diff --git a/.travis.yml b/.travis.yml
index f1137de6d3c50..e396552fa720e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,14 +1,48 @@
 language: cpp
-os:
-    - linux
-    - osx
-env:
-    - ARCH="i686"
-    - ARCH="x86_64"
+sudo: false
 matrix:
-  exclude:
-    - os: osx
+  include:
+    - os: linux
       env: ARCH="i686"
+      compiler: "g++-5 -m32"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - bar
+            - time
+            - binutils
+            - gcc-5
+            - g++-5
+            - gcc-5-multilib
+            - g++-5-multilib
+            - make:i386
+            - libssl-dev:i386
+            - gfortran-5
+            - gfortran-5-multilib
+    - os: linux
+      env: ARCH="x86_64"
+      compiler: "g++-5 -m64"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - bar
+            - time
+            - g++-5
+            - gfortran-5
+    - os: osx
+      env: ARCH="x86_64"
+cache:
+  directories:
+    - $TRAVIS_BUILD_DIR/deps/srccache
+    - $TRAVIS_BUILD_DIR/deps/build
+branches:
+  only:
+    - master
+    - /release-.*/
 notifications:
     email: false
     irc:
@@ -22,51 +56,59 @@ notifications:
           - http://julia.mit.edu:8000/travis-hook
 before_install:
     - make check-whitespace
+    - JULIA_SYSIMG_BUILD_FLAGS="--output-ji ../usr/lib/julia/sys.ji"
     - if [ `uname` = "Linux" ]; then
-        sudo apt-get install jq -y;
         contrib/travis_fastfail.sh || exit 1;
-        BUILDOPTS="-j3 USEGCC=1 LLVM_CONFIG=llvm-config-3.3 VERBOSE=1 USE_BLAS64=0 FORCE_ASSERTIONS=1 STAGE2_DEPS=utf8proc";
-        for lib in LLVM SUITESPARSE ARPACK BLAS FFTW LAPACK GMP MPFR LIBUNWIND OPENLIBM; do
-            export BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1";
-        done;
-        sudo add-apt-repository ppa:staticfloat/julia-deps -y;
-        sudo apt-get update -qq -y;
-        if [ "$ARCH" = "i686" ]; then
-          sudo apt-get remove libblas3gf liblapack3gf libarmadillo2 -y;
-          sudo apt-get install binutils:i386 -y;
-          sudo apt-get install gcc:i386 g++:i386 make:i386 cpp:i386 g++-4.6:i386 gcc-4.6:i386 libssl-dev:i386 patchelf:i386 gfortran:i386 llvm-3.3-dev:i386 libsuitesparse-dev:i386 libopenblas-dev:i386 libopenblas-base:i386 libblas-dev:i386 liblapack-dev:i386 liblapack3:i386 libarpack2-dev:i386 libarpack2:i386 libfftw3-dev:i386 libgmp-dev:i386 libpcre3-dev:i386 libunwind7-dev:i386 libopenlibm-dev:i386 libmpfr-dev:i386 -y;
-        else
-          sudo apt-get install patchelf gfortran llvm-3.3-dev libsuitesparse-dev libopenblas-dev liblapack-dev libarpack2-dev libfftw3-dev libgmp-dev libpcre3-dev libunwind7-dev libopenlibm-dev libmpfr-dev -y;
-        fi;
+        mkdir -p $HOME/bin;
+        ln -s /usr/bin/gcc-5 $HOME/bin/gcc;
+        ln -s /usr/bin/g++-5 $HOME/bin/g++;
+        ln -s /usr/bin/gfortran-5 $HOME/bin/gfortran;
+        ln -s /usr/bin/gcc-5 $HOME/bin/x86_64-linux-gnu-gcc;
+        ln -s /usr/bin/g++-5 $HOME/bin/x86_64-linux-gnu-g++;
+        gcc --version;
+        BUILDOPTS="-j3 VERBOSE=1 FORCE_ASSERTIONS=1";
+        echo "override ARCH=$ARCH" >> Make.user;
+        TESTSTORUN="all";
       elif [ `uname` = "Darwin" ]; then
-        brew tap staticfloat/julia;
-        brew rm --force $(brew deps --HEAD julia);
         brew update;
-        brew install -v jq;
+        brew install -v jq bar;
         contrib/travis_fastfail.sh || exit 1;
+        brew tap staticfloat/julia;
+        brew rm --force $(brew deps --HEAD julia);
         brew install -v --only-dependencies --HEAD julia;
-        BUILDOPTS="-j3 USECLANG=1 LLVM_CONFIG=$(brew --prefix llvm33-julia)/bin/llvm-config-3.3 VERBOSE=1 USE_BLAS64=0 SUITESPARSE_INC=-I$(brew --prefix suite-sparse-julia)/include FORCE_ASSERTIONS=1 STAGE2_DEPS=utf8proc";
+        BUILDOPTS="-j3 USECLANG=1 LLVM_CONFIG=$(brew --prefix llvm37-julia)/bin/llvm-config-3.7.1 LLVM_SIZE=$(brew --prefix llvm37-julia)/bin/llvm-size-3.7.1";
+        BUILDOPTS="$BUILDOPTS VERBOSE=1 USE_BLAS64=0 SUITESPARSE_INC=-I$(brew --prefix suite-sparse-julia)/include FORCE_ASSERTIONS=1 STAGE2_DEPS=utf8proc";
         BUILDOPTS="$BUILDOPTS LIBBLAS=-lopenblas LIBBLASNAME=libopenblas LIBLAPACK=-lopenblas LIBLAPACKNAME=libopenblas";
         for lib in LLVM SUITESPARSE ARPACK BLAS FFTW LAPACK GMP MPFR PCRE LIBUNWIND LIBGIT2; do
             export BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1";
         done;
+        export CXXFLAGS=-DUSE_ORCJIT;
         export LDFLAGS="-L$(brew --prefix openblas-julia)/lib -L$(brew --prefix suite-sparse-julia)/lib";
         export DYLD_FALLBACK_LIBRARY_PATH="/usr/local/lib:/lib:/usr/lib:$(brew --prefix openblas-julia)/lib:$(brew --prefix suite-sparse-julia)/lib:$(brew --prefix arpack-julia)/lib";
         make $BUILDOPTS -C contrib -f repackage_system_suitesparse4.make;
-      fi
+        JULIA_SYSIMG_BUILD_FLAGS="$JULIA_SYSIMG_BUILD_FLAGS --compile=all";
+        COMPILE_MODE="--compile=min";
+        TESTSTORUN="core ccall mmap llvmcall threads"; fi # TODO: turn this back to "all" once it's fast enough to not time out
+    - git clone -q git://git.kitenet.net/moreutils
 script:
+    - make -C moreutils mispipe
     - make $BUILDOPTS -C base version_git.jl.phony
-    - git clone -q git://git.kitenet.net/moreutils
-    - make $BUILDOPTS NO_GIT=1 JULIA_SYSIMG_BUILD_FLAGS="--output-ji ../usr/lib/julia/sys.ji" prefix=/tmp/julia install | moreutils/ts -s "%.s"
+    - moreutils/mispipe "make $BUILDOPTS NO_GIT=1 -C deps" bar > deps.log || cat deps.log
+    - make $BUILDOPTS NO_GIT=1 JULIA_SYSIMG_BUILD_FLAGS="$JULIA_SYSIMG_BUILD_FLAGS" prefix=/tmp/julia install | moreutils/ts -s "%.s"
+    - make $BUILDOPTS NO_GIT=1 build-stats
+    - du -sk /tmp/julia/*
     - if [ `uname` = "Darwin" ]; then
         for name in suitesparseconfig spqr umfpack colamd cholmod amd suitesparse_wrapper; do
             install -pm755 usr/lib/lib${name}*.dylib* /tmp/julia/lib/julia/;
         done;
       fi
     - cd .. && mv julia julia2
-    - cp /tmp/julia/lib/julia/sys.ji local.ji && /tmp/julia/bin/julia -J local.ji -e 'true' && /tmp/julia/bin/julia-debug -J local.ji -e 'true' && rm local.ji
+    - cp /tmp/julia/lib/julia/sys.ji local.ji && /tmp/julia/bin/julia -J local.ji -e 'true' &&
+        /tmp/julia/bin/julia-debug -J local.ji -e 'true' && rm local.ji
     - /tmp/julia/bin/julia -e 'versioninfo()'
-    - export JULIA_CPU_CORES=2 && cd /tmp/julia/share/julia/test && /tmp/julia/bin/julia --check-bounds=yes runtests.jl all && /tmp/julia/bin/julia --check-bounds=yes runtests.jl pkg
-    - cd - && mv julia2 julia
-    - sudo dmesg
-    - echo "Ready for packaging..."
+    - export JULIA_CPU_CORES=2 && export JULIA_TEST_MAXRSS_MB=600 && cd /tmp/julia/share/julia/test &&
+        /tmp/julia/bin/julia --check-bounds=yes $COMPILE_MODE runtests.jl $TESTSTORUN &&
+        /tmp/julia/bin/julia --check-bounds=yes $COMPILE_MODE runtests.jl libgit2-online pkg
+    - cd `dirname $TRAVIS_BUILD_DIR` && mv julia2 julia && rm -rf julia/deps/build/julia-env
+# uncomment the following if failures are suspected to be due to the out-of-memory killer
+#    - dmesg
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 75c03a5ec63f0..a2566628ba333 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,8 +1,20 @@
 # Notes for Julia Contributors
 
-Hi! Thanks for checking out Julia. If you have questions or problems, the [Julia dev list](https://groups.google.com/forum/?fromgroups#!forum/julia-dev) is a good place to post them, but you should check out the [online Julia docs](http://docs.Julialang.org/en/latest/) first. If you have changes you'd like to contribute, you'll need a [free GitHub account](https://github.com/signup/free). (If you're reading this on GitHub, you probably already have one.) You'll also want a working copy of Julia, built from source (you can still contribute with a binary install, but it's harder and not really recommended). In list form, here's what to do to become a contributor:
+Hi! If you are new to the Julia community: welcome, and thanks for trying Julia. Please be sure to respect our [community standards](http://julialang.org/community/standards/) in all interactions.
 
-* Join the [dev list](https://groups.google.com/forum/?fromgroups#!forum/julia-dev).
+## Learning Julia
+
+[The learning page](http://julialang.org/learning/) has a great list of resources for new and experienced users alike. [This tutorial video](https://www.youtube.com/watch?v=vWkgEddb4-A) is one recommended starting point, as is the "[Invitation to Julia](https://www.youtube.com/watch?v=gQ1y5NUD_RI)" workshop video from JuliaCon 2015  ([slide materials here](https://github.com/dpsanders/invitation_to_julia)). The [Julia documentation](http://docs.Julialang.org/en/latest/) covers the language and core library features, and is [searchable](http://docs.Julialang.org/en/latest/search/). (note: Javascript required).
+
+## Before filing an issue
+
+- Reporting a potential bug? Please read the "[How to file a bug report](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md#how-to-file-a-bug-report)" section to make sure that all necessary information is included.
+
+- Contributing code? Be sure to review the [contributor checklist](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md#contributor-checklist) for helpful tips on the tools we use to build Julia.
+
+- Library feature requests are generally not accepted on this issue tracker. New libraries should be developed as [packages](http://docs.julialang.org/en/release-0.4/manual/packages/#package-development). Please email the [julia-users](https://groups.google.com/forum/#!forum/julia-users) mailing list to discuss library ideas. Doing so will often lead to pointers to existing projects and bring together collaborators with common interests.
+
+## Contributor Checklist
 
 * Create a [GitHub account](https://github.com/signup/free).
 
@@ -10,13 +22,15 @@ Hi! Thanks for checking out Julia. If you have questions or problems, the [Julia
 
 * Build the software and libraries (the first time takes a while, but it's fast after that). Detailed build instructions are in the [README](https://github.com/JuliaLang/julia/tree/master/README.md). Julia depends on several external packages; most are automatically downloaded and installed, but are less frequently updated than Julia itself.
 
-* Keep Julia current. Julia is a fast-moving target, and many details of the language are still settling out. Keep your repository up-to-date and rebase your work in progress frequently.
+* Keep Julia current. Julia is a fast-moving target, and many details of the language are still settling out. Keep the repository up-to-date and rebase work-in-progress frequently to make merges simpler.
 
 * Learn to use [git](http://git-scm.com), the version control system used by GitHub and the Julia project. Try a tutorial such as the one [provided by GitHub](http://try.GitHub.io/levels/1/challenges/1).
 
-* Respect our [community standards](http://julialang.org/community/standards/).
+* Review discussions on the [dev mailing list](https://groups.google.com/forum/?fromgroups#!forum/julia-dev).
+
+* For more detailed tips, read the [submission guide](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md#submitting-contributions) below.
 
-* Relax and have fun.
+* Relax and have fun!
 
 ## How to file a bug report
 
@@ -34,11 +48,11 @@ A useful bug report filed as a GitHub issue provides information about how to re
 3. When filing a bug report, provide where possible:
   - The full error message, including the backtrace.
   - A minimal working example, i.e. the smallest chunk of code that triggers the error. Ideally, this should be code that can be pasted into a REPL or run from a source file. If the code is larger than (say) 50 lines, consider putting it in a [gist](https://gist.github.com).
-  - The version of Julia you are using as provided by the `versioninfo()` command. Occasionally, the longer output produced by `versioninfo(true)` may be useful also, especially if the issue is related to a specific package.
+  - The version of Julia as provided by the `versioninfo()` command. Occasionally, the longer output produced by `versioninfo(true)` may be useful also, especially if the issue is related to a specific package.
 
-4. When pasting code blocks or output, put triple backquotes (\`\`\`) around the text so GitHub will format it nicely. You can format code statements by surrounding it in single backquotes (\`). Be aware that the `@` sign tags users on GitHub, so references to macros should always be in single backquotes. See [GitHub's guide on Markdown](https://guides.github.com/features/mastering-markdown/) for more formatting tricks.
+4. When pasting code blocks or output, put triple backquotes (\`\`\`) around the text so GitHub will format it nicely. Code statements should be surrounded by single backquotes (\`). Be aware that the `@` sign tags users on GitHub, so references to macros should always be in single backquotes. See [GitHub's guide on Markdown](https://guides.github.com/features/mastering-markdown/) for more formatting tricks.
 
-## Submitting your contributions
+## Submitting contributions
 
 ### Contributing a Julia package
 
@@ -58,7 +72,7 @@ There are never enough tests. Track [code coverage at Coveralls](https://coveral
 
 4. Run `make test-all` to rebuild Julia and run your new test(s). If you had to fix a bug or add functionality in `base`, this will ensure that your test passes and that you have not introduced extraneous whitespace.
 
-5. Submit the test as a pull request.
+5. Submit the test as a pull request (PR).
 
 * Code for the buildbot configuration is maintained at: https://github.com/staticfloat/julia-buildbot
 * You can see the current buildbot setup at: http://buildbot.e.ip.saba.us:8010/builders
@@ -85,20 +99,23 @@ from Julia's root directory. Sometimes errors only show up in one of them, so if
 Existing docstrings now live primarily in `base/docs/helpdb.jl`.
 It is a goal over time to move the docstrings inline to their respective method definitions.
 If you want to edit the body of a method docstring, run the `doc/genstdlib.jl` script to regenerate the restructured text files **after** you have already rebuilt Julia.
+(From the top-level source directory, you can do this with `make julia-genstdlib`.)
 If you want to edit an existing docstring signature, you **first** have to change the signature in the `doc/stdlib` `..function` or `..data` definition (not the auto-generated content) and *then*
 edit the helpdb.jl or inline method docstrings.  The existing signatures in the `doc/stdlib/*.rst` files are pattern matched to base docstrings and the new content overwrites the content in `doc/stdlib/`.
 The signature definitions **must** be in sync or else the pattern match will fail and documentation will be lost in the result.
-To add entirely new methods to the `stdlib` documentation, first add the signature in the appropriate `rst/stdlib/*.rst` file before writing the docstring, rebuilding Julia, and re-running `doc/genstdlib.jl`.
+To add entirely new methods to the `stdlib` documentation, first add the signature in the appropriate `doc/stdlib/*.rst` file before writing the docstring, rebuilding Julia, and re-running `doc/genstdlib.jl`.
 
 It is encouraged to write all new docstrings in Markdown markup.  If you need to write a more complicated docstring that contains cross-references or citations it can be written in a restructured text codeblock.
 Many of the existing docstrings are currently restructured text codeblocks and these will be transitioned to Markdown over time.  RST codeblocks are delineated with the triple-quote (\`\`\`rst  \`\`\`) Makdown codeblock syntax.
 The content of the codeblock is spliced directly into the final restructured text document unmodified.
 
+For new functionality and other substantial changes, add a brief summary to `NEWS.md`. The news item should cross reference the pull request (PR) parenthetically, in the form `([#pr])`; after adding this, run `./julia doc/NEWS-update.jl` from the `julia` directory to update the cross-reference links. To add the PR reference number, first create the PR, then push an additional commit updating `NEWS.md` with the PR reference number.
+
 ### Contributing to core functionality or base libraries
 
 *By contributing code to Julia, you are agreeing to release it under the [MIT License](https://github.com/JuliaLang/julia/tree/master/LICENSE.md).*
 
-The Julia community uses [GitHub issues](https://github.com/JuliaLang/julia/issues) to track and discuss problems, feature requests, and pull requests. You can make pull requests for incomplete features to get code review. The convention is to prefix the pull request title with "WIP:" for Work In Progress, or "RFC:" for Request for Comments when work is completed and ready for merging. This will prevent accidental merging of work that is in progress.
+The Julia community uses [GitHub issues](https://github.com/JuliaLang/julia/issues) to track and discuss problems, feature requests, and pull requests (PR). You can make pull requests for incomplete features to get code review. The convention is to prefix the pull request title with "WIP:" for Work In Progress, or "RFC:" for Request for Comments when work is completed and ready for merging. This will prevent accidental merging of work that is in progress.
 
 Note: These instructions are for adding to or improving functionality in the base library. Before getting started, it can be helpful to discuss the proposed changes or additions on the mailing list or in a GitHub issue---it's possible your proposed change belongs in a package rather than the core language. Also, keep in mind that changing stuff in the base can potentially break a lot of things. Finally, because of the time required to build Julia, note that it's usually faster to develop your code in stand-alone files, get it working, and then migrate it into the base libraries.
 
@@ -135,6 +152,8 @@ Make sure that [Travis](http://www.travis-ci.org) greenlights the pull request w
  - try to adhere to a 92 character line length limit
  - use upper camel case convention for modules, type names
  - use lower case with underscores for method names
+ - it is generally preferred to use ASCII operators and identifiers over
+   Unicode equivalents whenever possible
 
 #### General Formatting Guidelines For C code contributions
 
@@ -162,10 +181,6 @@ Make sure that [Travis](http://www.travis-ci.org) greenlights the pull request w
    - To remove whitespace relative to the `master` branch, run
      `git rebase --whitespace=fix master`.
 
-## Getting help
-
-While getting familiar with Julia, remember to check out [the docs](http://docs.Julialang.org/en/latest/), keeping in mind that they are [searchable](http://docs.Julialang.org/en/latest/search/). (If you use a script blocker then you'll have to unblock that page.) The [source code](https://github.com/JuliaLang/julia) is an excellent source of examples (and it's mostly pretty approachable). If you're still stumped, post something on [the dev list](https://groups.google.com/forum/?fromgroups#!forum/julia-dev), but you may want to search the archives first to see if there's already been a discussion about what you're stuck on.
-
 ## Resources
 
 * Julia
diff --git a/LICENSE.md b/LICENSE.md
index d1b76975eeac8..1f00b208885a3 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -3,7 +3,7 @@ of the compiler (the contents of src/), most of the standard library (base/),
 and some utilities (most of the rest of the files in this repository). See below
 for exceptions.
 
-> Copyright (c) 2009-2015: Jeff Bezanson, Stefan Karpinski, Viral B. Shah,
+> Copyright (c) 2009-2016: Jeff Bezanson, Stefan Karpinski, Viral B. Shah,
 > and other contributors:
 >
 > https://github.com/JuliaLang/julia/contributors
@@ -29,8 +29,9 @@ for exceptions.
 
 Julia includes code from the following projects, which have their own licenses:
 - [LDC](https://github.com/ldc-developers/ldc/blob/master/LICENSE) (for ccall/cfunction ABI definitions) [BSD-3]. The portion of code that Julia uses from LDC is [BSD-3] licensed.
+- [LLVM](http://llvm.org/releases/3.7.0/LICENSE.TXT) (for parts of src/jitlayers.cpp and src/disasm.cpp) [BSD-3, effectively]
 - [MUSL](http://git.musl-libc.org/cgit/musl/tree/COPYRIGHT) (for getopt implementations on Windows) [MIT]
-- [NetBSD](http://www.netbsd.org/about/redistribution.html) (for setjmp/longjmp implementations on Windows) [BSD-3]
+- [NetBSD](http://www.netbsd.org/about/redistribution.html) (for setjmp, longjmp, and strptime implementations on Windows) [BSD-3]
 
 The Julia language links to the following external libraries, which have their
 own licenses:
@@ -38,7 +39,7 @@ own licenses:
 - [FEMTOLISP](https://github.com/JeffBezanson/femtolisp) [BSD-3]
 - [LIBUNWIND](http://git.savannah.gnu.org/gitweb/?p=libunwind.git;a=blob_plain;f=LICENSE;hb=master) [MIT]
 - [LIBUV](https://github.com/joyent/libuv/blob/master/LICENSE) [MIT]
-- [LLVM](http://llvm.org/releases/3.3/LICENSE.TXT) [BSD-3, effectively]
+- [LLVM](http://llvm.org/releases/3.7.0/LICENSE.TXT) [BSD-3, effectively]
 - [UTF8PROC](https://github.com/JuliaLang/libmojibake) [MIT]
 
 
@@ -83,7 +84,9 @@ Julia's build process uses the following external tools:
 Julia bundles the following external programs and libraries on some platforms:
 
 - [7-Zip](http://www.7-zip.org/license.txt)
-- [BUSYBOX](https://github.com/rmyorston/busybox-w32/blob/master/LICENSE)
 - [GIT](http://git-scm.com/about/free-and-open-source)
 - [ZLIB](http://zlib.net/zlib_license.html)
 - [LIBEXPAT](http://expat.cvs.sourceforge.net/viewvc/expat/expat/README)
+- [OPENSSL](https://github.com/openssl/openssl/blob/master/LICENSE)
+
+On some platforms, distributions of Julia contain SSL certificate authority certificates, released under the [Mozilla Public License](https://en.wikipedia.org/wiki/Mozilla_Public_License).
diff --git a/Make.inc b/Make.inc
index 4b4a4cf4b365a..6d8ca1580a49f 100644
--- a/Make.inc
+++ b/Make.inc
@@ -2,43 +2,45 @@
 
 ## Note:
 ##   It is generally preferable to change these options, for
-##   your local machine, in a file named `Make.user` in this directory
+##   your local machine, in a file named `Make.user` in the toplevel
+##   and build directories
 
 # OPENBLAS build options
-OPENBLAS_TARGET_ARCH=
-OPENBLAS_SYMBOLSUFFIX=
+OPENBLAS_TARGET_ARCH:=
+OPENBLAS_SYMBOLSUFFIX:=
+OPENBLAS_LIBNAMESUFFIX:=
 
 # If OPENBLAS_TARGET_ARCH is set, we default to disabling OPENBLAS_DYNAMIC_ARCH
 ifneq ($(OPENBLAS_TARGET_ARCH),)
-OPENBLAS_DYNAMIC_ARCH=0
+OPENBLAS_DYNAMIC_ARCH:=0
 else
-OPENBLAS_DYNAMIC_ARCH=1
+OPENBLAS_DYNAMIC_ARCH:=1
 endif
-OPENBLAS_USE_THREAD=1
+OPENBLAS_USE_THREAD:=1
 
 # Use libraries available on the system instead of building them
-USE_SYSTEM_LLVM=0
-USE_SYSTEM_LIBUNWIND=0
-USE_SYSTEM_PCRE=0
-USE_SYSTEM_LIBM=0
-USE_SYSTEM_OPENLIBM=0
-UNTRUSTED_SYSTEM_LIBM=0
-USE_SYSTEM_OPENSPECFUN=0
-USE_SYSTEM_DSFMT=0
-USE_SYSTEM_BLAS=0
-USE_SYSTEM_LAPACK=0
-USE_SYSTEM_FFTW=0
-USE_SYSTEM_GMP=0
-USE_SYSTEM_MPFR=0
-USE_SYSTEM_ARPACK=0
-USE_SYSTEM_SUITESPARSE=0
-USE_SYSTEM_LIBUV=0
-USE_SYSTEM_UTF8PROC=0
-USE_SYSTEM_LIBGIT2=0
-USE_SYSTEM_PATCHELF=0
+USE_SYSTEM_LLVM:=0
+USE_SYSTEM_LIBUNWIND:=0
+USE_SYSTEM_PCRE:=0
+USE_SYSTEM_LIBM:=0
+USE_SYSTEM_OPENLIBM:=0
+UNTRUSTED_SYSTEM_LIBM:=0
+USE_SYSTEM_OPENSPECFUN:=0
+USE_SYSTEM_DSFMT:=0
+USE_SYSTEM_BLAS:=0
+USE_SYSTEM_LAPACK:=0
+USE_SYSTEM_FFTW:=0
+USE_SYSTEM_GMP:=0
+USE_SYSTEM_MPFR:=0
+USE_SYSTEM_ARPACK:=0
+USE_SYSTEM_SUITESPARSE:=0
+USE_SYSTEM_LIBUV:=0
+USE_SYSTEM_UTF8PROC:=0
+USE_SYSTEM_LIBGIT2:=0
+USE_SYSTEM_PATCHELF:=0
 
 # Link to the LLVM shared library
-USE_LLVM_SHLIB = 0
+USE_LLVM_SHLIB := 0
 
 ## Settings for various Intel tools
 # Set to 1 to use MKL
@@ -55,42 +57,79 @@ USEIFC  ?= 0
 
 ifeq ($(USE_MKL), 1)
 $(warning "The julia make variable USE_MKL has been renamed to USE_INTEL_MKL")
-USE_INTEL_MKL = 1
+USE_INTEL_MKL := 1
 endif
 
+# Set to 1 to enable profiling with OProfile
+USE_OPROFILE_JITEVENTS ?= 0
+
 # libc++ is standard on OS X 10.9, but not for earlier releases
-USE_LIBCPP = 0
+USE_LIBCPP := 0
 
 # assume we don't have LIBSSP support in our compiler, will enable later if likely true
-HAVE_SSP = 0
+HAVE_SSP := 0
 
 # GC debugging options
-WITH_GC_VERIFY = 0
-WITH_GC_DEBUG_ENV = 0
+WITH_GC_VERIFY := 0
+WITH_GC_DEBUG_ENV := 0
 
 # Prevent picking up $ARCH from the environment variables
-ARCH=
+ARCH:=
+
+# pick up BUILDROOT from O= if it isn't already set (from recursive make)
+ifeq ($(BUILDROOT),)
+ifeq ("$(origin O)", "command line")
+  BUILDROOT := $(abspath $O)
+  BUILDDIR := $(abspath $(BUILDROOT)/$(shell $(JULIAHOME)/contrib/relative_path.sh $(JULIAHOME) $(SRCDIR)))
+  $(info $(shell printf '\033[32;1mBuilding into $(BUILDROOT)\033[0m')) # use printf to expand the escape sequences
+else
+  BUILDROOT:=$(JULIAHOME)
+endif
+endif
+export BUILDROOT
+unexport O
+
+# Make sure the user didn't try to specify a path that will confuse the shell / make
+METACHARACTERS := ][?*{}() $$%:;&|!\#,\\`\":
+ifneq (,$(findstring ',$(value BUILDROOT)))
+$(error cowardly refusing to build into directory with a single-quote in the path)
+endif
+ifneq (,$(findstring ',$(value JULIAHOME)))
+$(error cowardly refusing to build from source directory with a single-quote in the path)
+endif
+ifneq (,$(shell echo '$(value BUILDROOT)' | grep '[$(METACHARACTERS)]'))
+$(error cowardly refusing to build into directory with a shell-metacharacter in the path\
+    (got: $(value BUILDROOT)))
+endif
+ifneq (,$(shell echo '$(value JULIAHOME)' | grep '[$(METACHARACTERS)]'))
+$(error cowardly refusing to build from source directory with a shell-metacharacter in the path\
+    (got: $(value JULIAHOME)))
+endif
 
 # we include twice to pickup user definitions better
+# include from JULIAHOME first so that BUILDROOT can override
 ifeq (exists, $(shell [ -e $(JULIAHOME)/Make.user ] && echo exists ))
 include $(JULIAHOME)/Make.user
 endif
+ifeq (exists, $(shell [ -e $(BUILDROOT)/Make.user ] && echo exists ))
+include $(BUILDROOT)/Make.user
+endif
 
 # disable automatic Makefile rules
 .SUFFIXES:
 
 # find out if git repository is available
 ifeq ($(shell [ -e $(JULIAHOME)/.git ] && echo true || echo "Warning: git information unavailable; versioning information limited" >&2), true)
-NO_GIT = 0
+NO_GIT := 0
 else
-NO_GIT = 1
+NO_GIT := 1
 endif
 
-JULIA_VERSION = $(shell cat $(JULIAHOME)/VERSION)
+JULIA_VERSION := $(shell cat $(JULIAHOME)/VERSION)
 ifneq ($(NO_GIT), 1)
-JULIA_COMMIT = $(shell git rev-parse --short=10 HEAD)
+JULIA_COMMIT := $(shell git rev-parse --short=10 HEAD)
 else
-JULIA_COMMIT = $(JULIA_VERSION)
+JULIA_COMMIT := $(JULIA_VERSION)
 endif
 
 # Whether to use GPL libraries or not.
@@ -98,67 +137,70 @@ USE_GPL_LIBS ?= 1
 
 # Directories where said libraries get installed to
 prefix ?= $(abspath julia-$(JULIA_COMMIT))
-bindir = $(prefix)/bin
-libdir = $(prefix)/lib
-private_libdir = $(libdir)/julia
-libexecdir = $(prefix)/libexec
-datarootdir = $(prefix)/share
-docdir = $(datarootdir)/doc/julia
-mandir = $(datarootdir)/man
-man1dir = $(mandir)/man1
-includedir = $(prefix)/include
-sysconfdir = $(prefix)/etc
+bindir := $(prefix)/bin
+libdir := $(prefix)/lib
+libexecdir := $(prefix)/libexec
+datarootdir := $(prefix)/share
+docdir := $(datarootdir)/doc/julia
+mandir := $(datarootdir)/man
+man1dir := $(mandir)/man1
+includedir := $(prefix)/include
+sysconfdir := $(prefix)/etc
 
 # Directories where things get built into
-build_prefix = $(JULIAHOME)/usr
-build_staging = $(build_prefix)-staging
-build_bindir = $(build_prefix)/bin
-build_libdir = $(build_prefix)/lib
-build_private_libdir = $(build_prefix)/lib/julia
-build_libexecdir = $(build_prefix)/libexec
-build_datarootdir = $(build_prefix)/share
-build_docdir = $(build_datarootdir)/doc/julia
-build_mandir = $(build_datarootdir)/man
-build_man1dir = $(build_mandir)/man1
-build_includedir = $(build_prefix)/include
-build_sysconfdir = $(build_prefix)/etc
-
-
-# Calculate relative paths to libdir, private_libdir, datarootdir, and sysconfdir
-build_libdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(build_bindir) $(build_libdir))
-libdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(libdir))
-build_private_libdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(build_bindir) $(build_private_libdir))
-private_libdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(private_libdir))
-datarootdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(datarootdir))
-docdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(docdir))
-sysconfdir_rel = $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(sysconfdir))
-
-INSTALL_F = $(JULIAHOME)/contrib/install.sh 644
-INSTALL_M = $(JULIAHOME)/contrib/install.sh 755
+build_prefix := $(BUILDROOT)/usr
+build_staging := $(build_prefix)-staging
+build_bindir := $(build_prefix)/bin
+build_libdir := $(build_prefix)/lib
+build_libexecdir := $(build_prefix)/libexec
+build_datarootdir := $(build_prefix)/share
+build_docdir := $(build_datarootdir)/doc/julia
+build_mandir := $(build_datarootdir)/man
+build_man1dir := $(build_mandir)/man1
+build_includedir := $(build_prefix)/include
+build_sysconfdir := $(build_prefix)/etc
 
 # This used for debian packaging, to conform to library layout guidelines
 ifeq ($(MULTIARCH_INSTALL), 1)
-MULTIARCH = $(shell gcc -print-multiarch)
-private_libdir = $(prefix)/lib/$(MULTIARCH)/julia
-libdir = $(prefix)/lib/$(MULTIARCH)/
+MULTIARCH := $(shell gcc -print-multiarch)
+libdir := $(prefix)/lib/$(MULTIARCH)
+build_libdir := $(build_prefix)/lib/$(MULTIARCH)
 endif
 
+# Private library directories
+private_libdir := $(libdir)/julia
+build_private_libdir := $(build_libdir)/julia
+
+# Calculate relative paths to libdir, private_libdir, datarootdir, and sysconfdir
+build_libdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(build_bindir) $(build_libdir))
+libdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(libdir))
+build_private_libdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(build_bindir) $(build_private_libdir))
+private_libdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(private_libdir))
+datarootdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(datarootdir))
+docdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(docdir))
+sysconfdir_rel := $(shell $(JULIAHOME)/contrib/relative_path.sh $(bindir) $(sysconfdir))
+
+INSTALL_F := $(JULIAHOME)/contrib/install.sh 644
+INSTALL_M := $(JULIAHOME)/contrib/install.sh 755
+
 # LLVM Options
-LLVMROOT = $(build_prefix)
-LLVM_ASSERTIONS = 0
-LLVM_DEBUG = 0
+LLVMROOT := $(build_prefix)
+LLVM_ASSERTIONS := 0
+LLVM_DEBUG := 0
+#LLVM_USE_CMAKE: defined in deps/Makefile as it depends on LLVM_VER_SHORT
 # set to 1 to get clang and compiler-rt
-BUILD_LLVM_CLANG = 0
+BUILD_LLVM_CLANG := 0
 # set to 1 to get lldb (often does not work, no chance with llvm3.2 and earlier)
 # see http://lldb.llvm.org/build.html for dependencies
-BUILD_LLDB = 0
+BUILD_LLDB := 0
 
 # Cross-compile
-#XC_HOST = i686-w64-mingw32
-#XC_HOST = x86_64-w64-mingw32
+#XC_HOST := i686-w64-mingw32
+#XC_HOST := x86_64-w64-mingw32
 
 # Path to cmake (override in Make.user if needed)
 CMAKE ?= cmake
+CMAKE_GENERATOR ?= make
 
 # Point pkg-config to only look at our libraries
 export PKG_CONFIG_LIBDIR = $(JULIAHOME)/usr/lib/pkgconfig
@@ -171,28 +213,28 @@ XC_HOST ?= $(shell uname -m)-w64-mingw32
 endif
 
 ifeq ($(XC_HOST),)
-CROSS_COMPILE=
+CROSS_COMPILE:=
+# delayed expansion of $(CC), since it won't be computed until later
 HOSTCC = $(CC)
 else
-HOSTCC = gcc
-override OPENBLAS_DYNAMIC_ARCH = 1
-override CROSS_COMPILE=$(XC_HOST)-
+HOSTCC := gcc
+override OPENBLAS_DYNAMIC_ARCH := 1
+override CROSS_COMPILE:=$(XC_HOST)-
 ifneq (,$(findstring mingw,$(XC_HOST)))
 override OS := WINNT
-ifneq (,$(findstring CYGWIN,$(BUILD_OS)))
-export STD_LIB_PATH := $(shell $(CROSS_COMPILE)gcc -print-search-dirs | grep programs | sed -e "s/^programs: =//" -e "s!/lib/!/bin/!g")
-export STD_LIB_PATH := $(STD_LIB_PATH):$(shell $(CROSS_COMPILE)gcc -print-search-dirs | grep libraries | sed -e "s/^libraries: =//" -e "s!/lib/!/bin/!g")
-else
-export STD_LIB_PATH := $(shell $(CROSS_COMPILE)gcc -print-search-dirs | grep programs | sed "s/^programs: =//" | xargs -d":" winepath -w | tr '\n' ';')
-export STD_LIB_PATH := $(STD_LIB_PATH);$(shell $(CROSS_COMPILE)gcc -print-search-dirs | grep libraries | sed "s/^libraries: =//" | xargs -d":" winepath -w | tr '\n' ';')
+STD_LIB_PATH := $(shell $(CROSS_COMPILE)gcc -print-search-dirs | grep programs | sed -e "s/^programs: =//")
+STD_LIB_PATH := $(STD_LIB_PATH):$(shell $(CROSS_COMPILE)gcc -print-search-dirs | grep libraries | sed -e "s/^libraries: =//")
+ifneq (,$(findstring CYGWIN,$(BUILD_OS))) # the cygwin-mingw32 compiler lies about it search directory paths
+STD_LIB_PATH := $(shell echo '$(STD_LIB_PATH)' | sed -e "s!/lib/!/bin/!g")
 endif
 else
 $(error "unknown XC_HOST variable set")
 endif
 endif
+STD_LIB_PATH ?= $(PATH)
 
-JLDOWNLOAD = $(JULIAHOME)/deps/jldownload
-JLCHECKSUM = $(JULIAHOME)/deps/jlchecksum
+JLDOWNLOAD := $(JULIAHOME)/deps/jldownload
+JLCHECKSUM := $(JULIAHOME)/deps/jlchecksum
 
 # Figure out OS and architecture
 OS := $(BUILD_OS)
@@ -210,75 +252,79 @@ ifneq (,$(findstring MSYS,$(BUILD_OS)))
 override BUILD_OS := WINNT
 endif
 
-ifeq ($(OS), WINNT)
-fPIC =
 ifeq ($(BUILD_OS), WINNT)
-PATH := $(PATH):$(build_libdir):$(build_private_libdir):/c/Program Files/7-zip
+BUILD_EXE := .exe
+else ifneq (,$(findstring CYGWIN,$(BUILD_OS)))
+BUILD_EXE := .exe
+else
+BUILD_EXE :=
 endif
-EXE = .exe
+ifeq ($(OS), WINNT)
+fPIC :=
+EXE := .exe
 else
-fPIC = -fPIC
-EXE =
+fPIC := -fPIC
+EXE :=
 endif
 
-JULIAGC = MARKSWEEP
-USE_COPY_STACKS = 1
+JULIAGC := MARKSWEEP
+JULIACODEGEN := LLVM
 
 # flag for disabling assertions
 ifeq ($(FORCE_ASSERTIONS), 1)
-DISABLE_ASSERTIONS =
+DISABLE_ASSERTIONS :=
 else
-DISABLE_ASSERTIONS = -DNDEBUG
+DISABLE_ASSERTIONS := -DNDEBUG
 endif
 
 # Compiler specific stuff
 
 ifeq ($(USEMSVC), 1)
-USEGCC = 0
-USECLANG = 0
-USEICC = 0
+USEGCC := 0
+USECLANG := 0
+USEICC := 0
 else
 ifeq ($(USECLANG), 1)
-USEGCC = 0
-USEICC = 0
+USEGCC := 0
+USEICC := 0
 else
 ifeq ($(USEICC), 1)
-USEGCC = 0
-USECLANG = 0
+USEGCC := 0
+USECLANG := 0
 else  # default to gcc
-USEGCC = 1
-USECLANG = 0
-USEICC = 0
+USEGCC := 1
+USECLANG := 0
+USEICC := 0
 endif
 endif
 endif
 
 ifeq ($(USEIFC), 1)
-FC = ifort
+FC := ifort
 else
-FC = $(CROSS_COMPILE)gfortran
+FC := $(CROSS_COMPILE)gfortran
 endif
 
-STDLIBCPP_FLAG =
+STDLIBCPP_FLAG :=
 
 ifeq ($(OS), Darwin)
 DARWINVER := $(shell uname -r | cut -b 1-2)
 DARWINVER_GTE13 := $(shell expr `uname -r | cut -b 1-2` \>= 13)
 ifeq ($(DARWINVER), 10) # Snow Leopard specific configuration
-USEGCC = 1
-USECLANG = 0
-OPENBLAS_TARGET_ARCH=NEHALEM
-OPENBLAS_DYNAMIC_ARCH=0
-USE_SYSTEM_LIBUNWIND=1
+USEGCC := 1
+USECLANG := 0
+OPENBLAS_TARGET_ARCH:=NEHALEM
+OPENBLAS_DYNAMIC_ARCH:=0
+USE_SYSTEM_LIBUNWIND:=1
 else
 ifeq ($(DARWINVER_GTE13),1)
-USE_LIBCPP = 1
-STDLIBCPP_FLAG = -stdlib=libstdc++
+USE_LIBCPP := 1
+STDLIBCPP_FLAG := -stdlib=libstdc++
 else
-USE_LIBCPP = 0
+USE_LIBCPP := 0
 endif
-USEGCC = 0
-USECLANG = 1
+USEGCC := 0
+USECLANG := 1
 endif
 endif
 
@@ -289,23 +335,29 @@ endif
 ifeq ($(SANITIZE),1)
 $(error Address Sanitizer only supported with clang. Try setting SANITIZE=0)
 endif
-CC = $(CROSS_COMPILE)gcc
-CXX = $(CROSS_COMPILE)g++
-JCFLAGS = -std=gnu99 -pipe $(fPIC) -fno-strict-aliasing -D_FILE_OFFSET_BITS=64
-JCPPFLAGS =
-JCXXFLAGS = -pipe $(fPIC) -fno-rtti
-DEBUGFLAGS = -O0 -ggdb3 -DJL_DEBUG_BUILD -fstack-protector-all
-SHIPFLAGS = -O3 -ggdb3 -falign-functions
+CC := $(CROSS_COMPILE)gcc
+CXX := $(CROSS_COMPILE)g++
+JCFLAGS := -std=gnu99 -pipe $(fPIC) -fno-strict-aliasing -D_FILE_OFFSET_BITS=64
+# AArch64 needs this flag to generate the .eh_frame used by libunwind
+JCPPFLAGS := -fasynchronous-unwind-tables
+JCXXFLAGS := -pipe $(fPIC) -fno-rtti
+ifneq ($(OS), WINNT)
+# Do no enable on windows to avoid warnings from libuv.
+JCXXFLAGS += -pedantic
+endif
+DEBUGFLAGS := -O0 -ggdb2 -DJL_DEBUG_BUILD -fstack-protector-all
+SHIPFLAGS := -O3 -ggdb2 -falign-functions
 endif
 
 ifeq ($(USECLANG),1)
-CC = $(CROSS_COMPILE)clang
-CXX = $(CROSS_COMPILE)clang++
-JCFLAGS = -pipe $(fPIC) -fno-strict-aliasing -D_FILE_OFFSET_BITS=64
-JCPPFLAGS =
-JCXXFLAGS = -pipe $(fPIC) -fno-rtti
-DEBUGFLAGS = -O0 -g -DJL_DEBUG_BUILD -fstack-protector-all
-SHIPFLAGS = -O3 -g
+CC := $(CROSS_COMPILE)clang
+CXX := $(CROSS_COMPILE)clang++
+JCFLAGS := -pipe $(fPIC) -fno-strict-aliasing -D_FILE_OFFSET_BITS=64
+# AArch64 needs this flag to generate the .eh_frame used by libunwind
+JCPPFLAGS := -fasynchronous-unwind-tables
+JCXXFLAGS := -pipe $(fPIC) -fno-rtti -pedantic
+DEBUGFLAGS := -O0 -g -DJL_DEBUG_BUILD -fstack-protector-all
+SHIPFLAGS := -O3 -g
 ifeq ($(OS), Darwin)
 ifeq ($(USE_LIBCPP), 1)
 CC += -stdlib=libc++ -mmacosx-version-min=10.7
@@ -326,13 +378,13 @@ endif
 ifeq ($(SANITIZE),1)
 $(error Address Sanitizer only supported with clang. Try setting SANITIZE=0)
 endif
-CC  = icc
-CXX = icpc
-JCFLAGS = -std=gnu11 -pipe $(fPIC) -fno-strict-aliasing -D_FILE_OFFSET_BITS=64 -fp-model precise -fp-model except -no-ftz
-JCPPFLAGS =
-JCXXFLAGS = -pipe $(fPIC) -fno-rtti
-DEBUGFLAGS = -O0 -g -DJL_DEBUG_BUILD -fstack-protector-all
-SHIPFLAGS = -O3 -g -falign-functions
+CC  := icc
+CXX := icpc
+JCFLAGS := -std=gnu11 -pipe $(fPIC) -fno-strict-aliasing -D_FILE_OFFSET_BITS=64 -fp-model precise -fp-model except -no-ftz
+JCPPFLAGS :=
+JCXXFLAGS := -pipe $(fPIC) -fno-rtti
+DEBUGFLAGS := -O0 -g -DJL_DEBUG_BUILD -fstack-protector-all
+SHIPFLAGS := -O3 -g -falign-functions
 endif
 
 ifeq ($(USECCACHE), 1)
@@ -341,35 +393,31 @@ CC_ARG   := $(CC)         # Expand CC and CXX here already because we want
 CXX_ARG  := $(CXX)        # the original definition and not the ccache version.
 CC_FULL  := ccache $(CC)  # Expand CC and CXX here already to avoid recursive
 CXX_FULL := ccache $(CXX) # referencing.
-CC        = $(CC_FULL)    # Add an extra indirection to make CC/CXX non-simple
-CXX       = $(CXX_FULL)   # vars (because of how -m$(BINARY) is added later on).
-CC_BASE   = ccache
-CXX_BASE  = ccache
+CC       := $(CC_FULL)    # Add an extra indirection to make CC/CXX non-simple
+CXX      := $(CXX_FULL)   # vars (because of how -m$(BINARY) is added later on).
+CC_BASE  := ccache
+CXX_BASE := ccache
 ifeq ($(USECLANG),1)
 # ccache and Clang don't do well together
 # http://petereisentraut.blogspot.be/2011/05/ccache-and-clang.html
-CC += -Qunused-arguments -fcolor-diagnostics
-CXX += -Qunused-arguments -fcolor-diagnostics
+CC += -Qunused-arguments
+CXX += -Qunused-arguments
 # http://petereisentraut.blogspot.be/2011/09/ccache-and-clang-part-2.html
 export CCACHE_CPP2 := yes
 endif
 else #USECCACHE
-CC_BASE = $(shell echo $(CC) | cut -d' ' -f1)
-CXX_BASE = $(shell echo $(CXX) | cut -d' ' -f1)
-endif
-
-ifeq ($(LLVM_VER),svn)
-JCXXFLAGS += -std=c++11
+CC_BASE := $(shell echo $(CC) | cut -d' ' -f1)
+CXX_BASE := $(shell echo $(CXX) | cut -d' ' -f1)
 endif
 
-JFFLAGS = -O2 $(fPIC)
+JFFLAGS := -O2 $(fPIC)
 ifneq ($(USEMSVC),1)
-CPP = $(CC) -E
+CPP := $(CC) -E
 AR := $(CROSS_COMPILE)ar
 AS := $(CROSS_COMPILE)as
 LD := $(CROSS_COMPILE)ld
 else #USEMSVC
-CPP = $(CC) -EP
+CPP := $(CC) -EP
 AR := lib
 ifeq ($(ARCH),x86_64)
 AS := ml64
@@ -382,35 +430,43 @@ RANLIB := $(CROSS_COMPILE)ranlib
 
 # file extensions
 ifeq ($(OS), WINNT)
-  SHLIB_EXT = dll
+  SHLIB_EXT := dll
 else ifeq ($(OS), Darwin)
-  SHLIB_EXT = dylib
+  SHLIB_EXT := dylib
 else
-  SHLIB_EXT = so
+  SHLIB_EXT := so
 endif
 
 # On Windows, we want shared library files to end up in $(build_bindir), instead of $(build_libdir)
 ifeq ($(OS),WINNT)
-build_shlibdir = $(build_bindir)
+build_shlibdir := $(build_bindir)
 else
-build_shlibdir = $(build_libdir)
+build_shlibdir := $(build_libdir)
 endif
 
 ifeq (exists, $(shell [ -e $(JULIAHOME)/Make.user ] && echo exists ))
 include $(JULIAHOME)/Make.user
 endif
+ifeq (exists, $(shell [ -e $(BUILDROOT)/Make.user ] && echo exists ))
+include $(BUILDROOT)/Make.user
+endif
 
 ifeq ($(SANITIZE),1)
 ifeq ($(SANITIZE_MEMORY),1)
-SANITIZE_OPTS = -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer
+SANITIZE_OPTS := -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer
+SANITIZE_LDFLAGS := $(SANITIZE_OPTS)
 else
-SANITIZE_OPTS = -fsanitize=address -mllvm -asan-stack=0
+SANITIZE_OPTS := -fsanitize=address -mllvm -asan-stack=0
+SANITIZE_LDFLAGS := -fsanitize=address
 endif
 JCXXFLAGS += $(SANITIZE_OPTS)
 JCFLAGS += $(SANITIZE_OPTS)
-LDFLAGS += $(SANITIZE_OPTS)
-DEPS_CFLAGS += $(SANITIZE_OPTS)
-DEPS_CXXFLAGS += $(SANITIZE_OPTS)
+LDFLAGS += $(SANITIZE_LDFLAGS)
+# FIXME: sanitizing all dependencies doesn't work because of -Wl,--no-undefined
+#        https://github.com/JuliaLang/julia/issues/13858
+#        use LLVM_SANITIZE to sanitize LLVM
+#DEPS_CFLAGS += $(SANITIZE_OPTS)
+#DEPS_CXXFLAGS += $(SANITIZE_OPTS)
 endif
 
 TAR=`which gtar 2>/dev/null || which tar 2>/dev/null`
@@ -441,9 +497,24 @@ endif
 #    if MARCH is set newer than the native processor, be forewarned that the compile might fail
 # JULIA_CPU_TARGET is the JIT-only complement to MARCH. Setting it explicitly is not generally necessary,
 #    since it is set equal to MARCH by default
+
 BUILD_MACHINE := $(shell $(HOSTCC) -dumpmachine)
+
+# Clang spells mingw `-windows-gnu`, but autotools, etc
+# don't recognize that, so canonicalize to mingw32
+BUILD_MACHINE := $(subst windows-gnu,mingw32,$(BUILD_MACHINE))
+
 ifeq ($(ARCH),)
 override ARCH := $(shell $(CC) -dumpmachine | sed "s/\([^-]*\).*$$/\1/")
+else
+ifneq ($(XC_HOST),)
+XC_HOST := $(ARCH)$(shell echo $(XC_HOST) | sed "s/[^-]*\(.*\)$$/\1/")
+MARCH := $(subst _,-,$(ARCH))
+else # insert ARCH into HOST
+XC_HOST := $(ARCH)$(shell echo $(BUILD_MACHINE) | sed "s/[^-]*\(.*\)$$/\1/")
+endif
+endif
+
 ifeq ($(ARCH),mingw32)
 $(error "the mingw32 compiler you are using fails the openblas testsuite. please see the README.windows document for a replacement")
 else ifeq (cygwin, $(shell $(CC) -dumpmachine | cut -d\- -f3))
@@ -451,24 +522,37 @@ $(error "cannot build julia with cygwin-target compilers. set XC_HOST to i686-w6
 else ifeq (msys, $(shell $(CC) -dumpmachine | cut -d\- -f3))
 $(error "cannot build julia with msys-target compilers. please see the README.windows document for instructions on setting up mingw-w64 compilers")
 endif
+
 ifeq ($(BUILD_OS),Darwin)
-## Mac is a rather amazing 64-bit user-space on 32-bit kernel architecture, so to determine arch we detect
+## Mac is a rather cool 64-bit user-space on 32-bit kernel architecture, so to determine arch we detect
 ## the capabilities of the hardware, rather than the compiler or kernel, and make a substitution
-ifeq ($(ARCH),x86_64)
-override ARCH = i686
-else ifeq ($(ARCH),i386)
-override ARCH = i686
+BUILD_ARCH := $(shell echo $(BUILD_MACHINE) | sed "s/\([^-]*\).*$$/\1/")
+ifeq ($(BUILD_ARCH),x86_64)
+BUILD_ARCH := i686
+else ifeq ($(BUILD_ARCH),i386)
+BUILD_ARCH := i686
 endif
-ifeq ($(ARCH),i686)
+ifeq ($(BUILD_ARCH),i686)
 ifeq ($(shell sysctl -n hw.cpu64bit_capable),1)
-override ARCH = x86_64
+BUILD_ARCH := x86_64
 endif
-BUILD_MACHINE := $(ARCH)$(shell echo $(BUILD_MACHINE) | sed "s/[^-]*\(.*\)$$/\1/")
+BUILD_MACHINE := $(BUILD_ARCH)$(shell echo $(BUILD_MACHINE) | sed "s/[^-]*\(.*\)$$/\1/")
 endif
+ifeq ($(BUILD_OS),$(OS))
+ARCH := $(BUILD_OS)
+endif
+endif
+
+# Detect common pre-SSE2 JULIA_CPU_TARGET values known not to work (#7185)
+ifeq ($(MARCH),)
+ifneq ($(findstring $(ARCH),i386 i486 i586 i686),)
+MARCH := pentium4
 endif
-else
-XC_HOST := $(ARCH)$(shell echo $(BUILD_MACHINE) | sed "s/[^-]*\(.*\)$$/\1/")
-MARCH = $(ARCH)
+endif
+
+ifneq ($(findstring $(MARCH),i386 i486 i586 i686 pentium pentium2 pentium3),)
+$(error Pre-SSE2 CPU targets not supported. To create a generic 32-bit x86 binary, \
+pass 'MARCH=pentium4'.)
 endif
 
 ifneq ($(MARCH),)
@@ -494,43 +578,32 @@ endif
 
 JULIA_CPU_TARGET ?= native
 
-# Detect common pre-SSE2 JULIA_CPU_TARGET values known not to work (#7185)
-ifneq ($(findstring $(JULIA_CPU_TARGET),i386 i486 i586 i686 pentium pentium2 pentium3),)
-$(error Pre-SSE2 CPU targets not supported. To create a generic 32-bit x86 binary, \
-pass 'MARCH=i686 JULIA_CPU_TARGET=pentium4', or 'MARCH=pentium4' if not building any dependencies.)
-endif
-
 # We map amd64 to x86_64 for compatibility with systems that identify 64-bit systems as such
 ifeq ($(ARCH),amd64)
-override ARCH = x86_64
+override ARCH := x86_64
 endif
 
 ifeq ($(ARCH),i386)
-BINARY=32
-ISX86=1
+BINARY:=32
+ISX86:=1
 else ifeq ($(ARCH),i387)
-BINARY=32
-ISX86=1
+BINARY:=32
+ISX86:=1
 else ifeq ($(ARCH),i486)
-BINARY=32
-ISX86=1
+BINARY:=32
+ISX86:=1
 else ifeq ($(ARCH),i586)
-BINARY=32
-ISX86=1
+BINARY:=32
+ISX86:=1
 else ifeq ($(ARCH),i686)
-BINARY=32
-ISX86=1
+BINARY:=32
+ISX86:=1
 else ifeq ($(ARCH),x86_64)
-BINARY=64
-ISX86=1
-else ifneq (,$(findstring arm,$(ARCH)))
-ISX86=0
-else ifneq (,$(findstring powerpc,$(ARCH)))
-ISX86=0
-else ifneq (,$(findstring ppc,$(ARCH)))
-ISX86=0
+BINARY:=64
+ISX86:=1
 else
-$(error "unknown word-size for arch: $(ARCH)")
+# For all other architectures (ARM, PPC, AArch64, etc.)
+ISX86:=0
 endif
 
 # If we are running on ARM, set certain options automatically
@@ -539,11 +612,11 @@ JCFLAGS += -fsigned-char
 
 LLVM_ASSERTIONS=1
 #LLVM_FLAGS+="--with-float=hard --with-abi=aapcs-vfp"
-LLVM_VER=3.6.1
 
-override USE_BLAS64=0
-override OPENBLAS_DYNAMIC_ARCH=0
-override OPENBLAS_TARGET_ARCH=ARMV7
+override USE_BLAS64:=0
+override OPENBLAS_DYNAMIC_ARCH:=0
+override OPENBLAS_TARGET_ARCH:=ARMV7
+override USE_SYSTEM_LIBM:=1
 
 endif
 
@@ -558,6 +631,13 @@ CXX_ARG += -m$(BINARY)
 endif
 endif
 
+ifeq ($(OS),WINNT)
+ifneq ($(ARCH),x86_64)
+JCFLAGS += -mincoming-stack-boundary=2
+JCXXFLAGS += -mincoming-stack-boundary=2
+endif
+endif
+
 ifeq ($(USEGCC),1)
 ifeq ($(ISX86),1)
   SHIPFLAGS += -momit-leaf-frame-pointer
@@ -565,34 +645,57 @@ endif
 endif
 
 ifeq ($(OS),WINNT)
-LIBUNWIND=
+LIBUNWIND:=
 else
 ifeq ($(USE_SYSTEM_LIBUNWIND), 1)
 ifneq ($(OS),Darwin)
-LIBUNWIND=-lunwind-generic -lunwind
+LIBUNWIND:=-lunwind-generic -lunwind
+# Only for linux since we want to use not yet released libunwind features
+JCFLAGS+=-DSYSTEM_LIBUNWIND
+JCPPFLAGS+=-DSYSTEM_LIBUNWIND
 endif
 else
 ifeq ($(OS),Darwin)
-LIBUNWIND=$(build_libdir)/libosxunwind.a
+LIBUNWIND:=$(build_libdir)/libosxunwind.a
 JCPPFLAGS+=-DLIBOSXUNWIND
 else
-LIBUNWIND=$(build_libdir)/libunwind-generic.a $(build_libdir)/libunwind.a
+LIBUNWIND:=$(build_libdir)/libunwind-generic.a $(build_libdir)/libunwind.a
 endif
 endif
 endif
 
+ifeq ($(origin LLVM_CONFIG), undefined)
+ifeq ($(USE_SYSTEM_LLVM), 1)
+LLVM_CONFIG := llvm-config$(EXE)
+else
+LLVM_CONFIG := $(build_bindir)/llvm-config$(EXE)
+endif
+endif # LLVM_CONFIG undefined
+
 ifeq ($(USE_SYSTEM_LLVM), 1)
-LLVM_CONFIG ?= llvm-config$(EXE)
 JCPPFLAGS+=-DSYSTEM_LLVM
-LLVM_VER = $(shell $(LLVM_CONFIG) --version)
+endif # SYSTEM_LLVM
+
+ifeq ($(BUILD_OS),$(OS))
+LLVM_CONFIG_HOST := $(LLVM_CONFIG)
+else
+LLVM_CONFIG_HOST := $(basename $(LLVM_CONFIG))-host$(BUILD_EXE)
+ifeq (exists, $(shell [ -f '$(LLVM_CONFIG_HOST)' ] && echo exists ))
+ifeq ($(shell $(LLVM_CONFIG_HOST) --version),3.3)
+# llvm-config-host <= 3.3 is broken, use llvm-config instead (in an emulator)
+# use delayed expansion (= not :=) because spawn isn't defined until later
+LLVM_CONFIG_HOST = $(call spawn,$(LLVM_CONFIG))
+endif
 else
-LLVM_CONFIG=$(build_bindir)/llvm-config$(EXE)
+# llvm-config-host does not exist (cmake build)
+LLVM_CONFIG_HOST = $(call spawn,$(LLVM_CONFIG))
+endif
 endif
 
 ifeq ($(USE_SYSTEM_PCRE), 1)
-PCRE_CONFIG = pcre2-config
+PCRE_CONFIG := pcre2-config
 else
-PCRE_CONFIG = $(build_bindir)/pcre2-config
+PCRE_CONFIG := $(build_bindir)/pcre2-config
 endif
 
 # Use ILP64 BLAS interface when building openblas from source on 64-bit architectures
@@ -610,64 +713,64 @@ endif
 
 ifeq ($(USE_SYSTEM_BLAS), 1)
 ifeq ($(OS), Darwin)
-USE_BLAS64 = 0
-USE_SYSTEM_LAPACK = 0
-LIBBLAS = -L$(build_libdir) -lgfortblas
-LIBBLASNAME = libgfortblas
+USE_BLAS64 := 0
+USE_SYSTEM_LAPACK := 0
+LIBBLAS := -L$(build_libdir) -lgfortblas
+LIBBLASNAME := libgfortblas
 else
 LIBBLAS ?= -lblas
 LIBBLASNAME ?= libblas
 endif
 else
-LIBBLAS = -L$(build_shlibdir) -lopenblas
-LIBBLASNAME = libopenblas
+LIBBLAS := -L$(build_shlibdir) -lopenblas
+LIBBLASNAME := libopenblas
 endif
 
 # OpenBLAS builds LAPACK as part of its build.
 # We only need to build LAPACK if we are not using OpenBLAS.
 ifeq ($(USE_SYSTEM_BLAS), 0)
-LIBLAPACK = $(LIBBLAS)
-LIBLAPACKNAME = $(LIBBLASNAME)
+LIBLAPACK := $(LIBBLAS)
+LIBLAPACKNAME := $(LIBBLASNAME)
 else
 ifeq ($(USE_SYSTEM_LAPACK), 1)
 LIBLAPACK ?= -llapack
 LIBLAPACKNAME ?= liblapack
 else
-LIBLAPACK = -L$(build_shlibdir) -llapack $(LIBBLAS)
-LIBLAPACKNAME = liblapack
+LIBLAPACK := -L$(build_shlibdir) -llapack $(LIBBLAS)
+LIBLAPACKNAME := liblapack
 endif
 endif
 
 ifeq ($(OS), WINNT)
-LIBFFTWNAME = libfftw3
-LIBFFTWFNAME = libfftw3f
+LIBFFTWNAME := libfftw3
+LIBFFTWFNAME := libfftw3f
 else
-LIBFFTWNAME = libfftw3_threads
-LIBFFTWFNAME = libfftw3f_threads
+LIBFFTWNAME := libfftw3_threads
+LIBFFTWFNAME := libfftw3f_threads
 endif
 
 ifeq ($(USE_SYSTEM_LIBM), 1)
-LIBM = -lm
-LIBMNAME = libm
+LIBM := -lm
+LIBMNAME := libm
 else
-LIBM = -lopenlibm
-LIBMNAME = libopenlibm
+LIBM := -lopenlibm
+LIBMNAME := libopenlibm
 endif
 
 ifeq ($(USE_SYSTEM_LIBUV), 1)
-  LIBUV = /usr/lib/libuv-julia.a
-  LIBUV_INC = /usr/include
+  LIBUV := /usr/lib/libuv-julia.a
+  LIBUV_INC := /usr/include
 else
-  LIBUV = $(build_libdir)/libuv.a
-  LIBUV_INC = $(build_includedir)
+  LIBUV := $(build_libdir)/libuv.a
+  LIBUV_INC := $(build_includedir)
 endif
 
 ifeq ($(USE_SYSTEM_UTF8PROC), 1)
-  LIBUTF8PROC = -lutf8proc
-  UTF8PROC_INC = /usr/include
+  LIBUTF8PROC := -lutf8proc
+  UTF8PROC_INC := /usr/include
 else
-  LIBUTF8PROC = $(build_libdir)/libutf8proc.a
-  UTF8PROC_INC = $(build_includedir)
+  LIBUTF8PROC := $(build_libdir)/libutf8proc.a
+  UTF8PROC_INC := $(build_includedir)
 endif
 
 # OS specific stuff
@@ -675,44 +778,44 @@ endif
 # install_name_tool
 ifeq ($(OS), Darwin)
   # must end with a / and have no trailing spaces
-  INSTALL_NAME_ID_DIR = @rpath/
-  INSTALL_NAME_CMD = install_name_tool -id $(INSTALL_NAME_ID_DIR)
-  INSTALL_NAME_CHANGE_CMD = install_name_tool -change
+  INSTALL_NAME_ID_DIR := @rpath/
+  INSTALL_NAME_CMD := install_name_tool -id $(INSTALL_NAME_ID_DIR)
+  INSTALL_NAME_CHANGE_CMD := install_name_tool -change
 ifeq ($(shell test `dsymutil -v | cut -d\- -f2 | cut -d. -f1` -gt 102 && echo yes), yes)
-  DSYMUTIL = dsymutil
+  DSYMUTIL := dsymutil
 else
-  DSYMUTIL = true -ignore
+  DSYMUTIL := true -ignore
 endif
 else
-  INSTALL_NAME_ID_DIR =
-  INSTALL_NAME_CMD = true -ignore
-  INSTALL_NAME_CHANGE_CMD = true -ignore
-  DSYMUTIL = true -ignore
+  INSTALL_NAME_ID_DIR :=
+  INSTALL_NAME_CMD := true -ignore
+  INSTALL_NAME_CHANGE_CMD := true -ignore
+  DSYMUTIL := true -ignore
 endif
 
 # shared library runtime paths
 ifeq ($(OS), WINNT)
-  RPATH =
-  RPATH_ORIGIN =
+  RPATH :=
+  RPATH_ORIGIN :=
 else ifeq ($(OS), Darwin)
-  RPATH = -Wl,-rpath,'@executable_path/$(build_private_libdir_rel)' -Wl,-rpath,'@executable_path/$(build_libdir_rel)'
-  RPATH_ORIGIN = -Wl,-rpath,'@loader_path/'
+  RPATH := -Wl,-rpath,'@executable_path/$(build_private_libdir_rel)' -Wl,-rpath,'@executable_path/$(build_libdir_rel)'
+  RPATH_ORIGIN := -Wl,-rpath,'@loader_path/'
 else
-  RPATH = -Wl,-rpath,'$$ORIGIN/$(build_private_libdir_rel)' -Wl,-rpath,'$$ORIGIN/$(build_libdir_rel)' -Wl,-z,origin
-  RPATH_ORIGIN = -Wl,-rpath,'$$ORIGIN' -Wl,-z,origin
+  RPATH := -Wl,-rpath,'$$ORIGIN/$(build_private_libdir_rel)' -Wl,-rpath,'$$ORIGIN/$(build_libdir_rel)' -Wl,-z,origin
+  RPATH_ORIGIN := -Wl,-rpath,'$$ORIGIN' -Wl,-z,origin
 endif
 
 # --whole-archive
 ifeq ($(OS), Darwin)
-  WHOLE_ARCHIVE = -Xlinker -all_load
-  NO_WHOLE_ARCHIVE =
+  WHOLE_ARCHIVE := -Xlinker -all_load
+  NO_WHOLE_ARCHIVE :=
 else ifneq ($(USEMSVC), 1)
-  WHOLE_ARCHIVE = -Wl,--whole-archive
-  NO_WHOLE_ARCHIVE = -Wl,--no-whole-archive
+  WHOLE_ARCHIVE := -Wl,--whole-archive
+  NO_WHOLE_ARCHIVE := -Wl,--no-whole-archive
 endif
 
 ifeq ($(OS), Linux)
-OSLIBS += -ldl -lrt -lpthread -Wl,--export-dynamic -Wl,--no-whole-archive $(LIBUNWIND)
+OSLIBS += -Wl,--no-as-needed -ldl -lrt -lpthread -Wl,--export-dynamic,--as-needed,--no-whole-archive $(LIBUNWIND)
 ifneq ($(SANITIZE),1)
 ifneq ($(SANITIZE_MEMORY),1)
 ifneq ($(LLVM_SANITIZE),1)
@@ -720,47 +823,53 @@ OSLIBS += -Wl,--version-script=$(JULIAHOME)/src/julia.expmap
 endif
 endif
 endif
-JLDFLAGS = -Wl,-Bdynamic
+JLDFLAGS := -Wl,-Bdynamic
 ifeq (-Bsymbolic-functions, $(shell $(LD) --help | grep -o -e "-Bsymbolic-functions"))
-JLIBLDFLAGS = -Wl,-Bsymbolic-functions
+JLIBLDFLAGS := -Wl,-Bsymbolic-functions
 else
-JLIBLDFLAGS =
+JLIBLDFLAGS :=
 endif
 else #Linux
-JLIBLDFLAGS =
+JLIBLDFLAGS :=
 endif
 
 ifeq ($(OS), FreeBSD)
-JLDFLAGS = -Wl,-Bdynamic
+JLDFLAGS := -Wl,-Bdynamic
 OSLIBS += -lelf -lkvm -lrt -Wl,--export-dynamic -Wl,--version-script=$(JULIAHOME)/src/julia.expmap $(NO_WHOLE_ARCHIVE) $(LIBUNWIND)
 endif
 
 ifeq ($(OS), Darwin)
-INSTALL_NAME_CMD = install_name_tool -id $(INSTALL_NAME_ID_DIR)
-INSTALL_NAME_CHANGE_CMD = install_name_tool -change
-SHLIB_EXT = dylib
+INSTALL_NAME_CMD := install_name_tool -id $(INSTALL_NAME_ID_DIR)
+INSTALL_NAME_CHANGE_CMD := install_name_tool -change
+SHLIB_EXT := dylib
 OSLIBS += -ldl -Wl,-w -framework CoreFoundation -framework CoreServices $(LIBUNWIND)
-WHOLE_ARCHIVE = -Xlinker -all_load
-NO_WHOLE_ARCHIVE =
-JLDFLAGS =
-HAVE_SSP = 1
+WHOLE_ARCHIVE := -Xlinker -all_load
+NO_WHOLE_ARCHIVE :=
+JLDFLAGS :=
+HAVE_SSP := 1
 endif
 
 ifeq ($(OS), WINNT)
 ifneq ($(USEMSVC), 1)
-HAVE_SSP = 1
+HAVE_SSP := 1
 OSLIBS += -Wl,--export-all-symbols -Wl,--version-script=$(JULIAHOME)/src/julia.expmap \
 	$(NO_WHOLE_ARCHIVE) -lpsapi -lkernel32 -lws2_32 -liphlpapi -lwinmm -ldbghelp
-JLDFLAGS = -Wl,--stack,8388608
 ifeq ($(ARCH),i686)
-JLDFLAGS += -Wl,--large-address-aware
+JLDFLAGS := -Wl,--stack,8388608 -Wl,--large-address-aware
+else #x64
+JLDFLAGS := -Wl,--stack,16777216
 endif
 else #USEMSVC
 OSLIBS += kernel32.lib ws2_32.lib psapi.lib advapi32.lib iphlpapi.lib shell32.lib winmm.lib
-JLDFLAGS = -stack:8388608
+JLDFLAGS := -stack:16777216
 endif
 JCPPFLAGS += -D_WIN32_WINNT=0x0502
-UNTRUSTED_SYSTEM_LIBM = 1
+UNTRUSTED_SYSTEM_LIBM := 1
+endif
+
+# Threads
+ifeq ($(JULIA_THREADS), 1)
+JCPPFLAGS += -DJULIA_ENABLE_THREADING
 endif
 
 # Intel VTune Amplifier
@@ -768,41 +877,46 @@ ifeq ($(USE_INTEL_JITEVENTS), 1)
 JCPPFLAGS += -DJL_USE_INTEL_JITEVENTS
 endif
 
+# OProfile
+ifeq ($(USE_OPROFILE_JITEVENTS), 1)
+JCPPFLAGS += -DJL_USE_OPROFILE_JITEVENTS
+endif
+
 # Intel libraries
 
 ifeq ($(USE_INTEL_LIBM), 1)
-USE_SYSTEM_LIBM = 1
-LIBM = -L$(MKLROOT)/../compiler/lib/intel64 -limf
-LIBMNAME = libimf
+USE_SYSTEM_LIBM := 1
+LIBM := -L$(MKLROOT)/../compiler/lib/intel64 -limf
+LIBMNAME := libimf
 endif
 
 ifeq ($(USE_INTEL_MKL), 1)
 ifeq ($(USE_BLAS64), 1)
 export MKL_INTERFACE_LAYER := ILP64
-MKLLIB = $(MKLROOT)/lib/intel64
+MKLLIB := $(MKLROOT)/lib/intel64
 else
-MKLLIB = $(MKLROOT)/lib/ia32
+MKLLIB := $(MKLROOT)/lib/ia32
 endif
-USE_SYSTEM_BLAS=1
-USE_SYSTEM_LAPACK=1
-LIBBLASNAME = libmkl_rt
-LIBLAPACKNAME = libmkl_rt
-MKL_LDFLAGS = -L$(MKLLIB) -lmkl_rt
+USE_SYSTEM_BLAS:=1
+USE_SYSTEM_LAPACK:=1
+LIBBLASNAME := libmkl_rt
+LIBLAPACKNAME := libmkl_rt
+MKL_LDFLAGS := -L$(MKLLIB) -lmkl_rt
 ifneq ($(strip $(MKLLIB)),)
   ifeq ($(OS), Linux)
-    RPATH_MKL = -Wl,-rpath,$(MKLLIB)
+    RPATH_MKL := -Wl,-rpath,$(MKLLIB)
     RPATH     += $(RPATH_MKL)
     MKL_LDFLAGS += $(RPATH_MKL)
   endif
 endif
-LIBBLAS   = $(MKL_LDFLAGS)
-LIBLAPACK = $(MKL_LDFLAGS)
+LIBBLAS   := $(MKL_LDFLAGS)
+LIBLAPACK := $(MKL_LDFLAGS)
 endif
 
 ifeq ($(USE_INTEL_MKL_FFT), 1)
-USE_SYSTEM_FFTW = 1
-LIBFFTWNAME = libmkl_rt
-LIBFFTWFNAME = libmkl_rt
+USE_SYSTEM_FFTW := 1
+LIBFFTWNAME := libmkl_rt
+LIBFFTWFNAME := libmkl_rt
 endif
 
 ifeq ($(HAVE_SSP),1)
@@ -817,33 +931,38 @@ endif
 # ATLAS must have been previously built with "make -C deps compile-atlas" (without -jN),
 # or installed to usr/lib/libatlas from some another source (built as
 # a shared library, for your platform, single threaded)
-USE_ATLAS = 0
-ATLAS_LIBDIR = $(build_libdir)
-#or ATLAS_LIBDIR = /path/to/system/atlas/lib
+USE_ATLAS := 0
+ATLAS_LIBDIR := $(build_libdir)
+#or ATLAS_LIBDIR := /path/to/system/atlas/lib
 
 ifeq ($(USE_ATLAS), 1)
-USE_BLAS64 = 0
-USE_SYSTEM_BLAS = 1
-USE_SYSTEM_LAPACK = 1
-LIBBLAS = -L$(ATLAS_LIBDIR) -lsatlas
-LIBLAPACK = $(LIBBLAS)
-LIBBLASNAME = libsatlas
-LIBLAPACKNAME = $(LIBBLASNAME)
+USE_BLAS64 := 0
+USE_SYSTEM_BLAS := 1
+USE_SYSTEM_LAPACK := 1
+LIBBLAS := -L$(ATLAS_LIBDIR) -lsatlas
+LIBLAPACK := $(LIBBLAS)
+LIBBLASNAME := libsatlas
+LIBLAPACKNAME := $(LIBBLASNAME)
 endif
 
 # Renaming OpenBLAS symbols, see #4923 and #8734
 ifeq ($(USE_SYSTEM_BLAS), 0)
 ifeq ($(USE_BLAS64), 1)
-OPENBLAS_SYMBOLSUFFIX = 64_
+OPENBLAS_SYMBOLSUFFIX := 64_
+OPENBLAS_LIBNAMESUFFIX := 64_
+LIBBLAS := -L$(build_shlibdir) -lopenblas$(OPENBLAS_LIBNAMESUFFIX)
+LIBLAPACK := $(LIBBLAS)
+LIBBLASNAME := $(LIBBLASNAME)$(OPENBLAS_LIBNAMESUFFIX)
+LIBLAPACKNAME := $(LIBBLASNAME)
 endif
 endif
 
 # Custom libcxx
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
-LDFLAGS += -L$(build_libdir) -lc++abi
+LDFLAGS += -L$(build_libdir)
 CXXLDFLAGS += -L$(build_libdir) -lc++abi -stdlib=libc++ -lc++
 CPPFLAGS += -I$(build_includedir)/c++/v1
-CUSTOM_LD_LIBRARY_PATH = LD_LIBRARY_PATH="$(build_libdir)"
+CUSTOM_LD_LIBRARY_PATH := LD_LIBRARY_PATH="$(build_libdir)"
 ifeq ($(USEICC),1)
 CXXFLAGS += -cxxlib-nostd -static-intel
 CLDFLAGS += -static-intel
@@ -886,6 +1005,7 @@ else
 endif
 endef
 
+# many of the following targets must be = not := because the expansion of the makefile functions (and $1) shouldn't happen until later
 ifeq ($(BUILD_OS), WINNT) # MSYS
 spawn = $(1)
 cygpath_w = $(1)
@@ -904,47 +1024,42 @@ endif
 
 exec = $(shell $(call spawn,$(1)))
 
-ifneq (,$(findstring CYGWIN,$(BUILD_OS)))
-wine_pathsearch = $(firstword $(wildcard $(addsuffix /$(1),$(subst :, ,$(2)))))
-else
-wine_pathsearch = $(firstword $(wildcard $(addsuffix /$(1),$(shell printf %s\n '$(2)' | xargs -d";" winepath -u | tr '\n' ' '))))
-endif
 pathsearch = $(firstword $(wildcard $(addsuffix /$(1),$(subst :, ,$(2)))))
 
-JULIA_BUILD_MODE = release
-JULIA_LIBSUFFIX=
+JULIA_BUILD_MODE := release
+JULIA_LIBSUFFIX:=
 ifeq (,$(findstring release,$(MAKECMDGOALS)))
 ifneq (,$(findstring debug,$(MAKECMDGOALS)))
-JULIA_BUILD_MODE = debug
-JULIA_LIBSUFFIX=-debug
+JULIA_BUILD_MODE := debug
+JULIA_LIBSUFFIX:=-debug
 endif
 endif
 
-JULIA_EXECUTABLE_debug = $(build_bindir)/julia-debug$(EXE)
-JULIA_EXECUTABLE_release = $(build_bindir)/julia$(EXE)
-JULIA_EXECUTABLE = $(JULIA_EXECUTABLE_$(JULIA_BUILD_MODE))
+JULIA_EXECUTABLE_debug := $(build_bindir)/julia-debug$(EXE)
+JULIA_EXECUTABLE_release := $(build_bindir)/julia$(EXE)
+JULIA_EXECUTABLE := $(JULIA_EXECUTABLE_$(JULIA_BUILD_MODE))
 
 # Colors for make
 ifndef VERBOSE
-VERBOSE = 0
+VERBOSE := 0
 endif
 
-WARNCOLOR="\033[33;1m"
+WARNCOLOR:="\033[33;1m"
+ENDCOLOR:="\033[0m"
 
 ifeq ($(VERBOSE), 0)
 
 QUIET_MAKE = -s
 
-CCCOLOR="\033[34m"
-LINKCOLOR="\033[34;1m"
-PERLCOLOR="\033[35m"
-FLISPCOLOR="\033[32m"
-JULIACOLOR="\033[32;1m"
+CCCOLOR:="\033[34m"
+LINKCOLOR:="\033[34;1m"
+PERLCOLOR:="\033[35m"
+FLISPCOLOR:="\033[32m"
+JULIACOLOR:="\033[32;1m"
 
-SRCCOLOR="\033[33m"
-BINCOLOR="\033[37;1m"
-JULCOLOR="\033[34;1m"
-ENDCOLOR="\033[0m"
+SRCCOLOR:="\033[33m"
+BINCOLOR:="\033[37;1m"
+JULCOLOR:="\033[34;1m"
 
 GOAL=$(subst ','\'',$(subst $(abspath $(JULIAHOME))/,,$(abspath $@)))
 
@@ -963,3 +1078,8 @@ PRINT_FLISP = echo '$(subst ','\'',$(1))'; $(1)
 PRINT_JULIA = echo '$(subst ','\'',$(1))'; $(1)
 
 endif
+
+# Makefile debugging trick:
+# call print-VARIABLE to see the runtime value of any variable
+print-%:
+	@echo '$*=$($*)'
diff --git a/Make.powerpc b/Make.powerpc
index 15b2167ef6fc9..d456036a6e4ec 100644
--- a/Make.powerpc
+++ b/Make.powerpc
@@ -24,8 +24,6 @@ ifeq ($(USE_SYSTEM_LLVM),1)
 LLVM_CONFIG=llvm-config-3.5
 else
 LLVM_ASSERTIONS=1
-LLVM_VER=3.6.0
-LLVM_ASSERTIONS=1
 endif
 
 # On a newly allocated machine, you'll need the following dependencies:
diff --git a/Makefile b/Makefile
index 5d8ba3a7f3b3f..1ff6f833e6350 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-JULIAHOME = $(abspath .)
+JULIAHOME := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
 include $(JULIAHOME)/Make.inc
 
 # TODO: Code bundled with Julia should be installed into a versioned directory,
@@ -8,25 +8,55 @@ include $(JULIAHOME)/Make.inc
 # prefix/share/julia/site/VERSDIR (not prefix/share/julia/VERSDIR/site ...
 # so that prefix/share/julia/VERSDIR can be overwritten without touching
 # third-party code).
-VERSDIR = v`cut -d. -f1-2 < VERSION`
+VERSDIR := v`cut -d. -f1-2 < $(JULIAHOME)/VERSION`
 
 #file name of make binary-dist result
 ifeq ($(JULIA_BINARYDIST_TARNAME),)
-	JULIA_BINARYDIST_TARNAME = julia-$(JULIA_COMMIT)-$(OS)-$(ARCH)
+	JULIA_BINARYDIST_TARNAME := julia-$(JULIA_COMMIT)-$(OS)-$(ARCH)
 endif
 
 default: $(JULIA_BUILD_MODE) # contains either "debug" or "release"
 all: debug release
 
 # sort is used to remove potential duplicates
-DIRS = $(sort $(build_bindir) $(build_libdir) $(build_private_libdir) $(build_libexecdir) $(build_sysconfdir)/julia $(build_datarootdir)/julia $(build_man1dir))
+DIRS := $(sort $(build_bindir) $(build_libdir) $(build_private_libdir) $(build_libexecdir) $(build_sysconfdir)/julia $(build_datarootdir)/julia $(build_man1dir))
+ifneq ($(BUILDROOT),$(JULIAHOME))
+BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps test test/perf)
+BUILDDIRMAKE := $(addsuffix /Makefile,$(BUILDDIRS))
+DIRS := $(DIRS) $(BUILDDIRS)
+$(BUILDDIRMAKE): | $(BUILDDIRS)
+	@# add Makefiles to the build directories for convenience (pointing back to the source location of each)
+	@echo '# -- This file is automatically generated in julia/Makefile -- #' > $@
+	@echo 'BUILDROOT=$(BUILDROOT)' >> $@
+	@echo 'include $(JULIAHOME)$(patsubst $(BUILDROOT)%,%,$@)' >> $@
+julia-deps: | $(BUILDDIRMAKE)
+configure-y: | $(BUILDDIRMAKE)
+configure:
+ifeq ("$(origin O)", "command line")
+	@if [ "$$(ls '$(BUILDROOT)' 2> /dev/null)" ]; then \
+		echo 'WARNING: configure called on non-empty directory $(BUILDROOT)'; \
+		read -p "Proceed [y/n]? " answer; \
+	else \
+		answer=y;\
+	fi; \
+	[ $$answer = 'y' ] && $(MAKE) configure-$$answer
+else
+	$(error "cannot rerun configure from within a build directory")
+endif
+else
+configure:
+	$(error "must specify O=builddir to run the Julia `make configure` target")
+endif
 
 $(foreach dir,$(DIRS),$(eval $(call dir_target,$(dir))))
 $(foreach link,base test,$(eval $(call symlink_target,$(link),$(build_datarootdir)/julia)))
 
+julia_flisp.boot.inc.phony: julia-deps
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/src julia_flisp.boot.inc.phony
+
 # Build the HTML docs (skipped if already exists, notably in tarballs)
-doc/_build/html:
-	@$(MAKE) -C doc html
+$(BUILDROOT)/doc/_build/html:
+	@$(MAKE) -C $(BUILDROOT)/doc html
 
 # doc needs to live under $(build_docdir), not under $(build_datarootdir)/julia/
 CLEAN_TARGETS += clean-docdir
@@ -43,62 +73,68 @@ $(build_prefix)/.examples: $(wildcard $(JULIAHOME)/examples/*.jl) $(shell find $
 julia-symlink: julia-ui-$(JULIA_BUILD_MODE)
 ifneq ($(OS),WINNT)
 ifndef JULIA_VAGRANT_BUILD
-	@ln -sf "$(shell contrib/relative_path.sh "$(JULIAHOME)" "$(JULIA_EXECUTABLE)")" julia
+	@ln -sf "$(shell $(JULIAHOME)/contrib/relative_path.sh "$(BUILDROOT)" "$(JULIA_EXECUTABLE)")" $(BUILDROOT)/julia
 endif
 endif
 
 julia-deps: | $(DIRS) $(build_datarootdir)/julia/base $(build_datarootdir)/julia/test
-	@$(MAKE) $(QUIET_MAKE) -C deps
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/deps
 
 julia-base: julia-deps $(build_sysconfdir)/julia/juliarc.jl $(build_man1dir)/julia.1
-	@$(MAKE) $(QUIET_MAKE) -C base
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/base
 
-julia-libccalltest:
-	@$(MAKE) $(QUIET_MAKE) -C test libccalltest
+julia-libccalltest: julia-deps
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/src libccalltest
 
-julia-src-release julia-src-debug : julia-src-% : julia-deps
-	@$(MAKE) $(QUIET_MAKE) -C src libjulia-$*
+julia-src-release julia-src-debug : julia-src-% : julia-deps julia_flisp.boot.inc.phony
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/src libjulia-$*
 
 julia-ui-release julia-ui-debug : julia-ui-% : julia-src-%
-	@$(MAKE) $(QUIET_MAKE) -C ui julia-$*
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/ui julia-$*
 
 julia-inference : julia-base julia-ui-$(JULIA_BUILD_MODE) $(build_prefix)/.examples
-	@$(MAKE) $(QUIET_MAKE) $(build_private_libdir)/inference.ji JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) $(build_private_libdir)/inference.ji JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 julia-sysimg-release : julia-inference julia-ui-release
-	@$(MAKE) $(QUIET_MAKE) $(build_private_libdir)/sys.$(SHLIB_EXT) JULIA_BUILD_MODE=release
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) $(build_private_libdir)/sys.$(SHLIB_EXT) JULIA_BUILD_MODE=release
 
 julia-sysimg-debug : julia-inference julia-ui-debug
-	@$(MAKE) $(QUIET_MAKE) $(build_private_libdir)/sys-debug.$(SHLIB_EXT) JULIA_BUILD_MODE=debug
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) $(build_private_libdir)/sys-debug.$(SHLIB_EXT) JULIA_BUILD_MODE=debug
 
 julia-debug julia-release : julia-% : julia-ui-% julia-sysimg-% julia-symlink julia-libccalltest
 
 debug release : % : julia-%
 
+julia-genstdlib: julia-sysimg-$(JULIA_BUILD_MODE)
+	@$(call PRINT_JULIA, $(JULIA_EXECUTABLE) $(call cygpath_w, $(JULIAHOME)/doc/genstdlib.jl))
+
+docs: julia-genstdlib
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/doc
+
 check-whitespace:
 ifneq ($(NO_GIT), 1)
-	@contrib/check-whitespace.sh
+	@$(JULIAHOME)/contrib/check-whitespace.sh
 else
 	$(warn "Skipping whitespace check because git is unavailable")
 endif
 
 release-candidate: release testall
-	@$(JULIA_EXECUTABLE) contrib/add_license_to_files.jl #add license headers
-	@$(JULIA_EXECUTABLE) doc/genstdlib.jl
+	@$(JULIA_EXECUTABLE) $(JULIAHOME)/contrib/add_license_to_files.jl #add license headers
+	@$(JULIA_EXECUTABLE) $(JULIAHOME)/doc/genstdlib.jl
 	@#Check documentation
-	@$(JULIA_EXECUTABLE) doc/NEWS-update.jl #Add missing cross-references to NEWS.md
-	@$(MAKE) -C doc unicode #Rebuild Unicode table if necessary
-	@$(JULIA_EXECUTABLE) doc/DocCheck.jl > doc/UNDOCUMENTED.rst 2>&1 #Check for undocumented items
-	@if [ -z "$(cat doc/UNDOCUMENTED.rst)" ]; then \
-		rm doc/UNDOCUMENTED.rst; \
+	@$(JULIA_EXECUTABLE) $(JULIAHOME)/doc/NEWS-update.jl #Add missing cross-references to NEWS.md
+	@$(MAKE) -C $(BUILDROOT)/doc unicode #Rebuild Unicode table if necessary
+	@$(JULIA_EXECUTABLE) $(JULIAHOME)/doc/DocCheck.jl > $(BUILDROOT)/doc/UNDOCUMENTED.rst 2>&1 #Check for undocumented items
+	@if [ -z "$(cat $(BUILDROOT)/doc/UNDOCUMENTED.rst)" ]; then \
+		rm $(BUILDROOT)/doc/UNDOCUMENTED.rst; \
 	else \
 		echo "Undocumented functions found in doc/UNDOCUMENTED.rst; document them, then retry"; \
 		exit 1; \
 	fi
-	@$(MAKE) -C doc html  SPHINXOPTS="-n" #Rebuild Julia HTML docs pedantically
-	@$(MAKE) -C doc latex SPHINXOPTS="-n" #Rebuild Julia PDF docs pedantically
-	@$(MAKE) -C doc doctest #Run Julia doctests
-	@$(MAKE) -C doc linkcheck #Check all links
+	@$(MAKE) -C $(BUILDROOT)/doc html  SPHINXOPTS="-n" #Rebuild Julia HTML docs pedantically
+	@$(MAKE) -C $(BUILDROOT)/doc latex SPHINXOPTS="-n" #Rebuild Julia PDF docs pedantically
+	@$(MAKE) -C $(BUILDROOT)/doc doctest #Run Julia doctests
+	@$(MAKE) -C $(BUILDROOT)/doc linkcheck #Check all links
 
 	@# Check to see if the above make invocations changed anything important
 	@if [ -n "$$(git status --porcelain)" ]; then \
@@ -107,7 +143,7 @@ release-candidate: release testall
 	fi
 
 	@#Check that benchmarks work
-	@$(MAKE) -C test/perf
+	@$(MAKE) -C $(BUILDROOT)/test/perf
 	@#Check that netload tests work
 	@#for test in test/netload/*.jl; do julia $$test; if [ $$? -ne 0 ]; then exit 1; fi; done
 	@echo
@@ -115,15 +151,16 @@ release-candidate: release testall
 	@echo
 
 	@echo 1. Remove deprecations in base/deprecated.jl
-	@echo 2. Bump VERSION
-	@echo 3. Create tag, push to github "\(git tag v\`cat VERSION\` && git push --tags\)"		#"` # These comments deal with incompetent syntax highlighting rules
-	@echo 4. Clean out old .tar.gz files living in deps/, "\`git clean -fdx\`" seems to work	#"`
-	@echo 5. Replace github release tarball with tarballs created from make light-source-dist and make full-source-dist
-	@echo 6. Follow packaging instructions in DISTRIBUTING.md to create binary packages for all platforms
-	@echo 7. Upload to AWS, update http://julialang.org/downloads and http://status.julialang.org/stable links
-	@echo 8. Update checksums on AWS for tarball and packaged binaries
-	@echo 9. Announce on mailing lists
-	@echo 10. Change master to release-0.X in base/version.jl and base/version_git.sh as in 4cb1e20
+	@echo 2. Update references to the julia version in the source directories, such as in README.md
+	@echo 3. Bump VERSION
+	@echo 4. Create tag, push to github "\(git tag v\`cat VERSION\` && git push --tags\)"		#"` # These comments deal with incompetent syntax highlighting rules
+	@echo 5. Clean out old .tar.gz files living in deps/, "\`git clean -fdx\`" seems to work	#"`
+	@echo 6. Replace github release tarball with tarballs created from make light-source-dist and make full-source-dist
+	@echo 7. Follow packaging instructions in DISTRIBUTING.md to create binary packages for all platforms
+	@echo 8. Upload to AWS, update http://julialang.org/downloads and http://status.julialang.org/stable links
+	@echo 9. Update checksums on AWS for tarball and packaged binaries
+	@echo 10. Announce on mailing lists
+	@echo 11. Change master to release-0.X in base/version.jl and base/version_git.sh as in 4cb1e20
 	@echo
 
 $(build_man1dir)/julia.1: $(JULIAHOME)/doc/man/julia.1 | $(build_man1dir)
@@ -135,8 +172,8 @@ $(build_sysconfdir)/julia/juliarc.jl: $(JULIAHOME)/etc/juliarc.jl | $(build_sysc
 	@echo Creating usr/etc/julia/juliarc.jl
 	@cp $< $@
 ifeq ($(OS), WINNT)
-	@cat ./contrib/windows/juliarc.jl >> $(build_sysconfdir)/julia/juliarc.jl
-$(build_sysconfdir)/julia/juliarc.jl: contrib/windows/juliarc.jl
+	@cat $(JULIAHOME)/contrib/windows/juliarc.jl >> $(build_sysconfdir)/julia/juliarc.jl
+$(build_sysconfdir)/julia/juliarc.jl: $(JULIAHOME)/contrib/windows/juliarc.jl
 endif
 
 $(build_private_libdir)/%.$(SHLIB_EXT): $(build_private_libdir)/%.o
@@ -146,13 +183,15 @@ $(build_private_libdir)/%.$(SHLIB_EXT): $(build_private_libdir)/%.o
 	@$(INSTALL_NAME_CMD)$(notdir $@) $@
 	@$(DSYMUTIL) $@
 
-CORE_SRCS := base/boot.jl base/coreimg.jl \
+CORE_SRCS := $(addprefix $(JULIAHOME)/, \
+		base/boot.jl base/coreimg.jl \
 		base/abstractarray.jl \
 		base/array.jl \
 		base/bool.jl \
 		base/dict.jl \
 		base/error.jl \
 		base/essentials.jl \
+		base/generator.jl \
 		base/expr.jl \
 		base/functors.jl \
 		base/hashing.jl \
@@ -169,43 +208,49 @@ CORE_SRCS := base/boot.jl base/coreimg.jl \
 		base/range.jl \
 		base/reduce.jl \
 		base/reflection.jl \
-		base/tuple.jl
-BASE_SRCS := $(wildcard base/*.jl base/*/*.jl base/*/*/*.jl)
+		base/tuple.jl)
+BASE_SRCS := $(shell find $(JULIAHOME)/base -name \*.jl)
 
 $(build_private_libdir)/inference0.ji: $(CORE_SRCS) | $(build_private_libdir)
-	@$(call PRINT_JULIA, cd base && \
+	@$(call PRINT_JULIA, cd $(JULIAHOME)/base && \
 	$(call spawn,$(JULIA_EXECUTABLE)) -C $(JULIA_CPU_TARGET) --output-ji $(call cygpath_w,$@) -f \
 		coreimg.jl)
 
 $(build_private_libdir)/inference.ji: $(build_private_libdir)/inference0.ji
-	@$(call PRINT_JULIA, cd base && \
+	@$(call PRINT_JULIA, cd $(JULIAHOME)/base && \
 	$(call spawn,$(JULIA_EXECUTABLE)) -C $(JULIA_CPU_TARGET) --output-ji $(call cygpath_w,$@) -f \
 		-J $(call cygpath_w,$<) coreimg.jl)
 
+RELBUILDROOT := $(shell $(JULIAHOME)/contrib/relative_path.sh "$(JULIAHOME)/base" "$(BUILDROOT)/base/")
 COMMA:=,
 define sysimg_builder
-$$(build_private_libdir)/sys$1.o: $$(build_private_libdir)/inference.ji VERSION $$(BASE_SRCS)
-	@$$(call PRINT_JULIA, cd base && \
+$$(build_private_libdir)/sys$1.o: $$(build_private_libdir)/inference.ji $$(JULIAHOME)/VERSION $$(BASE_SRCS)
+	@$$(call PRINT_JULIA, cd $$(JULIAHOME)/base && \
 	$$(call spawn,$2) -C $$(JULIA_CPU_TARGET) --output-o $$(call cygpath_w,$$@) $$(JULIA_SYSIMG_BUILD_FLAGS) -f \
-		-J $$(call cygpath_w,$$<) sysimg.jl \
+		-J $$(call cygpath_w,$$<) sysimg.jl $$(RELBUILDROOT) \
 		|| { echo '*** This error is usually fixed by running `make clean`. If the error persists$$(COMMA) try `make cleanall`. ***' && false; } )
 .SECONDARY: $(build_private_libdir)/sys$1.o
 endef
 $(eval $(call sysimg_builder,,$(JULIA_EXECUTABLE_release)))
 $(eval $(call sysimg_builder,-debug,$(JULIA_EXECUTABLE_debug)))
 
-$(build_bindir)/stringreplace: contrib/stringreplace.c | $(build_bindir)
-	@$(call PRINT_CC, $(HOSTCC) -o $(build_bindir)/stringreplace contrib/stringreplace.c)
+$(build_bindir)/stringreplace: $(JULIAHOME)/contrib/stringreplace.c | $(build_bindir)
+	@$(call PRINT_CC, $(HOSTCC) -o $(build_bindir)/stringreplace $(JULIAHOME)/contrib/stringreplace.c)
 
 
 # public libraries, that are installed in $(prefix)/lib
-JL_LIBS = julia julia-debug
+JL_LIBS := julia julia-debug
 
 # private libraries, that are installed in $(prefix)/lib/julia
-JL_PRIVATE_LIBS = suitesparse_wrapper Rmath
+JL_PRIVATE_LIBS := ccalltest
+ifeq ($(USE_GPL_LIBS), 1)
+JL_PRIVATE_LIBS += suitesparse_wrapper Rmath-julia
+endif
 ifeq ($(USE_SYSTEM_FFTW),0)
+ifeq ($(USE_GPL_LIBS), 1)
 JL_PRIVATE_LIBS += fftw3 fftw3f fftw3_threads fftw3f_threads
 endif
+endif
 ifeq ($(USE_SYSTEM_PCRE),0)
 JL_PRIVATE_LIBS += pcre
 endif
@@ -238,8 +283,10 @@ ifeq ($(USE_SYSTEM_ARPACK),0)
 JL_PRIVATE_LIBS += arpack
 endif
 ifeq ($(USE_SYSTEM_SUITESPARSE),0)
+ifeq ($(USE_GPL_LIBS), 1)
 JL_PRIVATE_LIBS += amd camd ccolamd cholmod colamd umfpack spqr suitesparseconfig
 endif
+endif
 ifeq ($(USE_SYSTEM_LLVM),0)
 ifeq ($(USE_LLVM_SHLIB),1)
 JL_PRIVATE_LIBS += LLVM
@@ -257,11 +304,7 @@ ifeq ($(OS),WINNT)
 define std_dll
 julia-deps: | $$(build_bindir)/lib$(1).dll
 $$(build_bindir)/lib$(1).dll: | $$(build_bindir)
-ifeq ($$(BUILD_OS),$$(OS))
-	cp $$(call pathsearch,lib$(1).dll,$$(PATH)) $$(build_bindir) ;
-else
-	cp $$(call wine_pathsearch,lib$(1).dll,$$(STD_LIB_PATH)) $$(build_bindir) ;
-endif
+	cp $$(call pathsearch,lib$(1).dll,$$(STD_LIB_PATH)) $$(build_bindir) ;
 JL_LIBS += $(1)
 endef
 $(eval $(call std_dll,gfortran-3))
@@ -278,7 +321,7 @@ define stringreplace
 	$(build_bindir)/stringreplace $$(strings -t x - $1 | grep '$2' | awk '{print $$1;}') '$3' 255 "$(call cygpath_w,$1)"
 endef
 
-install: $(build_bindir)/stringreplace doc/_build/html
+install: $(build_bindir)/stringreplace $(BUILDROOT)/doc/_build/html
 	@$(MAKE) $(QUIET_MAKE) all
 	@for subdir in $(bindir) $(libexecdir) $(datarootdir)/julia/site/$(VERSDIR) $(docdir) $(man1dir) $(includedir)/julia $(libdir) $(private_libdir) $(sysconfdir); do \
 		mkdir -p $(DESTDIR)$$subdir; \
@@ -325,22 +368,20 @@ ifeq ($(OS),WINNT)
 endif
 	$(INSTALL_F) $(build_includedir)/uv* $(DESTDIR)$(includedir)/julia
 endif
-	$(INSTALL_F) src/julia.h src/julia_version.h src/options.h src/support/*.h $(DESTDIR)$(includedir)/julia
+	$(INSTALL_F) $(addprefix $(JULIAHOME)/,src/julia.h src/julia_threads.h src/julia_version.h src/support/*.h) $(DESTDIR)$(includedir)/julia
 	# Copy system image
 	-$(INSTALL_F) $(build_private_libdir)/sys.ji $(DESTDIR)$(private_libdir)
 	$(INSTALL_M) $(build_private_libdir)/sys.$(SHLIB_EXT) $(DESTDIR)$(private_libdir)
 	$(INSTALL_M) $(build_private_libdir)/sys-debug.$(SHLIB_EXT) $(DESTDIR)$(private_libdir)
 	# Copy in system image build script
-	$(INSTALL_M) contrib/build_sysimg.jl $(DESTDIR)$(datarootdir)/julia/
-	# Copy in standalone executable build script
-	$(INSTALL_M) contrib/build_executable.jl $(DESTDIR)$(datarootdir)/julia/
+	$(INSTALL_M) $(JULIAHOME)/contrib/build_sysimg.jl $(DESTDIR)$(datarootdir)/julia/
 	# Copy in standalone julia-config script
-	$(INSTALL_M) contrib/julia-config.jl $(DESTDIR)$(datarootdir)/julia/
+	$(INSTALL_M) $(JULIAHOME)/contrib/julia-config.jl $(DESTDIR)$(datarootdir)/julia/
 	# Copy in all .jl sources as well
 	cp -R -L $(build_datarootdir)/julia $(DESTDIR)$(datarootdir)/
 	# Copy documentation
 	cp -R -L $(build_docdir)/* $(DESTDIR)$(docdir)/
-	cp -R -L doc/_build/html $(DESTDIR)$(docdir)/
+	cp -R -L $(BUILDROOT)/doc/_build/html $(DESTDIR)$(docdir)/
 	-rm $(DESTDIR)$(docdir)/html/.buildinfo
 	# Remove perf suite
 	-rm -rf $(DESTDIR)$(datarootdir)/julia/test/perf/
@@ -351,14 +392,14 @@ endif
 	$(INSTALL_F) $(build_man1dir)/julia.1 $(DESTDIR)$(man1dir)/
 	# Copy icon and .desktop file
 	mkdir -p $(DESTDIR)$(datarootdir)/icons/hicolor/scalable/apps/
-	$(INSTALL_F) contrib/julia.svg $(DESTDIR)$(datarootdir)/icons/hicolor/scalable/apps/
+	$(INSTALL_F) $(JULIAHOME)/contrib/julia.svg $(DESTDIR)$(datarootdir)/icons/hicolor/scalable/apps/
 	-touch -c $(DESTDIR)$(datarootdir)/icons/hicolor/
 	-gtk-update-icon-cache $(DESTDIR)$(datarootdir)/icons/hicolor/
 	mkdir -p $(DESTDIR)$(datarootdir)/applications/
-	$(INSTALL_F) contrib/julia.desktop $(DESTDIR)$(datarootdir)/applications/
+	$(INSTALL_F) $(JULIAHOME)/contrib/julia.desktop $(DESTDIR)$(datarootdir)/applications/
 	# Install appdata file
 	mkdir -p $(DESTDIR)$(datarootdir)/appdata/
-	$(INSTALL_F) contrib/julia.appdata.xml $(DESTDIR)$(datarootdir)/appdata/
+	$(INSTALL_F) $(JULIAHOME)/contrib/julia.appdata.xml $(DESTDIR)$(datarootdir)/appdata/
 
 	# Update RPATH entries and JL_SYSTEM_IMAGE_PATH if $(private_libdir_rel) != $(build_private_libdir_rel)
 ifneq ($(private_libdir_rel),$(build_private_libdir_rel))
@@ -382,11 +423,17 @@ endif
 	cp -R $(build_sysconfdir)/julia $(DESTDIR)$(sysconfdir)/
 
 distclean dist-clean:
-	rm -fr julia-*.tar.gz julia*.exe julia-*.7z julia-$(JULIA_COMMIT)
+	-rm -fr $(BUILDROOT)/julia-*.tar.gz $(BUILDROOT)/julia*.exe $(BUILDROOT)/julia-*.7z $(BUILDROOT)/julia-$(JULIA_COMMIT)
 
 dist:
 	@echo \'dist\' target is deprecated: use \'binary-dist\' instead.
 
+ifeq ($(ARCH),x86_64)
+GITCONFIG := $(BUILDROOT)/julia-$(JULIA_COMMIT)/Git/mingw64/etc/gitconfig
+else
+GITCONFIG := $(BUILDROOT)/julia-$(JULIA_COMMIT)/Git/mingw32/etc/gitconfig
+endif
+
 binary-dist: distclean
 ifeq ($(USE_SYSTEM_BLAS),0)
 ifeq ($(ISX86),1)
@@ -402,50 +449,53 @@ endif
 ifneq ($(DESTDIR),)
 	$(error DESTDIR must not be set for make binary-dist)
 endif
-	@$(MAKE) install
-	cp LICENSE.md $(prefix)
+	@$(MAKE) -C $(BUILDROOT) -f $(JULIAHOME)/Makefile install
+	cp $(JULIAHOME)/LICENSE.md $(BUILDROOT)/julia-$(JULIA_COMMIT)
 ifneq ($(OS), WINNT)
-	-./contrib/fixup-libgfortran.sh $(DESTDIR)$(private_libdir)
+	-$(JULIAHOME)/contrib/fixup-libgfortran.sh $(DESTDIR)$(private_libdir)
 endif
 ifeq ($(OS), Linux)
-	-./contrib/fixup-libstdc++.sh $(DESTDIR)$(private_libdir)
+	-$(JULIAHOME)/contrib/fixup-libstdc++.sh $(DESTDIR)$(private_libdir)
+	# We need to bundle ca certs on linux now that we're using libgit2 with ssl
+ifeq ($(shell [ -e $(shell openssl version -d | cut -d '"' -f 2)/cert.pem ] && echo exists),exists)
+	-cp $(shell openssl version -d | cut -d '"' -f 2)/cert.pem $(DESTDIR)$(datarootdir)/julia/
+endif
 endif
 	# Copy in juliarc.jl files per-platform for binary distributions as well
 	# Note that we don't install to sysconfdir: we always install to $(DESTDIR)$(prefix)/etc.
 	# If you want to make a distribution with a hardcoded path, you take care of installation
 ifeq ($(OS), Darwin)
-	-cat ./contrib/mac/juliarc.jl >> $(DESTDIR)$(prefix)/etc/julia/juliarc.jl
+	-cat $(JULIAHOME)/contrib/mac/juliarc.jl >> $(DESTDIR)$(prefix)/etc/julia/juliarc.jl
 endif
 
 ifeq ($(OS), WINNT)
-	[ ! -d dist-extras ] || ( cd dist-extras && \
-		cp 7z.exe 7z.dll libexpat-1.dll zlib1.dll libgfortran-3.dll libquadmath-0.dll libstdc++-6.dll libgcc_s_s*-1.dll libssp-0.dll $(bindir) && \
-	    mkdir $(DESTDIR)$(prefix)/Git && \
-	    7z x PortableGit.7z -o"$(DESTDIR)$(prefix)/Git" && \
-	    echo "[core] eol = lf" >> "$(DESTDIR)$(prefix)/Git/etc/gitconfig" && \
-	    sed -i "s/\bautocrlf = true$$/autocrlf = input/" "$(DESTDIR)$(prefix)/Git/etc/gitconfig" && \
-	    cp busybox.exe $(DESTDIR)$(prefix)/Git/bin/echo.exe && \
-	    cp busybox.exe $(DESTDIR)$(prefix)/Git/bin/printf.exe )
-	cd $(DESTDIR)$(bindir) && rm -f llvm* llc.exe lli.exe opt.exe LTO.dll bugpoint.exe macho-dump.exe
+	[ ! -d $(JULIAHOME)/dist-extras ] || ( cd $(JULIAHOME)/dist-extras && \
+		cp 7z.exe 7z.dll libexpat-1.dll zlib1.dll $(BUILDROOT)/julia-$(JULIA_COMMIT)/bin && \
+	    mkdir $(BUILDROOT)/julia-$(JULIA_COMMIT)/Git && \
+	    7z x PortableGit.7z -o"$(BUILDROOT)/julia-$(JULIA_COMMIT)/Git" && \
+	    echo "[core] eol = lf" >> "$(GITCONFIG)" && \
+	    sed -i "s/\bautocrlf = true$$/autocrlf = input/" "$(GITCONFIG)" )
+	cd $(BUILDROOT)/julia-$(JULIA_COMMIT)/bin && rm -f llvm* llc.exe lli.exe opt.exe LTO.dll bugpoint.exe macho-dump.exe
 
 	# create file listing for uninstall. note: must have Windows path separators and line endings.
-	cd $(prefix) && find * | sed -e 's/\//\\/g' -e 's/$$/\r/g' > etc/uninstall.log
+	cd $(BUILDROOT)/julia-$(JULIA_COMMIT) && find * | sed -e 's/\//\\/g' -e 's/$$/\r/g' > etc/uninstall.log
 
 	# build nsis package
-	$(call spawn,./dist-extras/nsis/makensis.exe) -NOCD -DVersion=$(JULIA_VERSION) -DArch=$(ARCH) -DCommit=$(JULIA_COMMIT) ./contrib/windows/build-installer.nsi
+	cd $(BUILDROOT) && $(call spawn,$(JULIAHOME)/dist-extras/nsis/makensis.exe) -NOCD -DVersion=$(JULIA_VERSION) -DArch=$(ARCH) -DCommit=$(JULIA_COMMIT) -DMUI_ICON="$(call cygpath_w,$(JULIAHOME)/contrib/windows/julia.ico)" $(call cygpath_w,$(JULIAHOME)/contrib/windows/build-installer.nsi)
 
 	# compress nsis installer and combine with 7zip self-extracting header
-	./dist-extras/7z a -mx9 "julia-install-$(JULIA_COMMIT)-$(ARCH).7z" julia-installer.exe
-	cat ./contrib/windows/7zS.sfx ./contrib/windows/7zSFX-config.txt "julia-install-$(JULIA_COMMIT)-$(ARCH).7z" > "julia-${JULIA_VERSION}-${ARCH}.exe"
-	-rm -f julia-installer.exe
+	cd $(BUILDROOT) && $(JULIAHOME)/dist-extras/7z a -mx9 "julia-install-$(JULIA_COMMIT)-$(ARCH).7z" julia-installer.exe
+	cd $(BUILDROOT) && cat $(JULIAHOME)/contrib/windows/7zS.sfx $(JULIAHOME)/contrib/windows/7zSFX-config.txt "julia-install-$(JULIA_COMMIT)-$(ARCH).7z" > "julia-${JULIA_VERSION}-${ARCH}.exe"
+	-rm -f $(BUILDROOT)/julia-installer.exe
 else
-	$(TAR) zcvf $(JULIA_BINARYDIST_TARNAME).tar.gz julia-$(JULIA_COMMIT)
+	cd $(BUILDROOT) && $(TAR) zcvf $(JULIA_BINARYDIST_TARNAME).tar.gz julia-$(JULIA_COMMIT)
 endif
-	rm -fr $(prefix)
+	rm -fr $(BUILDROOT)/julia-$(JULIA_COMMIT)
 
-light-source-dist.tmp: doc/_build/html
+# this target does not accept BUILDROOT
+light-source-dist.tmp: $(JULIAHOME)/doc/_build/html
 	# Save git information
-	-@$(MAKE) -C base version_git.jl.phony
+	-@$(MAKE) -C $(JULIAHOME)/base version_git.jl.phony
 
 	# Create file light-source-dist.tmp to hold all the filenames that go into the tarball
 	echo "base/version_git.jl" > light-source-dist.tmp
@@ -453,6 +503,7 @@ light-source-dist.tmp: doc/_build/html
 	find doc/_build/html >> light-source-dist.tmp
 
 # Make tarball with only Julia code
+# this target does not accept BUILDROOT
 light-source-dist: light-source-dist.tmp
 	# Prefix everything with the current directory name (usually "julia"), then create tarball
 	DIRNAME=$$(basename $$(pwd)); \
@@ -463,13 +514,14 @@ source-dist:
 	@echo \'source-dist\' target is deprecated: use \'full-source-dist\' instead.
 
 # Make tarball with Julia code plus all dependencies
+# this target does not accept BUILDROOT
 full-source-dist: light-source-dist.tmp
 	# Get all the dependencies downloaded
 	@$(MAKE) -C deps getall NO_GIT=1
 
 	# Create file full-source-dist.tmp to hold all the filenames that go into the tarball
 	cp light-source-dist.tmp full-source-dist.tmp
-	-ls deps/*.tar.gz deps/*.tar.bz2 deps/*.tar.xz deps/*.tgz deps/*.zip >> full-source-dist.tmp
+	-ls deps/srccache/*.tar.gz deps/srccache/*.tar.bz2 deps/srccache/*.tar.xz deps/srccache/*.tgz deps/srccache/*.zip >> full-source-dist.tmp
 
 	# Prefix everything with the current directory name (usually "julia"), then create tarball
 	DIRNAME=$$(basename $$(pwd)); \
@@ -477,31 +529,33 @@ full-source-dist: light-source-dist.tmp
 	cd ../ && tar -cz -T $$DIRNAME/full-source-dist.tmp1 --no-recursion -f $$DIRNAME/julia-$(JULIA_VERSION)_$(JULIA_COMMIT)-full.tar.gz
 
 clean: | $(CLEAN_TARGETS)
-	@$(MAKE) -C base clean
-	@$(MAKE) -C doc clean
-	@$(MAKE) -C src clean
-	@$(MAKE) -C ui clean
-	@$(MAKE) -C test clean
-	@rm -f julia
-	@rm -f *~ *# *.tar.gz
-	@rm -f $(build_bindir)/stringreplace \
-		light-source-dist.tmp light-source-dist.tmp1 \
-		full-source-dist.tmp full-source-dist.tmp1
-	@rm -fr $(build_private_libdir)
-	@rm -f $(build_prefix)/.examples
+	@-$(MAKE) -C $(BUILDROOT)/base clean
+	@-$(MAKE) -C $(BUILDROOT)/doc clean
+	@-$(MAKE) -C $(BUILDROOT)/src clean
+	@-$(MAKE) -C $(BUILDROOT)/ui clean
+	@-$(MAKE) -C $(BUILDROOT)/test clean
+	-rm -f $(BUILDROOT)/julia
+	-rm -f $(BUILDROOT)/*.tar.gz
+	-rm -f $(build_bindir)/stringreplace \
+	   $(BUILDROOT)/light-source-dist.tmp $(BUILDROOT)/light-source-dist.tmp1 \
+	   $(BUILDROOT)/full-source-dist.tmp $(BUILDROOT)/full-source-dist.tmp1
+	-rm -fr $(build_private_libdir)
+# Teporarily add this line to the Makefile to remove extras
+	-rm -fr $(build_datarootdir)/julia/extras
+	-rm -f $(build_prefix)/.examples
 
 cleanall: clean
-	@$(MAKE) -C src clean-flisp clean-support
-	@rm -fr $(build_shlibdir)
+	@-$(MAKE) -C $(BUILDROOT)/src clean-flisp clean-support
+	-rm -fr $(build_shlibdir)
 ifeq ($(OS),WINNT)
-	@rm -rf $(build_prefix)/lib
+	-rm -rf $(build_prefix)/lib
 endif
-	@$(MAKE) -C deps clean-libuv
+	@-$(MAKE) -C $(BUILDROOT)/deps clean-libuv
 
 distcleanall: cleanall
-	@$(MAKE) -C deps distcleanall
-	@$(MAKE) -C doc cleanall
-	rm -fr $(build_prefix) $(build_staging)
+	@-$(MAKE) -C $(BUILDROOT)/deps distcleanall
+	@-$(MAKE) -C $(BUILDROOT)/doc cleanall
+	-rm -fr $(build_prefix) $(build_staging)
 
 .PHONY: default debug release check-whitespace release-candidate \
 	julia-debug julia-release julia-deps \
@@ -513,59 +567,72 @@ distcleanall: cleanall
 	dist full-source-dist source-dist
 
 test: check-whitespace $(JULIA_BUILD_MODE)
-	@$(MAKE) $(QUIET_MAKE) -C test default JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test default JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 testall: check-whitespace $(JULIA_BUILD_MODE)
-	cp $(build_prefix)/lib/julia/sys$(JULIA_LIBSUFFIX).$(SHLIB_EXT) local.$(SHLIB_EXT) && $(JULIA_EXECUTABLE) -J local.$(SHLIB_EXT) -e 'true' && rm local.$(SHLIB_EXT)
-	@$(MAKE) $(QUIET_MAKE) -C test all JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	cp $(build_private_libdir)/sys$(JULIA_LIBSUFFIX).$(SHLIB_EXT) $(BUILDROOT)/local.$(SHLIB_EXT) && $(JULIA_EXECUTABLE) -J $(call cygpath_w,$(BUILDROOT)/local.$(SHLIB_EXT)) -e 'true' && rm $(BUILDROOT)/local.$(SHLIB_EXT)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test all JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 testall1: check-whitespace $(JULIA_BUILD_MODE)
-	@env JULIA_CPU_CORES=1 $(MAKE) $(QUIET_MAKE) -C test all JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	@env JULIA_CPU_CORES=1 $(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test all JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 test-%: check-whitespace $(JULIA_BUILD_MODE)
-	@$(MAKE) $(QUIET_MAKE) -C test $* JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test $* JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 perf: release
-	@$(MAKE) $(QUIET_MAKE) -C test/perf JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test/perf JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 perf-%: release
-	@$(MAKE) $(QUIET_MAKE) -C test/perf $* JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/test/perf $* JULIA_BUILD_MODE=$(JULIA_BUILD_MODE)
 
 # download target for some hardcoded windows dependencies
 .PHONY: win-extras wine_path
 win-extras:
-	[ -d dist-extras ] || mkdir dist-extras
+	[ -d $(JULIAHOME)/dist-extras ] || mkdir $(JULIAHOME)/dist-extras
 ifneq ($(BUILD_OS),WINNT)
 ifeq (,$(findstring CYGWIN,$(BUILD_OS)))
-	cp /usr/lib/p7zip/7z /usr/lib/p7zip/7z.so dist-extras
+	cp /usr/lib/p7zip/7z /usr/lib/p7zip/7z.so $(JULIAHOME)/dist-extras
 endif
 endif
 ifneq (,$(filter $(ARCH), i386 i486 i586 i686))
-	cd dist-extras && \
+	cd $(JULIAHOME)/dist-extras && \
 	$(JLDOWNLOAD) http://downloads.sourceforge.net/sevenzip/7z920.exe && \
 	7z x -y 7z920.exe 7z.exe 7z.dll && \
-	../contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win32/openSUSE_13.1 \
-	"mingw32-libgfortran3 mingw32-libquadmath0 mingw32-libstdc++6 mingw32-libgcc_s_sjlj1 mingw32-libssp0 mingw32-libexpat1 mingw32-zlib1" && \
-	cp usr/i686-w64-mingw32/sys-root/mingw/bin/*.dll .
+	../contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win32/openSUSE_13.2 \
+		"mingw32-libgfortran3 mingw32-libquadmath0 mingw32-libstdc++6 mingw32-libgcc_s_sjlj1 mingw32-libssp0 mingw32-libexpat1 mingw32-zlib1" && \
+	cp usr/i686-w64-mingw32/sys-root/mingw/bin/*.dll . && \
+	$(JLDOWNLOAD) PortableGit.7z https://github.com/git-for-windows/git/releases/download/v2.6.1.windows.1/PortableGit-2.6.1-32-bit.7z.exe
 else ifeq ($(ARCH),x86_64)
-	cd dist-extras && \
+	cd $(JULIAHOME)/dist-extras && \
 	$(JLDOWNLOAD) 7z920-x64.msi http://downloads.sourceforge.net/sevenzip/7z920-x64.msi && \
 	7z x -y 7z920-x64.msi _7z.exe _7z.dll && \
 	mv _7z.dll 7z.dll && \
 	mv _7z.exe 7z.exe && \
-	../contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_13.1 \
-	"mingw64-libgfortran3 mingw64-libquadmath0 mingw64-libstdc++6 mingw64-libgcc_s_seh1 mingw64-libssp0 mingw64-libexpat1 mingw64-zlib1" && \
-	cp usr/x86_64-w64-mingw32/sys-root/mingw/bin/*.dll .
+	../contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_13.2 \
+		"mingw64-libgfortran3 mingw64-libquadmath0 mingw64-libstdc++6 mingw64-libgcc_s_seh1 mingw64-libssp0 mingw64-libexpat1 mingw64-zlib1" && \
+	cp usr/x86_64-w64-mingw32/sys-root/mingw/bin/*.dll . && \
+	$(JLDOWNLOAD) PortableGit.7z https://github.com/git-for-windows/git/releases/download/v2.6.1.windows.1/PortableGit-2.6.1-64-bit.7z.exe
 else
 	$(error no win-extras target for ARCH=$(ARCH))
 endif
-	cd dist-extras && \
+	cd $(JULIAHOME)/dist-extras && \
 	$(JLDOWNLOAD) http://downloads.sourceforge.net/sevenzip/7z920_extra.7z && \
 	$(JLDOWNLOAD) https://unsis.googlecode.com/files/nsis-2.46.5-Unicode-setup.exe && \
-	$(JLDOWNLOAD) busybox.exe http://frippery.org/files/busybox/busybox-w32-FRP-1-g9eb16cb.exe && \
 	chmod a+x 7z.exe && \
 	chmod a+x 7z.dll && \
 	$(call spawn,./7z.exe) x -y -onsis nsis-2.46.5-Unicode-setup.exe && \
-	chmod a+x ./nsis/makensis.exe && \
-	chmod a+x busybox.exe && \
-	$(JLDOWNLOAD) PortableGit.7z https://github.com/msysgit/msysgit/releases/download/Git-1.9.5-preview20141217/PortableGit-1.9.5-preview20141217.7z
+	chmod a+x ./nsis/makensis.exe
+
+# various statistics about the build that may interest the user
+ifeq ($(USE_SYSTEM_LLVM), 1)
+LLVM_SIZE := llvm-size$(EXE)
+else
+LLVM_SIZE := $(build_bindir)/llvm-size$(EXE)
+endif
+build-stats:
+	@echo $(JULCOLOR)' ==> ./julia binary sizes'$(ENDCOLOR)
+	$(call spawn,$(LLVM_SIZE) -A $(build_private_libdir)/sys.$(SHLIB_EXT) $(build_shlibdir)/libjulia.$(SHLIB_EXT) $(build_bindir)/julia$(EXE))
+	@echo $(JULCOLOR)' ==> ./julia launch speedtest'$(ENDCOLOR)
+	@time $(call spawn,$(build_bindir)/julia$(EXE) -e '')
+	@time $(call spawn,$(build_bindir)/julia$(EXE) -e '')
+	@time $(call spawn,$(build_bindir)/julia$(EXE) -e '')
diff --git a/NEWS.md b/NEWS.md
index 135fda38422bd..50bef68b74857 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,135 @@
+Julia v0.5.0 Release Notes
+==========================
+
+New language features
+---------------------
+
+  * Generator expressions, e.g. `f(i) for i in 1:n` (#4470). This returns an iterator
+    that computes the specified values on demand.
+
+  * Macro expander functions are now generic, so macros can have multiple definitions
+    (e.g. for different numbers of arguments, or optional arguments) ([#8846], [#9627]).
+    However note that the argument types refer to the syntax tree representation, and not
+    to the types of run time values.
+
+  * `x ∈ X` is now a synonym for `x in X` in `for` loops and comprehensions,
+    as it already was in comparisons ([#13824]).
+
+Language changes
+----------------
+
+  * Each function and closure now has its own type. The captured variables of a closure
+    are fields of its type. `Function` is now an abstract type, and is the default supertype
+    of functions and closures. All functions, including anonymous functions,
+    are generic and support all features (e.g. keyword arguments).
+    Instead of adding methods to `call`, methods are added by type using the syntax
+    `(::ftype)(...) = ...`. `call` is deprecated ([#13412]).
+
+  * `using` and `import` are now case-sensitive even on case-insensitive filesystems (common on Mac and Windows) ([#13542]).
+
+  * Relational symbols are now allowed as infix operators ([#8036]).
+
+  * A warning is always given when a method is overwritten (previously, this was done only when the new
+    and old definitions were in separate modules) ([#14759]).
+
+Command-line option changes
+---------------------------
+
+Compiler/Runtime improvements
+-----------------------------
+
+Library improvements
+--------------------
+
+  * Most of the  combinatorics functions have been moved from `Base`
+    to the [Combinatorics.jl package](https://github.com/JuliaLang/Combinatorics.jl) ([#13897]).
+
+  * Packages:
+
+    * The package system (`Pkg`) is now based on the `libgit2` library, rather
+      than running the `git` program, increasing performance (especially on
+      Windows) ([#11196]).
+
+    * Package-development functions like `Pkg.tag` and `Pkg.publish`
+      have been moved to an external [PkgDev] package ([#13387]).
+
+  * The `Base.Test` module now has a `@testset` feature to bundle
+    tests together and delay throwing an error until the end ([#13062]).
+
+    * The new features are mirrored in the
+      [BaseTestNext](https://github.com/IainNZ/BaseTestNext.jl)
+      package for users who would like to use the new functionality on Julia v0.4.
+
+    * The [BaseTestDeprecated](https://github.com/IainNZ/BaseTestDeprecated.jl)
+      package provides the old-style `handler` functionality, for compatibility
+      with code that needs to support both Julia v0.4 and v0.5.
+
+  * The functions `remotecall`, `remotecall_fetch`, and `remotecall_wait` now have the
+    function argument as the first argument to allow for do-block syntax ([#13338]).
+
+  * `cov` and `cor` don't use keyword arguments anymore and are therefore now type stable ([#13465]).
+
+  * Linear algebra:
+
+    * All dimensions indexed by scalars are now dropped, whereas previously only
+      trailing scalar dimensions would be omitted from the result.
+
+    * New `normalize` and `normalize!` convenience functions for normalizing
+      vectors ([#13681]).
+
+    * QR
+
+      * New method for generic QR with column pivoting ([#13480]).
+
+      * New method for polar decompositions of `AbstractVector`s ([#13681]).
+
+    * A new `SparseVector` type allows for one-dimensional sparse arrays.
+      Slicing and reshaping sparse matrices now return vectors when
+      appropriate. The `sparsevec` function returns a one-dimensional sparse
+      vector instead of a one-column sparse matrix. ([#13440])
+
+    * Rank one update and downdate functions, `lowrankupdate`, `lowrankupdate!`, `lowrankdowndate`,
+    and `lowrankdowndate!`, for dense Cholesky factorizations ([#14243],[#14424])
+
+    * All `sparse` methods now retain provided numerical zeros as structural nonzeros; to
+      drop numerical zeros, use `dropzeros!` ([#14798],[#15242]).
+
+  * New `foreach` function for calling a function on every element of a collection when
+    the results are not needed.
+
+  * `Cmd(cmd; ...)` now accepts new Windows-specific options `windows_verbatim`
+    (to alter Windows command-line generation) and `windows_hide` (to
+    suppress creation of new console windows) ([#13780]).
+
+  * Statistics:
+
+    * Improve performance of `quantile` ([#14413]).
+
+  * The new `Base.StackTraces` module makes stack traces easier to use programmatically. ([#14469])
+
+Deprecated or removed
+---------------------
+
+  * The following function names have been simplified and unified ([#13232]):
+
+    * `get_bigfloat_precision`  -> `precision(BigFloat)`
+    * `set_bigfloat_precision`  -> `setprecision`
+    * `with_bigfloat_precision` -> `setprecision`
+
+    * `get_rounding`            -> `rounding`
+    * `set_rounding`            -> `setrounding`
+    * `with_rounding`           -> `setrounding`
+
+  * The method `A_ldiv_B!(SparseMatrixCSC, StrideVecOrMat)` has been deprecated
+    in favor of versions that require the matrix to be in factored form
+    ([#13496]).
+
+  * Deprecate `chol(A,Val{:U/:L})` in favor of `chol(A)` ([#13680]).
+
+  * `issym` is deprecated in favor of `issymmetric` to match similar functions (`ishermitian`, ...) ([#15192])
+
+  * `scale` is deprecated in favor of either `α*A`, `Diagonal(x)*A`, or `A*Diagonal(x)`. ([#15258])
+
 Julia v0.4.0 Release Notes
 ==========================
 
@@ -54,12 +186,14 @@ New language features
   * Support for inter-task communication using `Channels` ([#12264]).
     See http://docs.julialang.org/en/latest/manual/parallel-computing/#channels for details.
 
-  * RemoteRefs now point to remote channels. The remote channels can be of length greater than 1.
+  * `RemoteRef`s now point to remote channels. The remote channels can be of length greater than 1.
     Default continues to be of length 1 ([#12385]).
     See http://docs.julialang.org/en/latest/manual/parallel-computing/#remoterefs-and-abstractchannels for details.
 
   * `@__LINE__` special macro now available to reflect invocation source line number ([#12727]).
 
+  * `PROGRAM_FILE` global is now available for determining the name of the running script ([#14114]).
+
 Language changes
 ----------------
 
@@ -278,6 +412,8 @@ Library improvements
 
     * Capture groups in regular expressions can now be named using PCRE syntax, `(?P<group_name>...)`. Capture group matches can be accessed by name by indexing a `Match` object with the name of the group ([#11566]).
 
+    * `countlines()` now counts all lines, not just non-empty ([#11947]).
+
   * Array and AbstractArray improvements
 
     * New multidimensional iterators and index types for efficient iteration over `AbstractArray`s. Array iteration should generally be written as `for i in eachindex(A) ... end` rather than `for i = 1:length(A) ... end` ([#8432]).
@@ -388,7 +524,7 @@ Library improvements
 
   * Other improvements
 
-    * You can now tab-complete Emoji characters via their [short names](http://www.emoji-cheat-sheet.com/), using `\:name:<tab>` ([#10709]).
+    * You can now tab-complete emoji via their [short names](http://www.emoji-cheat-sheet.com/), using `\:name:<tab>` ([#10709]).
 
     * `gc_enable` subsumes `gc_disable`, and also returns the previous GC state.
 
@@ -402,9 +538,9 @@ Library improvements
 
     * Added `recvfrom` to get source address of UDP packets ([#9418]).
 
-    * ClusterManager performance improvements ([#9309]) and support for changing transports([#9434]).
+    * `ClusterManager` performance improvements ([#9309]) and support for changing transports([#9434]).
 
-    * Added Base.get_process_title / Base.set_process_title ([#9957]).
+    * Added `Base.get_process_title` / `Base.set_process_title` ([#9957]).
 
     * `readavailable` now returns a byte vector instead of a string.
 
@@ -448,7 +584,7 @@ Deprecated or removed
      end
     ```
 
-  * indexing with Reals that are not subtypes of Integers (Rationals, AbstractFloat, etc.) has been deprecated ([#10458]).
+  * indexing with `Real`s that are not subtypes of `Integer` (`Rational`, `AbstractFloat`, etc.) has been deprecated ([#10458]).
 
   * `push!(A)` has been deprecated, use `append!` instead of splatting arguments to `push!` ([#10400]).
 
@@ -461,7 +597,7 @@ Deprecated or removed
   * The `Graphics` module has been removed from `Base` and is now a
     standalone package ([#10150], [#9862]).
 
-  * The `Woodbury` special matrix type has been removed from LinAlg ([#10024]).
+  * The `Woodbury` special matrix type has been removed from `LinAlg` ([#10024]).
 
   * `median` and `median!` no longer accept a `checknan` keyword argument ([#8605]).
 
@@ -910,7 +1046,7 @@ Deprecated or removed
 
   * The `Stat` type is renamed `StatStruct` ([#4670]).
 
-  * `set_rounding`, `get_rounding` and `with_rounding` now take an additional
+  * `setrounding`, `rounding` and `setrounding` now take an additional
     argument specifying the floating point type to which they apply. The old
     behaviour and `[get/set/with]_bigfloat_rounding` functions are deprecated ([#5007]).
 
@@ -1260,6 +1396,7 @@ Too numerous to mention.
 [pairwise summation]: https://en.wikipedia.org/wiki/Pairwise_summation
 [a448e080]: https://github.com/JuliaLang/julia/commit/a448e080dc736c7fb326426dfcb2528be36973d3
 [5e3f074b]: https://github.com/JuliaLang/julia/commit/5e3f074b9173044a0a4219f9b285879ff7cec041
+[PkgDev]: https://github.com/JuliaLang/PkgDev.jl
 <!--- generated by NEWS-update.jl: -->
 [#13]: https://github.com/JuliaLang/julia/issues/13
 [#69]: https://github.com/JuliaLang/julia/issues/69
@@ -1491,6 +1628,7 @@ Too numerous to mention.
 [#7917]: https://github.com/JuliaLang/julia/issues/7917
 [#7992]: https://github.com/JuliaLang/julia/issues/7992
 [#8011]: https://github.com/JuliaLang/julia/issues/8011
+[#8036]: https://github.com/JuliaLang/julia/issues/8036
 [#8089]: https://github.com/JuliaLang/julia/issues/8089
 [#8113]: https://github.com/JuliaLang/julia/issues/8113
 [#8135]: https://github.com/JuliaLang/julia/issues/8135
@@ -1523,6 +1661,7 @@ Too numerous to mention.
 [#8827]: https://github.com/JuliaLang/julia/issues/8827
 [#8832]: https://github.com/JuliaLang/julia/issues/8832
 [#8845]: https://github.com/JuliaLang/julia/issues/8845
+[#8846]: https://github.com/JuliaLang/julia/issues/8846
 [#8854]: https://github.com/JuliaLang/julia/issues/8854
 [#8867]: https://github.com/JuliaLang/julia/issues/8867
 [#8872]: https://github.com/JuliaLang/julia/issues/8872
@@ -1555,6 +1694,7 @@ Too numerous to mention.
 [#9575]: https://github.com/JuliaLang/julia/issues/9575
 [#9578]: https://github.com/JuliaLang/julia/issues/9578
 [#9597]: https://github.com/JuliaLang/julia/issues/9597
+[#9627]: https://github.com/JuliaLang/julia/issues/9627
 [#9666]: https://github.com/JuliaLang/julia/issues/9666
 [#9690]: https://github.com/JuliaLang/julia/issues/9690
 [#9701]: https://github.com/JuliaLang/julia/issues/9701
@@ -1602,6 +1742,7 @@ Too numerous to mention.
 [#11105]: https://github.com/JuliaLang/julia/issues/11105
 [#11145]: https://github.com/JuliaLang/julia/issues/11145
 [#11171]: https://github.com/JuliaLang/julia/issues/11171
+[#11196]: https://github.com/JuliaLang/julia/issues/11196
 [#11241]: https://github.com/JuliaLang/julia/issues/11241
 [#11279]: https://github.com/JuliaLang/julia/issues/11279
 [#11347]: https://github.com/JuliaLang/julia/issues/11347
@@ -1613,6 +1754,7 @@ Too numerous to mention.
 [#11849]: https://github.com/JuliaLang/julia/issues/11849
 [#11891]: https://github.com/JuliaLang/julia/issues/11891
 [#11922]: https://github.com/JuliaLang/julia/issues/11922
+[#11947]: https://github.com/JuliaLang/julia/issues/11947
 [#11985]: https://github.com/JuliaLang/julia/issues/11985
 [#12025]: https://github.com/JuliaLang/julia/issues/12025
 [#12031]: https://github.com/JuliaLang/julia/issues/12031
@@ -1629,3 +1771,26 @@ Too numerous to mention.
 [#12576]: https://github.com/JuliaLang/julia/issues/12576
 [#12727]: https://github.com/JuliaLang/julia/issues/12727
 [#12739]: https://github.com/JuliaLang/julia/issues/12739
+[#13062]: https://github.com/JuliaLang/julia/issues/13062
+[#13232]: https://github.com/JuliaLang/julia/issues/13232
+[#13338]: https://github.com/JuliaLang/julia/issues/13338
+[#13387]: https://github.com/JuliaLang/julia/issues/13387
+[#13412]: https://github.com/JuliaLang/julia/issues/13412
+[#13440]: https://github.com/JuliaLang/julia/issues/13440
+[#13465]: https://github.com/JuliaLang/julia/issues/13465
+[#13480]: https://github.com/JuliaLang/julia/issues/13480
+[#13496]: https://github.com/JuliaLang/julia/issues/13496
+[#13542]: https://github.com/JuliaLang/julia/issues/13542
+[#13680]: https://github.com/JuliaLang/julia/issues/13680
+[#13681]: https://github.com/JuliaLang/julia/issues/13681
+[#13780]: https://github.com/JuliaLang/julia/issues/13780
+[#13824]: https://github.com/JuliaLang/julia/issues/13824
+[#13897]: https://github.com/JuliaLang/julia/issues/13897
+[#14114]: https://github.com/JuliaLang/julia/issues/14114
+[#14243]: https://github.com/JuliaLang/julia/issues/14243
+[#14413]: https://github.com/JuliaLang/julia/issues/14413
+[#14424]: https://github.com/JuliaLang/julia/issues/14424
+[#14469]: https://github.com/JuliaLang/julia/issues/14469
+[#14759]: https://github.com/JuliaLang/julia/issues/14759
+[#14798]: https://github.com/JuliaLang/julia/issues/14798
+[#15242]: https://github.com/JuliaLang/julia/issues/15242
diff --git a/README.arm.md b/README.arm.md
index 7bfddb132ae62..1c50538172cb9 100644
--- a/README.arm.md
+++ b/README.arm.md
@@ -1,3 +1,8 @@
+# Julia binaries for ARM
+
+[Nightly builds](https://status.julialang.org/download/linux-arm) are
+available for ARM.
+
 # Building Julia on ARM
 
 Julia has been compiled on several ARMv7 / Cortex A15 Samsung
@@ -9,8 +14,9 @@ Julia on ARM can be built by simply typing `make`, which will download all
 the relevant libraries. This is the *recommended* way, and it will take a
 few hours.
 
-If you get SIGILL during sysimg.o creation, it is likely that your cpu does not support VFP.
-File an issue on the Julia issue tracker with the contents of /proc/cpuinfo.
+If you get SIGILL during sysimg.o creation, it is likely that your cpu
+does not support VFP.  File an issue on the Julia issue tracker with
+the contents of /proc/cpuinfo.
 
 This is the list of known issues on ARM:
  [https://github.com/JuliaLang/julia/labels/arm](https://github.com/JuliaLang/julia/labels/arm)
@@ -20,8 +26,9 @@ This is the list of known issues on ARM:
 We recommend using at least Ubuntu 14.04 and gcc 4.8, which is part of the
 standard `build-essentials`.
 
-One can install other system libraries instead of building them,
-should the build be troublesome, by adding the following lines in `Make.user`:
+In case the build is failing on one of the dependent libraries, one
+can install various system libraries instead of building them, by
+adding the following lines in `Make.user`:
 
 ````
 override USE_SYSTEM_BLAS=1
@@ -36,7 +43,9 @@ override USE_SYSTEM_ARPACK=1
 The following command will install all the necessary libraries on Ubuntu.
 
 ````
-sudo apt-get install libblas3gf liblapack3gf libfftw3-dev libgmp3-dev libmpfr-dev libblas-dev liblapack-dev cmake gcc-4.8 g++-4.8 gfortran libgfortran3 m4 libedit-dev
+sudo apt-get install libblas3gf liblapack3gf libarpack2 libfftw3-dev libgmp3-dev \
+                     libmpfr-dev libblas-dev liblapack-dev cmake gcc-4.8 \
+                     g++-4.8 gfortran libgfortran3 m4 libedit-dev
 ````
 
 Note that OpenBLAS only supports ARMv7. For older ARM variants, using the reference BLAS
@@ -47,24 +56,58 @@ may be the simplest thing to do.
 If you run into issues building LLVM, see these notes:
 [http://llvm.org/docs/HowToBuildOnARM.html](http://llvm.org/docs/HowToBuildOnARM.html)
 
-# Raspberry Pi
+## Raspberry Pi 1 / Raspberry Pi Zero
+
+Note: These chips use ARMv6, which is not well supported at the moment. However it is
+possible to get a working Julia build.
+
+The Raspberry Pi ARM CPU type is not detected by LLVM.  Before starting the
+build, it is recommended to explicitly set the CPU target by adding the
+following to `Make.user`:
+
+````
+JULIA_CPU_TARGET=arm1176jzf-s
+````
+
+It is also preferable to use various system provided dependencies on
+ARMv6 as described in [Build Dependencies](#build-dependencies).
+
+You may need to increase the swap file size: edit the `/etc/dphys-swapfile`, changing the line
+
+    CONF_SWAPSIZE=100
 
-The Raspberry Pi ARM CPU type is not detected by LLVM.
-Before starting the build, it is recommended to do `export JULIA_CPU_ARCH=arm1176jzf-s`
-at the shell to tune the generated code for your CPU architecture.
+to
 
-# Raspberry Pi 2
+    CONF_SWAPSIZE=512
 
-In the case of Raspberry Pi 2, in case the default build fails, download LLVM binaries from the LLVM website.
+Then restart the swapfile service:
 
-1.  Download the [LLVM 3.6.1 binaries for ARMv7a] (http://llvm.org/releases/3.6.1/clang+llvm-3.6.1-armv7a-linux-gnueabihf.tar.xz) and extract them in a local directory.
-2.  For each file in the extracted `bin`, `include`, and `lib` subdirectories, create symlinks from the corresponding directory under `/usr/local`.
-3. Add the following to `Make.user`:
-```
-override USE_SYSTEM_LLVM=1
-```
+    sudo /etc/init.d/dphys-swapfile stop
+    sudo /etc/init.d/dphys-swapfile start
 
-# Chromebook
+## Raspberry Pi 2
+
+For Raspberry Pi 2, which is ARMv7, the default build should work. However, the
+CPU type is also not detected by LLVM. Fix this by adding
+`JULIA_CPU_TARGET=cortex-a7` to `Make.user`.
+
+Depending on the exact compiler and distribution, there might be a build failure
+due to unsupported inline assembly. In that case, add `MARCH=armv7-a` to
+`Make.user`.
+
+If building LLVM fails, you can download binaries from the LLVM website:
+
+1.  Download the [LLVM 3.7.0 binaries for ARMv7a] (http://llvm.org/releases/3.7.0/clang+llvm-3.7.0-armv7a-linux-gnueabihf.tar.xz) and extract them in a local directory.
+2. Add the following to `Make.user` (adjusting the path to the `llvm-config` binary):
+
+    ```
+    override USE_SYSTEM_LLVM=1
+    LLVM_CONFIG=${EXTRACTED_LOCATION}/bin/llvm-config
+    ```
+
+Please do let us know if you had to download a pre-built LLVM in [#10235](https://github.com/JuliaLang/julia/issues/10235).
+
+## Chromebook
 
 On Chromebooks, you have to first install Crouton.  If you do not have
 an Ubuntu chroot running on your Chromebook using Crouton, you can do
@@ -76,3 +119,8 @@ so by following these tutorials.
 These tutorials will end up installing Ubuntu 12.04, and you have to
 upgrade to Ubuntu 14.04, or install Ubuntu 14.04 from scratch by
 finding appropriate `crouton` help.
+
+## Scaleway cloud hosted ARM servers
+
+On the current [Scaleway](http://scaleway.com) ARM servers, the Julia
+build works out of the box.
diff --git a/README.md b/README.md
index 908bddff2b048..7484a4aac6b12 100644
--- a/README.md
+++ b/README.md
@@ -68,18 +68,20 @@ First, acquire the source code by cloning the git repository:
 
 Be sure to also configure your system to use the appropriate proxy settings, e.g. by setting the `https_proxy` and `http_proxy` variables.)
 
-By default you will be building the latest unstable version of Julia. However, most users should use the most recent stable version of Julia, which is currently the `0.3` series of releases. You can get this version by changing to the Julia directory and running
+By default you will be building the latest unstable version of Julia. However, most users should use the most recent stable version of Julia, which is currently the `0.4` series of releases. You can get this version by changing to the Julia directory and running
 
-    git checkout release-0.3
+    git checkout release-0.4
 
 Now run `make` to build the `julia` executable. To perform a parallel build, use `make -j N` and supply the maximum number of concurrent processes.
 When compiled the first time, it will automatically download and build its [external dependencies](#Required-Build-Tools-External-Libraries).
 This takes a while, but only has to be done once. If the defaults in the build do not work for you, and you need to set specific make parameters, you can save them in `Make.user`. The build will automatically check for the existence of `Make.user` and use it if it exists.
 Building Julia requires 1.5GiB of disk space and approximately 700MiB of virtual memory.
 
+For builds of julia starting with 0.5.0-dev, you can create out-of-tree builds of Julia by specifying `make O=<build-directory> configure` on the command line. This will create a directory mirror, with all of the necessary Makefiles to build Julia, in the specified directory. These builds will share the source files in Julia and `deps/srccache`. Each out-of-tree build directory can have its own `Make.user` file to override the global `Make.user` file in the top-level folder.
+
 If you need to build Julia in an environment that does not allow access to the outside world, use `make -C deps getall` to download all the necessary files. Then, copy the `julia` directory over to the target environment and build with `make`.
 
-**Note:** the build process will not work if any of the build directory's parent directories have spaces in their names (this is due to a limitation in GNU make).
+**Note:** the build process fail badly if any of the build directory's parent directories have spaces or other shell meta-characters such as `$` or `:` in their names (this is due to a limitation in GNU make).
 
 Once it is built, you can run the `julia` executable using its full path in the directory created above (the `julia` directory), or, to run it from anywhere, either
 
@@ -150,8 +152,9 @@ latest version.
    b. To delete existing binaries of `julia` and all its dependencies,
       delete the `./usr` directory _in the source tree_.
 
-3. If you've upgraded OS X recently and you get an error that looks like
-    ```ld: library not found for -lcrt1.10.6.o```, run `xcode-select --install`.
+3. If you've updated OS X recently, be sure to run `xcode-select --install` to update the command line tools.
+   Otherwise, you could run into errors for missing headers and libraries, such as
+   ```ld: library not found for -lcrt1.10.6.o```.
 
 4. If you've moved the source directory, you might get errors such as
     ```CMake Error: The current CMakeCache.txt directory ... is different than the directory ... where     CMakeCache.txt was created.```, in which case you may delete the offending dependency under `deps`
@@ -217,8 +220,12 @@ Illegal Instruction error | Check if your CPU supports AVX while your OS does no
 
 ### OS X
 
-It is essential to use a 64-bit gfortran to compile Julia dependencies. The gfortran-4.7 (and newer) compilers in Brew, Fink, and MacPorts work for building Julia.
-Clang is now used by default to build Julia on OS X (10.7 and above). It is recommended that you upgrade to the latest version of Xcode (at least 4.3.3.). You need to have the Xcode command line utilities installed (and updated): run `xcode-select --install` in the terminal (in Xcode prior to v5.0, you can alternatively go to Preferences -> Downloads and select the Command Line Utilities). This will ensure that clang v3.1 is installed, which is the minimum version of `clang` required to build Julia. On OS X 10.6, the Julia build will automatically use `gcc`.
+You need to have the current Xcode command line utilities installed: run `xcode-select --install` in the terminal.
+You will need to rerun this terminal command after each OS X update, otherwise you may run into errors involving missing libraries or headers.
+You will also need a 64-bit gfortran to compile Julia dependencies. The gfortran-4.7 (and newer) compilers in Brew, Fink, and MacPorts work for building Julia.
+
+Clang is now used by default to build Julia on OS X 10.7 and above. On OS X 10.6, the Julia build will automatically use `gcc`.
+On current systems, we recommend that you install the command line tools as described above. Older systems do not have a separate command line tools package from Apple, and will require a full Xcode install.  On these, you will need at least Xcode 4.3.3.  In Xcode prior to v5.0, you can alternatively go to Preferences -> Downloads and select the Command Line Utilities. These steps will ensure that clang v3.1 is installed, which is the minimum version of `clang` required to build Julia.
 
 If you have set `LD_LIBRARY_PATH` or `DYLD_LIBRARY_PATH` in your `.bashrc` or equivalent, Julia may be unable to find various libraries that come bundled with it. These environment variables need to be unset for Julia to work.
 
@@ -249,34 +256,35 @@ Building Julia requires that the following software be installed:
 
 - **[GNU make]**                — building dependencies.
 - **[gcc & g++][gcc]** (>= 4.7) or **[Clang][clang]** (>= 3.1, Xcode 4.3.3 on OS X) — compiling and linking C, C++
-- **[gfortran][gcc]**           — compiling and linking Fortran libraries
+- **[gfortran]**                — compiling and linking Fortran libraries
 - **[git]**                     — version control and package management (version 1.7.3+ required)
 - **[perl]**                    — preprocessing of header files of libraries.
 - **[wget]**, **[curl]**, or **[fetch]** (FreeBSD) — to automatically download external libraries.
 - **[m4]**                      — needed to build GMP.
 - **[patch]**                   — for modifying source code.
 - **[cmake]**                   — needed to build `libgit2`.
+- **[openssl]**                 — needed for HTTPS support in `libgit2` on Linux, install via `apt-get install libssl-dev` or `yum install openssl-devel`.
 
 Julia uses the following external libraries, which are automatically downloaded (or in a few cases, included in the Julia source repository) and then compiled from source the first time you run `make`:
 
-- **[LLVM]** (3.3)           — compiler infrastructure. (3.4 not supported; 3.5+ mostly supported, [with caveats](https://github.com/JuliaLang/julia/issues/9336))
+- **[LLVM]** (3.7)           — compiler infrastructure.
 - **[FemtoLisp]**            — packaged with Julia source, and used to implement the compiler front-end.
 - **[libuv]**                — portable, high-performance event-based I/O library
 - **[OpenLibm]**             — portable libm library containing elementary math functions.
 - **[OpenSpecFun]** (>= 0.4) — library containing Bessel and error functions of complex arguments.
 - **[DSFMT]**                — fast Mersenne Twister pseudorandom number generator library.
 - **[OpenBLAS]**             — fast, open, and maintained [basic linear algebra subprograms (BLAS)](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) library, based on [Kazushige Goto's](https://en.wikipedia.org/wiki/Kazushige_Goto) famous [GotoBLAS](https://www.tacc.utexas.edu/research-development/tacc-software/gotoblas2).
-- **[LAPACK]** (>= 3.4)      — library of linear algebra routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.
+- **[LAPACK]** (>= 3.5)      — library of linear algebra routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems.
 - **[MKL]** (optional)       – OpenBLAS and LAPACK may be replaced by Intel's MKL library.
 - **[AMOS]**                 — subroutines for computing Bessel and Airy functions.
 - **[SuiteSparse]** (>= 4.1) — library of linear algebra routines for sparse matrices.
 - **[ARPACK]**               — collection of subroutines designed to solve large, sparse eigenvalue problems.
 - **[FFTW]** (>= 3.3)        — library for computing fast Fourier transforms very quickly and efficiently.
-- **[PCRE]** (>= 8.31)       — Perl-compatible regular expressions library.
+- **[PCRE]** (>= 10.00)      — Perl-compatible regular expressions library.
 - **[GMP]** (>= 5.0)         — GNU multiple precision arithmetic library, needed for `BigInt` support.
 - **[MPFR]** (>= 3.0)        — GNU multiple precision floating point library, needed for arbitrary precision floating point (`BigFloat`) support.
 - **[libgit2]** (>= 0.21)    — Git linkable library, used by Julia's package manager
-- **[utf8proc]** (>= 1.2)    — a library for processing UTF-8 encoded Unicode strings
+- **[utf8proc]** (>= 1.3)    — a library for processing UTF-8 encoded Unicode strings
 - **[libosxunwind]**         — clone of [libunwind], a library that determines the call-chain of a program
 - **[Rmath-julia]**          — library for commonly used statistical functions from the R project.
 
@@ -288,6 +296,7 @@ For a longer overview of Julia's dependencies, see these [slides](https://github
 [m4]:           http://www.gnu.org/software/m4
 [gcc]:          http://gcc.gnu.org
 [clang]:        http://clang.llvm.org
+[gfortran]:     https://gcc.gnu.org/fortran/
 [curl]:         http://curl.haxx.se
 [fetch]:        http://www.freebsd.org/cgi/man.cgi?fetch(1)
 [git]:          http://git-scm.com
@@ -315,6 +324,7 @@ For a longer overview of Julia's dependencies, see these [slides](https://github
 [libosxunwind]: https://github.com/JuliaLang/libosxunwind
 [libunwind]:    http://www.nongnu.org/libunwind
 [Rmath-julia]:  https://github.com/JuliaLang/Rmath-julia
+[openssl]:      https://www.openssl.org
 
 <a name="System-Provided-Libraries">
 ### System Provided Libraries
@@ -397,8 +407,9 @@ The following distributions include julia, but the versions may be out of date d
   * Git package for openSUSE: [OBS page](https://build.opensuse.org/package/show/science/julia-unstable), [1 Click Install](http://software.opensuse.org/download.html?project=science&package=julia-unstable)
 * [NixOS](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/compilers/julia)
 * Ubuntu
-  * [Ubuntu 13.04 (Raring Ringtail)](http://packages.ubuntu.com/raring/julia)
+  * [Ubuntu](http://packages.ubuntu.com/search?keywords=julia)
   * [Nightly builds PPA](https://launchpad.net/~staticfloat/+archive/julianightlies) (depends on the [julia-deps PPA](https://launchpad.net/~staticfloat/+archive/julia-deps/))
+* [MacPorts](https://trac.macports.org/browser/trunk/dports/lang/julia/Portfile)
 * [OS X Homebrew Tap](https://github.com/staticfloat/homebrew-julia/)
 
 <a name="Editor-Terminal-Setup"/>
diff --git a/README.windows.md b/README.windows.md
index a4acb7b594820..a4bc7064a7ffa 100644
--- a/README.windows.md
+++ b/README.windows.md
@@ -192,7 +192,7 @@ Julia can be also compiled from source in [Cygwin](http://www.cygwin.com), using
 
 If you prefer to cross-compile, the following steps should get you started.
 
-For maximum compatibility with packages that use [WinRPM.jl](https://github.com/JuliaLang/WinRPM.jl) for binary dependencies on Windows, it is recommended that you use OpenSUSE 13.1 for cross-compiling a Windows build of Julia. If you use a different Linux distribution or OS X, install [Vagrant](http://www.vagrantup.com/downloads) and use the following `Vagrantfile`:
+For maximum compatibility with packages that use [WinRPM.jl](https://github.com/JuliaLang/WinRPM.jl) for binary dependencies on Windows, it is recommended that you use OpenSUSE 13.2 for cross-compiling a Windows build of Julia. If you use a different Linux distribution or OS X, install [Vagrant](http://www.vagrantup.com/downloads) and use the following `Vagrantfile`:
 ```
 # Vagrantfile for MinGW-w64 cross-compilation of Julia
 
@@ -201,7 +201,7 @@ $script = <<SCRIPT
 export XC_HOST=x86_64-w64-mingw32
 # Change the following to 32 for 32 bit Julia:
 export BITS=64
-zypper addrepo http://download.opensuse.org/repositories/windows:mingw:win$BITS/openSUSE_13.1/windows:mingw:win$BITS.repo
+zypper addrepo http://download.opensuse.org/repositories/windows:mingw:win$BITS/openSUSE_13.2/windows:mingw:win$BITS.repo
 zypper --gpg-auto-import-keys refresh
 zypper -n install --no-recommends git make cmake tar wine which curl \
     python python-xml patch gcc-c++ m4 p7zip.i586 libxml2-tools
@@ -218,7 +218,7 @@ make -j4 binary-dist
 SCRIPT
 
 Vagrant.configure("2") do |config|
-  config.vm.box = "chef/opensuse-13.1"
+  config.vm.box = "bento/opensuse-13.2"
   config.vm.provider :virtualbox do |vb|
     # Use VBoxManage to customize the VM. For example to change memory:
     vb.memory = 2048
@@ -237,7 +237,7 @@ a system compiler, and some downloaders.
 On Ubuntu (on other linux systems, the dependency names are likely to be similar):
 
     apt-add-repository ppa:ubuntu-wine/ppa
-    apt-get upate
+    apt-get update
     apt-get install wine1.7 subversion cvs gcc wget p7zip-full
 
 On Mac: Install XCode, XCode command line tools, X11 (now [XQuartz](http://xquartz.macosforge.org/)),
@@ -252,7 +252,7 @@ So first we need to get a cross-compile version of gcc.
 Most binary packages appear to not include gfortran, so we will need to compile it from source.
 This is typically quite a bit of work, so we will use [this script](http://sourceforge.net/projects/mingw-w64-dgn/) o make it easy.
 
-1. `svn checkout svn checkout svn://svn.code.sf.net/p/mingw-w64-dgn/code/trunk mingw-w64-dgn-code`
+1. `svn checkout svn://svn.code.sf.net/p/mingw-w64-dgn/code/trunk mingw-w64-dgn`
 2. `cd mingw-w64-dgn`
 3. edit `rebuild_cross.sh` and make the following two changes:
   a. uncomment `export MAKE_OPT="-j 2"`, if appropriate for your machine
@@ -260,7 +260,7 @@ This is typically quite a bit of work, so we will use [this script](http://sourc
 5. `bash update_source.sh`
 4. `bash rebuild_cross.sh`
 5. `mv cross ~/cross-w64`
-6. `export PATH=$HOME/cross-w64/bin:$PATH` # NOTE: it is important that you remember to always do this before using make in the following steps!, you can put this line in your .profile to make it easy
+6. `export PATH=$HOME/cross-w64/bin:$PATH` # NOTE: it is important that you remember to always do this before using make in the following steps! You can put this line in your .profile to make it easy.
 
 Then we can essentially just repeat these steps for the 32-bit compiler, reusing some of the work:
 
@@ -270,13 +270,13 @@ Then we can essentially just repeat these steps for the 32-bit compiler, reusing
 10. `rm -r cross build`
 11. `bash rebuild_cross.sh 32r`
 12. `mv cross ~/cross-w32`
-13. `export PATH=$HOME/cross-w32/bin:$PATH` # NOTE: it is important that you remember to always do this before using make in the following steps!, you can put this line in your .profile to make it easy
+13. `export PATH=$HOME/cross-w32/bin:$PATH` # NOTE: it is important that you remember to always do this before using make in the following steps! You can put this line in your .profile to make it easy.
 
 Note: for systems that support rpm-based package managers, the necessary dependencies can be downloaded from the OpenSUSE build service (see the Vagrant script above).
 
 @vtjnash occassionally upload his builds, so you can also download those to save build time:
 - [x86_64-w64-mingw64 gcc-5.2.0 MacOS-10.10 (105 MB)](https://onedrive.live.com/redir?resid=BCAF288A35FC4406!1601&authkey=!ANpFOoCqFGYTcHM&ithint=file%2cgz)
-- [i686-w64-mingw64 gcc-5.2.0 MacOS-10.10 (143 MB)](https://onedrive.live.com/redir?resid=BCAF288A35FC4406!1603&authkey=!AFFN2E_8hytOaoc&ithint=file%2cgz)
+- [i686-w64-mingw64 gcc-5.2.0 MacOS-10.10 (89 MB)](https://onedrive.live.com/redir?resid=BCAF288A35FC4406!1607&authkey=!AFrL8G5G70iYhUU&ithint=file%2cgz)
 - [*-w64-mingw64 gcc-4.9.2 Ubuntu-15.04 (168 MB)](https://onedrive.live.com/redir?resid=BCAF288A35FC4406!1602&authkey=!ABhstrqDG-4zdLo&ithint=file%2cgz)
 
 Then run the build:
@@ -284,7 +284,7 @@ Then run the build:
 1. `git clone https://github.com/JuliaLang/julia.git julia-win32`
 2. `echo override XC_HOST = i686-w64-mingw32 >> Make.user`
 3. `make`
-4. `make win-extras` (Necessary before running `make binary-dist`p)
+4. `make win-extras` (Necessary before running `make binary-dist`)
 5. `make binary-dist`
 6. move the julia-*.exe installer to the target machine
 
diff --git a/appveyor.yml b/appveyor.yml
index 8c3f03524f349..7947415bea34c 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,5 +1,6 @@
 environment:
 #  USEMSVC: "1"
+  JULIA_TEST_MAXRSS_MB: 500
   matrix:
   - ARCH: "i686"
   - ARCH: "x86_64"
@@ -31,11 +32,15 @@ cache:
 # Cache any downloads from sourceforge because it's really unreliable
   - i686-4.9.2-release-win32-sjlj-rt_v4-rev3.7z
   - x86_64-4.9.2-release-win32-seh-rt_v4-rev3.7z
-  - llvm-3.3-i686-w64-mingw32-juliadeps.7z
-  - llvm-3.3-x86_64-w64-mingw32-juliadeps.7z
-  - jq.exe
+  - llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z
+  - llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z
 
 build_script:
+# If there's a newer build queued for the same PR, cancel this one
+  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
+        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
+        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
+        throw "There are newer queued builds for this pull request, failing early." }
 # Remove C:\MinGW\bin from the path, the version of MinGW installed on
 # AppVeyor is not compatible with the cross-compiled Julia Windows binaries
   - set PATH=%PATH:C:\MinGW\bin;=%
@@ -43,10 +48,9 @@ build_script:
 # Unable to find Digest::SHA or Digest::SHA::PurePerl
   - set PATH=%PATH:C:\Perl\bin;=%
 #  - '"%VS120COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64'
-# Since the AppVeyor VMs have Git installed, they have MSYS1
-  - sh --login /c/projects/julia/contrib/windows/msys_build.sh
+  - C:\msys64\usr\bin\sh.exe --login /c/projects/julia/contrib/windows/msys_build.sh
 
 test_script:
   - usr\bin\julia -e "versioninfo()"
   - copy usr\lib\julia\sys.ji local.ji && usr\bin\julia -J local.ji -e "true" && del local.ji
-  - cd test && ..\usr\bin\julia runtests.jl all
+  - cd test && ..\usr\bin\julia runtests.jl all && ..\usr\bin\julia runtests.jl libgit2-online pkg
diff --git a/base/Enums.jl b/base/Enums.jl
index af241db044192..9937565a114bf 100644
--- a/base/Enums.jl
+++ b/base/Enums.jl
@@ -74,7 +74,7 @@ macro enum(T,syms...)
     end
     blk = quote
         # enum definition
-        bitstype 32 $(esc(T)) <: Enum
+        Base.@__doc__(bitstype 32 $(esc(T)) <: Enum)
         function Base.convert(::Type{$(esc(typename))}, x::Integer)
             $(membershiptest(:x, values)) || enum_argument_error($(Expr(:quote, typename)), x)
             Intrinsics.box($(esc(typename)), convert(Int32, x))
@@ -92,7 +92,19 @@ macro enum(T,syms...)
                 end
             end
         end
-        Base.show(io::IO,x::$(esc(typename))) = print(io, x, "::", $(esc(typename)))
+        function Base.show(io::IO,x::$(esc(typename)))
+            if Base.limit_output(io)
+                print(io, x)
+            else
+                print(io, x, "::", $(esc(typename)), " = ", Int(x))
+            end
+        end
+        function Base.writemime(io::IO,::MIME"text/plain",::Type{$(esc(typename))})
+            print(io, "Enum ", $(esc(typename)), ":")
+            for (sym, i) in $vals
+                print(io, "\n", sym, " = ", i)
+            end
+        end
     end
     if isa(T,Symbol)
         for (sym,i) in vals
diff --git a/base/LineEdit.jl b/base/LineEdit.jl
index 385643bd8bfc8..c478b216f350c 100644
--- a/base/LineEdit.jl
+++ b/base/LineEdit.jl
@@ -70,7 +70,7 @@ input_string(s::PromptState) = bytestring(s.input_buffer)
 input_string_newlines(s::PromptState) = count(c->(c == '\n'), input_string(s))
 function input_string_newlines_aftercursor(s::PromptState)
     str = input_string(s)
-    length(str) == 0 && return 0
+    isempty(str) && return 0
     rest = str[nextind(str, position(s.input_buffer)):end]
     return count(c->(c == '\n'), rest)
 end
@@ -143,7 +143,7 @@ end
 complete_line(s::MIState) = complete_line(s.mode_state[s.current_mode], s.key_repeats)
 function complete_line(s::PromptState, repeats)
     completions, partial, should_complete = complete_line(s.p.complete, s)
-    if length(completions) == 0
+    if isempty(completions)
         beep(terminal(s))
     elseif !should_complete
         # should_complete is false for cases where we only want to show
@@ -156,7 +156,7 @@ function complete_line(s::PromptState, repeats)
         edit_replace(s, position(s.input_buffer), prev_pos, completions[1])
     else
         p = common_prefix(completions)
-        if length(p) > 0 && p != partial
+        if !isempty(p) && p != partial
             # All possible completions share the same prefix, so we might as
             # well complete that
             prev_pos = position(s.input_buffer)
@@ -747,13 +747,13 @@ immutable KeyAlias
     KeyAlias(seq) = new(normalize_key(seq))
 end
 
-match_input(k::Function, s, term, cs, keymap) = (update_key_repeats(s, cs); return keymap_fcn(k, s, ByteString(cs)))
+match_input(k::Function, s, term, cs, keymap) = (update_key_repeats(s, cs); return keymap_fcn(k, ByteString(cs)))
 match_input(k::Void, s, term, cs, keymap) = (s,p) -> return :ok
 match_input(k::KeyAlias, s, term, cs, keymap) = match_input(keymap, s, IOBuffer(k.seq), Char[], keymap)
 function match_input(k::Dict, s, term=terminal(s), cs=Char[], keymap = k)
     # if we run out of characters to match before resolving an action,
     # return an empty keymap function
-    eof(term) && return keymap_fcn(nothing, s, "")
+    eof(term) && return keymap_fcn(nothing, "")
     c = read(term, Char)
     push!(cs, c)
     key = haskey(k, c) ? c : '\0'
@@ -761,9 +761,9 @@ function match_input(k::Dict, s, term=terminal(s), cs=Char[], keymap = k)
     return match_input(get(k, key, nothing), s, term, cs, keymap)
 end
 
-keymap_fcn(f::Void, s, c) = (s, p) -> return :ok
-function keymap_fcn(f::Function, s, c)
-    return (s, p) -> begin
+keymap_fcn(f::Void, c) = (s, p) -> return :ok
+function keymap_fcn(f::Function, c)
+    return function (s, p)
         r = f(s, p, c)
         if isa(r, Symbol)
             return r
@@ -990,7 +990,7 @@ function write_response_buffer(s::PromptState, data)
     offset = s.input_buffer.ptr
     ptr = data.response_buffer.ptr
     seek(data.response_buffer, 0)
-    write(s.input_buffer, readall(data.response_buffer))
+    write(s.input_buffer, readstring(data.response_buffer))
     s.input_buffer.ptr = offset + ptr - 2
     data.response_buffer.ptr = ptr
     refresh_line(s)
@@ -1100,6 +1100,7 @@ function reset_state(s::PrefixSearchState)
         s.response_buffer.size = 0
         s.response_buffer.ptr = 1
     end
+    reset_state(s.histprompt.hp)
 end
 
 function transition(f::Function, s::PrefixSearchState, mode)
@@ -1124,12 +1125,12 @@ end
 
 function refresh_multi_line(termbuf::TerminalBuffer, s::SearchState)
     buf = IOBuffer()
-    write(buf, pointer(s.query_buffer.data), s.query_buffer.ptr-1)
+    unsafe_write(buf, pointer(s.query_buffer.data), s.query_buffer.ptr-1)
     write(buf, "': ")
     offset = buf.ptr
     ptr = s.response_buffer.ptr
     seek(s.response_buffer, 0)
-    write(buf, readall(s.response_buffer))
+    write(buf, readstring(s.response_buffer))
     buf.ptr = offset + ptr - 1
     s.response_buffer.ptr = ptr
     s.ias = refresh_multi_line(termbuf, s.terminal, buf, s.ias, s.backward ? "(reverse-i-search)`" : "(forward-i-search)`")
diff --git a/base/Makefile b/base/Makefile
index 5888408e15c31..27fd276f23206 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -1,40 +1,42 @@
-JULIAHOME = ..
-include ../deps/Versions.make
-include ../Make.inc
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+BUILDDIR := .
+JULIAHOME := $(abspath $(SRCDIR)/..)
+include $(JULIAHOME)/deps/Versions.make
+include $(JULIAHOME)/Make.inc
 
-TAGGED_RELEASE_BANNER = ""
+TAGGED_RELEASE_BANNER := ""
 
 ifneq ($(USEMSVC), 1)
-CPP_STDOUT = $(CPP) -P
+CPP_STDOUT := $(CPP) -P
 else
-CPP_STDOUT = $(CPP) -E
+CPP_STDOUT := $(CPP) -E
 endif
 
-all: pcre_h.jl errno_h.jl build_h.jl.phony fenv_constants.jl file_constants.jl uv_constants.jl version_git.jl.phony
+all: $(addprefix $(BUILDDIR)/,pcre_h.jl errno_h.jl build_h.jl.phony fenv_constants.jl file_constants.jl uv_constants.jl version_git.jl.phony)
 
-PCRE_CONST = 0x[0-9a-fA-F]+|[0-9]+
+PCRE_CONST := 0x[0-9a-fA-F]+|[0-9]+
 ifeq ($(USE_SYSTEM_PCRE), 1)
-  PCRE_INCL_PATH = $(shell $(PCRE_CONFIG) --prefix)/include/pcre2.h
+  PCRE_INCL_PATH := $(shell $(PCRE_CONFIG) --prefix)/include/pcre2.h
 else
-  PCRE_INCL_PATH = $(build_includedir)/pcre2.h
+  PCRE_INCL_PATH := $(build_includedir)/pcre2.h
 endif
 
-pcre_h.jl:
-	@$(call PRINT_PERL, $(CPP) -D PCRE2_CODE_UNIT_WIDTH=8 -dM $(PCRE_INCL_PATH) | perl -nle '/^\s*#define\s+PCRE2_(\w*)\s*\(?($(PCRE_CONST))\)?u?\s*$$/ and print "const $$1 = UInt32($$2)"' | sort > $@)
+$(BUILDDIR)/pcre_h.jl: $(PCRE_INCL_PATH)
+	@$(call PRINT_PERL, $(CPP) -D PCRE2_CODE_UNIT_WIDTH=8 -dM $< | perl -nle '/^\s*#define\s+PCRE2_(\w*)\s*\(?($(PCRE_CONST))\)?u?\s*$$/ and print "const $$1 = UInt32($$2)"' | LC_ALL=C sort > $@)
 
-errno_h.jl:
-	@$(call PRINT_PERL, echo '#include "errno.h"' | $(CPP) -dM - | perl -nle 'print "const $$1 = Int32($$2)" if /^#define\s+(E\w+)\s+(\d+)\s*$$/' | sort > $@)
+$(BUILDDIR)/errno_h.jl:
+	@$(call PRINT_PERL, echo '#include <errno.h>' | $(CPP) -dM - | perl -nle 'print "const $$1 = Int32($$2)" if /^#define\s+(E\w+)\s+(\d+)\s*$$/' | LC_ALL=C sort > $@)
 
-fenv_constants.jl: ../src/fenv_constants.h
-	@$(PRINT_PERL) $(CPP_STDOUT) -DJULIA ../src/fenv_constants.h | tail -n 8 | perl -ple 's/\sFE_UN\w+/ 0x10/g; s/\sFE_O\w+/ 0x08/g; s/\sFE_DI\w+/ 0x04/g; s/\sFE_INV\w+/ 0x01/g; s/\sFE_TON\w+/ 0x00/g; s/\sFE_UP\w+/ 0x800/g; s/\sFE_DO\w+/ 0x400/g; s/\sFE_TOW\w+/ 0xc00/g' > $@
+$(BUILDDIR)/fenv_constants.jl: $(SRCDIR)/../src/fenv_constants.h
+	@$(PRINT_PERL) $(CPP_STDOUT) -DJULIA $< | tail -n 8 | perl -ple 's/\sFE_UN\w+/ 0x10/g; s/\sFE_O\w+/ 0x08/g; s/\sFE_DI\w+/ 0x04/g; s/\sFE_INV\w+/ 0x01/g; s/\sFE_TON\w+/ 0x00/g; s/\sFE_UP\w+/ 0x800/g; s/\sFE_DO\w+/ 0x400/g; s/\sFE_TOW\w+/ 0xc00/g' > $@
 
-file_constants.jl: ../src/file_constants.h
-	@$(call PRINT_PERL, $(CPP_STDOUT) -DJULIA ../src/file_constants.h | perl -nle 'print "$$1 0o$$2" if /^(\s*const\s+[A-z_]+\s+=)\s+(0[0-9]*)\s*$$/; print "$$1" if /^\s*(const\s+[A-z_]+\s+=\s+([1-9]|0x)[0-9A-z]*)\s*$$/' > $@)
+$(BUILDDIR)/file_constants.jl: $(SRCDIR)/../src/file_constants.h
+	@$(call PRINT_PERL, $(CPP_STDOUT) -DJULIA $< | perl -nle 'print "$$1 0o$$2" if /^(\s*const\s+[A-z_]+\s+=)\s+(0[0-9]*)\s*$$/; print "$$1" if /^\s*(const\s+[A-z_]+\s+=\s+([1-9]|0x)[0-9A-z]*)\s*$$/' > $@)
 
-uv_constants.jl: ../src/uv_constants.h $(build_includedir)/uv-errno.h
-	@$(call PRINT_PERL, $(CPP_STDOUT) "-I$(LIBUV_INC)" -DJULIA ../src/uv_constants.h | tail -n 16 > $@)
+$(BUILDDIR)/uv_constants.jl: $(SRCDIR)/../src/uv_constants.h $(build_includedir)/uv-errno.h
+	@$(call PRINT_PERL, $(CPP_STDOUT) "-I$(LIBUV_INC)" -DJULIA $< | tail -n 16 > $@)
 
-build_h.jl.phony:
+$(BUILDDIR)/build_h.jl.phony:
 	@echo "# This file is automatically generated in base/Makefile" > $@
 	@echo "const ARCH = :$(ARCH)" >> $@
 ifeq ($(XC_HOST),)
@@ -57,7 +59,7 @@ else
 endif
 	@echo "const libfftw_name = \"$(LIBFFTWNAME)\"" >> $@
 	@echo "const libfftwf_name = \"$(LIBFFTWFNAME)\"" >> $@
-	@echo "const libllvm_version = \"$(LLVM_VER)\"" >> $@
+	@echo "const libllvm_version = \"$$($(LLVM_CONFIG_HOST) --version)\"" >> $@
 	@echo "const VERSION_STRING = \"$(JULIA_VERSION)\"" >> $@
 	@echo "const TAGGED_RELEASE_BANNER = \"$(TAGGED_RELEASE_BANNER)\"" >> $@
 	@echo "const SYSCONFDIR = \"$(sysconfdir_rel)\"" >> $@
@@ -73,9 +75,9 @@ endif
 		rm -f $@; \
 	fi
 
-version_git.jl.phony:
+$(BUILDDIR)/version_git.jl.phony: $(SRCDIR)/version_git.sh
 ifneq ($(NO_GIT), 1)
-	@sh version_git.sh > $@
+	sh $< $(SRCDIR) > $@
 	@# This to avoid touching git_version.jl when it is not modified,
 	@# so that the system image does not need to be rebuilt.
 	@if ! cmp -s $@ version_git.jl; then \
@@ -85,29 +87,26 @@ ifneq ($(NO_GIT), 1)
 	    rm -f $@; \
 	fi
 else
-ifeq ($(shell [ -f version_git.jl ] && echo "true"), true)
+ifeq ($(shell [ -f $(BUILDDIR)/version_git.jl ] && echo "true"), true)
 	@# Give warning if boilerplate git is used
-	@if grep -q "Default output if git is not available" version_git.jl; then \
+	@if grep -q "Default output if git is not available" $(BUILDDIR)/version_git.jl; then \
 	    echo "WARNING: Using boilerplate git version info" >&2; \
 	fi
 else
 	$(warning "WARNING: Generating boilerplate git version info")
-	@sh version_git.sh NO_GIT > version_git.jl
+	@sh $(SRCDIR)/version_git.sh $(SRCDIR) NO_GIT > $(BUILDDIR)/version_git.jl
 endif
 endif
 
-.PHONY: build_h.jl.phony version_git.jl.phony
-
-
+.PHONY: $(BUILDDIR)/build_h.jl.phony $(BUILDDIR)/version_git.jl.phony clean all
 
 clean:
-	rm -f *# *~
-	rm -f pcre_h.jl
-	rm -f errno_h.jl
-	rm -f build_h.jl
-	rm -f build_h.jl.phony
-	rm -f fenv_constants.jl
-	rm -f uv_constants.jl
-	rm -f file_constants.jl
-	rm -f version_git.jl
-	rm -f version_git.jl.phony
+	rm -f $(BUILDDIR)/pcre_h.jl
+	rm -f $(BUILDDIR)/errno_h.jl
+	rm -f $(BUILDDIR)/build_h.jl
+	rm -f $(BUILDDIR)/build_h.jl.phony
+	rm -f $(BUILDDIR)/fenv_constants.jl
+	rm -f $(BUILDDIR)/uv_constants.jl
+	rm -f $(BUILDDIR)/file_constants.jl
+	rm -f $(BUILDDIR)/version_git.jl
+	rm -f $(BUILDDIR)/version_git.jl.phony
diff --git a/base/REPL.jl b/base/REPL.jl
index 267ba1d4cbd2d..78135c082da20 100644
--- a/base/REPL.jl
+++ b/base/REPL.jl
@@ -13,7 +13,6 @@ export
     StreamREPL
 
 import Base:
-    AsyncStream,
     Display,
     display,
     writemime,
@@ -58,10 +57,10 @@ function eval_user_input(ast::ANY, backend::REPLBackend)
                 ans = backend.ans
                 # note: value wrapped in a non-syntax value to avoid evaluating
                 # possibly-invalid syntax (issue #6763).
+                eval(Main, :(ans = $(getindex)($(Any[ans]), 1)))
                 backend.in_eval = true
-                eval(Main, :(ans = $(Any[ans])[1]))
-                backend.in_eval = false
                 value = eval(Main, ast)
+                backend.in_eval = false
                 backend.ans = value
                 put!(backend.response_channel, (value, nothing))
             end
@@ -160,10 +159,11 @@ immutable REPLBackendRef
     response_channel::Channel
 end
 
-function run_repl(repl::AbstractREPL)
+function run_repl(repl::AbstractREPL, consumer = x->nothing)
     repl_channel = Channel(1)
     response_channel = Channel(1)
     backend = start_repl_backend(repl_channel, response_channel)
+    consumer(backend)
     run_frontend(repl, REPLBackendRef(repl_channel,response_channel))
     backend
 end
@@ -385,7 +385,7 @@ function add_history(hist::REPLHistoryProvider, s)
     str = rstrip(bytestring(s.input_buffer))
     isempty(strip(str)) && return
     mode = mode_idx(hist, LineEdit.mode(s))
-    length(hist.history) > 0 &&
+    !isempty(hist.history) &&
         mode == hist.modes[end] && str == hist.history[end] && return
     push!(hist.modes, mode)
     push!(hist.history, str)
@@ -507,7 +507,7 @@ function history_move_prefix(s::LineEdit.PrefixSearchState,
         if (idx == max_idx) || (startswith(hist.history[idx], prefix) && (hist.history[idx] != cur_response || hist.modes[idx] != LineEdit.mode(s)))
             m = history_move(s, hist, idx)
             if m == :ok
-                if length(prefix) == 0
+                if isempty(prefix)
                     # on empty prefix search, move cursor to the end
                     LineEdit.move_input_end(s)
                 else
@@ -538,18 +538,18 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
 
     # Alright, first try to see if the current match still works
     a = position(response_buffer) + 1
-    b = a + sizeof(searchdata) - 1
-    if !skip_current && (0 < a <= b <= response_buffer.size) &&
-       searchdata == bytestring(response_buffer.data[a:b])
-        return true
-    end
+    b = min(endof(response_str), prevind(response_str, a + sizeof(searchdata)))
+
+    !skip_current && searchdata == response_str[a:b] && return true
 
-    searchfunc,delta = backwards ? (rsearch,0) : (search,1)
+    searchfunc, searchstart, skipfunc = backwards ? (rsearch, b, prevind) :
+                                                    (search,  a, nextind)
+    skip_current && (searchstart = skipfunc(response_str, searchstart))
 
     # Start searching
     # First the current response buffer
-    if 1 <= a+delta <= length(response_str)
-        match = searchfunc(response_str, searchdata, a+delta)
+    if 1 <= searchstart <= endof(response_str)
+        match = searchfunc(response_str, searchdata, searchstart)
         if match != 0:-1
             seek(response_buffer, first(match)-1)
             return true
@@ -574,8 +574,10 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
 end
 
 function history_reset_state(hist::REPLHistoryProvider)
-    hist.last_idx = hist.cur_idx
-    hist.cur_idx = length(hist.history) + 1
+    if hist.cur_idx != length(hist.history) + 1
+        hist.last_idx = hist.cur_idx
+        hist.cur_idx = length(hist.history) + 1
+    end
 end
 LineEdit.reset_state(hist::REPLHistoryProvider) = history_reset_state(hist)
 
@@ -711,14 +713,7 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
         keymap_func_data = repl,
         complete = replc,
         # When we're done transform the entered line into a call to help("$line")
-        on_done = respond(repl, julia_prompt) do line
-            line = strip(line)
-            haskey(Docs.keywords, symbol(line)) ? # Special-case keywords, which won't parse
-                :(Base.Docs.@repl $(symbol(line))) :
-                Base.syntax_deprecation_warnings(false) do
-                    parse("Base.Docs.@repl $line", raise=false)
-                end
-        end)
+        on_done = respond(Docs.helpmode, repl, julia_prompt))
 
     # Set up shell mode
     shell_mode = Prompt("shell> ";
@@ -734,6 +729,7 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
             Expr(:call, :(Base.repl_cmd), macroexpand(Expr(:macrocall, symbol("@cmd"),line)), outstream(repl))
         end)
 
+
     ################################# Stage II #############################
 
     # Setup history
@@ -795,7 +791,7 @@ function setup_interface(repl::LineEditREPL; hascolor = repl.hascolor, extra_rep
             edit_insert(buf, input)
             string = takebuf_string(buf)
             curspos = position(LineEdit.buffer(s))
-            pos = 0
+            pos = 1
             inputsz = sizeof(input)
             sz = sizeof(string)
             while pos <= sz
@@ -884,7 +880,7 @@ end
 
 outstream(s::StreamREPL) = s.stream
 
-StreamREPL(stream::AsyncStream) = StreamREPL(stream, julia_green, Base.text_colors[:white], Base.answer_color())
+StreamREPL(stream::IO) = StreamREPL(stream, julia_green, Base.text_colors[:white], Base.answer_color())
 
 answer_color(r::LineEditREPL) = r.envcolors ? Base.answer_color() : r.answer_color
 answer_color(r::StreamREPL) = r.answer_color
@@ -892,7 +888,7 @@ input_color(r::LineEditREPL) = r.envcolors ? Base.input_color() : r.input_color
 input_color(r::StreamREPL) = r.input_color
 
 
-function run_repl(stream::AsyncStream)
+function run_repl(stream::IO)
     repl =
     @async begin
         repl_channel = Channel(1)
diff --git a/base/REPLCompletions.jl b/base/REPLCompletions.jl
index 967340b779bf3..c59e5ae190085 100644
--- a/base/REPLCompletions.jl
+++ b/base/REPLCompletions.jl
@@ -95,10 +95,10 @@ end
 function complete_keyword(s::ByteString)
     const sorted_keywords = [
         "abstract", "baremodule", "begin", "bitstype", "break", "catch", "ccall",
-        "const", "continue", "do", "else", "elseif", "end", "export", "finally",
-        "for", "function", "global", "if", "immutable", "import", "importall",
-        "let", "local", "macro", "module", "quote", "return", "try", "type",
-        "typealias", "using", "while"]
+        "const", "continue", "do", "else", "elseif", "end", "export", "false",
+        "finally", "for", "function", "global", "if", "immutable", "import",
+        "importall", "let", "local", "macro", "module", "quote", "return",
+        "true", "try", "type", "typealias", "using", "while"]
     r = searchsorted(sorted_keywords, s)
     i = first(r)
     n = length(sorted_keywords)
@@ -109,7 +109,7 @@ function complete_keyword(s::ByteString)
     sorted_keywords[r]
 end
 
-function complete_path(path::AbstractString, pos)
+function complete_path(path::AbstractString, pos; use_envpath=false)
     if Base.is_unix(OS_NAME) && ismatch(r"^~(?:/|$)", path)
         # if the path is just "~", don't consider the expanded username as a prefix
         if path == "~"
@@ -122,7 +122,7 @@ function complete_path(path::AbstractString, pos)
     end
     local files
     try
-        if length(dir) == 0
+        if isempty(dir)
             files = readdir()
         elseif isdir(dir)
             files = readdir(dir)
@@ -133,7 +133,7 @@ function complete_path(path::AbstractString, pos)
         return UTF8String[], 0:-1, false
     end
 
-    matches = UTF8String[]
+    matches = Set{UTF8String}()
     for file in files
         if startswith(file, prefix)
             id = try isdir(joinpath(dir, file)) catch; false end
@@ -141,12 +141,55 @@ function complete_path(path::AbstractString, pos)
             push!(matches, id ? file * (@windows? "\\\\" : "/") : file)
         end
     end
-    matches = UTF8String[replace(s, r"\s", "\\ ") for s in matches]
+
+    if use_envpath && length(dir) == 0
+        # Look for files in PATH as well
+        local pathdirs = split(ENV["PATH"], @unix? ":" : ";")
+
+        for pathdir in pathdirs
+            local actualpath
+            try
+                actualpath = realpath(pathdir)
+            catch
+                # Bash doesn't expect every folder in PATH to exist, so neither shall we
+                continue
+            end
+
+            if actualpath != pathdir && in(actualpath,pathdirs)
+                # Remove paths which (after resolving links) are in the env path twice.
+                # Many distros eg. point /bin to /usr/bin but have both in the env path.
+                continue
+            end
+
+            local filesinpath
+            try
+                filesinpath = readdir(pathdir)
+            catch e
+                # Bash allows dirs in PATH that can't be read, so we should as well.
+                if isa(e, SystemError)
+                    continue
+                else
+                    # We only handle SystemErrors here
+                    rethrow(e)
+                end
+            end
+
+            for file in filesinpath
+                # In a perfect world, we would filter on whether the file is executable
+                # here, or even on whether the current user can execute the file in question.
+                if startswith(file, prefix) && isfile(joinpath(pathdir, file))
+                    push!(matches, file)
+                end
+            end
+        end
+    end
+
+    matchList = UTF8String[replace(s, r"\s", "\\ ") for s in matches]
     startpos = pos - endof(prefix) + 1 - length(matchall(r" ", prefix))
     # The pos - endof(prefix) + 1 is correct due to `endof(prefix)-endof(prefix)==0`,
     # hence we need to add one to get the first index. This is also correct when considering
     # pos, because pos is the `endof` a larger string which `endswith(path)==true`.
-    return matches, startpos:pos, length(matches) > 0
+    return matchList, startpos:pos, !isempty(matchList)
 end
 
 # Determines whether method_complete should be tried. It should only be done if
@@ -222,20 +265,71 @@ get_value(sym::Symbol, fn) = isdefined(fn, sym) ? (fn.(sym), true) : (nothing, f
 get_value(sym::QuoteNode, fn) = isdefined(fn, sym.value) ? (fn.(sym.value), true) : (nothing, false)
 get_value(sym, fn) = sym, true
 
+# Return the value of a getfield call expression
+function get_value_getfield(ex::Expr, fn)
+    # Example :((top(getfield))(Base,:max))
+    val, found = get_value_getfield(ex.args[2],fn) #Look up Base in Main and returns the module
+    found || return (nothing, false)
+    get_value_getfield(ex.args[3],val) #Look up max in Base and returns the function if found.
+end
+get_value_getfield(sym, fn) = get_value(sym, fn)
+# Determines the return type with Base.return_types of a function call using the type information of the arguments.
+function get_type_call(expr::Expr)
+    f_name = expr.args[1]
+    # The if statement should find the f function. How f is found depends on how f is referenced
+    if isa(f_name, TopNode)
+        f = Base.(f_name.name)
+        found = true
+    elseif isa(f_name, Expr) && f_name.args[1] === TopNode(:getfield)
+        f, found = get_value_getfield(f_name, Main)
+    else
+        f, found = get_value(f_name, Main)
+    end
+    found || return (Any, false) # If the function f is not found return Any.
+    args = Any[]
+    for ex in expr.args[2:end] # Find the type of the function arguments
+        typ, found = get_type(ex, Main)
+        found ? push!(args, typ) : push!(args, Any)
+    end
+    return_types = Base.return_types(f,Tuple{args...})
+    length(return_types) == 1 || return (Any, false)
+    return (return_types[1], true)
+end
+# Returns the return type. example: get_type(:(Base.strip("",' ')),Main) returns (ASCIIString,true)
+function get_type(sym::Expr, fn)
+    sym=expand(sym)
+    val, found = get_value(sym, fn)
+    found && return Base.typesof(val).parameters[1], found
+    if sym.head === :call
+        # getfield call is special cased as the evaluation of getfield provides good type information,
+        # is inexpensive and it is also performed in the complete_symbol function.
+        if sym.args[1] === TopNode(:getfield)
+            val, found = get_value_getfield(sym, Main)
+            return found ? Base.typesof(val).parameters[1] : Any, found
+        end
+        return get_type_call(sym)
+    end
+    (Any, false)
+end
+function get_type(sym, fn)
+    val, found = get_value(sym, fn)
+    return found ? Base.typesof(val).parameters[1] : Any, found
+end
 # Method completion on function call expression that look like :(max(1))
 function complete_methods(ex_org::Expr)
     args_ex = DataType[]
     func, found = get_value(ex_org.args[1], Main)
-    (!found || (found && !isgeneric(func))) && return UTF8String[]
+    !found && return UTF8String[]
     for ex in ex_org.args[2:end]
-        val, found = get_value(ex, Main)
-        found ? push!(args_ex, Base.typesof(val).parameters[1]) : push!(args_ex, Any)
+        val, found = get_type(ex, Main)
+        push!(args_ex, val)
     end
     out = UTF8String[]
-    t_in = Tuple{args_ex...} # Input types
+    t_in = Tuple{Core.Typeof(func), args_ex...} # Input types
+    na = length(args_ex)+1
     for method in methods(func)
         # Check if the method's type signature intersects the input types
-        typeintersect(Tuple{method.sig.parameters[1 : min(length(args_ex), end)]...}, t_in) != Union{} &&
+        typeintersect(Tuple{method.sig.parameters[1 : min(na, end)]...}, t_in) != Union{} &&
             push!(out,string(method))
     end
     return out
@@ -390,8 +484,18 @@ function shell_completions(string, pos)
     isempty(args.args[end].args) && return UTF8String[], 0:-1, false
     arg = args.args[end].args[end]
     if all(s -> isa(s, AbstractString), args.args[end].args)
-        # Treat this as a path (perhaps give a list of commands in the future as well?)
-        return complete_path(join(args.args[end].args), pos)
+        # Treat this as a path
+
+        # As Base.shell_parse throws away trailing spaces (unless they are escaped),
+        # we need to special case here.
+        # If the last char was a space, but shell_parse ignored it search on "".
+        ignore_last_word = arg != " " && scs[end] == ' '
+        prefix = ignore_last_word ? "" : join(args.args[end].args)
+
+        # Also try looking into the env path if the user wants to complete the first argument
+        use_envpath = !ignore_last_word && length(args.args) < 2
+
+        return complete_path(prefix, pos, use_envpath=use_envpath)
     elseif isexpr(arg, :escape) && (isexpr(arg.args[1], :incomplete) || isexpr(arg.args[1], :error))
         r = first(last_parse):prevind(last_parse, last(last_parse))
         partial = scs[r]
diff --git a/base/Terminals.jl b/base/Terminals.jl
index 1499c38ce6ef8..433a0933304b0 100644
--- a/base/Terminals.jl
+++ b/base/Terminals.jl
@@ -22,34 +22,30 @@ export
     getY,
     hascolor,
     pos,
-    raw!,
-    writepos
+    raw!
 
 import Base:
+    check_open, # stream.jl
+    displaysize,
     flush,
+    pipe_reader,
+    pipe_writer,
     read,
     readuntil,
-    size,
-    start_reading,
-    stop_reading,
-    write,
-    writemime,
-    reseteof,
-    eof,
-    check_open # stream.jl
+    writemime
 
 ## TextTerminal ##
 
-abstract TextTerminal <: Base.IO
+abstract TextTerminal <: Base.AbstractPipe
 
 # INTERFACE
-size(::TextTerminal) = error("Unimplemented")
-writepos(t::TextTerminal, x, y, s::Array{UInt8,1}) = error("Unimplemented")
+pipe_reader(::TextTerminal) = error("Unimplemented")
+pipe_writer(::TextTerminal) = error("Unimplemented")
+displaysize(::TextTerminal) = error("Unimplemented")
 cmove(t::TextTerminal, x, y) = error("Unimplemented")
 getX(t::TextTerminal) = error("Unimplemented")
 getY(t::TextTerminal) = error("Unimplemented")
 pos(t::TextTerminal) = (getX(t), getY(t))
-reseteof(t::TextTerminal) = nothing
 
 # Relative moves (Absolute position fallbacks)
 cmove_up(t::TextTerminal, n) = cmove(getX(t), max(1, getY(t)-n))
@@ -76,20 +72,8 @@ cmove_col(t::TextTerminal, c) = cmove(c, getY(t))
 hascolor(::TextTerminal) = false
 
 # Utility Functions
-function writepos{T}(t::TextTerminal, x, y, b::Array{T})
-    if isbits(T)
-        writepos(t, x, y, reinterpret(UInt8, b))
-    else
-        cmove(t, x, y)
-        invoke(write, Tuple{IO, Array}, s, a)
-    end
-end
-function writepos(t::TextTerminal, x, y, args...)
-    cmove(t, x, y)
-    write(t, args...)
-end
-width(t::TextTerminal) = size(t)[2]
-height(t::TextTerminal) = size(t)[1]
+width(t::TextTerminal) = displaysize(t)[2]
+height(t::TextTerminal) = displaysize(t)[1]
 
 # For terminals with buffers
 flush(t::TextTerminal) = nothing
@@ -108,6 +92,9 @@ disable_bracketed_paste(t::TextTerminal) = nothing
 
 abstract UnixTerminal <: TextTerminal
 
+pipe_reader(t::UnixTerminal) = t.in_stream
+pipe_writer(t::UnixTerminal) = t.out_stream
+
 type TerminalBuffer <: UnixTerminal
     out_stream::Base.IO
 end
@@ -119,8 +106,6 @@ type TTYTerminal <: UnixTerminal
     err_stream::Base.TTY
 end
 
-reseteof(t::TTYTerminal) = reseteof(t.in_stream)
-
 const CSI = "\x1b["
 
 cmove_up(t::UnixTerminal, n) = write(t.out_stream, "$(CSI)$(n)A")
@@ -131,14 +116,10 @@ cmove_line_up(t::UnixTerminal, n) = (cmove_up(t, n); cmove_col(t, 0))
 cmove_line_down(t::UnixTerminal, n) = (cmove_down(t, n); cmove_col(t, 0))
 cmove_col(t::UnixTerminal, n) = write(t.out_stream, "$(CSI)$(n)G")
 
-@windows_only begin
-    ispty(s::Base.TTY) = s.ispty
-    ispty(s) = false
-end
 @windows ? begin
     function raw!(t::TTYTerminal,raw::Bool)
         check_open(t.in_stream)
-        if ispty(t.in_stream)
+        if Base.ispty(t.in_stream)
             run(if raw
                     `stty raw -echo onlcr -ocrnl opost`
                 else
@@ -162,46 +143,22 @@ disable_bracketed_paste(t::UnixTerminal) = write(t.out_stream, "$(CSI)?2004l")
 end_keypad_transmit_mode(t::UnixTerminal) = # tput rmkx
     write(t.out_stream, "$(CSI)?1l\x1b>")
 
-let s = zeros(Int32, 2)
-    function Base.size(t::TTYTerminal)
-        @windows_only if ispty(t.out_stream)
-            try
-                h,w = map(x->parse(Int,x),split(readall(open(`stty size`, "r", t.out_stream)[1])))
-                w > 0 || (w = 80)
-                h > 0 || (h = 24)
-                return h,w
-            catch
-                return 24,80
-            end
-        end
-        Base.uv_error("size (TTY)", ccall(:uv_tty_get_winsize,
-                                          Int32, (Ptr{Void}, Ptr{Int32}, Ptr{Int32}),
-                                          t.out_stream.handle, pointer(s,1), pointer(s,2)) != 0)
-        w,h = s[1],s[2]
-        w > 0 || (w = 80)
-        h > 0 || (h = 24)
-        (Int(h),Int(w))
-    end
+function Base.displaysize(t::UnixTerminal)
+    return displaysize(t.out_stream)
 end
 
 clear(t::UnixTerminal) = write(t.out_stream, "\x1b[H\x1b[2J")
 clear_line(t::UnixTerminal) = write(t.out_stream, "\x1b[0G\x1b[0K")
 #beep(t::UnixTerminal) = write(t.err_stream,"\x7")
 
-write{T,N}(t::UnixTerminal, a::Array{T,N}) = write(t.out_stream, a)
-write(t::UnixTerminal, p::Ptr{UInt8}) = write(t.out_stream, p)
-write(t::UnixTerminal, p::Ptr{UInt8}, x::Integer) = write(t.out_stream, p, x)
-write(t::UnixTerminal, x::UInt8) = write(t.out_stream, x)
-read{T,N}(t::UnixTerminal, x::Array{T,N}) = read(t.in_stream, x)
-readuntil(t::UnixTerminal, s::AbstractString) = readuntil(t.in_stream, s)
-readuntil(t::UnixTerminal, c::Char) = readuntil(t.in_stream, c)
-readuntil(t::UnixTerminal, s) = readuntil(t.in_stream, s)
-read(t::UnixTerminal, ::Type{UInt8}) = read(t.in_stream, UInt8)
-start_reading(t::UnixTerminal) = start_reading(t.in_stream)
-stop_reading(t::UnixTerminal) = stop_reading(t.in_stream)
-eof(t::UnixTerminal) = eof(t.in_stream)
-
-@unix_only hascolor(t::TTYTerminal) = (startswith(t.term_type, "xterm") || success(`tput setaf 0`))
+@unix_only function hascolor(t::TTYTerminal)
+    startswith(t.term_type, "xterm") && return true
+    try
+        return success(`tput setaf 0`)
+    catch
+        return false
+    end
+end
 @windows_only hascolor(t::TTYTerminal) = true
 
 end # module
diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index f202fe6e7067c..7fd228855bd3d 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -57,10 +57,10 @@ eltype{T,n}(::Type{AbstractArray{T,n}}) = T
 elsize{T}(::AbstractArray{T}) = sizeof(T)
 ndims{T,n}(::AbstractArray{T,n}) = n
 ndims{T,n}(::Type{AbstractArray{T,n}}) = n
-ndims{T<:AbstractArray}(::Type{T}) = ndims(super(T))
+ndims{T<:AbstractArray}(::Type{T}) = ndims(supertype(T))
 length(t::AbstractArray) = prod(size(t))::Int
 endof(a::AbstractArray) = length(a)
-first(a::AbstractArray) = a[1]
+first(a::AbstractArray) = a[first(eachindex(a))]
 
 function first(itr)
     state = start(itr)
@@ -117,15 +117,6 @@ linearindexing(A::AbstractArray, B::AbstractArray...) = linearindexing(linearind
 linearindexing(::LinearFast, ::LinearFast) = LinearFast()
 linearindexing(::LinearIndexing, ::LinearIndexing) = LinearSlow()
 
-# The real @inline macro is not available this early in the bootstrap, so this
-# internal macro splices the meta Expr directly into the function body.
-macro _inline_meta()
-    Expr(:meta, :inline)
-end
-macro _noinline_meta()
-    Expr(:meta, :noinline)
-end
-
 ## Bounds checking ##
 @generated function trailingsize{T,N,n}(A::AbstractArray{T,N}, ::Type{Val{n}})
     n > N && return 1
@@ -140,7 +131,7 @@ checkbounds(::Type{Bool}, sz::Integer, i) = throw(ArgumentError("unable to check
 checkbounds(::Type{Bool}, sz::Integer, i::Real) = 1 <= i <= sz
 checkbounds(::Type{Bool}, sz::Integer, ::Colon) = true
 function checkbounds(::Type{Bool}, sz::Integer, r::Range)
-    @_inline_meta
+    @_propagate_inbounds_meta
     isempty(r) || (checkbounds(Bool, sz, minimum(r)) && checkbounds(Bool, sz, maximum(r)))
 end
 checkbounds(::Type{Bool}, sz::Integer, I::AbstractArray{Bool}) = length(I) == sz
@@ -198,13 +189,14 @@ end
 ## Constructors ##
 
 # default arguments to similar()
-similar{T}(a::AbstractArray{T})               = similar(a, T, size(a))
-similar(   a::AbstractArray, T)               = similar(a, T, size(a))
-similar{T}(a::AbstractArray{T}, dims::Dims)   = similar(a, T, dims)
-similar{T}(a::AbstractArray{T}, dims::Int...) = similar(a, T, dims)
-similar(   a::AbstractArray, T, dims::Int...) = similar(a, T, dims)
+similar{T}(a::AbstractArray{T})                          = similar(a, T)
+similar(   a::AbstractArray, T::Type)                    = similar(a, T, size(a))
+similar{T}(a::AbstractArray{T}, dims::DimsInteger)       = similar(a, T, dims)
+similar{T}(a::AbstractArray{T}, dims::Integer...)        = similar(a, T, dims)
+similar(   a::AbstractArray, T::Type, dims::Integer...)  = similar(a, T, dims)
 # similar creates an Array by default
-similar(   a::AbstractArray, T, dims::Dims)   = Array(T, dims)
+similar(   a::AbstractArray, T::Type, dims::DimsInteger) = Array(T, dims...)
+similar(   a::AbstractArray, T::Type, dims::Dims)        = Array(T, dims)
 
 function reshape(a::AbstractArray, dims::Dims)
     if prod(dims) != length(a)
@@ -230,10 +222,10 @@ function copy!(dest::AbstractArray, doffs::Integer, src)
     doffs < 1 && throw(BoundsError(dest, doffs))
     st = start(src)
     i, dmax = doffs, length(dest)
-    @inbounds while !done(src, st)
+    while !done(src, st)
         i > dmax && throw(BoundsError(dest, i))
         val, st = next(src, st)
-        dest[i] = val
+        @inbounds dest[i] = val
         i += 1
     end
     return dest
@@ -259,10 +251,10 @@ function copy!(dest::AbstractArray, doffs::Integer, src, soffs::Integer)
                                       "expected at least ",soffs,", got ",soffs-1)))
     end
     i, dmax = doffs, length(dest)
-    @inbounds while !dn
+    while !dn
         i > dmax && throw(BoundsError(dest, i))
         val, st = next(src, st)
-        dest[i] = val
+        @inbounds dest[i] = val
         i += 1
         dn = done(src, st)
     end
@@ -288,9 +280,9 @@ function copy!(dest::AbstractArray, doffs::Integer, src, soffs::Integer, n::Inte
         _, st = next(src, st)
     end
     i = doffs
-    @inbounds while i <= dmax && !done(src, st)
+    while i <= dmax && !done(src, st)
         val, st = next(src, st)
-        dest[i] = val
+        @inbounds dest[i] = val
         i += 1
     end
     i <= dmax && throw(BoundsError(dest, i))
@@ -300,7 +292,10 @@ end
 ## copy between abstract arrays - generally more efficient
 ## since a single index variable can be used.
 
-function copy!(dest::AbstractArray, src::AbstractArray)
+copy!(dest::AbstractArray, src::AbstractArray) =
+    copy!(linearindexing(dest), dest, linearindexing(src), src)
+
+function copy!(::LinearIndexing, dest::AbstractArray, ::LinearIndexing, src::AbstractArray)
     n = length(src)
     n > length(dest) && throw(BoundsError(dest, n))
     @inbounds for i = 1:n
@@ -309,6 +304,16 @@ function copy!(dest::AbstractArray, src::AbstractArray)
     return dest
 end
 
+function copy!(::LinearIndexing, dest::AbstractArray, ::LinearSlow, src::AbstractArray)
+    n = length(src)
+    n > length(dest) && throw(BoundsError(dest, n))
+    i = 0
+    @inbounds for a in src
+        dest[i+=1] = a
+    end
+    return dest
+end
+
 function copy!(dest::AbstractArray, doffs::Integer, src::AbstractArray)
     copy!(dest, doffs, src, 1, length(src))
 end
@@ -345,8 +350,8 @@ function copy!{R,S}(B::AbstractVecOrMat{R}, ir_dest::Range{Int}, jr_dest::Range{
         throw(ArgumentError(string("source and destination must have same size (got ",
                                    length(jr_src)," and ",length(jr_dest),")")))
     end
-    checkbounds(B, ir_dest, jr_dest)
-    checkbounds(A, ir_src, jr_src)
+    @boundscheck checkbounds(B, ir_dest, jr_dest)
+    @boundscheck checkbounds(A, ir_src, jr_src)
     jdest = first(jr_dest)
     for jsrc in jr_src
         idest = first(ir_dest)
@@ -369,8 +374,8 @@ function copy_transpose!{R,S}(B::AbstractVecOrMat{R}, ir_dest::Range{Int}, jr_de
         throw(ArgumentError(string("source and destination must have same size (got ",
                                    length(ir_src)," and ",length(jr_dest),")")))
     end
-    checkbounds(B, ir_dest, jr_dest)
-    checkbounds(A, ir_src, jr_src)
+    @boundscheck checkbounds(B, ir_dest, jr_dest)
+    @boundscheck checkbounds(A, ir_src, jr_src)
     idest = first(ir_dest)
     for jsrc in jr_src
         jdest = first(jr_dest)
@@ -397,7 +402,6 @@ done(A::AbstractArray,i) = done(i[1], i[2])
 
 # eachindex iterates over all indices. LinearSlow definitions are later.
 eachindex(A::AbstractArray) = (@_inline_meta(); eachindex(linearindexing(A), A))
-eachindex(::LinearFast, A::AbstractArray) = 1:length(A)
 
 function eachindex(A::AbstractArray, B::AbstractArray)
     @_inline_meta
@@ -407,8 +411,16 @@ function eachindex(A::AbstractArray, B::AbstractArray...)
     @_inline_meta
     eachindex(linearindexing(A,B...), A, B...)
 end
-eachindex(::LinearFast, A::AbstractArray, B::AbstractArray) = 1:max(length(A),length(B))
-eachindex(::LinearFast, A::AbstractArray, B::AbstractArray...) = 1:max(length(A), map(length, B)...)
+eachindex(::LinearFast, A::AbstractArray) = 1:length(A)
+function eachindex(::LinearFast, A::AbstractArray, B::AbstractArray...)
+    @_inline_meta
+    1:_maxlength(A, B...)
+end
+_maxlength(A) = length(A)
+function _maxlength(A, B, C...)
+    @_inline_meta
+    max(length(A), _maxlength(B, C...))
+end
 
 isempty(a::AbstractArray) = (length(a) == 0)
 
@@ -458,47 +470,35 @@ pointer{T}(x::AbstractArray{T}, i::Integer) = (@_inline_meta; unsafe_convert(Ptr
 # but that isn't as obvious and would require that the function be inlined to
 # avoid allocations.  If the subtype hasn't defined those methods, it goes back
 # to the _getindex function where an error is thrown to prevent stack overflows.
-#
-# We use the same scheme for unsafe_getindex, with the exception that we can
-# fallback to the safe version if the subtype hasn't defined the required
-# unsafe method.
 
 function getindex(A::AbstractArray, I...)
-    @_inline_meta
+    @_propagate_inbounds_meta
     _getindex(linearindexing(A), A, I...)
 end
 function unsafe_getindex(A::AbstractArray, I...)
     @_inline_meta
-    _unsafe_getindex(linearindexing(A), A, I...)
+    @inbounds r = getindex(A, I...)
+    r
 end
 ## Internal defitions
 # 0-dimensional indexing is defined to prevent ambiguities. LinearFast is easy:
-_getindex(::LinearFast, A::AbstractArray) = (@_inline_meta; getindex(A, 1))
+_getindex(::LinearFast, A::AbstractArray) = (@_propagate_inbounds_meta; getindex(A, 1))
 # But LinearSlow must take into account the dimensionality of the array:
 _getindex{T}(::LinearSlow, A::AbstractArray{T,0}) = error("indexing not defined for ", typeof(A))
-_getindex(::LinearSlow, A::AbstractVector) = (@_inline_meta; getindex(A, 1))
-_getindex(l::LinearSlow, A::AbstractArray) = (@_inline_meta; _getindex(l, A, 1))
-_unsafe_getindex(::LinearFast, A::AbstractArray) = (@_inline_meta; unsafe_getindex(A, 1))
-_unsafe_getindex{T}(::LinearSlow, A::AbstractArray{T,0}) = error("indexing not defined for ", typeof(A))
-_unsafe_getindex(::LinearSlow, A::AbstractVector) = (@_inline_meta; unsafe_getindex(A, 1))
-_unsafe_getindex(l::LinearSlow, A::AbstractArray) = (@_inline_meta; _unsafe_getindex(l, A, 1))
+_getindex(::LinearSlow, A::AbstractVector) = (@_propagate_inbounds_meta; getindex(A, 1))
+_getindex(l::LinearSlow, A::AbstractArray) = (@_propagate_inbounds_meta; _getindex(l, A, 1))
 
 _getindex(::LinearIndexing, A::AbstractArray, I...) = error("indexing $(typeof(A)) with types $(typeof(I)) is not supported")
-_unsafe_getindex(::LinearIndexing, A::AbstractArray, I...) = (@_inline_meta; getindex(A, I...))
 
 ## LinearFast Scalar indexing
 _getindex(::LinearFast, A::AbstractArray, I::Int) = error("indexing not defined for ", typeof(A))
 function _getindex(::LinearFast, A::AbstractArray, I::Real...)
     @_inline_meta
-    # We must check bounds for sub2ind; so we can then call unsafe_getindex
+    # We must check bounds for sub2ind; so we can then use @inbounds
     J = to_indexes(I...)
-    checkbounds(A, J...)
-    unsafe_getindex(A, sub2ind(size(A), J...))
-end
-_unsafe_getindex(::LinearFast, A::AbstractArray, I::Real) = (@_inline_meta; getindex(A, I))
-function _unsafe_getindex(::LinearFast, A::AbstractArray, I::Real...)
-    @_inline_meta
-    unsafe_getindex(A, sub2ind(size(A), to_indexes(I...)...))
+    @boundscheck checkbounds(A, J...)
+    @inbounds r = getindex(A, sub2ind(size(A), J...))
+    r
 end
 
 # LinearSlow Scalar indexing
@@ -508,15 +508,16 @@ end
         if all(x->x===Int, I)
             :(error("indexing not defined for ", typeof(A)))
         else
-            :($(Expr(:meta, :inline)); getindex(A, to_indexes(I...)...))
+            :(@_propagate_inbounds_meta; getindex(A, to_indexes(I...)...))
         end
     elseif N > AN
         # Drop trailing ones
         Isplat = Expr[:(I[$d]) for d = 1:AN]
         Osplat = Expr[:(to_index(I[$d]) == 1) for d = AN+1:N]
         quote
-            $(Expr(:meta, :inline))
-            (&)($(Osplat...)) || throw_boundserror(A, I)
+            # We only check the trailing ones, so just propagate @inbounds state
+            @_propagate_inbounds_meta
+            @boundscheck (&)($(Osplat...)) || throw_boundserror(A, I)
             getindex(A, $(Isplat...))
         end
     else
@@ -530,77 +531,43 @@ end
         sz.args = Expr[:(size(A, $d)) for d=N:AN]
         szcheck = Expr[:(size(A, $d) > 0) for d=N:AN]
         quote
-            $(Expr(:meta, :inline))
             # ind2sub requires all dimensions to be > 0:
-            (&)($(szcheck...)) || throw_boundserror(A, I)
+            @_propagate_inbounds_meta
+            @boundscheck (&)($(szcheck...)) || throw_boundserror(A, I)
             s = ind2sub($sz, to_index(I[$N]))
             getindex(A, $(Isplat...))
         end
     end
 end
-@generated function _unsafe_getindex{T,AN}(::LinearSlow, A::AbstractArray{T,AN}, I::Real...)
-    N = length(I)
-    if N == AN
-        :($(Expr(:meta, :inline)); getindex(A, I...))
-    elseif N > AN
-        # Drop trailing dimensions (unchecked)
-        Isplat = Expr[:(I[$d]) for d = 1:AN]
-        quote
-            $(Expr(:meta, :inline))
-            unsafe_getindex(A, $(Isplat...))
-        end
-    else
-        # Expand the last index into the appropriate number of indices
-        Isplat = Expr[:(I[$d]) for d = 1:N-1]
-        for d=N:AN
-            push!(Isplat, :(s[$(d-N+1)]))
-        end
-        sz = Expr(:tuple)
-        sz.args = Expr[:(size(A, $d)) for d=N:AN]
-        quote
-            $(Expr(:meta, :inline))
-            s = ind2sub($sz, to_index(I[$N]))
-            unsafe_getindex(A, $(Isplat...))
-        end
-    end
-end
 
 ## Setindex! is defined similarly. We first dispatch to an internal _setindex!
 # function that allows dispatch on array storage
 function setindex!(A::AbstractArray, v, I...)
-    @_inline_meta
+    @_propagate_inbounds_meta
     _setindex!(linearindexing(A), A, v, I...)
 end
 function unsafe_setindex!(A::AbstractArray, v, I...)
     @_inline_meta
-    _unsafe_setindex!(linearindexing(A), A, v, I...)
+    @inbounds r = setindex!(A, v, I...)
+    r
 end
 ## Internal defitions
-_setindex!(::LinearFast, A::AbstractArray, v) = (@_inline_meta; setindex!(A, v, 1))
+_setindex!(::LinearFast, A::AbstractArray, v) = (@_propagate_inbounds_meta; setindex!(A, v, 1))
 _setindex!{T}(::LinearSlow, A::AbstractArray{T,0}, v) = error("indexing not defined for ", typeof(A))
-_setindex!(::LinearSlow, A::AbstractVector, v) = (@_inline_meta; setindex!(A, v, 1))
-_setindex!(l::LinearSlow, A::AbstractArray, v) = (@_inline_meta; _setindex!(l, A, v, 1))
-_unsafe_setindex!(::LinearFast, A::AbstractArray, v) = (@_inline_meta; unsafe_setindex!(A, v, 1))
-_unsafe_setindex!{T}(::LinearSlow, A::AbstractArray{T,0}, v) = error("indexing not defined for ", typeof(A))
-_unsafe_setindex!(::LinearSlow, A::AbstractVector, v) = (@_inline_meta; unsafe_setindex!(A, v, 1))
-_unsafe_setindex!(l::LinearSlow, A::AbstractArray, v) = (@_inline_meta; _unsafe_setindex!(l, A, v, 1))
+_setindex!(::LinearSlow, A::AbstractVector, v) = (@_propagate_inbounds_meta; setindex!(A, v, 1))
+_setindex!(l::LinearSlow, A::AbstractArray, v) = (@_propagate_inbounds_meta; _setindex!(l, A, v, 1))
 
 _setindex!(::LinearIndexing, A::AbstractArray, v, I...) = error("indexing $(typeof(A)) with types $(typeof(I)) is not supported")
-_unsafe_setindex!(::LinearIndexing, A::AbstractArray, v, I...) = (@_inline_meta; setindex!(A, v, I...))
 
 ## LinearFast Scalar indexing
 _setindex!(::LinearFast, A::AbstractArray, v, I::Int) = error("indexed assignment not defined for ", typeof(A))
 function _setindex!(::LinearFast, A::AbstractArray, v, I::Real...)
     @_inline_meta
-    # We must check bounds for sub2ind; so we can then call unsafe_setindex!
+    # We must check bounds for sub2ind; so we can then use @inbounds
     J = to_indexes(I...)
-    checkbounds(A, J...)
-    unsafe_setindex!(A, v, sub2ind(size(A), J...))
-end
-_unsafe_setindex!(::LinearFast, A::AbstractArray, v, I::Real) = (@_inline_meta; setindex!(A, v, I))
-function _unsafe_setindex!(::LinearFast, A::AbstractArray, v, I::Real...)
-    @_inline_meta
-    unsafe_setindex!(A, v, sub2ind(size(A), to_indexes(I...)...))
+    @boundscheck checkbounds(A, J...)
+    @inbounds r = setindex!(A, v, sub2ind(size(A), J...))
+    r
 end
 
 # LinearSlow Scalar indexing
@@ -610,15 +577,16 @@ end
         if all(x->x===Int, I)
             :(error("indexing not defined for ", typeof(A)))
         else
-            :($(Expr(:meta, :inline)); setindex!(A, v, to_indexes(I...)...))
+            :(@_propagate_inbounds_meta; setindex!(A, v, to_indexes(I...)...))
         end
     elseif N > AN
         # Drop trailing ones
         Isplat = Expr[:(I[$d]) for d = 1:AN]
         Osplat = Expr[:(to_index(I[$d]) == 1) for d = AN+1:N]
         quote
-            $(Expr(:meta, :inline))
-            (&)($(Osplat...)) || throw_boundserror(A, I)
+            # We only check the trailing ones, so just propagate @inbounds state
+            @_propagate_inbounds_meta
+            @boundscheck (&)($(Osplat...)) || throw_boundserror(A, I)
             setindex!(A, v, $(Isplat...))
         end
     else
@@ -632,40 +600,14 @@ end
         sz.args = Expr[:(size(A, $d)) for d=N:AN]
         szcheck = Expr[:(size(A, $d) > 0) for d=N:AN]
         quote
-            $(Expr(:meta, :inline))
+            @_propagate_inbounds_meta
             # ind2sub requires all dimensions to be > 0:
-            (&)($(szcheck...)) || throw_boundserror(A, I)
+            @boundscheck (&)($(szcheck...)) || throw_boundserror(A, I)
             s = ind2sub($sz, to_index(I[$N]))
             setindex!(A, v, $(Isplat...))
         end
     end
 end
-@generated function _unsafe_setindex!{T,AN}(::LinearSlow, A::AbstractArray{T,AN}, v, I::Real...)
-    N = length(I)
-    if N == AN
-        :($(Expr(:meta, :inline)); setindex!(A, v, I...))
-    elseif N > AN
-        # Drop trailing dimensions (unchecked)
-        Isplat = Expr[:(I[$d]) for d = 1:AN]
-        quote
-            $(Expr(:meta, :inline))
-            unsafe_setindex!(A, v, $(Isplat...))
-        end
-    else
-        # Expand the last index into the appropriate number of indices
-        Isplat = Expr[:(I[$d]) for d = 1:N-1]
-        for d=N:AN
-            push!(Isplat, :(s[$(d-N+1)]))
-        end
-        sz = Expr(:tuple)
-        sz.args = Expr[:(size(A, $d)) for d=N:AN]
-        quote
-            $(Expr(:meta, :inline))
-            s = ind2sub($sz, to_index(I[$N]))
-            unsafe_setindex!(A, v, $(Isplat...))
-        end
-    end
-end
 
 ## get (getindex with a default value) ##
 
@@ -694,6 +636,9 @@ end
 
 get(A::AbstractArray, I::RangeVecIntList, default) = get!(similar(A, typeof(default), map(length, I)...), A, I, default)
 
+## structured matrix methods ##
+replace_in_print_matrix(A::AbstractMatrix,i::Integer,j::Integer,s::AbstractString) = s
+replace_in_print_matrix(A::AbstractVector,i::Integer,j::Integer,s::AbstractString) = s
 
 ## Concatenation ##
 
@@ -705,29 +650,29 @@ cat(catdim::Integer) = Array(Any, 0)
 
 vcat() = Array(Any, 0)
 hcat() = Array(Any, 0)
+typed_vcat(T::Type) = Array(T, 0)
+typed_hcat(T::Type) = Array(T, 0)
 
 ## cat: special cases
-hcat{T}(X::T...)         = T[ X[j] for i=1, j=1:length(X) ]
-hcat{T<:Number}(X::T...) = T[ X[j] for i=1, j=1:length(X) ]
 vcat{T}(X::T...)         = T[ X[i] for i=1:length(X) ]
 vcat{T<:Number}(X::T...) = T[ X[i] for i=1:length(X) ]
+hcat{T}(X::T...)         = T[ X[j] for i=1, j=1:length(X) ]
+hcat{T<:Number}(X::T...) = T[ X[j] for i=1, j=1:length(X) ]
 
-function vcat(X::Number...)
-    T = promote_typeof(X...)
-    hvcat_fill(Array(T,length(X)), X)
-end
+vcat(X::Number...) = hvcat_fill(Array(promote_typeof(X...),length(X)), X)
+hcat(X::Number...) = hvcat_fill(Array(promote_typeof(X...),1,length(X)), X)
+typed_vcat(T::Type, X::Number...) = hvcat_fill(Array(T,length(X)), X)
+typed_hcat(T::Type, X::Number...) = hvcat_fill(Array(T,1,length(X)), X)
 
-function hcat(X::Number...)
-    T = promote_typeof(X...)
-    hvcat_fill(Array(T,1,length(X)), X)
-end
+vcat(V::AbstractVector...) = typed_vcat(promote_eltype(V...), V...)
+vcat{T}(V::AbstractVector{T}...) = typed_vcat(T, V...)
 
-function vcat{T}(V::AbstractVector{T}...)
-    n = 0
+function typed_vcat(T::Type, V::AbstractVector...)
+    n::Int = 0
     for Vk in V
         n += length(Vk)
     end
-    a = similar(full(V[1]), n)
+    a = similar(full(V[1]), T, n)
     pos = 1
     for k=1:length(V)
         Vk = V[k]
@@ -738,7 +683,10 @@ function vcat{T}(V::AbstractVector{T}...)
     a
 end
 
-function hcat{T}(A::AbstractVecOrMat{T}...)
+hcat(A::AbstractVecOrMat...) = typed_hcat(promote_eltype(A...), A...)
+hcat{T}(A::AbstractVecOrMat{T}...) = typed_hcat(T, A...)
+
+function typed_hcat(T::Type, A::AbstractVecOrMat...)
     nargs = length(A)
     nrows = size(A[1], 1)
     ncols = 0
@@ -752,7 +700,7 @@ function hcat{T}(A::AbstractVecOrMat{T}...)
         nd = ndims(Aj)
         ncols += (nd==2 ? size(Aj,2) : 1)
     end
-    B = similar(full(A[1]), nrows, ncols)
+    B = similar(full(A[1]), T, nrows, ncols)
     pos = 1
     if dense
         for k=1:nargs
@@ -772,7 +720,10 @@ function hcat{T}(A::AbstractVecOrMat{T}...)
     return B
 end
 
-function vcat{T}(A::AbstractMatrix{T}...)
+vcat(A::AbstractMatrix...) = typed_vcat(promote_eltype(A...), A...)
+vcat{T}(A::AbstractMatrix{T}...) = typed_vcat(T, A...)
+
+function typed_vcat(T::Type, A::AbstractMatrix...)
     nargs = length(A)
     nrows = sum(a->size(a, 1), A)::Int
     ncols = size(A[1], 2)
@@ -781,7 +732,7 @@ function vcat{T}(A::AbstractMatrix{T}...)
             throw(ArgumentError("number of columns of each array must match (got $(map(x->size(x,2), A)))"))
         end
     end
-    B = similar(full(A[1]), nrows, ncols)
+    B = similar(full(A[1]), T, nrows, ncols)
     pos = 1
     for k=1:nargs
         Ak = A[k]
@@ -1013,7 +964,7 @@ function isequal(A::AbstractArray, B::AbstractArray)
     if isa(A,Range) != isa(B,Range)
         return false
     end
-    for i in eachindex(A)
+    for i in eachindex(A,B)
         if !isequal(A[i], B[i])
             return false
         end
@@ -1037,7 +988,7 @@ function (==)(A::AbstractArray, B::AbstractArray)
     if isa(A,Range) != isa(B,Range)
         return false
     end
-    for i in eachindex(A)
+    for i in eachindex(A,B)
         if !(A[i]==B[i])
             return false
         end
@@ -1124,6 +1075,18 @@ end
 
 ## iteration utilities ##
 
+"""
+    foreach(f, c...) -> Void
+
+Call function `f` on each element of iterable `c`.
+For multiple iterable arguments, `f` is called elementwise.
+`foreach` should be used instead of `map` when the results of `f` are not
+needed, for example in `foreach(println, array)`.
+"""
+foreach(f) = (f(); nothing)
+foreach(f, itr) = (for x in itr; f(x); end; nothing)
+foreach(f, itrs...) = (for z in zip(itrs...); f(z...); end; nothing)
+
 # generic map on any iterator
 function map(f, iters...)
     result = []
@@ -1217,11 +1180,12 @@ end
 function promote_to!{T,F}(f::F, offs, dest::AbstractArray{T}, A::AbstractArray)
     # map to dest array, checking the type of each result. if a result does not
     # match, do a type promotion and re-dispatch.
-    @inbounds for i = offs:length(A)
-        el = f(A[i])
+    for i = offs:length(A)
+        @inbounds Ai = A[i]
+        el = f(Ai)
         S = typeof(el)
         if S === T || S <: T
-            dest[i] = el::T
+            @inbounds dest[i] = el::T
         else
             R = promote_type(T, S)
             if R !== T
@@ -1230,7 +1194,7 @@ function promote_to!{T,F}(f::F, offs, dest::AbstractArray{T}, A::AbstractArray)
                 new[i] = el
                 return promote_to!(f, i+1, new, A)
             end
-            dest[i] = el
+            @inbounds dest[i] = el
         end
     end
     return dest
@@ -1244,6 +1208,15 @@ function map_promote(f, A::AbstractArray)
     return promote_to!(f, 2, dest, A)
 end
 
+# These are needed because map(eltype, As) is not inferrable
+promote_eltype_op(::Any) = (@_pure_meta; Bottom)
+promote_eltype_op{T}(op, ::AbstractArray{T}) = (@_pure_meta; promote_op(op, T))
+promote_eltype_op{T}(op, ::T               ) = (@_pure_meta; promote_op(op, T))
+promote_eltype_op{R,S}(op, ::AbstractArray{R}, ::AbstractArray{S}) = (@_pure_meta; promote_op(op, R, S))
+promote_eltype_op{R,S}(op, ::AbstractArray{R}, ::S) = (@_pure_meta; promote_op(op, R, S))
+promote_eltype_op{R,S}(op, ::R, ::AbstractArray{S}) = (@_pure_meta; promote_op(op, R, S))
+promote_eltype_op(op, A, B, C, D...) = (@_pure_meta; promote_op(op, eltype(A), promote_eltype_op(op, B, C, D...)))
+
 ## 1 argument
 map!{F}(f::F, A::AbstractArray) = map!(f, A, A)
 function map!{F}(f::F, dest::AbstractArray, A::AbstractArray)
@@ -1253,20 +1226,23 @@ function map!{F}(f::F, dest::AbstractArray, A::AbstractArray)
     return dest
 end
 
-function map_to!{T,F}(f::F, offs, dest::AbstractArray{T}, A::AbstractArray)
+function map_to!{T,F}(f::F, offs, st, dest::AbstractArray{T}, A)
     # map to dest array, checking the type of each result. if a result does not
     # match, widen the result type and re-dispatch.
-    @inbounds for i = offs:length(A)
-        el = f(A[i])
+    i = offs
+    while !done(A, st)
+        @inbounds Ai, st = next(A, st)
+        el = f(Ai)
         S = typeof(el)
         if S === T || S <: T
-            dest[i] = el::T
+            @inbounds dest[i] = el::T
+            i += 1
         else
             R = typejoin(T, S)
             new = similar(dest, R)
             copy!(new,1, dest,1, i-1)
-            new[i] = el
-            return map_to!(f, i+1, new, A)
+            @inbounds new[i] = el
+            return map_to!(f, i+1, st, new, A)
         end
     end
     return dest
@@ -1276,10 +1252,12 @@ function map(f, A::AbstractArray)
     if isempty(A)
         return isa(f,Type) ? similar(A,f) : similar(A)
     end
-    first = f(A[1])
+    st = start(A)
+    A1, st = next(A, st)
+    first = f(A1)
     dest = similar(A, typeof(first))
     dest[1] = first
-    return map_to!(f, 2, dest, A)
+    return map_to!(f, 2, st, dest, A)
 end
 
 ## 2 argument
@@ -1291,17 +1269,18 @@ function map!{F}(f::F, dest::AbstractArray, A::AbstractArray, B::AbstractArray)
 end
 
 function map_to!{T,F}(f::F, offs, dest::AbstractArray{T}, A::AbstractArray, B::AbstractArray)
-    @inbounds for i = offs:length(A)
-        el = f(A[i], B[i])
+    for i = offs:length(A)
+        @inbounds Ai, Bi = A[i], B[i]
+        el = f(Ai, Bi)
         S = typeof(el)
         if (S !== T) && !(S <: T)
             R = typejoin(T, S)
             new = similar(dest, R)
             copy!(new,1, dest,1, i-1)
-            new[i] = el
+            @inbounds new[i] = el
             return map_to!(f, i+1, new, A, B)
         end
-        dest[i] = el::T
+        @inbounds dest[i] = el::T
     end
     return dest
 end
@@ -1333,17 +1312,17 @@ end
 map!{F}(f::F, dest::AbstractArray, As::AbstractArray...) = map_n!(f, dest, As)
 
 function map_to_n!{T,F}(f::F, offs, dest::AbstractArray{T}, As)
-    @inbounds for i = offs:length(As[1])
+    for i = offs:length(As[1])
         el = f(ith_all(i, As)...)
         S = typeof(el)
         if (S !== T) && !(S <: T)
             R = typejoin(T, S)
             new = similar(dest, R)
             copy!(new,1, dest,1, i-1)
-            new[i] = el
+            @inbounds new[i] = el
             return map_to_n!(f, i+1, new, As)
         end
-        dest[i] = el::T
+        @inbounds dest[i] = el::T
     end
     return dest
 end
diff --git a/base/abstractarraymath.jl b/base/abstractarraymath.jl
index 7fc7a868187a3..a924a083eddd9 100644
--- a/base/abstractarraymath.jl
+++ b/base/abstractarraymath.jl
@@ -231,9 +231,7 @@ function repeat{T}(A::Array{T};
             # "Project" outer repetitions into inner repetitions
             indices_in[t] = mod1(indices_out[t], inner_size_out[t])
             # Find inner repetitions using flooring division
-            if inner[t] != 1
-                indices_in[t] = fld1(indices_in[t], inner[t])
-            end
+            indices_in[t] = fld1(indices_in[t], inner[t])
         end
         index_in = sub2ind(size_in, indices_in...)
         R[index_out] = A[index_in]
diff --git a/base/array.jl b/base/array.jl
index 26949644727a1..89596506a1206 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -10,41 +10,8 @@ typealias DenseVector{T} DenseArray{T,1}
 typealias DenseMatrix{T} DenseArray{T,2}
 typealias DenseVecOrMat{T} Union{DenseVector{T}, DenseMatrix{T}}
 
-call{T}(::Type{Vector{T}}, m::Integer) = Array{T}(m)
-call{T}(::Type{Vector{T}}) = Array{T}(0)
-call(::Type{Vector}, m::Integer) = Array{Any}(m)
-call(::Type{Vector}) = Array{Any}(0)
-
-call{T}(::Type{Matrix{T}}, m::Integer, n::Integer) = Array{T}(m, n)
-call{T}(::Type{Matrix{T}}) = Array{T}(0, 0)
-call(::Type{Matrix}, m::Integer, n::Integer) = Array{Any}(m, n)
-call(::Type{Matrix}) = Array{Any}(0, 0)
-
 ## Basic functions ##
 
-# convert Arrays to pointer arrays for ccall
-function call{P<:Ptr,T<:Ptr}(::Type{Ref{P}}, a::Array{T}) # Ref{P<:Ptr}(a::Array{T<:Ptr})
-    return RefArray(a) # effectively a no-op
-end
-function call{P<:Ptr,T}(::Type{Ref{P}}, a::Array{T}) # Ref{P<:Ptr}(a::Array)
-    if (!isbits(T) && T <: eltype(P))
-        # this Array already has the right memory layout for the requested Ref
-        return RefArray(a,1,false) # root something, so that this function is type-stable
-    else
-        ptrs = Array(P, length(a)+1)
-        roots = Array(Any, length(a))
-        for i = 1:length(a)
-            root = cconvert(P, a[i])
-            ptrs[i] = unsafe_convert(P, root)::P
-            roots[i] = root
-        end
-        ptrs[length(a)+1] = C_NULL
-        return RefArray(ptrs,1,roots)
-    end
-end
-cconvert{P<:Ptr,T<:Ptr}(::Union{Type{Ptr{P}},Type{Ref{P}}}, a::Array{T}) = a
-cconvert{P<:Ptr}(::Union{Type{Ptr{P}},Type{Ref{P}}}, a::Array) = Ref{P}(a)
-
 size(a::Array, d) = arraysize(a, d)
 size(a::Vector) = (arraysize(a,1),)
 size(a::Matrix) = (arraysize(a,1), arraysize(a,2))
@@ -183,19 +150,9 @@ function fill!(a::Union{Array{UInt8}, Array{Int8}}, x::Integer)
 end
 
 function fill!{T<:Union{Integer,AbstractFloat}}(a::Array{T}, x)
-    # note: checking bit pattern
-    xT = convert(T,x)
-    if isbits(T) && nfields(T)==0 &&
-        ((sizeof(T)==1 && reinterpret(UInt8, xT) == 0) ||
-         (sizeof(T)==2 && reinterpret(UInt16, xT) == 0) ||
-         (sizeof(T)==4 && reinterpret(UInt32, xT) == 0) ||
-         (sizeof(T)==8 && reinterpret(UInt64, xT) == 0))
-        ccall(:memset, Ptr{Void}, (Ptr{Void}, Cint, Csize_t),
-              a, 0, length(a)*sizeof(T))
-    else
-        for i in eachindex(a)
-            @inbounds a[i] = xT
-        end
+    xT = convert(T, x)
+    for i in eachindex(a)
+        @inbounds a[i] = xT
     end
     return a
 end
@@ -236,8 +193,9 @@ end
 
 convert{T,n}(::Type{Array{T}}, x::Array{T,n}) = x
 convert{T,n}(::Type{Array{T,n}}, x::Array{T,n}) = x
-convert{T,n,S}(::Type{Array{T}}, x::Array{S,n}) = convert(Array{T,n}, x)
-convert{T,n,S}(::Type{Array{T,n}}, x::Array{S,n}) = copy!(similar(x,T), x)
+
+convert{T,n,S}(::Type{Array{T}}, x::AbstractArray{S, n}) = convert(Array{T, n}, x)
+convert{T,n,S}(::Type{Array{T,n}}, x::AbstractArray{S,n}) = copy!(Array(T, size(x)), x)
 
 promote_rule{T,n,S}(::Type{Array{T,n}}, ::Type{Array{S,n}}) = Array{promote_type(T,S),n}
 
@@ -274,7 +232,7 @@ collect(itr) = collect(eltype(itr), itr)
 ## Iteration ##
 start(A::Array) = 1
 next(a::Array,i) = (a[i],i+1)
-done(a::Array,i) = (i > length(a))
+done(a::Array,i) = i == length(a)+1
 
 ## Indexing: getindex ##
 
@@ -282,11 +240,10 @@ done(a::Array,i) = (i > length(a))
 getindex(A::Array, i1::Real) = arrayref(A, to_index(i1))
 getindex(A::Array, i1::Real, i2::Real, I::Real...) = arrayref(A, to_index(i1), to_index(i2), to_indexes(I...)...)
 
-unsafe_getindex(A::Array, i1::Real, I::Real...) = @inbounds return arrayref(A, to_index(i1), to_indexes(I...)...)
-
 # Faster contiguous indexing using copy! for UnitRange and Colon
-getindex(A::Array, I::UnitRange{Int}) = (checkbounds(A, I); unsafe_getindex(A, I))
-function unsafe_getindex(A::Array, I::UnitRange{Int})
+function getindex(A::Array, I::UnitRange{Int})
+    @_inline_meta
+    @boundscheck checkbounds(A, I)
     lI = length(I)
     X = similar(A, lI)
     if lI > 0
@@ -294,8 +251,7 @@ function unsafe_getindex(A::Array, I::UnitRange{Int})
     end
     return X
 end
-getindex(A::Array, c::Colon) = unsafe_getindex(A, c)
-function unsafe_getindex(A::Array, ::Colon)
+function getindex(A::Array, c::Colon)
     lI = length(A)
     X = similar(A, lI)
     if lI > 0
@@ -305,15 +261,13 @@ function unsafe_getindex(A::Array, ::Colon)
 end
 
 # This is redundant with the abstract fallbacks, but needed for bootstrap
-function getindex{T<:Real}(A::Array, I::Range{T})
-    return [ A[to_index(i)] for i in I ]
+function getindex{S,T<:Real}(A::Array{S}, I::Range{T})
+    return S[ A[to_index(i)] for i in I ]
 end
 
 ## Indexing: setindex! ##
-setindex!{T}(A::Array{T}, x, i1::Real) = arrayset(A, convert(T,x), to_index(i1))
-setindex!{T}(A::Array{T}, x, i1::Real, i2::Real, I::Real...) = arrayset(A, convert(T,x), to_index(i1), to_index(i2), to_indexes(I...)...)
-
-unsafe_setindex!{T}(A::Array{T}, x, i1::Real, I::Real...) = @inbounds return arrayset(A, convert(T,x), to_index(i1), to_indexes(I...)...)
+setindex!{T}(A::Array{T}, x, i1::Real) = arrayset(A, convert(T,x)::T, to_index(i1))
+setindex!{T}(A::Array{T}, x, i1::Real, i2::Real, I::Real...) = arrayset(A, convert(T,x)::T, to_index(i1), to_index(i2), to_indexes(I...)...)
 
 # These are redundant with the abstract fallbacks but needed for bootstrap
 function setindex!(A::Array, x, I::AbstractVector{Int})
@@ -340,8 +294,9 @@ function setindex!(A::Array, X::AbstractArray, I::AbstractVector{Int})
 end
 
 # Faster contiguous setindex! with copy!
-setindex!{T}(A::Array{T}, X::Array{T}, I::UnitRange{Int}) = (checkbounds(A, I); unsafe_setindex!(A, X, I))
-function unsafe_setindex!{T}(A::Array{T}, X::Array{T}, I::UnitRange{Int})
+function setindex!{T}(A::Array{T}, X::Array{T}, I::UnitRange{Int})
+    @_inline_meta
+    @boundscheck checkbounds(A, I)
     lI = length(I)
     setindex_shape_check(X, lI)
     if lI > 0
@@ -349,8 +304,7 @@ function unsafe_setindex!{T}(A::Array{T}, X::Array{T}, I::UnitRange{Int})
     end
     return A
 end
-setindex!{T}(A::Array{T}, X::Array{T}, c::Colon) = unsafe_setindex!(A, X, c)
-function unsafe_setindex!{T}(A::Array{T}, X::Array{T}, ::Colon)
+function setindex!{T}(A::Array{T}, X::Array{T}, c::Colon)
     lI = length(A)
     setindex_shape_check(X, lI)
     if lI > 0
@@ -426,9 +380,9 @@ end
 
 function push!{T}(a::Array{T,1}, item)
     # convert first so we don't grow the array if the assignment won't work
-    item = convert(T, item)
+    itemT = convert(T, item)
     ccall(:jl_array_grow_end, Void, (Any, UInt), a, 1)
-    a[end] = item
+    a[end] = itemT
     return a
 end
 
@@ -827,10 +781,12 @@ function findmax(a)
     if isempty(a)
         throw(ArgumentError("collection must be non-empty"))
     end
-    m = a[1]
-    mi = 1
-    for i=2:length(a)
-        ai = a[i]
+    s = start(a)
+    mi = i = 1
+    m, s = next(a, s)
+    while !done(a, s)
+        ai, s = next(a, s)
+        i += 1
         if ai > m || m!=m
             m = ai
             mi = i
@@ -843,10 +799,12 @@ function findmin(a)
     if isempty(a)
         throw(ArgumentError("collection must be non-empty"))
     end
-    m = a[1]
-    mi = 1
-    for i=2:length(a)
-        ai = a[i]
+    s = start(a)
+    mi = i = 1
+    m, s = next(a, s)
+    while !done(a, s)
+        ai, s = next(a, s)
+        i += 1
         if ai < m || m!=m
             m = ai
             mi = i
@@ -865,19 +823,6 @@ function indexin(a::AbstractArray, b::AbstractArray)
     [get(bdict, i, 0) for i in a]
 end
 
-# findin (the index of intersection)
-function findin(a, b::UnitRange)
-    ind = Array(Int, 0)
-    f = first(b)
-    l = last(b)
-    for i = 1:length(a)
-        if f <= a[i] <= l
-            push!(ind, i)
-        end
-    end
-    ind
-end
-
 function findin(a, b)
     ind = Array(Int, 0)
     bset = Set(b)
diff --git a/base/arraymath.jl b/base/arraymath.jl
index caa52d79387b5..cefffb73c9d65 100644
--- a/base/arraymath.jl
+++ b/base/arraymath.jl
@@ -104,6 +104,7 @@ end
 for (f,F) in ((:.+,  DotAddFun()),
           (:.-,  DotSubFun()),
           (:.*,  DotMulFun()),
+          (:.÷,  DotIDivFun()),
           (:.%,  DotRemFun()),
           (:.<<, DotLSFun()),
           (:.>>, DotRSFun()),
diff --git a/base/ascii.jl b/base/ascii.jl
index 4fe48eeb7f0fe..40cde5ae6f410 100644
--- a/base/ascii.jl
+++ b/base/ascii.jl
@@ -45,7 +45,7 @@ function string(c::ASCIIString...)
 end
 
 function ucfirst(s::ASCIIString)
-    if length(s) > 0 && 'a' <= s[1] <= 'z'
+    if !isempty(s) && 'a' <= s[1] <= 'z'
         t = ASCIIString(copy(s.data))
         t.data[1] -= 32
         return t
@@ -53,7 +53,7 @@ function ucfirst(s::ASCIIString)
     return s
 end
 function lcfirst(s::ASCIIString)
-    if length(s) > 0 && 'A' <= s[1] <= 'Z'
+    if !isempty(s) && 'A' <= s[1] <= 'Z'
         t = ASCIIString(copy(s.data))
         t.data[1] += 32
         return t
diff --git a/base/atomics.jl b/base/atomics.jl
new file mode 100644
index 0000000000000..132c69aab6505
--- /dev/null
+++ b/base/atomics.jl
@@ -0,0 +1,89 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+using Base.Intrinsics: llvmcall
+
+import Base: setindex!, getindex
+
+export
+    Atomic,
+    atomic_cas!,
+    atomic_xchg!,
+    atomic_add!, atomic_sub!,
+    atomic_and!, atomic_nand!, atomic_or!, atomic_xor!,
+    atomic_max!, atomic_min!,
+    atomic_fence
+
+atomicintsmap = Dict(Int8   => "i8",   UInt8   => "i8",
+                     Int16  => "i16",  UInt16  => "i16",
+                     Int32  => "i32",  UInt32  => "i32",
+                     Int64  => "i64",  UInt64  => "i64",
+                     Int128 => "i128", UInt128 => "i128")
+AtomicInts = Union{keys(atomicintsmap)...}
+
+type Atomic{T<:AtomicInts}
+    value::T
+    Atomic() = new(zero(T))
+    Atomic(value) = new(value)
+end
+
+Atomic() = Atomic{Int}()
+
+unsafe_convert{T}(::Type{Ptr{T}}, x::Atomic{T}) = convert(Ptr{T}, pointer_from_objref(x))
+setindex!{T}(x::Atomic{T}, v) = setindex!(x, convert(T, v))
+
+# All atomic operations have acquire and/or release semantics, depending on
+# whether the load or store values. Most of the time, this is what one wants
+# anyway, and it's only moderately expensive on most hardware.
+for (typ, lt) in atomicintsmap
+    rt = VersionNumber(Base.libllvm_version) >= v"3.6" ? "$lt, $lt*" : "$lt*"
+    @eval getindex(x::Atomic{$typ}) =
+        llvmcall($"""
+                %rv = load atomic $rt %0 acquire, align $WORD_SIZE
+                ret $lt %rv
+            """, $typ, Tuple{Ptr{$typ}}, unsafe_convert(Ptr{$typ}, x))
+    @eval setindex!(x::Atomic{$typ}, v::$typ) =
+        llvmcall($"""
+                store atomic $lt %1, $lt* %0 release, align $WORD_SIZE
+                ret void
+            """, Void, Tuple{Ptr{$typ},$typ}, unsafe_convert(Ptr{$typ}, x), v)
+    if VersionNumber(Base.libllvm_version) >= v"3.5"
+        @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
+            llvmcall($"""
+                     %rv = cmpxchg $lt* %0, $lt %1, $lt %2 acq_rel monotonic
+                     %bv = extractvalue { $lt, i1 } %rv, 1
+                     ret i1 %bv
+                     """, Bool, Tuple{Ptr{$typ},$typ,$typ},
+                     unsafe_convert(Ptr{$typ}, x), cmp, new)
+    else
+        @eval atomic_cas!(x::Atomic{$typ}, cmp::$typ, new::$typ) =
+            llvmcall($"""
+                     %rv = cmpxchg $lt* %0, $lt %1, $lt %2 acq_rel
+                     %bv = icmp eq $lt %1, %rv
+                     ret i1 %bv
+                     """, Bool, Tuple{Ptr{$typ},$typ,$typ},
+                     unsafe_convert(Ptr{$typ}, x), cmp, new)
+    end
+    for rmwop in [:xchg, :add, :sub, :and, :nand, :or, :xor, :max, :min]
+        rmw = string(rmwop)
+        fn = symbol("atomic_", rmw, "!")
+        if (rmw == "max" || rmw == "min") && typ <: Unsigned
+            # LLVM distinguishes signedness in the operation, not the integer type.
+            rmw = "u" * rmw
+        end
+        @eval $fn(x::Atomic{$typ}, v::$typ) =
+            llvmcall($"""
+                    %rv = atomicrmw $rmw $lt* %0, $lt %1 acq_rel
+                    ret $lt %rv
+                """, $typ, Tuple{Ptr{$typ}, $typ}, unsafe_convert(Ptr{$typ}, x), v)
+    end
+end
+
+# Use sequential consistency for a memory fence. There are algorithms where this
+# is needed (where an acquire/release ordering is insufficient). This is likely
+# a very expensive operation. Given that all other atomic operations have
+# already acquire/release semantics, explicit fences should not be necessary in
+# most cases.
+atomic_fence() = llvmcall("""
+                          fence seq_cst
+                          ret void
+                          """, Void, Tuple{})
diff --git a/base/base.jl b/base/base.jl
index 909bb062b6a13..ead103bcb3954 100644
--- a/base/base.jl
+++ b/base/base.jl
@@ -7,7 +7,9 @@ end
 type SystemError <: Exception
     prefix::AbstractString
     errnum::Int32
-    SystemError(p::AbstractString, e::Integer) = new(p, e)
+    extrainfo
+    SystemError(p::AbstractString, e::Integer, extrainfo) = new(p, e, extrainfo)
+    SystemError(p::AbstractString, e::Integer) = new(p, e, nothing)
     SystemError(p::AbstractString) = new(p, Libc.errno())
 end
 
@@ -68,7 +70,7 @@ ccall(:jl_get_system_hooks, Void, ())
 ==(w::WeakRef, v) = isequal(w.value, v)
 ==(w, v::WeakRef) = isequal(w, v.value)
 
-function finalizer(o::ANY, f::Union{Function,Ptr})
+function finalizer(o::ANY, f::ANY)
     if isimmutable(o)
         error("objects of type ", typeof(o), " cannot be finalized")
     end
diff --git a/base/base64.jl b/base/base64.jl
index f91282a172d50..5b9856dfed1d5 100644
--- a/base/base64.jl
+++ b/base/base64.jl
@@ -85,16 +85,15 @@ end
 
 #############################################################################
 
-function write(b::Base64EncodePipe, x::AbstractVector{UInt8})
-    n = length(x)
+function unsafe_write(b::Base64EncodePipe, x::Ptr{UInt8}, n::UInt)
     s = 1 # starting index
     # finish any cached data to write:
     if b.nb == 1
         if n >= 2
-            write(b.io, b64(b.b0, x[1], x[2])...)
+            write(b.io, b64(b.b0, unsafe_load(x, 1), unsafe_load(x, 2))...)
             s = 3
         elseif n == 1
-            b.b1 = x[1]
+            b.b1 = unsafe_load(x, 1)
             b.nb = 2
             return
         else
@@ -102,7 +101,7 @@ function write(b::Base64EncodePipe, x::AbstractVector{UInt8})
         end
     elseif b.nb == 2
         if n >= 1
-            write(b.io, b64(b.b0, b.b1, x[1])...)
+            write(b.io, b64(b.b0, b.b1, unsafe_load(x, 1))...)
             s = 2
         else
             return
@@ -110,16 +109,16 @@ function write(b::Base64EncodePipe, x::AbstractVector{UInt8})
     end
     # write all groups of three bytes:
     while s + 2 <= n
-        write(b.io, b64(x[s], x[s+1], x[s+2])...)
+        write(b.io, b64(unsafe_load(x, s), unsafe_load(x, s + 1), unsafe_load(x, s + 2))...)
         s += 3
     end
     # cache any leftover bytes:
     if s + 1 == n
-        b.b0 = x[s]
-        b.b1 = x[s+1]
+        b.b0 = unsafe_load(x, s)
+        b.b1 = unsafe_load(x, s + 1)
         b.nb = 2
     elseif s == n
-        b.b0 = x[s]
+        b.b0 = unsafe_load(x, s)
         b.nb = 1
     else
         b.nb = 0
@@ -179,7 +178,7 @@ type Base64DecodePipe <: IO
 end
 
 function read(b::Base64DecodePipe, t::Type{UInt8})
-    if length(b.cache) > 0
+    if !isempty(b.cache)
         return shift!(b.cache)
     else
         empty!(b.encvec)
@@ -193,14 +192,14 @@ function read(b::Base64DecodePipe, t::Type{UInt8})
     end
 end
 
-eof(b::Base64DecodePipe) = length(b.cache) == 0 && eof(b.io)
+eof(b::Base64DecodePipe) = isempty(b.cache) && eof(b.io)
 close(b::Base64DecodePipe) = nothing
 
 # Decodes a base64-encoded string
 function base64decode(s)
     b = IOBuffer(s)
     try
-        return readbytes(Base64DecodePipe(b))
+        return read(Base64DecodePipe(b))
     finally
         close(b)
     end
diff --git a/base/bitarray.jl b/base/bitarray.jl
index c84397571604c..d5acc46e19310 100644
--- a/base/bitarray.jl
+++ b/base/bitarray.jl
@@ -32,7 +32,7 @@ BitArray(dims::Int...) = BitArray(dims)
 typealias BitVector BitArray{1}
 typealias BitMatrix BitArray{2}
 
-call(::Type{BitVector}) = BitArray{1}(0)
+(::Type{BitVector})() = BitArray{1}(0)
 
 ## utility functions ##
 
@@ -224,7 +224,7 @@ similar(B::BitArray, T::Type, dims::Dims) = Array(T, dims)
 
 function fill!(B::BitArray, x)
     y = convert(Bool, x)
-    length(B) == 0 && return B
+    isempty(B) && return B
     Bc = B.chunks
     if !y
         fill!(Bc, 0)
@@ -310,21 +310,17 @@ function convert{T,N}(::Type{BitArray{N}}, A::AbstractArray{T,N})
     ind = 1
     @inbounds begin
         for i = 1:length(Bc)-1
-            u = UInt64(1)
             c = UInt64(0)
             for j = 0:63
-                A[ind]!=0 && (c |= u)
+                c |= (UInt64(A[ind] != 0) << j)
                 ind += 1
-                u <<= 1
             end
             Bc[i] = c
         end
-        u = UInt64(1)
         c = UInt64(0)
         for j = 0:_mod64(l-1)
-            A[ind]!=0 && (c |= u)
+            c |= (UInt64(A[ind] != 0) << j)
             ind += 1
-            u <<= 1
         end
         Bc[end] = c
     end
@@ -350,8 +346,10 @@ bitpack{T,N}(A::AbstractArray{T,N}) = convert(BitArray{N}, A)
     return r
 end
 
-@inline getindex(B::BitArray, i::Int) = (checkbounds(B, i); unsafe_getindex(B, i))
-@inline unsafe_getindex(B::BitArray, i::Int) = unsafe_bitgetindex(B.chunks, i)
+@inline function getindex(B::BitArray, i::Int)
+    @boundscheck checkbounds(B, i)
+    unsafe_bitgetindex(B.chunks, i)
+end
 
 ## Indexing: setindex! ##
 
@@ -359,28 +357,25 @@ end
     i1, i2 = get_chunks_id(i)
     u = UInt64(1) << i2
     @inbounds begin
-        if x
-            Bc[i1] |= u
-        else
-            Bc[i1] &= ~u
-        end
+        c = Bc[i1]
+        Bc[i1] = ifelse(x, c | u, c & ~u)
     end
 end
 
-setindex!(B::BitArray, x, i::Int) = (checkbounds(B, i); unsafe_setindex!(B, x, i))
-@inline function unsafe_setindex!(B::BitArray, x, i::Int)
+@inline function setindex!(B::BitArray, x, i::Int)
+    @boundscheck checkbounds(B, i)
     unsafe_bitsetindex!(B.chunks, convert(Bool, x), i)
     return B
 end
 
 # logical indexing
-# (when the indexing is provided as an Array{Bool} or a BitArray we can be
-# sure about the behaviour and use unsafe_getindex; in the general case
-# we can't and must use getindex, otherwise silent corruption can happen)
 
 # When indexing with a BitArray, we can operate whole chunks at a time for a ~100x gain
-setindex!(B::BitArray, x, I::BitArray) = (checkbounds(B, I); unsafe_setindex!(B, x, I))
-function unsafe_setindex!(B::BitArray, x, I::BitArray)
+@inline function setindex!(B::BitArray, x, I::BitArray)
+    @boundscheck checkbounds(B, I)
+    _unsafe_setindex!(B, x, I)
+end
+function _unsafe_setindex!(B::BitArray, x, I::BitArray)
     y = convert(Bool, x)
     Bc = B.chunks
     Ic = I.chunks
@@ -399,8 +394,11 @@ end
 
 # Assigning an array of bools is more complicated, but we can still do some
 # work on chunks by combining X and I 64 bits at a time to improve perf by ~40%
-setindex!(B::BitArray, X::AbstractArray, I::BitArray) = (checkbounds(B, I); unsafe_setindex!(B, X, I))
-function unsafe_setindex!(B::BitArray, X::AbstractArray, I::BitArray)
+@inline function setindex!(B::BitArray, X::AbstractArray, I::BitArray)
+    @boundscheck checkbounds(B, I)
+    _unsafe_setindex!(B, X, I)
+end
+function _unsafe_setindex!(B::BitArray, X::AbstractArray, I::BitArray)
     Bc = B.chunks
     Ic = I.chunks
     length(Bc) == length(Ic) || throw_boundserror(B, I)
@@ -416,12 +414,8 @@ function unsafe_setindex!(B::BitArray, X::AbstractArray, I::BitArray)
         for j = 1:(i < lc ? 64 : last_chunk_len)
             if Imsk & u != 0
                 lx < c && throw_setindex_mismatch(X, c)
-                x = convert(Bool, unsafe_getindex(X, c))
-                if x
-                    C |= u
-                else
-                    C &= ~u
-                end
+                @inbounds x = convert(Bool, X[c])
+                C = ifelse(x, C | u, C & ~u)
                 c += 1
             end
             u <<= 1
@@ -1153,7 +1147,7 @@ end
 function reverse!(B::BitVector)
     # Basic idea: each chunk is divided into two blocks of size k = n % 64, and
     # h = 64 - k. Walk from either end (with indexes i and j) reversing chunks
-    # and seperately ORing their two blocks into place.
+    # and separately ORing their two blocks into place.
     #
     #           chunk 3                  chunk 2                  chunk 1
     # ┌───────────────┬───────┐┌───────────────┬───────┐┌───────────────┬───────┐
@@ -1488,7 +1482,7 @@ sum(A::BitArray, region) = reducedim(AddFun(), A, region)
 sum(B::BitArray) = countnz(B)
 
 function all(B::BitArray)
-    length(B) == 0 && return true
+    isempty(B) && return true
     Bc = B.chunks
     @inbounds begin
         for i = 1:length(Bc)-1
@@ -1500,7 +1494,7 @@ function all(B::BitArray)
 end
 
 function any(B::BitArray)
-    length(B) == 0 && return false
+    isempty(B) && return false
     Bc = B.chunks
     @inbounds begin
         for i = 1:length(Bc)
@@ -1533,7 +1527,7 @@ map!(f::Function, dest::BitArray, A::BitArray, B::BitArray) = map!(specialized_b
 # iterates bit-by-bit.
 function map!(f::BitFunctorUnary, dest::BitArray, A::BitArray)
     size(A) == size(dest) || throw(DimensionMismatch("sizes of dest and A must match"))
-    length(A) == 0 && return dest
+    isempty(A) && return dest
     for i=1:length(A.chunks)-1
         dest.chunks[i] = f(A.chunks[i])
     end
@@ -1542,7 +1536,7 @@ function map!(f::BitFunctorUnary, dest::BitArray, A::BitArray)
 end
 function map!(f::BitFunctorBinary, dest::BitArray, A::BitArray, B::BitArray)
     size(A) == size(B) == size(dest) || throw(DimensionMismatch("sizes of dest, A, and B must all match"))
-    length(A) == 0 && return dest
+    isempty(A) && return dest
     for i=1:length(A.chunks)-1
         dest.chunks[i] = f(A.chunks[i], B.chunks[i])
     end
@@ -1738,22 +1732,21 @@ function vcat(A::BitMatrix...)
     return B
 end
 
+function cat(catdim::Integer, X::Integer...)
+    reshape([X...], (ones(Int,catdim-1)..., length(X)))
+end
+
 # general case, specialized for BitArrays and Integers
 function cat(catdim::Integer, X::Union{BitArray, Integer}...)
     nargs = length(X)
     # using integers results in conversion to Array{Int}
     # (except in the all-Bool case)
-    has_bitarray = false
     has_integer = false
     for a in X
-        if isa(a, BitArray)
-            has_bitarray = true
-        else
-            has_integer = true
+        if isa(a, Integer)
+            has_integer = true; break
         end
     end
-    # just integers and no BitArrays -> general case
-    has_bitarray || return invoke(cat, Tuple{Integer, Vararg{Any}}, catdim, X...)
     dimsX = map((a->isa(a,BitArray) ? size(a) : (1,)), X)
     ndimsX = map((a->isa(a,BitArray) ? ndims(a) : 1), X)
     d_max = maximum(ndimsX)
diff --git a/base/bool.jl b/base/bool.jl
index 95df1e3494cb3..915d67a97bb3f 100644
--- a/base/bool.jl
+++ b/base/bool.jl
@@ -59,3 +59,5 @@ fld(x::Bool, y::Bool) = div(x,y)
 cld(x::Bool, y::Bool) = div(x,y)
 rem(x::Bool, y::Bool) = y ? false : throw(DivideError())
 mod(x::Bool, y::Bool) = rem(x,y)
+
+promote_op(op, ::Type{Bool}, ::Type{Bool}) = typeof(op(true, true))
diff --git a/base/boot.jl b/base/boot.jl
index e79885196708a..0e8cc513b89d0 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -59,7 +59,7 @@
 #    name::Symbol
 #end
 
-#type LambdaStaticData
+#type LambdaInfo
 #    ast::Expr
 #    sparams::Tuple
 #    tfunc
@@ -71,10 +71,6 @@
 #    module::Module
 #end
 
-#type Box
-#    contents::Any
-#end
-
 #abstract Ref{T}
 #bitstype {32|64} Ptr{T} <: Ref{T}
 
@@ -114,7 +110,6 @@
 
 # type Task
 #     parent::Task
-#     last::Task
 #     storage::Any
 #     consumers
 #     started::Bool
@@ -130,7 +125,7 @@ export
     Tuple, Type, TypeConstructor, TypeName, TypeVar, Union, Void,
     SimpleVector, AbstractArray, DenseArray,
     # special objects
-    Box, Function, IntrinsicFunction, LambdaStaticData, Method, MethodTable,
+    Box, Function, Builtin, IntrinsicFunction, LambdaInfo, Method, MethodTable,
     Module, Symbol, Task, Array, WeakRef,
     # numeric types
     Number, Real, Integer, Bool, Ref, Ptr,
@@ -147,22 +142,25 @@ export
     Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode, SymbolNode, TopNode,
     GlobalRef, NewvarNode, GenSym,
     # object model functions
-    fieldtype, getfield, setfield!, nfields, throw, tuple, is, ===, isdefined,
-    # arraylen, arrayref, arrayset, arraysize,
-    # _apply, kwcall,
+    fieldtype, getfield, setfield!, nfields, throw, tuple, is, ===, isdefined, eval,
+    # arrayref, arrayset, arraysize,
+    # _apply,
+    kwfunc,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
     # type reflection
     issubtype, typeof, isa,
     # typeassert, apply_type,
     # method reflection
-    applicable, invoke, method_exists,
+    applicable, invoke,
     # constants
     nothing, Main,
     # intrinsics module
     Intrinsics
     #ccall, cglobal, llvmcall, abs_float, add_float, add_int, and_int, ashr_int,
-    #box, bswap_int, checked_fptosi, checked_fptoui, checked_sadd,
-    #checked_smul, checked_ssub, checked_uadd, checked_umul, checked_usub,
+    #box, bswap_int, checked_fptosi, checked_fptoui,
+    #checked_sadd_int, checked_ssub_int, checked_smul_int, checked_sdiv_int,
+    #checked_srem_int, checked_uadd_int, checked_usub_int, checked_umul_int,
+    #checked_udiv_int, checked_urem_int,
     #checked_trunc_sint, checked_trunc_uint, check_top_bit,
     #nan_dom_err, copysign_float, ctlz_int, ctpop_int, cttz_int,
     #div_float, eq_float, eq_int, eqfsi64, eqfui64, flipsign_int, select_value,
@@ -174,7 +172,7 @@ export
     #mul_int, ne_float, ne_int, neg_float, neg_int, not_int, or_int, rem_float,
     #sdiv_int, shl_int, sitofp, sle_int, slt_int, smod_int,
     #srem_int, sub_float, sub_int, trunc_int, udiv_int, uitofp,
-    #ule_int, ult_int, unbox, urem_int, xor_int, sext_int, zext_int
+    #ule_int, ult_int, unbox, urem_int, xor_int, sext_int, zext_int, arraylen
 
 
 const (===) = is
@@ -211,17 +209,9 @@ else
 end
 
 abstract AbstractString
-abstract DirectIndexString <: AbstractString
 
-immutable ASCIIString <: DirectIndexString
-    data::Array{UInt8,1}
-end
-
-immutable UTF8String <: AbstractString
-    data::Array{UInt8,1}
-end
-
-typealias ByteString Union{ASCIIString,UTF8String}
+function Typeof end
+(f::typeof(Typeof))(x::ANY) = isa(x,Type) ? Type{x} : typeof(x)
 
 abstract Exception
 immutable BoundsError        <: Exception
@@ -257,8 +247,35 @@ type SymbolNode
     SymbolNode(name::Symbol, t::ANY) = new(name, t)
 end
 
+abstract DirectIndexString <: AbstractString
+
+immutable ASCIIString <: DirectIndexString
+    data::Array{UInt8,1}
+    ASCIIString(d::Array{UInt8,1}) = new(d)
+end
+
+immutable UTF8String <: AbstractString
+    data::Array{UInt8,1}
+    UTF8String(d::Array{UInt8,1}) = new(d)
+end
+
+typealias ByteString Union{ASCIIString,UTF8String}
+
 include(fname::ByteString) = ccall(:jl_load_, Any, (Any,), fname)
 
+eval(e::ANY) = eval(Main, e)
+eval(m::Module, e::ANY) = ccall(:jl_toplevel_eval_in, Any, (Any, Any), m, e)
+
+kwfunc(f::ANY) = ccall(:jl_get_keyword_sorter, Any, (Any,), f)
+
+kwftype(t::ANY) = typeof(ccall(:jl_get_kwsorter, Any, (Any,), t.name))
+
+type Box
+    contents::Any
+    Box(x::ANY) = new(x)
+    Box() = new()
+end
+
 # constructors for built-in types
 
 type WeakRef
@@ -286,19 +303,19 @@ Void() = nothing
 
 Expr(args::ANY...) = _expr(args...)
 
-_new(typ::Symbol, argty::Symbol) = eval(:(Core.call(::Type{$typ}, n::$argty) = $(Expr(:new, typ, :n))))
+_new(typ::Symbol, argty::Symbol) = eval(:((::Type{$typ})(n::$argty) = $(Expr(:new, typ, :n))))
 _new(:LabelNode, :Int)
 _new(:GotoNode, :Int)
 _new(:TopNode, :Symbol)
 _new(:NewvarNode, :Symbol)
 _new(:QuoteNode, :ANY)
 _new(:GenSym, :Int)
-eval(:(Core.call(::Type{LineNumberNode}, f::Symbol, l::Int) = $(Expr(:new, :LineNumberNode, :f, :l))))
-eval(:(Core.call(::Type{GlobalRef}, m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
+eval(:((::Type{LineNumberNode})(f::Symbol, l::Int) = $(Expr(:new, :LineNumberNode, :f, :l))))
+eval(:((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
 
 Module(name::Symbol=:anonymous, std_imports::Bool=true) = ccall(:jl_f_new_module, Any, (Any, Bool), name, std_imports)::Module
 
-Task(f::ANY) = ccall(:jl_new_task, Any, (Any, Int), f::Function, 0)::Task
+Task(f::ANY) = ccall(:jl_new_task, Any, (Any, Int), f, 0)::Task
 
 # simple convert for use by constructors of types in Core
 # note that there is no actual conversion defined here,
@@ -308,4 +325,26 @@ convert{T}(::Type{T}, x::T) = x
 cconvert(T::Type, x) = convert(T, x)
 unsafe_convert{T}(::Type{T}, x::T) = x
 
+# primitive array constructors
+(::Type{Array{T,N}}){T,N}(d::NTuple{N,Int}) =
+    ccall(:jl_new_array, Array{T,N}, (Any,Any), Array{T,N}, d)
+(::Type{Array{T,1}}){T}(m::Int) =
+    ccall(:jl_alloc_array_1d, Array{T,1}, (Any,Int), Array{T,1}, m)
+(::Type{Array{T,2}}){T}(m::Int, n::Int) =
+    ccall(:jl_alloc_array_2d, Array{T,2}, (Any,Int,Int), Array{T,2}, m, n)
+(::Type{Array{T,3}}){T}(m::Int, n::Int, o::Int) =
+    ccall(:jl_alloc_array_3d, Array{T,3}, (Any,Int,Int,Int), Array{T,3}, m, n, o)
+
+(::Type{Array{T}}){T,N}(d::NTuple{N,Int}) = Array{T,N}(d)
+(::Type{Array{T}}){T}(m::Int) = Array{T,1}(m)
+(::Type{Array{T}}){T}(m::Int, n::Int) = Array{T,2}(m, n)
+(::Type{Array{T}}){T}(m::Int, n::Int, o::Int) = Array{T,3}(m, n, o)
+
+# TODO: possibly turn these into deprecations
+Array{T,N}(::Type{T}, d::NTuple{N,Int}) = Array{T}(d)
+Array{T}(::Type{T}, d::Int...) = Array{T}(d)
+Array{T}(::Type{T}, m::Int)               = Array{T,1}(m)
+Array{T}(::Type{T}, m::Int,n::Int)        = Array{T,2}(m,n)
+Array{T}(::Type{T}, m::Int,n::Int,o::Int) = Array{T,3}(m,n,o)
+
 ccall(:jl_set_istopmod, Void, (Bool,), true)
diff --git a/base/broadcast.jl b/base/broadcast.jl
index de593d46e0c47..aaa659ddd8159 100644
--- a/base/broadcast.jl
+++ b/base/broadcast.jl
@@ -3,10 +3,9 @@
 module Broadcast
 
 using ..Cartesian
-import Base.promote_eltype
-import Base.@get!
-import Base.num_bit_chunks, Base._msk_end, Base.unsafe_bitgetindex
-import Base: .+, .-, .*, ./, .\, .//, .==, .<, .!=, .<=, .%, .<<, .>>, .^
+using Base: promote_op, promote_eltype, promote_eltype_op, @get!, _msk_end, unsafe_bitgetindex
+using Base: AddFun, SubFun, MulFun, LDivFun, RDivFun, PowFun
+import Base: .+, .-, .*, ./, .\, .//, .==, .<, .!=, .<=, .÷, .%, .<<, .>>, .^
 export broadcast, broadcast!, broadcast_function, broadcast!_function, bitbroadcast
 export broadcast_getindex, broadcast_setindex!
 
@@ -104,16 +103,34 @@ end
 const bitcache_chunks = 64 # this can be changed
 const bitcache_size = 64 * bitcache_chunks # do not change this
 
+function bpack(z::UInt64)
+    z |= z >>> 7
+    z |= z >>> 14
+    z |= z >>> 28
+    z &= 0xFF
+    return z
+end
+
 function dumpbitcache(Bc::Vector{UInt64}, bind::Int, C::Vector{Bool})
     ind = 1
     nc = min(bitcache_chunks, length(Bc)-bind+1)
-    for i = 1:nc
-        u = UInt64(1)
+    C8 = reinterpret(UInt64, C)
+    nc8 = (nc >>> 3) << 3
+    @inbounds for i = 1:nc8
         c = UInt64(0)
-        for j = 1:64
-            C[ind] && (c |= u)
+        for j = 0:8:63
+            c |= (bpack(C8[ind]) << j)
+            ind += 1
+        end
+        Bc[bind] = c
+        bind += 1
+    end
+    ind = (ind-1) << 3 + 1
+    @inbounds for i = (nc8+1):nc
+        c = UInt64(0)
+        for j = 0:63
+            c |= (UInt64(C[ind]) << j)
             ind += 1
-            u <<= 1
         end
         Bc[bind] = c
         bind += 1
@@ -232,7 +249,7 @@ for (Bsig, Asig, gbf, gbb) in
 end
 
 
-broadcast(f, As...) = broadcast!(f, Array(promote_eltype(As...), broadcast_shape(As...)), As...)
+broadcast(f, As...) = broadcast!(f, Array(promote_eltype_op(f, As...), broadcast_shape(As...)), As...)
 
 bitbroadcast(f, As...) = broadcast!(f, BitArray(broadcast_shape(As...)), As...)
 
@@ -286,35 +303,29 @@ end
 
 ## elementwise operators ##
 
-.*(As::AbstractArray...) = broadcast(*, As...)
+.÷(A::AbstractArray, B::AbstractArray) = broadcast(÷, A, B)
 .%(A::AbstractArray, B::AbstractArray) = broadcast(%, A, B)
 .<<(A::AbstractArray, B::AbstractArray) = broadcast(<<, A, B)
 .>>(A::AbstractArray, B::AbstractArray) = broadcast(>>, A, B)
 
-eltype_plus(As::AbstractArray...) = promote_eltype(As...)
-eltype_plus(As::AbstractArray{Bool}...) = typeof(true+true)
+eltype_plus(As::AbstractArray...) = promote_eltype_op(AddFun(), As...)
 
 .+(As::AbstractArray...) = broadcast!(+, Array(eltype_plus(As...), broadcast_shape(As...)), As...)
 
-type_minus(T, S) = promote_type(T, S)
-type_minus(::Type{Bool}, ::Type{Bool}) = typeof(true-true)
-
 function .-(A::AbstractArray, B::AbstractArray)
-    broadcast!(-, Array(type_minus(eltype(A), eltype(B)), broadcast_shape(A,B)), A, B)
+    broadcast!(-, Array(promote_op(SubFun(), eltype(A), eltype(B)), broadcast_shape(A,B)), A, B)
 end
 
-type_div(T,S) = promote_type(T,S)
-type_div{T<:Integer,S<:Integer}(::Type{T},::Type{S}) = typeof(one(T)/one(S))
-type_div{T,S}(::Type{Complex{T}},::Type{Complex{S}}) = Complex{type_div(T,S)}
-type_div{T,S}(::Type{Complex{T}},::Type{S})          = Complex{type_div(T,S)}
-type_div{T,S}(::Type{T},::Type{Complex{S}})          = Complex{type_div(T,S)}
+eltype_mul(As::AbstractArray...) = promote_eltype_op(MulFun(), As...)
+
+.*(As::AbstractArray...) = broadcast!(*, Array(eltype_mul(As...), broadcast_shape(As...)), As...)
 
 function ./(A::AbstractArray, B::AbstractArray)
-    broadcast!(/, Array(type_div(eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
+    broadcast!(/, Array(promote_op(RDivFun(), eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
 end
 
 function .\(A::AbstractArray, B::AbstractArray)
-    broadcast!(\, Array(type_div(eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
+    broadcast!(\, Array(promote_op(LDivFun(), eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
 end
 
 typealias RatIntT{T<:Integer} Union{Type{Rational{T}},Type{T}}
@@ -327,12 +338,8 @@ function .//(A::AbstractArray, B::AbstractArray)
     broadcast!(//, Array(type_rdiv(eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
 end
 
-type_pow(T,S) = promote_type(T,S)
-type_pow{S<:Integer}(::Type{Bool},::Type{S}) = Bool
-type_pow{S}(T,::Type{Rational{S}}) = type_pow(T, type_div(S, S))
-
 function .^(A::AbstractArray, B::AbstractArray)
-    broadcast!(^, Array(type_pow(eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
+    broadcast!(^, Array(promote_op(PowFun(), eltype(A), eltype(B)), broadcast_shape(A, B)), A, B)
 end
 
 ## element-wise comparison operators returning BitArray ##
@@ -373,6 +380,7 @@ for (f, cachef, scalarf) in ((:.==, :bitcache_eq , :(==)),
                              (:.< , :bitcache_lt , :<   ),
                              (:.!=, :bitcache_neq, :!=  ),
                              (:.<=, :bitcache_le , :<=  ))
+    @eval ($cachef)(A::AbstractArray, B::AbstractArray, l::Int, ind::Int, C::Vector{Bool}) = 0
     for (sigA, sigB, expA, expB, shape) in ((:Any, :AbstractArray,
                                              :A, :(B[ind]),
                                              :(size(B))),
@@ -380,7 +388,6 @@ for (f, cachef, scalarf) in ((:.==, :bitcache_eq , :(==)),
                                              :(A[ind]), :B,
                                              :(size(A))))
         @eval begin
-            ($cachef)(A::AbstractArray, B::AbstractArray, l::Int, ind::Int, C::Vector{Bool}) = 0
             function ($cachef)(A::$sigA, B::$sigB, l::Int, ind::Int, C::Vector{Bool})
                 left = l - ind + 1
                 @inbounds begin
diff --git a/base/c.jl b/base/c.jl
index a32bdda4ae56d..f30fc62434a42 100644
--- a/base/c.jl
+++ b/base/c.jl
@@ -2,9 +2,7 @@
 
 # definitions related to C interface
 
-import Core.Intrinsics: cglobal, box, unbox
-
-const OS_NAME = ccall(:jl_get_OS_NAME, Any, ())
+import Core.Intrinsics: cglobal, box
 
 cfunction(f::Function, r, a) = ccall(:jl_function_ptr, Ptr{Void}, (Any, Any, Any), f, r, a)
 
@@ -37,16 +35,17 @@ typealias Culonglong UInt64
 typealias Cfloat Float32
 typealias Cdouble Float64
 
-const sizeof_off_t = ccall(:jl_sizeof_off_t, Cint, ())
-
-if sizeof_off_t === 4
-    typealias FileOffset Int32
-else
-    typealias FileOffset Int64
+if OS_NAME !== :Windows
+    const sizeof_mode_t = ccall(:jl_sizeof_mode_t, Cint, ())
+    if sizeof_mode_t == 2
+        typealias Cmode_t Int16
+    elseif sizeof_mode_t == 4
+        typealias Cmode_t Int32
+    elseif sizeof_mode_t == 8
+        typealias Cmode_t Int64
+    end
 end
 
-typealias Coff_t FileOffset
-
 # C NUL-terminated string pointers; these can be used in ccall
 # instead of Ptr{Cchar} and Ptr{Cwchar_t}, respectively, to enforce
 # a check for embedded NUL chars in the string (to avoid silent truncation).
@@ -58,10 +57,21 @@ else
     bitstype 32 Cwstring
 end
 
-convert{T<:Union{Int8,UInt8}}(::Type{Cstring}, p::Ptr{T}) = box(Cstring, unbox(Ptr{T}, p))
-convert(::Type{Cwstring}, p::Ptr{Cwchar_t}) = box(Cwstring, unbox(Ptr{Cwchar_t}, p))
-convert{T<:Union{Int8,UInt8}}(::Type{Ptr{T}}, p::Cstring) = box(Ptr{T}, unbox(Cstring, p))
-convert(::Type{Ptr{Cwchar_t}}, p::Cwstring) = box(Ptr{Cwchar_t}, unbox(Cwstring, p))
+# construction from typed pointers
+convert{T<:Union{Int8,UInt8}}(::Type{Cstring}, p::Ptr{T}) = box(Cstring, p)
+convert(::Type{Cwstring}, p::Ptr{Cwchar_t}) = box(Cwstring, p)
+convert{T<:Union{Int8,UInt8}}(::Type{Ptr{T}}, p::Cstring) = box(Ptr{T}, p)
+convert(::Type{Ptr{Cwchar_t}}, p::Cwstring) = box(Ptr{Cwchar_t}, p)
+
+# construction from untyped pointers
+convert{T<:Union{Cstring,Cwstring}}(::Type{T}, p::Ptr{Void}) = box(T, p)
+
+pointer(p::Cstring) = convert(Ptr{UInt8}, p)
+pointer(p::Cwstring) = convert(Ptr{Cwchar_t}, p)
+
+# comparisons against pointers (mainly to support `cstr==C_NULL`)
+==(x::Union{Cstring,Cwstring}, y::Ptr) = pointer(x) == y
+==(x::Ptr, y::Union{Cstring,Cwstring}) = x == pointer(y)
 
 # here, not in pointer.jl, to avoid bootstrapping problems in coreimg.jl
 pointer_to_string(p::Cstring, own::Bool=false) = pointer_to_string(convert(Ptr{UInt8}, p), own)
@@ -74,7 +84,7 @@ containsnul(p::Ptr, len) = C_NULL != ccall(:memchr, Ptr{Cchar}, (Ptr{Cchar}, Cin
 function unsafe_convert(::Type{Cstring}, s::ByteString)
     p = unsafe_convert(Ptr{Cchar}, s)
     if containsnul(p, sizeof(s))
-        throw(ArgumentError("embedded NUL chars are not allowed in C strings: $(repr(s))"))
+        throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(s))"))
     end
     return Cstring(p)
 end
@@ -84,6 +94,105 @@ convert(::Type{Cstring}, s::Symbol) = Cstring(unsafe_convert(Ptr{Cchar}, s))
 
 # in string.jl: unsafe_convert(::Type{Cwstring}, s::WString)
 
+# FIXME: this should be handled by implicit conversion to Cwstring, but good luck with that
+@windows_only function cwstring(s::AbstractString)
+    bytes = bytestring(s).data
+    0 in bytes && throw(ArgumentError("embedded NULs are not allowed in C strings: $(repr(s))"))
+    return push!(utf8to16(bytes), 0)
+end
+
+# conversions between UTF-8 and UTF-16 for Windows APIs
+
+function utf8to16(src::Vector{UInt8})
+    dst = UInt16[]
+    i, n = 1, length(src)
+    n > 0 || return dst
+    sizehint!(dst, 2n)
+    a = src[1]
+    while true
+        if i < n && -64 <= a % Int8 <= -12 # multi-byte character
+            b = src[i += 1]
+            if -64 <= (b % Int8) || a == 0xf4 && 0x8f < b
+                # invalid UTF-8 (non-continuation or too-high code point)
+                push!(dst, a)
+                a = b; continue
+            elseif a < 0xe0 # 2-byte UTF-8
+                push!(dst, 0x3080 $ (UInt16(a) << 6) $ b)
+            elseif i < n # 3/4-byte character
+                c = src[i += 1]
+                if -64 <= (c % Int8) # invalid UTF-8 (non-continuation)
+                    push!(dst, a, b)
+                    a = c; continue
+                elseif a < 0xf0 # 3-byte UTF-8
+                    push!(dst, 0x2080 $ (UInt16(a) << 12) $ (UInt16(b) << 6) $ c)
+                elseif i < n
+                    d = src[i += 1]
+                    if -64 <= (d % Int8) # invalid UTF-8 (non-continuation)
+                        push!(dst, a, b, c)
+                        a = d; continue
+                    elseif a == 0xf0 && b < 0x90 # overlong encoding
+                        push!(dst, 0x2080 $ (UInt16(b) << 12) $ (UInt16(c) << 6) $ d)
+                    else # 4-byte UTF-8
+                        push!(dst, 0xe5b8 + (UInt16(a) << 8) + (UInt16(b) << 2) + (c >> 4),
+                                   0xdc80 $ (UInt16(c & 0xf) << 6) $ d)
+                    end
+                else # too short
+                    push!(dst, a, b, c)
+                    break
+                end
+            else # too short
+                push!(dst, a, b)
+                break
+            end
+        else # ASCII or invalid UTF-8 (continuation byte or too-high code point)
+            push!(dst, a)
+        end
+        i < n || break
+        a = src[i += 1]
+    end
+    return dst
+end
+
+function utf16to8(src::Vector{UInt16})
+    dst = UInt8[]
+    i, n = 1, length(src)
+    n > 0 || return dst
+    sizehint!(dst, n)
+    a = src[1]
+    while true
+        if a < 0x80 # ASCII
+            push!(dst, a % UInt8)
+        elseif a < 0x800 # 2-byte UTF-8
+            push!(dst, 0xc0 | ((a >> 6) % UInt8),
+                       0x80 | ((a % UInt8) & 0x3f))
+        elseif a & 0xfc00 == 0xd800 && i < n
+            b = src[i += 1]
+            if (b & 0xfc00) == 0xdc00
+                # 2-unit UTF-16 sequence => 4-byte UTF-8
+                a += 0x2840
+                push!(dst, 0xf0 | ((a >> 8) % UInt8),
+                           0x80 | ((a % UInt8) >> 2),
+                           0xf0 $ ((((a % UInt8) << 4) & 0x3f) $ (b >> 6) % UInt8),
+                           0x80 | ((b % UInt8) & 0x3f))
+            else
+                push!(dst, 0xe0 | ((a >> 12) % UInt8),
+                           0x80 | (((a >> 6) % UInt8) & 0x3f),
+                           0x80 | ((a % UInt8) & 0x3f))
+                a = b; continue
+            end
+        else
+            # 1-unit high UTF-16 or unpaired high surrogate
+            # either way, encode as 3-byte UTF-8 code point
+            push!(dst, 0xe0 | ((a >> 12) % UInt8),
+                       0x80 | (((a >> 6) % UInt8) & 0x3f),
+                       0x80 | ((a % UInt8) & 0x3f))
+        end
+        i < n || break
+        a = src[i += 1]
+    end
+    return dst
+end
+
 # deferring (or un-deferring) ctrl-c handler for external C code that
 # is not interrupt safe (see also issue #2622).  The sigatomic_begin/end
 # functions should always be called in matched pairs, ideally via:
diff --git a/base/cartesian.jl b/base/cartesian.jl
index b765cded4b95e..0a5a1e9aa9948 100644
--- a/base/cartesian.jl
+++ b/base/cartesian.jl
@@ -2,11 +2,39 @@
 
 module Cartesian
 
-export @nloops, @nref, @ncall, @nexprs, @nextract, @nall, @ntuple, @nif
+export @nloops, @nref, @ncall, @nexprs, @nextract, @nall, @nany, @ntuple, @nif
 
 ### Cartesian-specific macros
 
-# Generate nested loops
+"""
+    @nloops N itersym rangeexpr bodyexpr
+    @nloops N itersym rangeexpr preexpr bodyexpr
+    @nloops N itersym rangeexpr preexpr postexpr bodyexpr
+
+Generate `N` nested loops, using `itersym` as the prefix for the iteration variables.
+`rangeexpr` may be an anonymous-function expression, or a simple symbol `var` in which case
+the range is `1:size(var,d)` for dimension `d`.
+
+Optionally, you can provide "pre" and "post" expressions. These get executed first and last,
+respectively, in the body of each loop. For example:
+
+    @nloops 2 i A d->j_d=min(i_d,5) begin
+        s += @nref 2 A j
+    end
+
+would generate:
+
+    for i_2 = 1:size(A, 2)
+        j_2 = min(i_2, 5)
+        for i_1 = 1:size(A, 1)
+            j_1 = min(i_1, 5)
+            s += A[j_1,j_2]
+        end
+    end
+
+If you want just a post-expression, supply `nothing` for the pre-expression. Using
+parentheses and semicolons, you can supply multi-statement expressions.
+"""
 macro nloops(N, itersym, rangeexpr, args...)
     _nloops(N, itersym, rangeexpr, args...)
 end
@@ -38,7 +66,12 @@ function _nloops(N::Int, itersym::Symbol, rangeexpr::Expr, args::Expr...)
     ex
 end
 
-# Generate expression A[i1, i2, ...]
+"""
+    @nref N A indexexpr
+
+Generate expressions like `A[i_1,i_2,...]`. `indexexpr` can either be an iteration-symbol
+prefix, or an anonymous-function expression.
+"""
 macro nref(N, A, sym)
     _nref(N, A, sym)
 end
@@ -48,7 +81,21 @@ function _nref(N::Int, A::Symbol, ex)
     Expr(:escape, Expr(:ref, A, vars...))
 end
 
-# Generate f(arg1, arg2, ...)
+"""
+    @ncall N f sym...
+
+Generate a function call expression. `sym` represents any number of function arguments, the
+last of which may be an anonymous-function expression and is expanded into `N` arguments.
+
+For example `@ncall 3 func a` generates
+
+    func(a_1, a_2, a_3)
+
+while `@ncall 2 func a b i->c[i]` yields
+
+    func(a, b, c[1], c[2])
+
+"""
 macro ncall(N, f, sym...)
     _ncall(N, f, sym...)
 end
@@ -60,7 +107,11 @@ function _ncall(N::Int, f, args...)
     Expr(:escape, Expr(:call, f, pre..., vars...))
 end
 
-# Generate N expressions
+"""
+    @nexprs N expr
+
+Generate `N` expressions. `expr` should be an anonymous-function expression.
+"""
 macro nexprs(N, ex)
     _nexprs(N, ex)
 end
@@ -70,7 +121,24 @@ function _nexprs(N::Int, ex::Expr)
     Expr(:escape, Expr(:block, exs...))
 end
 
-# Make variables esym1, esym2, ... = isym
+"""
+    @nextract N esym isym
+
+Generate `N` variables `esym_1`, `esym_2`, ..., `esym_N` to extract values from `isym`.
+`isym` can be either a `Symbol` or anonymous-function expression.
+
+`@nextract 2 x y` would generate
+
+    x_1 = y[1]
+    x_2 = y[2]
+
+while `@nextract 3 x d->y[2d-1]` yields
+
+    x_1 = y[1]
+    x_2 = y[3]
+    x_3 = y[5]
+
+"""
 macro nextract(N, esym, isym)
     _nextract(N, esym, isym)
 end
@@ -85,7 +153,15 @@ function _nextract(N::Int, esym::Symbol, ex::Expr)
     Expr(:block, aexprs...)
 end
 
-# Check whether variables i1, i2, ... all satisfy criterion
+"""
+    @nall N expr
+
+Check whether all of the expressions generated by the anonymous-function expression `expr`
+evaluate to `true`.
+
+`@nall 3 d->(i_d > 1)` would generate the expression `(i_1 > 1 && i_2 > 1 && i_3 > 1)`. This
+can be convenient for bounds-checking.
+"""
 macro nall(N, criterion)
     _nall(N, criterion)
 end
@@ -98,6 +174,32 @@ function _nall(N::Int, criterion::Expr)
     Expr(:&&, conds...)
 end
 
+"""
+    @nany N expr
+
+Check whether any of the expressions generated by the anonymous-function expression `expr`
+evaluate to `true`.
+
+`@nany 3 d->(i_d > 1)` would generate the expression `(i_1 > 1 || i_2 > 1 || i_3 > 1)`.
+"""
+macro nany(N, criterion)
+    _nany(N, criterion)
+end
+
+function _nany(N::Int, criterion::Expr)
+    if criterion.head != :->
+        error("Second argument must be an anonymous function expression yielding the criterion")
+    end
+    conds = [Expr(:escape, inlineanonymous(criterion, i)) for i = 1:N]
+    Expr(:||, conds...)
+end
+
+"""
+    @ntuple N expr
+
+Generates an `N`-tuple. `@ntuple 2 i` would generate `(i_1, i_2)`, and `@ntuple 2 k->k+1`
+would generate `(2,3)`.
+"""
 macro ntuple(N, ex)
     _ntuple(N, ex)
 end
@@ -107,8 +209,24 @@ function _ntuple(N::Int, ex)
     Expr(:escape, Expr(:tuple, vars...))
 end
 
-# if condition1; operation1; elseif condition2; operation2; else operation3
-# You can pass one or two operations; the second, if present, is used in the final "else"
+"""
+    @nif N conditionexpr expr
+    @nif N conditionexpr expr elseexpr
+
+Generates a sequence of `if ... elseif ... else ... end` statements. For example:
+
+    @nif 3 d->(i_d >= size(A,d)) d->(error("Dimension ", d, " too big")) d->println("All OK")
+
+would generate:
+
+    if i_1 > size(A, 1)
+        error("Dimension ", 1, " too big")
+    elseif i_2 > size(A, 2)
+        error("Dimension ", 2, " too big")
+    else
+        println("All OK")
+    end
+"""
 macro nif(N, condition, operation...)
     # Handle the final "else"
     ex = esc(inlineanonymous(length(operation) > 1 ? operation[2] : operation[1], N))
diff --git a/base/channels.jl b/base/channels.jl
index 4d1b1c881a9cb..34778b1585b3a 100644
--- a/base/channels.jl
+++ b/base/channels.jl
@@ -1,28 +1,23 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-abstract AbstractChannel{T}
+abstract AbstractChannel
 
-type Channel{T} <: AbstractChannel{T}
+const DEF_CHANNEL_SZ=32
+
+type Channel{T} <: AbstractChannel
     cond_take::Condition    # waiting for data to become available
     cond_put::Condition     # waiting for a writeable slot
     state::Symbol
 
     data::Array{T,1}
-    szp1::Int               # current channel size plus one
     sz_max::Int             # maximum size of channel
-    take_pos::Int           # read position
-    put_pos::Int            # write position
 
     function Channel(sz)
         sz_max = sz == typemax(Int) ? typemax(Int) - 1 : sz
-        szp1 = sz > 32 ? 33 : sz+1
-        new(Condition(), Condition(), :open,
-            Array(T, szp1), szp1, sz_max, 1, 1)
+        new(Condition(), Condition(), :open, Array(T, 0), sz_max)
     end
 end
 
-const DEF_CHANNEL_SZ=32
-
 Channel(sz::Int = DEF_CHANNEL_SZ) = Channel{Any}(sz)
 
 closed_exception() = InvalidStateException("Channel is closed.", :closed)
@@ -40,53 +35,32 @@ end
 
 function put!(c::Channel, v)
     !isopen(c) && throw(closed_exception())
-    d = c.take_pos - c.put_pos
-    if (d == 1) || (d == -(c.szp1-1))
-        # grow the channel if possible
-        if (c.szp1 - 1) < c.sz_max
-            if ((c.szp1-1) * 2) > c.sz_max
-                c.szp1 = c.sz_max + 1
-            else
-                c.szp1 = ((c.szp1-1) * 2) + 1
-            end
-            newdata = Array(eltype(c), c.szp1)
-            if c.put_pos > c.take_pos
-                copy!(newdata, 1, c.data, c.take_pos, (c.put_pos - c.take_pos))
-                c.put_pos = c.put_pos - c.take_pos + 1
-            else
-                len_first_part = length(c.data) - c.take_pos + 1
-                copy!(newdata, 1, c.data, c.take_pos, len_first_part)
-                copy!(newdata, len_first_part+1, c.data, 1, c.put_pos-1)
-                c.put_pos = len_first_part + c.put_pos
-            end
-            c.take_pos = 1
-            c.data = newdata
-        else
-            wait(c.cond_put)
-        end
+    while length(c.data) == c.sz_max
+        wait(c.cond_put)
     end
-
-    c.data[c.put_pos] = v
-    c.put_pos = (c.put_pos == c.szp1 ? 1 : c.put_pos + 1)
+    push!(c.data, v)
     notify(c.cond_take, nothing, true, false)  # notify all, since some of the waiters may be on a "fetch" call.
     v
 end
 
+push!(c::Channel, v) = put!(c, v)
+
 function fetch(c::Channel)
     wait(c)
-    c.data[c.take_pos]
+    c.data[1]
 end
 
 function take!(c::Channel)
     !isopen(c) && !isready(c) && throw(closed_exception())
     wait(c)
-    v = c.data[c.take_pos]
-    c.take_pos = (c.take_pos == c.szp1 ? 1 : c.take_pos + 1)
+    v = shift!(c.data)
     notify(c.cond_put, nothing, false, false) # notify only one, since only one slot has become available for a put!.
     v
 end
 
-isready(c::Channel) = (c.take_pos == c.put_pos ? false : true)
+shift!(c::Channel) = take!(c)
+
+isready(c::Channel) = n_avail(c) > 0
 
 function wait(c::Channel)
     while !isready(c)
@@ -102,13 +76,7 @@ end
 
 eltype{T}(::Type{Channel{T}}) = T
 
-function n_avail(c::Channel)
-    if c.put_pos >= c.take_pos
-        return c.put_pos - c.take_pos
-    else
-        return c.szp1 - c.take_pos + c.put_pos
-    end
-end
+n_avail(c::Channel) = length(c.data)
 
 show(io::IO, c::Channel) = print(io, "$(typeof(c))(sz_max:$(c.sz_max),sz_curr:$(n_avail(c)))")
 
diff --git a/base/char.jl b/base/char.jl
index 7999f4074b090..c99498582b349 100644
--- a/base/char.jl
+++ b/base/char.jl
@@ -7,8 +7,8 @@ convert{T<:Number}(::Type{T}, x::Char) = convert(T, UInt32(x))
 
 rem{T<:Number}(x::Char, ::Type{T}) = rem(UInt32(x), T)
 
-typemax(::Type{Char}) = Char(typemax(UInt32))
-typemin(::Type{Char}) = Char(typemin(UInt32))
+typemax(::Type{Char}) = reinterpret(Char, typemax(UInt32))
+typemin(::Type{Char}) = reinterpret(Char, typemin(UInt32))
 
 size(c::Char) = ()
 size(c::Char,d) = convert(Int, d) < 1 ? throw(BoundsError()) : 1
@@ -38,15 +38,48 @@ isless(x::Char, y::Integer) = isless(UInt32(x), y)
 isless(x::Integer, y::Char) = isless(x, UInt32(y))
 
 -(x::Char, y::Char) = Int(x) - Int(y)
--(x::Char, y::Integer) = reinterpret(Char, Int32(x) - Int32(y))
-+(x::Char, y::Integer) = reinterpret(Char, Int32(x) + Int32(y))
+-(x::Char, y::Integer) = Char(Int32(x) - Int32(y))
++(x::Char, y::Integer) = Char(Int32(x) + Int32(y))
 +(x::Integer, y::Char) = y + x
 
+Base.promote_op{I<:Integer}(::Base.SubFun, ::Type{Char}, ::Type{I}) = Char
+Base.promote_op{I<:Integer}(::Base.AddFun, ::Type{Char}, ::Type{I}) = Char
+Base.promote_op{I<:Integer}(::Base.AddFun, ::Type{I}, ::Type{Char}) = Char
+
 bswap(x::Char) = Char(bswap(UInt32(x)))
 
 print(io::IO, c::Char) = (write(io, c); nothing)
+
+const hex_chars = UInt8['0':'9';'a':'z']
+
 function show(io::IO, c::Char)
-    print(io, '\'')
-    print_escaped(io, utf32(c), "'")
-    print(io, '\'')
+    if c <= '\\'
+        b = c == '\0' ? 0x30 :
+            c == '\a' ? 0x61 :
+            c == '\b' ? 0x62 :
+            c == '\t' ? 0x74 :
+            c == '\n' ? 0x6e :
+            c == '\v' ? 0x76 :
+            c == '\f' ? 0x66 :
+            c == '\r' ? 0x72 :
+            c == '\e' ? 0x65 :
+            c == '\'' ? 0x27 :
+            c == '\\' ? 0x5c : 0xff
+        if b != 0xff
+            write(io, 0x27, 0x5c, b, 0x27)
+            return
+        end
+    end
+    if isprint(c)
+        write(io, 0x27, c, 0x27)
+    else
+        u = UInt32(c)
+        write(io, 0x27, 0x5c, c <= '\x7f' ? 0x78 : c <= '\uffff' ? 0x75 : 0x55)
+        d = max(2, 8 - (leading_zeros(u) >> 2))
+        while 0 < d
+            write(io, hex_chars[((u >> ((d -= 1) << 2)) & 0xf) + 1])
+        end
+        write(io, 0x27)
+    end
+    return
 end
diff --git a/base/checked.jl b/base/checked.jl
new file mode 100644
index 0000000000000..217f800e06b84
--- /dev/null
+++ b/base/checked.jl
@@ -0,0 +1,356 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# Support for checked integer arithmetic
+
+module Checked
+
+export checked_neg, checked_abs, checked_add, checked_sub, checked_mul,
+       checked_div, checked_rem, checked_fld, checked_mod, checked_cld
+
+import Core.Intrinsics: box, unbox,
+       checked_sadd_int, checked_ssub_int, checked_smul_int, checked_sdiv_int,
+       checked_srem_int,
+       checked_uadd_int, checked_usub_int, checked_umul_int, checked_udiv_int,
+       checked_urem_int
+import Base: no_op_err
+
+# define promotion behavior for checked operations
+checked_add(x::Integer, y::Integer) = checked_add(promote(x,y)...)
+checked_sub(x::Integer, y::Integer) = checked_sub(promote(x,y)...)
+checked_mul(x::Integer, y::Integer) = checked_mul(promote(x,y)...)
+checked_div(x::Integer, y::Integer) = checked_div(promote(x,y)...)
+checked_rem(x::Integer, y::Integer) = checked_rem(promote(x,y)...)
+checked_fld(x::Integer, y::Integer) = checked_fld(promote(x,y)...)
+checked_mod(x::Integer, y::Integer) = checked_mod(promote(x,y)...)
+checked_cld(x::Integer, y::Integer) = checked_cld(promote(x,y)...)
+
+# fallback catchall rules to prevent infinite recursion if promotion succeeds,
+# but no method exists to handle those types
+checked_neg{T<:Integer}(x::T) = no_op_err("checked_neg", T)
+checked_abs{T<:Integer}(x::T) = no_op_err("checked_abs", T)
+checked_add{T<:Integer}(x::T, y::T) = no_op_err("checked_add", T)
+checked_sub{T<:Integer}(x::T, y::T) = no_op_err("checked_sub", T)
+checked_mul{T<:Integer}(x::T, y::T) = no_op_err("checked_mul", T)
+checked_div{T<:Integer}(x::T, y::T) = no_op_err("checked_div", T)
+checked_rem{T<:Integer}(x::T, y::T) = no_op_err("checked_rem", T)
+checked_fld{T<:Integer}(x::T, y::T) = no_op_err("checked_fld", T)
+checked_mod{T<:Integer}(x::T, y::T) = no_op_err("checked_mod", T)
+checked_cld{T<:Integer}(x::T, y::T) = no_op_err("checked_cld", T)
+
+typealias SignedInt Union{Int8,Int16,Int32,Int64,Int128}
+typealias UnsignedInt Union{UInt8,UInt16,UInt32,UInt64,UInt128,Bool}
+
+# LLVM has several code generation bugs for checked integer arithmetic (see e.g.
+# #4905). We thus distinguish between operations that can be implemented via
+# intrinsics, and operations for which we have to provide work-arounds.
+
+# Note: As far as this code has been tested, most checked_* functions are
+# working fine in LLVM. (Note that division is still handled via `base/int.jl`,
+# which always checks for overflow, and which provides its own sets of
+# work-arounds for LLVM codegen bugs.) However, the comments in `base/int.jl`
+# and in issue #4905 are more pessimistic. For the time being, we thus retain
+# the ability to handle codegen bugs in LLVM, until the code here has been
+# tested on more systems and architectures. It also seems that things depend on
+# which compiler that was used to build LLVM (i.e. either gcc or clang).
+
+# These unions are used for most checked functions:
+#     BrokenSignedInt
+#     BrokenUnsignedInt
+# These unions are used for checked_{mul,div,rem}:
+#     BrokenSignedIntMul
+#     BrokenUnsignedIntMul
+
+# This code runs early during bootstrap, and we can't use Julia's version
+# strings yet
+const llvm_version = Int(ccall(:jl_get_LLVM_VERSION, UInt32, ()))
+
+brokenSignedInt = Union{}
+brokenUnsignedInt = Union{}
+brokenSignedIntMul = Int128
+brokenUnsignedIntMul = UInt128
+if WORD_SIZE == 32
+    brokenSignedIntMul = Union{brokenSignedIntMul, Int64}
+    brokenUnsignedIntMul = Union{brokenUnsignedIntMul, UInt64}
+end
+if llvm_version < 30500
+    brokenSignedIntMul = Union{brokenSignedIntMul, Int8}
+    brokenUnsignedIntMul = Union{brokenUnsignedIntMul, UInt8}
+end
+typealias BrokenSignedInt brokenSignedInt
+typealias BrokenUnsignedInt brokenUnsignedInt
+typealias BrokenSignedIntMul brokenSignedIntMul
+typealias BrokenUnsignedIntMul brokenUnsignedIntMul
+# Use these definitions to test the non-LLVM implementations
+# typealias BrokenSignedInt SignedInt
+# typealias BrokenUnsignedInt UnsignedInt
+# typealias BrokenSignedIntMul SignedInt
+# typealias BrokenUnsignedIntMul UnsignedInt
+
+"""
+    Base.checked_neg(x)
+
+Calculates `-x`, checking for overflow errors where applicable. For
+example, standard two's complement signed integers (e.g. `Int`) cannot
+represent `-typemin(Int)`, thus leading to an overflow.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_neg end
+
+function checked_neg{T<:SignedInt}(x::T)
+    checked_sub(T(0), x)
+end
+function checked_neg{T<:UnsignedInt}(x::T)
+    checked_sub(T(0), x)
+end
+if BrokenSignedInt != Union{}
+function checked_neg{T<:BrokenSignedInt}(x::T)
+    r = -x
+    (x<0) & (r<0) && throw(OverflowError())
+    r
+end
+end
+if BrokenUnsignedInt != Union{}
+function checked_neg{T<:BrokenUnsignedInt}(x::T)
+    x != 0 && throw(OverflowError())
+    T(0)
+end
+end
+
+"""
+    Base.checked_abs(x)
+
+Calculates `abs(x)`, checking for overflow errors where applicable.
+For example, standard two's complement signed integers (e.g. `Int`)
+cannot represent `abs(typemin(Int))`, thus leading to an overflow.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_abs end
+
+function checked_abs(x::SignedInt)
+    r = ifelse(x<0, -x, x)
+    r<0 && throw(OverflowError())
+    r
+ end
+checked_abs(x::UnsignedInt) = x
+
+"""
+    Base.checked_add(x, y)
+
+Calculates `x+y`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_add end
+
+function checked_add{T<:SignedInt}(x::T, y::T)
+    box(T, checked_sadd_int(unbox(T,x), unbox(T,y)))
+end
+function checked_add{T<:UnsignedInt}(x::T, y::T)
+    box(T, checked_uadd_int(unbox(T,x), unbox(T,y)))
+end
+if BrokenSignedInt != Union{}
+function checked_add{T<:BrokenSignedInt}(x::T, y::T)
+    r = x + y
+    # x and y have the same sign, and the result has a different sign
+    (x<0) == (y<0) != (r<0) && throw(OverflowError())
+    r
+end
+end
+if BrokenUnsignedInt != Union{}
+function checked_add{T<:BrokenUnsignedInt}(x::T, y::T)
+    # x + y > typemax(T)
+    # Note: ~y == -y-1
+    x > ~y && throw(OverflowError())
+    x + y
+end
+end
+checked_add(x::Bool, y::Bool) = x + y
+checked_add(x::Bool) = +x
+
+# Handle multiple arguments
+checked_add(x) = x
+checked_add{T}(x1::T, x2::T, x3::T) =
+    checked_add(checked_add(x1, x2), x3)
+checked_add{T}(x1::T, x2::T, x3::T, x4::T) =
+    checked_add(checked_add(x1, x2), x3, x4)
+checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T) =
+    checked_add(checked_add(x1, x2), x3, x4, x5)
+checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T) =
+    checked_add(checked_add(x1, x2), x3, x4, x5, x6)
+checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T) =
+    checked_add(checked_add(x1, x2), x3, x4, x5, x6, x7)
+checked_add{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T, x8::T) =
+    checked_add(checked_add(x1, x2), x3, x4, x5, x6, x7, x8)
+
+"""
+    Base.checked_sub(x, y)
+
+Calculates `x-y`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_sub end
+
+function checked_sub{T<:SignedInt}(x::T, y::T)
+    box(T, checked_ssub_int(unbox(T,x), unbox(T,y)))
+end
+function checked_sub{T<:UnsignedInt}(x::T, y::T)
+    box(T, checked_usub_int(unbox(T,x), unbox(T,y)))
+end
+if BrokenSignedInt != Union{}
+function checked_sub{T<:BrokenSignedInt}(x::T, y::T)
+    r = x - y
+    # x and y have different signs, and the result has a different sign than x
+    (x<0) != (y<0) == (r<0) && throw(OverflowError())
+    r
+end
+end
+if BrokenUnsignedInt != Union{}
+function checked_sub{T<:BrokenUnsignedInt}(x::T, y::T)
+    # x - y < 0
+    x < y && throw(OverflowError())
+    x - y
+end
+end
+checked_sub(x::Bool, y::Bool) = x - y
+checked_sub(x::Bool) = -x
+
+"""
+    Base.checked_mul(x, y)
+
+Calculates `x*y`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_mul end
+
+function checked_mul{T<:SignedInt}(x::T, y::T)
+    box(T, checked_smul_int(unbox(T,x), unbox(T,y)))
+end
+function checked_mul{T<:UnsignedInt}(x::T, y::T)
+    box(T, checked_umul_int(unbox(T,x), unbox(T,y)))
+end
+if BrokenSignedIntMul != Union{} && BrokenSignedIntMul != Int128
+function checked_mul{T<:BrokenSignedIntMul}(x::T, y::T)
+    r = widemul(x, y)
+    r % T != r && throw(OverflowError())
+    r % T
+end
+end
+if BrokenUnsignedIntMul != Union{} && BrokenUnsignedIntMul != UInt128
+function checked_mul{T<:BrokenUnsignedIntMul}(x::T, y::T)
+    r = widemul(x, y)
+    r % T != r && throw(OverflowError())
+    r % T
+end
+end
+if Int128 <: BrokenSignedIntMul
+    # Avoid BigInt
+    function checked_mul{T<:Int128}(x::T, y::T)
+        if y > 0
+            # x * y > typemax(T)
+            # x * y < typemin(T)
+            x > fld(typemax(T), y) && throw(OverflowError())
+            x < cld(typemin(T), y) && throw(OverflowError())
+        elseif y < 0
+            # x * y > typemax(T)
+            # x * y < typemin(T)
+            x < cld(typemax(T), y) && throw(OverflowError())
+            # y == -1 can overflow fld
+            y != -1 && x > fld(typemin(T), y) && throw(OverflowError())
+        end
+        x * y
+    end
+end
+if UInt128 <: BrokenUnsignedIntMul
+    # Avoid BigInt
+    function checked_mul{T<:UInt128}(x::T, y::T)
+        # x * y > typemax(T)
+        y > 0 && x > fld(typemax(T), y) && throw(OverflowError())
+        x * y
+    end
+end
+
+# Handle multiple arguments
+checked_mul(x) = x
+checked_mul{T}(x1::T, x2::T, x3::T) =
+    checked_mul(checked_mul(x1, x2), x3)
+checked_mul{T}(x1::T, x2::T, x3::T, x4::T) =
+    checked_mul(checked_mul(x1, x2), x3, x4)
+checked_mul{T}(x1::T, x2::T, x3::T, x4::T, x5::T) =
+    checked_mul(checked_mul(x1, x2), x3, x4, x5)
+checked_mul{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T) =
+    checked_mul(checked_mul(x1, x2), x3, x4, x5, x6)
+checked_mul{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T) =
+    checked_mul(checked_mul(x1, x2), x3, x4, x5, x6, x7)
+checked_mul{T}(x1::T, x2::T, x3::T, x4::T, x5::T, x6::T, x7::T, x8::T) =
+    checked_mul(checked_mul(x1, x2), x3, x4, x5, x6, x7, x8)
+
+"""
+    Base.checked_div(x, y)
+
+Calculates `div(x,y)`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_div end
+
+# Base.div already checks; nothing to do here
+checked_div{T<:SignedInt}(x::T, y::T) = div(x, y)
+checked_div{T<:UnsignedInt}(x::T, y::T) = div(x, y)
+
+"""
+    Base.checked_rem(x, y)
+
+Calculates `x%y`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_rem end
+
+# Base.rem already checks; nothing to do here
+checked_rem{T<:SignedInt}(x::T, y::T) = rem(x, y)
+checked_rem{T<:UnsignedInt}(x::T, y::T) = rem(x, y)
+
+"""
+    Base.checked_fld(x, y)
+
+Calculates `fld(x,y)`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_fld end
+
+# Base.fld already checks; nothing to do here
+checked_fld{T<:SignedInt}(x::T, y::T) = fld(x, y)
+checked_fld{T<:UnsignedInt}(x::T, y::T) = fld(x, y)
+
+"""
+    Base.checked_mod(x, y)
+
+Calculates `mod(x,y)`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_mod end
+
+# Base.mod already checks; nothing to do here
+checked_mod{T<:SignedInt}(x::T, y::T) = mod(x, y)
+checked_mod{T<:UnsignedInt}(x::T, y::T) = mod(x, y)
+
+"""
+    Base.checked_cld(x, y)
+
+Calculates `cld(x,y)`, checking for overflow errors where applicable.
+
+The overflow protection may impose a perceptible performance penalty.
+"""
+function checked_cld end
+
+# Base.cld already checks; nothing to do here
+checked_cld{T<:SignedInt}(x::T, y::T) = cld(x, y)
+checked_cld{T<:UnsignedInt}(x::T, y::T) = cld(x, y)
+
+end
diff --git a/base/client.jl b/base/client.jl
index 664c7b65323da..d74d4fdbd06a3 100644
--- a/base/client.jl
+++ b/base/client.jl
@@ -3,8 +3,6 @@
 ## client.jl - frontend handling command line options, environment setup,
 ##             and REPL
 
-const ARGS = UTF8String[]
-
 const text_colors = AnyDict(
     :black   => "\033[1m\033[30m",
     :red     => "\033[1m\033[31m",
@@ -18,26 +16,42 @@ const text_colors = AnyDict(
     :bold    => "\033[1m",
 )
 
+# Create a docstring with an automatically generated list
+# of colors.
+const possible_formatting_symbols = [:normal, :bold]
+available_text_colors = collect(keys(text_colors))
+available_text_colors =
+    cat(1, intersect(available_text_colors, possible_formatting_symbols),
+        sort(setdiff(  available_text_colors, possible_formatting_symbols)))
+
+const available_text_colors_docstring =
+    string(join([string("`:", key,"`")
+                 for key in available_text_colors], ",\n", ", or \n"))
+
+"""Dictionary of color codes for the terminal.
+
+Available colors are: $available_text_colors_docstring.
+"""
+text_colors
+
 have_color = false
-@unix_only default_color_answer = text_colors[:bold]
-@unix_only default_color_input = text_colors[:bold]
-@windows_only default_color_answer = text_colors[:normal]
-@windows_only default_color_input = text_colors[:normal]
+default_color_warn = :red
+default_color_info = :blue
+@unix_only default_color_input = :bold
+@unix_only default_color_answer = :bold
+@windows_only default_color_input = :normal
+@windows_only default_color_answer = :normal
 color_normal = text_colors[:normal]
 
-function answer_color()
-    c = symbol(get(ENV, "JULIA_ANSWER_COLOR", ""))
-    return get(text_colors, c, default_color_answer)
-end
-
-function input_color()
-    c = symbol(get(ENV, "JULIA_INPUT_COLOR", ""))
-    return get(text_colors, c, default_color_input)
+function repl_color(key, default)
+    c = symbol(get(ENV, key, ""))
+    haskey(text_colors, c) ? c : default
 end
 
-exit(n) = ccall(:jl_exit, Void, (Int32,), n)
-exit() = exit(0)
-quit() = exit()
+warn_color()   = repl_color("JULIA_WARN_COLOR", default_color_warn)
+info_color()   = repl_color("JULIA_INFO_COLOR", default_color_info)
+input_color()  = text_colors[repl_color("JULIA_INPUT_COLOR", default_color_input)]
+answer_color() = text_colors[repl_color("JULIA_ANSWER_COLOR", default_color_answer)]
 
 function repl_cmd(cmd, out)
     shell = shell_split(get(ENV,"JULIA_SHELL",get(ENV,"SHELL","/bin/sh")))
@@ -76,11 +90,6 @@ function repl_cmd(cmd, out)
     nothing
 end
 
-function repl_hook(input::AbstractString)
-    Expr(:call, :(Base.repl_cmd),
-         macroexpand(Expr(:macrocall,symbol("@cmd"),input)))
-end
-
 display_error(er) = display_error(er, [])
 function display_error(er, bt)
     with_output_color(:red, STDERR) do io
@@ -186,154 +195,76 @@ end
 # try to include() a file, ignoring if not found
 try_include(path::AbstractString) = isfile(path) && include(path)
 
-# initialize the local proc network address / port
-function init_bind_addr()
-    opts = JLOptions()
-    if opts.bindto != C_NULL
-        bind_to = split(bytestring(opts.bindto), ":")
-        bind_addr = string(parseip(bind_to[1]))
-        if length(bind_to) > 1
-            bind_port = parse(Int,bind_to[2])
-        else
-            bind_port = 0
-        end
-    else
-        bind_port = 0
-        try
-            bind_addr = string(getipaddr())
-        catch
-            # All networking is unavailable, initialize bind_addr to the loopback address
-            # Will cause an exception to be raised only when used.
-            bind_addr = "127.0.0.1"
+function process_options(opts::JLOptions)
+    if !isempty(ARGS)
+        idxs = find(x -> x == "--", ARGS)
+        if length(idxs) > 1
+            println(STDERR, "julia: redundant option terminator `--`")
+            exit(1)
         end
+        deleteat!(ARGS, idxs)
     end
-    global LPROC
-    LPROC.bind_addr = bind_addr
-    LPROC.bind_port = UInt16(bind_port)
-end
+    repl                  = true
+    startup               = (opts.startupfile != 2)
+    history_file          = (opts.historyfile != 0)
+    quiet                 = (opts.quiet != 0)
+    color_set             = (opts.color != 0)
+    global have_color     = (opts.color == 1)
+    global is_interactive = (opts.isinteractive != 0)
+    while true
+        # load ~/.juliarc file
+        startup && load_juliarc()
 
-# NOTE: This set of required arguments need to be kept in sync with the required arguments defined in ui/repl.c
-let reqarg = Set(UTF8String["--home",          "-H",
-                            "--eval",          "-e",
-                            "--print",         "-E",
-                            "--post-boot",     "-P",
-                            "--load",          "-L",
-                            "--sysimage",      "-J",
-                            "--cpu-target",    "-C",
-                            "--procs",         "-p",
-                            "--machinefile",
-                            "--color",
-                            "--history-file",
-                            "--startup-file",
-                            "--compile",
-                            "--check-bounds",
-                            "--depwarn",
-                            "--inline",
-                            "--output-o",
-                            "--output-ji",
-                            "--output-bc",
-                            "--bind-to",
-                            "--precompiled"])
-    global process_options
-    function process_options(opts::JLOptions, args::Vector{UTF8String})
-        if !isempty(args)
-            arg = first(args)
-            if !isempty(arg) && arg[1] == '-' && in(arg, reqarg)
-                println(STDERR, "julia: option `$arg` is missing an argument")
-                exit(1)
-            end
-            idxs = find(x -> x == "--", args)
-            if length(idxs) > 1
-                println(STDERR, "julia: redundant option terminator `--`")
-                exit(1)
-            end
-            deleteat!(ARGS, idxs)
+        # startup worker
+        if opts.worker != 0
+            start_worker() # does not return
         end
-        repl                  = true
-        startup               = (opts.startupfile != 2)
-        history_file          = (opts.historyfile != 0)
-        quiet                 = (opts.quiet != 0)
-        color_set             = (opts.color != 0)
-        global have_color     = (opts.color == 1)
-        global is_interactive = (opts.isinteractive != 0)
-        while true
-            # load ~/.juliarc file
-            startup && load_juliarc()
-
-            # startup worker
-            if opts.worker != 0
-                start_worker() # does not return
-            end
-            # add processors
-            if opts.nprocs > 0
-                addprocs(opts.nprocs)
-            end
-            # load processes from machine file
-            if opts.machinefile != C_NULL
-                addprocs(load_machine_file(bytestring(opts.machinefile)))
-            end
-            # load file immediately on all processors
-            if opts.load != C_NULL
-                @sync for p in procs()
-                    @async remotecall_fetch(p, include, bytestring(opts.load))
-                end
-            end
-            # eval expression
-            if opts.eval != C_NULL
-                repl = false
-                eval(Main, parse_input_line(bytestring(opts.eval)))
-                break
-            end
-            # eval expression and show result
-            if opts.print != C_NULL
-                repl = false
-                show(eval(Main, parse_input_line(bytestring(opts.print))))
-                println()
-                break
-            end
-            # eval expression but don't disable interactive mode
-            if opts.postboot != C_NULL
-                eval(Main, parse_input_line(bytestring(opts.postboot)))
-            end
-            # load file
-            if !isempty(args)
-                if !isempty(args[1]) && args[1][1] != '-'
-                    # program
-                    repl = false
-                    # remove filename from ARGS
-                    shift!(ARGS)
-                    if !is_interactive
-                        ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
-                    end
-                    include(args[1])
-                else
-                    println(STDERR, "julia: unknown option `$(args[1])`")
-                    exit(1)
-                end
+        # add processors
+        if opts.nprocs > 0
+            addprocs(opts.nprocs)
+        end
+        # load processes from machine file
+        if opts.machinefile != C_NULL
+            addprocs(load_machine_file(bytestring(opts.machinefile)))
+        end
+        # load file immediately on all processors
+        if opts.load != C_NULL
+            @sync for p in procs()
+                @async remotecall_fetch(include, p, bytestring(opts.load))
             end
+        end
+        # eval expression
+        if opts.eval != C_NULL
+            repl = false
+            eval(Main, parse_input_line(bytestring(opts.eval)))
             break
         end
-        repl |= is_interactive
-        return (quiet,repl,startup,color_set,history_file)
-    end
-end
-
-const roottask = current_task()
-
-is_interactive = false
-isinteractive() = (is_interactive::Bool)
-
-const LOAD_PATH = ByteString[]
-const LOAD_CACHE_PATH = ByteString[]
-function init_load_path()
-    vers = "v$(VERSION.major).$(VERSION.minor)"
-    if haskey(ENV,"JULIA_LOAD_PATH")
-        prepend!(LOAD_PATH, split(ENV["JULIA_LOAD_PATH"], @windows? ';' : ':'))
+        # eval expression and show result
+        if opts.print != C_NULL
+            repl = false
+            show(eval(Main, parse_input_line(bytestring(opts.print))))
+            println()
+            break
+        end
+        # eval expression but don't disable interactive mode
+        if opts.postboot != C_NULL
+            eval(Main, parse_input_line(bytestring(opts.postboot)))
+        end
+        # load file
+        if !isempty(ARGS) && !isempty(ARGS[1])
+            # program
+            repl = false
+            # remove filename from ARGS
+            global PROGRAM_FILE = UTF8String(shift!(ARGS))
+            if !is_interactive
+                ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
+            end
+            include(PROGRAM_FILE)
+        end
+        break
     end
-    push!(LOAD_PATH,abspath(JULIA_HOME,"..","local","share","julia","site",vers))
-    push!(LOAD_PATH,abspath(JULIA_HOME,"..","share","julia","site",vers))
-    push!(LOAD_CACHE_PATH,abspath(Pkg.Dir._pkgroot(),"lib",vers))
-    push!(LOAD_CACHE_PATH,abspath(JULIA_HOME,"..","usr","lib","julia")) #TODO: fixme
+    repl |= is_interactive
+    return (quiet,repl,startup,color_set,history_file)
 end
 
 function load_juliarc()
@@ -349,7 +280,7 @@ end
 
 function load_machine_file(path::AbstractString)
     machines = []
-    for line in split(readall(path),'\n'; keep=false)
+    for line in split(readstring(path),'\n'; keep=false)
         s = map!(strip, split(line,'*'; keep=false))
         if length(s) > 1
             cnt = isnumber(s[1]) ? parse(Int,s[1]) : symbol(s[1])
@@ -361,32 +292,6 @@ function load_machine_file(path::AbstractString)
     return machines
 end
 
-function early_init()
-    global const JULIA_HOME = ccall(:jl_get_julia_home, Any, ())
-    # make sure OpenBLAS does not set CPU affinity (#1070, #9639)
-    ENV["OPENBLAS_MAIN_FREE"] = get(ENV, "OPENBLAS_MAIN_FREE",
-                                    get(ENV, "GOTOBLAS_MAIN_FREE", "1"))
-    Sys.init_sysinfo()
-    if CPU_CORES > 8 && !("OPENBLAS_NUM_THREADS" in keys(ENV)) && !("OMP_NUM_THREADS" in keys(ENV))
-        # Prevent openblas from starting too many threads, unless/until specifically requested
-        ENV["OPENBLAS_NUM_THREADS"] = 8
-    end
-end
-
-function init_parallel()
-    start_gc_msgs_task()
-    atexit(terminate_all_workers)
-
-    init_bind_addr()
-
-    # start in "head node" mode, if worker, will override later.
-    global PGRP
-    global LPROC
-    LPROC.id = 1
-    assert(length(PGRP.workers) == 0)
-    register_worker(LPROC)
-end
-
 import .Terminals
 import .REPL
 
@@ -406,9 +311,11 @@ function _atreplinit(repl)
 end
 
 function _start()
+    empty!(ARGS)
+    append!(ARGS, Core.ARGS)
     opts = JLOptions()
     try
-        (quiet,repl,startup,color_set,history_file) = process_options(opts,copy(ARGS))
+        (quiet,repl,startup,color_set,history_file) = process_options(opts)
 
         local term
         global active_repl
@@ -441,7 +348,7 @@ function _start()
                 # note: currently IOStream is used for file STDIN
                 if isa(STDIN,File) || isa(STDIN,IOStream)
                     # reading from a file, behave like include
-                    eval(Main,parse_input_line(readall(STDIN)))
+                    eval(Main,parse_input_line(readstring(STDIN)))
                 else
                     # otherwise behave repl-like
                     while !eof(STDIN)
@@ -450,7 +357,7 @@ function _start()
                 end
             else
                 _atreplinit(active_repl)
-                active_repl_backend = REPL.run_repl(active_repl)
+                REPL.run_repl(active_repl, backend->(global active_repl_backend = backend))
             end
         end
     catch err
@@ -461,18 +368,3 @@ function _start()
         print(color_normal)
     end
 end
-
-const atexit_hooks = []
-
-atexit(f::Function) = (unshift!(atexit_hooks, f); nothing)
-
-function _atexit()
-    for f in atexit_hooks
-        try
-            f()
-        catch err
-            show(STDERR, err)
-            println(STDERR)
-        end
-    end
-end
diff --git a/base/collections.jl b/base/collections.jl
index 43173f802c2bf..1fef595f745bb 100644
--- a/base/collections.jl
+++ b/base/collections.jl
@@ -61,8 +61,12 @@ end
 
 percolate_up!{T}(xs::AbstractArray{T}, i::Integer, o::Ordering) = percolate_up!(xs, i, xs[i], o)
 
+"""
+    heappop!(v, [ord])
 
-# Binary min-heap pop.
+Given a binary heap-ordered array, remove and return the lowest ordered element.
+For efficiency, this function does not check that the array is indeed heap-ordered.
+"""
 function heappop!(xs::AbstractArray, o::Ordering=Forward)
     x = xs[1]
     y = pop!(xs)
@@ -72,8 +76,12 @@ function heappop!(xs::AbstractArray, o::Ordering=Forward)
     x
 end
 
+"""
+    heappush!(v, x, [ord])
 
-# Binary min-heap push.
+Given a binary heap-ordered array, push a new element `x`, preserving the heap property.
+For efficiency, this function does not check that the array is indeed heap-ordered.
+"""
 function heappush!(xs::AbstractArray, x, o::Ordering=Forward)
     push!(xs, x)
     percolate_up!(xs, length(xs), x, o)
@@ -82,6 +90,11 @@ end
 
 
 # Turn an arbitrary array into a binary min-heap in linear time.
+"""
+    heapify!(v, [ord])
+
+In-place [`heapify`](:func:`heapify`).
+"""
 function heapify!(xs::AbstractArray, o::Ordering=Forward)
     for i in heapparent(length(xs)):-1:1
         percolate_down!(xs, i, o)
@@ -89,10 +102,18 @@ function heapify!(xs::AbstractArray, o::Ordering=Forward)
     xs
 end
 
+"""
+    heapify(v, [ord])
+
+Returns a new vector in binary heap order, optionally using the given ordering.
+"""
 heapify(xs::AbstractArray, o::Ordering=Forward) = heapify!(copy(xs), o)
 
+"""
+    isheap(v, [ord])
 
-# Is an arbitrary array heap ordered?
+Return `true` if an array is heap-ordered according to the given order.
+"""
 function isheap(xs::AbstractArray, o::Ordering=Forward)
     for i in 1:div(length(xs), 2)
         if lt(o, xs[heapleft(i)], xs[i]) ||
@@ -107,9 +128,18 @@ end
 # PriorityQueue
 # -------------
 
-# A PriorityQueue that acts like a Dict, mapping values to their priorities,
-# with the addition of a dequeue! function to remove the lowest priority
-# element.
+"""
+    PriorityQueue(K, V, [ord])
+
+Construct a new [`PriorityQueue`](:obj:`PriorityQueue`), with keys of type
+`K` and values/priorites of type `V`.
+If an order is not given, the priority queue is min-ordered using
+the default comparison for `V`.
+
+A `PriorityQueue` acts like a `Dict`, mapping values to their
+priorities, with the addition of a `dequeue!` function to remove the
+lowest priority element.
+"""
 type PriorityQueue{K,V,O<:Ordering} <: Associative{K,V}
     # Binary heap of (element, priority) pairs.
     xs::Array{Pair{K,V}, 1}
@@ -168,8 +198,14 @@ PriorityQueue{K,V}(a::AbstractArray{Tuple{K,V}}, o::Ordering=Forward) = Priority
 length(pq::PriorityQueue) = length(pq.xs)
 isempty(pq::PriorityQueue) = isempty(pq.xs)
 haskey(pq::PriorityQueue, key) = haskey(pq.index, key)
-peek(pq::PriorityQueue) = pq.xs[1]
 
+"""
+    peek(pq)
+
+Return the lowest priority key from a priority queue without removing that
+key from the queue.
+"""
+peek(pq::PriorityQueue) = pq.xs[1]
 
 function percolate_down!(pq::PriorityQueue, i::Integer)
     x = pq.xs[i]
@@ -246,7 +282,11 @@ function setindex!{K,V}(pq::PriorityQueue{K, V}, value, key)
     value
 end
 
+"""
+    enqueue!(pq, k, v)
 
+Insert the a key `k` into a priority queue `pq` with priority `v`.
+"""
 function enqueue!{K,V}(pq::PriorityQueue{K,V}, key, value)
     if haskey(pq, key)
         throw(ArgumentError("PriorityQueue keys must be unique"))
@@ -257,7 +297,11 @@ function enqueue!{K,V}(pq::PriorityQueue{K,V}, key, value)
     pq
 end
 
+"""
+    dequeue!(pq)
 
+Remove and return the lowest priority key from a priority queue.
+"""
 function dequeue!(pq::PriorityQueue)
     x = pq.xs[1]
     y = pop!(pq.xs)
diff --git a/base/combinatorics.jl b/base/combinatorics.jl
index 52aec2db7b1dd..d70af65b268cd 100644
--- a/base/combinatorics.jl
+++ b/base/combinatorics.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+# Factorials
+
 const _fact_table64 =
     Int64[1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800,
           87178291200,1307674368000,20922789888000,355687428096000,6402373705728000,
@@ -51,67 +53,14 @@ function gamma(n::Union{Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64})
     @inbounds return Float64(_fact_table64[n-1])
 end
 
-# computes n!/k!
-function factorial{T<:Integer}(n::T, k::T)
-    if k < 0 || n < 0 || k > n
-        throw(DomainError())
-    end
-    f = one(T)
-    while n > k
-        f = Base.checked_mul(f,n)
-        n -= 1
-    end
-    return f
-end
-factorial(n::Integer, k::Integer) = factorial(promote(n, k)...)
 
-## other ordering related functions ##
-function nthperm!(a::AbstractVector, k::Integer)
-    k -= 1 # make k 1-indexed
-    k < 0 && throw(ArgumentError("permutation k must be ≥ 0, got $k"))
-    n = length(a)
-    n == 0 && return a
-    f = factorial(oftype(k, n-1))
-    for i=1:n-1
-        j = div(k, f) + 1
-        k = k % f
-        f = div(f, n-i)
+# Basic functions for working with permutations
 
-        j = j+i-1
-        elt = a[j]
-        for d = j:-1:i+1
-            a[d] = a[d-1]
-        end
-        a[i] = elt
-    end
-    a
-end
-nthperm(a::AbstractVector, k::Integer) = nthperm!(copy(a),k)
-
-function nthperm{T<:Integer}(p::AbstractVector{T})
-    isperm(p) || throw(ArgumentError("argument is not a permutation"))
-    k, n = 1, length(p)
-    for i = 1:n-1
-        f = factorial(n-i)
-        for j = i+1:n
-            k += ifelse(p[j] < p[i], f, 0)
-        end
-    end
-    return k
-end
-
-function invperm(a::AbstractVector)
-    b = zero(a) # similar vector of zeros
-    n = length(a)
-    for i = 1:n
-        j = a[i]
-        ((1 <= j <= n) && b[j] == 0) ||
-            throw(ArgumentError("argument is not a permutation"))
-        b[j] = i
-    end
-    b
-end
+"""
+    isperm(v) -> Bool
 
+Returns `true` if `v` is a valid permutation.
+"""
 function isperm(A)
     n = length(A)
     used = falses(n)
@@ -142,6 +91,15 @@ function permute!!{T<:Integer}(a, p::AbstractVector{T})
     a
 end
 
+"""
+    permute!(v, p)
+
+Permute vector `v` in-place, according to permutation `p`. No checking is done
+to verify that `p` is a permutation.
+
+To return a new permutation, use `v[p]`. Note that this is generally faster than
+`permute!(v,p)` for large vectors.
+"""
 permute!(a, p::AbstractVector) = permute!!(a, copy!(similar(p), p))
 
 function ipermute!!{T<:Integer}(a, p::AbstractVector{T})
@@ -167,359 +125,43 @@ function ipermute!!{T<:Integer}(a, p::AbstractVector{T})
     a
 end
 
-ipermute!(a, p::AbstractVector) = ipermute!!(a, copy!(similar(p), p))
-
-immutable Combinations{T}
-    a::T
-    t::Int
-end
-
-eltype{T}(::Type{Combinations{T}}) = Vector{eltype(T)}
-
-length(c::Combinations) = binomial(length(c.a),c.t)
-
-function combinations(a, t::Integer)
-    if t < 0
-        # generate 0 combinations for negative argument
-        t = length(a)+1
-    end
-    Combinations(a, t)
-end
-
-start(c::Combinations) = [1:c.t;]
-function next(c::Combinations, s)
-    comb = [c.a[si] for si in s]
-    if c.t == 0
-        # special case to generate 1 result for t==0
-        return (comb,[length(c.a)+2])
-    end
-    s = copy(s)
-    for i = length(s):-1:1
-        s[i] += 1
-        if s[i] > (length(c.a) - (length(s)-i))
-            continue
-        end
-        for j = i+1:endof(s)
-            s[j] = s[j-1]+1
-        end
-        break
-    end
-    (comb,s)
-end
-done(c::Combinations, s) = !isempty(s) && s[1] > length(c.a)-c.t+1
-
-immutable Permutations{T}
-    a::T
-end
-
-eltype{T}(::Type{Permutations{T}}) = Vector{eltype(T)}
-
-length(p::Permutations) = factorial(length(p.a))
-
-permutations(a) = Permutations(a)
-
-start(p::Permutations) = [1:length(p.a);]
-function next(p::Permutations, s)
-    perm = [p.a[si] for si in s]
-    if length(p.a) == 0
-        # special case to generate 1 result for len==0
-        return (perm,[1])
-    end
-    s = copy(s)
-    k = length(s)-1
-    while k > 0 && s[k] > s[k+1];  k -= 1;  end
-    if k == 0
-        s[1] = length(s)+1   # done
-    else
-        l = length(s)
-        while s[k] >= s[l];  l -= 1;  end
-        s[k],s[l] = s[l],s[k]
-        reverse!(s,k+1)
-    end
-    (perm,s)
-end
-done(p::Permutations, s) = !isempty(s) && s[1] > length(p.a)
-
-
-# Integer Partitions
-
-immutable IntegerPartitions
-    n::Int
-end
-
-length(p::IntegerPartitions) = npartitions(p.n)
-
-partitions(n::Integer) = IntegerPartitions(n)
-
-start(p::IntegerPartitions) = Int[]
-done(p::IntegerPartitions, xs) = length(xs) == p.n
-next(p::IntegerPartitions, xs) = (xs = nextpartition(p.n,xs); (xs,xs))
-
-function nextpartition(n, as)
-    if isempty(as);  return Int[n];  end
-
-    xs = similar(as,0)
-    sizehint!(xs,length(as)+1)
-
-    for i = 1:length(as)-1
-        if as[i+1] == 1
-            x = as[i]-1
-            push!(xs, x)
-            n -= x
-            while n > x
-                push!(xs, x)
-                n -= x
-            end
-            push!(xs, n)
-
-            return xs
-        end
-        push!(xs, as[i])
-        n -= as[i]
-    end
-    push!(xs, as[end]-1)
-    push!(xs, 1)
-
-    xs
-end
-
-let _npartitions = Dict{Int,Int}()
-    global npartitions
-    function npartitions(n::Int)
-        if n < 0
-            0
-        elseif n < 2
-            1
-        elseif (np = get(_npartitions, n, 0)) > 0
-            np
-        else
-            np = 0
-            sgn = 1
-            for k = 1:n
-                np += sgn * (npartitions(n-k*(3k-1)>>1) + npartitions(n-k*(3k+1)>>1))
-                sgn = -sgn
-            end
-            _npartitions[n] = np
-        end
-    end
-end
-
-# Algorithm H from TAoCP 7.2.1.4
-# Partition n into m parts
-# in colex order (lexicographic by reflected sequence)
-
-immutable FixedPartitions
-    n::Int
-    m::Int
-end
-
-length(f::FixedPartitions) = npartitions(f.n,f.m)
-
-partitions(n::Integer, m::Integer) = n >= 1 && m >= 1 ? FixedPartitions(n,m) : throw(DomainError())
-
-start(f::FixedPartitions) = Int[]
-function done(f::FixedPartitions, s::Vector{Int})
-    f.m <= f.n || return true
-    isempty(s) && return false
-    return f.m == 1 || s[1]-1 <= s[end]
-end
-next(f::FixedPartitions, s::Vector{Int}) = (xs = nextfixedpartition(f.n,f.m,s); (xs,xs))
-
-function nextfixedpartition(n, m, bs)
-    as = copy(bs)
-    if isempty(as)
-        # First iteration
-        as = [n-m+1; ones(Int, m-1)]
-    elseif as[2] < as[1]-1
-        # Most common iteration
-        as[1] -= 1
-        as[2] += 1
-    else
-        # Iterate
-        local j
-        s = as[1]+as[2]-1
-        for j = 3:m
-            if as[j] < as[1]-1; break; end
-            s += as[j]
-        end
-        x = as[j] += 1
-        for k = j-1:-1:2
-            as[k] = x
-            s -= x
-        end
-        as[1] = s
-    end
-
-    return as
-end
-
-let _nipartitions = Dict{Tuple{Int,Int},Int}()
-    global npartitions
-    function npartitions(n::Int,m::Int)
-        if n < m || m == 0
-            0
-        elseif n == m
-            1
-        elseif (np = get(_nipartitions, (n,m), 0)) > 0
-            np
-        else
-            _nipartitions[(n,m)] = npartitions(n-1,m-1) + npartitions(n-m,m)
-        end
-    end
-end
-
-# Algorithm H from TAoCP 7.2.1.5
-# Set partitions
-
-immutable SetPartitions{T<:AbstractVector}
-    s::T
-end
-
-length(p::SetPartitions) = nsetpartitions(length(p.s))
-
-partitions(s::AbstractVector) = SetPartitions(s)
-
-start(p::SetPartitions) = (n = length(p.s); (zeros(Int32, n), ones(Int32, n-1), n, 1))
-done(p::SetPartitions, s) = s[1][1] > 0
-next(p::SetPartitions, s) = nextsetpartition(p.s, s...)
-
-function nextsetpartition(s::AbstractVector, a, b, n, m)
-    function makeparts(s, a, m)
-        temp = [ similar(s,0) for k = 0:m ]
-        for i = 1:n
-            push!(temp[a[i]+1], s[i])
-        end
-        filter!(x->!isempty(x), temp)
-    end
-
-    if isempty(s);  return ([s], ([1], Int[], n, 1));  end
-
-    part = makeparts(s,a,m)
+"""
+    ipermute!(v, p)
 
-    if a[end] != m
-        a[end] += 1
-    else
-        local j
-        for j = n-1:-1:1
-            if a[j] != b[j]
-                break
-            end
-        end
-        a[j] += 1
-        m = b[j] + (a[j] == b[j])
-        for k = j+1:n-1
-            a[k] = 0
-            b[k] = m
-        end
-        a[end] = 0
-    end
+Like `permute!`, but the inverse of the given permutation is applied.
+"""
+ipermute!(a, p::AbstractVector) = ipermute!!(a, copy!(similar(p), p))
 
-    return (part, (a,b,n,m))
+"""
+    invperm(v)
 
-end
-
-let _nsetpartitions = Dict{Int,Int}()
-    global nsetpartitions
-    function nsetpartitions(n::Int)
-        if n < 0
-            0
-        elseif n < 2
-            1
-        elseif (wn = get(_nsetpartitions, n, 0)) > 0
-            wn
-        else
-            wn = 0
-            for k = 0:n-1
-                wn += binomial(n-1,k)*nsetpartitions(n-1-k)
-            end
-            _nsetpartitions[n] = wn
-        end
+Return the inverse permutation of `v`
+"""
+function invperm(a::AbstractVector)
+    b = zero(a) # similar vector of zeros
+    n = length(a)
+    @inbounds for i in eachindex(a)
+        j = a[i]
+        ((1 <= j <= n) && b[j] == 0) ||
+            throw(ArgumentError("argument is not a permutation"))
+        b[j] = i
     end
+    b
 end
 
-immutable FixedSetPartitions{T<:AbstractVector}
-    s::T
-    m::Int
-end
-
-length(p::FixedSetPartitions) = nfixedsetpartitions(length(p.s),p.m)
-
-partitions(s::AbstractVector,m::Int) = length(s) >= 1 && m >= 1 ? FixedSetPartitions(s,m) : throw(DomainError())
-
-function start(p::FixedSetPartitions)
-    n = length(p.s)
-    m = p.m
-    m <= n ? (vcat(ones(Int, n-m),1:m), vcat(1,n-m+2:n), n) : (Int[], Int[], n)
-end
-# state consists of:
-# vector a of length n describing to which partition every element of s belongs
-# vector b of length n describing the first index b[i] that belongs to partition i
-# integer n
-
-done(p::FixedSetPartitions, s) = length(s[1]) == 0 || s[1][1] > 1
-next(p::FixedSetPartitions, s) = nextfixedsetpartition(p.s,p.m, s...)
-
-function nextfixedsetpartition(s::AbstractVector, m, a, b, n)
-    function makeparts(s, a)
-        part = [ similar(s,0) for k = 1:m ]
-        for i = 1:n
-            push!(part[a[i]], s[i])
-        end
-        return part
-    end
-
-    part = makeparts(s,a)
-
-    if m == 1
-        a[1] = 2
-        return (part, (a, b, n))
-    end
+#XXX This function should be moved to Combinatorics.jl but is currently used by Base.DSP.
+"""
+    nextprod([k_1,k_2,...], n)
 
-    if a[end] != m
-        a[end] += 1
-    else
-        local j, k
-        for j = n-1:-1:1
-            if a[j]<m && b[a[j]+1]<j
-                break
-            end
-        end
-        if j>1
-            a[j]+=1
-            for p=j+1:n
-                if b[a[p]]!=p
-                    a[p]=1
-                end
-            end
-        else
-            for k=m:-1:2
-                if b[k-1]<b[k]-1
-                    break
-                end
-            end
-            b[k]=b[k]-1
-            b[k+1:m]=n-m+k+1:n
-            a[1:n]=1
-            a[b]=1:m
-        end
-    end
+Next integer not less than `n` that can be written as ``\\prod k_i^{p_i}`` for integers
+``p_1``, ``p_2``, etc.
 
-    return (part, (a,b,n))
-end
-
-function nfixedsetpartitions(n::Int,m::Int)
-    numpart=0
-    for k=0:m
-        numpart+=(-1)^(m-k)*binomial(m,k)*(k^n)
-    end
-    numpart=div(numpart,factorial(m))
-    return numpart
-end
+For a list of integers i1, i2, i3, find the smallest
 
+    i1^n1 * i2^n2 * i3^n3 >= x
 
-# For a list of integers i1, i2, i3, find the smallest
-#     i1^n1 * i2^n2 * i3^n3 >= x
-# for integer n1, n2, n3
+for integer n1, n2, n3
+"""
 function nextprod(a::Vector{Int}, x)
     if x > typemax(Int)
         throw(ArgumentError("unsafe for x > typemax(Int), got $x"))
@@ -554,92 +196,20 @@ function nextprod(a::Vector{Int}, x)
             end
         end
     end
-    best = mx[end] < best ? mx[end] : best
-    return Int(best)  # could overflow, but best to have predictable return type
+    # might overflow, but want predictable return type
+    return mx[end] < best ? Int(mx[end]) : Int(best)
 end
 
-# For a list of integers i1, i2, i3, find the largest
-#     i1^n1 * i2^n2 * i3^n3 <= x
-# for integer n1, n2, n3
-function prevprod(a::Vector{Int}, x)
-    if x > typemax(Int)
-        throw(ArgumentError("unsafe for x > typemax(Int), got $x"))
-    end
-    k = length(a)
-    v = ones(Int, k)                  # current value of each counter
-    mx = [nextpow(ai,x) for ai in a]  # allow each counter to exceed p (sentinel)
-    first = Int(prevpow(a[1], x))     # start at best case in first factor
-    v[1] = first
-    p::widen(Int) = first
-    best = p
-    icarry = 1
 
-    while v[end] < mx[end]
-        while p <= x
-            best = p > best ? p : best
-            p *= a[1]
-            v[1] *= a[1]
-        end
-        if p > x
-            carrytest = true
-            while carrytest
-                p = div(p, v[icarry])
-                v[icarry] = 1
-                icarry += 1
-                p *= a[icarry]
-                v[icarry] *= a[icarry]
-                carrytest = v[icarry] > mx[icarry] && icarry < k
-            end
-            if p <= x
-                icarry = 1
-            end
-        end
-    end
-    best = x >= p > best ? p : best
-    return Int(best)
-end
-
-const levicivita_lut = cat(3, [0 0  0;  0 0 1; 0 -1 0],
-                              [0 0 -1;  0 0 0; 1  0 0],
-                              [0 1  0; -1 0 0; 0  0 0])
-
-# Levi-Civita symbol of a permutation.
-# The parity is computed by using the fact that a permutation is odd if and
-# only if the number of even-length cycles is odd.
-# Returns 1 is the permutarion is even, -1 if it is odd and 0 otherwise.
-function levicivita{T<:Integer}(p::AbstractVector{T})
-    n = length(p)
-
-    if n == 3
-        @inbounds valid = (0 < p[1] <= 3) * (0 < p[2] <= 3) * (0 < p[3] <= 3)
-        return valid ? levicivita_lut[p[1], p[2], p[3]] : 0
-    end
 
-    todo = trues(n)
-    first = 1
-    cycles = flips = 0
+#Functions that have been moved out of base in Julia 0.5
+#Note: only the two-argument form of factorial has been moved
+for deprecatedfunc in [:combinations, :factorial, :prevprod, :levicivita,
+    :nthperm!, :nthperm, :parity, :partitions, :permutations]
 
-    while cycles + flips < n
-        first = findnext(todo, first)
-        (todo[first] $= true) && return 0
-        j = p[first]
-        (0 < j <= n) || return 0
-        cycles += 1
-        while j ≠ first
-            (todo[j] $= true) && return 0
-            j = p[j]
-            (0 < j <= n) || return 0
-            flips += 1
-        end
+    @eval begin
+        $deprecatedfunc(args...) = error(string($deprecatedfunc, args,
+            " has been moved to the package Combinatorics.jl.\n",
+            "Run Pkg.add(\"Combinatorics\") to install Combinatorics on Julia v0.5-"))
     end
-
-    return iseven(flips) ? 1 : -1
-end
-
-# Computes the parity of a permutation using the levicivita function,
-# so you can ask iseven(parity(p)). If p is not a permutation throws an error.
-function parity{T<:Integer}(p::AbstractVector{T})
-    epsilon = levicivita(p)
-    epsilon == 0 && throw(ArgumentError("Not a permutation"))
-    epsilon == 1 ? 0 : 1
 end
diff --git a/base/complex.jl b/base/complex.jl
index 28eb4a97704f9..82dd324c76d91 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -26,6 +26,13 @@ promote_rule{T<:Real,S<:Real}(::Type{Complex{T}}, ::Type{S}) =
 promote_rule{T<:Real,S<:Real}(::Type{Complex{T}}, ::Type{Complex{S}}) =
     Complex{promote_type(T,S)}
 
+promote_op{T<:Real,S<:Real}(op, ::Type{Complex{T}}, ::Type{Complex{S}}) =
+    Complex{promote_op(op,T,S)}
+promote_op{T<:Real,S<:Real}(op, ::Type{Complex{T}}, ::Type{S}) =
+    Complex{promote_op(op,T,S)}
+promote_op{T<:Real,S<:Real}(op, ::Type{T}, ::Type{Complex{S}}) =
+    Complex{promote_op(op,T,S)}
+
 widen{T}(::Type{Complex{T}}) = Complex{widen(T)}
 
 real(z::Complex) = z.re
@@ -37,6 +44,9 @@ reim(z) = (real(z), imag(z))
 real{T<:Real}(::Type{T}) = T
 real{T<:Real}(::Type{Complex{T}}) = T
 
+complex{T<:Real}(::Type{T}) = Complex{T}
+complex{T<:Real}(::Type{Complex{T}}) = Complex{T}
+
 isreal(x::Real) = true
 isreal(z::Complex) = imag(z) == 0
 isimag(z::Number) = real(z) == 0
@@ -49,25 +59,26 @@ complex(x::Real, y::Real) = Complex(x, y)
 complex(x::Real) = Complex(x)
 complex(z::Complex) = z
 
-function complex_show(io::IO, z::Complex, compact::Bool)
+flipsign(x::Complex, y::Real) = ifelse(signbit(y), -x, x)
+
+function show(io::IO, z::Complex)
     r, i = reim(z)
-    compact ? showcompact(io,r) : show(io,r)
+    compact = limit_output(io)
+    showcompact_lim(io, r)
     if signbit(i) && !isnan(i)
         i = -i
         print(io, compact ? "-" : " - ")
     else
         print(io, compact ? "+" : " + ")
     end
-    compact ? showcompact(io, i) : show(io, i)
+    showcompact_lim(io, i)
     if !(isa(i,Integer) && !isa(i,Bool) || isa(i,AbstractFloat) && isfinite(i))
         print(io, "*")
     end
     print(io, "im")
 end
-complex_show(io::IO, z::Complex{Bool}, compact::Bool) =
+show(io::IO, z::Complex{Bool}) =
     print(io, z == im ? "im" : "Complex($(z.re),$(z.im))")
-show(io::IO, z::Complex) = complex_show(io, z, false)
-showcompact(io::IO, z::Complex) = complex_show(io, z, true)
 
 function read{T<:Real}(s::IO, ::Type{Complex{T}})
     r = read(s,T)
@@ -75,8 +86,7 @@ function read{T<:Real}(s::IO, ::Type{Complex{T}})
     Complex{T}(r,i)
 end
 function write(s::IO, z::Complex)
-    write(s,real(z))
-    write(s,imag(z))
+    write(s,real(z),imag(z))
 end
 
 ## equality and hashing of complex numbers ##
@@ -545,32 +555,42 @@ end
     n>=0 ? power_by_squaring(z,n) : power_by_squaring(inv(z),-n)
 ^{T<:Integer}(z::Complex{T}, n::Integer) = power_by_squaring(z,n) # DomainError for n<0
 
-function sin(z::Complex)
+function sin{T}(z::Complex{T})
+    F = float(T)
     zr, zi = reim(z)
-    if !isfinite(zi) && zr == 0 return Complex(zr, zi) end
-    if isnan(zr) && !isfinite(zi) return Complex(zr, zi) end
-    if !isfinite(zr) && zi == 0 return Complex(oftype(zr, NaN), zi) end
-    if !isfinite(zr) && isfinite(zi) return Complex(oftype(zr, NaN), oftype(zi, NaN)) end
-    if !isfinite(zr) && !isfinite(zi) return Complex(zr, oftype(zi, NaN)) end
-    Complex(sin(zr)*cosh(zi), cos(zr)*sinh(zi))
+    if zr == 0
+        Complex(F(zr), sinh(zi))
+    elseif !isfinite(zr)
+        if zi == 0 || isinf(zi)
+            Complex(F(NaN), F(zi))
+        else
+            Complex(F(NaN), F(NaN))
+        end
+    else
+        Complex(sin(zr)*cosh(zi), cos(zr)*sinh(zi))
+    end
 end
 
-function cos(z::Complex)
+
+function cos{T}(z::Complex{T})
+    F = float(T)
     zr, zi = reim(z)
-    if !isfinite(zi) && zr == 0
-        return Complex(isnan(zi) ? zi : oftype(zi, Inf),
-                       isnan(zi) ? zr : zr*-sign(zi))
-    end
-    if !isfinite(zr) && isinf(zi)
-        return Complex(oftype(zr, Inf), oftype(zi, NaN))
-    end
-    if isinf(zr)
-        return Complex(oftype(zr, NaN), zi==0 ? -copysign(zi, zr) : oftype(zi, NaN))
+    if zr == 0
+        Complex(cosh(zi), isnan(zi) ? F(zr) : -flipsign(F(zr),zi))
+    elseif !isfinite(zr)
+        if zi == 0
+            Complex(F(NaN), isnan(zr) ? zero(F) : -flipsign(F(zi),zr))
+        elseif isinf(zi)
+            Complex(F(Inf), F(NaN))
+        else
+            Complex(F(NaN), F(NaN))
+        end
+    else
+        Complex(cos(zr)*cosh(zi), -sin(zr)*sinh(zi))
     end
-    if isnan(zr) && zi==0 return Complex(zr, abs(zi)) end
-    Complex(cos(zr)*cosh(zi), -sin(zr)*sinh(zi))
 end
 
+
 function tan(z::Complex)
     zr, zi = reim(z)
     w = tanh(Complex(-zi, zr))
@@ -621,15 +641,13 @@ end
 
 function sinh(z::Complex)
     zr, zi = reim(z)
-    if isinf(zr) && isinf(zi) return Complex(zr, oftype(zi, NaN)) end
     w = sin(Complex(zi, zr))
     Complex(imag(w),real(w))
 end
 
 function cosh(z::Complex)
     zr, zi = reim(z)
-    if isnan(zr) && zi==0 return Complex(zr, zi) end
-    cos(Complex(-zi,zr))
+    cos(Complex(zi,-zr))
 end
 
 function tanh{T<:AbstractFloat}(z::Complex{T})
diff --git a/base/coreimg.jl b/base/coreimg.jl
index e960008ff34a4..4590a5ac4488b 100644
--- a/base/coreimg.jl
+++ b/base/coreimg.jl
@@ -1,8 +1,8 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 Main.Core.eval(Main.Core, :(baremodule Inference
-using Core: Intrinsics, arraylen, arrayref, arrayset, arraysize, _expr,
-            kwcall, _apply, typeassert, apply_type, svec
+using Core: Intrinsics, arrayref, arrayset, arraysize, _expr,
+            _apply, typeassert, apply_type, svec
 ccall(:jl_set_istopmod, Void, (Bool,), false)
 
 eval(x) = Core.eval(Inference,x)
@@ -22,6 +22,7 @@ macro doc(str, def) Expr(:escape, def) end
 
 ## Load essential files and libraries
 include("essentials.jl")
+include("generator.jl")
 include("reflection.jl")
 include("options.jl")
 
@@ -40,6 +41,8 @@ include("number.jl")
 include("int.jl")
 include("operators.jl")
 include("pointer.jl")
+const checked_add = +
+const checked_sub = -
 
 # core array operations
 include("abstractarray.jl")
@@ -70,12 +73,12 @@ include("inference.jl")
 
 precompile(CallStack, (Expr, Module, Tuple{Void}, EmptyCallStack))
 precompile(_ieval, (Symbol,))
-precompile(abstract_eval, (LambdaStaticData, ObjectIdDict, StaticVarInfo))
-precompile(abstract_interpret, (Bool, ObjectIdDict, StaticVarInfo))
+precompile(abstract_eval, (LambdaInfo, ObjectIdDict, VarInfo))
+precompile(abstract_interpret, (Bool, ObjectIdDict, VarInfo))
 precompile(delete_var!, (Expr, Symbol))
-precompile(eval_annotate, (LambdaStaticData, ObjectIdDict, StaticVarInfo, ObjectIdDict, Array{Any,1}))
+precompile(eval_annotate, (LambdaInfo, ObjectIdDict, VarInfo, ObjectIdDict, Array{Any,1}))
 precompile(is_var_assigned, (Expr, Symbol))
-precompile(isconstantfunc, (SymbolNode, StaticVarInfo))
+precompile(isconstantfunc, (SymbolNode, VarInfo))
 precompile(occurs_more, (Bool, Function, Int))
 precompile(occurs_more, (UInt8, Function, Int))
 precompile(occurs_undef, (Symbol, Expr))
diff --git a/base/datafmt.jl b/base/datafmt.jl
index 6a0a12bdf6141..deda884281ce7 100644
--- a/base/datafmt.jl
+++ b/base/datafmt.jl
@@ -4,16 +4,18 @@
 
 module DataFmt
 
-importall Base
-import Base: _default_delims, tryparse_internal
+import Base: _default_delims, tryparse_internal, writemime
 
 export countlines, readdlm, readcsv, writedlm, writecsv
 
+invalid_dlm(::Type{Char})   = reinterpret(Char, 0xfffffffe)
+invalid_dlm(::Type{UInt8})  = 0xfe
+invalid_dlm(::Type{UInt16}) = 0xfffe
+invalid_dlm(::Type{UInt32}) = 0xfffffffe
 
-const invalid_dlm = Char(0xfffffffe)
 const offs_chunk_size = 5000
 
-countlines(f::AbstractString,eol::Char='\n') = open(io->countlines(io,eol),f)::Int
+countlines(f::AbstractString, eol::Char='\n') = open(io->countlines(io,eol), f)::Int
 function countlines(io::IO, eol::Char='\n')
     isascii(eol) || throw(ArgumentError("only ASCII line terminators are supported"))
     a = Array(UInt8, 8192)
@@ -27,10 +29,10 @@ function countlines(io::IO, eol::Char='\n')
     nl
 end
 
-readdlm(input, T::Type; opts...) = readdlm(input, invalid_dlm, T, '\n'; opts...)
+readdlm(input, T::Type; opts...) = readdlm(input, invalid_dlm(Char), T, '\n'; opts...)
 readdlm(input, dlm::Char, T::Type; opts...) = readdlm(input, dlm, T, '\n'; opts...)
 
-readdlm(input; opts...) = readdlm(input, invalid_dlm, '\n'; opts...)
+readdlm(input; opts...) = readdlm(input, invalid_dlm(Char), '\n'; opts...)
 readdlm(input, dlm::Char; opts...) = readdlm(input, dlm, '\n'; opts...)
 
 readdlm(input, dlm::Char, eol::Char; opts...) = readdlm_auto(input, dlm, Float64, eol, true; opts...)
@@ -39,9 +41,16 @@ readdlm(input, dlm::Char, T::Type, eol::Char; opts...) = readdlm_auto(input, dlm
 function readdlm_auto(input, dlm::Char, T::Type, eol::Char, auto::Bool; opts...)
     optsd = val_opts(opts)
     use_mmap = get(optsd, :use_mmap, @windows ? false : true)
-    isa(input, AbstractString) && (fsz = filesize(input); input = use_mmap && (fsz > 0) && fsz < typemax(Int) ? as_mmap(input,fsz) : readall(input))
+    if isa(input, AbstractString)
+        fsz = filesize(input)
+        if use_mmap && fsz > 0 && fsz < typemax(Int)
+            input = as_mmap(input, fsz)
+        else
+            input = readstring(input)
+        end
+    end
     sinp = isa(input, Vector{UInt8}) ? bytestring(input) :
-           isa(input, IO) ? readall(input) :
+           isa(input, IO) ? readstring(input) :
            input
     readdlm_string(sinp, dlm, T, eol, auto, optsd)
 end
@@ -53,7 +62,7 @@ function as_mmap(fname::AbstractString, fsz::Int64)
 end
 
 function ascii_if_possible(sbuff::AbstractString)
-    isascii(sbuff) ? convert(ASCIIString,sbuff) : sbuff
+    isascii(sbuff) ? convert(ASCIIString, sbuff) : sbuff
 end
 
 #
@@ -73,7 +82,7 @@ type DLMOffsets <: DLMHandler
     function DLMOffsets(sbuff::ByteString)
         offsets = Array(Array{Int,1}, 1)
         offsets[1] = Array(Int, offs_chunk_size)
-        thresh = ceil(min(typemax(UInt),Base.Sys.total_memory()) / sizeof(Int) / 5)
+        thresh = ceil(min(typemax(UInt), Base.Sys.total_memory()) / sizeof(Int) / 5)
         new(offsets, 1, thresh, length(sbuff.data))
     end
 end
@@ -109,7 +118,7 @@ function store_cell(dlmoffsets::DLMOffsets, row::Int, col::Int, quoted::Bool, st
 end
 
 function result(dlmoffsets::DLMOffsets)
-    trimsz = (dlmoffsets.offidx-1)%offs_chunk_size
+    trimsz = (dlmoffsets.offidx-1) % offs_chunk_size
     ((trimsz > 0) || (dlmoffsets.offidx == 1)) && resize!(dlmoffsets.oarr[end], trimsz)
     dlmoffsets.oarr
 end
@@ -163,7 +172,7 @@ function store_cell{T,S<:ByteString}(dlmstore::DLMStore{T,S}, row::Int, col::Int
             end
             for cidx in (lastcol+1):ncols
                 if (T <: AbstractString) || (T == Any)
-                    cells[lastrow,cidx] = SubString(sbuff, 1, 0)
+                    cells[lastrow, cidx] = SubString(sbuff, 1, 0)
                 elseif ((T <: Number) || (T <: Char)) && dlmstore.auto
                     throw(TypeError(:store_cell, "", Any, T))
                 else
@@ -175,13 +184,13 @@ function store_cell{T,S<:ByteString}(dlmstore::DLMStore{T,S}, row::Int, col::Int
 
         # fill data
         if quoted && _chrinstr(sbuff, UInt8('"'), startpos, endpos)
-            unescaped = replace(SubString(sbuff,startpos,endpos), r"\"\"", "\"")
+            unescaped = replace(SubString(sbuff, startpos, endpos), r"\"\"", "\"")
             fail = colval(unescaped, 1, length(unescaped), cells, drow, col)
         else
             fail = colval(sbuff, startpos, endpos, cells, drow, col)
         end
         if fail
-            sval = SubString(sbuff,startpos,endpos)
+            sval = SubString(sbuff, startpos, endpos)
             ((T <: Number) && dlmstore.auto) ? throw(TypeError(:store_cell, "", Any, T)) : error("file entry \"$(sval)\" cannot be converted to $T")
         end
 
@@ -190,10 +199,10 @@ function store_cell{T,S<:ByteString}(dlmstore::DLMStore{T,S}, row::Int, col::Int
     else
         # fill header
         if quoted && _chrinstr(sbuff, UInt8('"'), startpos, endpos)
-            unescaped = replace(SubString(sbuff,startpos,endpos), r"\"\"", "\"")
+            unescaped = replace(SubString(sbuff, startpos, endpos), r"\"\"", "\"")
             colval(unescaped, 1, length(unescaped), dlmstore.hdr, 1, col)
         else
-            colval(sbuff, startpos,endpos, dlmstore.hdr, 1, col)
+            colval(sbuff, startpos, endpos, dlmstore.hdr, 1, col)
         end
     end
 
@@ -208,12 +217,12 @@ function result{T}(dlmstore::DLMStore{T})
     cells = dlmstore.data
     sbuff = dlmstore.sbuff
 
-    if (lastcol < ncols) || (lastrow < nrows)
+    if (nrows > 0) && ((lastcol < ncols) || (lastrow < nrows))
         while lastrow <= nrows
             (lastcol == ncols) && (lastcol = 0; lastrow += 1)
             for cidx in (lastcol+1):ncols
                 if (T <: AbstractString) || (T == Any)
-                    cells[lastrow,cidx] = SubString(sbuff, 1, 0)
+                    cells[lastrow, cidx] = SubString(sbuff, 1, 0)
                 elseif ((T <: Number) || (T <: Char)) && dlmstore.auto
                     throw(TypeError(:store_cell, "", Any, T))
                 else
@@ -231,7 +240,7 @@ end
 
 
 function readdlm_string(sbuff::ByteString, dlm::Char, T::Type, eol::Char, auto::Bool, optsd::Dict)
-    ign_empty = (dlm == invalid_dlm)
+    ign_empty = (dlm == invalid_dlm(Char))
     quotes = get(optsd, :quotes, true)
     comments = get(optsd, :comments, true)
     comment_char = get(optsd, :comment_char, '#')
@@ -315,59 +324,82 @@ end
 
 function colval{S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{Bool,2}, row::Int, col::Int)
     n = tryparse_internal(Bool, sbuff, startpos, endpos, false)
-    isnull(n) || (cells[row,col] = get(n))
+    isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
 function colval{T<:Integer, S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
     n = tryparse_internal(T, sbuff, startpos, endpos, 0, false)
-    isnull(n) || (cells[row,col] = get(n))
+    isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
 function colval(sbuff::ByteString, startpos::Int, endpos::Int, cells::Array{Float64,2}, row::Int, col::Int)
     n = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), sbuff, startpos-1, endpos-startpos+1)
-    isnull(n) || (cells[row,col] = get(n))
+    isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
 function colval(sbuff::ByteString, startpos::Int, endpos::Int, cells::Array{Float32,2}, row::Int, col::Int)
-    n = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8},Csize_t,Csize_t), sbuff, startpos-1, endpos-startpos+1)
-    isnull(n) || (cells[row,col] = get(n))
+    n = ccall(:jl_try_substrtof, Nullable{Float32}, (Ptr{UInt8}, Csize_t, Csize_t), sbuff, startpos-1, endpos-startpos+1)
+    isnull(n) || (cells[row, col] = get(n))
     isnull(n)
 end
-colval{T<:AbstractString, S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) = ((cells[row,col] = SubString(sbuff,startpos,endpos)); false)
+function colval{T<:AbstractString, S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
+    cells[row, col] = SubString(sbuff, startpos, endpos)
+    return false
+end
 function colval{S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{Any,2}, row::Int, col::Int)
     # if array is of Any type, attempt parsing only the most common types: Int, Bool, Float64 and fallback to SubString
     len = endpos-startpos+1
     if len > 0
         # check Inteter
         ni64 = tryparse_internal(Int, sbuff, startpos, endpos, 0, false)
-        isnull(ni64) || (cells[row,col] = get(ni64); return false)
+        isnull(ni64) || (cells[row, col] = get(ni64); return false)
 
         # check Bool
         nb = tryparse_internal(Bool, sbuff, startpos, endpos, false)
-        isnull(nb) || (cells[row,col] = get(nb); return false)
+        isnull(nb) || (cells[row, col] = get(nb); return false)
 
         # check float64
-        nf64 = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8},Csize_t,Csize_t), sbuff, startpos-1, endpos-startpos+1)
-        isnull(nf64) || (cells[row,col] = get(nf64); return false)
+        nf64 = ccall(:jl_try_substrtod, Nullable{Float64}, (Ptr{UInt8}, Csize_t, Csize_t), sbuff, startpos-1, endpos-startpos+1)
+        isnull(nf64) || (cells[row, col] = get(nf64); return false)
     end
-    cells[row,col] = SubString(sbuff, startpos, endpos)
+    cells[row, col] = SubString(sbuff, startpos, endpos)
     false
 end
-colval{T<:Char, S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int) = ((startpos==endpos) ? ((cells[row,col] = next(sbuff,startpos)[1]); false) : true)
+function colval{T<:Char, S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array{T,2}, row::Int, col::Int)
+    if startpos == endpos
+        cells[row, col] = next(sbuff, startpos)[1]
+        return false
+    else
+        return true
+    end
+end
 colval{S<:ByteString}(sbuff::S, startpos::Int, endpos::Int, cells::Array, row::Int, col::Int) = true
 
-dlm_parse(s::ASCIIString, eol::Char, dlm::Char, qchar::Char, cchar::Char, ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool, skipstart::Int, skipblanks::Bool, dh::DLMHandler) =  begin
-    dlm_parse(s.data, UInt32(eol)%UInt8, UInt32(dlm)%UInt8, UInt32(qchar)%UInt8, UInt32(cchar)%UInt8,
+function dlm_parse(s::ASCIIString, eol::Char, dlm::Char, qchar::Char, cchar::Char,
+                   ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool,
+                   skipstart::Int, skipblanks::Bool, dh::DLMHandler)
+    dlm_parse(s.data, reinterpret(UInt32, eol) % UInt8, reinterpret(UInt32, dlm) % UInt8,
+              reinterpret(UInt32, qchar) % UInt8, reinterpret(UInt32, cchar) % UInt8,
               ign_adj_dlm, allow_quote, allow_comments, skipstart, skipblanks, dh)
 end
 
-function dlm_parse{T,D}(dbuff::T, eol::D, dlm::D, qchar::D, cchar::D, ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool, skipstart::Int, skipblanks::Bool, dh::DLMHandler)
-    all_ascii = (D <: UInt8) || (isascii(eol) && isascii(dlm) && (!allow_quote || isascii(qchar)) && (!allow_comments || isascii(cchar)))
-    (T <: UTF8String) && all_ascii && (return dlm_parse(dbuff.data, eol%UInt8, dlm%UInt8, qchar%UInt8, cchar%UInt8, ign_adj_dlm, allow_quote, allow_comments, skipstart, skipblanks, dh))
+function dlm_parse{T,D}(dbuff::T, eol::D, dlm::D, qchar::D, cchar::D,
+                        ign_adj_dlm::Bool, allow_quote::Bool, allow_comments::Bool,
+                        skipstart::Int, skipblanks::Bool, dh::DLMHandler)
+    all_ascii = (D <: UInt8) || (isascii(eol) &&
+                                 isascii(dlm) &&
+                                 (!allow_quote || isascii(qchar)) &&
+                                 (!allow_comments || isascii(cchar)))
+    if (T <: UTF8String) && all_ascii
+        return dlm_parse(dbuff.data, eol % UInt8, dlm % UInt8, qchar % UInt8, cchar % UInt8,
+                         ign_adj_dlm, allow_quote, allow_comments, skipstart, skipblanks, dh)
+    end
     ncols = nrows = col = 0
-    is_default_dlm = (dlm == UInt32(invalid_dlm) % D)
+    is_default_dlm = (dlm == invalid_dlm(D))
     error_str = ""
-    # 0: begin field, 1: quoted field, 2: unquoted field, 3: second quote (could either be end of field or escape character), 4: comment, 5: skipstart
+    # 0: begin field, 1: quoted field, 2: unquoted field,
+    # 3: second quote (could either be end of field or escape character),
+    # 4: comment, 5: skipstart
     state = (skipstart > 0) ? 5 : 0
     is_eol = is_dlm = is_cr = is_quote = is_comment = expct_col = false
     idx = 1
@@ -531,15 +563,15 @@ function writedlm_cell{T}(io::IO, elt::AbstractString, dlm::T, quotes::Bool)
     end
 end
 writedlm_cell(io::IO, elt, dlm, quotes) = print(io, elt)
-function writedlm(io::IO, a::AbstractVecOrMat, dlm; opts...)
+function writedlm(io::IO, a::AbstractMatrix, dlm; opts...)
     optsd = val_opts(opts)
     quotes = get(optsd, :quotes, true)
     pb = PipeBuffer()
-    nr = size(a,1)
-    nc = size(a,2)
+    nr = size(a, 1)
+    nc = size(a, 2)
     for i = 1:nr
         for j = 1:nc
-            writedlm_cell(pb, a[i,j], dlm, quotes)
+            writedlm_cell(pb, a[i, j], dlm, quotes)
             j == nc ? write(pb,'\n') : print(pb,dlm)
         end
         (nb_available(pb) > (16*1024)) && write(io, takebuf_array(pb))
@@ -550,17 +582,32 @@ end
 
 writedlm{T}(io::IO, a::AbstractArray{T,0}, dlm; opts...) = writedlm(io, reshape(a,1), dlm; opts...)
 
+# write an iterable row as dlm-separated items
+function writedlm_row(io::IO, row, dlm, quotes)
+    state = start(row)
+    while !done(row, state)
+        (x, state) = next(row, state)
+        writedlm_cell(io, x, dlm, quotes)
+        done(row, state) ? write(io,'\n') : print(io,dlm)
+    end
+end
+
+# If the row is a single string, write it as a string rather than
+# iterating over characters. Also, include the common case of
+# a Number (handled correctly by the generic writedlm_row above)
+# purely as an optimization.
+function writedlm_row(io::IO, row::Union{Number,AbstractString}, dlm, quotes)
+    writedlm_cell(io, row, dlm, quotes)
+    write(io, '\n')
+end
+
+# write an iterable collection of iterable rows
 function writedlm(io::IO, itr, dlm; opts...)
     optsd = val_opts(opts)
     quotes = get(optsd, :quotes, true)
     pb = PipeBuffer()
     for row in itr
-        state = start(row)
-        while !done(row, state)
-            (x, state) = next(row, state)
-            writedlm_cell(pb, x, dlm, quotes)
-            done(row, state) ? write(pb,'\n') : print(pb,dlm)
-        end
+        writedlm_row(pb, row, dlm, quotes)
         (nb_available(pb) > (16*1024)) && write(io, takebuf_array(pb))
     end
     write(io, takebuf_array(pb))
@@ -576,7 +623,7 @@ end
 writedlm(io, a; opts...) = writedlm(io, a, '\t'; opts...)
 writecsv(io, a; opts...) = writedlm(io, a, ','; opts...)
 
-writemime(io::IO, ::MIME"text/csv", a::AbstractVecOrMat) = writedlm(io, a, ',')
-writemime(io::IO, ::MIME"text/tab-separated-values", a::AbstractVecOrMat) = writedlm(io, a, '\t')
+writemime(io::IO, ::MIME"text/csv", a) = writedlm(io, a, ',')
+writemime(io::IO, ::MIME"text/tab-separated-values", a) = writedlm(io, a, '\t')
 
 end # module DataFmt
diff --git a/base/dates/accessors.jl b/base/dates/accessors.jl
index 55aa9b20f49fd..6a308c7050e85 100644
--- a/base/dates/accessors.jl
+++ b/base/dates/accessors.jl
@@ -54,8 +54,26 @@ second(dt::DateTime) = mod(fld(value(dt),1000),60)
 millisecond(dt::DateTime) = mod(value(dt),1000)
 
 dayofmonth(dt::TimeType) = day(dt)
+
+"""
+    yearmonth(dt::TimeType) -> (Int64, Int64)
+
+Simultaneously return the year and month parts of a `Date` or `DateTime`.
+"""
 yearmonth(dt::TimeType) = yearmonth(days(dt))
+
+"""
+    monthday(dt::TimeType) -> (Int64, Int64)
+
+Simultaneously return the month and day parts of a `Date` or `DateTime`.
+"""
 monthday(dt::TimeType) = monthday(days(dt))
+
+"""
+    yearmonthday(dt::TimeType) -> (Int64, Int64, Int64)
+
+Simultaneously return the year, month, and day parts of a `Date` or `DateTime`.
+"""
 yearmonthday(dt::TimeType) = yearmonthday(days(dt))
 
 @vectorize_1arg TimeType year
diff --git a/base/dates/adjusters.jl b/base/dates/adjusters.jl
index 992a389ca4014..f98dd5a09365b 100644
--- a/base/dates/adjusters.jl
+++ b/base/dates/adjusters.jl
@@ -13,17 +13,55 @@ Base.trunc(dt::DateTime,p::Type{Minute}) = dt - Second(dt) - Millisecond(dt)
 Base.trunc(dt::DateTime,p::Type{Second}) = dt - Millisecond(dt)
 Base.trunc(dt::DateTime,p::Type{Millisecond}) = dt
 
+"""
+    trunc(dt::TimeType, ::Type{Period}) -> TimeType
+
+Truncates the value of `dt` according to the provided `Period` type. E.g. if `dt` is
+`1996-01-01T12:30:00`, then `trunc(dt,Day) == 1996-01-01T00:00:00`.
+"""
+Dates.trunc(::Dates.TimeType, ::Type{Dates.Period})
+
 # Adjusters
+"""
+    firstdayofweek(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the Monday of its week.
+"""
+function firstdayofweek end
+
 firstdayofweek(dt::Date) = Date(UTD(value(dt) - dayofweek(dt) + 1))
 firstdayofweek(dt::DateTime) = DateTime(firstdayofweek(Date(dt)))
+
+"""
+    lastdayofweek(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the Sunday of its week.
+"""
+function lastdayofweek end
+
 lastdayofweek(dt::Date) = Date(UTD(value(dt) + (7-dayofweek(dt))))
 lastdayofweek(dt::DateTime) = DateTime(lastdayofweek(Date(dt)))
 
 @vectorize_1arg TimeType firstdayofweek
 @vectorize_1arg TimeType lastdayofweek
 
+"""
+    firstdayofmonth(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the first day of its month.
+"""
+function firstdayofmonth end
+
 firstdayofmonth(dt::Date) = Date(UTD(value(dt)-day(dt)+1))
 firstdayofmonth(dt::DateTime) = DateTime(firstdayofmonth(Date(dt)))
+
+"""
+    lastdayofmonth(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the last day of its month.
+"""
+function lastdayofmonth end
+
 function lastdayofmonth(dt::Date)
     y,m,d = yearmonthday(dt)
     return Date(UTD(value(dt)+daysinmonth(y,m)-d))
@@ -33,8 +71,23 @@ lastdayofmonth(dt::DateTime) = DateTime(lastdayofmonth(Date(dt)))
 @vectorize_1arg TimeType firstdayofmonth
 @vectorize_1arg TimeType lastdayofmonth
 
+"""
+    firstdayofyear(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the first day of its year.
+"""
+function firstdayofyear end
+
 firstdayofyear(dt::Date) = Date(UTD(value(dt)-dayofyear(dt)+1))
 firstdayofyear(dt::DateTime) = DateTime(firstdayofyear(Date(dt)))
+
+"""
+    lastdayofyear(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the last day of its year.
+"""
+function lastdayofyear end
+
 function lastdayofyear(dt::Date)
     y,m,d = yearmonthday(dt)
     return Date(UTD(value(dt)+daysinyear(y)-dayofyear(y,m,d)))
@@ -44,18 +97,34 @@ lastdayofyear(dt::DateTime) = DateTime(lastdayofyear(Date(dt)))
 @vectorize_1arg TimeType firstdayofyear
 @vectorize_1arg TimeType lastdayofyear
 
+"""
+    firstdayofquarter(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the first day of its quarter.
+"""
+function firstdayofquarter end
+
 function firstdayofquarter(dt::Date)
     y,m = yearmonth(dt)
     mm = m < 4 ? 1 : m < 7 ? 4 : m < 10 ? 7 : 10
     return Date(y,mm,1)
 end
+firstdayofquarter(dt::DateTime) = DateTime(firstdayofquarter(Date(dt)))
+
+"""
+    lastdayofquarter(dt::TimeType) -> TimeType
+
+Adjusts `dt` to the last day of its quarter.
+"""
+function lastdayofquarter end
+
 function lastdayofquarter(dt::Date)
     y,m = yearmonth(dt)
     mm,d = m < 4 ? (3,31) : m < 7 ? (6,30) : m < 10 ? (9,30) : (12,31)
     return Date(y,mm,d)
 end
-firstdayofquarter(dt::DateTime) = DateTime(firstdayofquarter(Date(dt)))
 lastdayofquarter(dt::DateTime) = DateTime(lastdayofquarter(Date(dt)))
+
 @vectorize_1arg TimeType firstdayofquarter
 @vectorize_1arg TimeType lastdayofquarter
 
@@ -63,7 +132,7 @@ lastdayofquarter(dt::DateTime) = DateTime(lastdayofquarter(Date(dt)))
 immutable DateFunction
     f::Function
     # validate boolean, single-arg inner constructor
-    function DateFunction(f::Function,negate::Bool,dt::TimeType)
+    function DateFunction(f::ANY,negate::Bool,dt::TimeType)
         try
             f(dt) in (true,false) || throw(ArgumentError("Provided function must take a single TimeType argument and return true or false"))
         catch e
@@ -73,7 +142,7 @@ immutable DateFunction
         return new(@eval x->$n($f(x)))
     end
 end
-Base.show(io::IO,df::DateFunction) = println(io, df.f.code)
+Base.show(io::IO,df::DateFunction) = println(io, df.f)
 
 # Core adjuster
 function adjust(df::DateFunction,start,step,limit)
@@ -119,24 +188,68 @@ ISDAYOFWEEK = Dict(Mon=>DateFunction(ismonday,false,Date(0)),
                    Sun=>DateFunction(issunday,false,Date(0)))
 
 # "same" indicates whether the current date can be considered or not
+"""
+    tonext(dt::TimeType,dow::Int;same::Bool=false) -> TimeType
+
+Adjusts `dt` to the next day of week corresponding to `dow` with `1 = Monday, 2 = Tuesday,
+etc`. Setting `same=true` allows the current `dt` to be considered as the next `dow`,
+allowing for no adjustment to occur.
+"""
 tonext(dt::TimeType,dow::Int;same::Bool=false) = adjust(ISDAYOFWEEK[dow],same ? dt : dt+Day(1),Day(1),7)
+
 # Return the next TimeType where func evals true using step in incrementing
+"""
+    tonext(func::Function,dt::TimeType;step=Day(1),negate=false,limit=10000,same=false) -> TimeType
+
+Adjusts `dt` by iterating at most `limit` iterations by `step` increments until `func`
+returns `true`. `func` must take a single `TimeType` argument and return a `Bool`. `same`
+allows `dt` to be considered in satisfying `func`. `negate` will make the adjustment process
+terminate when `func` returns `false` instead of `true`.
+"""
 function tonext(func::Function,dt::TimeType;step::Period=Day(1),negate::Bool=false,limit::Int=10000,same::Bool=false)
     return adjust(DateFunction(func,negate,dt),same ? dt : dt+step,step,limit)
 end
 
+"""
+    toprev(dt::TimeType,dow::Int;same::Bool=false) -> TimeType
+
+Adjusts `dt` to the previous day of week corresponding to `dow` with `1 = Monday, 2 =
+Tuesday, etc`. Setting `same=true` allows the current `dt` to be considered as the previous
+`dow`, allowing for no adjustment to occur.
+"""
 toprev(dt::TimeType,dow::Int;same::Bool=false) = adjust(ISDAYOFWEEK[dow],same ? dt : dt+Day(-1),Day(-1),7)
+
+"""
+    toprev(func::Function,dt::TimeType;step=Day(-1),negate=false,limit=10000,same=false) -> TimeType
+
+Adjusts `dt` by iterating at most `limit` iterations by `step` increments until `func`
+returns `true`. `func` must take a single `TimeType` argument and return a `Bool`. `same`
+allows `dt` to be considered in satisfying `func`. `negate` will make the adjustment process
+terminate when `func` returns `false` instead of `true`.
+"""
 function toprev(func::Function,dt::TimeType;step::Period=Day(-1),negate::Bool=false,limit::Int=10000,same::Bool=false)
     return adjust(DateFunction(func,negate,dt),same ? dt : dt+step,step,limit)
 end
 
 # Return the first TimeType that falls on dow in the Month or Year
+"""
+    tofirst(dt::TimeType,dow::Int;of=Month) -> TimeType
+
+Adjusts `dt` to the first `dow` of its month. Alternatively, `of=Year` will adjust to the
+first `dow` of the year.
+"""
 function tofirst(dt::TimeType,dow::Int;of::Union{Type{Year},Type{Month}}=Month)
     dt = of <: Month ? firstdayofmonth(dt) : firstdayofyear(dt)
     return adjust(ISDAYOFWEEK[dow],dt,Day(1),366)
 end
 
 # Return the last TimeType that falls on dow in the Month or Year
+"""
+    tolast(dt::TimeType,dow::Int;of=Month) -> TimeType
+
+Adjusts `dt` to the last `dow` of its month. Alternatively, `of=Year` will adjust to the
+last `dow` of the year.
+"""
 function tolast(dt::TimeType,dow::Int;of::Union{Type{Year},Type{Month}}=Month)
     dt = of <: Month ? lastdayofmonth(dt) : lastdayofyear(dt)
     return adjust(ISDAYOFWEEK[dow],dt,Day(-1),366)
@@ -155,6 +268,15 @@ function recur{T<:TimeType}(fun::Function,start::T,stop::T;step::Period=Day(1),n
     end
     return a
 end
+
+"""
+    recur{T<:TimeType}(func::Function,dr::StepRange{T};negate=false,limit=10000) -> Vector{T}
+
+`func` takes a single TimeType argument and returns a `Bool` indicating whether the input
+should be "included" in the final set. `recur` applies `func` over each element in the range
+of `dr`, including those elements for which `func` returns `true` in the resulting Array,
+unless `negate=true`, then only elements where `func` returns `false` are included.
+"""
 function recur{T<:TimeType}(fun::Function,dr::StepRange{T};negate::Bool=false,limit::Int=10000)
     return recur(fun,first(dr),last(dr);step=step(dr),negate=negate,limit=limit)
 end
diff --git a/base/dates/conversions.jl b/base/dates/conversions.jl
index afc7a6e2e1d6c..fe39b4c2ff630 100644
--- a/base/dates/conversions.jl
+++ b/base/dates/conversions.jl
@@ -5,37 +5,116 @@ Date(dt::TimeType) = convert(Date,dt)
 DateTime(dt::TimeType) = convert(DateTime,dt)
 Base.convert(::Type{DateTime},dt::Date) = DateTime(UTM(value(dt)*86400000))
 Base.convert(::Type{Date},dt::DateTime) = Date(UTD(days(dt)))
+"""
+    convert{T<:Real}(::Type{T}, dt::DateTime) -> T
+Converts a DateTime value `dt` to a number of type `T`. The returned value corresponds to the number of Rata Die milliseconds since epoch.
+See `convert(DateTime, x::Real)` for inverse.
+"""
 Base.convert{R<:Real}(::Type{R},x::DateTime) = convert(R,value(x))
+"""
+    convert{T<:Real}(::Type{T}, dt::Date) -> T
+Converts a Date value `dt` to a number of type `T`. The returned value corresponds to the number of Rata Die days since epoch.
+See `convert(Date, x::Real)` for inverse.
+"""
 Base.convert{R<:Real}(::Type{R},x::Date)     = convert(R,value(x))
+"""
+    convert{T<:Real}(::Type{DateTime}, x::T) -> DateTime
+Converts a number of type `T` to a DateTime. `x` should be the number of Rata Die milliseconds since epoch.
+See `convert(Int64,dt::DateTime)` for inverse.
+"""
+Base.convert{R<:Real}(::Type{DateTime}, x::R) = DateTime(UTM(x))
+"""
+    convert{T<:Real}(::Type{Date}, x::T) -> Date
+Converts a number of type `T` to a Date. `x` should be the number of Rata Die days since epoch.
+See `convert(Int64,dt::Date)` for inverse.
+"""
+Base.convert{R<:Real}(::Type{Date}, x::R) = Date(UTD(x))
 
 @vectorize_1arg DateTime Date
 @vectorize_1arg Date DateTime
 
 ### External Conversions
 const UNIXEPOCH = value(DateTime(1970)) #Rata Die milliseconds for 1970-01-01T00:00:00
+
+"""
+    unix2datetime(x) -> DateTime
+
+Takes the number of seconds since unix epoch `1970-01-01T00:00:00` and converts to the
+corresponding `DateTime`.
+"""
 function unix2datetime(x)
-    rata = UNIXEPOCH + round(Int64,1000*x)
+    rata = UNIXEPOCH + round(Int64, Int64(1000) * x)
     return DateTime(UTM(rata))
 end
-# Returns unix seconds since 1970-01-01T00:00:00
+"""
+    datetime2unix(dt::DateTime) -> Float64
+
+Takes the given `DateTime` and returns the number of seconds
+since the unix epoch `1970-01-01T00:00:00` as a `Float64`.
+"""
 datetime2unix(dt::DateTime) = (value(dt) - UNIXEPOCH)/1000.0
+
+"""
+    now() -> DateTime
+
+Returns a `DateTime` corresponding to the user's system time including the system timezone
+locale.
+"""
 function now()
-    tm = Libc.TmStruct(time())
-    return DateTime(tm.year+1900,tm.month+1,tm.mday,tm.hour,tm.min,tm.sec)
+    tv = Libc.TimeVal()
+    tm = Libc.TmStruct(tv.sec)
+    return DateTime(tm.year+1900,tm.month+1,tm.mday,tm.hour,tm.min,tm.sec,div(tv.usec,1000))
 end
+
+"""
+    today() -> Date
+
+Returns the date portion of `now()`.
+"""
 today() = Date(now())
+
+"""
+    now(::Type{UTC}) -> DateTime
+
+Returns a `DateTime` corresponding to the user's system time as UTC/GMT.
+"""
 now(::Type{UTC}) = unix2datetime(time())
 
+"""
+    rata2datetime(days) -> DateTime
+
+Takes the number of Rata Die days since epoch `0000-12-31T00:00:00` and returns the
+corresponding `DateTime`.
+"""
 rata2datetime(days) = DateTime(yearmonthday(days)...)
-datetime2rata(dt::DateTime) = days(dt)
+
+"""
+    datetime2rata(dt::TimeType) -> Int64
+
+Returns the number of Rata Die days since epoch from the given `Date` or `DateTime`.
+"""
+datetime2rata(dt::TimeType) = days(dt)
 
 # Julian conversions
 const JULIANEPOCH = value(DateTime(-4713,11,24,12))
+
+"""
+    julian2datetime(julian_days) -> DateTime
+
+Takes the number of Julian calendar days since epoch `-4713-11-24T12:00:00` and returns the
+corresponding `DateTime`.
+"""
 function julian2datetime(f)
-    rata = JULIANEPOCH + round(Int64,86400000*f)
+    rata = JULIANEPOCH + round(Int64, Int64(86400000) * f)
     return DateTime(UTM(rata))
 end
-# Returns # of julian days since -4713-11-24T12:00:00
+
+"""
+    datetime2julian(dt::DateTime) -> Float64
+
+Takes the given `DateTime` and returns the number of Julian calendar days since the julian
+epoch `-4713-11-24T12:00:00` as a `Float64`.
+"""
 datetime2julian(dt::DateTime) = (value(dt) - JULIANEPOCH)/86400000.0
 
 @vectorize_1arg Real unix2datetime
diff --git a/base/dates/io.jl b/base/dates/io.jl
index 06c69f1408c87..257f7b16133b5 100644
--- a/base/dates/io.jl
+++ b/base/dates/io.jl
@@ -82,6 +82,13 @@ SLOT_RULE['s'] = Millisecond
 
 duplicates(slots) = any(map(x->count(y->x.parser==y.parser,slots),slots) .> 1)
 
+"""
+    Dates.DateFormat(format::AbstractString) -> DateFormat
+
+Construct a date formatting object that can be passed repeatedly for parsing similarly
+formatted date strings. `format` is a format string in the form described above (e.g.
+`"yyyy-mm-dd"`).
+"""
 function DateFormat(f::AbstractString,locale::AbstractString="english")
     slots = Slot[]
     prefix = ""
diff --git a/base/dates/periods.jl b/base/dates/periods.jl
index 9f0c7bb9e58a5..c49568e5f9a61 100644
--- a/base/dates/periods.jl
+++ b/base/dates/periods.jl
@@ -30,6 +30,14 @@ Base.typemin{P<:Period}(::Type{P}) = P(typemin(Int64))
 Base.typemax{P<:Period}(::Type{P}) = P(typemax(Int64))
 
 # Default values (as used by TimeTypes)
+"""
+    default(p::Period) -> Period
+
+Returns a sensible "default" value for the input Period by returning `one(p)` for Year,
+Month, and Day, and `zero(p)` for Hour, Minute, Second, and Millisecond.
+"""
+function default end
+
 default{T<:DatePeriod}(p::Union{T,Type{T}}) = one(p)
 default{T<:TimePeriod}(p::Union{T,Type{T}}) = zero(p)
 
diff --git a/base/dates/query.jl b/base/dates/query.jl
index 1c1adb52ac093..297cba19a690f 100644
--- a/base/dates/query.jl
+++ b/base/dates/query.jl
@@ -8,6 +8,11 @@
 dayofweek(days) = mod1(days,7)
 
 # Number of days in year
+"""
+    daysinyear(dt::TimeType) -> Int
+
+Returns 366 if the year of `dt` is a leap year, otherwise returns 365.
+"""
 daysinyear(y) = 365 + isleapyear(y)
 
 # Day of the year
@@ -15,6 +20,11 @@ const MONTHDAYS = [0,31,59,90,120,151,181,212,243,273,304,334]
 dayofyear(y,m,d) = MONTHDAYS[m] + d + (m > 2 && isleapyear(y))
 
 ### Days of the Week
+"""
+    dayofweek(dt::TimeType) -> Int64
+
+Returns the day of the week as an `Int64` with `1 = Monday, 2 = Tuesday, etc.`.
+"""
 dayofweek(dt::TimeType) = dayofweek(days(dt))
 
 const Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday = 1,2,3,4,5,6,7
@@ -26,8 +36,23 @@ const english_daysofweekabbr = Dict(1=>"Mon",2=>"Tue",3=>"Wed",
                                     4=>"Thu",5=>"Fri",6=>"Sat",7=>"Sun")
 const VALUETODAYOFWEEKABBR = Dict{UTF8String,Dict{Int,UTF8String}}("english"=>english_daysofweekabbr)
 dayname(dt::Integer;locale::AbstractString="english") = VALUETODAYOFWEEK[locale][dt]
+
+"""
+    dayabbr(dt::TimeType; locale="english") -> AbstractString
+
+Return the abbreviated name corresponding to the day of the week of the `Date` or `DateTime`
+in the given `locale`.
+"""
 dayabbr(dt::Integer;locale::AbstractString="english") = VALUETODAYOFWEEKABBR[locale][dt]
+
+"""
+    dayname(dt::TimeType; locale="english") -> AbstractString
+
+Return the full day name corresponding to the day of the week of the `Date` or `DateTime` in
+the given `locale`.
+"""
 dayname(dt::TimeType;locale::AbstractString="english") = VALUETODAYOFWEEK[locale][dayofweek(dt)]
+
 dayabbr(dt::TimeType;locale::AbstractString="english") = VALUETODAYOFWEEKABBR[locale][dayofweek(dt)]
 
 # Convenience methods for each day
@@ -40,6 +65,13 @@ issaturday(dt::TimeType) = dayofweek(dt) == Sat
 issunday(dt::TimeType) = dayofweek(dt) == Sun
 
 # i.e. 1st Monday? 2nd Monday? 3rd Wednesday? 5th Sunday?
+"""
+    dayofweekofmonth(dt::TimeType) -> Int
+
+For the day of week of `dt`, returns which number it is in `dt`'s month. So if the day of
+the week of `dt` is Monday, then `1 = First Monday of the month, 2 = Second Monday of the
+month, etc.` In the range 1:5.
+"""
 dayofweekofmonth(dt::TimeType) = (d = day(dt); return d < 8 ? 1 :
     d < 15 ? 2 : d < 22 ? 3 : d < 29 ? 4 : 5)
 
@@ -48,6 +80,15 @@ dayofweekofmonth(dt::TimeType) = (d = day(dt); return d < 8 ? 1 :
 const TWENTYNINE = IntSet([1,8,15,22,29])
 const THIRTY = IntSet([1,2,8,9,15,16,22,23,29,30])
 const THIRTYONE = IntSet([1,2,3,8,9,10,15,16,17,22,23,24,29,30,31])
+
+"""
+    daysofweekinmonth(dt::TimeType) -> Int
+
+For the day of week of `dt`, returns the total number of that day of the week in `dt`'s
+month. Returns 4 or 5. Useful in temporal expressions for specifying the last day of a week
+in a month by including `dayofweekofmonth(dt) == daysofweekinmonth(dt)` in the adjuster
+function.
+"""
 function daysofweekinmonth(dt::TimeType)
     y,m,d = yearmonthday(dt)
     ld = daysinmonth(y,m)
@@ -76,9 +117,26 @@ const englishabbr_months = Dict(1=>"Jan",2=>"Feb",3=>"Mar",4=>"Apr",
 const VALUETOMONTHABBR = Dict{UTF8String,Dict{Int,UTF8String}}("english"=>englishabbr_months)
 monthname(dt::Integer;locale::AbstractString="english") = VALUETOMONTH[locale][dt]
 monthabbr(dt::Integer;locale::AbstractString="english") = VALUETOMONTHABBR[locale][dt]
+
+"""
+    monthname(dt::TimeType; locale="english") -> AbstractString
+
+Return the full name of the month of the `Date` or `DateTime` in the given `locale`.
+"""
 monthname(dt::TimeType;locale::AbstractString="english") = VALUETOMONTH[locale][month(dt)]
+
+"""
+    monthabbr(dt::TimeType; locale="english") -> AbstractString
+
+Return the abbreviated month name of the `Date` or `DateTime` in the given `locale`.
+"""
 monthabbr(dt::TimeType;locale::AbstractString="english") = VALUETOMONTHABBR[locale][month(dt)]
 
+"""
+    daysinmonth(dt::TimeType) -> Int
+
+Returns the number of days in the month of `dt`. Value will be 28, 29, 30, or 31.
+"""
 daysinmonth(dt::TimeType) = ((y,m) = yearmonth(dt); return daysinmonth(y,m))
 
 @vectorize_1arg TimeType monthname
@@ -86,8 +144,18 @@ daysinmonth(dt::TimeType) = ((y,m) = yearmonth(dt); return daysinmonth(y,m))
 @vectorize_1arg TimeType daysinmonth
 
 ### Years
+"""
+    isleapyear(dt::TimeType) -> Bool
+
+Returns `true` if the year of `dt` is a leap year.
+"""
 isleapyear(dt::TimeType) = isleapyear(year(dt))
 
+"""
+    dayofyear(dt::TimeType) -> Int
+
+Returns the day of the year for `dt` with January 1st being day 1.
+"""
 dayofyear(dt::TimeType) = ((y,m,d) = yearmonthday(dt); return dayofyear(y,m,d))
 
 daysinyear(dt::TimeType) = 365 + isleapyear(dt)
@@ -97,11 +165,22 @@ daysinyear(dt::TimeType) = 365 + isleapyear(dt)
 @vectorize_1arg TimeType daysinyear
 
 ### Quarters
+"""
+    quarterofyear(dt::TimeType) -> Int
+
+Returns the quarter that `dt` resides in. Range of value is 1:4.
+"""
 function quarterofyear(dt::TimeType)
     m = month(dt)
     return m < 4 ? 1 : m < 7 ? 2 : m < 10 ? 3 : 4
 end
 const QUARTERDAYS = [0,90,181,273]
+
+"""
+    dayofquarter(dt::TimeType) -> Int
+
+Returns the day of the current quarter of `dt`. Range of value is 1:92.
+"""
 dayofquarter(dt::TimeType) = dayofyear(dt) - QUARTERDAYS[quarterofyear(dt)]
 
 @vectorize_1arg TimeType quarterofyear
diff --git a/base/dates/types.jl b/base/dates/types.jl
index ce9c7cb933ee1..cbb9a1ed86f07 100644
--- a/base/dates/types.jl
+++ b/base/dates/types.jl
@@ -49,13 +49,20 @@ abstract TimeType <: AbstractTime
 # DateTime is a millisecond precision UTInstant interpreted by ISOCalendar
 immutable DateTime <: TimeType
     instant::UTInstant{Millisecond}
+    DateTime(instant::UTInstant{Millisecond}) = new(instant)
 end
 
 # DateTime is a day precision UTInstant interpreted by ISOCalendar
 immutable Date <: TimeType
     instant::UTInstant{Day}
+    Date(instant::UTInstant{Day}) = new(instant)
 end
 
+# Fallback constructors
+_c(x) = convert(Int64,x)
+DateTime(y,m=1,d=1,h=0,mi=0,s=0,ms=0) = DateTime(_c(y),_c(m),_c(d),_c(h),_c(mi),_c(s),_c(ms))
+Date(y,m=1,d=1) = Date(_c(y),_c(m),_c(d))
+
 # Convert y,m,d to # of Rata Die days
 # Works by shifting the beginning of the year to March 1,
 # so a leap day is the very last day of the year
@@ -77,20 +84,31 @@ daysinmonth(y,m) = DAYSINMONTH[m] + (m == 2 && isleapyear(y))
 
 ### CONSTRUCTORS ###
 # Core constructors
+"""
+    DateTime(y, [m, d, h, mi, s, ms]) -> DateTime
+
+Construct a `DateTime` type by parts. Arguments must be convertible to `Int64`.
+"""
 function DateTime(y::Int64,m::Int64=1,d::Int64=1,
                   h::Int64=0,mi::Int64=0,s::Int64=0,ms::Int64=0)
     0 < m < 13 || throw(ArgumentError("Month: $m out of range (1:12)"))
-    0 < d < daysinmonth(y,m)+1 || throw(ArgumentError("Day: $d out of range (1:$daysinmonth(y,m))"))
-    -1 < h < 24 || throw(ArgumentError("Hour: $h out of range (1:23)"))
-    -1 < mi < 60 || throw(ArgumentError("Minute: $mi out of range (1:59)"))
-    -1 < s < 60 || throw(ArgumentError("Second: $s out of range (1:59)"))
-    -1 < ms < 1000 || throw(ArgumentError("Millisecond: $ms out of range (1:999)"))
+    0 < d < daysinmonth(y,m)+1 || throw(ArgumentError("Day: $d out of range (1:$(daysinmonth(y,m)))"))
+    -1 < h < 24 || throw(ArgumentError("Hour: $h out of range (0:23)"))
+    -1 < mi < 60 || throw(ArgumentError("Minute: $mi out of range (0:59)"))
+    -1 < s < 60 || throw(ArgumentError("Second: $s out of range (0:59)"))
+    -1 < ms < 1000 || throw(ArgumentError("Millisecond: $ms out of range (0:999)"))
     rata = ms + 1000*(s + 60mi + 3600h + 86400*totaldays(y,m,d))
     return DateTime(UTM(rata))
 end
+
+"""
+    Date(y, [m, d]) -> Date
+
+Construct a `Date` type by parts. Arguments must be convertible to `Int64`.
+"""
 function Date(y::Int64,m::Int64=1,d::Int64=1)
     0 < m < 13 || throw(ArgumentError("Month: $m out of range (1:12)"))
-    0 < d < daysinmonth(y,m)+1 || throw(ArgumentError("Day: $d out of range (1:$daysinmonth(y,m))"))
+    0 < d < daysinmonth(y,m)+1 || throw(ArgumentError("Day: $d out of range (1:$(daysinmonth(y,m)))"))
     return Date(UTD(totaldays(y,m,d)))
 end
 
@@ -105,41 +123,60 @@ end
 Date(y::Year,m::Month=Month(1),d::Day=Day(1)) = Date(value(y),value(m),value(d))
 
 # To allow any order/combination of Periods
+
+"""
+    DateTime(periods::Period...) -> DateTime
+
+Construct a `DateTime` type by `Period` type parts. Arguments may be in any order. DateTime
+parts not provided will default to the value of `Dates.default(period)`.
+"""
 function DateTime(periods::Period...)
     y = Year(1); m = Month(1); d = Day(1)
     h = Hour(0); mi = Minute(0); s = Second(0); ms = Millisecond(0)
     for p in periods
-        typeof(p) <: Year && (y = p)
-        typeof(p) <: Month && (m = p)
-        typeof(p) <: Day && (d = p)
-        typeof(p) <: Hour && (h = p)
-        typeof(p) <: Minute && (mi = p)
-        typeof(p) <: Second && (s = p)
-        typeof(p) <: Millisecond && (ms = p)
+        isa(p, Year) && (y = p::Year)
+        isa(p, Month) && (m = p::Month)
+        isa(p, Day) && (d = p::Day)
+        isa(p, Hour) && (h = p::Hour)
+        isa(p, Minute) && (mi = p::Minute)
+        isa(p, Second) && (s = p::Second)
+        isa(p, Millisecond) && (ms = p::Millisecond)
     end
     return DateTime(y,m,d,h,mi,s,ms)
 end
+
+"""
+    Date(period::Period...) -> Date
+
+Construct a `Date` type by `Period` type parts. Arguments may be in any order. `Date` parts
+not provided will default to the value of `Dates.default(period)`.
+"""
 function Date(periods::Period...)
     y = Year(1); m = Month(1); d = Day(1)
     for p in periods
-        typeof(p) <: Year && (y = p)
-        typeof(p) <: Month && (m = p)
-        typeof(p) <: Day && (d = p)
+        isa(p, Year) && (y = p::Year)
+        isa(p, Month) && (m = p::Month)
+        isa(p, Day) && (d = p::Day)
     end
     return Date(y,m,d)
 end
 
-# Fallback constructors
-_c(x) = convert(Int64,x)
-DateTime(y,m=1,d=1,h=0,mi=0,s=0,ms=0) = DateTime(_c(y),_c(m),_c(d),_c(h),_c(mi),_c(s),_c(ms))
-Date(y,m=1,d=1) = Date(_c(y),_c(m),_c(d))
-
 # Traits, Equality
 Base.isfinite{T<:TimeType}(::Union{Type{T},T}) = true
 calendar(dt::DateTime) = ISOCalendar
 calendar(dt::Date) = ISOCalendar
+
+"""
+    eps(::DateTime) -> Millisecond
+    eps(::Date) -> Day
+
+Returns `Millisecond(1)` for `DateTime` values and `Day(1)` for `Date` values.
+"""
+Base.eps
+
 Base.eps(dt::DateTime) = Millisecond(1)
 Base.eps(dt::Date) = Day(1)
+
 Base.typemax(::Union{DateTime,Type{DateTime}}) = DateTime(146138512,12,31,23,59,59)
 Base.typemin(::Union{DateTime,Type{DateTime}}) = DateTime(-146138511,1,1,0,0,0)
 Base.typemax(::Union{Date,Type{Date}}) = Date(252522163911149,12,31)
diff --git a/base/deepcopy.jl b/base/deepcopy.jl
index 787be75d00165..a785f2c8a83b0 100644
--- a/base/deepcopy.jl
+++ b/base/deepcopy.jl
@@ -7,20 +7,12 @@
 
 deepcopy(x) = deepcopy_internal(x, ObjectIdDict())
 
-deepcopy_internal(x::Union{Symbol,LambdaStaticData,TopNode,GlobalRef,
-                           DataType,Union,Task},
+deepcopy_internal(x::Union{Symbol,LambdaInfo,TopNode,GlobalRef,DataType,Union,Task},
                   stackdict::ObjectIdDict) = x
 deepcopy_internal(x::Tuple, stackdict::ObjectIdDict) =
     ntuple(i->deepcopy_internal(x[i], stackdict), length(x))
 deepcopy_internal(x::Module, stackdict::ObjectIdDict) = error("deepcopy of Modules not supported")
 
-function deepcopy_internal(x::Function, stackdict::ObjectIdDict)
-    if isa(x.env, Union{MethodTable, Symbol}) || x.env === ()
-        return x
-    end
-    invoke(deepcopy_internal, Tuple{Any, ObjectIdDict}, x, stackdict)
-end
-
 function deepcopy_internal(x, stackdict::ObjectIdDict)
     if haskey(stackdict, x)
         return stackdict[x]
@@ -31,18 +23,15 @@ end
 function _deepcopy_t(x, T::DataType, stackdict::ObjectIdDict)
     nf = nfields(T)
     (isbits(T) || nf == 0) && return x
+    y = ccall(:jl_new_struct_uninit, Any, (Any,), T)
     if T.mutable
-        y = ccall(:jl_new_struct_uninit, Any, (Any,), T)
         stackdict[x] = y
-        for i in 1:nf
-            if isdefined(x,i)
-                y.(i) = deepcopy_internal(x.(i), stackdict)
-            end
+    end
+    for i in 1:nf
+        if isdefined(x,i)
+            ccall(:jl_set_nth_field, Void, (Any, Csize_t, Any), y, i-1,
+                  deepcopy_internal(getfield(x,i), stackdict))
         end
-    else
-        fields = Any[deepcopy_internal(x.(i), stackdict) for i in 1:nf]
-        y = ccall(:jl_new_structv, Any, (Any, Ptr{Void}, UInt32),
-                  T, pointer(fields), length(fields))
     end
     return y::T
 end
@@ -56,7 +45,7 @@ end
 
 function _deepcopy_array_t(x, T, stackdict::ObjectIdDict)
     if isbits(T)
-        return copy(x)
+        return (stackdict[x]=copy(x))
     end
     dest = similar(x)
     stackdict[x] = dest
diff --git a/base/deprecated.jl b/base/deprecated.jl
index 156b86e5981a1..9c80f62304284 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -56,15 +56,6 @@ macro deprecate(old,new)
     end
 end
 
-remove_linenums!(ex) = ex
-function remove_linenums!(ex::Expr)
-    filter!(x->!((isa(x,Expr) && is(x.head,:line)) || isa(x,LineNumberNode)), ex.args)
-    for subex in ex.args
-        remove_linenums!(subex)
-    end
-    ex
-end
-
 function depwarn(msg, funcsym)
     opts = JLOptions()
     if opts.depwarn > 0
@@ -85,13 +76,12 @@ function firstcaller(bt::Array{Ptr{Void},1}, funcsym::Symbol)
     # Identify the calling line
     i = 1
     while i <= length(bt)
-        lkup = ccall(:jl_lookup_code_address, Any, (Ptr{Void},Cint), bt[i], true)
+        lkup = StackTraces.lookup(bt[i])
         i += 1
-        if lkup === ()
+        if lkup === StackTraces.UNKNOWN
             continue
         end
-        fname, file, line, inlinedat_file, inlinedat_line, fromC = lkup
-        if fname == funcsym
+        if lkup.func == funcsym
             break
         end
     end
@@ -101,6 +91,16 @@ function firstcaller(bt::Array{Ptr{Void},1}, funcsym::Symbol)
     return C_NULL
 end
 
+deprecate(s::Symbol) = deprecate(current_module(), s)
+deprecate(m::Module, s::Symbol) = ccall(:jl_deprecate_binding, Void, (Any, Any), m, s)
+
+macro deprecate_binding(old, new)
+    Expr(:toplevel,
+         Expr(:export, esc(old)),
+         Expr(:const, Expr(:(=), esc(old), esc(new))),
+         Expr(:call, :deprecate, Expr(:quote, old)))
+end
+
 # 0.4 deprecations
 
 @deprecate split(x,y,l::Integer,k::Bool) split(x,y;limit=l,keep=k)
@@ -111,24 +111,22 @@ end
 @deprecate rsplit(x,y,l::Integer) rsplit(x,y;limit=l)
 @deprecate rsplit(x,y,k::Bool) rsplit(x,y;keep=k)
 
-export UdpSocket
 const TcpSocket = TCPSocket
-const UdpSocket = UDPSocket
+deprecate(:TcpSocket)
 const IpAddr = IPAddr
+deprecate(:IpAddr)
+@deprecate_binding UdpSocket UDPSocket
 
 @deprecate isblank(c::Char) c == ' ' || c == '\t'
 @deprecate isblank(s::AbstractString) all(c -> c == ' ' || c == '\t', s)
 
-export Nothing
-const Nothing = Void
-
-export None
-const None = Union{}
+@deprecate_binding Nothing Void
+@deprecate_binding None Union{}
 
 export apply
 @noinline function apply(f, args...)
     depwarn("apply(f, x) is deprecated, use `f(x...)` instead", :apply)
-    return Core._apply(call, f, args...)
+    return Core._apply(f, args...)
 end
 
 @deprecate median(v::AbstractArray; checknan::Bool=true)  median(v)
@@ -150,16 +148,15 @@ end
 @deprecate inf{T<:AbstractFloat}(::Type{T})  convert(T,Inf)
 @deprecate nan{T<:AbstractFloat}(::Type{T})  convert(T,NaN)
 
-export String
-const String = AbstractString
+@deprecate_binding String AbstractString
 
-export Uint, Uint8, Uint16, Uint32, Uint64, Uint128
-const Uint = UInt
-const Uint8 = UInt8
-const Uint16 = UInt16
-const Uint32 = UInt32
-const Uint64 = UInt64
-const Uint128 = UInt128
+# 13221 - when removing Uint deprecation, remove hack in jl_binding_deprecation_warning
+@deprecate_binding Uint    UInt
+@deprecate_binding Uint8   UInt8
+@deprecate_binding Uint16  UInt16
+@deprecate_binding Uint32  UInt32
+@deprecate_binding Uint64  UInt64
+@deprecate_binding Uint128 UInt128
 
 @deprecate zero{T}(::Type{Ptr{T}}) Ptr{T}(0)
 @deprecate zero{T}(x::Ptr{T})      Ptr{T}(0)
@@ -178,8 +175,7 @@ const Uint128 = UInt128
 @deprecate iround(x)              round(Integer,x)
 @deprecate iround{T}(::Type{T},x) round(T,x)
 
-export Base64Pipe
-const Base64Pipe = Base64EncodePipe
+@deprecate_binding Base64Pipe Base64EncodePipe
 @deprecate base64 base64encode
 
 @deprecate prevind(a::Any, i::Integer)   i-1
@@ -208,8 +204,7 @@ const Base64Pipe = Base64EncodePipe
 @deprecate error(ex::Exception) throw(ex)
 @deprecate error{E<:Exception}(::Type{E}) throw(E())
 
-export MemoryError
-const MemoryError = OutOfMemoryError
+@deprecate_binding MemoryError OutOfMemoryError
 
 @deprecate map!(f::Callable, dest::StridedArray, A::StridedArray, B::Number) broadcast!(f, dest, A, B)
 @deprecate map!(f::Callable, dest::StridedArray, A::Number, B::StridedArray) broadcast!(f, dest, A, B)
@@ -250,16 +245,38 @@ const MemoryError = OutOfMemoryError
 @deprecate float64(s::AbstractString)   parse(Float64,s)
 @deprecate float32(s::AbstractString)   parse(Float32,s)
 
-for (f,t) in ((:integer, Integer), (:signed, Signed),
-              (:unsigned, Unsigned), (:int, Int), (:int8, Int8), (:int16, Int16),
-              (:int32, Int32), (:int64, Int64), (:int128, Int128), (:uint, UInt),
-              (:uint8, UInt8), (:uint16, UInt16), (:uint32, UInt32), (:uint64, UInt64),
-              (:uint128, UInt128))
+for (f,t) in ((:integer, Integer), (:signed, Signed), (:unsigned, Unsigned))
     @eval begin
         @deprecate $f(x::AbstractArray) round($t, x)
     end
 end
 
+for (f,t) in ((:int,    Int), (:int8,   Int8), (:int16,  Int16), (:int32,  Int32),
+              (:int64,  Int64), (:int128, Int128), (:uint,   UInt), (:uint8,  UInt8),
+              (:uint16, UInt16), (:uint32, UInt32), (:uint64, UInt64), (:uint128,UInt128))
+    ex1 = sprint(io->show_unquoted(io,:([parse($t,s) for s in a])))
+    ex2 = sprint(io->show_unquoted(io,:(round($t, a))))
+    name = Expr(:quote,f)
+    @eval begin
+        function ($f)(x::AbstractArray)
+            if all(y->isa(y,AbstractString), x)
+                depwarn(string($name,"(a::AbstractArray) is deprecated, use ", $ex1, " instead."), $name)
+                return [parse($t,s) for s in x]
+            elseif all(y->isa(y,Number), x)
+                depwarn(string($name,"(a::AbstractArray) is deprecated, use ", $ex2, " instead."), $name)
+                return round($t, x)
+            end
+            y = similar(x,$t)
+            i = 1
+            for e in x
+                y[i] = ($f)(e)
+                i += 1
+            end
+            y
+        end
+    end
+end
+
 for (f,t) in ((:char, Char), (:bool, Bool), (:float16, Float16), (:float32, Float32),
               (:float64, Float64), (:complex64, Complex64), (:complex128, Complex128))
     @eval begin
@@ -342,13 +359,6 @@ end
 @deprecate integer(x::Ptr)   convert(UInt, x)
 @deprecate unsigned(x::Ptr)  convert(UInt, x)
 
-for (f,t) in ((:int,    Int), (:int8,   Int8), (:int16,  Int16), (:int32,  Int32),
-              (:int64,  Int64), (:int128, Int128), (:uint,   UInt), (:uint8,  UInt8),
-              (:uint16, UInt16), (:uint32, UInt32), (:uint64, UInt64), (:uint128,UInt128))
-    @eval begin
-        @deprecate ($f){S<:AbstractString}(a::AbstractArray{S}) [parse($t,s) for s in a]
-    end
-end
 for (f,t) in ((:float32, Float32), (:float64, Float64))
     @eval begin
         @deprecate ($f){S<:AbstractString}(a::AbstractArray{S}) [parse($t,s) for s in a]
@@ -424,7 +434,7 @@ end
 to_index_nodep(i::Real) = convert(Int,i)::Int
 
 @noinline function to_index(i::Real)
-    depwarn("indexing with non Integer Reals is deprecated", :to_index)
+    depwarn("Indexing with non-Integer Reals is deprecated.  It may be that your index arose from an integer division of the form i/j, in which case you should consider using i÷j or div(i,j) instead.", :to_index)
     to_index_nodep(i)
 end
 
@@ -495,7 +505,13 @@ export float32_isvalid, float64_isvalid
 @deprecate utf32(c::Integer...)   UTF32String(UInt32[c...,0])
 
 # 12087
-@deprecate call(P::Base.DFT.Plan, A) P * A
+@deprecate call(P::Base.DFT.ScaledPlan, A) P * A
+if Base.USE_GPL_LIBS
+    @deprecate call(P::Base.FFTW.DCTPlan, A) P * A
+    @deprecate call(P::Base.FFTW.cFFTWPlan, A) P * A
+    @deprecate call(P::Base.FFTW.rFFTWPlan, A) P * A
+    @deprecate call(P::Base.FFTW.r2rFFTWPlan, A) P * A
+end
 for f in (:plan_fft, :plan_ifft, :plan_bfft, :plan_fft!, :plan_ifft!, :plan_bfft!, :plan_rfft)
     @eval @deprecate $f(A, dims, flags) $f(A, dims; flags=flags)
     @eval @deprecate $f(A, dims, flags, tlim) $f(A, dims; flags=flags, timelimit=tlim)
@@ -542,21 +558,34 @@ function start_timer(t, d, r)
     error("start_timer is deprecated. Use Timer(callback, delay, repeat) instead.")
 end
 
-const UnionType = Union
-export UnionType
+@deprecate_binding UnionType Union
 
-const MathConst = Irrational
+@deprecate_binding MathConst Irrational
 
 macro math_const(sym, val, def)
     depwarn("@math_const is deprecated and renamed to @irrational.", symbol("@math_const"))
     :(@irrational $(esc(sym)) $(esc(val)) $(esc(def)))
 end
-
-export MathConst, @math_const
+export @math_const
 
 # 11280, mmap
 
 export msync
+
+"""
+    msync(ptr, len, [flags])
+
+Forces synchronization of the [`mmap`](:func:`mmap`)ped memory region from `ptr` to
+`ptr+len`. Flags defaults to `MS_SYNC`, but can be a combination of `MS_ASYNC`, `MS_SYNC`,
+or `MS_INVALIDATE`. See your platform man page for specifics. The flags argument is not
+valid on Windows.
+
+You may not need to call `msync`, because synchronization is performed at intervals
+automatically by the operating system. However, you can call this directly if, for example,
+you are concerned about losing the result of a long-running calculation.
+"""
+function msync end
+
 msync{T}(A::Array{T}) = msync(pointer(A), length(A)*sizeof(T))
 msync(B::BitArray) = msync(pointer(B.chunks), length(B.chunks)*sizeof(UInt64))
 
@@ -573,10 +602,10 @@ export mmap
         throw(ArgumentError("requested size must be ≤ $(typemax(Int)-pagesize), got $len"))
     end
     # Set the offset to a page boundary
-    offset_page::FileOffset = floor(Integer,offset/pagesize)*pagesize
+    offset_page::Int64 = floor(Integer,offset/pagesize)*pagesize
     len_page::Int = (offset-offset_page) + len
     # Mmap the file
-    p = ccall(:jl_mmap, Ptr{Void}, (Ptr{Void}, Csize_t, Cint, Cint, Cint, FileOffset), C_NULL, len_page, prot, flags, fd, offset_page)
+    p = ccall(:jl_mmap, Ptr{Void}, (Ptr{Void}, Csize_t, Cint, Cint, Cint, Int64), C_NULL, len_page, prot, flags, fd, offset_page)
     systemerror("memory mapping failed", reinterpret(Int,p) == -1)
     # Also return a pointer that compensates for any adjustment in the offset
     return p, Int(offset-offset_page)
@@ -626,7 +655,7 @@ type SharedMemSpec
     create :: Bool
 end
 export mmap_array
-@noinline function mmap_array{T,N}(::Type{T}, dims::NTuple{N,Integer}, s::Union{IO,SharedMemSpec}, offset::FileOffset)
+@noinline function mmap_array{T,N}(::Type{T}, dims::NTuple{N,Integer}, s::Union{IO,SharedMemSpec}, offset::Int64)
     depwarn("`mmap_array` is deprecated, use `Mmap.mmap(io, Array{T,N}, dims, offset)` instead to return an mmapped-array", :mmap_array)
     if isa(s,SharedMemSpec)
         a = Mmap.Anonymous(s.name, s.readonly, s.create)
@@ -637,7 +666,7 @@ export mmap_array
 end
 end
 
-@deprecate mmap_bitarray{N}(::Type{Bool}, dims::NTuple{N,Integer}, s::IOStream, offset::FileOffset=position(s)) mmap(s, BitArray, dims, offset)
+@deprecate mmap_bitarray{N}(::Type{Bool}, dims::NTuple{N,Integer}, s::IOStream, offset::Int64=position(s)) mmap(s, BitArray, dims, offset)
 @deprecate mmap_bitarray{N}(dims::NTuple{N,Integer}, s::IOStream, offset=position(s)) mmap(s, BitArray, dims, offset)
 
 # T[a:b] and T[a:s:b]
@@ -661,14 +690,36 @@ end
 
 ## require ##
 
+function maybe_require_file(name::AbstractString)
+    isabspath(name) && return name
+    isfile(name) && return abspath(name)
+    if !endswith(name,".jl")
+        fname = string(name,".jl")
+        isfile(fname) && return abspath(fname)
+    end
+    return name
+end
+
 include("require.jl")
 @noinline function require(f::AbstractString)
-    if !(endswith(f,".jl") || contains(f,path_separator))
-        # for require("Name") this function shouldn't be needed at all
-        error("use `using` or `import` to load packages")
-    end
     depwarn("`require` is deprecated, use `using` or `import` instead", :require)
-    OldRequire.require(f)
+    if endswith(f,".jl") || contains(f,Filesystem.path_separator)
+        # specifying file path
+        OldRequire.require(f)
+    else
+        # require("Foo") --- ambiguous. might be file or package
+        filename = maybe_require_file(f)
+        if filename == f
+            mod = symbol(require_modname(f))
+            M = current_module()
+            if isdefined(M,mod) && isa(eval(M,mod),Module)
+                return
+            end
+            require(mod)
+        else
+            OldRequire.require(f)
+        end
+    end
 end
 @noinline function require(f::AbstractString, fs::AbstractString...)
     require(f)
@@ -767,8 +818,7 @@ end
 
 @deprecate iseltype(x,T)  eltype(x) <: T
 
-const FloatingPoint = AbstractFloat
-export FloatingPoint
+@deprecate_binding FloatingPoint AbstractFloat
 
 # 11447
 
@@ -787,3 +837,165 @@ export FloatingPoint
 end
 
 @deprecate cartesianmap(f, dims) for idx in CartesianRange(dims); f(idx.I...); end
+
+@deprecate Union(args...) Union{args...}
+
+# 0.5 deprecations
+
+# 12839
+const AsyncStream = IO
+deprecate(:AsyncStream)
+
+for f in (:remotecall, :remotecall_fetch, :remotecall_wait)
+    @eval begin
+        @deprecate ($f)(w::LocalProcess, f::Function, args...)    ($f)(f, w::LocalProcess, args...)
+        @deprecate ($f)(w::Worker, f::Function, args...)          ($f)(f, w::Worker, args...)
+        @deprecate ($f)(id::Integer, f::Function, args...)        ($f)(f, id::Integer, args...)
+    end
+end
+
+# 13232
+@deprecate with_bigfloat_precision setprecision
+@deprecate set_bigfloat_precision(prec) setprecision(prec)
+@deprecate get_bigfloat_precision() precision(BigFloat)
+
+@deprecate set_rounding setrounding
+@deprecate with_rounding setrounding
+@deprecate get_rounding rounding
+
+#13465
+@deprecate cov(x::AbstractVector; corrected=true, mean=Base.mean(x)) covm(x, mean, corrected)
+@deprecate cov(X::AbstractMatrix; vardim=1, corrected=true, mean=Base.mean(X, vardim)) covm(X, mean, vardim, corrected)
+@deprecate cov(x::AbstractVector, y::AbstractVector; corrected=true, mean=(Base.mean(x), Base.mean(y))) covm(x, mean[1], y, mean[2], corrected)
+@deprecate cov(X::AbstractVecOrMat, Y::AbstractVecOrMat; vardim=1, corrected=true, mean=(Base.mean(X, vardim), Base.mean(Y, vardim))) covm(X, mean[1], Y, mean[2], vardim, corrected)
+
+@deprecate cor(x::AbstractVector; mean=Base.mean(x)) corm(x, mean)
+@deprecate cor(X::AbstractMatrix; vardim=1, mean=Base.mean(X, vardim)) corm(X, mean, vardim)
+@deprecate cor(x::AbstractVector, y::AbstractVector; mean=(Base.mean(x), Base.mean(y))) corm(x, mean[1], y, mean[2])
+@deprecate cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; vardim=1, mean=(Base.mean(X, vardim), Base.mean(Y, vardim))) corm(X, mean[1], Y, mean[2], vardim)
+
+@deprecate_binding SparseMatrix SparseArrays
+
+#13496
+@deprecate A_ldiv_B!(A::SparseMatrixCSC, B::StridedVecOrMat) A_ldiv_B!(factorize(A), B)
+
+@deprecate chol(A::Number, ::Type{Val{:U}})         chol(A)
+@deprecate chol(A::AbstractMatrix, ::Type{Val{:U}}) chol(A)
+@deprecate chol(A::Number, ::Type{Val{:L}})         ctranspose(chol(A))
+@deprecate chol(A::AbstractMatrix, ::Type{Val{:L}}) ctranspose(chol(A))
+
+# Number updates
+
+# rem1 is inconsistent for x==0: The result should both have the same
+# sign as x, and should be non-zero.
+function rem1{T<:Real}(x::T, y::T)
+    depwarn("`rem1(x,y)` is discontinued, as it cannot be defined consistently for `x==0`. Rewrite the expression using `mod1` instead.", :rem1)
+    rem(x-1,y)+1
+end
+
+# Filesystem module updates
+
+@deprecate_binding FS Filesystem
+
+isreadable(path...) = isreadable(stat(path...))
+iswritable(path...) = iswritable(stat(path...))
+isexecutable(path...) = isexecutable(stat(path...))
+function isreadable(st::Filesystem.StatStruct)
+    depwarn("isreadable is deprecated as it implied that the file would actually be readable by the user; consider using `isfile` instead. see also the system man page for `access`", :isreadable)
+    return (st.mode & 0o444) > 0
+end
+function iswritable(st::Filesystem.StatStruct)
+    depwarn("iswritable is deprecated as it implied that the file would actually be writable by the user; consider using `isfile` instead. see also the system man page for `access`", :iswritable)
+    return (st.mode & 0o222) > 0
+end
+function isexecutable(st::Filesystem.StatStruct)
+    depwarn("isexecutable is deprecated as it implied that the file would actually be executable by the user; consider using `isfile` instead. see also the system man page for `access`", :isexecutable)
+    return (st.mode & 0o111) > 0
+end
+export isreadable, iswritable, isexecutable
+
+@deprecate RemoteRef RemoteChannel
+
+function tty_size()
+    depwarn("tty_size is deprecated. use `displaysize(io)` as a replacement", :tty_size)
+    if isdefined(Base, :active_repl)
+        os = REPL.outstream(Base.active_repl)
+        if isa(os, Terminals.TTYTerminal)
+            return displaysize(os)
+        end
+    end
+    if isdefined(Base, :STDOUT)
+        return displaysize(STDOUT)
+    end
+    return displaysize()
+end
+
+#14335
+@deprecate super(T::DataType) supertype(T)
+
+function with_output_limit(thk, lim=true) # thk is usually show()
+    depwarn("with_output_limit is deprecated. use `io = IOContext(io, :limit_output => lim)` as a replacement", :with_output_limit)
+    global _limit_output
+    last = _limit_output
+    _limit_output::Bool = lim
+    try
+        thk()
+    finally
+        _limit_output = last
+    end
+end
+
+#14555
+@deprecate_binding Coff_t Int64
+@deprecate_binding FileOffset Int64
+
+#14474
+macro boundscheck(yesno,blk)
+    depwarn("The meaning of `@boundscheck` has changed. It now indicates that the provided code block performs bounds checking, and may be elided when inbounds.", symbol("@boundscheck"))
+    if yesno === true
+        :(@inbounds $(esc(blk)))
+    end
+end
+
+
+@deprecate parseip(str::AbstractString) parse(IPAddr, str)
+
+#https://github.com/JuliaLang/julia/issues/14608
+@deprecate readall readstring
+@deprecate readbytes read
+
+@deprecate field_offset(x::DataType, idx) fieldoffset(x, idx+1)
+@noinline function fieldoffsets(x::DataType)
+    depwarn("fieldoffsets is deprecated. use `map(idx->fieldoffset(x, idx), 1:nfields(x))` instead", :fieldoffsets)
+    nf = nfields(x)
+    offsets = Array(Int, nf)
+    for i = 1:nf
+        offsets[i] = fieldoffset(x, i)
+    end
+    return offsets
+end
+export fieldoffsets
+
+# 14766
+@deprecate write(io::IO, p::Ptr, nb::Integer) unsafe_write(io, p, nb)
+
+@deprecate isgeneric(f) isa(f,Function)
+
+# need to do this manually since the front end deprecates method defs of `call`
+const call = @eval function(f, args...; kw...)
+    $(Expr(:meta, :noinline))
+    depwarn("call(f,args...) is deprecated, use f(args...) instead.", :call)
+    f(args...; kw...)
+end
+export call
+
+@deprecate_binding LambdaStaticData LambdaInfo
+
+# Changed issym to issymmetric. #15192
+@deprecate issym issymmetric
+
+# 15258
+@deprecate scale(α::Number, A::AbstractArray) α*A
+@deprecate scale(A::AbstractArray, α::Number) A*α
+@deprecate scale(A::AbstractMatrix, x::AbstractVector) A*Diagonal(x)
+@deprecate scale(x::AbstractVector, A::AbstractMatrix) Diagonal(x)*A
diff --git a/base/dft.jl b/base/dft.jl
index 706d55c259389..8ac815d6203a4 100644
--- a/base/dft.jl
+++ b/base/dft.jl
@@ -39,6 +39,142 @@ for f in (:fft, :bfft, :ifft, :fft!, :bfft!, :ifft!, :rfft)
     end
 end
 
+"""
+    plan_ifft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Same as [`plan_fft`](:func:`plan_fft`), but produces a plan that performs inverse transforms
+[`ifft`](:func:`ifft`).
+"""
+plan_ifft
+
+"""
+    plan_ifft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Same as [`plan_ifft`](:func:`plan_ifft`), but operates in-place on `A`.
+"""
+plan_ifft!
+
+"""
+    plan_bfft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Same as [`plan_bfft`](:func:`plan_bfft`), but operates in-place on `A`.
+"""
+plan_bfft!
+
+"""
+    plan_bfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Same as [`plan_fft`](:func:`plan_fft`), but produces a plan that performs an unnormalized
+backwards transform [`bfft`](:func:`bfft`).
+"""
+plan_bfft
+
+"""
+    plan_fft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Pre-plan an optimized FFT along given dimensions (`dims`) of arrays matching the shape and
+type of `A`.  (The first two arguments have the same meaning as for [`fft`](:func:`fft`).)
+Returns an object `P` which represents the linear operator computed by the FFT, and which
+contains all of the information needed to compute `fft(A, dims)` quickly.
+
+To apply `P` to an array `A`, use `P * A`; in general, the syntax for applying plans is much
+like that of matrices.  (A plan can only be applied to arrays of the same size as the `A`
+for which the plan was created.)  You can also apply a plan with a preallocated output array `Â`
+by calling `A_mul_B!(Â, plan, A)`.  You can compute the inverse-transform plan by `inv(P)`
+and apply the inverse plan with `P \\ Â` (the inverse plan is cached and reused for
+subsequent calls to `inv` or `\\`), and apply the inverse plan to a pre-allocated output
+array `A` with `A_ldiv_B!(A, P, Â)`.
+
+The `flags` argument is a bitwise-or of FFTW planner flags, defaulting to `FFTW.ESTIMATE`.
+e.g. passing `FFTW.MEASURE` or `FFTW.PATIENT` will instead spend several seconds (or more)
+benchmarking different possible FFT algorithms and picking the fastest one; see the FFTW
+manual for more information on planner flags.  The optional `timelimit` argument specifies a
+rough upper bound on the allowed planning time, in seconds. Passing `FFTW.MEASURE` or
+`FFTW.PATIENT` may cause the input array `A` to be overwritten with zeros during plan
+creation.
+
+[`plan_fft!`](:func:`plan_fft!`) is the same as [`plan_fft`](:func:`plan_fft`) but creates a
+plan that operates in-place on its argument (which must be an array of complex
+floating-point numbers). [`plan_ifft`](:func:`plan_ifft`) and so on are similar but produce
+plans that perform the equivalent of the inverse transforms [`ifft`](:func:`ifft`) and so on.
+"""
+plan_fft
+
+"""
+    plan_fft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Same as [`plan_fft`](:func:`plan_fft`), but operates in-place on `A`.
+"""
+plan_fft!
+
+"""
+    rfft(A [, dims])
+
+Multidimensional FFT of a real array `A`, exploiting the fact that the transform has
+conjugate symmetry in order to save roughly half the computational time and storage costs
+compared with [`fft`](:func:`fft`). If `A` has size `(n_1, ..., n_d)`, the result has size
+`(div(n_1,2)+1, ..., n_d)`.
+
+The optional `dims` argument specifies an iterable subset of one or more dimensions of `A`
+to transform, similar to [`fft`](:func:`fft`). Instead of (roughly) halving the first
+dimension of `A` in the result, the `dims[1]` dimension is (roughly) halved in the same way.
+"""
+rfft
+
+"""
+    ifft!(A [, dims])
+
+Same as [`ifft`](:func:`ifft`), but operates in-place on `A`.
+"""
+ifft!
+
+"""
+    ifft(A [, dims])
+
+Multidimensional inverse FFT.
+
+A one-dimensional inverse FFT computes
+
+```math
+\\operatorname{IDFT}(A)[k] = \\frac{1}{\\operatorname{length}(A)}
+\\sum_{n=1}^{\\operatorname{length}(A)} \\exp\\left(+i\\frac{2\\pi (n-1)(k-1)}
+{\\operatorname{length}(A)} \\right) A[n].
+```
+
+A multidimensional inverse FFT simply performs this operation along each transformed dimension of `A`.
+"""
+ifft
+
+"""
+    fft!(A [, dims])
+
+Same as [`fft`](:func:`fft`), but operates in-place on `A`, which must be an array of
+complex floating-point numbers.
+"""
+fft!
+
+"""
+    bfft(A [, dims])
+
+Similar to [`ifft`](:func:`ifft`), but computes an unnormalized inverse (backward)
+transform, which must be divided by the product of the sizes of the transformed dimensions
+in order to obtain the inverse. (This is slightly more efficient than [`ifft`](:func:`ifft`)
+because it omits a scaling step, which in some applications can be combined with other
+computational steps elsewhere.)
+
+```math
+\\operatorname{BDFT}(A)[k] = \\operatorname{length}(A) \\operatorname{IDFT}(A)[k]
+```
+"""
+bfft
+
+"""
+    bfft!(A [, dims])
+
+Same as [`bfft`](:func:`bfft`), but operates in-place on `A`.
+"""
+bfft!
+
 # promote to a complex floating-point type (out-of-place only),
 # so implementations only need Complex{Float} methods
 for f in (:fft, :bfft, :ifft)
@@ -86,7 +222,7 @@ type ScaledPlan{T,P,N} <: Plan{T}
     pinv::Plan
     ScaledPlan(p, scale) = new(p, scale)
 end
-call{T,P,N}(::Type{ScaledPlan{T}}, p::P, scale::N) = ScaledPlan{T,P,N}(p, scale)
+(::Type{ScaledPlan{T}}){T,P,N}(p::P, scale::N) = ScaledPlan{T,P,N}(p, scale)
 ScaledPlan{T}(p::Plan{T}, scale::Number) = ScaledPlan{T}(p, scale)
 ScaledPlan(p::ScaledPlan, α::Number) = ScaledPlan(p.p, p.scale * α)
 
@@ -142,6 +278,29 @@ for f in (:brfft, :irfft)
     end
 end
 
+"""
+    irfft(A, d [, dims])
+
+Inverse of [`rfft`](:func:`rfft`): for a complex array `A`, gives the corresponding real
+array whose FFT yields `A` in the first half. As for [`rfft`](:func:`rfft`), `dims` is an
+optional subset of dimensions to transform, defaulting to `1:ndims(A)`.
+
+`d` is the length of the transformed real array along the `dims[1]` dimension, which must
+satisfy `div(d,2)+1 == size(A,dims[1])`. (This parameter cannot be inferred from `size(A)`
+since both `2*size(A,dims[1])-2` as well as `2*size(A,dims[1])-1` are valid sizes for the
+transformed real array.)
+"""
+irfft
+
+"""
+    brfft(A, d [, dims])
+
+Similar to [`irfft`](:func:`irfft`) but computes an unnormalized inverse transform (similar
+to [`bfft`](:func:`bfft`)), which must be divided by the product of the sizes of the
+transformed dimensions (of the real output array) in order to obtain the inverse transform.
+"""
+brfft
+
 function rfft_output_size(x::AbstractArray, region)
     d1 = first(region)
     osize = [size(x)...]
@@ -161,20 +320,50 @@ plan_irfft{T}(x::AbstractArray{Complex{T}}, d::Integer, region; kws...) =
     ScaledPlan(plan_brfft(x, d, region; kws...),
                normalization(T, brfft_output_size(x, d, region), region))
 
+"""
+    plan_irfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Pre-plan an optimized inverse real-input FFT, similar to [`plan_rfft`](:func:`plan_rfft`)
+except for [`irfft`](:func:`irfft`) and [`brfft`](:func:`brfft`), respectively. The first
+three arguments have the same meaning as for [`irfft`](:func:`irfft`).
+"""
+plan_irfft
+
 ##############################################################################
 
 export fftshift, ifftshift
 
 fftshift(x) = circshift(x, div([size(x)...],2))
 
+"""
+    fftshift(x)
+
+Swap the first and second halves of each dimension of `x`.
+"""
+fftshift(x)
+
 function fftshift(x,dim)
     s = zeros(Int,ndims(x))
     s[dim] = div(size(x,dim),2)
     circshift(x, s)
 end
 
+"""
+    fftshift(x,dim)
+
+Swap the first and second halves of the given dimension of array `x`.
+"""
+fftshift(x,dim)
+
 ifftshift(x) = circshift(x, div([size(x)...],-2))
 
+"""
+    ifftshift(x, [dim])
+
+Undoes the effect of `fftshift`.
+"""
+ifftshift
+
 function ifftshift(x,dim)
     s = zeros(Int,ndims(x))
     s[dim] = -div(size(x,dim),2)
@@ -185,6 +374,32 @@ end
 
 # FFTW module (may move to an external package at some point):
 if Base.USE_GPL_LIBS
+
+    @doc """
+        fft(A [, dims])
+
+    Performs a multidimensional FFT of the array `A`. The optional `dims` argument specifies an
+    iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along.
+    Most efficient if the size of `A` along the transformed dimensions is a product of small
+    primes; see `nextprod()`. See also `plan_fft()` for even greater efficiency.
+
+    A one-dimensional FFT computes the one-dimensional discrete Fourier transform (DFT) as
+    defined by
+
+    ```math
+    \\operatorname{DFT}(A)[k] =
+      \\sum_{n=1}^{\\operatorname{length}(A)}
+      \\exp\\left(-i\\frac{2\\pi
+      (n-1)(k-1)}{\\operatorname{length}(A)} \\right) A[n].
+    ```
+
+    A multidimensional FFT simply performs this operation along each transformed dimension of `A`.
+
+    Higher performance is usually possible with multi-threading. Use `FFTW.set_num_threads(np)`
+    to use `np` threads, if you have `np` processors.
+    """ ->
+    fft
+
     include("fft/FFTW.jl")
     importall .FFTW
     export FFTW, dct, idct, dct!, idct!, plan_dct, plan_idct, plan_dct!, plan_idct!
diff --git a/base/dict.jl b/base/dict.jl
index 22fee19569fb6..c6f52be16e69d 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -8,14 +8,26 @@ const secret_table_token = :__c782dbf1cf4d6a2e5e3865d7e95634f2e09b5902__
 
 haskey(d::Associative, k) = in(k,keys(d))
 
-function in(p, a::Associative)
-    if !isa(p,Pair)
-        error("""Associative collections only contain Pairs;
-                 Either look for e.g. A=>B instead, or use the `keys` or `values`
-                 function if you are looking for a key or value respectively.""")
-    end
+function in(p::Pair, a::Associative, valcmp=(==))
     v = get(a,p[1],secret_table_token)
-    !is(v, secret_table_token) && (v == p[2])
+    if !is(v, secret_table_token)
+        if valcmp === is
+            is(v, p[2]) && return true
+        elseif valcmp === (==)
+            ==(v, p[2]) && return true
+        elseif valcmp === isequal
+            isequal(v, p[2]) && return true
+        else
+            valcmp(v, p[2]) && return true
+        end
+    end
+    return false
+end
+
+function in(p, a::Associative)
+    error("""Associative collections only contain Pairs;
+             Either look for e.g. A=>B instead, or use the `keys` or `values`
+             function if you are looking for a key or value respectively.""")
 end
 
 function summary(t::Associative)
@@ -49,87 +61,81 @@ function _truncate_at_width_or_chars(str, width, chars="", truncmark="…")
 end
 
 showdict(t::Associative; kw...) = showdict(STDOUT, t; kw...)
-function showdict{K,V}(io::IO, t::Associative{K,V}; limit::Bool = false, compact = false,
-                       sz=(s = tty_size(); (s[1]-3, s[2])))
-    shown_set = get(task_local_storage(), :SHOWNSET, nothing)
-    if shown_set === nothing
-        shown_set = ObjectIdDict()
-        task_local_storage(:SHOWNSET, shown_set)
-    end
-    t in keys(shown_set) && (print(io, "#= circular reference =#"); return)
-
-    try
-        shown_set[t] = true
-        if compact
-            # show in a Julia-syntax-like form: Dict(k=>v, ...)
-            if isempty(t)
-                print(io, typeof(t), "()")
+function showdict{K,V}(io::IO, t::Associative{K,V}; compact = false)
+    (:SHOWN_SET => t) in io && (print(io, "#= circular reference =#"); return)
+
+    recur_io = IOContext(io, :SHOWN_SET => t)
+    limit::Bool = limit_output(io)
+    if compact
+        # show in a Julia-syntax-like form: Dict(k=>v, ...)
+        if isempty(t)
+            print(io, typeof(t), "()")
+        else
+            if isleaftype(K) && isleaftype(V)
+                print(io, typeof(t).name)
             else
-                if isleaftype(K) && isleaftype(V)
-                    print(io, typeof(t).name)
-                else
-                    print(io, typeof(t))
-                end
-                print(io, '(')
-                first = true
-                n = 0
-                for (k, v) in t
-                    first || print(io, ',')
-                    first = false
-                    show(io, k)
-                    print(io, "=>")
-                    show(io, v)
-                    n+=1
-                    limit && n >= 10 && (print(io, "…"); break)
-                end
-                print(io, ')')
+                print(io, typeof(t))
             end
-            return
+            print(io, '(')
+            first = true
+            n = 0
+            for (k, v) in t
+                first || print(io, ',')
+                first = false
+                show(recur_io, k)
+                print(io, "=>")
+                show(recur_io, v)
+                n+=1
+                limit && n >= 10 && (print(io, "…"); break)
+            end
+            print(io, ')')
         end
+        return
+    end
 
-        # Otherwise show more descriptively, with one line per key/value pair
-        rows, cols = sz
-        print(io, summary(t))
-        isempty(t) && return
-        print(io, ":")
-        if limit
-            rows < 2   && (print(io, " …"); return)
-            cols < 12  && (cols = 12) # Minimum widths of 2 for key, 4 for value
-            cols -= 6 # Subtract the widths of prefix "  " separator " => "
-            rows -= 2 # Subtract the summary and final ⋮ continuation lines
-
-            # determine max key width to align the output, caching the strings
-            ks = Array(AbstractString, min(rows, length(t)))
-            keylen = 0
-            for (i, k) in enumerate(keys(t))
-                i > rows && break
-                ks[i] = sprint(show, k)
-                keylen = clamp(length(ks[i]), keylen, div(cols, 3))
-            end
+    # Otherwise show more descriptively, with one line per key/value pair
+    print(io, summary(t))
+    isempty(t) && return
+    print(io, ":")
+    if limit
+        sz = displaysize(io)
+        rows, cols = sz[1] - 3, sz[2]
+        rows < 2   && (print(io, " …"); return)
+        cols < 12  && (cols = 12) # Minimum widths of 2 for key, 4 for value
+        cols -= 6 # Subtract the widths of prefix "  " separator " => "
+        rows -= 2 # Subtract the summary and final ⋮ continuation lines
+
+        # determine max key width to align the output, caching the strings
+        ks = Array(AbstractString, min(rows, length(t)))
+        keylen = 0
+        for (i, k) in enumerate(keys(t))
+            i > rows && break
+            ks[i] = sprint(0, show, k, env=recur_io)
+            keylen = clamp(length(ks[i]), keylen, div(cols, 3))
         end
+    else
+        rows = cols = 0
+    end
 
-        for (i, (k, v)) in enumerate(t)
-            print(io, "\n  ")
-            limit && i > rows && (print(io, rpad("⋮", keylen), " => ⋮"); break)
+    for (i, (k, v)) in enumerate(t)
+        print(io, "\n  ")
+        limit && i > rows && (print(io, rpad("⋮", keylen), " => ⋮"); break)
 
-            if limit
-                key = rpad(_truncate_at_width_or_chars(ks[i], keylen, "\r\n"), keylen)
-            else
-                key = sprint(show, k)
-            end
-            print(io, key)
-            print(io, " => ")
+        if limit
+            key = rpad(_truncate_at_width_or_chars(ks[i], keylen, "\r\n"), keylen)
+        else
+            key = sprint(0, show, k, env=recur_io)
+        end
+        print(recur_io, key)
+        print(io, " => ")
 
-            if limit
-                val = with_output_limit(()->sprint(show, v))
-                val = _truncate_at_width_or_chars(val, cols - keylen, "\r\n")
-                print(io, val)
-            else
-                show(io, v)
-            end
+        if limit
+            val = sprint(0, show, v, env=recur_io)
+            val = _truncate_at_width_or_chars(val, cols - keylen, "\r\n")
+            print(io, val)
+        else
+            show(recur_io, v)
         end
-    finally
-        delete!(shown_set, t)
     end
 end
 
@@ -145,18 +151,21 @@ summary{T<:Union{KeyIterator,ValueIterator}}(iter::T) =
 
 show(io::IO, iter::Union{KeyIterator,ValueIterator}) = show(io, collect(iter))
 
-showkv(iter::Union{KeyIterator,ValueIterator}; kw...) = showkv(STDOUT, iter; kw...)
-function showkv{T<:Union{KeyIterator,ValueIterator}}(io::IO, iter::T; limit::Bool = false,
-                                                     sz=(s = tty_size(); (s[1]-3, s[2])))
-    rows, cols = sz
+showkv(iter::Union{KeyIterator,ValueIterator}) = showkv(STDOUT, iter)
+function showkv{T<:Union{KeyIterator,ValueIterator}}(io::IO, iter::T)
     print(io, summary(iter))
     isempty(iter) && return
     print(io, ". ", T<:KeyIterator ? "Keys" : "Values", ":")
+    limit::Bool = limit_output(io)
     if limit
+        sz = displaysize(io)
+        rows, cols = sz[1] - 3, sz[2]
         rows < 2 && (print(io, " …"); return)
         cols < 4 && (cols = 4)
         cols -= 2 # For prefix "  "
         rows -= 2 # For summary and final ⋮ continuation lines
+    else
+        rows = cols = 0
     end
 
     for (i, v) in enumerate(iter)
@@ -164,7 +173,7 @@ function showkv{T<:Union{KeyIterator,ValueIterator}}(io::IO, iter::T; limit::Boo
         limit && i >= rows && (print(io, "⋮"); break)
 
         if limit
-            str = with_output_limit(()->sprint(show, v))
+            str = sprint(0, show, v, env=io)
             str = _truncate_at_width_or_chars(str, cols, "\r\n")
             print(io, str)
         else
@@ -216,8 +225,12 @@ function merge!(d::Associative, others::Associative...)
     end
     return d
 end
-keytype{K,V}(::Associative{K,V}) = K
-valtype{K,V}(::Associative{K,V}) = V
+keytype{K,V}(::Type{Associative{K,V}}) = K
+keytype(a::Associative) = keytype(typeof(a))
+keytype{A<:Associative}(::Type{A}) = keytype(supertype(A))
+valtype{K,V}(::Type{Associative{K,V}}) = V
+valtype{A<:Associative}(::Type{A}) = valtype(supertype(A))
+valtype(a::Associative) = valtype(typeof(a))
 function merge(d::Associative, others::Associative...)
     K, V = keytype(d), valtype(d)
     for other in others
@@ -228,24 +241,38 @@ function merge(d::Associative, others::Associative...)
 end
 
 function filter!(f, d::Associative)
+    badkeys = Array(keytype(d), 0)
     for (k,v) in d
-        if !f(k,v)
-            delete!(d,k)
-        end
+        # don't delete!(d, k) here, since associative types
+        # may not support mutation during iteration
+        f(k,v) || push!(badkeys, k)
+    end
+    for k in badkeys
+        delete!(d, k)
     end
     return d
 end
-filter(f, d::Associative) = filter!(f,copy(d))
+function filter(f, d::Associative)
+    # don't just do filter!(f, copy(d)): avoid making a whole copy of d
+    df = similar(d)
+    for (k,v) in d
+        if f(k,v)
+            df[k] = v
+        end
+    end
+    return df
+end
 
 eltype{K,V}(::Type{Associative{K,V}}) = Pair{K,V}
 
 function isequal(l::Associative, r::Associative)
+    l === r && return true
     if isa(l,ObjectIdDict) != isa(r,ObjectIdDict)
         return false
     end
     if length(l) != length(r) return false end
-    for (key, value) in l
-        if !isequal(value, get(r, key, secret_table_token))
+    for pair in l
+        if !in(pair, r, isequal)
             return false
         end
     end
@@ -253,12 +280,13 @@ function isequal(l::Associative, r::Associative)
 end
 
 function ==(l::Associative, r::Associative)
+    l === r && return true
     if isa(l,ObjectIdDict) != isa(r,ObjectIdDict)
         return false
     end
     if length(l) != length(r) return false end
-    for (key, value) in l
-        if value != get(r, key, secret_table_token)
+    for pair in l
+        if !in(pair, r, ==)
             return false
         end
     end
@@ -267,7 +295,7 @@ end
 
 const hasha_seed = UInt === UInt64 ? 0x6d35bb51952d5539 : 0x952d5539
 function hash(a::Associative, h::UInt)
-    h += hasha_seed
+    h = hash(hasha_seed, h)
     for (k,v) in a
         h $= hash(k, hash(v))
     end
@@ -495,15 +523,21 @@ function rehash!{K,V}(h::Dict{K,V}, newsz = length(h.keys))
     vals = Array(V, newsz)
     count0 = h.count
     count = 0
+    maxprobe = max(16, newsz>>6)
 
     for i = 1:sz
         if olds[i] == 0x1
             k = oldk[i]
             v = oldv[i]
-            index = hashindex(k, newsz)
+            index0 = index = hashindex(k, newsz)
             while slots[index] != 0
                 index = (index & (newsz-1)) + 1
             end
+            if index - index0 > maxprobe
+                # rare condition: new table size causes more grouping of keys than before
+                # see issue #15077
+                return rehash!(h, newsz*2)
+            end
             slots[index] = 0x1
             keys[index] = k
             vals[index] = v
@@ -850,3 +884,99 @@ function next{K,V}(t::WeakKeyDict{K,V}, i)
     (Pair{K,V}(kv[1].value::K,kv[2]), i)
 end
 length(t::WeakKeyDict) = length(t.ht)
+
+# For these Associative types, it is safe to implement filter!
+# by deleting keys during iteration.
+function filter!(f, d::Union{ObjectIdDict,Dict,WeakKeyDict})
+     for (k,v) in d
+        if !f(k,v)
+            delete!(d,k)
+        end
+     end
+     return d
+ end
+
+immutable ImmutableDict{K, V} <: Associative{K,V}
+    parent::ImmutableDict{K, V}
+    key::K
+    value::V
+    ImmutableDict() = new() # represents an empty dictionary
+    ImmutableDict(key, value) = (empty = new(); new(empty, key, value))
+    ImmutableDict(parent::ImmutableDict, key, value) = new(parent, key, value)
+end
+
+"""
+    ImmutableDict
+
+ImmutableDict is a Dictionary implemented as an immutable linked list,
+which is optimal for small dictionaries that are constructed over many individual insertions
+Note that it is not possible to remove a value, although it can be partially overridden and hidden
+by inserting a new value with the same key
+
+    ImmutableDict(KV::Pair)
+
+Create a new entry in the Immutable Dictionary for the key => value pair
+
+ - use `(key => value) in dict` to see if this particular combination is in the properties set
+ - use `get(dict, key, default)` to retrieve the most recent value for a particular key
+
+"""
+ImmutableDict
+ImmutableDict{K,V}(KV::Pair{K,V}) = ImmutableDict{K,V}(KV[1], KV[2])
+ImmutableDict{K,V}(t::ImmutableDict{K,V}, KV::Pair) = ImmutableDict{K,V}(t, KV[1], KV[2])
+
+function in(key_value::Pair, dict::ImmutableDict, valcmp=(==))
+    key, value = key_value
+    while isdefined(dict, :parent)
+        if dict.key == key
+            if valcmp === is
+                is(value, dict.value) && return true
+            elseif valcmp === (==)
+                ==(value, dict.value) && return true
+            elseif valcmp === isequal
+                isequal(value, dict.value) && return true
+            else
+                valcmp(value, dict.value) && return true
+            end
+        end
+        dict = dict.parent
+    end
+    return false
+end
+
+function haskey(dict::ImmutableDict, key)
+    while isdefined(dict, :parent)
+        dict.key == key && return true
+        dict = dict.parent
+    end
+    return false
+end
+
+function getindex(dict::ImmutableDict, key)
+    while isdefined(dict, :parent)
+        dict.key == key && return dict.value
+        dict = dict.parent
+    end
+    throw(KeyError(key))
+end
+function get(dict::ImmutableDict, key, default)
+    while isdefined(dict, :parent)
+        dict.key == key && return dict.value
+        dict = dict.parent
+    end
+    return default
+end
+
+# this actually defines reverse iteration (e.g. it should not be used for merge/copy/filter type operations)
+start(t::ImmutableDict) = t
+next{K,V}(::ImmutableDict{K,V}, t) = (Pair{K,V}(t.key, t.value), t.parent)
+done(::ImmutableDict, t) = !isdefined(t, :parent)
+length(t::ImmutableDict) = count(x->1, t)
+isempty(t::ImmutableDict) = done(t, start(t))
+copy(t::ImmutableDict) = t
+function similar(t::ImmutableDict)
+    while isdefined(t, :parent)
+        t = t.parent
+    end
+    return t
+end
diff --git a/base/docs/Docs.jl b/base/docs/Docs.jl
index ce82dc069bc92..f8cc290872098 100644
--- a/base/docs/Docs.jl
+++ b/base/docs/Docs.jl
@@ -57,126 +57,28 @@ function.
 include("bindings.jl")
 
 import Base.Markdown: @doc_str, MD
-import Base.Meta: quot
+import Base.Meta: quot, isexpr
+import Base: Callable
 
 export doc
 
 # Basic API / Storage
 
 const modules = Module[]
+const META    = gensym(:meta)
 
-const META′ = :__META__
+meta(m::Module = current_module()) = isdefined(m, META) ? getfield(m, META) : ObjectIdDict()
 
-meta(mod) = mod.(META′)
-
-meta() = meta(current_module())
-
-macro init()
-    META = esc(META′)
-    quote
-        if !isdefined($(Expr(:quote, META′)))
-            const $META = ObjectIdDict()
-            doc!($META, @doc_str $("Documentation metadata for `$(current_module())`."))
-            push!(modules, current_module())
-            nothing
-        end
-    end
-end
-
-"`doc!(obj, data)`: Associate the metadata `data` with `obj`."
-function doc!(obj, data)
-    meta()[obj] = data
-end
-
-"`doc(obj)`: Get the metadata associated with `obj`."
-function doc(obj)
-    for mod in modules
-        haskey(meta(mod), obj) && return meta(mod)[obj]
+function initmeta(m::Module = current_module())
+    if !isdefined(m, META)
+        eval(m, :(const $META = $(ObjectIdDict())))
+        push!(modules, m)
     end
+    nothing
 end
 
-function write_lambda_signature(io::IO, lam::LambdaStaticData)
-    ex = Base.uncompressed_ast(lam)
-    write(io, '(')
-    nargs = length(ex.args[1])
-    for (i,arg) in enumerate(ex.args[1])
-        argname, argtype = arg.args
-        if argtype === :Any || argtype === :ANY
-            write(io, argname)
-        elseif isa(argtype,Expr) && argtype.head === :... &&
-               (argtype.args[end] === :Any || argtype.args[end] === :ANY)
-            write(io, argname, "...")
-        else
-            write(io, argname, "::", argtype)
-        end
-        i < nargs && write(io, ',')
-    end
-    write(io, ')')
-    return io
-end
-
-function macrosummary(name::Symbol, func::Function)
-    if !isdefined(func,:code) || func.code == nothing
-        return Markdown.parse("\n")
-    end
-    io  = IOBuffer()
-    write(io, "```julia\n")
-    write(io, name)
-    write_lambda_signature(io, func.code)
-    write(io, "\n```")
-    return Markdown.parse(takebuf_string(io))
-end
-
-function functionsummary(func::Function)
-    io  = IOBuffer()
-    write(io, "```julia\n")
-    if isgeneric(func)
-        print(io, methods(func))
-    else
-        if isdefined(func,:code) && func.code !== nothing
-            write_lambda_signature(io, func.code)
-            write(io, " -> ...")
-        end
-    end
-    write(io, "\n```")
-    return Markdown.parse(takebuf_string(io))
-end
-
-function doc(b::Binding)
-    d = invoke(doc, Tuple{Any}, b)
-    if d === nothing
-        v = getfield(b.mod,b.var)
-        d = doc(v)
-        if d === nothing
-            if startswith(string(b.var),'@')
-                # check to see if the binding var is a macro
-                d = catdoc(Markdown.parse("""
-                No documentation found.
-
-                """), macrosummary(b.var, v))
-            elseif isa(v,Function)
-                d = catdoc(Markdown.parse("""
-                No documentation found.
-
-                `$(b.mod === Main ? b.var : join((b.mod, b.var),'.'))` is $(isgeneric(v) ? "a generic" : "an anonymous") `Function`.
-                """), functionsummary(v))
-            else
-                T = typeof(v)
-                d = catdoc(Markdown.parse("""
-                No documentation found.
-
-                `$(b.mod === Main ? b.var : join((b.mod, b.var),'.'))` is of type `$T`:
-                """), typesummary(typeof(v)))
-            end
-        end
-    end
-    return d
-end
-
-# Function / Method support
-
 function signature(expr::Expr)
-    if isexpr(expr, :call)
+    if isexpr(expr, [:call, :macrocall])
         sig = :(Union{Tuple{}})
         for arg in expr.args[2:end]
             isexpr(arg, :parameters) && continue
@@ -190,6 +92,7 @@ function signature(expr::Expr)
         signature(expr.args[1])
     end
 end
+signature(other) = :(Union{})
 
 function argtype(expr::Expr)
     isexpr(expr, :(::))  && return expr.args[end]
@@ -207,212 +110,250 @@ typevars(::Symbol) = []
 tvar(x::Expr)   = :($(x.args[1]) = TypeVar($(quot(x.args[1])), $(x.args[2]), true))
 tvar(s::Symbol) = :($(s) = TypeVar($(quot(s)), Any, true))
 
-type FuncDoc
-    main
-    order::Vector{Type}
-    meta::ObjectIdDict
-    source::ObjectIdDict
-end
+# Docsystem types.
+# ================
 
-FuncDoc() = FuncDoc(nothing, [], ObjectIdDict(), ObjectIdDict())
-
-# handles the :(function foo end) form
-function doc!(f::Function, data)
-    doc!(f, Union{}, data, nothing)
-end
+"""
+    Docs.DocStr
 
-type_morespecific(a::Type, b::Type) =
-    (ccall(:jl_type_morespecific, Int32, (Any,Any), a, b) > 0)
-
-# handles the :(function foo(x...); ...; end) form
-function doc!(f::Function, sig::ANY, data, source)
-    fd = get!(meta(), f, FuncDoc())
-    isa(fd, FuncDoc) || error("can not document a method when the function already has metadata")
-    haskey(fd.meta, sig) || push!(fd.order, sig)
-    sort!(fd.order, lt=type_morespecific)
-    fd.meta[sig] = data
-    fd.source[sig] = source
-end
+Stores the contents of a single docstring as well as related metadata.
 
-doc(f::Function) = doc(f, Tuple)
+Both the raw text, `.text`, and the parsed markdown, `.object`, are tracked by this type.
+Parsing of the raw text is done lazily when a request is made to render the docstring,
+which helps to reduce total precompiled image size.
 
-function doc(f::Function, sig::Type)
-    isgeneric(f) && isempty(methods(f,sig)) && return nothing
-    results, funcdocs = [], []
-    for mod in modules
-        if (haskey(meta(mod), f) && isa(meta(mod)[f], FuncDoc))
-            fd = meta(mod)[f]
-            push!(funcdocs, fd)
-            for msig in fd.order
-                # try to find specific matching method signatures
-                if sig <: msig
-                    push!(results, (msig, fd.meta[msig]))
-                end
-            end
-        end
-    end
-    # if all method signatures are Union{} ( ⊥ ), concat all docstrings
-    if isempty(results)
-        for fd in funcdocs
-            append!(results, [fd.meta[msig] for msig in reverse(fd.order)])
-        end
-    else
-        sort!(results, lt = (a, b) -> type_morespecific(first(a), first(b)))
-        results = [last(r) for r in results]
+The `.data` fields stores several values related to the docstring, such as: path,
+linenumber, source code, and fielddocs.
+"""
+type DocStr
+    text   :: UTF8String
+    object :: Nullable{Markdown.MD}
+    data   :: Dict{Symbol, Any}
+
+    DocStr(text::AbstractString, data = Dict()) = new(text, Nullable(), data)
+    DocStr(object, data = Dict())               = new("", Nullable(object), data)
+end
+docexpr(args...) = Expr(:call, DocStr, args...)
+
+function parsedoc(d::DocStr)
+    if isnull(d.object)
+        md = Markdown.parse(d.text)
+        md.meta[:module] = d.data[:module]
+        md.meta[:path]   = d.data[:path]
+        d.object = Nullable(md)
     end
-    catdoc(results...)
+    get(d.object)
 end
-doc(f::Function,args::Any...) = doc(f, Tuple{args...})
 
-
-"""
-`catdoc(xs...)`: Combine the documentation metadata `xs` into a single meta object.
 """
-catdoc() = nothing
-catdoc(xs...) = vcat(xs...)
+    MultiDoc
 
-# Type Documentation
+Stores a collection of docstrings for related objects, ie. a `Function`/`DataType` and
+associated `Method` objects.
 
-isdoc(x) = isexpr(x, :string, AbstractString) ||
-    (isexpr(x, :macrocall) && x.args[1] == symbol("@doc_str")) ||
-    (isexpr(x, :call) && x.args[1] == Expr(:., Base.Markdown, QuoteNode(:doc_str)))
+Each documented object in a `MultiDoc` is referred to by it's signature which is represented
+by a `Union` of `Tuple` types. For example the following `Method` definition
 
-dict_expr(d) = :(Dict($([:(Pair($(Expr(:quote, f)), $d)) for (f, d) in d]...)))
-
-function field_meta(def)
-    meta = Dict()
-    doc = nothing
-    for l in def.args[3].args
-        if isdoc(l)
-            doc = mdify(l)
-        elseif doc !== nothing && isexpr(l, Symbol, :(::))
-            meta[namify(l)] = doc
-            doc = nothing
-        end
-    end
-    return dict_expr(meta)
-end
+    f(x, y) = ...
+
+is stored as `Tuple{Any, Any}` in the `MultiDoc` while
+
+    f{T}(x::T, y = ?) = ...
+
+is stored as `Union{Tuple{T}, Tuple{T, Any}}`.
 
-type TypeDoc
-    main
-    fields::Dict{Symbol, Any}
+Note: The `Function`/`DataType` object's signature is always `Union{}`.
+"""
+type MultiDoc
+    "Ordered (via definition order) vector of object signatures."
     order::Vector{Type}
-    meta::ObjectIdDict
+    "Documentation for each object. Keys are signatures."
+    docs::ObjectIdDict
+
+    MultiDoc() = new(Type[], ObjectIdDict())
 end
 
-TypeDoc() = TypeDoc(nothing, Dict(), [], ObjectIdDict())
+# Docstring registration.
+# =======================
 
-function doc!(t::DataType, data, fields)
-    td = get!(meta(), t, TypeDoc())
-    td.main = data
-    td.fields = fields
-end
+"""
+    Docs.doc!(binding, str, sig)
 
-function doc!(T::DataType, sig::ANY, data, source)
-    td = get!(meta(), T, TypeDoc())
-    if !isa(td, TypeDoc)
-        error("can not document a method when the type already has metadata")
+Adds a new docstring `str` to the docsystem for `binding` and signature `sig`.
+"""
+function doc!(b::Binding, str::DocStr, sig::ANY = Union{})
+    m = get!(meta(), b, MultiDoc())
+    if haskey(m.docs, sig)
+        # We allow for docstrings to be updated, but print a warning since it is possible
+        # that over-writing a docstring *may* have been accidental.
+        warn("replacing docs for '$b :: $sig'.")
+    else
+        # The ordering of docstrings for each Binding is defined by the order in which they
+        # are initially added. Replacing a specific docstring does not change it's ordering.
+        push!(m.order, sig)
     end
-    !haskey(td.meta, sig) && push!(td.order, sig)
-    td.meta[sig] = data
+    m.docs[sig] = str
+    return b
 end
 
-function doc(T::DataType)
-    docs = []
+# Docstring lookup.
+# =================
+
+"""
+    Docs.doc(binding, sig)
+
+Returns all documentation that matches both `binding` and `sig`.
+"""
+function doc(binding::Binding, sig::Type = Union)
+    results, groups = DocStr[], MultiDoc[]
+    # Lookup `binding` and `sig` for matches in all modules of the docsystem.
     for mod in modules
-        if haskey(meta(mod), T)
-            Td = meta(mod)[T]
-            if isa(Td, TypeDoc)
-                if length(docs) == 0 && Td.main !== nothing
-                    push!(docs, Td.main)
-                end
-                for m in Td.order
-                    push!(docs, Td.meta[m])
-                end
-            elseif length(docs) == 0
-                return Td
+        dict = meta(mod)
+        if haskey(dict, binding)
+            multidoc = dict[binding]
+            push!(groups, multidoc)
+            for msig in multidoc.order
+                sig <: msig && push!(results, multidoc.docs[msig])
             end
         end
     end
-    if isempty(docs)
-        catdoc(Markdown.parse("""
-        No documentation found.
-
-        """), typesummary(T))
+    if isempty(groups)
+        # When no `MultiDoc`s are found that match `binding` then we check whether `binding`
+        # is an alias of some other `Binding`. When it is we then re-run `doc` with that
+        # `Binding`, otherwise if it's not an alias then we generate a summary for the
+        # `binding` and display that to the user instead.
+        alias = aliasof(binding)
+        alias == binding ? summarize(alias, sig) : doc(alias, sig)
     else
-        catdoc(docs...)
+        # There was at least one match for `binding` while searching. If there weren't any
+        # matches for `sig` then we concatenate *all* the docs from the matching `Binding`s.
+        if isempty(results)
+            for group in groups, each in group.order
+                push!(results, group.docs[each])
+            end
+        end
+        # Get parsed docs and concatenate them.
+        md = Markdown.MD(map(parsedoc, results))
+        # Save metadata in the generated markdown.
+        md.meta[:results] = results
+        md.meta[:binding] = binding
+        md.meta[:typesig] = sig
+        return md
     end
 end
 
-function typesummary(T::DataType)
-    parts = [
-    """
-    **Summary:**
-    ```julia
-    $(T.abstract ? "abstract" : T.mutable ? "type" : "immutable") $T <: $(super(T))
-    ```
-    """
-    ]
-    if !isempty(fieldnames(T))
-        pad    = maximum([length(string(f)) for f in fieldnames(T)])
-        fields = ["$(rpad(f, pad)) :: $(t)" for (f,t) in zip(fieldnames(T), T.types)]
-        push!(parts,
-        """
-        **Fields:**
-        ```julia
-        $(join(fields, "\n"))
-        ```
-        """)
-    end
-    if !isempty(subtypes(T))
-        push!(parts,
-        """
-        **Subtypes:**
-        ```julia
-        $(join(subtypes(T),'\n'))
-        ```
-        """)
-    end
-    Markdown.parse(join(parts,'\n'))
-end
+# Some additional convenience `doc` methods that take objects rather than `Binding`s.
+doc(object, sig::Type = Union) = doc(aliasof(object, typeof(object)), sig)
+doc(object, sig...)            = doc(object, Tuple{sig...})
 
-isfield(x) = isexpr(x, :.) &&
-  (isexpr(x.args[1], Symbol) || isfield(x.args[1])) &&
-  isexpr(x.args[2], QuoteNode, :quote)
+"""
+    Docs.fielddoc(binding, field)
 
-function fielddoc(T, k)
+Returns documentation for a particular `field` of a type if it exists.
+"""
+function fielddoc(binding::Binding, field::Symbol)
     for mod in modules
-        if haskey(meta(mod), T) && isa(meta(mod)[T], TypeDoc) && haskey(meta(mod)[T].fields, k)
-            return meta(mod)[T].fields[k]
+        dict = meta(mod)
+        if haskey(dict, binding)
+            multidoc = dict[binding]
+            if haskey(multidoc.docs, Union{})
+                fields = multidoc.docs[Union{}].data[:fields]
+                haskey(fields, field) && return Markdown.parse(fields[field])
+            end
         end
-  end
-  Text(sprint(io -> (print(io, "$T has fields: ");
-                     print_joined(io, fieldnames(T), ", ", " and "))))
+    end
+    fields = join(["`$f`" for f in fieldnames(resolve(binding))], ", ", ", and ")
+    fields = isempty(fields) ? "no fields" : "fields $fields"
+    Markdown.parse("`$(resolve(binding))` has $fields.")
 end
 
-# Generic Callables
+# As with the additional `doc` methods, this converts an object to a `Binding` first.
+fielddoc(object, field::Symbol) = fielddoc(aliasof(object, typeof(object)), field)
 
-# Modules
+# Object Summaries.
+# =================
+
+function summarize(binding::Binding, sig)
+    io = IOBuffer()
+    println(io, "No documentation found.\n")
+    if defined(binding)
+        summarize(io, resolve(binding), binding)
+    else
+        println(io, "Binding `", binding, "` does not exist.")
+    end
+    md = Markdown.parse(seekstart(io))
+    # Save metadata in the generated markdown.
+    md.meta[:results] = DocStr[]
+    md.meta[:binding] = binding
+    md.meta[:typesig] = sig
+    return md
+end
+
+function summarize(io::IO, λ::Function, binding)
+    kind = startswith(string(binding.var), '@') ? "macro" : "`Function`"
+    println(io, "`", binding, "` is a ", kind, ".")
+    println(io, "```\n", methods(λ), "\n```")
+end
+
+function summarize(io::IO, T::DataType, binding)
+    println(io, "**Summary:**")
+    println(io, "```")
+    println(io,
+        T.abstract ? "abstract" : T.mutable ? "type" : "immutable",
+        " ", T, " <: ", supertype(T)
+    )
+    println(io, "```")
+    if !isempty(fieldnames(T))
+        println(io, "**Fields:**")
+        println(io, "```")
+        pad = maximum(length(string(f)) for f in fieldnames(T))
+        for (f, t) in zip(fieldnames(T), T.types)
+            println(io, rpad(f, pad), " :: ", t)
+        end
+        println(io, "```")
+    end
+    if !isempty(subtypes(T))
+        println(io, "**Subtypes:**")
+        println(io, "```")
+        for t in subtypes(T)
+            println(io, t)
+        end
+        println(io, "```")
+    end
+end
 
-function doc(m::Module)
-    md = invoke(doc, Tuple{Any}, m)
-    md === nothing || return md
+function summarize(io::IO, m::Module, binding)
     readme = Pkg.dir(string(m), "README.md")
     if isfile(readme)
-        return Markdown.parse_file(readme)
+        println(io, "Displaying the `README.md` for the module instead.\n")
+        println(io, "---\n")
+        println(io, readstring(readme))
+    else
+        println(io, "No `README.md` found for module `", m, "`.\n")
     end
 end
 
-# Keywords
+function summarize{T}(io::IO, ::T, binding)
+    println(io, "`", binding, "` is of type `", T, "`.\n")
+    summarize(io, T, binding)
+end
+
+# Utilities.
+# ==========
 
-const keywords = Dict{Symbol,Any}()
+"""
+`catdoc(xs...)`: Combine the documentation metadata `xs` into a single meta object.
+"""
+catdoc() = nothing
+catdoc(xs...) = vcat(xs...)
 
-# Usage macros
+const keywords = Dict{Symbol, DocStr}()
 
-isexpr(x::Expr) = true
-isexpr(x) = false
-isexpr(x::Expr, ts...) = x.head in ts
-isexpr(x, ts...) = any(T->isa(T, Type) && isa(x, T), ts)
+isdoc(s::AbstractString) = true
+
+isdoc(x) = isexpr(x, :string) ||
+    (isexpr(x, :macrocall) && x.args[1] == symbol("@doc_str")) ||
+    (isexpr(x, :call) && x.args[1] == Expr(:., Base.Markdown, QuoteNode(:doc_str)))
 
 function unblock(ex)
     isexpr(ex, :block) || return ex
@@ -423,47 +364,80 @@ end
 
 uncurly(ex) = isexpr(ex, :curly) ? ex.args[1] : ex
 
-namify(ex::Expr) = isexpr(ex, :.) ? ex : namify(ex.args[1])
-namify(ex::QuoteNode) = ex.value
-namify(sy::Symbol) = sy
+namify(x) = nameof(x, isexpr(x, :macro))
 
-function mdify(ex)
-    if isexpr(ex, AbstractString, :string)
-        :(Markdown.doc_str($(esc(ex)), @__FILE__, current_module()))
+function nameof(x::Expr, ismacro)
+    if isexpr(x, :.)
+        ismacro ? macroname(x) : x
     else
-        esc(ex)
+        n = isexpr(x, [:module, :type, :bitstype]) ? 2 : 1
+        nameof(x.args[n], ismacro)
     end
 end
+nameof(q::QuoteNode, ismacro) = nameof(q.value, ismacro)
+nameof(s::Symbol, ismacro)    = ismacro ? macroname(s) : s
+nameof(other, ismacro)        = other
 
-function namedoc(meta, def, name)
-    quote
-        @init
-        $(esc(def))
-        doc!($(esc(name)), $(mdify(meta)))
-        nothing
-    end
-end
+macroname(s::Symbol) = symbol('@', s)
+macroname(x::Expr)   = Expr(x.head, x.args[1], macroname(x.args[end].value))
 
-function funcdoc(meta, def, def′)
-    f = esc(namify(def′))
-    quote
-        @init
-        $(esc(def))
-        doc!($f, $(esc(signature(def′))), $(mdify(meta)), $(esc(quot(def′))))
-        $f
+isfield(x) = isexpr(x, :.) &&
+    (isa(x.args[1], Symbol) || isfield(x.args[1])) &&
+    (isa(x.args[2], QuoteNode) || isexpr(x.args[2], :quote))
+
+# @doc expression builders.
+# =========================
+
+"""
+    Docs.metadata(expr)
+
+Build a `Dict` expression containing metadata captured from the expression `expr`.
+
+Fields that may be included in the returned `Dict`:
+
+- `:source`:     Source code for the given `expr`.
+- `:path`:       String representing the file where `expr` is defined.
+- `:linenumber`: Linenumber where `expr` is defined.
+- `:module`:     Module where the docstring is defined.
+- `:fields`:     `Dict` of all field docs found in `expr`. Only for concrete types.
+"""
+function metadata(expr)
+    args = []
+    # Source code for the object being documented.
+    push!(args, :($(Pair)(:source, $(quot(expr)))))
+    # Filename and linenumber of the docstring.
+    push!(args, :($(Pair)(:path, $(Base).@__FILE__)), :($(Pair)(:linenumber, @__LINE__)))
+    # Module in which the docstring is defined.
+    push!(args, :($(Pair)(:module, $(current_module)())))
+    # Field docs for concrete types.
+    if isexpr(expr, :type)
+        fields = []
+        tmp = nothing
+        for each in expr.args[3].args
+            if isdoc(each)
+                tmp = each
+            elseif tmp !== nothing && (isa(each, Symbol) || isexpr(each, :(::)))
+                push!(fields, (namify(each), tmp))
+                tmp = nothing
+            end
+        end
+        dict = :($(Dict)($([:($(Pair)($(quot(f)), $d)) for (f, d) in fields]...)))
+        push!(args, :($(Pair)(:fields, $dict)))
     end
+    :($(Dict)($(args...)))
 end
 
-function typedoc(meta, def, def′)
+function objectdoc(str, def, expr, sig = :(Union{}))
+    binding = esc(bindingexpr(namify(expr)))
+    docstr  = esc(docexpr(str, metadata(expr)))
     quote
-        @init
         $(esc(def))
-        doc!($(esc(namify(def′.args[2]))), $(mdify(meta)), $(field_meta(unblock(def′))))
-        nothing
+        $(doc!)($binding, $docstr, $(esc(sig)))
     end
 end
 
-function moddoc(meta, def, name)
+function moduledoc(meta, def, def′)
+    name  = namify(def′)
     docex = :(@doc $meta $name)
     if def == nothing
         esc(:(eval($name, $(quot(docex)))))
@@ -472,71 +446,177 @@ function moddoc(meta, def, name)
         block = def.args[3].args
         if !def.args[1]
             isempty(block) && error("empty baremodules are not documentable.")
-            insert!(block, 2, :(import Base: call, @doc))
+            insert!(block, 2, :(import Base: @doc))
         end
         push!(block, docex)
         esc(Expr(:toplevel, def))
     end
 end
 
-function objdoc(meta, def)
-    quote
-        @init
-        doc!($(esc(def)), $(mdify(meta)))
-    end
-end
-
-function vardoc(meta, def, name)
-    quote
-        @init
-        $(esc(def))
-        doc!(@var($(esc(name))), $(mdify(meta)))
-    end
+function multidoc(meta, ex, define)
+    out = Expr(:toplevel)
+    out.args = [:(@doc($meta, $obj, $define)) for obj in ex.args]
+    esc(out)
 end
 
-multidoc(meta, objs) = quote $([:(@doc $(esc(meta)) $(esc(obj))) for obj in objs]...) end
-
-fexpr(ex) = isexpr(ex, :function, :stagedfunction, :(=)) && isexpr(ex.args[1], :call)
-
-function docm(meta, def, define = true)
-    def′ = unblock(def)
-
-    isexpr(def′, :quote) && isexpr(def′.args[1], :macrocall) &&
-        return vardoc(meta, nothing, namify(def′.args[1]))
+"""
+    @__doc__(ex)
 
-    def = macroexpand(def)
-    def′ = unblock(def)
+Low-level macro used to mark expressions returned by a macro that should be documented. If
+more than one expression is marked then the same docstring is applied to each expression.
 
-    define || (def = nothing)
+    macro example(f)
+        quote
+            \$(f)() = 0
+            @__doc__ \$(f)(x) = 1
+            \$(f)(x, y) = 2
+        end |> esc
+    end
 
-    fexpr(def′)                ? funcdoc(meta, def, def′) :
-    isexpr(def′, :function)    ? namedoc(meta, def, namify(def′)) :
-    isexpr(def′, :call)        ? funcdoc(meta, nothing, def′) :
-    isexpr(def′, :type)        ? typedoc(meta, def, def′) :
-    isexpr(def′, :macro)       ?  vardoc(meta, def, symbol('@',namify(def′))) :
-    isexpr(def′, :abstract)    ? namedoc(meta, def, namify(def′)) :
-    isexpr(def′, :bitstype)    ? namedoc(meta, def, namify(def′.args[2])) :
-    isexpr(def′, :typealias)   ?  vardoc(meta, def, namify(def′)) :
-    isexpr(def′, :module)      ?  moddoc(meta, def, def′.args[2]) :
-    isexpr(def′, :(=), :const,
-                 :global)      ?  vardoc(meta, def, namify(def′)) :
-    isvar(def′)                ? objdoc(meta, def′) :
-    isexpr(def′, :tuple)       ? multidoc(meta, def′.args) :
-    isa(def′, Expr)            ? error("invalid doc expression $def′") :
-    objdoc(meta, def′)
+`@__doc__` has no effect when a macro that uses it is not documented.
+"""
+:(Base.@__doc__)
+
+function __doc__!(meta, def, define)
+    # Two cases must be handled here to avoid redefining all definitions contained in `def`:
+    if define
+        # `def` has not been defined yet (this is the common case, i.e. when not generating
+        # the Base image). We just need to convert each `@__doc__` marker to an `@doc`.
+        finddoc(def) do each
+            each.head = :macrocall
+            each.args = [symbol("@doc"), meta, each.args[end], define]
+        end
+    else
+        # `def` has already been defined during Base image gen so we just need to find and
+        # document any subexpressions marked with `@__doc__`.
+        docs  = []
+        found = finddoc(def) do each
+            push!(docs, :(@doc($meta, $(each.args[end]), $define)))
+        end
+        # If any subexpressions have been documented then replace the entire expression with
+        # just those documented subexpressions to avoid redefining any definitions.
+        if found
+            def.head = :toplevel
+            def.args = docs
+        end
+        found
+    end
 end
-
-function docm(ex)
-    isexpr(ex, :->)                        ? docm(ex.args...) :
-    isa(ex,Symbol) && haskey(keywords, ex) ? keywords[ex] :
-    isexpr(ex, :call)                      ? findmethod(ex) :
-    isvar(ex)                              ? :(doc(@var($(esc(ex))))) :
-    :(doc($(esc(ex))))
+# Walk expression tree `def` and call `λ` when any `@__doc__` markers are found. Returns
+# `true` to signify that at least one `@__doc__` has been found, and `false` otherwise.
+function finddoc(λ, def::Expr)
+    if isexpr(def, :block, 2) && isexpr(def.args[1], :meta, 1) && def.args[1].args[1] === :doc
+        # Found the macroexpansion of an `@__doc__` expression.
+        λ(def)
+        true
+    else
+        found = false
+        for each in def.args
+            found |= finddoc(λ, each)
+        end
+        found
+    end
+end
+finddoc(λ, def) = false
+
+# Predicates and helpers for `docm` expression selection:
+
+const FUNC_HEADS    = [:function, :stagedfunction, :macro, :(=)]
+const BINDING_HEADS = [:typealias, :const, :global, :(=)]
+# For the special `:@mac` / `:(Base.@mac)` syntax for documenting a macro after defintion.
+isquotedmacrocall(x) =
+    isexpr(x, :copyast, 1) &&
+    isa(x.args[1], QuoteNode) &&
+    isexpr(x.args[1].value, :macrocall, 1)
+# Simple expressions / atoms the may be documented.
+isbasicdoc(x) = isexpr(x, :.) || isa(x, Union{QuoteNode, Symbol})
+
+function docm(meta, ex, define = true)
+    # Some documented expressions may be decorated with macro calls which obscure the actual
+    # expression. Expand the macro calls and remove extra blocks.
+    x = unblock(macroexpand(ex))
+    # Don't try to redefine expressions. This is only needed for `Base` img gen since
+    # otherwise calling `loaddocs` would redefine all documented functions and types.
+    def = define ? x : nothing
+
+    # Initalise the module's docstring storage.
+    initmeta()
+
+    # Method / macro definitions and "call" syntax.
+    #
+    #   function f(...) ... end
+    #   f(...) = ...
+    #   macro m(...) end
+    #   function f end
+    #   f(...)
+    #
+    isexpr(x, FUNC_HEADS) &&  isexpr(x.args[1], :call) ? objectdoc(meta, def, x, signature(x)) :
+    isexpr(x, :function)  && !isexpr(x.args[1], :call) ? objectdoc(meta, def, x) :
+    isexpr(x, :call)                                   ? objectdoc(meta, nothing, x, signature(x)) :
+
+    # Type definitions.
+    #
+    #   type T ... end
+    #   abstract T
+    #   bitstype N T
+    #
+    isexpr(x, [:type, :abstract, :bitstype]) ? objectdoc(meta, def, x) :
+
+    # "Bindings". Names that resolve to objects with different names, ie.
+    #
+    #   typealias T S
+    #   const T = S
+    #   T = S
+    #   global T = S
+    #
+    isexpr(x, BINDING_HEADS) && !isexpr(x.args[1], :call) ? objectdoc(meta, def, x) :
+
+    # Quoted macrocall syntax. `:@time` / `:(Base.@time)`.
+    isquotedmacrocall(x) ? objectdoc(meta, def, x) :
+    # Modules and baremodules.
+    isexpr(x, :module) ? moduledoc(meta, def, x) :
+    # Document several expressions with the same docstring. `a, b, c`.
+    isexpr(x, :tuple) ? multidoc(meta, x, define) :
+    # Errors generated by calling `macroexpand` are passed back to the call site.
+    isexpr(x, :error) ? esc(x) :
+    # When documenting macro-generated code we look for embedded `@__doc__` calls.
+    __doc__!(meta, x, define) ? esc(x) :
+    # Any "basic" expression such as a bare function or module name or numeric literal.
+    isbasicdoc(x) ? objectdoc(meta, nothing, x) :
+
+    # All other expressions are undocumentable and should be handled on a case-by-case basis
+    # with `@__doc__`. Unbound string literals are also undocumentable since they cannot be
+    # retrieved from the module's metadata `ObjectIdDict` without a reference to the string.
+    docerror(ex)
+end
+
+function docerror(ex)
+    txt = """
+    invalid doc expression:
+
+    @doc "..." $(isa(ex, AbstractString) ? repr(ex) : ex)"""
+    if isexpr(ex, :macrocall)
+        txt *= "\n\n'$(ex.args[1])' not documentable. See 'Base.@__doc__' docs for details."
+    end
+    :(error($txt, "\n"))
 end
 
-function findmethod(ex)
-    f = esc(namify(ex.args[1]))
-    :(doc($f, $(esc(signature(ex)))))
+function docm(ex)
+    if isexpr(ex, :->)
+        docm(ex.args...)
+    elseif haskey(keywords, ex)
+        parsedoc(keywords[ex])
+    elseif isa(ex, Union{Expr, Symbol})
+        binding = esc(bindingexpr(namify(ex)))
+        if isexpr(ex, [:call, :macrocall])
+            sig = esc(signature(ex))
+            :($(doc)($binding, $sig))
+        else
+            :($(doc)($binding))
+        end
+    else
+        :($(doc)($(typeof)($(esc(ex)))))
+    end
 end
 
 # Swap out the bootstrap macro with the real one
@@ -545,7 +625,7 @@ Base.DocBootstrap.setexpand!(docm)
 
 # Names are resolved relative to the Base module, so inject the ones we need there.
 
-eval(Base, :(import .Docs: @init, @var, doc!, doc, @doc_str))
+eval(Base, :(import .Docs: @doc_str))
 
 Base.DocBootstrap.loaddocs()
 
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 15916b020c09c..27905ac068f24 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -2,484 +2,739 @@
 
 import .Docs: keywords
 
-keywords[:hello] = keywords[:hi] = doc"Hello, Human."
-
-const intro = doc"""
-  **Welcome to Julia $(string(VERSION)).** The full manual is available at
-
-      http://docs.julialang.org/
-
-  as well many great tutorials and learning resources:
-
-      http://julialang.org/learning/
-
-  For help on a specific function or macro, type `?` followed
-  by its name, e.g. `?fft`, `?@time` or `?html`, and press
-  enter.
-  """
-
-keywords[:help] = keywords[:?] = keywords[:julia] = intro
-
-keywords[:using] = doc"""
-  `using` will load the given module or package and make some of its names
-  available for use (see also `export`). For example:
-
-      using Gadfly
-
-  loads the plotting package, Gadfly, so that the `plot` function can be used.
-
-  Names can be used via dot syntax, whether they are exported or not:
-
-      Gadfly.plot(...)
-
-  If you don't want to use the packages exports directly, see also `import`.
-  If you're not sure, `using` is almost definitely what you want.
-  """
-
-keywords[:import] = doc"""
-      import Gadfly
-
-  `import`, like `using`, will load modules and packages for use. Unlike
-  `using`, however, it will *not* make any `export`ed names available for use.
-  To use Gadfly's `plot` function after importing it, for example, you have
-  to write:
-
-      Gadfly.plot(...)
-
-  Import can also be used with specific names, for example
-
-      import Gadfly: plot, render
-
-  This syntax is used when you want to extend the modules functions with
-  new methods.
-  """
-
-keywords[:export] = doc"""
-  `export` is used within modules and packages to tell Julia which functions
-  should be made available to the user. For example:
-
-      module Test
-      export foo # foo is exported, but bar isn't
-      foo(x) = x
-      bar(y) = y
-      end
-
-      using Test
-      foo(1) # 1
-      bar(1) # Error: bar not defined
-      Test.bar(1) # 1
-  """
-
-keywords[:const] = doc"""
-  `const` is used to declare global variables which are also constant.
-  In almost all code (and particularly performance sensitive code)
-  global variables should be declared constant in this way.
-
-      const x = 5
-
-  Note that "constant-ness" is not enforced inside containers, so if
-  `x` is an array or dictionary (for example) you can still add and remove
-  elements.
-
-  Technically, you can even redefine `const` variables, although this will
-  generate a warning from the compiler. The only strict requirement is that
-  the *type* of the variable does not change, which is why `const` variables
-  are much faster than regular globals.
-  """
-
-keywords[:function] = doc"""
-  Functions are defined with the `function` keyword:
-
-      function add(a, b)
-          return a + b
-      end
-
-  Or the short form notation:
-
-      add(a, b) = a + b
-
-  The use of the `return` keyword is exactly the same as in other languages,
-  but is often optional. When it's not used, the last expression in the function
-  body will be returned by default:
-
-      function compare(a, b)
-        a == b && return "equal to"
-        a < b ? "less than" : "greater than"
-      end
-  """
-
-keywords[:return] = doc"""
-  `return` can be used function bodies to exit early and return a given value,
-  e.g.
-
-      function compare(a, b)
-          a == b && return "equal to"
-          a < b ? "less than" : "greater than"
-      end
-
-  In general you can place a `return` statement anywhere within a function
-  body, including within deeply nested loops or conditionals, but be careful
-  with `do` blocks. For example:
-
-      function test1(xs)
-          for x in xs
-              iseven(x) && return 2x
-          end
-      end
-
-      function test2(xs)
-          map(xs) do x
-              iseven(x) && return 2x
-              x
-          end
-      end
-
-  In the first example, the return breaks out of its enclosing function
-  as soon as it hits an even number, so `test1([5,6,7])` returns `12`.
-
-  You might expect the second example to behave the same way, but in fact
-  the `return` there only breaks out of the *inner* function (inside the `do`
-  block) and gives a value back to `map`. `test2([5,6,7])` then returns `[5,12,7]`.
-  """
-
-keywords[:if]  = keywords[:elseif] = keywords[:else] = doc"""
-  `if`-`elseif`-`else` performs conditional evaluation, which allows portions of code to be evaluated or not evaluated depending on the value of a boolean expression.
-  Here is the anatomy of the `if`-`elseif`-`else` conditional syntax:
-
-      if x < y
-          println("x is less than y")
-      elseif x > y
-          println("x is greater than y")
-      else
-          println("x is equal to y")
-      end
-
-  If the condition expression `x < y` is true, then the corresponding block is evaluated;
-  otherwise the condition expression `x > y` is evaluated, and if it is true, the corresponding block is evaluated; if neither expression is true, the `else` block is evaluated.
-  The `elseif` and `else` blocks are optional, and as many `elseif` blocks as desired can be used.
-  """
-
-keywords[:for] = doc"""
-  `for` loops repeatedly evaluate the body of the loop by iterating over a sequence of values.  For example:
-
-      for i in [1,4,0]
-          println(i)
-      end
-  """
-
-keywords[:while] = doc"""
-  `while` loops repeatedly evaluate a conditional expression, and continues evaluating the body of the while loop so long as
-  the expression remains `true`. If the condition expression is false when the while loop is first reached, the body is never evaluated.
-  For example:
-
-      while i <= 5
-          println(i)
-          i += 1
-      end
-  """
-
-keywords[:end] = doc"""
-  `end` marks the conclusion of a block of expressions.
-  In the example below, `end` marks the conclusion of a `function`.
-
-      function foo()
-          println("hello, world")
-      end
-
-  `end` marks the conclusion of all kinds of expression blocks: `module`, `type`, `begin`, `let`, `for`, etc.
-
-  In addition, `end` may be used when indexing into an array to represent the last index of each dimension:
-
-      x[1:end, 2:end-1]
-  """
-
-keywords[:try] = keywords[:catch] = doc"""
-  A `try/catch` statement allows for `Exception`s to be tested for. For example, a customized square root function
-  can be written to automatically call either the real or complex square root method on demand using `Exception`s:
-
-      f(x) = try
-          sqrt(x)
-      catch
-          sqrt(complex(x, 0))
-      end
-
-  `try/catch` statements also allow the `Exception` to be saved in a variable, e.g. `catch y`.
-
-  The `catch` clause is not strictly necessary; when omitted, the default return value is `nothing`.
-  The power of the `try/catch` construct lies in the ability to unwind a deeply nested computation
-  immediately to a much higher level in the stack of calling functions.
-  """
-
-keywords[:finally] = doc"""
-  `finally` provides a way to run some code when a given block of code exits, regardless of how it exits.
-  For example, here is how we can guarantee that an opened file is closed:
-
-      f = open("file")
-      try
-          operate_on_file(f)
-      finally
-          close(f)
-      end
-
-  When control leaves the `try` block (for example due to a `return`, or just finishing normally),
-  `close(f)` will be executed. If the `try` block exits due to an exception, the exception will continue propagating.
-  A `catch` block may be combined with `try` and `finally` as well.
-  In this case the `finally` block will run after `catch` has handled the error.
-  """
-
-keywords[:break] = doc"""
-  `break` breaks out of a loop immediately. For example
-
-      i = 0
-      while true
-          i += 1
-          i > 10 && break
-          println(i)
-      end
-
-  prints the numbers 1 to 10.
-  """
-
-keywords[:continue] = doc"""
-  `continue` skips the rest of the current loop, then carries on
-  looping. For example
-
-      for i = 1:10
-          iseven(i) && continue
-          println(i)
-      end
-
-  prints the numbers 1, 3, 5..., skipping the even numbers.
-  """
-
-keywords[:do] = doc"""
-  The `do` keyword creates an anonymous function. For example
-
-      map(1:10) do x
-          2x
-      end
-
-  is equivalent to `map(x->2x, 1:10)`.
-
-  Use multiple arguments like so:
-
-      map(1:10, 10:20) do x, y
-          x + y
-      end
-  """
-
-keywords[:...] = doc"""
-  The "splat" operator, `...`, represents a sequence of arguments. For example
-
-      add(xs...) = reduce(+, xs)
-
-  can take any number of arguments:
-
-      add(1, 2, 3, 4, 5)
-
-  `...` can also be used to apply a function to a sequence of arguments like so:
-
-      add([1, 2, 3]...) # 6
-      add(7, 1:100..., 1000:1100...) # 111107
-  """
-
-keywords[symbol(";")] = doc"""
-  `;` has a similar role in Julia as in many C-like languages,
-  and is used to delimit the end of the previous statement.
-  `;` is not necessary after new lines, but can be used to
-  seperate statements on a single line or to join statements into
-  a single expression:
-
-      function foo()
-          println("Hello, "); println("World!")
-          return true
-      end
-
-      foo() = (println("Hello, World!"); true)
-
-    `;` is also used to suppress output in the REPL and similar
-    interfaces.
-  """
-
-keywords[:(&&)]  = doc"""
-    x && y
-
-Short-circuiting boolean AND
-"""
-
-keywords[:(||)]  = doc"""
-    x || y
-
-Short-circuiting boolean OR
-"""
-
-keywords[:ccall] = doc"""
-      ccall((symbol, library) or function_pointer, ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
-
-  Call function in C-exported shared library, specified by
-  `(function name, library)` tuple, where each component is a string
-  or symbol.
-
-  Note that the argument type tuple must be a literal tuple, and not
-  a tuple-valued variable or expression. Alternatively, `ccall` may
-  also be used to call a function pointer, such as one returned by
-  `dlsym`.
-
-  Each `ArgumentValue` to the `ccall` will be converted to the
-  corresponding `ArgumentType`, by automatic insertion of calls to
-  `unsafe_convert(ArgumentType, cconvert(ArgumentType,
-  ArgumentValue))`. (See also the documentation for each of these
-  functions for further details.) In most cases, this simply results
-  in a call to `convert(ArgumentType, ArgumentValue)`.
-  """
-
-keywords[:begin] = doc"""
-  `begin...end` denotes a block of code.
-
-      begin
-          println("Hello, ")
-          println("World!")
-      end
-
-  Usually `begin` will not be necessary, since keywords
-  such as `function` and `let` implicitly begin blocks of
-  code. See also `;`.
-  """
-
-keywords[:type] = doc"""
-  At their most basic, Julia types are specified as a name
-  and a set of fields.
-
-      type Point
-          x
-          y
-      end
-
-  Fields can have type restrictions, which may be parametised:
-
-      type Point{X}
-          x::X
-          y::Float64
-      end
-
-  Type can also declare an abstract super type via `<:` syntax:
-
-      type Point <: AbstractPoint
-          ...
-
-  See the manual for more details, such as information on
-  inner constructors.
-  """
-
-keywords[:typealias] = doc"""
-  Introduce a new name for an already expressible type.
-  For example, in `base/boot.jl`, `UInt` is type aliased to either `UInt64` or `UInt32` as appropriate
-  for the size of pointers on the system:
-
-      if is(Int,Int64)
-          typealias UInt UInt64
-      else
-          typealias UInt UInt32
-      end
-
-  For parametric types, `typealias` can be convenient for providing names in cases where some parameter
-  choices are fixed.  In `base` for example:
-
-      typealias Vector{T} Array{T,1}
-  """
-
-keywords[:immutable] = doc"""
-  `immutable` acts in the same way as `type`, but declares
-  that the fields of the type may not be set after construction.
-  See `type` and the manual for more information.
-  """
-
-# """
-# Executes an expression, printing the time it took to
-# execute and the total number of bytes its execution caused to be
-# allocated. Returns the value of the expression. For example:
-#
-#     @time begin
-#         sleep(1)
-#         2+2
-#     end
-# """
-# :@time
-
-doc"""
-    @r_str -> Regex
-Construct a regex, such as `r"^[a-z]*$"`. The regex also accepts
-one or more flags, listed after the ending quote, to change its
-behaviour:
-
-  • `i` enables case-insensitive matching
-  • `m` treats the `^` and `$` tokens as matching the start and
-    and end of individual lines, as opposed to the whole string.
-  • `s` allows the `.` modifier to match newlines.
-  • `x` enables "comment mode": whitespace is enabled except when
-    escaped with `\`, and `#` is treated as starting a comment.
-
-For example, this regex has all three flags enabled:
-
-    julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
-    RegexMatch("angry,\nBad world")
-"""
-:(r"")
-
-# """
-#     push!(collection, items...) → collection
-#
-# Insert `items` at the end of `collection`.
-#
-#     push!([1,2,3], 4) == [1,2,3,4]
-# """
-# push!
-
-if Base.USE_GPL_LIBS
-
-@doc doc"""
-    fft(A [, dims])
-
-Performs a multidimensional FFT of the array `A`.  The optional
-`dims` argument specifies an iterable subset of dimensions (e.g.
-an integer, range, tuple, or array) to transform along.  Most
-efficient if the size of `A` along the transformed dimensions is
-a product of small primes; see `nextprod()`.  See also
-`plan_fft()` for even greater efficiency.
-
-A one-dimensional FFT computes the one-dimensional discrete Fourier
-transform (DFT) as defined by
-
-$$\operatorname{DFT}(A)[k] =
-  \sum_{n=1}^{\operatorname{length}(A)}
-  \exp\left(-i\frac{2\pi
-  (n-1)(k-1)}{\operatorname{length}(A)} \right) A[n].$$
-
-A multidimensional FFT simply performs this operation along each
-transformed dimension of `A`.
-
-Higher performance is usually possible with multi-threading. Use
-`FFTW.set_num_threads(np)` to use `np` threads, if you have `np`
-processors.
-""" fft
-
-end # USE_GPL_LIBS
-
-"""
-    include(path::AbstractString)
-
-Evaluate the contents of a source file in the current context.
-During including, a task-local include path is set to the directory
-containing the file. Nested calls to `include` will search
-relative to that path. All paths refer to files on node 1 when
-running in parallel, and files will be fetched from node 1. This
-function is typically used to load source interactively, or to
-combine files in packages that are broken into multiple source
-files.
-"""
-include_from_node1(::AbstractString)
-
-"""
-0 (zero; BrE: `/ˈzɪərəʊ/` or AmE: `/ˈziːroʊ/`) is both a number and the numerical digit used to represent that number in numerals. It fulfills a central role in mathematics as the additive identity of the integers, real numbers, and many other algebraic structures. As a digit, 0 is used as a placeholder in place value systems. Names for the number 0 in English include zero, nought or (US) naught (`/ˈnɔːt/`), nil, or — in contexts where at least one adjacent digit distinguishes it from the letter "O" — oh or o (`/ˈoʊ/`). Informal or slang terms for zero include zilch and zip. Ought and aught (/ˈɔːt/), as well as cipher, have also been used historically.
-"""
-0
+macro keyword(str, first, rest...)
+    out = :($(keywords)[$(esc(first))] = $(Docs.docexpr(str, Docs.metadata(:()))))
+    for symbol in rest
+        out = Expr(:(=), :($(keywords)[$(esc(symbol))]), out)
+    end
+    out
+end
+
+@keyword(
+    "Hello, Human.",
+    :hello, :hi
+)
+
+@keyword(
+    """
+    **Welcome to Julia $(string(VERSION)).** The full manual is available at
+
+        http://docs.julialang.org/
+
+    as well many great tutorials and learning resources:
+
+        http://julialang.org/learning/
+
+    For help on a specific function or macro, type `?` followed
+    by its name, e.g. `?fft`, or `?@time`, and press enter.
+    """,
+    :help, :?, :julia
+)
+
+@keyword(
+    """
+    `using` will load the given module or package and make some of its names available for
+    use (see also `export`). For example:
+
+        using Gadfly
+
+    loads the plotting package, Gadfly, so that the `plot` function can be used.
+
+    Names can be used via dot syntax, whether they are exported or not:
+
+        Gadfly.plot(...)
+
+    If you don't want to use the packages exports directly, see also `import`. If you're not
+    sure, `using` is almost definitely what you want.
+    """,
+    :using
+)
+
+@keyword(
+    """
+        import Gadfly
+
+    `import`, like `using`, will load modules and packages for use. Unlike `using`, however,
+    it will *not* make any `export`ed names available for use. To use Gadfly's `plot`
+    function after importing it, for example, you have to write:
+
+        Gadfly.plot(...)
+
+    Import can also be used with specific names, for example
+
+        import Gadfly: plot, render
+
+    This syntax is used when you want to extend the modules functions with new methods.
+    """,
+    :import
+)
+
+@keyword(
+    """
+    `export` is used within modules and packages to tell Julia which functions should be
+    made available to the user. For example:
+
+        module Test
+        export foo # foo is exported, but bar isn't
+        foo(x) = x
+        bar(y) = y
+        end
+
+        using Test
+        foo(1) # 1
+        bar(1) # Error: bar not defined
+        Test.bar(1) # 1
+    """,
+    :export
+)
+
+@keyword(
+    """
+    `abstract` declares a type that cannot be instantiated, and serves only as a node in the
+    type graph, thereby describing sets of related concrete types: those concrete types
+    which are their descendants. Abstract types form the conceptual hierarchy which makes
+    Julia’s type system more than just a collection of object implementations. For example:
+
+        abstract Number
+        abstract Real <: Number
+
+    `abstract Number` has no supertype, whereas `abstract Real` is an abstract subtype of `Number`.
+    """,
+    :abstract
+)
+
+@keyword(
+    """
+    `module` declares a Module, which is a separate global variable workspace.  Within a
+    module, you can control which names from other modules are visible (via importing), and
+    specify which of your names are intended to be public (via exporting). For example:
+
+        module
+        import Base.show
+        export MyType, foo
+
+        type MyType
+            x
+        end
+
+        bar(x) = 2x
+        foo(a::MyType) = bar(a.x) + 1
+        show(io, a::MyType) = print(io, "MyType \$(a.x)")
+        end
+
+    Modules allow you to create top-level definitions without worrying about name conflicts
+    when your code is used together with somebody else’s.
+    """,
+    :module
+)
+
+@keyword(
+    """
+    `baremodule` declares a module that does not contain `using Base`
+    or a definition of `eval`.  It does still import `Core`.
+    """,
+    :baremodule
+)
+
+@keyword(
+    """
+    `bitstype` declares a concrete type whose data consists of plain old bits. Classic
+    examples of bits types are integers and floating-point values. Some example built-in
+    bits type declarations:
+
+        bitstype 32 Char
+        bitstype 8  Bool <: Integer
+
+    The first parameter indicates how many bits of storage the type requires. Currently,
+    only sizes that are multiples of 8 bits are supported. The second parameter gives the
+    name of the type.  The `Bool` declaration shows how a bits type can be optionally
+    declared to be a subtype of some supertype.
+    """,
+    :bitstype
+)
+
+@keyword(
+    """
+    `macro` defines a method to include generated code in the final body of a program. A
+    macro maps a tuple of arguments to a returned expression, and the resulting expression
+    is compiled directly rather than requiring a runtime `eval()` call. Macro arguments may
+    include expressions, literal values, and symbols. For example:
+
+        macro sayhello(name)
+            return :( println("Hello, ", \$name) )
+        end
+
+    This macro takes one argument: `name`. When `@sayhello` is encountered, the quoted
+    expression is expanded to interpolate the value of the argument into the final
+    expression.
+    """,
+    :macro
+)
+
+@keyword(
+    """
+    `importall` imports all names exported by the specified module, as if `import` were used
+    individually on all of them.  For example:
+
+        importall Distributions
+
+    As with `import`, functions imported by `importall` can be extended.
+    """,
+    :importall
+)
+
+@keyword(
+    """
+    `local` introduces a new local variable. For example:
+
+        function foo(n)
+            x = 0
+            for i = 1:n
+                local x
+                x = i
+            end
+            x
+        end
+
+        julia> foo(10)
+        0
+
+    Here `local x` introduces a separate `x` inside the loop, so the function returns `0`.
+    """,
+    :local
+)
+
+@keyword(
+    """
+    `global x` makes `x` in the current scope and its inner scopes refer to the global
+    variable of that name.   In the example below, `global` is needed so the function can
+    modify the global variable `z`:
+
+        z=3
+        function foo()
+            global z=6
+        end
+
+        julia> foo()
+        6
+        julia> z
+        6
+
+    Without the `global` declaration in `foo()`, a new local variable would have been
+    created inside foo(), and the `z` in the global scope would have remained equal to `3`.
+    """,
+    :global
+)
+
+@keyword(
+    """
+    `let` statements allocate new variable bindings each time they run. Whereas an
+    assignment modifies an existing value location, `let` creates new locations. This
+    difference is only detectable in the case of variables that outlive their scope via
+    closures. The `let` syntax accepts a comma-separated series of assignments and variable
+    names:
+
+        let var1 = value1, var2, var3 = value3
+            code
+        end
+
+    The assignments are evaluated in order, with each right-hand side evaluated in the scope
+    before the new variable on the left-hand side has been introduced. Therefore it makes
+    sense to write something like `let x = x`, since the two `x` variables are distinct and
+    have separate storage.
+    """,
+    :let
+)
+
+@keyword(
+    """
+    `quote` creates multiple expression objects in a block without using the explicit `Expr`
+    constructor. For example:
+
+        ex = quote
+            x = 1
+            y = 2
+            x + y
+        end
+
+    Unlike the other means of quoting, `:( ... )`, this form introduces `QuoteNode` elements
+    to the expression tree, which must be considered when directly manipulating the tree.
+    For other purposes, `:( ... )` and `quote .. end` blocks are treated identically.
+    """,
+    :quote
+)
+
+@keyword(
+    """
+    `'` is the conjugate transposition operator:
+
+        > A = reshape(1:4, 2,2)
+        2x2 Array{Int64,2}:
+         1  3
+         2  4
+
+        > A'
+        2x2 Array{Int64,2}:
+         1  2
+         3  4
+
+        > B = A + im
+        2x2 Array{Complex{Int64},2}:
+         1+1im  3+1im
+         2+1im  4+1im
+
+        > B'
+        2x2 Array{Complex{Int64},2}:
+         1-1im  2-1im
+         3-1im  4-1im
+    """,
+    symbol("'")
+)
+
+
+@keyword(
+    """
+    `.'` is the transposition operator:
+
+        > A = reshape(1:4, 2,2)
+        2x2 Array{Int64,2}:
+         1  3
+         2  4
+
+        > A.'
+        2x2 Array{Int64,2}:
+         1  2
+         3  4
+
+        > B = A + im
+        2x2 Array{Complex{Int64},2}:
+         1+1im  3+1im
+         2+1im  4+1im
+
+        > B.'
+        2x2 Array{Complex{Int64},2}:
+         1+1im  2+1im
+         3+1im  4+1im
+    """,
+    symbol(".'")
+)
+
+@keyword(
+    """
+    `const` is used to declare global variables which are also constant. In almost all code
+    (and particularly performance sensitive code) global variables should be declared
+    constant in this way.
+
+        const x = 5
+
+    Note that "constant-ness" is not enforced inside containers, so if `x` is an array or
+    dictionary (for example) you can still add and remove elements.
+
+    Technically, you can even redefine `const` variables, although this will generate a
+    warning from the compiler. The only strict requirement is that the *type* of the
+    variable does not change, which is why `const` variables are much faster than regular
+    globals.
+    """,
+    :const
+)
+
+@keyword(
+    """
+    Functions are defined with the `function` keyword:
+
+        function add(a, b)
+            return a + b
+        end
+
+    Or the short form notation:
+
+        add(a, b) = a + b
+
+    The use of the `return` keyword is exactly the same as in other languages, but is often
+    optional. When it's not used, the last expression in the function body will be returned
+    by default:
+
+        function compare(a, b)
+            a == b && return "equal to"
+            a < b ? "less than" : "greater than"
+        end
+    """,
+    :function
+)
+
+@keyword(
+    """
+    `return` can be used function bodies to exit early and return a given value, e.g.
+
+        function compare(a, b)
+            a == b && return "equal to"
+            a < b ? "less than" : "greater than"
+        end
+
+    In general you can place a `return` statement anywhere within a function body, including
+    within deeply nested loops or conditionals, but be careful with `do` blocks. For
+    example:
+
+        function test1(xs)
+            for x in xs
+                iseven(x) && return 2x
+            end
+        end
+
+        function test2(xs)
+            map(xs) do x
+                iseven(x) && return 2x
+                x
+            end
+        end
+
+    In the first example, the return breaks out of its enclosing function as soon as it hits
+    an even number, so `test1([5,6,7])` returns `12`.
+
+    You might expect the second example to behave the same way, but in fact the `return`
+    there only breaks out of the *inner* function (inside the `do` block) and gives a value
+    back to `map`. `test2([5,6,7])` then returns `[5,12,7]`.
+    """,
+    :return
+)
+
+@keyword(
+    """
+    `if`-`elseif`-`else` performs conditional evaluation, which allows portions of code to
+    be evaluated or not evaluated depending on the value of a boolean expression. Here is
+    the anatomy of the `if`-`elseif`-`else` conditional syntax:
+
+        if x < y
+            println("x is less than y")
+        elseif x > y
+            println("x is greater than y")
+        else
+            println("x is equal to y")
+        end
+
+    If the condition expression `x < y` is true, then the corresponding block is evaluated;
+    otherwise the condition expression `x > y` is evaluated, and if it is true, the
+    corresponding block is evaluated; if neither expression is true, the `else` block is
+    evaluated. The `elseif` and `else` blocks are optional, and as many `elseif` blocks as
+    desired can be used.
+    """,
+    :if, :elseif, :else
+)
+
+@keyword(
+    """
+    `for` loops repeatedly evaluate the body of the loop by iterating over a sequence of
+    values. For example:
+
+        for i in [1,4,0]
+            println(i)
+        end
+    """,
+    :for
+)
+
+@keyword(
+    """
+    `while` loops repeatedly evaluate a conditional expression, and continues evaluating the
+    body of the while loop so long as the expression remains `true`. If the condition
+    expression is false when the while loop is first reached, the body is never evaluated.
+    For example:
+
+        while i <= 5
+            println(i)
+            i += 1
+        end
+    """,
+    :while
+)
+
+@keyword(
+    """
+    `end` marks the conclusion of a block of expressions. In the example below, `end` marks
+    the conclusion of a `function`.
+
+        function foo()
+            println("hello, world")
+        end
+
+    `end` marks the conclusion of all kinds of expression blocks: `module`, `type`, `begin`,
+    `let`, `for`, etc.
+
+    In addition, `end` may be used when indexing into an array to represent the last index
+    of each dimension:
+
+        x[1:end, 2:end-1]
+    """,
+    :end
+)
+
+@keyword(
+    """
+    A `try/catch` statement allows for `Exception`s to be tested for. For example, a
+    customized square root function can be written to automatically call either the real or
+    complex square root method on demand using `Exception`s:
+
+        f(x) = try
+            sqrt(x)
+        catch
+            sqrt(complex(x, 0))
+        end
+
+    `try/catch` statements also allow the `Exception` to be saved in a variable, e.g. `catch y`.
+
+    The `catch` clause is not strictly necessary; when omitted, the default return value is
+    `nothing`. The power of the `try/catch` construct lies in the ability to unwind a deeply
+    nested computation immediately to a much higher level in the stack of calling functions.
+    """,
+    :try, :catch
+)
+
+@keyword(
+    """
+
+    `finally` provides a way to run some code when a given block of code exits, regardless
+    of how it exits. For example, here is how we can guarantee that an opened file is
+    closed:
+
+        f = open("file")
+        try
+            operate_on_file(f)
+        finally
+            close(f)
+        end
+
+    When control leaves the `try` block (for example due to a `return`, or just finishing
+    normally), `close(f)` will be executed. If the `try` block exits due to an exception,
+    the exception will continue propagating. A `catch` block may be combined with `try` and
+    `finally` as well. In this case the `finally` block will run after `catch` has handled
+    the error.
+    """,
+    :finally
+)
+
+@keyword(
+    """
+    `break` breaks out of a loop immediately. For example
+
+        i = 0
+        while true
+            i += 1
+            i > 10 && break
+            println(i)
+        end
+
+    prints the numbers 1 to 10.
+    """,
+    :break
+)
+
+@keyword(
+    """
+    `continue` skips the rest of the current loop, then carries on looping. For example
+
+        for i = 1:10
+            iseven(i) && continue
+            println(i)
+        end
+
+    prints the numbers 1, 3, 5..., skipping the even numbers.
+    """,
+    :continue
+)
+
+@keyword(
+    """
+    The `do` keyword creates an anonymous function. For example
+
+        map(1:10) do x
+            2x
+        end
+
+    is equivalent to `map(x->2x, 1:10)`.
+
+    Use multiple arguments like so:
+
+        map(1:10, 11:20) do x, y
+            x + y
+        end
+    """,
+    :do
+)
+
+@keyword(
+    """
+    The "splat" operator, `...`, represents a sequence of arguments. For example
+
+        add(xs...) = reduce(+, xs)
+
+    can take any number of arguments:
+
+        add(1, 2, 3, 4, 5)
+
+    `...` can also be used to apply a function to a sequence of arguments like so:
+
+        add([1, 2, 3]...) # 6
+        add(7, 1:100..., 1000:1100...) # 111107
+    """,
+    :...
+)
+
+@keyword(
+    """
+    `;` has a similar role in Julia as in many C-like languages, and is used to delimit the
+    end of the previous statement. `;` is not necessary after new lines, but can be used to
+    separate statements on a single line or to join statements into a single expression:
+
+        function foo()
+            println("Hello, "); println("World!")
+            return true
+        end
+
+        foo() = (println("Hello, World!"); true)
+
+    `;` is also used to suppress output in the REPL and similar interfaces.
+    """,
+    symbol(";")
+)
+
+@keyword(
+    """
+        x && y
+
+    Short-circuiting boolean AND.
+    """,
+    :(&&)
+)
+
+@keyword(
+    """
+        x || y
+
+    Short-circuiting boolean OR.
+    """,
+    :(||)
+)
+
+@keyword(
+    """
+        ccall((symbol, library) or function_pointer, ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
+
+    Call function in C-exported shared library, specified by `(function name, library)`
+    tuple, where each component is a string or symbol.
+
+    Note that the argument type tuple must be a literal tuple, and not a tuple-valued
+    variable or expression. Alternatively, `ccall` may also be used to call a function
+    pointer, such as one returned by `dlsym`.
+
+    Each `ArgumentValue` to the `ccall` will be converted to the corresponding
+    `ArgumentType`, by automatic insertion of calls to `unsafe_convert(ArgumentType,
+    cconvert(ArgumentType, ArgumentValue))`. (See also the documentation for each of these
+    functions for further details.) In most cases, this simply results in a call to
+    `convert(ArgumentType, ArgumentValue)`.
+    """,
+    :ccall
+)
+
+@keyword(
+    """
+        llvmcall(IR::String, ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
+        llvmcall((declarations::String, IR::String), ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
+
+    Call LLVM IR string in the first argument. Similar to an LLVM function `define` block,
+    arguments are available as consecutive unnamed SSA variables (%0, %1, etc.).
+
+    The optional declarations string contains external functions declarations that are
+    necessary for llvm to compile the IR string. Multiple declarations can be passed in by
+    separating them with line breaks.
+
+    Note that the argument type tuple must be a literal tuple, and not a tuple-valued
+    variable or expression.
+
+    Each `ArgumentValue` to `llvmcall` will be converted to the corresponding
+    `ArgumentType`, by automatic insertion of calls to `unsafe_convert(ArgumentType,
+    cconvert(ArgumentType, ArgumentValue))`. (see also the documentation for each of these
+    functions for further details). In most cases, this simply results in a call to
+    `convert(ArgumentType, ArgumentValue)`.
+
+    See `test/llvmcall.jl` for usage examples.
+    """,
+    :llvmcall
+)
+
+@keyword(
+    """
+    `begin...end` denotes a block of code.
+
+        begin
+            println("Hello, ")
+            println("World!")
+        end
+
+    Usually `begin` will not be necessary, since keywords such as `function` and `let`
+    implicitly begin blocks of code. See also `;`.
+    """,
+    :begin
+)
+
+@keyword(
+    """
+    At their most basic, Julia types are specified as a name and a set of fields.
+
+        type Point
+            x
+            y
+        end
+
+    Fields can have type restrictions, which may be parametrised:
+
+        type Point{X}
+            x::X
+            y::Float64
+        end
+
+    Type can also declare an abstract super type via `<:` syntax:
+
+        type Point <: AbstractPoint
+            ...
+
+    See the manual for more details, such as information on inner constructors.
+    """,
+    :type
+)
+
+@keyword(
+    """
+    Introduce a new name for an already expressible type. For example, in `base/boot.jl`,
+    `UInt` is type aliased to either `UInt64` or `UInt32` as appropriate for the size of
+    pointers on the system:
+
+        if is(Int,Int64)
+            typealias UInt UInt64
+        else
+            typealias UInt UInt32
+        end
+
+    For parametric types, `typealias` can be convenient for providing names in cases where
+    some parameter choices are fixed.  In `base` for example:
+
+        typealias Vector{T} Array{T,1}
+    """,
+    :typealias
+)
+
+@keyword(
+    """
+    `immutable` acts in the same way as `type`, but declares that the fields of the type may
+    not be set after construction. See `type` and the manual for more information.
+    """,
+    :immutable
+)
+
+@keyword(
+    """
+        @__LINE__ -> Int
+
+    `@__LINE__` expands to the line number of the call-site.
+    """,
+    symbol("@__LINE__")
+)
diff --git a/base/docs/bindings.jl b/base/docs/bindings.jl
index bc799b7ff0eba..368075b0334c3 100644
--- a/base/docs/bindings.jl
+++ b/base/docs/bindings.jl
@@ -5,22 +5,36 @@ export @var
 immutable Binding
     mod::Module
     var::Symbol
-    Binding(m, v) = new(Base.which_module(m, v), v)
+
+    function Binding(m::Module, v::Symbol)
+        # Normalise the binding module for module symbols so that:
+        #   Binding(Base, :Base) === Binding(Main, :Base)
+        m = module_name(m) === v ? module_parent(m) : m
+        new(Base.binding_module(m, v), v)
+    end
 end
 
+bindingexpr(x) = Expr(:call, Binding, splitexpr(x)...)
+
+defined(b::Binding) = isdefined(b.mod, b.var)
+resolve(b::Binding) = getfield(b.mod, b.var)
+
 function splitexpr(x::Expr)
     isexpr(x, :macrocall) ? splitexpr(x.args[1]) :
-    isexpr(x, :.)         ? (esc(x.args[1]), x.args[2]) :
+    isexpr(x, :.)         ? (x.args[1], x.args[2]) :
     error("Invalid @var syntax `$x`.")
 end
-splitexpr(s::Symbol) = :(current_module()), quot(s)
+splitexpr(s::Symbol) = Expr(:call, current_module), quot(s)
 splitexpr(other)     = error("Invalid @var syntax `$other`.")
 
-isvar(x) = isexpr(x, :macrocall, :.)
-isvar(::Symbol) = true
-
 macro var(x)
-    :(Binding($(splitexpr(x)...)))
+    esc(bindingexpr(x))
 end
 
-Base.show(io::IO, x::Binding) = print(io, "$(x.mod).$(x.var)")
+Base.show(io::IO, b::Binding) = b.mod === Main ? print(io, b.var) : print(io, b.mod, '.', b.var)
+
+aliasof(b::Binding)     = defined(b) ? (a = aliasof(resolve(b), b); defined(a) ? a : b) : b
+aliasof(d::DataType, b) = Binding(d.name.module, d.name.name)
+aliasof(λ::Function, b) = (m = typeof(λ).name.mt; Binding(m.module, m.name))
+aliasof(m::Module,   b) = Binding(m, module_name(m))
+aliasof(other,       b) = b
diff --git a/base/docs/bootstrap.jl b/base/docs/bootstrap.jl
index 7084219bc9596..191b20abc9c66 100644
--- a/base/docs/bootstrap.jl
+++ b/base/docs/bootstrap.jl
@@ -4,6 +4,8 @@ macro doc(args...)
     DocBootstrap._expand_(args...)
 end
 
+macro __doc__(ex) esc(Expr(:block, Expr(:meta, :doc), ex)) end
+
 module DocBootstrap
 
 type List
@@ -17,11 +19,22 @@ _expand_ = nothing
 
 setexpand!(f) = global _expand_ = f
 
-setexpand!() do str, obj
+function __bootexpand(str, obj)
     global docs = List((ccall(:jl_get_current_module, Any, ()), str, obj), docs)
-    return esc(Expr(:toplevel, obj))
+    (isa(obj, Expr) && obj.head === :call) && return nothing
+    (isa(obj, Expr) && obj.head === :module) && return esc(Expr(:toplevel, obj))
+    esc(obj)
+end
+
+function __bootexpand(expr::Expr)
+    if expr.head !== :->
+        throw(ArgumentError("Wrong argument to @doc"))
+    end
+    __bootexpand(expr.args...)
 end
 
+setexpand!(__bootexpand)
+
 """
     DocBootstrap :: Module
 
@@ -32,13 +45,24 @@ that were stored in `DocBootstrap.docs` are migrated to their correct modules us
 """
 DocBootstrap
 
+"""
+    loaddocs()
+
+Move all docstrings from `DocBootstrap.docs` to their module's metadata dict.
+"""
 function loaddocs()
-    node = docs
+    # To keep the ordering of docstrings consistent within the entire docsystem we need to
+    # reverse the contents of `docs` (a stack) before evaluating each docstring.
+    node  = docs
+    stack = []
     while node ≠ nothing
-        mod, str, obj = node.head
-        eval(mod, :(Base.@doc($str, $obj, false)))
+        push!(stack, node.head)
         node = node.tail
     end
+    while !isempty(stack)
+        mod, str, obj = pop!(stack)
+        eval(mod, :(Base.@doc($str, $obj, false)))
+    end
     global docs = nothing
 end
 
diff --git a/base/docs/helpdb.jl b/base/docs/helpdb.jl
index 74cc08427d8fb..858ffc96e1849 100644
--- a/base/docs/helpdb.jl
+++ b/base/docs/helpdb.jl
@@ -1,12473 +1,6 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-# Base.LinAlg.BLAS
-
 import .Docs: keywords
 
-doc"""
-    ger!(alpha, x, y, A)
-
-Rank-1 update of the matrix `A` with vectors `x` and `y` as `alpha*x*y' + A`.
-"""
-LinAlg.BLAS.ger!
-
-doc"""
-    gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)
-
-Update vector `y` as `alpha*A*x + beta*y` or `alpha*A'*x + beta*y` according to `trans` ('N' or 'T'). The matrix `A` is a general band matrix of dimension `m` by `size(A,2)` with `kl` sub-diagonals and `ku` super-diagonals. Returns the updated `y`.
-"""
-LinAlg.BLAS.gbmv!
-
-doc"""
-    gbmv(trans, m, kl, ku, alpha, A, x, beta, y)
-
-Returns `alpha*A*x` or `alpha*A'*x` according to `trans` ('N' or 'T'). The matrix `A` is a general band matrix of dimension `m` by `size(A,2)` with `kl` sub-diagonals and `ku` super-diagonals.
-"""
-LinAlg.BLAS.gbmv
-
-doc"""
-    gemm!(tA, tB, alpha, A, B, beta, C)
-
-Update `C` as `alpha*A*B + beta*C` or the other three variants according to `tA` (transpose `A`) and `tB`. Returns the updated `C`.
-"""
-LinAlg.BLAS.gemm!
-
-doc"""
-    gemv!(tA, alpha, A, x, beta, y)
-
-Update the vector `y` as `alpha*A*x + beta*y` or `alpha*A'x + beta*y` according to `tA` (transpose `A`). Returns the updated `y`.
-"""
-LinAlg.BLAS.gemv!
-
-doc"""
-    blascopy!(n, X, incx, Y, incy)
-
-Copy `n` elements of array `X` with stride `incx` to array `Y` with stride `incy`. Returns `Y`.
-"""
-LinAlg.BLAS.blascopy!
-
-doc"""
-    scal!(n, a, X, incx)
-
-Overwrite `X` with `a*X`. Returns `X`.
-"""
-LinAlg.BLAS.scal!
-
-doc"""
-    gemv(tA, alpha, A, x)
-
-Returns `alpha*A*x` or `alpha*A'x` according to `tA` (transpose `A`).
-"""
-LinAlg.BLAS.gemv(tA, alpha, A, x)
-
-doc"""
-    gemv(tA, A, x)
-
-Returns `A*x` or `A'x` according to `tA` (transpose `A`).
-"""
-LinAlg.BLAS.gemv(tA, A, x)
-
-doc"""
-    syr!(uplo, alpha, x, A)
-
-Rank-1 update of the symmetric matrix `A` with vector `x` as `alpha*x*x.' + A`. When `uplo` is 'U' the upper triangle of `A` is updated ('L' for lower triangle). Returns `A`.
-"""
-LinAlg.BLAS.syr!
-
-doc"""
-    trsm!(side, ul, tA, dA, alpha, A, B)
-
-Overwrite `B` with the solution to `A*X = alpha*B` or one of the other three variants determined by `side` (`A` on left or right of `X`) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones). Returns the updated `B`.
-"""
-LinAlg.BLAS.trsm!
-
-doc"""
-    trsv!(ul, tA, dA, A, b)
-
-Overwrite `b` with the solution to `A*x = b` or one of the other two variants determined by `tA` (transpose `A`) and `ul` (triangle of `A` used). `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones). Returns the updated `b`.
-"""
-LinAlg.BLAS.trsv!
-
-doc"""
-    her!(uplo, alpha, x, A)
-
-Methods for complex arrays only. Rank-1 update of the Hermitian matrix `A` with vector `x` as `alpha*x*x' + A`. When `uplo` is 'U' the upper triangle of `A` is updated ('L' for lower triangle). Returns `A`.
-"""
-LinAlg.BLAS.her!
-
-doc"""
-    trsv(ul, tA, dA, A, b)
-
-Returns the solution to `A*x = b` or one of the other two variants determined by `tA` (transpose `A`) and `ul` (triangle of `A` is used.) `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones).
-"""
-LinAlg.BLAS.trsv
-
-doc"""
-    dot(n, X, incx, Y, incy)
-
-Dot product of two vectors consisting of `n` elements of array `X` with stride `incx` and `n` elements of array `Y` with stride `incy`.
-"""
-LinAlg.BLAS.dot
-
-doc"""
-    dotu(n, X, incx, Y, incy)
-
-Dot function for two complex vectors.
-"""
-LinAlg.BLAS.dotu
-
-doc"""
-    herk!(uplo, trans, alpha, A, beta, C)
-
-Methods for complex arrays only. Rank-k update of the Hermitian matrix `C` as `alpha*A*A' + beta*C` or `alpha*A'*A + beta*C` according to whether `trans` is 'N' or 'T'. When `uplo` is 'U' the upper triangle of `C` is updated ('L' for lower triangle). Returns `C`.
-"""
-LinAlg.BLAS.herk!
-
-doc"""
-    trmv(side, ul, tA, dA, alpha, A, b)
-
-Returns `alpha*A*b` or one of the other three variants determined by `side` (`A` on left or right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones).
-"""
-LinAlg.BLAS.trmv
-
-doc"""
-    symv(ul, alpha, A, x)
-
-Returns `alpha*A*x`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used.
-"""
-LinAlg.BLAS.symv(ul, alpha, A, x)
-
-doc"""
-    symv(ul, A, x)
-
-Returns `A*x`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used.
-"""
-LinAlg.BLAS.symv(ul, A, x)
-
-doc"""
-    dotc(n, X, incx, U, incy)
-
-Dot function for two complex vectors conjugating the first vector.
-"""
-LinAlg.BLAS.dotc
-
-doc"""
-    axpy!(a, X, Y)
-
-Overwrite `Y` with `a*X + Y`. Returns `Y`.
-"""
-LinAlg.BLAS.axpy!
-
-doc"""
-    syrk!(uplo, trans, alpha, A, beta, C)
-
-Rank-k update of the symmetric matrix `C` as `alpha*A*A.' + beta*C` or `alpha*A.'*A + beta*C` according to whether `trans` is 'N' or 'T'. When `uplo` is 'U' the upper triangle of `C` is updated ('L' for lower triangle). Returns `C`.
-"""
-LinAlg.BLAS.syrk!
-
-doc"""
-    sbmv(uplo, k, alpha, A, x)
-
-Returns `alpha*A*x` where `A` is a symmetric band matrix of order `size(A,2)` with `k` super-diagonals stored in the argument `A`.
-"""
-LinAlg.BLAS.sbmv(uplo, k, alpha, A, x)
-
-doc"""
-    sbmv(uplo, k, A, x)
-
-Returns `A*x` where `A` is a symmetric band matrix of order `size(A,2)` with `k` super-diagonals stored in the argument `A`.
-"""
-LinAlg.BLAS.sbmv(uplo, k, A, x)
-
-doc"""
-    sbmv!(uplo, k, alpha, A, x, beta, y)
-
-Update vector `y` as `alpha*A*x + beta*y` where `A` is a a symmetric band matrix of order `size(A,2)` with `k` super-diagonals stored in the argument `A`. The storage layout for `A` is described the reference BLAS module, level-2 BLAS at <http://www.netlib.org/lapack/explore-html/>.
-
-Returns the updated `y`.
-"""
-LinAlg.BLAS.sbmv!
-
-doc"""
-    symv!(ul, alpha, A, x, beta, y)
-
-Update the vector `y` as `alpha*A*x + beta*y`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used. Returns the updated `y`.
-"""
-LinAlg.BLAS.symv!
-
-doc"""
-    symm(side, ul, alpha, A, B)
-
-Returns `alpha*A*B` or `alpha*B*A` according to `side`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used.
-"""
-LinAlg.BLAS.symm(side, ul, alpha, A, B)
-
-doc"""
-    symm(side, ul, A, B)
-
-Returns `A*B` or `B*A` according to `side`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used.
-"""
-LinAlg.BLAS.symm(side, ul, A, B)
-
-doc"""
-    symm(tA, tB, alpha, A, B)
-
-Returns `alpha*A*B` or the other three variants according to `tA` (transpose `A`) and `tB`.
-"""
-LinAlg.BLAS.symm(tA::Char, tB::Char, alpha, A, B)
-
-doc"""
-    herk(uplo, trans, alpha, A)
-
-Methods for complex arrays only. Returns either the upper triangle or the lower triangle, according to `uplo` ('U' or 'L'), of `alpha*A*A'` or `alpha*A'*A`, according to `trans` ('N' or 'T').
-"""
-LinAlg.BLAS.herk
-
-doc"""
-    syrk(uplo, trans, alpha, A)
-
-Returns either the upper triangle or the lower triangle, according to `uplo` ('U' or 'L'), of `alpha*A*A.'` or `alpha*A.'*A`, according to `trans` ('N' or 'T').
-"""
-LinAlg.BLAS.syrk
-
-doc"""
-    trsm(side, ul, tA, dA, alpha, A, B)
-
-Returns the solution to `A*X = alpha*B` or one of the other three variants determined by `side` (`A` on left or right of `X`) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones).
-"""
-LinAlg.BLAS.trsm
-
-doc"""
-    blas_set_num_threads(n)
-
-Set the number of threads the BLAS library should use.
-"""
-LinAlg.BLAS.blas_set_num_threads
-
-doc"""
-    asum(n, X, incx)
-
-sum of the absolute values of the first `n` elements of array `X` with stride `incx`.
-"""
-LinAlg.BLAS.asum
-
-doc"""
-    trmv!(side, ul, tA, dA, alpha, A, b)
-
-Update `b` as `alpha*A*b` or one of the other three variants determined by `side` (`A` on left or right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones). Returns the updated `b`.
-"""
-LinAlg.BLAS.trmv!
-
-doc"""
-    gemm(tA, tB, alpha, A, B)
-
-Returns `alpha*A*B` or the other three variants according to `tA` (transpose `A`) and `tB`.
-"""
-LinAlg.BLAS.gemm(tA, tB, alpha, A, B)
-
-doc"""
-    gemm(tA, tB, A, B)
-
-Returns `A*B` or the other three variants according to `tA` (transpose `A`) and `tB`.
-"""
-LinAlg.BLAS.gemm(tA, tB, A, B)
-
-doc"""
-    symm!(side, ul, alpha, A, B, beta, C)
-
-Update `C` as `alpha*A*B + beta*C` or `alpha*B*A + beta*C` according to `side`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used. Returns the updated `C`.
-"""
-LinAlg.BLAS.symm!
-
-doc"""
-    scal(n, a, X, incx)
-
-Returns `a*X`.
-"""
-LinAlg.BLAS.scal
-
-doc"""
-    nrm2(n, X, incx)
-
-2-norm of a vector consisting of `n` elements of array `X` with stride `incx`.
-"""
-LinAlg.BLAS.nrm2
-
-doc"""
-    trmm!(side, ul, tA, dA, alpha, A, B)
-
-Update `B` as `alpha*A*B` or one of the other three variants determined by `side` (`A` on left or right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones). Returns the updated `B`.
-"""
-LinAlg.BLAS.trmm!
-
-doc"""
-    trmm(side, ul, tA, dA, alpha, A, B)
-
-Returns `alpha*A*B` or one of the other three variants determined by `side` (`A` on left or right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones).
-"""
-LinAlg.BLAS.trmm
-
-# Libdl
-
-doc"""
-    dlopen(libfile::AbstractString [, flags::Integer])
-
-Load a shared library, returning an opaque handle.
-
-The optional flags argument is a bitwise-or of zero or more of `RTLD_LOCAL`, `RTLD_GLOBAL`, `RTLD_LAZY`, `RTLD_NOW`, `RTLD_NODELETE`, `RTLD_NOLOAD`, `RTLD_DEEPBIND`, and `RTLD_FIRST`. These are converted to the corresponding flags of the POSIX (and/or GNU libc and/or MacOS) dlopen command, if possible, or are ignored if the specified functionality is not available on the current platform. The default flags are platform specific. On MacOS the default `dlopen` flags are `RTLD_LAZY|RTLD_DEEPBIND|RTLD_GLOBAL` while on other platforms the defaults are `RTLD_LAZY|RTLD_DEEPBIND|RTLD_LOCAL`. An important usage of these flags is to specify non default behavior for when the dynamic library loader binds library references to exported symbols and if the bound references are put into process local or global scope. For instance `RTLD_LAZY|RTLD_DEEPBIND|RTLD_GLOBAL` allows the library's symbols to be available for usage in other shared libraries, addressing situations where there are dependencies between shared libraries.
-"""
-Libdl.dlopen
-
-doc"""
-    dlclose(handle)
-
-Close shared library referenced by handle.
-"""
-Libdl.dlclose
-
-doc"""
-    dlsym_e(handle, sym)
-
-Look up a symbol from a shared library handle, silently return NULL pointer on lookup failure.
-"""
-Libdl.dlsym_e
-
-doc"""
-```rst
-..  dlopen_e(libfile::AbstractString [, flags::Integer])
-
-Similar to :func:`dlopen`, except returns a ``NULL`` pointer instead of raising errors.
-```
-"""
-Libdl.dlopen_e
-
-doc"""
-    find_library(names, locations)
-
-Searches for the first library in `names` in the paths in the `locations` list, `DL_LOAD_PATH`, or system library paths (in that order) which can successfully be dlopen'd. On success, the return value will be one of the names (potentially prefixed by one of the paths in locations). This string can be assigned to a `global const` and used as the library name in future `ccall`'s. On failure, it returns the empty string.
-"""
-Libdl.find_library
-
-doc"""
-    dlsym(handle, sym)
-
-Look up a symbol from a shared library handle, return callable function pointer on success.
-"""
-Libdl.dlsym
-
-# Libc
-
-doc"""
-    TmStruct([seconds])
-
-Convert a number of seconds since the epoch to broken-down format, with fields `sec`, `min`, `hour`, `mday`, `month`, `year`, `wday`, `yday`, and `isdst`.
-"""
-Libc.TmStruct
-
-doc"""
-    time(t::TmStruct)
-
-Converts a `TmStruct` struct to a number of seconds since the epoch.
-"""
-Libc.time
-
-doc"""
-    calloc(num::Integer, size::Integer) -> Ptr{Void}
-
-Call `calloc` from the C standard library.
-"""
-Libc.calloc
-
-doc"""
-    strerror(n=errno())
-
-Convert a system call error code to a descriptive string
-"""
-Libc.strerror
-
-doc"""
-    realloc(addr::Ptr, size::Integer) -> Ptr{Void}
-
-Call `realloc` from the C standard library.
-
-See warning in the documentation for `free` regarding only using this on memory originally obtained from `malloc`.
-"""
-Libc.realloc
-
-doc"""
-    free(addr::Ptr)
-
-Call `free` from the C standard library. Only use this on memory obtained from `malloc`, not on pointers retrieved from other C libraries. `Ptr` objects obtained from C libraries should be freed by the free functions defined in that library, to avoid assertion failures if multiple `libc` libraries exist on the system.
-"""
-Libc.free
-
-doc"""
-    strftime([format], time)
-
-Convert time, given as a number of seconds since the epoch or a `TmStruct`, to a formatted string using the given format. Supported formats are the same as those in the standard C library.
-"""
-Libc.strftime
-
-doc"""
-    errno([code])
-
-Get the value of the C library's `errno`. If an argument is specified, it is used to set the value of `errno`.
-
-The value of `errno` is only valid immediately after a `ccall` to a C library routine that sets it. Specifically, you cannot call `errno` at the next prompt in a REPL, because lots of code is executed between prompts.
-"""
-Libc.errno
-
-doc"""
-    malloc(size::Integer) -> Ptr{Void}
-
-Call `malloc` from the C standard library.
-"""
-Libc.malloc
-
-doc"""
-    strptime([format], timestr)
-
-Parse a formatted time string into a `TmStruct` giving the seconds, minute, hour, date, etc. Supported formats are the same as those in the standard C library. On some platforms, timezones will not be parsed correctly. If the result of this function will be passed to `time` to convert it to seconds since the epoch, the `isdst` field should be filled in manually. Setting it to `-1` will tell the C library to use the current system settings to determine the timezone.
-"""
-Libc.strptime
-
-doc"""
-    flush_cstdio()
-
-Flushes the C `stdout` and `stderr` streams (which may have been written to by external C code).
-"""
-Libc.flush_cstdio
-
-doc"""
-```rst
-..  msync(ptr, len, [flags])
-
-Forces synchronization of the :func:`mmap`\ ped memory region from ``ptr`` to ``ptr+len``. Flags defaults to ``MS_SYNC``, but can be a combination of ``MS_ASYNC``, ``MS_SYNC``, or ``MS_INVALIDATE``. See your platform man page for specifics. The flags argument is not valid on Windows.
-
-You may not need to call ``msync``, because synchronization is performed at intervals automatically by the operating system. However, you can call this directly if, for example, you are concerned about losing the result of a long-running calculation.
-```
-"""
-Libc.msync
-
-# Base.Collections
-
-doc"""
-```rst
-..  PriorityQueue(K, V, [ord])
-
-Construct a new :obj:`PriorityQueue`, with keys of type ``K`` and values/priorites of
-type ``V``. If an order is not given, the priority queue is min-ordered using
-the default comparison for ``V``.
-```
-"""
-Collections.PriorityQueue
-
-doc"""
-    enqueue!(pq, k, v)
-
-Insert the a key `k` into a priority queue `pq` with priority `v`.
-"""
-Collections.enqueue!
-
-doc"""
-    dequeue!(pq)
-
-Remove and return the lowest priority key from a priority queue.
-"""
-Collections.dequeue!
-
-doc"""
-    peek(pq)
-
-Return the lowest priority key from a priority queue without removing that key from the queue.
-"""
-Collections.peek
-
-doc"""
-```rst
-..  heapify!(v, [ord])
-
-In-place :func:`heapify`.
-```
-"""
-Collections.heapify!
-
-doc"""
-    heappush!(v, x, [ord])
-
-Given a binary heap-ordered array, push a new element `x`, preserving the heap property. For efficiency, this function does not check that the array is indeed heap-ordered.
-"""
-Collections.heappush!
-
-doc"""
-    heappop!(v, [ord])
-
-Given a binary heap-ordered array, remove and return the lowest ordered element. For efficiency, this function does not check that the array is indeed heap-ordered.
-"""
-Collections.heappop!
-
-doc"""
-    heapify(v, [ord])
-
-Return a new vector in binary heap order, optionally using the given ordering.
-"""
-Collections.heapify
-
-doc"""
-    isheap(v, [ord])
-
-Return `true` iff an array is heap-ordered according to the given order.
-"""
-Collections.isheap
-
-# Base.Test
-
-doc"""
-    @test_throws(extype, ex)
-
-Test that the expression `ex` throws an exception of type `extype` and calls the current handler to handle the result.
-"""
-:(Test.@test_throws)
-
-doc"""
-    @test_approx_eq_eps(a, b, tol)
-
-Test two floating point numbers `a` and `b` for equality taking in account a margin of tolerance given by `tol`.
-"""
-:(Test.@test_approx_eq_eps)
-
-doc"""
-    @test(ex)
-
-Test the expression `ex` and calls the current handler to handle the result.
-"""
-:(Test.@test)
-
-doc"""
-    @test_approx_eq(a, b)
-
-Test two floating point numbers `a` and `b` for equality taking in account small numerical errors.
-"""
-:(Test.@test_approx_eq)
-
-doc"""
-    with_handler(f, handler)
-
-Run the function `f` using the `handler` as the handler.
-"""
-Test.with_handler
-
-# Base.FFTW
-
-doc"""
-```rst
-..  r2r(A, kind [, dims])
-
-Performs a multidimensional real-input/real-output (r2r) transform
-of type ``kind`` of the array ``A``, as defined in the FFTW manual.
-``kind`` specifies either a discrete cosine transform of various types
-(``FFTW.REDFT00``, ``FFTW.REDFT01``, ``FFTW.REDFT10``, or
-``FFTW.REDFT11``), a discrete sine transform of various types
-(``FFTW.RODFT00``, ``FFTW.RODFT01``, ``FFTW.RODFT10``, or
-``FFTW.RODFT11``), a real-input DFT with halfcomplex-format output
-(``FFTW.R2HC`` and its inverse ``FFTW.HC2R``), or a discrete
-Hartley transform (``FFTW.DHT``).  The ``kind`` argument may be
-an array or tuple in order to specify different transform types
-along the different dimensions of ``A``; ``kind[end]`` is used
-for any unspecified dimensions.  See the FFTW manual for precise
-definitions of these transform types, at http://www.fftw.org/doc.
-
-The optional ``dims`` argument specifies an iterable subset of
-dimensions (e.g. an integer, range, tuple, or array) to transform
-along. ``kind[i]`` is then the transform type for ``dims[i]``,
-with ``kind[end]`` being used for ``i > length(kind)``.
-
-See also :func:`plan_r2r` to pre-plan optimized r2r transforms.
-```
-"""
-FFTW.r2r
-
-doc"""
-```rst
-..  r2r!(A, kind [, dims])
-
-Same as :func:`r2r`, but operates in-place on ``A``, which must be
-an array of real or complex floating-point numbers.
-```
-"""
-FFTW.r2r!
-
-doc"""
-```rst
-..  plan_r2r!(A, kind [, dims [, flags [, timelimit]]])
-
-Similar to :func:`Base.plan_fft`, but corresponds to :func:`r2r!`.
-```
-"""
-FFTW.plan_r2r!
-
-doc"""
-```rst
-..  plan_r2r(A, kind [, dims [, flags [, timelimit]]])
-
-Pre-plan an optimized r2r transform, similar to :func:`Base.plan_fft`
-except that the transforms (and the first three arguments)
-correspond to :func:`r2r` and :func:`r2r!`, respectively.
-```
-"""
-FFTW.plan_r2r
-
-# Base.Profile
-
-doc"""
-```rst
-..  print([io::IO = STDOUT,] [data::Vector]; format = :tree, C = false, combine = true, cols = tty_cols())
-
-Prints profiling results to ``io`` (by default, ``STDOUT``). If you
-do not supply a ``data`` vector, the internal buffer of accumulated
-backtraces will be used.  ``format`` can be ``:tree`` or
-``:flat``. If ``C==true``, backtraces from C and Fortran code are
-shown. ``combine==true`` merges instruction pointers that
-correspond to the same line of code.  ``cols`` controls the width
-of the display.
-```
-"""
-Profile.print(io::IO = STDOUT, data::Vector=?)
-
-doc"""
-```rst
-..  print([io::IO = STDOUT,] data::Vector, lidict::Dict; format = :tree, combine = true, cols = tty_cols())
-
-Prints profiling results to ``io``. This variant is used to examine
-results exported by a previous call to :func:`retrieve`.
-Supply the vector ``data`` of backtraces and a dictionary
-``lidict`` of line information.
-```
-"""
-Profile.print(io::IO = STDOUT, data::Vector = ?, lidict::Dict = ?)
-
-doc"""
-    init(; n::Integer, delay::Float64)
-
-Configure the `delay` between backtraces (measured in seconds), and the number `n` of instruction pointers that may be stored. Each instruction pointer corresponds to a single line of code; backtraces generally consist of a long list of instruction pointers. Default settings can be obtained by calling this function with no arguments, and each can be set independently using keywords or in the order `(n, delay)`.
-"""
-Profile.init
-
-doc"""
-```rst
-..  clear_malloc_data()
-
-Clears any stored memory allocation data when running julia with
-``--track-allocation``.  Execute the command(s) you want to test
-(to force JIT-compilation), then call :func:`clear_malloc_data`.
-Then execute your command(s) again, quit Julia, and examine the
-resulting ``*.mem`` files.
-```
-"""
-Profile.clear_malloc_data
-
-doc"""
-```rst
-..  callers(funcname, [data, lidict], [filename=<filename>], [linerange=<start:stop>]) -> Vector{Tuple{count, linfo}}
-
-Given a previous profiling run, determine who called a particular
-function. Supplying the filename (and optionally, range of line
-numbers over which the function is defined) allows you to
-disambiguate an overloaded method. The returned value is a vector
-containing a count of the number of calls and line information
-about the caller.  One can optionally supply backtrace data
-obtained from :func:`retrieve`; otherwise, the current internal profile
-buffer is used.
-```
-"""
-Profile.callers
-
-doc"""
-```rst
-..  fetch() -> data
-
-Returns a reference to the internal buffer of backtraces. Note that
-subsequent operations, like :func:`clear`, can affect
-``data`` unless you first make a copy. Note that the values in
-``data`` have meaning only on this machine in the current session,
-because it depends on the exact memory addresses used in
-JIT-compiling. This function is primarily for internal use;
-:func:`retrieve` may be a better choice for most users.
-```
-"""
-Profile.fetch
-
-doc"""
-    retrieve() -> data, lidict
-
-"Exports" profiling results in a portable format, returning the set of all backtraces (`data`) and a dictionary that maps the (session-specific) instruction pointers in `data` to `LineInfo` values that store the file name, function name, and line number. This function allows you to save profiling results for future analysis.
-"""
-Profile.retrieve
-
-doc"""
-    clear()
-
-Clear any existing backtraces from the internal buffer.
-"""
-Profile.clear
-
-# Base.Cartesian
-
-doc"""
-    @nall N expr
-
-`@nall 3 d->(i_d > 1)` would generate the expression `(i_1 > 1 && i_2 > 1 && i_3 > 1)`. This can be convenient for bounds-checking.
-"""
-:(Cartesian.@nall)
-
-doc"""
-    @nloops N itersym rangeexpr bodyexpr
-    @nloops N itersym rangeexpr preexpr bodyexpr
-    @nloops N itersym rangeexpr preexpr postexpr bodyexpr
-
-Generate `N` nested loops, using `itersym` as the prefix for the iteration variables. `rangeexpr` may be an anonymous-function expression, or a simple symbol `var` in which case the range is `1:size(var,d)` for dimension `d`.
-
-Optionally, you can provide "pre" and "post" expressions. These get executed first and last, respectively, in the body of each loop. For example, :
-
-    @nloops 2 i A d->j_d=min(i_d,5) begin
-        s += @nref 2 A j
-    end
-
-would generate :
-
-    for i_2 = 1:size(A, 2)
-        j_2 = min(i_2, 5)
-        for i_1 = 1:size(A, 1)
-            j_1 = min(i_1, 5)
-            s += A[j_1,j_2]
-        end
-    end
-
-If you want just a post-expression, supply `nothing` for the pre-expression. Using parenthesis and semicolons, you can supply multi-statement expressions.
-"""
-:(Cartesian.@nloops)
-
-doc"""
-    @ntuple N expr
-
-Generates an `N`-tuple. `@ntuple 2 i` would generate `(i_1, i_2)`, and `@ntuple 2 k->k+1` would generate `(2,3)`.
-"""
-:(Cartesian.@ntuple)
-
-doc"""
-    @nif N conditionexpr expr
-    @nif N conditionexpr expr elseexpr
-
-Generates a sequence of `if ... elseif ... else ... end` statements. For example:
-
-    @nif 3 d->(i_d >= size(A,d)) d->(error("Dimension ", d, " too big")) d->println("All OK")
-
-would generate:
-
-    if i_1 > size(A, 1)
-        error("Dimension ", 1, " too big")
-    elseif i_2 > size(A, 2)
-        error("Dimension ", 2, " too big")
-    else
-        println("All OK")
-    end
-"""
-:(Cartesian.@nif)
-
-doc"""
-    @nref N A indexexpr
-
-Generate expressions like `A[i_1,i_2,...]`. `indexexpr` can either be an iteration-symbol prefix, or an anonymous-function expression.
-"""
-:(Cartesian.@nref)
-
-doc"""
-    @nexprs N expr
-
-Generate `N` expressions. `expr` should be an anonymous-function expression.
-"""
-:(Cartesian.@nexprs)
-
-# Base
-
-doc"""
-    @time
-
-A macro to execute an expression, printing the time it took to execute, the number of allocations, and the total number of bytes its execution caused to be allocated, before returning the value of the expression.
-"""
-:@time
-
-doc"""
-    systemerror(sysfunc, iftrue)
-
-Raises a `SystemError` for `errno` with the descriptive string `sysfunc` if `iftrue` is `true`
-"""
-systemerror
-
-doc"""
-    writedlm(f, A, delim='\\t')
-
-Write `A` (a vector, matrix or an iterable collection of iterable rows) as text to `f` (either a filename string or an `IO` stream) using the given delimeter `delim` (which defaults to tab, but can be any printable Julia object, typically a `Char` or `AbstractString`).
-
-For example, two vectors `x` and `y` of the same length can be written as two columns of tab-delimited text to `f` by either `writedlm(f, [x y])` or by `writedlm(f, zip(x, y))`.
-"""
-writedlm
-
-doc"""
-    cholfact(A, [LU=:U[,pivot=Val{false}]][;tol=-1.0]) -> Cholesky
-
-Compute the Cholesky factorization of a dense symmetric positive (semi)definite matrix `A` and return either a `Cholesky` if `pivot==Val{false}` or `CholeskyPivoted` if `pivot==Val{true}`. `LU` may be `:L` for using the lower part or `:U` for the upper part. The default is to use `:U`. The triangular matrix can be obtained from the factorization `F` with: `F[:L]` and `F[:U]`. The following functions are available for `Cholesky` objects: `size`, `\`, `inv`, `det`. For `CholeskyPivoted` there is also defined a `rank`. If `pivot==Val{false}` a `PosDefException` exception is thrown in case the matrix is not positive definite. The argument `tol` determines the tolerance for determining the rank. For negative values, the tolerance is the machine precision.
-"""
-cholfact(A, LU=:U, pivot=Val{false})
-
-doc"""
-    cholfact(A; shift=0, perm=Int[]) -> CHOLMOD.Factor
-
-Compute the Cholesky factorization of a sparse positive definite matrix `A`. A fill-reducing permutation is used. `F = cholfact(A)` is most frequently used to solve systems of equations with `F\b`, but also the methods `diag`, `det`, `logdet` are defined for `F`. You can also extract individual factors from `F`, using `F[:L]`. However, since pivoting is on by default, the factorization is internally represented as `A == P'*L*L'*P` with a permutation matrix `P`; using just `L` without accounting for `P` will give incorrect answers. To include the effects of permutation, it's typically preferable to extact "combined" factors like `PtL = F[:PtL]` (the equivalent of `P'*L`) and `LtP = F[:UP]` (the equivalent of `L'*P`).
-
-Setting optional `shift` keyword argument computes the factorization of `A+shift*I` instead of `A`. If the `perm` argument is nonempty, it should be a permutation of `1:size(A,1)` giving the ordering to use (instead of CHOLMOD's default AMD ordering).
-
-The function calls the C library CHOLMOD and many other functions from the library are wrapped but not exported.
-"""
-cholfact(A)
-
-doc"""
-    digamma(x)
-
-Compute the digamma function of `x` (the logarithmic derivative of `gamma(x)`)
-"""
-digamma
-
-doc"""
-    fill!(A, x)
-
-Fill array `A` with the value `x`. If `x` is an object reference, all elements will refer to the same object. `fill!(A, Foo())` will return `A` filled with the result of evaluating `Foo()` once.
-"""
-fill!
-
-doc"""
-    read!(stream, array::Array)
-
-Read binary data from a stream, filling in the argument `array`.
-"""
-read!
-
-doc"""
-    empty!(collection) -> collection
-
-Remove all elements from a `collection`.
-"""
-empty!
-
-doc"""
-    asin(x)
-
-Compute the inverse sine of `x`, where the output is in radians
-"""
-asin
-
-doc"""
-    <:(T1, T2)
-
-Subtype operator, equivalent to `issubtype(T1,T2)`.
-"""
-Base.(:(<:))
-
-doc"""
-    schedule(t::Task, [val]; error=false)
-
-Add a task to the scheduler's queue. This causes the task to run constantly when the system is otherwise idle, unless the task performs a blocking operation such as `wait`.
-
-If a second argument is provided, it will be passed to the task (via the return value of `yieldto`) when it runs again. If `error` is `true`, the value is raised as an exception in the woken task.
-"""
-schedule
-
-doc"""
-```rst
-..  step(r)
-
-Get the step size of a :obj:`Range` object.
-```
-"""
-step
-
-doc"""
-    utf32(s)
-
-Create a UTF-32 string from a byte array, array of `Char` or `UInt32`, or any other string type. (Conversions of byte arrays check for a byte-order marker in the first four bytes, and do not include it in the resulting string.)
-
-Note that the resulting `UTF32String` data is terminated by the NUL codepoint (32-bit zero), which is not treated as a character in the string (so that it is mostly invisible in Julia); this allows the string to be passed directly to external functions requiring NUL-terminated data. This NUL is appended automatically by the `utf32(s)` conversion function. If you have a `Char` or `UInt32` array `A` that is already NUL-terminated UTF-32 data, then you can instead use `UTF32String(A)` to construct the string without making a copy of the data and treating the NUL as a terminator rather than as part of the string.
-"""
-utf32(s)
-
-doc"""
-    utf32(::Union{Ptr{Char},Ptr{UInt32},Ptr{Int32}} [, length])
-
-Create a string from the address of a NUL-terminated UTF-32 string. A copy is made; the pointer can be safely freed. If `length` is specified, the string does not have to be NUL-terminated.
-"""
-utf32(::Union{Ptr{Char},Ptr{UInt32},Ptr{Int32}}, length=?)
-
-doc"""
-    takebuf_array(b::IOBuffer)
-
-Obtain the contents of an `IOBuffer` as an array, without copying. Afterwards, the IOBuffer is reset to its initial state.
-"""
-takebuf_array
-
-doc"""
-    download(url,[localfile])
-
-Download a file from the given url, optionally renaming it to the given local file name. Note that this function relies on the availability of external tools such as `curl`, `wget` or `fetch` to download the file and is provided for convenience. For production use or situations in which more options are needed, please use a package that provides the desired functionality instead.
-"""
-download
-
-doc"""
-    @everywhere
-
-Execute an expression on all processes. Errors on any of the processes are collected into a `CompositeException` and thrown.
-"""
-:@everywhere
-
-doc"""
-    lstrip(string, [chars])
-
-Return `string` with any leading whitespace removed. If `chars` (a character, or vector or set of characters) is provided, instead remove characters contained in it.
-"""
-lstrip
-
-doc"""
-    reenable_sigint(f::Function)
-
-Re-enable Ctrl-C handler during execution of a function. Temporarily reverses the effect of `disable_sigint`.
-"""
-reenable_sigint
-
-doc"""
-    indmin(itr) -> Integer
-
-Returns the index of the minimum element in a collection.
-"""
-indmin
-
-doc"""
-    powermod(x, p, m)
-
-Compute $x^p \pmod m$.
-"""
-powermod
-
-doc"""
-    typeintersect(T, S)
-
-Compute a type that contains the intersection of `T` and `S`. Usually this will be the smallest such type or one close to it.
-"""
-typeintersect
-
-doc"""
-```rst
-..  plan_bfft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as :func:`plan_bfft`, but operates in-place on ``A``.
-```
-"""
-plan_bfft!
-
-doc"""
-    pointer(array [, index])
-
-Get the native address of an array or string element. Be careful to ensure that a julia reference to `a` exists as long as this pointer will be used. This function is "unsafe" like `unsafe_convert`.
-
-Calling `Ref(array[, index])` is generally preferable to this function.
-"""
-pointer
-
-doc"""
-    countnz(A)
-
-Counts the number of nonzero values in array `A` (dense or sparse). Note that this is not a constant-time operation. For sparse matrices, one should usually use `nnz`, which returns the number of stored values.
-"""
-countnz
-
-doc"""
-    isnan(f) -> Bool
-
-Test whether a floating point number is not a number (NaN)
-"""
-isnan
-
-doc"""
-```rst
-..  plan_irfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Pre-plan an optimized inverse real-input FFT, similar to :func:`plan_rfft`
-except for :func:`irfft` and :func:`brfft`, respectively.  The first
-three arguments have the same meaning as for :func:`irfft`.
-```
-"""
-plan_irfft
-
-doc"""
-```rst
-..  println(x)
-
-Print (using :func:`print`) ``x`` followed by a newline.
-```
-"""
-println
-
-doc"""
-    besselj(nu, x)
-
-Bessel function of the first kind of order `nu`, $J_\nu(x)$.
-"""
-besselj
-
-doc"""
-```rst
-..  @code_lowered
-
-Evaluates the arguments to the function call, determines their types, and calls :func:`code_lowered` on the resulting expression.
-```
-"""
-:@code_lowered
-
-doc"""
-    //(num, den)
-
-Divide two integers or rational numbers, giving a `Rational` result.
-"""
-Base.(:(//))
-
-doc"""
-    At_mul_B(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᵀ B`
-"""
-At_mul_B
-
-doc"""
-    methods(f, [types])
-
-Returns the method table for `f`.
-
-If `types` is specified, returns an array of methods whose types match.
-"""
-methods
-
-doc"""
-```rst
-..  pmap(f, lsts...; err_retry=true, err_stop=false, pids=workers())
-
-Transform collections ``lsts`` by applying ``f`` to each element in parallel.
-(Note that ``f`` must be made available to all worker processes; see :ref:`Code Availability and Loading Packages <man-parallel-computing-code-availability>` for details.)
-If ``nprocs() > 1``, the calling process will be dedicated to assigning tasks.
-All other available processes will be used as parallel workers, or on the processes specified by ``pids``.
-
-If ``err_retry`` is ``true``, it retries a failed application of ``f`` on a different worker.
-If ``err_stop`` is ``true``, it takes precedence over the value of ``err_retry`` and ``pmap`` stops execution on the first error.
-```
-"""
-pmap
-
-doc"""
-    workers()
-
-Returns a list of all worker process identifiers.
-"""
-workers
-
-doc"""
-    isinteger(x) -> Bool
-
-Test whether `x` or all its elements are numerically equal to some integer
-"""
-isinteger
-
-doc"""
-    sortrows(A, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Sort the rows of matrix `A` lexicographically.
-"""
-sortrows
-
-doc"""
-    ./(x, y)
-
-Element-wise right division operator.
-"""
-Base.(:(./))
-
-doc"""
-    IPv6(host::Integer) -> IPv6
-
-Returns IPv6 object from ip address formatted as Integer
-"""
-IPv6
-
-doc"""
-    prod!(r, A)
-
-Multiply elements of `A` over the singleton dimensions of `r`, and write results to `r`.
-"""
-prod!
-
-doc"""
-    hist2d!(counts, M, e1, e2) -> (e1, e2, counts)
-
-Compute a "2d histogram" with respect to the bins delimited by the edges given in `e1` and `e2`. This function writes the results to a pre-allocated array `counts`.
-"""
-hist2d!
-
-doc"""
-    fieldtype(T, name::Symbol | index::Int)
-
-Determine the declared type of a field (specified by name or index) in a composite DataType `T`.
-"""
-fieldtype
-
-doc"""
-    hypot(x, y)
-
-Compute the $\sqrt{x^2+y^2}$ avoiding overflow and underflow
-"""
-hypot
-
-doc"""
-    airybi(x)
-
-Airy function $\operatorname{Bi}(x)$.
-"""
-airybi
-
-doc"""
-    gensym([tag])
-
-Generates a symbol which will not conflict with other variable names.
-"""
-gensym
-
-doc"""
-    cummin(A, [dim])
-
-Cumulative minimum along a dimension. The dimension defaults to 1.
-"""
-cummin
-
-doc"""
-    minabs!(r, A)
-
-Compute the minimum absolute values over the singleton dimensions of `r`, and write values to `r`.
-"""
-minabs!
-
-doc"""
-    prevprod([k_1,k_2,...], n)
-
-Previous integer not greater than `n` that can be written as $\prod k_i^{p_i}$ for integers $p_1$, $p_2$, etc.
-"""
-prevprod
-
-doc"""
-    @evalpoly(z, c...)
-
-Evaluate the polynomial $\sum_k c[k] z^{k-1}$ for the
-coefficients `c[1]`, `c[2]`, ...; that is, the coefficients are
-given in ascending order by power of `z`.  This macro expands to
-efficient inline code that uses either Horner's method or, for
-complex `z`, a more efficient Goertzel-like algorithm.
-"""
-:@evalpoly
-
-doc"""
-```rst
-..  eigfact!(A, [B])
-
-Same as :func:`eigfact`, but saves space by overwriting the input ``A`` (and
-``B``), instead of creating a copy.
-```
-"""
-eigfact!
-
-doc"""
-    cosh(x)
-
-Compute hyperbolic cosine of `x`
-"""
-cosh
-
-doc"""
-```rst
-..  ipermutedims(A, perm)
-
-Like :func:`permutedims`, except the inverse of the given permutation is applied.
-```
-"""
-ipermutedims
-
-doc"""
-    dirname(path::AbstractString) -> AbstractString
-
-Get the directory part of a path.
-"""
-dirname
-
-doc"""
-    isfile(path) -> Bool
-
-Returns `true` if `path` is a regular file, `false` otherwise.
-"""
-isfile
-
-doc"""
-    symlink(target, link)
-
-Creates a symbolic link to `target` with the name `link`.
-
-**note**
-
-This function raises an error under operating systems that do not support soft symbolic links, such as Windows XP.
-"""
-symlink
-
-doc"""
-    task_local_storage(symbol)
-
-Look up the value of a symbol in the current task's task-local storage.
-"""
-task_local_storage(symbol)
-
-doc"""
-    task_local_storage(symbol, value)
-
-Assign a value to a symbol in the current task's task-local storage.
-"""
-task_local_storage(symbol, value)
-
-doc"""
-    task_local_storage(body, symbol, value)
-
-Call the function `body` with a modified task-local storage, in which `value` is assigned to `symbol`; the previous value of `symbol`, or lack thereof, is restored afterwards. Useful for emulating dynamic scoping.
-"""
-task_local_storage(body, symbol, value)
-
-doc"""
-    diff(A, [dim])
-
-Finite difference operator of matrix or vector.
-"""
-diff
-
-doc"""
-    precision(num::AbstractFloat)
-
-Get the precision of a floating point number, as defined by the effective number of bits in the mantissa.
-"""
-precision
-
-doc"""
-    cor(v1[, v2][, vardim=1, mean=nothing])
-
-Compute the Pearson correlation between the vector(s) in `v1` and `v2`.
-
-Users can use the keyword argument `vardim` to specify the variable dimension, and `mean` to supply pre-computed mean values.
-"""
-cor
-
-doc"""
-    partitions(n)
-
-Generate all integer arrays that sum to `n`. Because the number of partitions can be very large, this function returns an iterator object. Use `collect(partitions(n))` to get an array of all partitions. The number of partitions to generate can be efficiently computed using `length(partitions(n))`.
-"""
-partitions(n::Integer)
-
-doc"""
-    partitions(n, m)
-
-Generate all arrays of `m` integers that sum to `n`. Because the number of partitions can be very large, this function returns an iterator object. Use `collect(partitions(n,m))` to get an array of all partitions. The number of partitions to generate can be efficiently computed using `length(partitions(n,m))`.
-"""
-partitions(n::Integer, m::Integer)
-
-doc"""
-    partitions(array)
-
-Generate all set partitions of the elements of an array, represented as arrays of arrays. Because the number of partitions can be very large, this function returns an iterator object. Use `collect(partitions(array))` to get an array of all partitions. The number of partitions to generate can be efficiently computed using `length(partitions(array))`.
-"""
-partitions(array)
-
-doc"""
-    partitions(array, m)
-
-Generate all set partitions of the elements of an array into exactly m subsets, represented as arrays of arrays. Because the number of partitions can be very large, this function returns an iterator object. Use `collect(partitions(array,m))` to get an array of all partitions. The number of partitions into m subsets is equal to the Stirling number of the second kind and can be efficiently computed using `length(partitions(array,m))`.
-"""
-partitions(array, m::Integer)
-
-doc"""
-    readlines(stream)
-
-Read all lines as an array.
-"""
-readlines
-
-doc"""
-    findnz(A)
-
-Return a tuple `(I, J, V)` where `I` and `J` are the row and column indexes of the non-zero values in matrix `A`, and `V` is a vector of the non-zero values.
-"""
-findnz
-
-doc"""
-    RemoteRef()
-
-Make an uninitialized remote reference on the local machine.
-"""
-RemoteRef()
-
-doc"""
-    RemoteRef(n)
-
-Make an uninitialized remote reference on process `n`.
-"""
-RemoteRef(::Integer)
-
-doc"""
-```rst
-..  foldl(op, v0, itr)
-
-Like :func:`reduce`, but with guaranteed left associativity. ``v0``
-will be used exactly once.
-```
-"""
-foldl(op, v0, itr)
-
-doc"""
-```rst
-..  foldl(op, itr)
-
-Like ``foldl(op, v0, itr)``, but using the first element of ``itr``
-as ``v0``. In general, this cannot be used with empty collections
-(see ``reduce(op, itr)``).
-```
-"""
-foldl(op, itr)
-
-doc"""
-    airybiprime(x)
-
-Airy function derivative $\operatorname{Bi}'(x)$.
-"""
-airybiprime
-
-doc"""
-    Ac_rdiv_B(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᴴ / B`
-"""
-Ac_rdiv_B
-
-doc"""
-```rst
-..  set_rounding(T, mode)
-
-Set the rounding mode of floating point type ``T``, controlling the
-rounding of basic arithmetic functions (:func:`+`, :func:`-`, :func:`*`,
-:func:`/` and :func:`sqrt`) and type conversion.
-
-Note that this may affect other types, for instance changing the rounding
-mode of ``Float64`` will change the rounding mode of ``Float32``. See
-``get_rounding`` for available modes
-```
-"""
-set_rounding
-
-doc"""
-    linspace(start, stop, n=100)
-
-Construct a range of `n` linearly spaced elements from `start` to `stop`.
-"""
-linspace
-
-doc"""
-    promote_type(type1, type2)
-
-Determine a type big enough to hold values of each argument type without loss, whenever possible. In some cases, where no type exists to which both types can be promoted losslessly, some loss is tolerated; for example, `promote_type(Int64,Float64)` returns `Float64` even though strictly, not all `Int64` values can be represented exactly as `Float64` values.
-"""
-promote_type
-
-doc"""
-    ind2sub(dims, index) -> subscripts
-
-Returns a tuple of subscripts into an array with dimensions `dims`,
-corresponding to the linear index `index`.
-
-**Example**: `i, j, ... = ind2sub(size(A), indmax(A))` provides the
-indices of the maximum element
-"""
-ind2sub(dims::Tuple, index::Int)
-
-doc"""
-    ind2sub(a, index) -> subscripts
-
-Returns a tuple of subscripts into array `a` corresponding to the linear index `index`
-"""
-ind2sub(a, index)
-
-doc"""
-    .*(x, y)
-
-Element-wise multiplication operator.
-"""
-Base.(:(.*))
-
-doc"""
-    ror!(dest::BitArray{1}, src::BitArray{1}, i::Integer) -> BitArray{1}
-
-Performs a right rotation operation on `src` and put the result into `dest`.
-"""
-ror!(dest::BitArray{1}, src::BitArray{1}, i::Integer)
-
-doc"""
-    ror!(B::BitArray{1}, i::Integer) -> BitArray{1}
-
-Performs a right rotation operation on `B`.
-"""
-ror!(B::BitArray{1}, i::Integer)
-
-doc"""
-    range(start, [step], length)
-
-Construct a range by length, given a starting value and optional step (defaults to 1).
-"""
-range
-
-doc"""
-    eltype(type)
-
-Determine the type of the elements generated by iterating a collection of the given `type`. For associative collection types, this will be a `Pair{KeyType,ValType}`. The definition `eltype(x) = eltype(typeof(x))` is provided for convenience so that instances can be passed instead of types. However the form that accepts a type argument should be defined for new types.
-"""
-eltype
-
-doc"""
-    keytype(collection)
-
-For associative collection types, this will be the type of the Key, This is not defined for non-associative collections
-"""
-keytype
-
-doc"""
-    valtype(collection)
-
-For associative collection types, this will be the type of the Value, This is not defined for non-associative collections
-"""
-valtype
-
-doc"""
-    edit(file::AbstractString, [line])
-
-Edit a file optionally providing a line number to edit at. Returns to the julia prompt when you quit the editor.
-"""
-edit(file::AbstractString, line=?)
-
-doc"""
-    edit(function, [types])
-
-Edit the definition of a function, optionally specifying a tuple of types to indicate which method to edit.
-"""
-edit(::Function, types=?)
-
-doc"""
-    backtrace()
-
-Get a backtrace object for the current program point.
-"""
-backtrace
-
-doc"""
-    ignorestatus(command)
-
-Mark a command object so that running it will not throw an error if the result code is non-zero.
-"""
-ignorestatus
-
-doc"""
-    reducedim(f, A, dims[, initial])
-
-Reduce 2-argument function `f` along dimensions of `A`. `dims` is a vector specifying the dimensions to reduce, and `initial` is the initial value to use in the reductions. For `+`, `*`, `max` and `min` the `initial` argument is optional.
-
-The associativity of the reduction is implementation-dependent; if you need a particular associativity, e.g. left-to-right, you should write your own loop. See documentation for `reduce`.
-"""
-reducedim
-
-doc"""
-    -(x)
-
-Unary minus operator.
-"""
--(x)
-
-doc"""
-    -(x, y)
-
-Subtraction operator.
-"""
--(x, y)
-
-doc"""
-```rst
-..  mapfoldr(f, op, v0, itr)
-
-Like :func:`mapreduce`, but with guaranteed right associativity. ``v0``
-will be used exactly once.
-```
-"""
-mapfoldr(f, op, v0, itr)
-
-doc"""
-```rst
-..  mapfoldr(f, op, itr)
-
-Like ``mapfoldr(f, op, v0, itr)``, but using the first element of
-``itr`` as ``v0``. In general, this cannot be used with empty
-collections (see ``reduce(op, itr)``).
-```
-"""
-mapfoldr(f, op, itr)
-
-doc"""
-    broadcast_setindex!(A, X, inds...)
-
-Broadcasts the `X` and `inds` arrays to a common size and stores the value from each position in `X` at the indices given by the same positions in `inds`.
-"""
-broadcast_setindex!
-
-doc"""
-    Nullable(x)
-
-Wrap value `x` in an object of type `Nullable`, which indicates whether a value is present. `Nullable(x)` yields a non-empty wrapper, and `Nullable{T}()` yields an empty instance of a wrapper that might contain a value of type `T`.
-"""
-Nullable
-
-doc"""
-    bits(n)
-
-A string giving the literal bit representation of a number.
-"""
-bits
-
-doc"""
-    launch(manager::FooManager, params::Dict, launched::Vector{WorkerConfig}, launch_ntfy::Condition)
-
-Implemented by cluster managers. For every Julia worker launched by this function, it should append a `WorkerConfig` entry to `launched` and notify `launch_ntfy`. The function MUST exit once all workers, requested by `manager` have been launched. `params` is a dictionary of all keyword arguments `addprocs` was called with.
-"""
-launch
-
-doc"""
-```rst
-..  @code_typed
-
-Evaluates the arguments to the function call, determines their types, and calls :func:`code_typed` on the resulting expression.
-```
-"""
-:@code_typed
-
-doc"""
-    invdigamma(x)
-
-Compute the inverse digamma function of `x`.
-"""
-invdigamma
-
-doc"""
-```rst
-..  getindex(type[, elements...])
-
-Construct a 1-d array of the specified type. This is usually called with the syntax ``Type[]``. Element values can be specified using ``Type[a,b,c,...]``.
-```
-"""
-getindex(::Type, elements...)
-
-doc"""
-```rst
-..  getindex(A, inds...)
-
-Returns a subset of array ``A`` as specified by ``inds``, where each ``ind`` may be an ``Int``, a ``Range``, or a ``Vector``. See the manual section on :ref:`array indexing <man-array-indexing>` for details.
-```
-"""
-getindex(::AbstractArray, inds...)
-
-doc"""
-```rst
-..  getindex(collection, key...)
-
-Retrieve the value(s) stored at the given key or index within a collection.
-The syntax ``a[i,j,...]`` is converted by the compiler to
-``getindex(a, i, j, ...)``.
-```
-"""
-getindex(collection, key...)
-
-doc"""
-    cconvert(T,x)
-
-Convert `x` to a value of type `T`, typically by calling `convert(T,x)`
-
-In cases where `x` cannot be safely converted to `T`, unlike `convert`, `cconvert` may return an object of a type different from `T`, which however is suitable for `unsafe_convert` to handle.
-
-Neither `convert` nor `cconvert` should take a Julia object and turn it into a `Ptr`.
-"""
-cconvert
-
-doc"""
-    |>(x, f)
-
-Applies a function to the preceding argument. This allows for easy function chaining.
-
-```jldoctest
-julia> [1:5;] |> x->x.^2 |> sum |> inv
-0.01818181818181818
-```
-"""
-Base.(:(|>))
-
-doc"""
-    assert(cond)
-
-Throw an `AssertionError` if `cond` is `false`. Also available as the macro `@assert expr`.
-"""
-assert
-
-doc"""
-    sech(x)
-
-Compute the hyperbolic secant of `x`
-"""
-sech
-
-doc"""
-    nworkers()
-
-Get the number of available worker processes. This is one less than `nprocs()`. Equal to `nprocs()` if `nprocs() == 1`.
-"""
-nworkers
-
-doc"""
-    filemode(file)
-
-Equivalent to `stat(file).mode`
-"""
-filemode
-
-doc"""
-    print_joined(io, items, delim, [last])
-
-Print elements of `items` to `io` with `delim` between them. If `last` is specified, it is used as the final delimiter instead of `delim`.
-"""
-print_joined
-
-doc"""
-    lfact(x)
-
-Compute the logarithmic factorial of `x`
-"""
-lfact
-
-doc"""
-    deconv(b,a)
-
-Construct vector `c` such that `b = conv(a,c) + r`. Equivalent to polynomial division.
-"""
-deconv
-
-doc"""
-    insert!(collection, index, item)
-
-Insert an `item` into `collection` at the given `index`.
-`index` is the index of `item` in the resulting `collection`.
-
-```jldoctest
-julia> insert!([6, 5, 4, 2, 1], 4, 3)
-6-element Array{Int64,1}:
- 6
- 5
- 4
- 3
- 2
- 1
-```
-"""
-insert!
-
-doc"""
-    repmat(A, n, m)
-
-Construct a matrix by repeating the given matrix `n` times in dimension 1 and `m` times in dimension 2.
-"""
-repmat
-
-doc"""
-    acos(x)
-
-Compute the inverse cosine of `x`, where the output is in radians
-"""
-acos
-
-doc"""
-    nzrange(A, col)
-
-Return the range of indices to the structural nonzero values of a sparse matrix column. In conjunction with `nonzeros(A)` and `rowvals(A)`, this allows for convenient iterating over a sparse matrix :
-
-    A = sparse(I,J,V)
-    rows = rowvals(A)
-    vals = nonzeros(A)
-    m, n = size(A)
-    for i = 1:n
-       for j in nzrange(A, i)
-          row = rows[j]
-          val = vals[j]
-          # perform sparse wizardry...
-       end
-    end
-"""
-nzrange
-
-doc"""
-    ispath(path) -> Bool
-
-Returns `true` if `path` is a valid filesystem path, `false` otherwise.
-"""
-ispath
-
-doc"""
-    fdio([name::AbstractString, ]fd::Integer[, own::Bool]) -> IOStream
-
-Create an `IOStream` object from an integer file descriptor. If `own` is `true`, closing this object will close the underlying descriptor. By default, an `IOStream` is closed when it is garbage collected. `name` allows you to associate the descriptor with a named file.
-"""
-fdio
-
-doc"""
-    unsafe_copy!(dest::Ptr{T}, src::Ptr{T}, N)
-
-Copy `N` elements from a source pointer to a destination, with no checking. The size of an element is determined by the type of the pointers.
-
-The `unsafe` prefix on this function indicates that no validation is performed on the pointers `dest` and `src` to ensure that they are valid. Incorrect usage may corrupt or segfault your program, in the same manner as C.
-"""
-unsafe_copy!{T}(dest::Ptr{T}, src::Ptr{T}, N)
-
-doc"""
-    unsafe_copy!(dest::Array, do, src::Array, so, N)
-
-Copy `N` elements from a source array to a destination, starting at offset `so` in the source and `do` in the destination (1-indexed).
-
-The `unsafe` prefix on this function indicates that no validation is performed to ensure that N is inbounds on either array. Incorrect usage may corrupt or segfault your program, in the same manner as C.
-"""
-unsafe_copy!(dest::Array, d, src::Array, so, N)
-
-doc"""
-    diag(M[, k])
-
-The `k`th diagonal of a matrix, as a vector. Use `diagm` to construct a diagonal matrix.
-"""
-diag
-
-doc"""
-    .^(x, y)
-
-Element-wise exponentiation operator.
-"""
-Base.(:(.^))
-
-doc"""
-    isspace(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is any whitespace character. Includes ASCII characters '\\t', '\\n', '\\v', '\\f', '\\r', and ' ', Latin-1 character U+0085, and characters in Unicode category Zs. For strings, tests whether this is true for all elements of the string.
-"""
-isspace
-
-doc"""
-    splitext(path::AbstractString) -> (AbstractString,AbstractString)
-
-If the last component of a path contains a dot, split the path into everything before the dot and everything including and after the dot. Otherwise, return a tuple of the argument unmodified and the empty string.
-"""
-splitext
-
-doc"""
-    gethostname() -> AbstractString
-
-Get the local machine's host name.
-"""
-gethostname
-
-doc"""
-    code_typed(f, types; optimize=true)
-
-Returns an array of lowered and type-inferred ASTs for the methods matching the given generic function and type signature. The keyword argument `optimize` controls whether additional optimizations, such as inlining, are also applied.
-"""
-code_typed
-
-doc"""
-    hankelh1x(nu, x)
-
-Scaled Bessel function of the third kind of order `nu`, $H^{(1)}_\nu(x) e^{-x i}$.
-"""
-hankelh1x
-
-doc"""
-    blkdiag(A...)
-
-Concatenate matrices block-diagonally. Currently only implemented for sparse matrices.
-"""
-blkdiag
-
-doc"""
-    replace(string, pat, r[, n])
-
-Search for the given pattern `pat`, and replace each occurrence with `r`. If `n` is provided, replace at most `n` occurrences. As with search, the second argument may be a single character, a vector or a set of characters, a string, or a regular expression. If `r` is a function, each occurrence is replaced with `r(s)` where `s` is the matched substring. If `pat` is a regular expression and `r` is a `SubstitutionString`, then capture group references in `r` are replaced with the corresponding matched text.
-"""
-replace
-
-doc"""
-    randexp([rng], [dims...])
-
-Generate a random number according to the exponential distribution with scale 1. Optionally generate an array of such random numbers.
-"""
-randexp
-
-doc"""
-    chop(string)
-
-Remove the last character from a string.
-"""
-chop
-
-doc"""
-    Float32(x [, mode::RoundingMode])
-
-Create a Float32 from `x`. If `x` is not exactly representable then
-`mode` determines how `x` is rounded.
-
-```jldoctest
-julia> Float32(1/3, RoundDown)
-0.3333333f0
-
-julia> Float32(1/3, RoundUp)
-0.33333334f0
-```
-
-See `get_rounding` for available rounding modes.
-"""
-Float32
-
-doc"""
-    readuntil(stream, delim)
-
-Read a string, up to and including the given delimiter byte.
-"""
-readuntil
-
-doc"""
-```rst
-..  isimmutable(v)
-
-Return ``true`` iff value ``v`` is immutable.  See :ref:`man-immutable-composite-types` for a discussion of immutability.
-Note that this function works on values, so if you give it a type, it will tell you that a value of ``DataType`` is mutable.
-```
-"""
-isimmutable
-
-doc"""
-    macroexpand(x)
-
-Takes the expression `x` and returns an equivalent expression with all macros removed (expanded).
-"""
-macroexpand
-
-doc"""
-    issticky(path) -> Bool
-
-Returns `true` if `path` has the sticky bit set, `false` otherwise.
-"""
-issticky
-
-doc"""
-    rol(B::BitArray{1}, i::Integer) -> BitArray{1}
-
-Performs a left rotation operation.
-"""
-rol
-
-doc"""
-```rst
-..  Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)
-           Mmap.mmap(type::Type{Array{T,N}}, dims)
-
-Create an ``Array`` whose values are linked to a file, using memory-mapping. This provides a convenient way of working with data too large to fit in the computer's memory.
-
-The type is an ``Array{T,N}`` with a bits-type element of ``T`` and dimension ``N`` that determines how the bytes of the array are interpreted. Note that the file must be stored in binary format, and no format conversions are possible (this is a limitation of operating systems, not Julia).
-
-``dims`` is a tuple or single ``Integer`` specifying the size or length of the array.
-
-The file is passed via the stream argument, either as an open ``IOStream`` or filename string.  When you initialize the stream, use ``"r"`` for a "read-only" array, and ``"w+"`` to create a new array used to write values to disk.
-
-If no ``type`` argument is specified, the default is ``Vector{UInt8}``.
-
-Optionally, you can specify an offset (in bytes) if, for example, you want to skip over a header in the file. The default value for the offset is the current stream position for an ``IOStream``.
-
-The ``grow`` keyword argument specifies whether the disk file should be grown to accomodate the requested size of array (if the total file size is < requested array size). Write privileges are required to grow the file.
-
-The ``shared`` keyword argument specifies whether the resulting ``Array`` and changes made to it will be visible to other processes mapping the same file.
-
-For example, the following code::
-
-   # Create a file for mmapping
-   # (you could alternatively use mmap to do this step, too)
-   A = rand(1:20, 5, 30)
-   s = open("/tmp/mmap.bin", "w+")
-   # We'll write the dimensions of the array as the first two Ints in the file
-   write(s, size(A,1))
-   write(s, size(A,2))
-   # Now write the data
-   write(s, A)
-   close(s)
-
-   # Test by reading it back in
-   s = open("/tmp/mmap.bin")   # default is read-only
-   m = read(s, Int)
-   n = read(s, Int)
-   A2 = Mmap.mmap(s, Matrix{Int}, (m,n))
-
-creates a ``m``-by-``n`` ``Matrix{Int}``, linked to the file associated with stream ``s``.
-
-A more portable file would need to encode the word size---32 bit or 64 bit---and endianness information in the header. In practice, consider encoding binary data using standard formats like HDF5 (which can be used with memory-mapping).
-```
-"""
-Mmap.mmap(io, ::Type, dims, offset)
-
-doc"""
-```rst
-..  Mmap.mmap(io, BitArray, [dims, offset])
-
-Create a ``BitArray`` whose values are linked to a file, using memory-mapping; it has the same purpose, works in the same way, and has the same arguments, as :func:`mmap`, but the byte representation is different.
-
-**Example**:  ``B = Mmap.mmap(s, BitArray, (25,30000))``
-
-This would create a 25-by-30000 ``BitArray``, linked to the file associated with stream ``s``.
-```
-"""
-Mmap.mmap(io, ::BitArray, dims = ?, offset = ?)
-
-doc"""
-    airyprime(x)
-
-Airy function derivative $\operatorname{Ai}'(x)$.
-"""
-airyprime
-
-doc"""
-    bessely0(x)
-
-Bessel function of the second kind of order 0, $Y_0(x)$.
-"""
-bessely0
-
-doc"""
-    any!(r, A)
-
-Test whether any values in `A` along the singleton dimensions of `r` are `true`, and write results to `r`.
-"""
-any!
-
-doc"""
-    falses(dims)
-
-Create a `BitArray` with all values set to `false`
-"""
-falses
-
-doc"""
-    filter!(function, collection)
-
-Update `collection`, removing elements for which `function` is `false`. For associative collections, the function is passed two arguments (key and value).
-"""
-filter!
-
-doc"""
-    schurfact(A) -> Schur
-
-Computes the Schur factorization of the matrix `A`. The (quasi) triangular Schur factor can be obtained from the `Schur` object `F` with either `F[:Schur]` or `F[:T]` and the unitary/orthogonal Schur vectors can be obtained with `F[:vectors]` or `F[:Z]` such that `A=F[:vectors]*F[:Schur]*F[:vectors]'`. The eigenvalues of `A` can be obtained with `F[:values]`.
-"""
-schurfact(A)
-
-doc"""
-    schurfact(A, B) -> GeneralizedSchur
-
-Computes the Generalized Schur (or QZ) factorization of the matrices `A` and `B`. The (quasi) triangular Schur factors can be obtained from the `Schur` object `F` with `F[:S]` and `F[:T]`, the left unitary/orthogonal Schur vectors can be obtained with `F[:left]` or `F[:Q]` and the right unitary/orthogonal Schur vectors can be obtained with `F[:right]` or `F[:Z]` such that `A=F[:left]*F[:S]*F[:right]'` and `B=F[:left]*F[:T]*F[:right]'`. The generalized eigenvalues of `A` and `B` can be obtained with `F[:alpha]./F[:beta]`.
-"""
-schurfact(A, B)
-
-doc"""
-    base64decode(string)
-
-Decodes the base64-encoded `string` and returns a `Vector{UInt8}` of the decoded bytes.
-"""
-base64decode
-
-doc"""
-    besselkx(nu, x)
-
-Scaled modified Bessel function of the second kind of order `nu`, $K_\nu(x) e^x$.
-"""
-besselkx
-
-doc"""
-    myid()
-
-Get the id of the current process.
-"""
-myid
-
-doc"""
-    oct(n, [pad])
-
-Convert an integer to an octal string, optionally specifying a number of digits to pad to.
-"""
-oct
-
-doc"""
-    timedwait(testcb::Function, secs::Float64; pollint::Float64=0.1)
-
-Waits till `testcb` returns `true` or for `secs` seconds, whichever is earlier. `testcb` is polled every `pollint` seconds.
-"""
-timedwait
-
-doc"""
-    sizeof(T)
-
-Size, in bytes, of the canonical binary representation of the given DataType `T`, if any.
-"""
-sizeof(::Type)
-
-doc"""
-    sizeof(s::AbstractString)
-
-The number of bytes in string `s`.
-"""
-sizeof(::AbstractString)
-
-doc"""
-```rst
-..  ===(x, y)
-           ≡(x,y)
-
-See the :func:`is` operator
-```
-"""
-Base.(:(===))
-
-doc"""
-    ReadOnlyMemoryError()
-
-An operation tried to write to memory that is read-only.
-"""
-ReadOnlyMemoryError
-
-doc"""
-    startswith(string, prefix | chars)
-
-Returns `true` if `string` starts with `prefix`. If the second argument is a vector or set of characters, tests whether the first character of `string` belongs to that set.
-"""
-startswith
-
-doc"""
-    permutedims!(dest, src, perm)
-
-Permute the dimensions of array `src` and store the result in the array `dest`. `perm` is a vector specifying a permutation of length `ndims(src)`. The preallocated array `dest` should have `size(dest) == size(src)[perm]` and is completely overwritten. No in-place permutation is supported and unexpected results will happen if `src` and `dest` have overlapping memory regions.
-"""
-permutedims!
-
-doc"""
-    functionloc(f::Function, types)
-
-Returns a tuple `(filename,line)` giving the location of a generic `Function` definition.
-"""
-functionloc(f, types)
-
-doc"""
-    functionloc(m::Method)
-
-Returns a tuple `(filename,line)` giving the location of a `Method` definition.
-"""
-functionloc(m)
-
-doc"""
-    stride(A, k)
-
-Returns the distance in memory (in number of elements) between adjacent elements in dimension `k`.
-"""
-stride
-
-doc"""
-```rst
-..  last(coll)
-
-Get the last element of an ordered collection, if it can be computed in O(1) time.
-This is accomplished by calling :func:`endof` to get the last index.
-Returns the end point of a :obj:`Range` even if it is empty.
-```
-"""
-last
-
-doc"""
-    islink(path) -> Bool
-
-Returns `true` if `path` is a symbolic link, `false` otherwise.
-"""
-islink
-
-doc"""
-    istril(A) -> Bool
-
-Test whether a matrix is lower triangular.
-"""
-istril
-
-doc"""
-```rst
-..  lgamma(x)
-
-Compute the logarithm of the absolute value of :func:`gamma` for
-:obj:`Real` ``x``, while for :obj:`Complex` ``x`` it computes the
-logarithm of ``gamma(x)``.
-```
-"""
-lgamma
-
-doc"""
-    bin(n, [pad])
-
-Convert an integer to a binary string, optionally specifying a number of digits to pad to.
-"""
-bin
-
-doc"""
-    cis(z)
-
-Return $\exp(iz)$.
-"""
-cis
-
-doc"""
-    isapprox(x, y; rtol::Real=sqrt(eps), atol::Real=0)
-
-Inexact equality comparison: `true` if `norm(x-y) <= atol + rtol*max(norm(x), norm(y))`. The default `atol` is zero and the default `rtol` depends on the types of `x` and `y`.
-
-For real or complex floating-point values, `rtol` defaults to `sqrt(eps(typeof(real(x-y))))`. This corresponds to requiring equality of about half of the significand digits. For other types, `rtol` defaults to zero.
-
-`x` and `y` may also be arrays of numbers, in which case `norm` defaults to `vecnorm` but may be changed by passing a `norm::Function` keyword argument. (For numbers, `norm` is the same thing as `abs`.)
-
-The binary operator `≈` is equivalent to `isapprox` with the default arguments, and `x ≉ y` is equivalent to `!isapprox(x,y)`.
-"""
-isapprox
-
-doc"""
-    primes([lo,] hi)
-
-Returns a collection of the prime numbers (from `lo`, if specified) up to `hi`.
-"""
-primes
-
-doc"""
-    primesmask([lo,] hi)
-
-Returns a prime sieve, as a `BitArray`, of the positive integers (from `lo`, if specified) up to `hi`. Useful when working with either primes or composite numbers.
-"""
-primesmask
-
-doc"""
-    sinh(x)
-
-Compute hyperbolic sine of `x`
-"""
-sinh
-
-doc"""
-    permutations(array)
-
-Generate all permutations of an indexable object. Because the number of permutations can be very large, this function returns an iterator object. Use `collect(permutations(array))` to get an array of all permutations.
-"""
-permutations
-
-doc"""
-```rst
-..  ceil([T,] x, [digits, [base]])
-
-``ceil(x)`` returns the nearest integral value of the same type as ``x``
-that is greater than or equal to ``x``.
-
-``ceil(T, x)`` converts the result to type ``T``, throwing an
-``InexactError`` if the value is not representable.
-
-``digits`` and ``base`` work as for :func:`round`.
-```
-"""
-ceil
-
-doc"""
-    mapslices(f, A, dims)
-
-Transform the given dimensions of array `A` using function `f`. `f` is called on each slice of `A` of the form `A[...,:,...,:,...]`. `dims` is an integer vector specifying where the colons go in this expression. The results are concatenated along the remaining dimensions. For example, if `dims` is `[1,2]` and `A` is 4-dimensional, `f` is called on `A[:,:,i,j]` for all `i` and `j`.
-"""
-mapslices
-
-doc"""
-    spdiagm(B, d[, m, n])
-
-Construct a sparse diagonal matrix. `B` is a tuple of vectors containing the diagonals and `d` is a tuple containing the positions of the diagonals. In the case the input contains only one diagonaly, `B` can be a vector (instead of a tuple) and `d` can be the diagonal position (instead of a tuple), defaulting to 0 (diagonal). Optionally, `m` and `n` specify the size of the resulting sparse matrix.
-"""
-spdiagm
-
-doc"""
-    svdvals(A)
-
-Returns the singular values of `A`.
-"""
-svdvals(A)
-
-doc"""
-    svdvals(A, B)
-
-Return only the singular values from the generalized singular value decomposition of `A` and `B`.
-"""
-svdvals(A, B)
-
-doc"""
-    issocket(path) -> Bool
-
-Returns `true` if `path` is a socket, `false` otherwise.
-"""
-issocket
-
-doc"""
-    srand([rng], [seed])
-
-Reseed the random number generator. If a `seed` is provided, the RNG will give a reproducible sequence of numbers, otherwise Julia will get entropy from the system. For `MersenneTwister`, the `seed` may be a non-negative integer, a vector of `UInt32` integers or a filename, in which case the seed is read from a file. `RandomDevice` does not support seeding.
-"""
-srand
-
-doc"""
-```rst
-..  schur(A) -> Schur[:T], Schur[:Z], Schur[:values]
-
-See :func:`schurfact`
-```
-"""
-schur(A)
-
-doc"""
-```rst
-..  schur(A,B) -> GeneralizedSchur[:S], GeneralizedSchur[:T], GeneralizedSchur[:Q], GeneralizedSchur[:Z]
-
-See :func:`schurfact`
-```
-"""
-schur(A,B)
-
-doc"""
-    isexecutable(path) -> Bool
-
-Returns `true` if the current user has permission to execute `path`, `false` otherwise.
-"""
-isexecutable
-
-doc"""
-    acot(x)
-
-Compute the inverse cotangent of `x`, where the output is in radians
-"""
-acot
-
-doc"""
-    oftype(x, y)
-
-Convert `y` to the type of `x` (`convert(typeof(x), y)`).
-"""
-oftype
-
-doc"""
-    maxabs!(r, A)
-
-Compute the maximum absolute values over the singleton dimensions of `r`, and write values to `r`.
-"""
-maxabs!
-
-doc"""
-    nullspace(M)
-
-Basis for nullspace of `M`.
-"""
-nullspace
-
-doc"""
-    isfinite(f) -> Bool
-
-Test whether a number is finite
-"""
-isfinite
-
-doc"""
-```rst
-..  push!(collection, items...) -> collection
-
-Insert one or more ``items`` at the end of ``collection``.
-
-.. doctest::
-
-  julia> push!([1, 2, 3], 4, 5, 6)
-  6-element Array{Int64,1}:
-   1
-   2
-   3
-   4
-   5
-   6
-
-Use :func:`append!` to add all the elements of another collection to
-``collection``.
-The result of the preceding example is equivalent to
-``append!([1, 2, 3], [4, 5, 6])``.
-```
-"""
-push!
-
-doc"""
-    prevpow(a, x)
-
-The largest `a^n` not greater than `x`, where `n` is a non-negative integer. `a` must be greater than 1, and `x` must not be less than 1.
-"""
-prevpow
-
-doc"""
-    indexin(a, b)
-
-Returns a vector containing the highest index in `b` for each value in `a` that is a member of `b` . The output vector contains 0 wherever `a` is not a member of `b`.
-"""
-indexin
-
-doc"""
-    permutedims(A, perm)
-
-Permute the dimensions of array `A`. `perm` is a vector specifying a permutation of length `ndims(A)`. This is a generalization of transpose for multi-dimensional arrays. Transpose is equivalent to `permutedims(A, [2,1])`.
-"""
-permutedims
-
-doc"""
-```rst
-..  shuffle!([rng,] v)
-
-In-place version of :func:`shuffle`.
-```
-"""
-shuffle!
-
-doc"""
-    fldmod(x, y)
-
-The floored quotient and modulus after division. Equivalent to `(fld(x,y), mod(x,y))`.
-"""
-fldmod
-
-doc"""
-    promote(xs...)
-
-Convert all arguments to their common promotion type (if any), and return them all (as a tuple).
-"""
-promote
-
-doc"""
-    @schedule
-
-Wrap an expression in a `Task` and add it to the scheduler's queue.
-"""
-:@schedule
-
-doc"""
-    bessely(nu, x)
-
-Bessel function of the second kind of order `nu`, $Y_\nu(x)$.
-"""
-bessely
-
-doc"""
-    gradient(F, [h])
-
-Compute differences along vector `F`, using `h` as the spacing between points. The default spacing is one.
-"""
-gradient
-
-doc"""
-    tan(x)
-
-Compute tangent of `x`, where `x` is in radians
-"""
-tan
-
-doc"""
-    sprint(f::Function, args...)
-
-Call the given function with an I/O stream and the supplied extra arguments. Everything written to this I/O stream is returned as a string.
-"""
-sprint
-
-doc"""
-    fd(stream)
-
-Returns the file descriptor backing the stream or file. Note that this function only applies to synchronous `File`'s and `IOStream`'s not to any of the asynchronous streams.
-"""
-fd
-
-doc"""
-    require(module::Symbol)
-
-This function is part of the implementation of `using` / `import`, if a module is not already defined in `Main`. It can also be called directly to force reloading a module, regardless of whether it has been loaded before (for example, when interactively developing libraries).
-
-Loads a source files, in the context of the `Main` module, on every active node, searching standard locations for files. `require` is considered a top-level operation, so it sets the current `include` path but does not use it to search for files (see help for `include`). This function is typically used to load library code, and is implicitly called by `using` to load packages.
-
-When searching for files, `require` first looks in the current working directory, then looks for package code under `Pkg.dir()`, then tries paths in the global array `LOAD_PATH`.
-"""
-require
-
-doc"""
-    expand(x)
-
-Takes the expression `x` and returns an equivalent expression in lowered form.
-"""
-expand
-
-doc"""
-```rst
-..  peakflops(n; parallel=false)
-
-``peakflops`` computes the peak flop rate of the computer by using double precision :func:`Base.LinAlg.BLAS.gemm!`. By default, if no arguments are specified, it multiplies a matrix of size ``n x n``, where ``n = 2000``. If the underlying BLAS is using multiple threads, higher flop rates are realized. The number of BLAS threads can be set with ``blas_set_num_threads(n)``.
-
-If the keyword argument ``parallel`` is set to ``true``, ``peakflops`` is run in parallel on all the worker processors. The flop rate of the entire parallel computer is returned. When running in parallel, only 1 BLAS thread is used. The argument ``n`` still refers to the size of the problem that is solved on each processor.
-```
-"""
-peakflops
-
-doc"""
-    svd(A, [thin=true]) -> U, S, V
-
-Wrapper around `svdfact` extracting all parts the factorization to a tuple. Direct use of `svdfact` is therefore generally more efficient. Computes the SVD of `A`, returning `U`, vector `S`, and `V` such that `A == U*diagm(S)*V'`. If `thin` is `true`, an economy mode decomposition is returned. The default is to produce a thin decomposition.
-"""
-svd
-
-doc"""
-    svd(A, B) -> U, V, Q, D1, D2, R0
-
-Wrapper around `svdfact` extracting all parts the factorization to a tuple. Direct use of `svdfact` is therefore generally more efficient. The function returns the generalized SVD of `A` and `B`, returning `U`, `V`, `Q`, `D1`, `D2`, and `R0` such that `A = U*D1*R0*Q'` and `B = V*D2*R0*Q'`.
-"""
-svd(A::AbstractMatrix, B::AbstractMatrix)
-
-doc"""
-    ones(type, dims)
-
-Create an array of all ones of specified type. The type defaults to `Float64` if not specified.
-"""
-ones(t,dims)
-
-doc"""
-    ones(A)
-
-Create an array of all ones with the same element type and shape as `A`.
-"""
-ones(A)
-
-doc"""
-    ind2chr(string, i)
-
-Convert a byte index to a character index.
-"""
-ind2chr
-
-doc"""
-    reshape(A, dims)
-
-Create an array with the same data as the given array, but with different dimensions. An implementation for a particular type of array may choose whether the data is copied or shared.
-"""
-reshape
-
-doc"""
-    randsubseq!(S, A, p)
-
-Like `randsubseq`, but the results are stored in `S` (which is resized as needed).
-"""
-randsubseq!
-
-doc"""
-    maximum(itr)
-
-Returns the largest element in a collection.
-"""
-maximum(itr)
-
-doc"""
-    maximum(A, dims)
-
-Compute the maximum value of an array over the given dimensions.
-"""
-maximum(A,dims)
-
-doc"""
-    redisplay(x)
-    redisplay(d::Display, x)
-    redisplay(mime, x)
-    redisplay(d::Display, mime, x)
-
-By default, the `redisplay` functions simply call `display`. However, some display backends may override `redisplay` to modify an existing display of `x` (if any). Using `redisplay` is also a hint to the backend that `x` may be redisplayed several times, and the backend may choose to defer the display until (for example) the next interactive prompt.
-"""
-redisplay
-
-doc"""
-    A_mul_Bc(A, B)
-
-For matrices or vectors `A` and `B`, calculates `A Bᴴ`
-"""
-A_mul_Bc
-
-doc"""
-    searchsorted(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Returns the range of indices of `a` which compare as equal to `x` according to the order specified by the `by`, `lt` and `rev` keywords, assuming that `a` is already sorted in that order. Returns an empty range located at the insertion point if `a` does not contain values equal to `x`.
-"""
-searchsorted
-
-doc"""
-    /(x, y)
-
-Right division operator: multiplication of `x` by the inverse of `y` on the right. Gives floating-point results for integer arguments.
-"""
-Base.(:(/))
-
-doc"""
-    ldltfact(::Union{SparseMatrixCSC,Symmetric{Float64,SparseMatrixCSC{Flaot64,SuiteSparse_long}},Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},SuiteSparse_long}}}; shift=0, perm=Int[]) -> CHOLMOD.Factor
-
-Compute the `LDLt` factorization of a sparse symmetric or Hermitian matrix. A fill-reducing permutation is used. `F = ldltfact(A)` is most frequently used to solve systems of equations `A*x = b` with `F\b`, but also the methods `diag`, `det`, `logdet` are defined for `F`. You can also extract individual factors from `F`, using `F[:L]`. However, since pivoting is on by default, the factorization is internally represented as `A == P'*L*D*L'*P` with a permutation matrix `P`; using just `L` without accounting for `P` will give incorrect answers. To include the effects of permutation, it's typically preferable to extact "combined" factors like `PtL = F[:PtL]` (the equivalent of `P'*L`) and `LtP = F[:UP]` (the equivalent of `L'*P`). The complete list of supported factors is `:L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP`.
-
-Setting optional `shift` keyword argument computes the factorization of `A+shift*I` instead of `A`. If the `perm` argument is nonempty, it should be a permutation of `1:size(A,1)` giving the ordering to use (instead of CHOLMOD's default AMD ordering).
-
-The function calls the C library CHOLMOD and many other functions from the library are wrapped but not exported.
-"""
-ldltfact(A::SparseMatrixCSC; shift=0, perm=Int[])
-
-doc"""
-    connect([host],port) -> TcpSocket
-
-Connect to the host `host` on port `port`
-"""
-connect(host=?, port)
-
-doc"""
-    connect(path) -> PipeEndpoint
-
-Connect to the Named Pipe / Domain Socket at ``path``
-"""
-connect(path)
-
-doc"""
-    connect(manager::FooManager, pid::Int, config::WorkerConfig) -> (instrm::AsyncStream, outstrm::AsyncStream)
-
-Implemented by cluster managers using custom transports. It should establish a logical connection to worker with id `pid`, specified by `config` and return a pair of `AsyncStream` objects. Messages from `pid` to current process will be read off `instrm`, while messages to be sent to `pid` will be written to `outstrm`. The custom transport implementation must ensure that messages are delivered and received completely and in order. `Base.connect(manager::ClusterManager.....)` sets up TCP/IP socket connections in-between workers.
-"""
-connect(manager, pid::Int, config::WorkerConfig)
-
-doc"""
-    mean(v[, region])
-
-Compute the mean of whole array `v`, or optionally along the dimensions in `region`. Note: Julia does not ignore `NaN` values in the computation. For applications requiring the handling of missing data, the `DataArray` package is recommended.
-"""
-mean
-
-doc"""
-    split(string, [chars]; limit=0, keep=true)
-
-Return an array of substrings by splitting the given string on occurrences of the given character delimiters, which may be specified in any of the formats allowed by `search`'s second argument (i.e. a single character, collection of characters, string, or regular expression). If `chars` is omitted, it defaults to the set of all space characters, and `keep` is taken to be `false`. The two keyword arguments are optional: they are are a maximum size for the result and a flag determining whether empty fields should be kept in the result.
-"""
-split
-
-doc"""
-    dump(x)
-
-Show all user-visible structure of a value.
-"""
-dump
-
-doc"""
-    sumabs(itr)
-
-Sum absolute values of all elements in a collection. This is equivalent to `sum(abs(itr))` but faster.
-"""
-sumabs(itr)
-
-doc"""
-    sumabs(A, dims)
-
-Sum absolute values of elements of an array over the given dimensions.
-"""
-sumabs(A, dims)
-
-doc"""
-    svdvals!(A)
-
-Returns the singular values of `A`, while saving space by overwriting the input.
-"""
-svdvals!
-
-doc"""
-    consume(task, values...)
-
-Receive the next value passed to `produce` by the specified task. Additional arguments may be passed, to be returned from the last `produce` call in the producer.
-"""
-consume
-
-doc"""
-    hankelh2x(nu, x)
-
-Scaled Bessel function of the third kind of order `nu`, $H^{(2)}_\nu(x) e^{x i}$.
-"""
-hankelh2x
-
-doc"""
-    ndigits(n, b)
-
-Compute the number of digits in number `n` written in base `b`.
-"""
-ndigits
-
-doc"""
-    cummax(A, [dim])
-
-Cumulative maximum along a dimension. The dimension defaults to 1.
-"""
-cummax
-
-doc"""
-    watch_file(path, timeout_s::Real)
-
-Watch file or directory `path` for changes until a change occurs or `timeout_s` seconds have elapsed.
-
-The returned value is an object with boolean fields `changed`, `renamed`, and `timedout`, giving the result of watching the file.
-
-This behavior of this function varies slightly across platforms. See <https://nodejs.org/api/fs.html#fs_caveats> for more detailed information.
-"""
-watch_file
-
-doc"""
-    At_rdiv_Bt(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᵀ / Bᵀ`
-"""
-At_rdiv_Bt
-
-doc"""
-    isinteractive() -> Bool
-
-Determine whether Julia is running an interactive session.
-"""
-isinteractive
-
-doc"""
-    At_mul_Bt(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᵀ Bᵀ`
-"""
-At_mul_Bt
-
-doc"""
-    sum!(r, A)
-
-Sum elements of `A` over the singleton dimensions of `r`, and write results to `r`.
-"""
-sum!
-
-doc"""
-    close(stream)
-
-Close an I/O stream. Performs a `flush` first.
-"""
-close(stream::IO)
-
-doc"""
-    close(Channel)
-
-Closes a channel. An exception is thrown by:
-
-* `put!` on a closed channel.
-* `take!` and `fetch` on an empty, closed channel.
-"""
-close(::Channel)
-
-doc"""
-    cospi(x)
-
-Compute $\cos(\pi x)$ more accurately than `cos(pi*x)`, especially for large `x`.
-"""
-cospi
-
-doc"""
-    parentindexes(A)
-
-From an array view `A`, returns the corresponding indexes in the parent
-"""
-parentindexes
-
-doc"""
-    spones(S)
-
-Create a sparse matrix with the same structure as that of `S`, but with every nonzero element having the value `1.0`.
-"""
-spones
-
-doc"""
-    display(x)
-    display(d::Display, x)
-    display(mime, x)
-    display(d::Display, mime, x)
-
-Display `x` using the topmost applicable display in the display stack, typically using the richest supported multimedia output for `x`, with plain-text `STDOUT` output as a fallback. The `display(d, x)` variant attempts to display `x` on the given display `d` only, throwing a `MethodError` if `d` cannot display objects of this type.
-
-There are also two variants with a `mime` argument (a MIME type string, such as `"image/png"`), which attempt to display `x` using the requested MIME type *only*, throwing a `MethodError` if this type is not supported by either the display(s) or by `x`. With these variants, one can also supply the "raw" data in the requested MIME type by passing `x::AbstractString` (for MIME types with text-based storage, such as text/html or application/postscript) or `x::Vector{UInt8}` (for binary MIME types).
-"""
-display
-
-doc"""
-    @spawnat
-
-Accepts two arguments, `p` and an expression. A closure is created around the expression and run asynchronously on process `p`. Returns a `RemoteRef` to the result.
-"""
-:@spawnat
-
-doc"""
-    print_shortest(io, x)
-
-Print the shortest possible representation, with the minimum number of consecutive non-zero digits, of number `x`, ensuring that it would parse to the exact same number.
-"""
-print_shortest
-
-doc"""
-    merge(collection, others...)
-
-Construct a merged collection from the given collections. If necessary, the
-types of the resulting collection will be promoted to accommodate the types of
-the merged collections. If the same key is present in another collection, the
-value for that key will be the value it has in the last collection listed.
-
-```jldoctest
-julia> a = Dict("foo" => 0.0, "bar" => 42.0)
-Dict{ASCIIString,Float64} with 2 entries:
-  "bar" => 42.0
-  "foo" => 0.0
-
-julia> b = Dict(utf8("baz") => 17, utf8("bar") => 4711)
-Dict{UTF8String,Int64} with 2 entries:
-  "bar" => 4711
-  "baz" => 17
-
-julia> merge(a, b)
-Dict{UTF8String,Float64} with 3 entries:
-  "bar" => 4711.0
-  "baz" => 17.0
-  "foo" => 0.0
-
-julia> merge(b, a)
-Dict{UTF8String,Float64} with 3 entries:
-  "bar" => 42.0
-  "baz" => 17.0
-  "foo" => 0.0
-```
-"""
-merge
-
-doc"""
-    circshift(A,shifts)
-
-Circularly shift the data in an array. The second argument is a vector giving the amount to shift in each dimension.
-"""
-circshift
-
-doc"""
-    fieldnames(x::DataType)
-
-Get an array of the fields of a `DataType`.
-"""
-fieldnames
-
-doc"""
-    yield()
-
-Switch to the scheduler to allow another scheduled task to run. A task that calls this function is still runnable, and will be restarted immediately if there are no other runnable tasks.
-"""
-yield
-
-doc"""
-    transpose!(dest,src)
-
-Transpose array `src` and store the result in the preallocated array `dest`, which should have a size corresponding to `(size(src,2),size(src,1))`. No in-place transposition is supported and unexpected results will happen if `src` and `dest` have overlapping memory regions.
-"""
-transpose!
-
-doc"""
-    isconst([m::Module], s::Symbol) -> Bool
-
-Determine whether a global is declared `const` in a given `Module`. The default `Module` argument is `current_module()`.
-"""
-isconst
-
-doc"""
-```rst
-..  open(command, mode::AbstractString="r", stdio=DevNull)
-
-Start running ``command`` asynchronously, and return a tuple
-``(stream,process)``.  If ``mode`` is ``"r"``, then ``stream``
-reads from the process's standard output and ``stdio`` optionally
-specifies the process's standard input stream.  If ``mode`` is
-``"w"``, then ``stream`` writes to the process's standard input
-and ``stdio`` optionally specifies the process's standard output
-stream.
-```
-"""
-open(command::Cmd, mod::AbstractString="r", stdio=DevNull)
-
-doc"""
-```rst
-..  open(f::Function, command, mode::AbstractString="r", stdio=DevNull)
-
-Similar to ``open(command, mode, stdio)``, but calls ``f(stream)``
-on the resulting read or write stream, then closes the stream
-and waits for the process to complete.  Returns the value returned
-by ``f``.
-```
-"""
-open(f::Function, command::Cmd, mod::AbstractString="r", stdio=DevNull)
-
-doc"""
-```rst
-..  open(file_name, [read, write, create, truncate, append]) -> IOStream
-
-Open a file in a mode specified by five boolean arguments. The default is to open files for reading only. Returns a stream for accessing the file.
-```
-"""
-open(file_name, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool)
-
-doc"""
-```rst
-..  open(file_name, [mode]) -> IOStream
-
-Alternate syntax for open, where a string-based mode specifier is used instead of the five booleans. The values of ``mode`` correspond to those from ``fopen(3)`` or Perl ``open``, and are equivalent to setting the following boolean groups:
-
-==== =================================
- r    read
- r+   read, write
- w    write, create, truncate
- w+   read, write, create, truncate
- a    write, create, append
- a+   read, write, create, append
-==== =================================
-
-```
-"""
-open(file_name, mode="r")
-
-doc"""
-    open(f::Function, args...)
-
-Apply the function `f` to the result of `open(args...)`
-and close the resulting file descriptor upon completion.
-
-**Example**: `open(readall, "file.txt")`
-"""
-open(f::Function, args...)
-
-doc"""
-    sort(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Variant of `sort!` that returns a sorted copy of `v` leaving `v` itself unmodified.
-"""
-sort(v,?,?,?,?)
-
-"""
-    sort(A, dim, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Sort a multidimensional array `A` along the given dimension.
-"""
-sort(A,dim,?,?,?,?)
-
-doc"""
-    kron(A, B)
-
-Kronecker tensor product of two vectors or two matrices.
-"""
-kron
-
-doc"""
-    >>(x, n)
-
-Right bit shift operator, preserving the sign of `x`.
-"""
-Base.(:(>>))
-
-doc"""
-    fieldoffsets(type)
-
-The byte offset of each field of a type relative to the data start. For example, we could use it
-in the following manner to summarize information about a struct type:
-
-```jldoctest
-julia> structinfo(T) = [zip(fieldoffsets(T),fieldnames(T),T.types)...];
-
-julia> structinfo(StatStruct)
-12-element Array{Tuple{Int64,Symbol,DataType},1}:
- (0,:device,UInt64)
- (8,:inode,UInt64)
- (16,:mode,UInt64)
- (24,:nlink,Int64)
- (32,:uid,UInt64)
- (40,:gid,UInt64)
- (48,:rdev,UInt64)
- (56,:size,Int64)
- (64,:blksize,Int64)
- (72,:blocks,Int64)
- (80,:mtime,Float64)
- (88,:ctime,Float64)
-```
-"""
-fieldoffsets
-
-doc"""
-```rst
-..  fft!(A [, dims])
-
-Same as :func:`fft`, but operates in-place on ``A``,
-which must be an array of complex floating-point numbers.
-```
-"""
-fft!
-
-doc"""
-    randn([rng], [dims...])
-
-Generate a normally-distributed random number with mean 0 and standard deviation 1. Optionally generate an array of normally-distributed random numbers.
-"""
-randn
-
-doc"""
-    process_exited(p::Process)
-
-Determine whether a process has exited.
-"""
-process_exited
-
-doc"""
-    tuple(xs...)
-
-Construct a tuple of the given objects.
-"""
-tuple
-
-doc"""
-    besseli(nu, x)
-
-Modified Bessel function of the first kind of order `nu`, $I_\nu(x)$.
-"""
-besseli
-
-doc"""
-    ifftshift(x, [dim])
-
-Undoes the effect of `fftshift`.
-"""
-ifftshift
-
-doc"""
-    eachmatch(r::Regex, s::AbstractString[, overlap::Bool=false])
-
-Search for all matches of a the regular expression `r` in `s` and return a iterator over the matches. If overlap is `true`, the matching sequences are allowed to overlap indices in the original string, otherwise they must be from distinct character ranges.
-"""
-eachmatch
-
-doc"""
-    log10(x)
-
-Compute the logarithm of `x` to base 10. Throws `DomainError` for negative `Real` arguments.
-"""
-log10
-
-doc"""
-    @profile
-
-`@profile <expression>` runs your expression while taking periodic backtraces. These are appended to an internal buffer of backtraces.
-"""
-:@profile
-
-doc"""
-    extrema(itr)
-
-Compute both the minimum and maximum element in a single pass, and return them as a 2-tuple.
-"""
-extrema
-
-doc"""
-    isdigit(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is a numeric digit (0-9), or whether this is true for all elements of a string.
-"""
-isdigit
-
-doc"""
-    @windows
-
-Given `@windows? a : b`, do `a` on Windows and `b` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
-"""
-:@windows
-
-doc"""
-    @unix
-
-Given `@unix? a : b`, do `a` on Unix systems (including Linux and OS X) and `b` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
-"""
-:@unix
-
-doc"""
-    num2hex(f)
-
-Get a hexadecimal string of the binary representation of a floating point number
-"""
-num2hex
-
-doc"""
-    speye(type,m[,n])
-
-Create a sparse identity matrix of specified type of size `m x m`. In case `n` is supplied, create a sparse identity matrix of size `m x n`.
-"""
-speye
-
-doc"""
-    count_ones(x::Integer) -> Integer
-
-Number of ones in the binary representation of `x`.
-
-```jldoctest
-julia> count_ones(7)
-3
-```
-"""
-count_ones
-
-doc"""
-    reim(z)
-
-Return both the real and imaginary parts of the complex number `z`
-"""
-reim
-
-doc"""
-    displayable(mime) -> Bool
-    displayable(d::Display, mime) -> Bool
-
-Returns a boolean value indicating whether the given `mime` type (string) is displayable by any of the displays in the current display stack, or specifically by the display `d` in the second variant.
-"""
-displayable
-
-doc"""
-    sdata(S::SharedArray)
-
-Returns the actual `Array` object backing `S`
-"""
-sdata
-
-doc"""
-    truncate(file,n)
-
-Resize the file or buffer given by the first argument to exactly `n` bytes, filling previously unallocated space with '\\0' if the file or buffer is grown
-"""
-truncate
-
-doc"""
-```rst
-..  stat(file)
-
-Returns a structure whose fields contain information about the file. The fields of the structure are:
-
-========= ======================================================================
- size      The size (in bytes) of the file
- device    ID of the device that contains the file
- inode     The inode number of the file
- mode      The protection mode of the file
- nlink     The number of hard links to the file
- uid       The user id of the owner of the file
- gid       The group id of the file owner
- rdev      If this file refers to a device, the ID of the device it refers to
- blksize   The file-system preferred block size for the file
- blocks    The number of such blocks allocated
- mtime     Unix timestamp of when the file was last modified
- ctime     Unix timestamp of when the file was created
-========= ======================================================================
-```
-"""
-stat
-
-doc"""
-    exp10(x)
-
-Compute $10^x$.
-"""
-exp10
-
-doc"""
-    &(x, y)
-
-Bitwise and
-"""
-&
-
-doc"""
-    besselyx(nu, x)
-
-Scaled Bessel function of the second kind of order `nu`, $Y_\nu(x) e^{- | \operatorname{Im}(x) |}$.
-"""
-besselyx
-
-doc"""
-    eigmax(A)
-
-Returns the largest eigenvalue of `A`.
-"""
-eigmax
-
-doc"""
-    PipeBuffer()
-
-An IOBuffer that allows reading and performs writes by appending. Seeking and truncating are not supported. See IOBuffer for the available constructors.
-"""
-PipeBuffer()
-
-doc"""
-    PipeBuffer(data::Vector{UInt8},[maxsize])
-
-Create a PipeBuffer to operate on a data vector, optionally specifying a size beyond which the underlying Array may not be grown.
-"""
-PipeBuffer(data)
-
-doc"""
-```rst
-..  eigs(A, [B,]; nev=6, which="LM", tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
-
-Computes eigenvalues ``d`` of ``A`` using Lanczos or Arnoldi iterations for
-real symmetric or general nonsymmetric matrices respectively. If ``B`` is
-provided, the generalized eigenproblem is solved.
-
-The following keyword arguments are supported:
- * ``nev``: Number of eigenvalues
- * ``ncv``: Number of Krylov vectors used in the computation; should satisfy ``nev+1 <= ncv <= n`` for real symmetric problems and ``nev+2 <= ncv <= n`` for other problems, where ``n`` is the size of the input matrix ``A``. The default is ``ncv = max(20,2*nev+1)``.
-
-    Note that these restrictions limit the input matrix ``A`` to be of dimension at least 2.
- * ``which``: type of eigenvalues to compute. See the note below.
-
-   ========= ======================================================================================================================
-   ``which`` type of eigenvalues
-   --------- ----------------------------------------------------------------------------------------------------------------------
-   ``:LM``   eigenvalues of largest magnitude (default)
-   ``:SM``   eigenvalues of smallest magnitude
-   ``:LR``   eigenvalues of largest real part
-   ``:SR``   eigenvalues of smallest real part
-   ``:LI``   eigenvalues of largest imaginary part (nonsymmetric or complex ``A`` only)
-   ``:SI``   eigenvalues of smallest imaginary part (nonsymmetric or complex ``A`` only)
-   ``:BE``   compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric ``A`` only)
-   ========= ======================================================================================================================
-
- * ``tol``: tolerance (:math:`tol \le 0.0` defaults to ``DLAMCH('EPS')``)
- * ``maxiter``: Maximum number of iterations (default = 300)
- * ``sigma``: Specifies the level shift used in inverse iteration. If ``nothing`` (default), defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to ``sigma`` using shift and invert iterations.
- * ``ritzvec``: Returns the Ritz vectors ``v`` (eigenvectors) if ``true``
- * ``v0``: starting vector from which to start the iterations
-
-``eigs`` returns the ``nev`` requested eigenvalues in ``d``, the corresponding Ritz vectors ``v`` (only if ``ritzvec=true``), the number of converged eigenvalues ``nconv``, the number of iterations ``niter`` and the number of matrix vector multiplications ``nmult``, as well as the final residual vector ``resid``.
-
-.. note:: The ``sigma`` and ``which`` keywords interact: the description of eigenvalues searched for by ``which`` do _not_ necessarily refer to the eigenvalues of ``A``, but rather the linear operator constructed by the specification of the iteration mode implied by ``sigma``.
-
-   =============== ================================== ==================================
-   ``sigma``       iteration mode                     ``which`` refers to eigenvalues of
-   --------------- ---------------------------------- ----------------------------------
-   ``nothing``     ordinary (forward)                 :math:`A`
-   real or complex inverse with level shift ``sigma`` :math:`(A - \sigma I )^{-1}`
-   =============== ================================== ==================================
-```
-"""
-eigs
-
-doc"""
-```rst
-..  sortperm(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Return a permutation vector of indices of ``v`` that puts it in sorted order.
-Specify ``alg`` to choose a particular sorting algorithm (see Sorting Algorithms).
-``MergeSort`` is used by default, and since it is stable, the resulting permutation
-will be the lexicographically first one that puts the input array into sorted order –
-i.e. indices of equal elements appear in ascending order. If you choose a non-stable
-sorting algorithm such as ``QuickSort``, a different permutation that puts the array
-into order may be returned. The order is specified using the same keywords as ``sort!``.
-
-See also :func:`sortperm!`
-```
-"""
-sortperm
-
-doc"""
-    mod2pi(x)
-
-Modulus after division by 2pi, returning in the range \[0,2pi).
-
-This function computes a floating point representation of the modulus after division by numerically exact 2pi, and is therefore not exactly the same as mod(x,2pi), which would compute the modulus of `x` relative to division by the floating-point number 2pi.
-"""
-mod2pi
-
-doc"""
-    cumsum!(B, A, [dim])
-
-Cumulative sum of `A` along a dimension, storing the result in `B`. The dimension defaults to 1.
-"""
-cumsum!
-
-doc"""
-    logdet(M)
-
-Log of matrix determinant. Equivalent to `log(det(M))`, but may provide increased accuracy and/or speed.
-"""
-logdet
-
-doc"""
-    hcat(A...)
-
-Concatenate along dimension 2
-"""
-hcat
-
-doc"""
-    select(v, k, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Variant of `select!` which copies `v` before partially sorting it, thereby returning the same thing as `select!` but leaving `v` unmodified.
-"""
-select
-
-doc"""
-    lpad(string, n, p)
-
-Make a string at least `n` columns wide when printed, by padding on the left with copies of `p`.
-"""
-lpad
-
-doc"""
-```rst
-..  mapreduce(f, op, v0, itr)
-
-Apply function ``f`` to each element in ``itr``, and then reduce
-the result using the binary function ``op``. ``v0`` must be a
-neutral element for ``op`` that will be returned for empty
-collections. It is unspecified whether ``v0`` is used for non-empty
-collections.
-
-:func:`mapreduce` is functionally equivalent to calling ``reduce(op,
-v0, map(f, itr))``, but will in general execute faster since no
-intermediate collection needs to be created. See documentation for
-:func:`reduce` and :func:`map`.
-
-.. doctest::
-
-   julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
-   14
-
-The associativity of the reduction is implementation-dependent.
-Additionally, some implementations may reuse the return value of
-``f`` for elements that appear multiple times in ``itr``.
-Use :func:`mapfoldl` or :func:`mapfoldr` instead for guaranteed
-left or right associativity and invocation of ``f`` for every value.
-```
-"""
-mapreduce(f, op, v0, itr)
-
-doc"""
-```rst
-..  mapreduce(f, op, itr)
-
-Like ``mapreduce(f, op, v0, itr)``. In general, this cannot be used
-with empty collections (see ``reduce(op, itr)``).
-```
-"""
-mapreduce(f, op, itr)
-
-doc"""
-    quantile!(v, p)
-
-Like `quantile`, but overwrites the input vector.
-"""
-quantile!
-
-doc"""
-    accept(server[,client])
-
-Accepts a connection on the given server and returns a connection to the client. An uninitialized client stream may be provided, in which case it will be used instead of creating a new stream.
-"""
-accept
-
-doc"""
-```rst
-..  ordschur(Q, T, select) -> Schur
-
-Reorders the Schur factorization of a real matrix ``A=Q*T*Q'`` according to the logical array ``select`` returning a Schur object ``F``. The selected eigenvalues appear in the leading diagonal of ``F[:Schur]`` and the the corresponding leading columns of ``F[:vectors]`` form an orthonormal basis of the corresponding right invariant subspace. A complex conjugate pair of eigenvalues must be either both included or excluded via ``select``.
-```
-"""
-ordschur(Q, T, select)
-
-doc"""
-```rst
-..  ordschur(S, select) -> Schur
-
-Reorders the Schur factorization ``S`` of type ``Schur``.
-```
-"""
-ordschur(S::Schur, select)
-
-doc"""
-```rst
-..  ordschur(S, T, Q, Z, select) -> GeneralizedSchur
-
-Reorders the Generalized Schur factorization of a matrix ``(A, B) = (Q*S*Z^{H}, Q*T*Z^{H})`` according to the logical array ``select`` and returns a GeneralizedSchur object ``GS``.  The selected eigenvalues appear in the leading diagonal of both ``(GS[:S], GS[:T])`` and the left and right unitary/orthogonal Schur vectors are also reordered such that ``(A, B) = GS[:Q]*(GS[:S], GS[:T])*GS[:Z]^{H}`` still holds and the generalized eigenvalues of ``A`` and ``B`` can still be obtained with ``GS[:alpha]./GS[:beta]``.
-```
-"""
-ordschur(S, T, Q, Z)
-
-doc"""
-```rst
-..  ordschur(GS, select) -> GeneralizedSchur
-
-Reorders the Generalized Schur factorization of a Generalized Schur object.  See :func:`ordschur`.
-```
-"""
-ordschur(GS::GeneralizedSchur, select)
-
-doc"""
-    triu!(M)
-
-Upper triangle of a matrix, overwriting `M` in the process.
-"""
-triu!(M)
-
-doc"""
-    triu!(M, k)
-
-Returns the upper triangle of `M` starting from the `k`th superdiagonal, overwriting `M` in the process.
-"""
-triu!(M, k)
-
-doc"""
-    readall(stream::IO)
-
-Read the entire contents of an I/O stream as a string.
-"""
-readall(stream::IO)
-
-doc"""
-    readall(filename::AbstractString)
-
-Open `filename`, read the entire contents as a string, then close the file. Equivalent to `open(readall, filename)`.
-"""
-readall(filename::AbstractString)
-
-doc"""
-    poll_file(path, interval_s::Real, timeout_s::Real) -> (previous::StatStruct, current::StatStruct)
-
-Monitor a file for changes by polling every `interval_s` seconds until a change occurs or `timeout_s` seconds have elapsed. The `interval_s` should be a long period; the default is 5.007 seconds.
-
-Returns a pair of `StatStruct` objects `(previous, current)` when a change is detected.
-
-To determine when a file was modified, compare `mtime(prev) != mtime(current)` to detect notification of changes. However, using `watch_file` for this operation is preferred, since it is more reliable and efficient, although in some situations it may not be available.
-"""
-poll_file
-
-doc"""
-    eachline(stream)
-
-Create an iterable object that will yield each line from a stream.
-"""
-eachline
-
-doc"""
-    isposdef!(A) -> Bool
-
-Test whether a matrix is positive definite, overwriting `A` in the processes.
-"""
-isposdef!
-
-doc"""
-    complex(r, [i])
-
-Convert real numbers or arrays to complex. `i` defaults to zero.
-"""
-complex
-
-doc"""
-    setopt(sock::UDPSocket; multicast_loop = nothing, multicast_ttl=nothing, enable_broadcast=nothing, ttl=nothing)
-
-Set UDP socket options. `multicast_loop`: loopback for multicast packets (default: `true`). `multicast_ttl`: TTL for multicast packets. `enable_broadcast`: flag must be set to `true` if socket will be used for broadcast messages, or else the UDP system will return an access error (default: `false`). `ttl`: Time-to-live of packets sent on the socket.
-"""
-setopt
-
-doc"""
-    Mmap.Anonymous(name, readonly, create)
-
-Create an `IO`-like object for creating zeroed-out mmapped-memory that is not tied to a file for use in `Mmap.mmap`. Used by `SharedArray` for creating shared memory arrays.
-"""
-Mmap.Anonymous
-
-doc"""
-    A_rdiv_Bc(A, B)
-
-For matrices or vectors `A` and `B`, calculates `A / Bᴴ`
-"""
-A_rdiv_Bc
-
-doc"""
-    sparse(I,J,V,[m,n,combine])
-
-Create a sparse matrix `S` of dimensions `m x n` such that `S[I[k], J[k]] = V[k]`. The `combine` function is used to combine duplicates. If `m` and `n` are not specified, they are set to `maximum(I)` and `maximum(J)` respectively. If the `combine` function is not supplied, duplicates are added by default. All elements of `I` must satisfy `1 <= I[k] <= m`, and all elements of `J` must satisfy `1 <= J[k] <= n`.
-"""
-sparse(I, J, V, m=?, n=?, combine=?)
-
-doc"""
-    sparse(A)
-
-Convert an AbstractMatrix `A` into a sparse matrix.
-"""
-sparse(A)
-
-doc"""
-```rst
-..  round([T,] x, [digits, [base]], [r::RoundingMode])
-
-``round(x)`` rounds ``x`` to an integer value according to the default
-rounding mode (see :func:`get_rounding`), returning a value of the same type as
-``x``. By default (:obj:`RoundNearest`), this will round to the nearest
-integer, with ties (fractional values of 0.5) being rounded to the even
-integer.
-
-.. doctest::
-
-   julia> round(1.7)
-   2.0
-
-   julia> round(1.5)
-   2.0
-
-   julia> round(2.5)
-   2.0
-
-The optional :obj:`RoundingMode` argument will change how the number gets rounded.
-
-``round(T, x, [r::RoundingMode])`` converts the result to type ``T``, throwing an
-:exc:`InexactError` if the value is not representable.
-
-``round(x, digits)`` rounds to the specified number of digits after the
-decimal place (or before if negative). ``round(x, digits, base)`` rounds
-using a base other than 10.
-
-.. doctest::
-
-   julia> round(pi, 2)
-   3.14
-
-   julia> round(pi, 3, 2)
-   3.125
-
-.. note::
-
-   Rounding to specified digits in bases other than 2 can be inexact when
-   operating on binary floating point numbers. For example, the ``Float64``
-   value represented by ``1.15`` is actually *less* than 1.15, yet will be
-   rounded to 1.2.
-
-   .. doctest::
-
-      julia> x = 1.15
-      1.15
-
-      julia> @sprintf "%.20f" x
-      "1.14999999999999991118"
-
-      julia> x < 115//100
-      true
-
-      julia> round(x, 1)
-      1.2
-```
-"""
-round(T::Type, x)
-
-doc"""
-```rst
-.. round(z, RoundingModeReal, RoundingModeImaginary)
-
-Returns the nearest integral value of the same type as the complex-valued
-``z`` to ``z``, breaking ties using the specified :obj:`RoundingMode`\ s.
-The first :obj:`RoundingMode` is used for rounding the real components while
-the second is used for rounding the imaginary components.
-```
-"""
-round(z::Real, ::Type{RoundingMode}, ::Type{RoundingMode})
-
-doc"""
-    strwidth(s)
-
-Gives the number of columns needed to print a string.
-"""
-strwidth
-
-doc"""
-    function_module(f::Function, types) -> Module
-
-Determine the module containing a given definition of a generic function.
-"""
-function_module
-
-doc"""
-    hex(n, [pad])
-
-Convert an integer to a hexadecimal string, optionally specifying a number of digits to pad to.
-"""
-hex
-
-doc"""
-    workspace()
-
-Replace the top-level module (`Main`) with a new one, providing a clean workspace. The previous `Main` module is made available as `LastMain`. A previously-loaded package can be accessed using a statement such as `using LastMain.Package`.
-
-This function should only be used interactively.
-"""
-workspace
-
-doc"""
-    tempdir()
-
-Obtain the path of a temporary directory (possibly shared with other processes).
-"""
-tempdir
-
-doc"""
-    reduce(op, v0, itr)
-
-Reduce the given collection `ìtr` with the given binary operator `op`. `v0` must be a neutral element for `op` that will be returned for empty collections. It is unspecified whether `v0` is used for non-empty collections.
-
-Reductions for certain commonly-used operators have special implementations which should be used instead: `maximum(itr)`, `minimum(itr)`, `sum(itr)`, `prod(itr)`, `any(itr)`, `all(itr)`.
-
-The associativity of the reduction is implementation dependent. This means that you can't use non-associative operations like `-` because it is undefined whether `reduce(-,[1,2,3])` should be evaluated as `(1-2)-3` or `1-(2-3)`. Use `foldl` or `foldr` instead for guaranteed left or right associativity.
-
-Some operations accumulate error, and parallelism will also be easier if the reduction can be executed in groups. Future versions of Julia might change the algorithm. Note that the elements are not reordered if you use an ordered collection.
-"""
-reduce(op, v0, itr)
-
-doc"""
-    reduce(op, itr)
-
-Like `reduce(op, v0, itr)`. This cannot be used with empty collections, except for some special cases (e.g. when `op` is one of `+`, `*`, `max`, `min`, `&`, `|`) when Julia can determine the neutral element of `op`.
-"""
-reduce(op, itr)
-
-doc"""
-    .>=(x, y)
-    .≥(x,y)
-
-Element-wise greater-than-or-equals comparison operator.
-"""
-Base.(:(.>=))
-
-doc"""
-    stdm(v, m)
-
-Compute the sample standard deviation of a vector `v` with known mean `m`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-stdm
-
-doc"""
-    mv(src::AbstractString,dst::AbstractString; remove_destination::Bool=false)
-
-Move the file, link, or directory from `src` to `dst`. `remove_destination=true` will first remove an existing `dst`.
-"""
-mv
-
-doc"""
-    erfi(x)
-
-Compute the imaginary error function of `x`,
-defined by $-i \operatorname{erf}(ix)$.
-"""
-erfi
-
-doc"""
-```rst
-..  floor([T,] x, [digits, [base]])
-
-``floor(x)`` returns the nearest integral value of the same type as ``x``
-that is less than or equal to ``x``.
-
-``floor(T, x)`` converts the result to type ``T``, throwing an
-``InexactError`` if the value is not representable.
-
-``digits`` and ``base`` work as for :func:`round`.
-```
-"""
-floor
-
-doc"""
-    tril!(M)
-
-Lower triangle of a matrix, overwriting `M` in the process.
-"""
-tril!(M)
-
-doc"""
-    tril!(M, k)
-
-Returns the lower triangle of `M` starting from the `k`th superdiagonal, overwriting `M` in the process.
-"""
-tril!(M, k)
-
-doc"""
-    divrem(x, y)
-
-The quotient and remainder from Euclidean division. Equivalent to `(x÷y, x%y)`.
-"""
-divrem
-
-doc"""
-    ErrorException(msg)
-
-Generic error type. The error message, in the `.msg` field, may provide more specific details.
-"""
-ErrorException
-
-doc"""
-    reverse(v [, start=1 [, stop=length(v) ]] )
-
-Return a copy of `v` reversed from start to stop.
-"""
-reverse
-
-doc"""
-    reverse(s::AbstractString) -> AbstractString
-
-Reverses a string
-"""
-reverse(s::AbstractString)
-
-doc"""
-```rst
-..  reverse!(v [, start=1 [, stop=length(v) ]]) -> v
-
-In-place version of :func:`reverse`.
-```
-"""
-reverse!
-
-doc"""
-    flipdim(A, d)
-
-Reverse `A` in dimension `d`.
-"""
-flipdim
-
-doc"""
-    num(x)
-
-Numerator of the rational representation of `x`
-"""
-num
-
-doc"""
-    eachindex(A...)
-
-Creates an iterable object for visiting each index of an AbstractArray `A` in an efficient manner. For array types that have opted into fast linear indexing (like `Array`), this is simply the range `1:length(A)`. For other array types, this returns a specialized Cartesian range to efficiently index into the array with indices specified for every dimension. For other iterables, including strings and dictionaries, this returns an iterator object supporting arbitrary index types (e.g. unevenly spaced or non-integer indices).
-
-Example for a sparse 2-d array:
-
-    julia> A = sprand(2, 3, 0.5)
-    2x3 sparse matrix with 4 Float64 entries:
-        [1, 1]  =  0.598888
-        [1, 2]  =  0.0230247
-        [1, 3]  =  0.486499
-        [2, 3]  =  0.809041
-
-    julia> for iter in eachindex(A)
-               @show iter.I_1, iter.I_2
-               @show A[iter]
-           end
-    (iter.I_1,iter.I_2) = (1,1)
-    A[iter] = 0.5988881393454597
-    (iter.I_1,iter.I_2) = (2,1)
-    A[iter] = 0.0
-    (iter.I_1,iter.I_2) = (1,2)
-    A[iter] = 0.02302469881746183
-    (iter.I_1,iter.I_2) = (2,2)
-    A[iter] = 0.0
-    (iter.I_1,iter.I_2) = (1,3)
-    A[iter] = 0.4864987874354343
-    (iter.I_1,iter.I_2) = (2,3)
-    A[iter] = 0.8090413606455655
-
-If you supply more than one ``AbstractArray`` argument, ``eachindex``
-will create an iterable object that is fast for all arguments (a
-``UnitRange`` if all inputs have fast linear indexing, a
-CartesianRange otherwise).  If the arrays have different sizes and/or
-dimensionalities, ``eachindex`` returns an iterable that spans the
-largest range along each dimension.
-"""
-eachindex
-
-doc"""
-    .<(x, y)
-
-Element-wise less-than comparison operator.
-"""
-Base.(:(.<))
-
-doc"""
-    UndefRefError()
-
-The item or field is not defined for the given object.
-"""
-UndefRefError
-
-doc"""
-    bessely1(x)
-
-Bessel function of the second kind of order 1, $Y_1(x)$.
-"""
-bessely1
-
-doc"""
-```rst
-..  cumprod(A, [dim])
-
-Cumulative product along a dimension ``dim`` (defaults to 1).
-See also :func:`cumprod!` to use a preallocated output array,
-both for performance and to control the precision of the
-output (e.g. to avoid overflow).
-```
-"""
-cumprod
-
-doc"""
-    besseljx(nu, x)
-
-Scaled Bessel function of the first kind of order `nu`, $J_\nu(x) e^{- | \operatorname{Im}(x) |}$.
-"""
-besseljx
-
-doc"""
-    print(x)
-
-Write (to the default output stream) a canonical (un-decorated) text representation of a value if there is one, otherwise call `show`. The representation used by `print` includes minimal formatting and tries to avoid Julia-specific details.
-"""
-print
-
-doc"""
-    filt(b, a, x, [si])
-
-Apply filter described by vectors `a` and `b` to vector `x`, with an optional initial filter state vector `si` (defaults to zeros).
-"""
-filt
-
-doc"""
-    indexpids(S::SharedArray)
-
-Returns the index of the current worker into the `pids` vector, i.e., the list of workers mapping the SharedArray
-"""
-indexpids
-
-doc"""
-    remotecall_wait(id, func, args...)
-
-Perform `wait(remotecall(...))` in one message.
-"""
-remotecall_wait
-
-doc"""
-```rst
-..  dct(A [, dims])
-
-Performs a multidimensional type-II discrete cosine transform (DCT)
-of the array ``A``, using the unitary normalization of the DCT.
-The optional ``dims`` argument specifies an iterable subset of
-dimensions (e.g. an integer, range, tuple, or array) to transform
-along.  Most efficient if the size of ``A`` along the transformed
-dimensions is a product of small primes; see :func:`nextprod`.  See
-also :func:`plan_dct` for even greater efficiency.
-```
-"""
-dct
-
-doc"""
-```rst
-..  append!(collection, collection2) -> collection.
-
-Add the elements of ``collection2`` to the end of ``collection``.
-
-.. doctest::
-
-   julia> append!([1],[2,3])
-   3-element Array{Int64,1}:
-    1
-    2
-    3
-
-.. doctest::
-
-   julia> append!([1, 2, 3], [4, 5, 6])
-   6-element Array{Int64,1}:
-    1
-    2
-    3
-    4
-    5
-    6
-
-Use :func:`push!` to add individual items to ``collection`` which are not
-already themselves in another collection.
-The result is of the preceding example is equivalent to
-``push!([1, 2, 3], 4, 5, 6)``.
-```
-"""
-append!
-
-doc"""
-    find(A)
-
-Return a vector of the linear indexes of the non-zeros in `A` (determined by `A[i]!=0`). A common use of this is to convert a boolean array to an array of indexes of the `true` elements.
-"""
-find(A)
-
-doc"""
-    find(f,A)
-
-Return a vector of the linear indexes of `A` where `f` returns `true`.
-"""
-find(f, A)
-
-doc"""
-    ctranspose(A)
-
-The conjugate transposition operator (`'`).
-"""
-ctranspose
-
-doc"""
-    skip(s, offset)
-
-Seek a stream relative to the current position.
-"""
-skip
-
-doc"""
-```rst
-..  bfft(A [, dims])
-
-Similar to :func:`ifft`, but computes an unnormalized inverse (backward)
-transform, which must be divided by the product of the sizes of the
-transformed dimensions in order to obtain the inverse. (This is slightly
-more efficient than :func:`ifft` because it omits a scaling step, which in
-some applications can be combined with other computational steps elsewhere.)
-
-.. math::
-
-   \operatorname{BDFT}(A)[k] = \operatorname{length}(A) \operatorname{IDFT}(A)[k]
-```
-"""
-bfft
-
-doc"""
-    lu(A) -> L, U, p
-
-Compute the LU factorization of `A`, such that `A[p,:] = L*U`.
-"""
-lu
-
-doc"""
-    @task
-
-Wrap an expression in a `Task` without executing it, and return the `Task`. This only creates a task, and does not run it.
-"""
-:@task
-
-doc"""
-    fld(x, y)
-
-Largest integer less than or equal to `x/y`.
-"""
-fld
-
-doc"""
-    indmax(itr) -> Integer
-
-Returns the index of the maximum element in a collection.
-"""
-indmax
-
-doc"""
-    writecsv(filename, A)
-
-Equivalent to `writedlm` with `delim` set to comma.
-"""
-writecsv
-
-doc"""
-    wstring(s)
-
-This is a synonym for either `utf32(s)` or `utf16(s)`, depending on whether `Cwchar_t` is 32 or 16 bits, respectively. The synonym `WString` for `UTF32String` or `UTF16String` is also provided.
-"""
-wstring
-
-doc"""
-    withenv(f::Function, kv::Pair...)
-
-Execute `f()` in an environment that is temporarily modified (not replaced as in `setenv`) by zero or more `"var"=>val` arguments `kv`. `withenv` is generally used via the `withenv(kv...) do ... end` syntax. A value of `nothing` can be used to temporarily unset an environment variable (if it is set). When `withenv` returns, the original environment has been restored.
-"""
-withenv
-
-doc"""
-    setdiff!(s, iterable)
-
-Remove each element of `iterable` from set `s` in-place.
-"""
-setdiff!
-
-doc"""
-    EOFError()
-
-No more data was available to read from a file or stream.
-"""
-EOFError
-
-doc"""
-    isascii(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character belongs to the ASCII character set, or whether this is true for all elements of a string.
-"""
-isascii
-
-doc"""
-    ucfirst(string)
-
-Returns `string` with the first character converted to uppercase.
-"""
-ucfirst
-
-doc"""
-    copysign(x, y)
-
-Return `x` such that it has the same sign as `y`
-"""
-copysign
-
-doc"""
-    getaddrinfo(host)
-
-Gets the IP address of the `host` (may have to do a DNS lookup)
-"""
-getaddrinfo
-
-doc"""
-    @show
-
-Show an expression and result, returning the result.
-"""
-:@show
-
-doc"""
-    showcompact(x)
-
-Show a more compact representation of a value. This is used for printing array elements. If a new type has a different compact representation, it should overload `showcompact(io, x)` where the first argument is a stream.
-"""
-showcompact
-
-doc"""
-    isleaftype(T)
-
-Determine whether `T` is a concrete type that can have instances, meaning its only subtypes are itself and `None` (but `T` itself is not `None`).
-"""
-isleaftype
-
-doc"""
-    svdfact(A, [thin=true]) -> SVD
-
-Compute the Singular Value Decomposition (SVD) of `A` and return an `SVD` object. `U`, `S`, `V` and `Vt` can be obtained from the factorization `F` with `F[:U]`, `F[:S]`, `F[:V]` and `F[:Vt]`, such that `A = U*diagm(S)*Vt`. If `thin` is `true`, an economy mode decomposition is returned. The algorithm produces `Vt` and hence `Vt` is more efficient to extract than `V`. The default is to produce a thin decomposition.
-"""
-svdfact(A)
-
-doc"""
-    svdfact(A, B) -> GeneralizedSVD
-
-Compute the generalized SVD of `A` and `B`, returning a `GeneralizedSVD` Factorization object `F`, such that `A = F[:U]*F[:D1]*F[:R0]*F[:Q]'` and `B = F[:V]*F[:D2]*F[:R0]*F[:Q]'`.
-"""
-svdfact(A, B)
-
-doc"""
-    string(xs...)
-
-Create a string from any values using the `print` function.
-"""
-string
-
-doc"""
-    erfc(x)
-
-Compute the complementary error function of ``x``,
-defined by $1 - \operatorname{erf}(x)$.
-"""
-erfc
-
-doc"""
-    prevfloat(f) -> AbstractFloat
-
-Get the previous floating point number in lexicographic order
-"""
-prevfloat
-
-doc"""
-    rest(iter, state)
-
-An iterator that yields the same elements as `iter`, but starting at the given `state`.
-"""
-rest
-
-doc"""
-    getfield(value, name::Symbol)
-
-Extract a named field from a `value` of composite type. The syntax `a.b` calls `getfield(a, :b)`, and the syntax `a.(b)` calls `getfield(a, b)`.
-"""
-getfield
-
-doc"""
-    utf8(::Array{UInt8,1})
-
-Create a UTF-8 string from a byte array.
-"""
-utf8(::Vector{UInt8})
-
-doc"""
-    utf8(::Ptr{UInt8}, [length])
-
-Create a UTF-8 string from the address of a C (0-terminated) string encoded in UTF-8. A copy is made; the ptr can be safely freed. If `length` is specified, the string does not have to be 0-terminated.
-"""
-utf8(::Ptr{UInt8}, length::Int = 1)
-
-doc"""
-    utf8(s)
-
-Convert a string to a contiguous UTF-8 string (all characters must be valid UTF-8 characters).
-"""
-utf8(s)
-
-doc"""
-    hvcat(rows::Tuple{Vararg{Int}}, values...)
-
-Horizontal and vertical concatenation in one call. This function is called for block matrix syntax. The first argument specifies the number of arguments to concatenate in each block row. For example, `[a b;c d e]` calls `hvcat((2,3),a,b,c,d,e)`.
-
-If the first argument is a single integer `n`, then all block rows are assumed to have `n` block columns.
-"""
-hvcat
-
-doc"""
-    besselj1(x)
-
-Bessel function of the first kind of order 1, $J_1(x)$.
-"""
-besselj1
-
-doc"""
-    sinpi(x)
-
-Compute $\sin(\pi x)$ more accurately than `sin(pi*x)`, especially for large `x`.
-"""
-sinpi
-
-doc"""
-    select!(v, k, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Partially sort the vector `v` in place, according to the order specified by `by`, `lt` and `rev` so that the value at index `k` (or range of adjacent values if `k` is a range) occurs at the position where it would appear if the array were fully sorted via a non-stable algorithm. If `k` is a single index, that value is returned; if `k` is a range, an array of values at those indices is returned. Note that `select!` does not fully sort the input array.
-"""
-select!
-
-doc"""
-    maximum!(r, A)
-
-Compute the maximum value of `A` over the singleton dimensions of `r`, and write results to `r`.
-"""
-maximum!
-
-doc"""
-    prod(itr)
-
-Returns the product of all elements of a collection.
-"""
-prod(itr)
-
-"""
-    prod(A, dims)
-
-Multiply elements of an array over the given dimensions.
-"""
-prod(A, dims)
-
-doc"""
-    Base.linearindexing(A)
-
-`linearindexing` defines how an AbstractArray most efficiently accesses its elements. If `Base.linearindexing(A)` returns `Base.LinearFast()`, this means that linear indexing with only one index is an efficient operation. If it instead returns `Base.LinearSlow()` (by default), this means that the array intrinsically accesses its elements with indices specified for every dimension. Since converting a linear index to multiple indexing subscripts is typically very expensive, this provides a traits-based mechanism to enable efficient generic code for all array types.
-
-An abstract array subtype `MyArray` that wishes to opt into fast linear indexing behaviors should define `linearindexing` in the type-domain:
-
-    Base.linearindexing{T<:MyArray}(::Type{T}) = Base.LinearFast()
-"""
-Base.linearindexing
-
-doc"""
-    isqrt(n)
-
-Integer square root: the largest integer `m` such that `m*m <= n`.
-"""
-isqrt
-
-doc"""
-    log1p(x)
-
-Accurate natural logarithm of `1+x`. Throws `DomainError` for `Real` arguments less than -1.
-
-There is an experimental variant in the `Base.Math.JuliaLibm` module, which is typically faster and more accurate.
-"""
-log1p
-
-doc"""
-    flipsign(x, y)
-
-Return `x` with its sign flipped if `y` is negative. For example `abs(x) = flipsign(x,x)`.
-"""
-flipsign
-
-doc"""
-    lbeta(x, y)
-
-Natural logarithm of the absolute value of the beta function $\log(|\operatorname{B}(x,y)|)$.
-"""
-lbeta
-
-doc"""
-```rst
-..  randstring([rng,] len=8)
-
-Create a random ASCII string of length ``len``, consisting of upper- and
-lower-case letters and the digits 0-9. The optional ``rng`` argument
-specifies a random number generator, see :ref:`Random Numbers <random-numbers>`.
-```
-"""
-randstring
-
-doc"""
-    Float64(x [, mode::RoundingMode])
-
-Create a Float64 from `x`. If `x` is not exactly representable then
-`mode` determines how `x` is rounded.
-
-```jldoctest
-julia> Float64(pi, RoundDown)
-3.141592653589793
-
-julia> Float64(pi, RoundUp)
-3.1415926535897936
-```
-
-See `get_rounding` for available rounding modes.
-"""
-Float64
-
-doc"""
-    function_name(f::Function) -> Symbol
-
-Get the name of a generic `Function` as a symbol, or `:anonymous`.
-"""
-function_name
-
-doc"""
-```rst
-..  addprocs(n::Integer; exeflags=``) -> List of process identifiers
-
-Launches workers using the in-built ``LocalManager`` which only launches workers on the local host.
-This can be used to take advantage of multiple cores. ``addprocs(4)`` will add 4 processes on the local machine.
-```
-"""
-addprocs(n::Integer)
-
-doc"""
-```rst
-..  addprocs() -> List of process identifiers
-
-Equivalent to ``addprocs(CPU_CORES)``
-
-Note that workers do not run a `.juliarc.jl` startup script, nor do they synchronize their global state
-(such as global variables, new method definitions, and loaded modules) with any of the other running processes.
-```
-"""
-addprocs()
-
-doc"""
-```rst
-..  addprocs(machines; tunnel=false, sshflags=``, max_parallel=10, exeflags=``) -> List of process identifiers
-
-Add processes on remote machines via SSH.
-Requires julia to be installed in the same location on each node, or to be available via a shared file system.
-
-``machines`` is a vector of machine specifications.  Worker are started for each specification.
-
-A machine specification is either a string ``machine_spec`` or a tuple - ``(machine_spec, count)``
-
-``machine_spec`` is a string of the form ``[user@]host[:port] [bind_addr[:port]]``. ``user`` defaults
-to current user, ``port`` to the standard ssh port. If ``[bind_addr[:port]]`` is specified, other
-workers will connect to this worker at the specified ``bind_addr`` and ``port``.
-
-``count`` is the number of workers to be launched on the specified host. If specified as ``:auto``
-it will launch as many workers as the number of cores on the specific host.
-
-
-Keyword arguments:
-
-``tunnel`` : if ``true`` then SSH tunneling will be used to connect to the worker from the master process.
-
-``sshflags`` : specifies additional ssh options, e.g. :literal:`sshflags=\`-i /home/foo/bar.pem\`` .
-
-``max_parallel`` : specifies the maximum number of workers connected to in parallel at a host. Defaults to 10.
-
-``dir`` :  specifies the working directory on the workers. Defaults to the host's current directory (as found by ``pwd()``)
-
-``exename`` :  name of the julia executable. Defaults to "$JULIA_HOME/julia" or "$JULIA_HOME/julia-debug" as the case may be.
-
-``exeflags`` :  additional flags passed to the worker processes.
-
-Environment variables :
-
-If the master process fails to establish a connection with a newly launched worker within 60.0 seconds,
-the worker treats it a fatal situation and terminates. This timeout can be controlled via environment
-variable ``JULIA_WORKER_TIMEOUT``. The value of ``JULIA_WORKER_TIMEOUT`` on the master process, specifies
-the number of seconds a newly launched worker waits for connection establishment.
-```
-"""
-addprocs(machines)
-
-doc"""
-```rst
-..  addprocs(manager::ClusterManager; kwargs...) -> List of process identifiers
-
-Launches worker processes via the specified cluster manager.
-
-For example Beowulf clusters are  supported via a custom cluster manager implemented in package ``ClusterManagers``.
-
-The number of seconds a newly launched worker waits for connection establishment from the master can be
-specified via variable ``JULIA_WORKER_TIMEOUT`` in the worker process's environment. Relevant only when using TCP/IP as transport.
-```
-"""
-addprocs(manager::ClusterManager)
-
-doc"""
-    mkpath(path, [mode])
-
-Create all directories in the given `path`, with permissions `mode`. `mode` defaults to 0o777, modified by the current file creation mask.
-"""
-mkpath
-
-doc"""
-```rst
-..  lufact(A [,pivot=Val{true}]) -> F
-
-Compute the LU factorization of ``A``. The return type of ``F`` depends on the type of ``A``. In most cases, if ``A`` is a subtype ``S`` of AbstractMatrix with an element type ``T`` supporting ``+``, ``-``, ``*`` and ``/`` the return type is ``LU{T,S{T}}``. If pivoting is chosen (default) the element type should also support ``abs`` and ``<``. When ``A`` is sparse and have element of type ``Float32``, ``Float64``, ``Complex{Float32}``, or ``Complex{Float64}`` the return type is ``UmfpackLU``. Some examples are shown in the table below.
-
-   ======================= ========================= ========================================
-   Type of input ``A``     Type of output ``F``      Relationship between ``F`` and ``A``
-   ----------------------- ------------------------- ----------------------------------------
-   :func:`Matrix`           ``LU``                   ``F[:L]*F[:U] == A[F[:p], :]``
-   :func:`Tridiagonal`      ``LU{T,Tridiagonal{T}}`` ``F[:L]*F[:U] == A[F[:p], :]``
-   :func:`SparseMatrixCSC`  ``UmfpackLU``            ``F[:L]*F[:U] == (F[:Rs] .* A)[F[:p], F[:q]]``
-   ======================= ========================= ========================================
-
-The individual components of the factorization ``F`` can be accessed by indexing:
-
-   =========== ======================================= ====== ======================== =============
-   Component   Description                             ``LU`` ``LU{T,Tridiagonal{T}}`` ``UmfpackLU``
-   ----------- --------------------------------------- ------ ------------------------ -------------
-   ``F[:L]``   ``L`` (lower triangular) part of ``LU``    ✓            ✓                        ✓
-   ``F[:U]``   ``U`` (upper triangular) part of ``LU``    ✓            ✓                        ✓
-   ``F[:p]``   (right) permutation ``Vector``             ✓            ✓                        ✓
-   ``F[:P]``   (right) permutation ``Matrix``             ✓            ✓
-   ``F[:q]``   left permutation ``Vector``                                                      ✓
-   ``F[:Rs]``  ``Vector`` of scaling factors                                                    ✓
-   ``F[:(:)]`` ``(L,U,p,q,Rs)`` components                                                      ✓
-   =========== ======================================= ====== ======================== =============
-
-   ================== ====== ======================== =============
-   Supported function ``LU`` ``LU{T,Tridiagonal{T}}`` ``UmfpackLU``
-   ------------------ ------ ------------------------ -------------
-        ``/``            ✓
-        ``\``            ✓                       ✓             ✓
-        ``cond``         ✓                                     ✓
-        ``det``          ✓                       ✓             ✓
-        ``logdet``       ✓                       ✓
-        ``logabsdet``    ✓                       ✓
-        ``size``         ✓                       ✓
-   ================== ====== ======================== =============
-```
-"""
-lufact
-
-doc"""
-    besselix(nu, x)
-
-Scaled modified Bessel function of the first kind of order `nu`, $I_\nu(x) e^{- | \operatorname{Re}(x) |}$.
-"""
-besselix
-
-doc"""
-    union(s1,s2...)
-    ∪(s1,s2...)
-
-Construct the union of two or more sets. Maintains order with arrays.
-"""
-union
-
-doc"""
-    lstat(file)
-
-Like stat, but for symbolic links gets the info for the link itself rather than the file it refers to. This function must be called on a file path rather than a file object or a file descriptor.
-"""
-lstat
-
-doc"""
-```rst
-..  mapfoldl(f, op, v0, itr)
-
-Like :func:`mapreduce`, but with guaranteed left associativity. ``v0``
-will be used exactly once.
-```
-"""
-mapfoldl(f, op, v0, itr)
-
-doc"""
-```rst
-..  mapfoldl(f, op, itr)
-
-Like ``mapfoldl(f, op, v0, itr)``, but using the first element of
-``itr`` as ``v0``. In general, this cannot be used with empty
-collections (see ``reduce(op, itr)``).
-```
-"""
-mapfoldl(f, op, itr)
-
-doc"""
-    realmax(T)
-
-The highest finite value representable by the given floating-point DataType `T`.
-"""
-realmax
-
-doc"""
-    takebuf_string(b::IOBuffer)
-
-Obtain the contents of an `IOBuffer` as a string, without copying. Afterwards, the IOBuffer is reset to its initial state.
-"""
-takebuf_string
-
-doc"""
-    pipeline(from, to, ...)
-
-Create a pipeline from a data source to a destination. The source and destination can
-be commands, I/O streams, strings, or results of other `pipeline` calls. At least one
-argument must be a command. Strings refer to filenames.
-When called with more than two arguments, they are chained together from left to right.
-For example `pipeline(a,b,c)` is equivalent to `pipeline(pipeline(a,b),c)`. This provides a more
-concise way to specify multi-stage pipelines.
-
-**Examples**:
-
-* ``run(pipeline(`ls`, `grep xyz`))``
-* ``run(pipeline(`ls`, "out.txt"))``
-* ``run(pipeline("out.txt", `grep xyz`))``
-
-"""
-pipeline(from, to, rest...)
-
-doc"""
-    pipeline(command; stdin, stdout, stderr, append=false)
-
-Redirect I/O to or from the given `command`. Keyword arguments specify which of
-the command's streams should be redirected. `append` controls whether file output
-appends to the file.
-This is a more general version of the 2-argument `pipeline` function.
-`pipeline(from, to)` is equivalent to `pipeline(from, stdout=to)` when `from` is a
-command, and to `pipe(to, stdin=from)` when `from` is another kind of
-data source.
-
-**Examples**:
-
-* ``run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))``
-* ``run(pipeline(`update`, stdout="log.txt", append=true))``
-
-"""
-pipeline(command)
-
-doc"""
-    serialize(stream, value)
-
-Write an arbitrary value to a stream in an opaque format, such that it can be read back by `deserialize`. The read-back value will be as identical as possible to the original. In general, this process will not work if the reading and writing are done by different versions of Julia, or an instance of Julia with a different system image.
-"""
-serialize
-
-doc"""
-    sum(itr)
-
-Returns the sum of all elements in a collection.
-"""
-sum(itr)
-
-doc"""
-    sum(A, dims)
-
-Sum elements of an array over the given dimensions.
-"""
-sum(A, dims)
-
-doc"""
-    sum(f, itr)
-
-Sum the results of calling function `f` on each element of `itr`.
-"""
-sum(f::Function, itr)
-
-doc"""
-    typemin(T)
-
-The lowest value representable by the given (real) numeric DataType `T`.
-"""
-typemin
-
-doc"""
-    call(x, args...)
-
-If `x` is not a `Function`, then `x(args...)` is equivalent to `call(x, args...)`. This means that function-like behavior can be added to any type by defining new `call` methods.
-"""
-call
-
-doc"""
-    countfrom(start=1, step=1)
-
-An iterator that counts forever, starting at `start` and incrementing by `step`.
-"""
-countfrom
-
-doc"""
-    eof(stream) -> Bool
-
-Tests whether an I/O stream is at end-of-file. If the stream is not yet exhausted, this function will block to wait for more data if necessary, and then return `false`. Therefore it is always safe to read one byte after seeing `eof` return `false`. `eof` will return `false` as long as buffered data is still available, even if the remote end of a connection is closed.
-"""
-eof
-
-doc"""
-    mktempdir([parent=tempdir()])
-
-Create a temporary directory in the `parent` directory and return its path.
-"""
-mktempdir()
-
-doc"""
-    mktempdir(f::Function, [parent=tempdir()])
-
-Apply the function `f` to the result of `mktempdir(parent)` and remove the temporary directory upon completion.
-"""
-mktempdir(f::Function)
-
-doc"""
-    tril(M)
-
-Lower triangle of a matrix.
-"""
-tril(M)
-
-doc"""
-    tril(M, k)
-
-Returns the lower triangle of `M` starting from the `k`th superdiagonal.
-"""
-tril(M,k)
-
-doc"""
-    @edit
-
-Evaluates the arguments to the function call, determines their types, and calls the `edit` function on the resulting expression.
-"""
-:@edit
-
-doc"""
-    subtypes(T::DataType)
-
-Return a list of immediate subtypes of DataType `T`. Note that all currently loaded subtypes are included, including those not visible in the current module.
-"""
-subtypes
-
-doc"""
-    digits(n, [base], [pad])
-
-Returns an array of the digits of `n` in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indexes, such that `n == sum([digits[k]*base^(k-1) for k=1:length(digits)])`.
-"""
-digits
-
-doc"""
-    bytes2hex(bin_arr::Array{UInt8, 1})
-
-Convert an array of bytes to its hexadecimal representation. All characters are in lower-case. Returns an `ASCIIString`.
-"""
-bytes2hex
-
-doc"""
-    unlock(l::ReentrantLock)
-
-Releases ownership of the lock by the current task. If the lock had been acquired before, it just decrements an internal counter and returns immediately.
-"""
-unlock
-
-doc"""
-```rst
-..  BigFloat(x)
-
-Create an arbitrary precision floating point number. ``x`` may be
-an ``Integer``, a ``Float64`` or a ``BigInt``. The
-usual mathematical operators are defined for this type, and results
-are promoted to a ``BigFloat``.
-
-Note that because decimal literals are converted to floating point numbers
-when parsed, ``BigFloat(2.1)`` may not yield what you expect. You may instead
-prefer to initialize constants from strings via :func:`parse`, or using the
-``big`` string literal.
-
-.. doctest::
-
-   julia> BigFloat(2.1)
-   2.100000000000000088817841970012523233890533447265625000000000000000000000000000
-
-   julia> big"2.1"
-   2.099999999999999999999999999999999999999999999999999999999999999999999999999986
-```
-"""
-BigFloat
-
-doc"""
-    xcorr(u,v)
-
-Compute the cross-correlation of two vectors.
-"""
-xcorr
-
-doc"""
-    typeof(x)
-
-Get the concrete type of `x`.
-"""
-typeof
-
-doc"""
-    drop(iter, n)
-
-An iterator that generates all but the first `n` elements of `iter`.
-"""
-drop
-
-doc"""
-    acsc(x)
-
-Compute the inverse cosecant of `x`, where the output is in radians
-"""
-acsc
-
-doc"""
-    log(x)
-
-Compute the natural logarithm of `x`. Throws `DomainError` for negative `Real` arguments. Use complex negative arguments to obtain complex results.
-
-There is an experimental variant in the `Base.Math.JuliaLibm` module, which is typically faster and more accurate.
-"""
-log(x)
-
-doc"""
-    log(b,x)
-
-Compute the base `b` logarithm of `x`. Throws `DomainError` for negative `Real` arguments.
-"""
-log(b, x)
-
-doc"""
-```rst
-..  trunc([T,] x, [digits, [base]])
-
-``trunc(x)`` returns the nearest integral value of the same type as ``x`` whose absolute
-value is less than or equal to ``x``.
-
-``trunc(T, x)`` converts the result to type ``T``, throwing an
-``InexactError`` if the value is not representable.
-
-``digits`` and ``base`` work as for :func:`round`.
-```
-"""
-trunc
-
-doc"""
-    @less
-
-Evaluates the arguments to the function call, determines their types, and calls the `less` function on the resulting expression.
-"""
-:@less
-
-doc"""
-    broadcast_function(f)
-
-Returns a function `broadcast_f` such that `broadcast_function(f)(As...) === broadcast(f, As...)`. Most useful in the form `const broadcast_f = broadcast_function(f)`.
-"""
-broadcast_function
-
-doc"""
-    unsafe_convert(T,x)
-
-Convert `x` to a value of type `T`
-
-In cases where `convert` would need to take a Julia object and turn it into a `Ptr`, this function should be used to define and perform that conversion.
-
-Be careful to ensure that a julia reference to `x` exists as long as the result of this function will be used. Accordingly, the argument `x` to this function should never be an expression, only a variable name or field reference. For example, `x=a.b.c` is acceptable, but `x=[a,b,c]` is not.
-
-The `unsafe` prefix on this function indicates that using the result of this function after the `x` argument to this function is no longer accessible to the program may cause undefined behavior, including program corruption or segfaults, at any later time.
-"""
-unsafe_convert
-
-doc"""
-    warn(msg)
-
-Display a warning. Argument `msg` is a string describing the warning to be displayed.
-"""
-warn
-
-doc"""
-    erfinv(x)
-
-Compute the inverse error function of a real `x`,
-defined by $\operatorname{erf}(\operatorname{erfinv}(x)) = x$.
-"""
-erfinv
-
-doc"""
-    @async
-
-Wraps an expression in a closure and schedules it to run on the local machine. Also adds it to the set of items that the nearest enclosing `@sync` waits for.
-"""
-:@async
-
-doc"""
-    rotr90(A)
-
-Rotate matrix `A` right 90 degrees.
-"""
-rotr90(A)
-
-doc"""
-    rotr90(A, k)
-
-Rotate matrix `A` right 90 degrees an integer `k` number of times. If `k` is zero or a multiple of four, this is equivalent to a `copy`.
-"""
-rotr90(A, k)
-
-doc"""
-    readdir([dir]) -> Vector{ByteString}
-
-Returns the files and directories in the directory `dir` (or the current working directory if not given).
-"""
-readdir
-
-doc"""
-    seek(s, pos)
-
-Seek a stream to the given position.
-"""
-seek
-
-doc"""
-    acosd(x)
-
-Compute the inverse cosine of `x`, where the output is in degrees
-"""
-acosd
-
-doc"""
-    triu(M)
-
-Upper triangle of a matrix.
-"""
-triu(M)
-
-doc"""
-    triu(M, k)
-
-Returns the upper triangle of `M` starting from the `k`th superdiagonal.
-"""
-triu(M, k)
-
-doc"""
-    instances(T::Type)
-
-Return a collection of all instances of the given type, if applicable. Mostly used for enumerated types (see `@enum`).
-"""
-instances
-
-doc"""
-    besselj0(x)
-
-Bessel function of the first kind of order 0, $J_0(x)$.
-"""
-besselj0
-
-doc"""
-    erfcinv(x)
-
-Compute the inverse error complementary function of a real `x`,
-defined by $\operatorname{erfc}(\operatorname{erfcinv}(x)) = x$.
-"""
-erfcinv
-
-doc"""
-    minabs(itr)
-
-Compute the minimum absolute value of a collection of values.
-"""
-minabs(itr)
-
-doc"""
-    minabs(A, dims)
-
-Compute the minimum absolute values over given dimensions.
-"""
-minabs(A, dims)
-
-doc"""
-    popdisplay()
-    popdisplay(d::Display)
-
-Pop the topmost backend off of the display-backend stack, or the topmost copy of `d` in the second variant.
-"""
-popdisplay
-
-doc"""
-    readdlm(source, delim::Char, T::Type, eol::Char; header=false, skipstart=0, skipblanks=true, use_mmap, ignore_invalid_chars=false, quotes=true, dims, comments=true, comment_char='#')
-
-Read a matrix from the source where each line (separated by `eol`) gives one row, with elements separated by the given delimeter. The source can be a text file, stream or byte array. Memory mapped files can be used by passing the byte array representation of the mapped segment as source.
-
-If `T` is a numeric type, the result is an array of that type, with any non-numeric elements as `NaN` for floating-point types, or zero. Other useful values of `T` include `ASCIIString`, `AbstractString`, and `Any`.
-
-If `header` is `true`, the first row of data will be read as header and the tuple `(data_cells, header_cells)` is returned instead of only `data_cells`.
-
-Specifying `skipstart` will ignore the corresponding number of initial lines from the input.
-
-If `skipblanks` is `true`, blank lines in the input will be ignored.
-
-If `use_mmap` is `true`, the file specified by `source` is memory mapped for potential speedups. Default is `true` except on Windows. On Windows, you may want to specify `true` if the file is large, and is only read once and not written to.
-
-If `ignore_invalid_chars` is `true`, bytes in `source` with invalid character encoding will be ignored. Otherwise an error is thrown indicating the offending character position.
-
-If `quotes` is `true`, column enclosed within double-quote (") characters are allowed to contain new lines and column delimiters. Double-quote characters within a quoted field must be escaped with another double-quote.  Specifying `dims` as a tuple of the expected rows and columns (including header, if any) may speed up reading of large files.  If `comments` is `true`, lines beginning with `comment_char` and text following `comment_char` in any line are ignored.
-"""
-readdlm(source, delim, T, eol)
-
-doc"""
-    readdlm(source, delim::Char, eol::Char; options...)
-
-If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a cell array of numbers and strings is returned.
-"""
-readdlm(source, delim::Char, eol::Char)
-
-doc"""
-    readdlm(source, delim::Char, T::Type; options...)
-
-The end of line delimiter is taken as `n`.
-"""
-readdlm(source, delim::Char, T::Type)
-
-doc"""
-    readdlm(source, delim::Char; options...)
-
-The end of line delimiter is taken as `n`. If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a cell array of numbers and strings is returned.
-"""
-readdlm(source, delim::Char)
-
-doc"""
-    readdlm(source, T::Type; options...)
-
-The columns are assumed to be separated by one or more whitespaces. The end of line delimiter is taken as `n`.
-"""
-readdlm(source, T::Type)
-
-doc"""
-    readdlm(source; options...)
-
-The columns are assumed to be separated by one or more whitespaces. The end of line delimiter is taken as `n`. If all data is numeric, the result will be a numeric array. If some elements cannot be parsed as numbers, a cell array of numbers and strings is returned.
-"""
-readdlm(source)
-
-doc"""
-    filesize(path...)
-
-Equivalent to `stat(file).size`
-"""
-filesize
-
-doc"""
-    sinc(x)
-
-Compute $\sin(\pi x) / (\pi x)$ if $x \neq 0$, and $1$ if $x = 0$.
-"""
-sinc
-
-doc"""
-    utf16(s)
-
-Create a UTF-16 string from a byte array, array of `UInt16`, or any other string type. (Data must be valid UTF-16. Conversions of byte arrays check for a byte-order marker in the first two bytes, and do not include it in the resulting string.)
-
-Note that the resulting `UTF16String` data is terminated by the NUL codepoint (16-bit zero), which is not treated as a character in the string (so that it is mostly invisible in Julia); this allows the string to be passed directly to external functions requiring NUL-terminated data. This NUL is appended automatically by the `utf16(s)` conversion function. If you have a `UInt16` array `A` that is already NUL-terminated valid UTF-16 data, then you can instead use `UTF16String(A)` to construct the string without making a copy of the data and treating the NUL as a terminator rather than as part of the string.
-"""
-utf16(s)
-
-doc"""
-    utf16(::Union{Ptr{UInt16},Ptr{Int16}} [, length])
-
-Create a string from the address of a NUL-terminated UTF-16 string. A copy is made; the pointer can be safely freed. If `length` is specified, the string does not have to be NUL-terminated.
-"""
-utf16(::Union{Ptr{UInt16},Ptr{Int16}}, length=?)
-
-doc"""
-    median(v[, region])
-
-Compute the median of whole array `v`, or optionally along the dimensions in `region`. For even number of elements no exact median element exists, so the result is equivalent to calculating mean of two median elements. `NaN` is returned if the data contains any `NaN` values. For applications requiring the handling of missing data, the `DataArrays` package is recommended.
-"""
-median
-
-doc"""
-    cglobal((symbol, library) [, type=Void])
-
-Obtain a pointer to a global variable in a C-exported shared library, specified exactly as in `ccall`. Returns a `Ptr{Type}`, defaulting to `Ptr{Void}` if no Type argument is supplied. The values can be read or written by `unsafe_load` or `unsafe_store!`, respectively.
-"""
-cglobal
-
-doc"""
-    one(x)
-
-Get the multiplicative identity element for the type of `x` (`x` can also specify the type itself). For matrices, returns an identity matrix of the appropriate size and type.
-"""
-one
-
-doc"""
-    parseip(addr)
-
-Parse a string specifying an IPv4 or IPv6 ip address.
-"""
-parseip
-
-doc"""
-    rationalize([Type=Int,] x; tol=eps(x))
-
-Approximate floating point number `x` as a Rational number with components of the given integer type. The result will differ from `x` by no more than `tol`.
-"""
-rationalize
-
-doc"""
-    splice!(collection, index, [replacement]) -> item
-
-Remove the item at the given index, and return the removed item. Subsequent items
-are shifted down to fill the resulting gap. If specified, replacement values from
-an ordered collection will be spliced in place of the removed item.
-
-```jldoctest
-julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
-2
-
-julia> A
-5-element Array{Int64,1}:
- 6
- 5
- 4
- 3
- 1
-
-julia> splice!(A, 5, -1)
-1
-
-julia> A
-5-element Array{Int64,1}:
-  6
-  5
-  4
-  3
- -1
-
-julia> splice!(A, 1, [-1, -2, -3])
-6
-
-julia> A
-7-element Array{Int64,1}:
- -1
- -2
- -3
-  5
-  4
-  3
- -1
-```
-
-To insert `replacement` before an index `n` without removing any items, use
-`splice!(collection, n:n-1, replacement)`.
-"""
-splice!(collection, index, replacement = ?)
-
-doc"""
-    splice!(collection, range, [replacement]) -> items
-
-Remove items in the specified index range, and return a collection containing the
-removed items. Subsequent items are shifted down to fill the resulting gap.
-If specified, replacement values from an ordered collection will be spliced in place
-of the removed items.
-
-To insert `replacement` before an index `n` without removing any items, use
-`splice!(collection, n:n-1, replacement)`.
-
-```jldoctest
-julia> splice!(A, 4:3, 2)
-0-element Array{Int64,1}
-
-julia> A
-8-element Array{Int64,1}:
- -1
- -2
- -3
-  2
-  5
-  4
-  3
- -1
-```
-"""
-splice!(collection, range::Range, replacement)
-
-doc"""
-    endof(collection) -> Integer
-
-Returns the last index of the collection.
-
-```jldoctest
-julia> endof([1,2,4])
-3
-```
-"""
-endof
-
-doc"""
-    isfifo(path) -> Bool
-
-Returns `true` if `path` is a FIFO, `false` otherwise.
-"""
-isfifo
-
-doc"""
-    Channel{T}(sz::Int)
-
-Constructs a `Channel` that can hold a maximum of `sz` objects of type `T`. `put!` calls on a full channel block till an object is removed with `take!`.
-
-Other constructors:
-
-- `Channel()` - equivalent to `Channel{Any}(32)`
-- `Channel(sz::Int)` equivalent to `Channel{Any}(sz)`
-"""
-Channel
-
-doc"""
-    next(iter, state) -> item, state
-
-For a given iterable object and iteration state, return the current item and the next iteration state
-"""
-next
-
-doc"""
-```rst
-..  irfft(A, d [, dims])
-
-Inverse of :func:`rfft`: for a complex array ``A``, gives the
-corresponding real array whose FFT yields ``A`` in the first half.
-As for :func:`rfft`, ``dims`` is an optional subset of dimensions
-to transform, defaulting to ``1:ndims(A)``.
-
-``d`` is the length of the transformed real array along the ``dims[1]``
-dimension, which must satisfy ``div(d,2)+1 == size(A,dims[1])``.
-(This parameter cannot be inferred from ``size(A)`` since both
-``2*size(A,dims[1])-2`` as well as ``2*size(A,dims[1])-1`` are valid sizes
-for the transformed real array.)
-```
-"""
-irfft
-
-doc"""
-    nnz(A)
-
-Returns the number of stored (filled) elements in a sparse matrix.
-"""
-nnz
-
-doc"""
-    unshift!(collection, items...) -> collection
-
-Insert one or more `items` at the beginning of `collection`.
-
-```jldoctest
-  julia> unshift!([1, 2, 3, 4], 5, 6)
-  6-element Array{Int64,1}:
-   5
-   6
-   1
-   2
-   3
-   4
-```
-"""
-unshift!
-
-doc"""
-    log2(x)
-
-Compute the logarithm of `x` to base 2. Throws `DomainError` for negative `Real` arguments.
-"""
-log2
-
-doc"""
-```rst
-..  SymTridiagonal(d, du)
-
-Construct a real symmetric tridiagonal matrix from the diagonal and upper diagonal, respectively. The result is of type ``SymTridiagonal`` and provides efficient specialized eigensolvers, but may be converted into a regular matrix with :func:`full`.
-```
-"""
-SymTridiagonal
-
-doc"""
-    spzeros(m,n)
-
-Create a sparse matrix of size `m x n`. This sparse matrix will not contain any nonzero values. No storage will be allocated for nonzero values during construction.
-"""
-spzeros
-
-doc"""
-    colon(start, [step], stop)
-
-Called by `:` syntax for constructing ranges.
-"""
-colon
-
-doc"""
-    Base64EncodePipe(ostream)
-
-Returns a new write-only I/O stream, which converts any bytes written to it into base64-encoded ASCII bytes written to `ostream`. Calling `close` on the `Base64Pipe` stream is necessary to complete the encoding (but does not close `ostream`).
-"""
-Base64EncodePipe
-
-doc"""
-    issetgid(path) -> Bool
-
-Returns `true` if `path` has the setgid flag set, `false` otherwise.
-"""
-issetgid
-
-doc"""
-    isnull(x)
-
-Is the `Nullable` object `x` null, i.e. missing a value?
-"""
-isnull
-
-doc"""
-    abs2(x)
-
-Squared absolute value of `x`
-"""
-abs2
-
-doc"""
-    write(stream, x)
-
-Write the canonical binary representation of a value to the given stream.
-"""
-write
-
-doc"""
-    sizehint!(s, n)
-
-Suggest that collection `s` reserve capacity for at least `n` elements. This can improve performance.
-"""
-sizehint!
-
-doc"""
-    permute!(v, p)
-
-Permute vector `v` in-place, according to permutation `p`. No checking is done to verify that `p` is a permutation.
-
-To return a new permutation, use `v[p]`. Note that this is generally faster than `permute!(v,p)` for large vectors.
-"""
-permute!
-
-doc"""
-    ifelse(condition::Bool, x, y)
-
-Return `x` if `condition` is `true`, otherwise return `y`. This differs from `?` or `if` in that it is an ordinary function, so all the arguments are evaluated first. In some cases, using `ifelse` instead of an `if` statement can eliminate the branch in generated code and provide higher performance in tight loops.
-"""
-ifelse
-
-doc"""
-    ispow2(n) -> Bool
-
-Test whether `n` is a power of two
-"""
-ispow2
-
-doc"""
-    vcat(A...)
-
-Concatenate along dimension 1
-"""
-vcat
-
-doc"""
-    isgraph(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is printable, and not a space, or whether this is true for all elements of a string. Any character that would cause a printer to use ink should be classified with `isgraph(c)==true`.
-"""
-isgraph
-
-doc"""
-    OutOfMemoryError()
-
-An operation allocated too much memory for either the system or the garbage collector to handle properly.
-"""
-OutOfMemoryError
-
-doc"""
-```rst
-..  zip(iters...)
-
-For a set of iterable objects, returns an iterable of tuples, where the ``i``\ th tuple contains the ``i``\ th component of each input iterable.
-
-Note that :func:`zip` is its own inverse: ``collect(zip(zip(a...)...)) == collect(a)``.
-```
-"""
-zip
-
-doc"""
-    SystemError(prefix::AbstractString, [errno::Int32])
-
-A system call failed with an error code (in the `errno` global variable).
-"""
-SystemError
-
-doc"""
-    binomial(n,k)
-
-Number of ways to choose `k` out of `n` items
-"""
-binomial
-
-doc"""
-    rot180(A)
-
-Rotate matrix `A` 180 degrees.
-"""
-rot180(A)
-
-doc"""
-    rot180(A, k)
-
-Rotate matrix `A` 180 degrees an integer `k` number of times. If `k` is even, this is equivalent to a `copy`.
-"""
-rot180(A, k)
-
-doc"""
-    .<=(x, y)
-    .≤(x,y)
-
-Element-wise less-than-or-equals comparison operator.
-"""
-Base.(:(.<=))
-
-doc"""
-    checkbounds(array, indexes...)
-
-Throw an error if the specified indexes are not in bounds for the given array.
-Subtypes of `AbstractArray` should specialize this method if they need to
-provide custom bounds checking behaviors.
-"""
-checkbounds(array, indexes...)
-
-doc"""
-    checkbounds(::Type{Bool}, dimlength::Integer, index)
-
-Return a `Bool` describing if the given index is within the bounds of the given
-dimension length. Custom types that would like to behave as indices for all
-arrays can extend this method in order to provide a specialized bounds checking
-implementation.
-"""
-checkbounds(::Type{Bool}, ::Integer, index)
-
-doc"""
-    asec(x)
-
-Compute the inverse secant of `x`, where the output is in radians
-"""
-asec
-
-doc"""
-    rank(M)
-
-Compute the rank of a matrix.
-"""
-rank
-
-doc"""
-    max(x, y, ...)
-
-Return the maximum of the arguments. Operates elementwise over arrays.
-"""
-max
-
-doc"""
-    versioninfo([verbose::Bool])
-
-Print information about the version of Julia in use. If the `verbose` argument is `true`, detailed system information is shown as well.
-"""
-versioninfo
-
-doc"""
-    DimensionMismatch([msg])
-
-The objects called do not have matching dimensionality.
-Optional argument `msg` is a descriptive error string.
-"""
-DimensionMismatch
-
-doc"""
-    take!(RemoteRef)
-
-Fetch the value of a remote reference, removing it so that the reference is empty again.
-"""
-take!(::RemoteRef)
-
-doc"""
-    take!(Channel)
-
-Removes and returns a value from a `Channel`. Blocks till data is available.
-"""
-take!(::Channel)
-
-doc"""
-```rst
-..  ifft!(A [, dims])
-
-Same as :func:`ifft`, but operates in-place on ``A``.
-```
-"""
-ifft!
-
-doc"""
-    sort!(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Sort the vector `v` in place. `QuickSort` is used by default for numeric arrays while `MergeSort` is used for other arrays. You can specify an algorithm to use via the `alg` keyword (see Sorting Algorithms for available algorithms). The `by` keyword lets you provide a function that will be applied to each element before comparison; the `lt` keyword allows providing a custom "less than" function; use `rev=true` to reverse the sorting order. These options are independent and can be used together in all possible combinations: if both `by` and `lt` are specified, the `lt` function is applied to the result of the `by` function; `rev=true` reverses whatever ordering specified via the `by` and `lt` keywords.
-"""
-sort!
-
-doc"""
-    kill(p::Process, signum=SIGTERM)
-
-Send a signal to a process. The default is to terminate the process.
-"""
-kill(p::Process, signum=SIGTERM)
-
-doc"""
-    kill(manager::FooManager, pid::Int, config::WorkerConfig)
-
-Implemented by cluster managers. It is called on the master process, by `rmprocs`. It should cause the remote worker specified by `pid` to exit. `Base.kill(manager::ClusterManager.....)` executes a remote `exit()` on `pid`
-"""
-kill(manager, pid::Int, config::WorkerConfig)
-
-doc"""
-```rst
-..  logm(A)
-
-If ``A`` has no negative real eigenvalue, compute the principal matrix logarithm of ``A``, i.e. the unique matrix :math:`X` such that :math:`e^X = A` and :math:`-\pi < Im(\lambda) < \pi` for all the eigenvalues :math:`\lambda` of :math:`X`. If ``A`` has nonpositive eigenvalues, a warning is printed and whenever possible a nonprincipal matrix function is returned.
-
-If ``A`` is symmetric or Hermitian, its eigendecomposition (:func:`eigfact`) is used, if ``A`` is triangular an improved version of the inverse scaling and squaring method is employed (see [AH12]_ and [AHR13]_). For general matrices, the complex Schur form (:func:`schur`) is computed and the triangular algorithm is used on the triangular factor.
-
-.. [AH12] Awad H. Al-Mohy and Nicholas J. Higham, "Improved inverse  scaling
-   and squaring algorithms for the matrix logarithm", SIAM Journal on
-   Scientific Computing, 34(4), 2012, C153-C169.
-   `doi:10.1137/110852553 <http://dx.doi.org/10.1137/110852553>`_
-.. [AHR13] Awad H. Al-Mohy, Nicholas J. Higham and Samuel D. Relton,
-   "Computing the Fréchet derivative of the matrix logarithm and estimating
-   the condition number", SIAM Journal on Scientific Computing, 35(4), 2013,
-   C394-C410.
-   `doi:10.1137/120885991 <http://dx.doi.org/10.1137/120885991>`_
-```
-"""
-logm
-
-doc"""
-    sylvester(A, B, C)
-
-Computes the solution `X` to the Sylvester equation `AX + XB + C = 0`, where `A`, `B` and `C` have compatible dimensions and `A` and `-B` have no eigenvalues with equal real part.
-"""
-sylvester
-
-doc"""
-    broadcast!(f, dest, As...)
-
-Like `broadcast`, but store the result of `broadcast(f, As...)` in the `dest` array. Note that `dest` is only used to store the result, and does not supply arguments to `f` unless it is also listed in the `As`, as in `broadcast!(f, A, A, B)` to perform `A[:] = broadcast(f, A, B)`.
-"""
-broadcast!
-
-doc"""
-    cross(x, y)
-    ×(x,y)
-
-Compute the cross product of two 3-vectors.
-"""
-cross
-
-doc"""
-    strides(A)
-
-Returns a tuple of the memory strides in each dimension
-"""
-strides
-
-doc"""
-    keys(collection)
-
-Return an iterator over all keys in a collection. `collect(keys(d))` returns an array of keys.
-"""
-keys
-
-doc"""
-    repeat(A, inner = Int[], outer = Int[])
-
-Construct an array by repeating the entries of `A`. The i-th element of `inner` specifies the number of times that the individual entries of the i-th dimension of `A` should be repeated. The i-th element of `outer` specifies the number of times that a slice along the i-th dimension of `A` should be repeated.
-"""
-repeat
-
-doc"""
-    scale(A, b)
-    scale(b, A)
-
-Scale an array `A` by a scalar `b`, returning a new array.
-
-If `A` is a matrix and `b` is a vector, then `scale(A,b)` scales each column `i` of `A` by `b[i]` (similar to `A*diagm(b)`), while `scale(b,A)` scales each row `i` of `A` by `b[i]` (similar to `diagm(b)*A`), returning a new array.
-
-Note: for large `A`, `scale` can be much faster than `A .* b` or `b .* A`, due to the use of BLAS.
-"""
-scale
-
-doc"""
-    ReentrantLock()
-
-Creates a reentrant lock. The same task can acquire the lock as many times as required. Each lock must be matched with an unlock.
-"""
-ReentrantLock
-
-doc"""
-    real(z)
-
-Return the real part of the complex number `z`
-"""
-real
-
-doc"""
-    gperm(file)
-
-Like uperm but gets the permissions of the group owning the file
-"""
-gperm
-
-doc"""
-```rst
-..  idct(A [, dims])
-
-Computes the multidimensional inverse discrete cosine transform (DCT)
-of the array ``A`` (technically, a type-III DCT with the unitary
-normalization).
-The optional ``dims`` argument specifies an iterable subset of
-dimensions (e.g. an integer, range, tuple, or array) to transform
-along.  Most efficient if the size of ``A`` along the transformed
-dimensions is a product of small primes; see :func:`nextprod`.  See
-also :func:`plan_idct` for even greater efficiency.
-```
-"""
-idct
-
-doc"""
-    nb_available(stream)
-
-Returns the number of bytes available for reading before a read from this stream or buffer will block.
-"""
-nb_available
-
-doc"""
-    finalize(x)
-
-Immediately run finalizers registered for object `x`.
-"""
-finalize
-
-doc"""
-    rand([rng], [S], [dims...])
-
-Pick a random element or array of random elements from the set of values specified by `S`; `S` can be
-
-* an indexable collection (for example `1:n` or `['x','y','z']`), or
-* a type: the set of values to pick from is then equivalent to
-`typemin(S):typemax(S)` for integers (this is not applicable to `BigInt`),
-and to $[0, 1)$ for floating point numbers;
-
-`S` defaults to `Float64`.
-"""
-rand
-
-doc"""
-    bitpack(A::AbstractArray{T,N}) -> BitArray
-
-Converts a numeric array to a packed boolean array
-"""
-bitpack
-
-doc"""
-    base(base, n, [pad])
-
-Convert an integer to a string in the given base, optionally specifying a number of digits to pad to. The base can be specified as either an integer, or as a `UInt8` array of character values to use as digit symbols.
-"""
-base
-
-doc"""
-    Timer(callback::Function, delay, repeat=0)
-
-Create a timer to call the given `callback` function. The `callback` is passed one argument, the timer object itself. The callback will be invoked after the specified initial `delay`, and then repeating with the given `repeat` interval. If `repeat` is `0`, the timer is only triggered once. Times are in seconds. A timer is stopped and has its resources freed by calling `close` on it.
-"""
-Timer(::Function,delay,repeat=0)
-
-doc"""
-    Timer(delay, repeat=0)
-
-Create a timer that wakes up tasks waiting for it (by calling `wait` on the timer object) at a specified interval.  Times are in seconds.  Waiting tasks are woken with an error when the timer is closed (by `close`). Use `isopen` to check whether a timer is still active.
-"""
-Timer(delay, repeat=0)
-
-doc"""
-    BoundsError([a],[i])
-
-An indexing operation into an array, `a`, tried to access an out-of-bounds element, `i`.
-"""
-BoundsError
-
-doc"""
-    disable_sigint(f::Function)
-
-Disable Ctrl-C handler during execution of a function, for calling external code that is not interrupt safe. Intended to be called using `do` block syntax as follows:
-
-    disable_sigint() do
-        # interrupt-unsafe code
-        ...
-    end
-"""
-disable_sigint
-
-doc"""
-```rst
-..  svdfact!(A, [thin=true]) -> SVD
-
-``svdfact!`` is the same as :func:`svdfact`, but saves space by overwriting the input ``A``, instead of creating a copy. If ``thin`` is ``true``, an economy mode decomposition is returned. The default is to produce a thin decomposition.
-```
-"""
-svdfact!
-
-doc"""
-    hist2d(M, e1, e2) -> (edge1, edge2, counts)
-
-Compute a "2d histogram" of a set of N points specified by N-by-2 matrix `M`. Arguments `e1` and `e2` are bins for each dimension, specified either as integer bin counts or vectors of bin edges. The result is a tuple of `edge1` (the bin edges used in the first dimension), `edge2` (the bin edges used in the second dimension), and `counts`, a histogram matrix of size `(length(edge1)-1, length(edge2)-1)`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-hist2d
-
-doc"""
-    which(f, types)
-
-Returns the method of `f` (a `Method` object) that would be called for arguments of the given `types`.
-
-If `types` is an abstract type, then the method that would be called by `invoke` is returned.
-"""
-which(f, types)
-
-doc"""
-    which(symbol)
-
-Return the module in which the binding for the variable referenced by `symbol` was created.
-"""
-which(symbol)
-
-doc"""
-    conv2(u,v,A)
-
-2-D convolution of the matrix `A` with the 2-D separable kernel generated by the vectors `u` and `v`. Uses 2-D FFT algorithm
-"""
-conv2(u, v, A)
-
-doc"""
-    conv2(B,A)
-
-2-D convolution of the matrix `B` with the matrix `A`. Uses 2-D FFT algorithm
-"""
-conv2(B, A)
-
-doc"""
-    broadcast_getindex(A, inds...)
-
-Broadcasts the `inds` arrays to a common size like `broadcast`, and returns an array of the results `A[ks...]`, where `ks` goes over the positions in the broadcast.
-"""
-broadcast_getindex
-
-doc"""
-    findn(A)
-
-Return a vector of indexes for each dimension giving the locations of the non-zeros in `A` (determined by `A[i]!=0`).
-"""
-findn
-
-doc"""
-    invoke(f, (types...), args...)
-
-Invoke a method for the given generic function matching the specified types (as a tuple), on the specified arguments. The arguments must be compatible with the specified types. This allows invoking a method other than the most specific matching method, which is useful when the behavior of a more general definition is explicitly needed (often as part of the implementation of a more specific method of the same function).
-"""
-invoke
-
-doc"""
-    parse(str, start; greedy=true, raise=true)
-
-Parse the expression string and return an expression (which could later be passed to eval for execution). `start` is the index of the first character to start parsing. If `greedy` is `true` (default), `parse` will try to consume as much input as it can; otherwise, it will stop as soon as it has parsed a valid expression. Incomplete but otherwise syntactically valid expressions will return `Expr(:incomplete, "(error message)")`. If `raise` is `true` (default), syntax errors other than incomplete expressions will raise an error. If `raise` is `false`, `parse` will return an expression that will raise an error upon evaluation.
-"""
-parse(str, start)
-
-doc"""
-    parse(str; raise=true)
-
-Parse the expression string greedily, returning a single expression. An error is thrown if there are additional characters after the first expression. If `raise` is `true` (default), syntax errors will raise an error; otherwise, `parse` will return an expression that will raise an error upon evaluation.
-"""
-parse(str)
-
-doc"""
-    parse(type, str, [base])
-
-Parse a string as a number. If the type is an integer type, then a base can be specified (the default is 10). If the type is a floating point type, the string is parsed as a decimal floating point number. If the string does not contain a valid number, an error is raised.
-"""
-parse(T::Type, str, base=Int)
-
-doc"""
-    touch(path::AbstractString)
-
-Update the last-modified timestamp on a file to the current time.
-"""
-touch
-
-doc"""
-```rst
-..  bkfact!(A) -> BunchKaufman
-
-``bkfact!`` is the same as :func:`bkfact`, but saves space by overwriting the input ``A``, instead of creating a copy.
-```
-"""
-bkfact!
-
-doc"""
-    ^(x, y)
-
-Exponentiation operator.
-"""
-Base.(:(^))(x, y)
-
-doc"""
-    ^(s, n)
-
-Repeat `n` times the string `s`. The `repeat` function is an alias to this operator.
-
-```jldoctest
-julia> "Test "^3
-"Test Test Test "
-```
-"""
-Base.(:(^))(s::AbstractString, n::Int)
-
-doc"""
-    position(s)
-
-Get the current position of a stream.
-"""
-position
-
-doc"""
-    selectperm(v, k, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Return a partial permutation of the the vector `v`, according to the order specified by `by`, `lt` and `rev`, so that `v[output]` returns the first `k` (or range of adjacent values if `k` is a range) values of a fully sorted version of `v`. If `k` is a single index (Integer), an array of the first `k` indices is returned; if `k` is a range, an array of those indices is returned. Note that the handling of integer values for `k` is different from `select` in that it returns a vector of `k` elements instead of just the `k` th element. Also note that this is equivalent to, but more efficient than, calling `sortperm(...)[k]`
-"""
-selectperm
-
-doc"""
-    isabspath(path::AbstractString) -> Bool
-
-Determines whether a path is absolute (begins at the root directory).
-"""
-isabspath
-
-doc"""
-    hex2bytes(s::ASCIIString)
-
-Convert an arbitrarily long hexadecimal string to its binary representation. Returns an `Array{UInt8,1}`, i.e. an array of bytes.
-"""
-hex2bytes
-
-doc"""
-    isdir(path) -> Bool
-
-Returns `true` if `path` is a directory, `false` otherwise.
-"""
-isdir
-
-doc"""
-    reinterpret(type, A)
-
-Change the type-interpretation of a block of memory. For example, `reinterpret(Float32, UInt32(7))` interprets the 4 bytes corresponding to `UInt32(7)` as a `Float32`. For arrays, this constructs an array with the same binary data as the given array, but with the specified element type.
-"""
-reinterpret
-
-doc"""
-    squeeze(A, dims)
-
-Remove the dimensions specified by `dims` from array `A`. Elements of `dims` must be unique and within the range `1:ndims(A)`.
-"""
-squeeze
-
-doc"""
-    ~(x)
-
-Bitwise not
-"""
-~
-
-doc"""
-    hankelh1(nu, x)
-
-Bessel function of the third kind of order `nu`, $H^{(1)}_\nu(x)$.
-"""
-hankelh1
-
-doc"""
-```rst
-..  hessfact(A)
-
-Compute the Hessenberg decomposition of ``A`` and return a ``Hessenberg`` object. If ``F`` is the factorization object, the unitary matrix can be accessed with ``F[:Q]`` and the Hessenberg matrix with ``F[:H]``. When ``Q`` is extracted, the resulting type is the ``HessenbergQ`` object, and may be converted to a regular matrix with :func:`full`.
-```
-"""
-hessfact
-
-doc"""
-```rst
-..  gcdx(x,y)
-
-Computes the greatest common (positive) divisor of ``x`` and ``y`` and their Bézout coefficients, i.e. the integer coefficients ``u`` and ``v`` that satisfy :math:`ux+vy = d = gcd(x,y)`.
-
-.. doctest::
-
-   julia> gcdx(12, 42)
-   (6,-3,1)
-
-.. doctest::
-
-   julia> gcdx(240, 46)
-   (2,-9,47)
-
-.. note::
-
-   Bézout coefficients are *not* uniquely defined. ``gcdx`` returns the minimal Bézout coefficients that are computed by the extended Euclid algorithm. (Ref: D. Knuth, TAoCP, 2/e, p. 325, Algorithm X.) These coefficients ``u`` and ``v`` are minimal in the sense that :math:`|u| < |\frac y d` and :math:`|v| < |\frac x d`. Furthermore, the signs of ``u`` and ``v`` are chosen so that ``d`` is positive.
-```
-"""
-gcdx
-
-doc"""
-    rem(x, y)
-    %(x, y)
-
-Remainder from Euclidean division, returning a value of the same sign as `x`, and smaller in magnitude than `y`. This value is always exact.
-"""
-rem
-
-doc"""
-    rotl90(A)
-
-Rotate matrix `A` left 90 degrees.
-"""
-rotl90(A)
-
-doc"""
-    rotl90(A, k)
-
-Rotate matrix `A` left 90 degrees an integer `k` number of times. If `k` is zero or a multiple of four, this is equivalent to a `copy`.
-"""
-rotl90(A, k)
-
-doc"""
-    info(msg)
-
-Display an informational message.
-Argument `msg` is a string describing the information to be displayed.
-"""
-info
-
-doc"""
-    eigmin(A)
-
-Returns the smallest eigenvalue of `A`.
-"""
-eigmin
-
-doc"""
-    acscd(x)
-
-Compute the inverse cosecant of `x`, where the output is in degrees
-"""
-acscd
-
-doc"""
-    ltoh(x)
-
-Converts the endianness of a value from Little-endian to that used by the Host.
-"""
-ltoh
-
-doc"""
-    evalfile(path::AbstractString)
-
-Load the file using `include`, evaluate all expressions, and return the value of the last one.
-"""
-evalfile
-
-doc"""
-    success(command)
-
-Run a command object, constructed with backticks, and tell whether it was successful (exited with a code of 0). An exception is raised if the process cannot be started.
-"""
-success
-
-doc"""
-```rst
-..  sortperm!(ix, v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false,] [initialized=false])
-
-Like ``sortperm``, but accepts a preallocated index vector ``ix``.  If ``initialized`` is ``false``
-(the default), ix is initialized to contain the values ``1:length(v)``.
-
-See also :func:`sortperm`
-```
-"""
-sortperm!
-
-doc"""
-    isodd(x::Integer) -> Bool
-
-Returns `true` if `x` is odd (that is, not divisible by 2), and `false` otherwise.
-
-```jldoctest
-julia> isodd(9)
-true
-
-julia> isodd(10)
-false
-```
-"""
-isodd
-
-doc"""
-    normalize_string(s, normalform::Symbol)
-
-Normalize the string `s` according to one of the four "normal
-forms" of the Unicode standard: `normalform` can be `:NFC`,
-`:NFD`, `:NFKC`, or `:NFKD`.  Normal forms C (canonical
-composition) and D (canonical decomposition) convert different
-visually identical representations of the same abstract string into
-a single canonical form, with form C being more compact.  Normal
-forms KC and KD additionally canonicalize "compatibility
-equivalents": they convert characters that are abstractly similar
-but visually distinct into a single canonical choice (e.g. they expand
-ligatures into the individual characters), with form KC being more compact.
-
-Alternatively, finer control and additional transformations may be
-be obtained by calling `normalize_string(s; keywords...)`, where
-any number of the following boolean keywords options (which all default
-to `false` except for `compose`) are specified:
-
-* `compose=false`: do not perform canonical composition
-* `decompose=true`: do canonical decomposition instead of canonical composition (`compose=true` is ignored if present)
-* `compat=true`: compatibility equivalents are canonicalized
-* `casefold=true`: perform Unicode case folding, e.g. for case-insensitive string comparison
-* `newline2lf=true`, `newline2ls=true`, or `newline2ps=true`: convert various newline sequences (LF, CRLF, CR, NEL) into a linefeed (LF), line-separation (LS), or paragraph-separation (PS) character, respectively
-* `stripmark=true`: strip diacritical marks (e.g. accents)
-* `stripignore=true`: strip Unicode's "default ignorable" characters (e.g. the soft hyphen or the left-to-right marker)
-* `stripcc=true`: strip control characters; horizontal tabs and form feeds are converted to spaces; newlines are also converted to spaces unless a newline-conversion flag was specified
-* `rejectna=true`: throw an error if unassigned code points are found
-* `stable=true`: enforce Unicode Versioning Stability
-
-For example, NFKC corresponds to the options `compose=true, compat=true, stable=true`.
-"""
-normalize_string
-
-doc"""
-    cd([dir::AbstractString=homedir()])
-
-Set the current working directory.
-"""
-cd(dir::AbstractString)
-
-doc"""
-    cd(f, [dir=homedir()])
-
-Temporarily changes the current working directory and applies function `f` before returning.
-"""
-cd(f, dir=?)
-
-doc"""
-    hton(x)
-
-Converts the endianness of a value from that used by the Host to Network byte order (big-endian).
-"""
-hton
-
-doc"""
-    is(x, y) -> Bool
-    ===(x,y) -> Bool
-    ≡(x,y) -> Bool
-
-Determine whether `x` and `y` are identical, in the sense that no program could distinguish them. Compares mutable objects by address in memory, and compares immutable objects (such as numbers) by contents at the bit level. This function is sometimes called `egal`.
-"""
-is(x,y)
-
-doc"""
-```rst
-..  mark(s)
-
-Add a mark at the current position of stream ``s``.  Returns the marked position.
-
-See also :func:`unmark`, :func:`reset`, :func:`ismarked`
-```
-"""
-mark
-
-doc"""
-    cp(src::AbstractString, dst::AbstractString; remove_destination::Bool=false, follow_symlinks::Bool=false)
-
-Copy the file, link, or directory from *src* to *dest*. `remove_destination=true` will first remove an existing `dst`.
-
-If `follow_symlinks=false`, and `src` is a symbolic link, `dst` will be created as a symbolic link. If `follow_symlinks=true` and `src` is a symbolic link, `dst` will be a copy of the file or directory `src` refers to.
-"""
-cp
-
-doc"""
-    bswap(n)
-
-Byte-swap an integer
-"""
-bswap
-
-doc"""
-```rst
-.. manage(manager::FooManager, pid::Int, config::WorkerConfig. op::Symbol)
-
-Implemented by cluster managers. It is called on the master process, during a worker's lifetime,
-with appropriate ``op`` values:
-
-    - with ``:register``/``:deregister`` when a worker is added / removed
-      from the Julia worker pool.
-    - with ``:interrupt`` when ``interrupt(workers)`` is called. The
-      :class:`ClusterManager` should signal the appropriate worker with an
-      interrupt signal.
-    - with ``:finalize`` for cleanup purposes.
-```
-"""
-manage
-
-doc"""
-    resize!(collection, n) -> collection
-
-Resize `collection` to contain `n` elements.
-If `n` is smaller than the current collection length, the first `n`
-elements will be retained. If `n` is larger, the new elements are not
-guaranteed to be initialized.
-
-```jldoctest
-julia> resize!([6, 5, 4, 3, 2, 1], 3)
-3-element Array{Int64,1}:
- 6
- 5
- 4
-```
-
-```jl
-julia> resize!([6, 5, 4, 3, 2, 1], 8)
-8-element Array{Int64,1}:
- 6
- 5
- 4
- 3
- 2
- 1
- 0
- 0
-```
-"""
-resize!
-
-doc"""
-    sumabs2!(r, A)
-
-Sum squared absolute values of elements of `A` over the singleton dimensions of `r`, and write results to `r`.
-"""
-sumabs2!
-
-doc"""
-    IPv4(host::Integer) -> IPv4
-
-Returns IPv4 object from ip address formatted as Integer
-"""
-IPv4
-
-doc"""
-    trailing_zeros(x::Integer) -> Integer
-
-Number of zeros trailing the binary representation of `x`.
-
-```jldoctest
-julia> trailing_zeros(2)
-1
-```
-"""
-trailing_zeros
-
-doc"""
-    etree(A[, post])
-
-Compute the elimination tree of a symmetric sparse matrix `A` from `triu(A)` and, optionally, its post-ordering permutation.
-"""
-etree
-
-doc"""
-    isalnum(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is alphanumeric, or whether this is true for all elements of a string. A character is classified as alphabetic if it belongs to the Unicode general category Letter or Number, i.e. a character whose category code begins with 'L' or 'N'.
-"""
-isalnum
-
-doc"""
-```rst
-..  dct!(A [, dims])
-
-Same as :func:`dct!`, except that it operates in-place
-on ``A``, which must be an array of real or complex floating-point
-values.
-```
-"""
-dct!
-
-doc"""
-    @sprintf("%Fmt", args...)
-
-Return `@printf` formatted output as string.
-
-    julia> s = @sprintf "this is a %s %15.1f" "test" 34.567;
-
-    julia> println(s)
-    this is a test            34.6
-"""
-:@sprintf
-
-doc"""
-    tanh(x)
-
-Compute hyperbolic tangent of `x`
-"""
-tanh
-
-doc"""
-    repr(x)
-
-Create a string from any value using the `showall` function.
-"""
-repr
-
-doc"""
-    maxintfloat(T)
-
-The largest integer losslessly representable by the given floating-point DataType `T`.
-"""
-maxintfloat
-
-doc"""
-    promote_shape(s1, s2)
-
-Check two array shapes for compatibility, allowing trailing singleton dimensions, and return whichever shape has more dimensions.
-"""
-promote_shape
-
-doc"""
-    methodswith(typ[, module or function][, showparents])
-
-Return an array of methods with an argument of type `typ`. If optional `showparents` is `true`, also return arguments with a parent type of `typ`, excluding type `Any`.
-
-The optional second argument restricts the search to a particular module or function.
-"""
-methodswith
-
-doc"""
-```rst
-..  foldr(op, v0, itr)
-
-Like :func:`reduce`, but with guaranteed right associativity. ``v0``
-will be used exactly once.
-```
-"""
-foldr(op, v0, itr)
-
-doc"""
-```rst
-..  foldr(op, itr)
-
-Like ``foldr(op, v0, itr)``, but using the last element of ``itr``
-as ``v0``. In general, this cannot be used with empty collections
-(see ``reduce(op, itr)``).
-```
-"""
-foldr(op, itr)
-
-doc"""
-    chol(A, [LU]) -> F
-
-Compute the Cholesky factorization of a symmetric positive definite matrix `A` and return the matrix `F`. If `LU` is `Val{:U}` (Upper), `F` is of type `UpperTriangular` and `A = F'*F`. If `LU` is `Val{:L}` (Lower), `F` is of type `LowerTriangular` and `A = F*F'`. `LU` defaults to `Val{:U}`.
-"""
-chol
-
-doc"""
-    ParseError(msg)
-
-The expression passed to the `parse` function could not be interpreted as a valid Julia expression.
-"""
-ParseError
-
-doc"""
-    delete!(collection, key)
-
-Delete the mapping for the given key in a collection, and return the collection.
-"""
-delete!
-
-doc"""
-    interrupt([pids...])
-
-Interrupt the current executing task on the specified workers. This is equivalent to pressing Ctrl-C on the local machine. If no arguments are given, all workers are interrupted.
-"""
-interrupt
-
-doc"""
-    std(v[, region])
-
-Compute the sample standard deviation of a vector or array `v`, optionally along dimensions in `region`. The algorithm returns an estimator of the generative distribution's standard deviation under the assumption that each entry of `v` is an IID drawn from that generative distribution. This computation is equivalent to calculating `sqrt(sum((v - mean(v)).^2) / (length(v) - 1))`. Note: Julia does not ignore `NaN` values in the computation. For applications requiring the handling of missing data, the `DataArray` package is recommended.
-"""
-std
-
-doc"""
-    chr2ind(string, i)
-
-Convert a character index to a byte index.
-"""
-chr2ind
-
-doc"""
-    fullname(m::Module)
-
-Get the fully-qualified name of a module as a tuple of symbols. For example, `fullname(Base.Pkg)` gives `(:Base,:Pkg)`, and `fullname(Main)` gives `()`.
-"""
-fullname
-
-doc"""
-    isreadable(path) -> Bool
-
-Returns `true` if the current user has permission to read `path`, `false` otherwise.
-"""
-isreadable
-
-doc"""
-    eps(T)
-
-The distance between 1.0 and the next larger representable floating-point value of `DataType` `T`. Only floating-point types are sensible arguments.
-"""
-eps(::Union{Type{BigFloat},Type{Float64},Type{Float32},Type{Float16}})
-
-doc"""
-    eps()
-
-The distance between 1.0 and the next larger representable floating-point value of `Float64`.
-"""
-eps()
-
-doc"""
-    eps(x)
-
-The distance between `x` and the next larger representable floating-point value of the same `DataType` as `x`.
-"""
-eps(::FloatingPoint)
-
-doc"""
-    rem1(x,m)
-
-Remainder after division, returning in the range (0,m\]
-"""
-rem1
-
-doc"""
-    sparsevec(I, V, [m, combine])
-
-Create a sparse matrix `S` of size `m x 1` such that `S[I[k]] = V[k]`. Duplicates are combined using the `combine` function, which defaults to `+` if it is not provided. In julia, sparse vectors are really just sparse matrices with one column. Given Julia's Compressed Sparse Columns (CSC) storage format, a sparse column matrix with one column is sparse, whereas a sparse row matrix with one row ends up being dense.
-"""
-sparsevec(I, V)
-
-doc"""
-    sparsevec(D::Dict, [m])
-
-Create a sparse matrix of size `m x 1` where the row values are keys from the dictionary, and the nonzero values are the values from the dictionary.
-"""
-sparsevec(D::Dict)
-
-doc"""
-    sparsevec(A)
-
-Convert a dense vector `A` into a sparse matrix of size `m x 1`. In julia, sparse vectors are really just sparse matrices with one column.
-"""
-sparsevec(A)
-
-doc"""
-    isalpha(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is alphabetic, or whether this is true for all elements of a string. A character is classified as alphabetic if it belongs to the Unicode general category Letter, i.e. a character whose category code begins with 'L'.
-"""
-isalpha
-
-doc"""
-    lock(l::ReentrantLock)
-
-Associates `l` with the current task. If `l` is already locked by a different task, waits for it to become available. The same task can acquire the lock multiple times. Each "lock" must be matched by an "unlock"
-"""
-lock
-
-doc"""
-    transpose(A)
-
-The transposition operator (`.'`).
-"""
-transpose
-
-doc"""
-    searchsortedfirst(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Returns the index of the first value in `a` greater than or equal to `x`, according to the specified order. Returns `length(a)+1` if `x` is greater than all values in `a`.
-"""
-searchsortedfirst
-
-doc"""
-    big(x)
-
-Convert a number to a maximum precision representation (typically `BigInt` or `BigFloat`). See `BigFloat` for information about some pitfalls with floating-point numbers.
-"""
-big
-
-doc"""
-    names(x::Module[, all=false[, imported=false]])
-
-Get an array of the names exported by a `Module`, with optionally more `Module` globals according to the additional parameters.
-"""
-names
-
-doc"""
-```rst
-..  quit()
-
-Quit the program indicating that the processes completed successfully. This function calls ``exit(0)`` (see :func:`exit`).
-```
-"""
-quit
-
-doc"""
-    init_worker(manager::FooManager)
-
-Called by cluster managers implementing custom transports. It initializes a newly launched process as a worker. Command line argument `--worker` has the effect of initializing a process as a worker using TCP/IP sockets for transport.
-"""
-init_worker
-
-doc"""
-    print_escaped(io, str::AbstractString, esc::AbstractString)
-
-General escaping of traditional C and Unicode escape sequences, plus any characters in esc are also escaped (with a backslash).
-"""
-print_escaped
-
-doc"""
-    typejoin(T, S)
-
-Compute a type that contains both `T` and `S`.
-"""
-typejoin
-
-doc"""
-    summary(x)
-
-Return a string giving a brief description of a value. By default returns `string(typeof(x))`. For arrays, returns strings like "2x2 Float64 Array".
-"""
-summary
-
-doc"""
-    Base64DecodePipe(istream)
-
-Returns a new read-only I/O stream, which decodes base64-encoded data read from `istream`.
-"""
-Base64DecodePipe
-
-doc"""
-    module_parent(m::Module) -> Module
-
-Get a module's enclosing `Module`. `Main` is its own parent, as is `LastMain` after `workspace()`.
-"""
-module_parent
-
-doc"""
-    airyaiprime(x)
-
-Airy function derivative $\operatorname{Ai}'(x)$.
-"""
-airyaiprime
-
-doc"""
-    besselh(nu, k, x)
-
-Bessel function of the third kind of order `nu` (Hankel function). `k` is either 1 or 2, selecting `hankelh1` or `hankelh2`, respectively.
-"""
-besselh
-
-doc"""
-    prepend!(collection, items) -> collection
-
-Insert the elements of `items` to the beginning of `collection`.
-
-```jldoctest
-julia> prepend!([3],[1,2])
-3-element Array{Int64,1}:
- 1
- 2
- 3
-```
-"""
-prepend!
-
-doc"""
-    sum_kbn(A)
-
-Returns the sum of all array elements, using the Kahan-Babuska-Neumaier compensated summation algorithm for additional accuracy.
-"""
-sum_kbn
-
-doc"""
-    beta(x, y)
-
-Euler integral of the first kind $\operatorname{B}(x,y) = \Gamma(x)\Gamma(y)/\Gamma(x+y)$.
-"""
-beta
-
-doc"""
-    eye(n)
-
-`n`-by-`n` identity matrix
-"""
-eye(n::Int)
-
-doc"""
-    eye(m, n)
-
-`m`-by-`n` identity matrix
-"""
-eye(m, n)
-
-doc"""
-    eye(A)
-
-Constructs an identity matrix of the same dimensions and type as `A`.
-"""
-eye(A)
-
-doc"""
-    diagind(M[, k])
-
-A `Range` giving the indices of the `k`th diagonal of the matrix `M`.
-"""
-diagind
-
-doc"""
-    include_string(code::AbstractString, [filename])
-
-Like `include`, except reads code from the given string rather than from a file. Since there is no file path involved, no path processing or fetching from node 1 is done.
-"""
-include_string
-
-doc"""
-    chmod(path, mode)
-
-Change the permissions mode of `path` to `mode`. Only integer `mode`s (e.g. 0o777) are currently supported.
-"""
-chmod
-
-doc"""
-    gamma(x)
-
-Compute the gamma function of `x`
-"""
-gamma
-
-doc"""
-    sin(x)
-
-Compute sine of `x`, where `x` is in radians
-"""
-sin
-
-doc"""
-```rst
-..  ordschur!(Q, T, select) -> Schur
-
-Reorders the Schur factorization of a real matrix ``A=Q*T*Q'``, overwriting ``Q`` and ``T`` in the process. See :func:`ordschur`
-```
-"""
-ordschur!(Q,T,select)
-
-doc"""
-```rst
-..  ordschur!(S, select) -> Schur
-
-Reorders the Schur factorization ``S`` of type ``Schur``, overwriting ``S`` in the process. See :func:`ordschur`
-```
-"""
-ordschur!(S,select)
-
-doc"""
-```rst
-..  ordschur!(S, T, Q, Z, select) -> GeneralizedSchur
-
-Reorders the Generalized Schur factorization of a matrix by overwriting the matrices ``(S, T, Q, Z)`` in the process.  See :func:`ordschur`.
-```
-"""
-ordschur!(S,T,Q,Z,select)
-
-doc"""
-```rst
-..  ordschur!(GS, select) -> GeneralizedSchur
-
-Reorders the Generalized Schur factorization of a Generalized Schur object by overwriting the object with the new factorization.  See :func:`ordschur`.
-```
-"""
-ordschur!(::LinAlg.GeneralizedSchur,select)
-
-doc"""
-```rst
-..  Base.compilecache(module::ByteString)
-
-Creates a precompiled cache file for module (see help for ``require``) and all of its dependencies. This can be used to reduce package load times. Cache files are stored in ``LOAD_CACHE_PATH[1]``, which defaults to ``~/.julia/lib/VERSION``. See :ref:`Module initialization and precompilation <man-modules-initialization-precompilation>` for important notes.
-```
-"""
-compilecache
-
-doc"""
-    clipboard() -> AbstractString
-
-Return a string with the contents of the operating system clipboard ("paste").
-"""
-clipboard
-
-doc"""
-    clipboard(x)
-
-Send a printed form of `x` to the operating system clipboard ("copy").
-"""
-clipboard(x)
-
-doc"""
-    code_lowered(f, types)
-
-Returns an array of lowered ASTs for the methods matching the given generic function and type signature.
-"""
-code_lowered
-
-doc"""
-    nthperm(v, k)
-
-Compute the kth lexicographic permutation of a vector.
-"""
-nthperm(v,k)
-
-doc"""
-    nthperm(p)
-
-Return the `k` that generated permutation `p`. Note that `nthperm(nthperm([1:n], k)) == k` for `1 <= k <= factorial(n)`.
-"""
-nthperm(p)
-
-doc"""
-    values(collection)
-
-Return an iterator over all values in a collection. `collect(values(d))` returns an array of values.
-"""
-values
-
-doc"""
-    A_mul_B!(Y, A, B) -> Y
-
-
-Calculates the matrix-matrix or matrix-vector product `A * B` and stores the
-result in `Y`, overwriting the existing value of `Y`.
-
-```jldoctest
-julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; A_mul_B!(B, A, B);
-
-julia> B
-2x2 Array{Float64,2}:
- 3.0  3.0
- 7.0  7.0
-```
-"""
-A_mul_B!
-
-doc"""
-    ntuple(f::Function, n)
-
-Create a tuple of length `n`, computing each element as `f(i)`, where `i` is the index of the element.
-"""
-ntuple
-
-doc"""
-```rst
-..  idct!(A [, dims])
-
-Same as :func:`idct!`, but operates in-place on ``A``.
-```
-"""
-idct!
-
-doc"""
-    Ac_rdiv_Bc(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᴴ \ Bᴴ`
-
-"""
-Ac_rdiv_Bc
-
-doc"""
-    selectperm!(ix, v, k, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false,] [initialized=false])
-
-Like `selectperm`, but accepts a preallocated index vector `ix`. If `initialized` is `false` (the default), ix is initialized to contain the values `1:length(ix)`.
-"""
-selectperm!
-
-doc"""
-    istaskdone(task) -> Bool
-
-Tell whether a task has exited.
-"""
-istaskdone
-
-doc"""
-    .>(x, y)
-
-Element-wise greater-than comparison operator.
-"""
-Base.(:(.>))
-
-doc"""
-    search(string, chars, [start])
-
-Search for the first occurrence of the given characters within the given string. The second argument may be a single character, a vector or a set of characters, a string, or a regular expression (though regular expressions are only allowed on contiguous strings, such as ASCII or UTF-8 strings). The third argument optionally specifies a starting index. The return value is a range of indexes where the matching sequence is found, such that `s[search(s,x)] == x`:
-
-`search(string, "substring")` = `start:end` such that `string[start:end] == "substring"`, or `0:-1` if unmatched.
-
-`search(string, 'c')` = `index` such that `string[index] == 'c'`, or `0` if unmatched.
-"""
-search
-
-doc"""
-    remotecall_fetch(id, func, args...)
-
-Perform `fetch(remotecall(...))` in one message. Any remote exceptions are captured in a `RemoteException` and thrown.
-"""
-remotecall_fetch
-
-doc"""
-    contains(haystack, needle)
-
-Determine whether the second argument is a substring of the first.
-"""
-contains
-
-doc"""
-    flush(stream)
-
-Commit all currently buffered writes to the given stream.
-"""
-flush
-
-doc"""
-    detach(command)
-
-Mark a command object so that it will be run in a new process group, allowing it to outlive the julia process, and not have Ctrl-C interrupts passed to it.
-"""
-detach
-
-doc"""
-    precompile(f,args::Tuple{Vararg{Any}})
-
-Compile the given function `f` for the argument tuple (of types) `args`, but do not execute it.
-"""
-precompile
-
-doc"""
-```rst
-..  toc()
-
-Print and return the time elapsed since the last :func:`tic`.
-```
-"""
-toc
-
-doc"""
-    asinh(x)
-
-Compute the inverse hyperbolic sine of `x`
-"""
-asinh
-
-doc"""
-    count(p, itr) -> Integer
-
-Count the number of elements in `itr` for which predicate `p` returns `true`.
-"""
-count
-
-doc"""
-    atreplinit(f)
-
-Register a one-argument function to be called before the REPL interface is initialized in interactive sessions; this is useful to customize the interface. The argument of `f` is the REPL object. This function should be called from within the `.juliarc.jl` initialization file.
-"""
-atreplinit
-
-doc"""
-    strip(string, [chars])
-
-Return `string` with any leading and trailing whitespace removed. If `chars` (a character, or vector or set of characters) is provided, instead remove characters contained in it.
-"""
-strip
-
-doc"""
-    findin(a, b)
-
-Returns the indices of elements in collection `a` that appear in collection `b`
-"""
-findin
-
-doc"""
-    minimum(itr)
-
-Returns the smallest element in a collection.
-"""
-minimum(itr)
-
-doc"""
-    minimum(A, dims)
-
-Compute the minimum value of an array over the given dimensions.
-"""
-minimum(A,dims)
-
-doc"""
-    var(v[, region])
-
-Compute the sample variance of a vector or array `v`, optionally along dimensions in `region`. The algorithm will return an estimator of the generative distribution's variance under the assumption that each entry of `v` is an IID drawn from that generative distribution. This computation is equivalent to calculating `sum((v - mean(v)).^2) / (length(v) - 1)`. Note: Julia does not ignore `NaN` values in the computation. For applications requiring the handling of missing data, the `DataArray` package is recommended.
-"""
-var
-
-doc"""
-    lcfirst(string)
-
-Returns `string` with the first character converted to lowercase.
-"""
-lcfirst
-
-doc"""
-```rst
-..  @code_native
-
-Evaluates the arguments to the function call, determines their types, and calls :func:`code_native` on the resulting expression.
-```
-"""
-:@code_native
-
-doc"""
-```rst
-..  flipbits!(B::BitArray{N}) -> BitArray{N}
-
-Performs a bitwise not operation on ``B``. See :ref:`~ operator <~>`.
-```
-"""
-flipbits!
-
-doc"""
-    readlink(path) -> AbstractString
-
-Returns the value of a symbolic link `path`.
-"""
-readlink
-
-doc"""
-```rst
-..  @code_warntype
-
-Evaluates the arguments to the function call, determines their types, and calls :func:`code_warntype` on the resulting expression.
-```
-"""
-:@code_warntype
-
-doc"""
-    deg2rad(x)
-
-Convert `x` from degrees to radians
-"""
-deg2rad
-
-doc"""
-    redirect_stdin([stream])
-
-Like redirect\_stdout, but for STDIN. Note that the order of the return tuple is still (rd,wr), i.e. data to be read from STDIN, may be written to wr.
-"""
-redirect_stdin
-
-doc"""
-```rst
-..  minmax(x, y)
-
-Return ``(min(x,y), max(x,y))``.
-See also: :func:`extrema` that returns ``(minimum(x), maximum(x))``
-```
-"""
-minmax
-
-doc"""
-    mktemp([parent=tempdir()])
-
-Returns `(path, io)`, where `path` is the path of a new temporary file in `parent` and `io` is an open file object for this path.
-"""
-mktemp(?)
-
-doc"""
-    mktemp(f::Function, [parent=tempdir()])
-
-Apply the function `f` to the result of `mktemp(parent)` and remove the temporary file upon completion.
-"""
-mktemp(::Function, ?)
-
-doc"""
-    isreadonly(stream) -> Bool
-
-Determine whether a stream is read-only.
-"""
-isreadonly
-
-doc"""
-```rst
-..  get_rounding(T)
-
-Get the current floating point rounding mode for type ``T``, controlling
-the rounding of basic arithmetic functions (:func:`+`, :func:`-`,
-:func:`*`, :func:`/` and :func:`sqrt`) and type conversion.
-
-Valid modes are ``RoundNearest``, ``RoundToZero``, ``RoundUp``,
-``RoundDown``, and ``RoundFromZero`` (``BigFloat`` only).
-```
-"""
-get_rounding
-
-doc"""
-```rst
-..  code_llvm(f, types)
-
-Prints the LLVM bitcodes generated for running the method matching the given generic function and type signature to :const:`STDOUT`.
-
-All metadata and dbg.* calls are removed from the printed bitcode. Use code_llvm_raw for the full IR.
-```
-"""
-code_llvm
-
-doc"""
-```rst
-..  Bidiagonal(dv, ev, isupper)
-
-Constructs an upper (``isupper=true``) or lower (``isupper=false``) bidiagonal matrix
-using the given diagonal (``dv``) and off-diagonal (``ev``) vectors.  The result is of type ``Bidiagonal`` and provides efficient specialized linear solvers, but may be converted into a regular matrix with :func:`full`.
-```
-"""
-Bidiagonal
-
-doc"""
-    notify(condition, val=nothing; all=true, error=false)
-
-Wake up tasks waiting for a condition, passing them `val`. If `all` is `true` (the default), all waiting tasks are woken, otherwise only one is. If `error` is `true`, the passed value is raised as an exception in the woken tasks.
-"""
-notify
-
-doc"""
-    fftshift(x)
-
-Swap the first and second halves of each dimension of `x`.
-"""
-fftshift(x)
-
-doc"""
-    fftshift(x,dim)
-
-Swap the first and second halves of the given dimension of array `x`.
-"""
-fftshift(x,dim)
-
-doc"""
-    unique(itr[, dim])
-
-Returns an array containing only the unique elements of the iterable `itr`, in the order that the first of each set of equivalent elements originally appears. If `dim` is specified, returns unique regions of the array `itr` along `dim`.
-"""
-unique
-
-doc"""
-```rst
-..  sub(A, inds...)
-
-Like :func:`getindex`, but returns a view into the parent array ``A`` with the given indices instead of making a copy.  Calling :func:`getindex` or :func:`setindex!` on the returned :obj:`SubArray` computes the indices to the parent array on the fly without checking bounds.
-```
-"""
-sub
-
-doc"""
-```rst
-..  cholfact!(A [,LU=:U [,pivot=Val{false}]][;tol=-1.0]) -> Cholesky
-
-``cholfact!`` is the same as :func:`cholfact`, but saves space by overwriting the input ``A``, instead of creating a copy. ``cholfact!`` can also reuse the symbolic factorization from a different matrix ``F`` with the same structure when used as: ``cholfact!(F::CholmodFactor, A)``.
-```
-"""
-cholfact!
-
-doc"""
-    expanduser(path::AbstractString) -> AbstractString
-
-On Unix systems, replace a tilde character at the start of a path with the current user's home directory.
-"""
-expanduser
-
-doc"""
-    haskey(collection, key) -> Bool
-
-Determine whether a collection has a mapping for a given key.
-"""
-haskey
-
-doc"""
-    cot(x)
-
-Compute the cotangent of `x`, where `x` is in radians
-"""
-cot
-
-doc"""
-```rst
-..  get(x)
-
-Attempt to access the value of the ``Nullable`` object, ``x``. Returns the
-value if it is present; otherwise, throws a ``NullException``.
-```
-"""
-get(x)
-
-doc"""
-```rst
-..  get(x, y)
-
-Attempt to access the value of the ``Nullable{T}`` object, ``x``. Returns
-the value if it is present; otherwise, returns ``convert(T, y)``.
-```
-"""
-get(x,y)
-
-doc"""
-```rst
-..  get(collection, key, default)
-
-Return the value stored for the given key, or the given default value if no mapping for the key is present.
-```
-"""
-get(collection,key,default)
-
-doc"""
-```rst
-..  get(f::Function, collection, key)
-
-Return the value stored for the given key, or if no mapping for the key is present, return ``f()``.  Use :func:`get!` to also store the default value in the dictionary.
-
-This is intended to be called using ``do`` block syntax::
-
-  get(dict, key) do
-      # default value calculated here
-      time()
-  end
-```
-"""
-get
-
-doc"""
-    .!=(x, y)
-    .≠(x,y)
-
-Element-wise not-equals comparison operator.
-"""
-Base.(:(.!=))
-
-doc"""
-```rst
-..  lufact!(A) -> LU
-
-``lufact!`` is the same as :func:`lufact`, but saves space by overwriting the input ``A``, instead of creating a copy.  For sparse ``A`` the ``nzval`` field is not overwritten but the index fields, ``colptr`` and ``rowval`` are decremented in place, converting from 1-based indices to 0-based indices.
-```
-"""
-lufact!
-
-doc"""
-    IOBuffer() -> IOBuffer
-
-Create an in-memory I/O stream.
-"""
-IOBuffer()
-
-doc"""
-    IOBuffer(size::Int)
-
-Create a fixed size IOBuffer. The buffer will not grow dynamically.
-"""
-IOBuffer(size::Int)
-
-doc"""
-    IOBuffer(string)
-
-Create a read-only IOBuffer on the data underlying the given string
-"""
-IOBuffer(::AbstractString)
-
-doc"""
-    IOBuffer([data,],[readable,writable,[maxsize]])
-
-Create an IOBuffer, which may optionally operate on a pre-existing array. If the readable/writable arguments are given, they restrict whether or not the buffer may be read from or written to respectively. By default the buffer is readable but not writable. The last argument optionally specifies a size beyond which the buffer may not be grown.
-"""
-IOBuffer(data=?)
-
-doc"""
-```rst
-..  plan_dct!(A [, dims [, flags [, timelimit]]])
-
-Same as :func:`plan_dct`, but operates in-place on ``A``.
-```
-"""
-plan_dct!
-
-doc"""
-    findmax(itr) -> (x, index)
-
-Returns the maximum element and its index.
-"""
-findmax(itr)
-
-doc"""
-    findmax(A, dims) -> (maxval, index)
-
-For an array input, returns the value and index of the maximum over the given dimensions.
-"""
-findmax(A,dims)
-
-doc"""
-    tempname()
-
-Generate a unique temporary file path.
-"""
-tempname
-
-doc"""
-    poll_fd(fd, timeout_s::Real; readable=false, writable=false)
-
-Monitor a file descriptor `fd` for changes in the read or write availability, and with a timeout given by `timeout_s` seconds.
-
-The keyword arguments determine which of read and/or write status should be monitored; at least one of them must be set to `true`.
-
-The returned value is an object with boolean fields `readable`, `writable`, and `timedout`, giving the result of the polling.
-"""
-poll_fd
-
-doc"""
-    prevpow2(n)
-
-The largest power of two not greater than `n`. Returns 0 for `n==0`, and returns `-prevpow2(-n)` for negative arguments.
-"""
-prevpow2
-
-doc"""
-```rst
-..  code_warntype(f, types)
-
-Displays lowered and type-inferred ASTs for the methods matching the given generic function and type signature. The ASTs are annotated in such a way as to cause "non-leaf" types to be emphasized (if color is available, displayed in red). This serves as a warning of potential type instability. Not all non-leaf types are particularly problematic for performance, so the results need to be used judiciously. See :ref:`man-code-warntype` for more information.
-```
-"""
-code_warntype
-
-doc"""
-    broadcast!_function(f)
-
-Like `broadcast_function`, but for `broadcast!`.
-"""
-broadcast!_function
-
-doc"""
-    with_rounding(f::Function, T, mode)
-
-Change the rounding mode of floating point type `T` for the duration of `f`. It is logically equivalent to:
-
-    old = get_rounding(T)
-    set_rounding(T, mode)
-    f()
-    set_rounding(T, old)
-
-See `get_rounding` for available rounding modes.
-"""
-with_rounding
-
-doc"""
-    sleep(seconds)
-
-Block the current task for a specified number of seconds. The minimum sleep time is 1 millisecond or input of `0.001`.
-"""
-sleep
-
-doc"""
-    Mmap.sync!(array)
-
-Forces synchronization between the in-memory version of a memory-mapped `Array` or `BitArray` and the on-disk version.
-"""
-Mmap.sync!
-
-doc"""
-    csc(x)
-
-Compute the cosecant of `x`, where `x` is in radians
-"""
-csc
-
-doc"""
-    hash(x[, h])
-
-Compute an integer hash code such that `isequal(x,y)` implies `hash(x)==hash(y)`. The optional second argument `h` is a hash code to be mixed with the result.
-
-New types should implement the 2-argument form, typically by calling the 2-argument `hash` method recursively in order to mix hashes of the contents with each other (and with `h`). Typically, any type that implements `hash` should also implement its own `==` (hence `isequal`) to guarantee the property mentioned above.
-"""
-hash
-
-doc"""
-    atan2(y, x)
-
-Compute the inverse tangent of `y/x`, using the signs of both `x` and `y` to determine the quadrant of the return value.
-"""
-atan2
-
-doc"""
-    send(socket::UDPSocket, host::IPv4, port::Integer, msg)
-
-Send `msg` over `socket` to `host:port`.
-"""
-send
-
-doc"""
-    atanh(x)
-
-Compute the inverse hyperbolic tangent of `x`
-"""
-atanh
-
-doc"""
-    deleteat!(collection, index)
-
-Remove the item at the given `index` and return the modified `collection`.
-Subsequent items are shifted to fill the resulting gap.
-
-```jldoctest
-julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
-5-element Array{Int64,1}:
- 6
- 4
- 3
- 2
- 1
-```
-"""
-deleteat!(collection, index::Integer)
-
-doc"""
-    deleteat!(collection, itr)
-
-Remove the items at the indices given by `itr`, and return the modified `collection`.
-Subsequent items are shifted to fill the resulting gap. `itr` must be sorted and unique.
-
-```jldoctest
-julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
-3-element Array{Int64,1}:
- 5
- 3
- 1
-
-julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
-ERROR: ArgumentError: indices must be unique and sorted
- in deleteat! at array.jl:543
-```
-"""
-deleteat!(collection, itr)
-
-doc"""
-```rst
-..  schurfact!(A)
-
-Computes the Schur factorization of ``A``, overwriting ``A`` in the process. See :func:`schurfact`
-```
-"""
-schurfact!
-
-doc"""
-    read(stream, type)
-
-Read a value of the given type from a stream, in canonical binary representation.
-"""
-read(stream, t)
-
-doc"""
-    read(stream, type, dims)
-
-Read a series of values of the given type from a stream, in canonical binary representation. `dims` is either a tuple or a series of integer arguments specifying the size of `Array` to return.
-"""
-read(stream, t, dims)
-
-doc"""
-```rst
-..  plan_rfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Pre-plan an optimized real-input FFT, similar to :func:`plan_fft`
-except for :func:`rfft` instead of :func:`fft`.  The first two
-arguments, and the size of the transformed result, are the same as
-for :func:`rfft`.
-```
-"""
-plan_rfft
-
-doc"""
-    @timev
-
-This is a verbose version of the `@time` macro. It first prints the same information as `@time`, then any non-zero memory allocation counters, and then returns the value of the expression.
-"""
-:@timev
-
-doc"""
-    isopen(object) -> Bool
-
-Determine whether an object - such as a stream, timer, or mmap -- is not yet closed. Once an object is closed, it will never produce a new event. However, a closed stream may still have data to read in its buffer, use `eof` to check for the ability to read data. Use `poll_fd` to be notified when a stream might be writable or readable.
-"""
-isopen
-
-doc"""
-    shift!(collection) -> item
-
-Remove the first `item` from `collection`.
-
-```jldoctest
-julia> A = [1, 2, 3, 4, 5, 6]
-6-element Array{Int64,1}:
- 1
- 2
- 3
- 4
- 5
- 6
-
-julia> shift!(A)
-1
-
-julia> A
-5-element Array{Int64,1}:
- 2
- 3
- 4
- 5
- 6
-```
-"""
-shift!
-
-doc"""
-    @fetch
-
-Equivalent to `fetch(@spawn expr)`.
-"""
-:@fetch
-
-doc"""
-    spawn(command)
-
-Run a command object asynchronously, returning the resulting `Process` object.
-"""
-spawn
-
-doc"""
-    isposdef(A) -> Bool
-
-Test whether a matrix is positive definite.
-"""
-isposdef
-
-doc"""
-    nextind(str, i)
-
-Get the next valid string index after `i`. Returns a value greater than `endof(str)` at or after the end of the string.
-"""
-nextind
-
-doc"""
-    >>>(x, n)
-
-Unsigned right bit shift operator.
-"""
-Base.(:(>>>))
-
-doc"""
-    @timed
-
-A macro to execute an expression, and return the value of the expression, elapsed time, total bytes allocated, garbage collection time, and an object with various memory allocation counters.
-"""
-:@timed
-
-doc"""
-    code_native(f, types)
-
-Prints the native assembly instructions generated for running the method matching the given generic function and type signature to STDOUT.
-"""
-code_native
-
-doc"""
-    isgeneric(f::Function) -> Bool
-
-Determine whether a `Function` is generic.
-"""
-isgeneric
-
-doc"""
-    symdiff(s1,s2...)
-
-Construct the symmetric difference of elements in the passed in sets or arrays. Maintains order with arrays.
-"""
-symdiff
-
-doc"""
-```rst
-..  bfft!(A [, dims])
-
-Same as :func:`bfft`, but operates in-place on ``A``.
-```
-"""
-bfft!
-
-doc"""
-    histrange(v, n)
-
-Compute *nice* bin ranges for the edges of a histogram of `v`, using approximately `n` bins. The resulting step sizes will be 1, 2 or 5 multiplied by a power of 10. Note: Julia does not ignore `NaN` values in the computation.
-"""
-histrange
-
-doc"""
-    eta(x)
-
-Dirichlet eta function $\eta(s) = \sum^\infty_{n=1}(-)^{n-1}/n^{s}$.
-"""
-eta
-
-doc"""
-    isdefined([object,] index | symbol)
-
-Tests whether an assignable location is defined. The arguments can be an array and index, a composite object and field name (as a symbol), or a module and a symbol. With a single symbol argument, tests whether a global variable with that name is defined in `current_module()`.
-"""
-isdefined
-
-doc"""
-    cotd(x)
-
-Compute the cotangent of `x`, where `x` is in degrees
-"""
-cotd
-
-doc"""
-    dec(n, [pad])
-
-Convert an integer to a decimal string, optionally specifying a number of digits to pad to.
-"""
-dec
-
-doc"""
-    wait([x])
-
-Block the current task until some event occurs, depending on the type
-of the argument:
-
-* `RemoteRef`: Wait for a value to become available for the specified remote reference.
-* `Channel`: Wait for a value to be appended to the channel.
-* `Condition`: Wait for `notify` on a condition.
-* `Process`: Wait for a process or process chain to exit. The `exitcode` field of a process can be used to determine success or failure.
-* `Task`: Wait for a `Task` to finish, returning its result value. If the task fails with an exception, the exception is propagated (re-thrown in the task that called `wait`).
-* `RawFD`: Wait for changes on a file descriptor (see `poll_fd` for keyword arguments and return code)
-
-If no argument is passed, the task blocks for an undefined period. If the task's
-state is set to `:waiting`, it can only be restarted by an explicit call to
-`schedule` or `yieldto`. If the task's state is `:runnable`, it might be
-restarted unpredictably.
-
-Often `wait` is called within a `while` loop to ensure a waited-for condition
-is met before proceeding.
-"""
-wait
-
-doc"""
-```rst
-..  shuffle([rng,] v)
-
-Return a randomly permuted copy of ``v``. The optional ``rng`` argument
-specifies a random number generator, see :ref:`Random Numbers
-<random-numbers>`.
-```
-"""
-shuffle
-
-doc"""
-```rst
-..  Dict([itr])
-
-``Dict{K,V}()`` constructs a hash table with keys of type ``K`` and values of type ``V``.
-
-Given a single iterable argument, constructs a :obj:`Dict` whose key-value pairs
-are taken from 2-tuples ``(key,value)`` generated by the argument.
-
-.. doctest::
-
-  julia> Dict([("A", 1), ("B", 2)])
-  Dict{ASCIIString,Int64} with 2 entries:
-    "B" => 2
-    "A" => 1
-
-Alternatively, a sequence of pair arguments may be passed.
-
-.. doctest::
-
-  julia> Dict("A"=>1, "B"=>2)
-  Dict{ASCIIString,Int64} with 2 entries:
-    "B" => 2
-    "A" => 1
-```
-"""
-Dict
-
-doc"""
-    sqrt(x)
-
-Return $\sqrt{x}$. Throws `DomainError` for negative `Real` arguments. Use complex negative arguments instead.  The prefix operator `√` is equivalent to `sqrt`.
-"""
-sqrt
-
-doc"""
-    atexit(f)
-
-Register a zero-argument function `f()` to be called at process exit.
-`atexit()` hooks are called in last in first out (LIFO) order and run before object finalizers.
-"""
-atexit
-
-doc"""
-    besselk(nu, x)
-
-Modified Bessel function of the second kind of order `nu`, $K_\nu(x)$.
-"""
-besselk
-
-doc"""
-    readchomp(x)
-
-Read the entirety of `x` as a string but remove trailing newlines. Equivalent to `chomp(readall(x))`.
-"""
-readchomp
-
-doc"""
-```rst
-..  pinv(M[, tol])
-
-Computes the Moore-Penrose pseudoinverse.
-
-For matrices ``M`` with floating point elements, it is convenient to compute
-the pseudoinverse by inverting only singular values above a given threshold,
-``tol``.
-
-The optimal choice of ``tol`` varies both with the value of ``M``
-and the intended application of the pseudoinverse. The default value of
-``tol`` is ``eps(real(float(one(eltype(M)))))*maximum(size(A))``,
-which is essentially machine epsilon for the real part of a matrix element
-multiplied by the larger matrix dimension.
-For inverting dense ill-conditioned matrices in a least-squares sense,
-``tol = sqrt(eps(real(float(one(eltype(M))))))`` is recommended.
-
-For more information, see [8859]_, [B96]_, [S84]_, [KY88]_.
-
-.. [8859] Issue 8859, "Fix least squares", https://github.com/JuliaLang/julia/pull/8859
-.. [B96] Åke Björck, "Numerical Methods for Least Squares Problems",
-   SIAM Press, Philadelphia, 1996, "Other Titles in Applied Mathematics", Vol. 51.
-   `doi:10.1137/1.9781611971484 <http://epubs.siam.org/doi/book/10.1137/1.9781611971484>`_
-.. [S84] G. W. Stewart, "Rank Degeneracy", SIAM Journal on
-   Scientific and Statistical Computing, 5(2), 1984, 403-413.
-   `doi:10.1137/0905030 <http://epubs.siam.org/doi/abs/10.1137/0905030>`_
-.. [KY88] Konstantinos Konstantinides and Kung Yao, "Statistical analysis
-   of effective singular values in matrix rank determination", IEEE
-   Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988,
-   757-763.
-   `doi:10.1109/29.1585 <http://dx.doi.org/10.1109/29.1585>`_
-```
-"""
-pinv
-
-doc"""
-    asecd(x)
-
-Compute the inverse secant of `x`, where the output is in degrees
-"""
-asecd
-
-doc"""
-    readbytes!(stream, b::Vector{UInt8}, nb=length(b); all=true)
-
-Read at most `nb` bytes from the stream into `b`, returning the number of bytes read (increasing the size of `b` as needed).
-
-See `readbytes` for a description of the `all` option.
-"""
-readbytes!
-
-doc"""
-    basename(path::AbstractString) -> AbstractString
-
-Get the file name part of a path.
-"""
-basename
-
-doc"""
-    issparse(S)
-
-Returns `true` if `S` is sparse, and `false` otherwise.
-"""
-issparse
-
-doc"""
-    ArgumentError(msg)
-
-The parameters to a function call do not match a valid signature.
-Argument `msg` is a descriptive error string.
-"""
-ArgumentError
-
-doc"""
-    atand(x)
-
-Compute the inverse tangent of `x`, where the output is in degrees
-"""
-atand
-
-doc"""
-    KeyError(key)
-
-An indexing operation into an `Associative` (`Dict`) or `Set` like object tried to access or delete a non-existent element.
-"""
-KeyError
-
-doc"""
-    isdiag(A) -> Bool
-
-Test whether a matrix is diagonal.
-"""
-isdiag
-
-doc"""
-    !==(x, y)
-    ≢(x,y)
-
-Equivalent to `!is(x, y)`
-"""
-Base.(:(!==))
-
-doc"""
-    trailing_ones(x::Integer) -> Integer
-
-Number of ones trailing the binary representation of `x`.
-
-```jldoctest
-julia> trailing_ones(3)
-2
-```
-"""
-trailing_ones
-
-doc"""
-    repeated(x[, n::Int])
-
-An iterator that generates the value `x` forever. If `n` is specified, generates `x` that many times (equivalent to `take(repeated(x), n)`).
-"""
-repeated
-
-doc"""
-    isnumber(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is numeric, or whether this is true for all elements of a string. A character is classified as numeric if it belongs to the Unicode general category Number, i.e. a character whose category code begins with 'N'.
-"""
-isnumber
-
-doc"""
-    similar(array, [element_type=eltype(array)], [dims=size(array)])
-
-Create an uninitialized mutable array with the given element type and size,
-based upon the given source array. The second and third arguments are both
-optional, defaulting to the given array's `eltype` and `size`. The dimensions
-may be specified either as a single tuple argument or as a series of integer
-arguments.
-
-Custom AbstractArray subtypes may choose which specific array type is
-best-suited to return for the given element type and dimensionality. If they do
-not specialize this method, the default is an `Array(element_type, dims...)`.
-
-For example, `similar(1:10, 1, 4)` returns an uninitialized `Array{Int,2}` since
-ranges are neither mutable nor support 2 dimensions:
-
-    julia> similar(1:10, 1, 4)
-    1x4 Array{Int64,2}:
-     4419743872  4374413872  4419743888  0
-
-Conversely, `similar(trues(10,10), 2)` returns an uninitialized `BitVector`
-with two elements since `BitArray`s are both mutable and can support
-1-dimensional arrays:
-
-    julia> similar(trues(10,10), 2)
-    2-element BitArray{1}:
-     false
-     false
-
-Since `BitArray`s can only store elements of type `Bool`, however, if you
-request a different element type it will create a regular `Array` instead:
-
-    julia> similar(falses(10), Float64, 2, 4)
-    2x4 Array{Float64,2}:
-     2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
-     2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
-"""
-similar
-
-doc"""
-    copy(x)
-
-Create a shallow copy of `x`: the outer structure is copied, but not all internal values. For example, copying an array produces a new array with identically-same elements as the original.
-"""
-copy
-
-doc"""
-    isempty(collection) -> Bool
-
-Determine whether a collection is empty (has no elements).
-
-```jldoctest
-julia> isempty([])
-true
-
-julia> isempty([1 2 3])
-false
-```
-"""
-isempty
-
-doc"""
-    sumabs!(r, A)
-
-Sum absolute values of elements of `A` over the singleton dimensions of `r`, and write results to `r`.
-"""
-sumabs!
-
-doc"""
-    abs(x)
-
-Absolute value of `x`
-"""
-abs
-
-doc"""
-    Sys.set_process_title(title::AbstractString)
-
-Set the process title. No-op on some operating systems. (not exported)
-"""
-Sys.set_process_title
-
-doc"""
-    htol(x)
-
-Converts the endianness of a value from that used by the Host to Little-endian.
-"""
-htol
-
-doc"""
-    ctime(file)
-
-Equivalent to `stat(file).ctime`
-"""
-ctime
-
-doc"""
-    normpath(path::AbstractString) -> AbstractString
-
-Normalize a path, removing "." and ".." entries.
-"""
-normpath
-
-doc"""
-```rst
-..  unmark(s)
-
-Remove a mark from stream ``s``.
-Returns ``true`` if the stream was marked, ``false`` otherwise.
-
-See also :func:`mark`, :func:`reset`, :func:`ismarked`
-```
-"""
-unmark
-
-doc"""
-    module_name(m::Module) -> Symbol
-
-Get the name of a `Module` as a `Symbol`.
-"""
-module_name
-
-doc"""
-```rst
-..  reset(s)
-
-Reset a stream ``s`` to a previously marked position, and remove the mark.
-Returns the previously marked position.
-Throws an error if the stream is not marked.
-
-See also :func:`mark`, :func:`unmark`, :func:`ismarked`
-```
-"""
-reset
-
-doc"""
-    modf(x)
-
-Return a tuple (fpart,ipart) of the fractional and integral parts of a number. Both parts have the same sign as the argument.
-"""
-modf
-
-doc"""
-    hex2num(str)
-
-Convert a hexadecimal string to the floating point number it represents
-"""
-hex2num
-
-doc"""
-    ndims(A) -> Integer
-
-Returns the number of dimensions of `A`
-"""
-ndims
-
-doc"""
-    @osx
-
-Given `@osx? a : b`, do `a` on OS X and `b` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
-"""
-:@osx
-
-doc"""
-    ishermitian(A) -> Bool
-
-Test whether a matrix is Hermitian.
-"""
-ishermitian
-
-doc"""
-    sind(x)
-
-Compute sine of `x`, where `x` is in degrees.
-"""
-sind
-
-doc"""
-    iseltype(A,T)
-
-Tests whether `A` or its elements are of type `T`.
-"""
-iseltype
-
-doc"""
-    symperm(A, p)
-
-Return the symmetric permutation of `A`, which is `A[p,p]`. `A` should be symmetric and sparse, where only the upper triangular part of the matrix is stored. This algorithm ignores the lower triangular part of the matrix. Only the upper triangular part of the result is returned as well.
-"""
-symperm
-
-doc"""
-    min(x, y, ...)
-
-Return the minimum of the arguments. Operates elementwise over arrays.
-"""
-min
-
-doc"""
-    isready(r::RemoteRef)
-
-Determine whether a `RemoteRef` has a value stored to it. Note that this function can cause race conditions, since by the time you receive its result it may no longer be true. It is recommended that this function only be used on a `RemoteRef` that is assigned once.
-
-If the argument `RemoteRef` is owned by a different node, this call will block to wait for the answer. It is recommended to wait for `r` in a separate task instead, or to use a local `RemoteRef` as a proxy:
-
-    rr = RemoteRef()
-    @async put!(rr, remotecall_fetch(p, long_computation))
-    isready(rr)  # will not block
-"""
-isready
-
-doc"""
-    InexactError()
-
-Type conversion cannot be done exactly.
-"""
-InexactError
-
-doc"""
-    @sync
-
-Wait until all dynamically-enclosed uses of `@async`, `@spawn`, `@spawnat` and `@parallel` are complete. All exceptions thrown by enclosed async operations are collected and thrown as a `CompositeException`.
-"""
-:@sync
-
-doc"""
-    typemax(T)
-
-The highest value representable by the given (real) numeric `DataType`.
-"""
-typemax
-
-doc"""
-    all(itr) -> Bool
-
-Test whether all elements of a boolean collection are `true`.
-"""
-all(itr)
-
-doc"""
-    all(A, dims)
-
-Test whether all values along the given dimensions of an array are `true`.
-"""
-all(A::AbstractArray, dims)
-
-doc"""
-    all(p, itr) -> Bool
-
-Determine whether predicate `p` returns `true` for all elements of `itr`.
-
-```jldoctest
-julia> all(i->(4<=i<=6), [4,5,6])
-true
-```
-"""
-all(p, itr)
-
-doc"""
-    bind(socket::Union{UDPSocket, TCPSocket}, host::IPv4, port::Integer)
-
-Bind `socket` to the given `host:port`. Note that `0.0.0.0` will listen on all devices.
-"""
-bind
-
-doc"""
-    cld(x, y)
-
-Smallest integer larger than or equal to `x/y`.
-"""
-cld
-
-doc"""
-    issetuid(path) -> Bool
-
-Returns `true` if `path` has the setuid flag set, `false` otherwise.
-"""
-issetuid
-
-doc"""
-```rst
-..  scale!(A, b)
-           scale!(b, A)
-
-Scale an array ``A`` by a scalar ``b``, similar to :func:`scale` but
-overwriting ``A`` in-place.
-
-If ``A`` is a matrix and ``b`` is a vector, then ``scale!(A,b)``
-scales each column ``i`` of ``A`` by ``b[i]`` (similar to
-``A*diagm(b)``), while ``scale!(b,A)`` scales each row ``i`` of
-``A`` by ``b[i]`` (similar to ``diagm(b)*A``), again operating in-place
-on ``A``.
-```
-"""
-scale!
-
-doc"""
-    DomainError()
-
-The arguments to a function or constructor are outside the valid domain.
-"""
-DomainError
-
-doc"""
-    issym(A) -> Bool
-
-Test whether a matrix is symmetric.
-"""
-issym
-
-doc"""
-```rst
-..  svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000) -> (left_sv, s, right_sv, nconv, niter, nmult, resid)
-
-``svds`` computes largest singular values ``s`` of ``A`` using Lanczos or Arnoldi iterations.
-Uses :func:`eigs` underneath.
-
-Inputs are:
- * ``A``: Linear operator. It can either subtype of ``AbstractArray`` (e.g., sparse matrix) or duck typed. For duck typing ``A`` has to support ``size(A)``, ``eltype(A)``, ``A * vector`` and ``A' * vector``.
- * ``nsv``: Number of singular values.
- * ``ritzvec``: Whether to return the left and right singular vectors ``left_sv`` and ``right_sv``, default is ``true``. If ``false`` the singular vectors are omitted from the output.
- * ``tol``: tolerance, see :func:`eigs`.
- * ``maxiter``: Maximum number of iterations, see :func:`eigs`.
-
-**Example**::
-
-   X = sprand(10, 5, 0.2)
-   svds(X, nsv = 2)
-```
-"""
-svds
-
-doc"""
-    acosh(x)
-
-Compute the inverse hyperbolic cosine of `x`
-"""
-acosh
-
-doc"""
-```rst
-..  IntSet([itr])
-
-Construct a sorted set of positive ``Int``\ s generated by the given iterable
-object, or an empty set. Implemented as a bit string, and therefore designed
-for dense integer sets. Only ``Int``\ s greater than 0 can be stored. If the
-set will be sparse (for example holding a few very large integers), use
-:obj:`Set` instead.
-```
-"""
-IntSet
-
-doc"""
-    Task(func)
-
-Create a `Task` (i.e. thread, or coroutine) to execute the given function (which must be callable with no arguments). The task exits when this function returns.
-"""
-Task
-
-doc"""
-    pushdisplay(d::Display)
-
-Pushes a new display `d` on top of the global display-backend stack. Calling `display(x)` or `display(mime, x)` will display `x` on the topmost compatible backend in the stack (i.e., the topmost backend that does not throw a `MethodError`).
-"""
-pushdisplay
-
-doc"""
-    randexp!([rng], A::Array{Float64,N})
-
-Fill the array `A` with random numbers following the exponential distribution (with scale 1).
-"""
-randexp!
-
-doc"""
-    prevind(str, i)
-
-Get the previous valid string index before `i`. Returns a value less than `1` at the beginning of the string.
-"""
-prevind
-
-doc"""
-    setenv(command, env; dir=working_dir)
-
-Set environment variables to use when running the given `command`. `env` is either a dictionary mapping strings to strings, an array of strings of the form `"var=val"`, or zero or more `"var"=>val` pair arguments. In order to modify (rather than replace) the existing environment, create `env` by `copy(ENV)` and then setting `env["var"]=val` as desired, or use `withenv`.
-
-The `dir` keyword argument can be used to specify a working directory for the command.
-"""
-setenv
-
-doc"""
-    invperm(v)
-
-Return the inverse permutation of v.
-"""
-invperm
-
-doc"""
-    lowercase(string)
-
-Returns `string` with all characters converted to lowercase.
-"""
-lowercase
-
-doc"""
-    produce(value)
-
-Send the given value to the last `consume` call, switching to the consumer task. If the next `consume` call passes any values, they are returned by `produce`.
-"""
-produce
-
-doc"""
-    ifft(A [, dims])
-
-Multidimensional inverse FFT.
-
-A one-dimensional inverse FFT computes
-
-$$\operatorname{IDFT}(A)[k] = \frac{1}{\operatorname{length}(A)}
-\sum_{n=1}^{\operatorname{length}(A)} \exp\left(+i\frac{2\pi (n-1)(k-1)}
-{\operatorname{length}(A)} \right) A[n].$$
-
-A multidimensional inverse FFT simply performs this operation along each transformed dimension of `A`.
-"""
-ifft
-
-doc"""
-    StackOverflowError()
-
-The function call grew beyond the size of the call stack. This usually happens when a call recurses infinitely.
-"""
-StackOverflowError
-
-doc"""
-    acsch(x)
-
-Compute the inverse hyperbolic cosecant of `x`
-"""
-acsch
-
-doc"""
-    process_running(p::Process)
-
-Determine whether a process is currently running.
-"""
-process_running
-
-doc"""
-```rst
-..  BigInt(x)
-
-Create an arbitrary precision integer. ``x`` may be an ``Int`` (or anything
-that can be converted to an ``Int``).  The usual mathematical operators are
-defined for this type, and results are promoted to a ``BigInt``.
-
-Instances can be constructed from strings via :func:`parse`, or using the
-``big`` string literal.
-```
-"""
-BigInt
-
-doc"""
-    rsearch(string, chars, [start])
-
-Similar to `search`, but returning the last occurrence of the given characters within the given string, searching in reverse from `start`.
-"""
-rsearch
-
-doc"""
-    isdirpath(path::AbstractString) -> Bool
-
-Determines whether a path refers to a directory (for example, ends with a path separator).
-"""
-isdirpath
-
-doc"""
-```rst
-..  in(item, collection) -> Bool
-           ∈(item,collection) -> Bool
-           ∋(collection,item) -> Bool
-           ∉(item,collection) -> Bool
-           ∌(collection,item) -> Bool
-
-Determine whether an item is in the given collection, in the sense that it is
-``==`` to one of the values generated by iterating over the collection.
-Some collections need a slightly different definition; for example :obj:`Set`\ s
-check whether the item :func:`isequal` to one of the elements. :obj:`Dict`\ s look for
-``(key,value)`` pairs, and the key is compared using :func:`isequal`. To test
-for the presence of a key in a dictionary, use :func:`haskey` or
-``k in keys(dict)``.
-```
-"""
-Base.in
-
-doc"""
-    isblockdev(path) -> Bool
-
-Returns `true` if `path` is a block device, `false` otherwise.
-"""
-isblockdev
-
-doc"""
-    ==(x, y)
-
-Generic equality operator, giving a single `Bool` result. Falls back to `===`. Should be implemented for all types with a notion of equality, based on the abstract value that an instance represents. For example, all numeric types are compared by numeric value, ignoring type. Strings are compared as sequences of characters, ignoring encoding.
-
-Follows IEEE semantics for floating-point numbers.
-
-Collections should generally implement `==` by calling `==` recursively on all contents.
-
-New numeric types should implement this function for two arguments of the new type, and handle comparison to other types via promotion rules where possible.
-"""
-Base.(:(==))
-
-doc"""
-    mapreducedim(f, op, A, dims[, initial])
-
-Evaluates to the same as `reducedim(op, map(f, A), dims, f(initial))`, but is generally faster because the intermediate array is avoided.
-"""
-mapreducedim
-
-doc"""
-    seekstart(s)
-
-Seek a stream to its beginning.
-"""
-seekstart
-
-doc"""
-    nfields(x::DataType) -> Int
-
-Get the number of fields of a `DataType`.
-"""
-nfields
-
-doc"""
-```rst
-..  toq()
-
-Return, but do not print, the time elapsed since the last :func:`tic`.
-```
-"""
-toq
-
-doc"""
-    writemime(stream, mime, x)
-
-The `display` functions ultimately call `writemime` in order to write an object `x` as a given `mime` type to a given I/O `stream` (usually a memory buffer), if possible. In order to provide a rich multimedia representation of a user-defined type `T`, it is only necessary to define a new `writemime` method for `T`, via: `writemime(stream, ::MIME"mime", x::T) = ...`, where `mime` is a MIME-type string and the function body calls `write` (or similar) to write that representation of `x` to `stream`. (Note that the `MIME""` notation only supports literal strings; to construct `MIME` types in a more flexible manner use `MIME{symbol("")}`.)
-
-For example, if you define a `MyImage` type and know how to write it to a PNG file, you could define a function `writemime(stream, ::MIME"image/png", x::MyImage) = ...` to allow your images to be displayed on any PNG-capable `Display` (such as IJulia). As usual, be sure to `import Base.writemime` in order to add new methods to the built-in Julia function `writemime`.
-
-Technically, the `MIME"mime"` macro defines a singleton type for the given `mime` string, which allows us to exploit Julia's dispatch mechanisms in determining how to display objects of any given type.
-"""
-writemime
-
-doc"""
-    mean!(r, v)
-
-Compute the mean of `v` over the singleton dimensions of `r`, and write results to `r`.
-"""
-mean!
-
-doc"""
-    join(strings, delim, [last])
-
-Join an array of `strings` into a single string, inserting the given delimiter between adjacent strings. If `last` is given, it will be used instead of `delim` between the last two strings. For example, `join(["apples", "bananas", "pineapples"], ", ", " and ") == "apples, bananas and pineapples"`.
-
-`strings` can be any iterable over elements `x` which are convertible to strings via `print(io::IOBuffer, x)`.
-"""
-join
-
-doc"""
-    linreg(x, y) -> a, b
-
-Perform linear regression. Returns `a` and `b` such that `a + b*x` is the closest
-straight line to the given points `(x, y)`, i.e., such that the squared error
-between `y` and `a + b*x` is minimized.
-
-**Example**:
-```
-   using PyPlot
-   x = [1.0:12.0;]
-   y = [5.5, 6.3, 7.6, 8.8, 10.9, 11.79, 13.48, 15.02, 17.77, 20.81, 22.0, 22.99]
-   a, b = linreg(x, y)          # Linear regression
-   plot(x, y, "o")              # Plot (x, y) points
-   plot(x, [a+b*i for i in x])  # Plot line determined by linear regression
-```
-"""
-linreg(x,y)
-
-doc"""
-    linreg(x, y, w)
-
-Weighted least-squares linear regression.
-"""
-linreg(x,y,w)
-
-doc"""
-    polygamma(m, x)
-
-Compute the polygamma function of order `m` of argument `x` (the `(m+1)th` derivative of the logarithm of `gamma(x)`)
-"""
-polygamma
-
-doc"""
-    isless(x, y)
-
-Test whether `x` is less than `y`, according to a canonical total order. Values that are normally unordered, such as `NaN`, are ordered in an arbitrary but consistent fashion. This is the default comparison used by `sort`. Non-numeric types with a canonical total order should implement this function. Numeric types only need to implement it if they have special values such as `NaN`.
-"""
-isless
-
-doc"""
-    expm1(x)
-
-Accurately compute $e^x-1$.
-"""
-expm1
-
-doc"""
-    showerror(io, e)
-
-Show a descriptive representation of an exception object.
-"""
-showerror
-
-doc"""
-    setdiff(s1,s2)
-
-Construct the set of elements in `s1` but not `s2`. Maintains order with arrays. Note that both arguments must be collections, and both will be iterated over. In particular, `setdiff(set,element)` where `element` is a potential member of `set`, will not work in general.
-"""
-setdiff
-
-doc"""
-    airyai(x)
-
-Airy function $\operatorname{Ai}(x)$.
-"""
-airyai
-
-doc"""
-    error(message::AbstractString)
-
-Raise an `ErrorException` with the given message
-"""
-error
-
-doc"""
-    less(file::AbstractString, [line])
-
-Show a file using the default pager, optionally providing a starting line number. Returns to the julia prompt when you quit the pager.
-"""
-less(f::AbstractString, ?)
-
-doc"""
-    less(function, [types])
-
-Show the definition of a function using the default pager, optionally specifying a tuple of types to indicate which method to see.
-"""
-less(m::Method, ?)
-
-doc"""
-```rst
-..  sqrtm(A)
-
-If ``A`` has no negative real eigenvalues, compute the principal matrix square root of ``A``, that is the unique matrix :math:`X` with eigenvalues having positive real part such that :math:`X^2 = A`. Otherwise, a nonprincipal square root is returned.
-
-If ``A`` is symmetric or Hermitian, its eigendecomposition (:func:`eigfact`) is used to compute the square root. Otherwise, the square root is determined by means of the Björck-Hammarling method, which computes the complex Schur form (:func:`schur`) and then the complex square root of the triangular factor.
-
-.. [BH83] Åke Björck and Sven Hammarling, "A Schur method for the square root
-   of a matrix", Linear Algebra and its Applications, 52-53, 1983, 127-140.
-   `doi:10.1016/0024-3795(83)80010-X <http://dx.doi.org/10.1016/0024-3795(83)80010-X>`_
-```
-"""
-sqrtm
-
-doc"""
-    conv(u,v)
-
-Convolution of two vectors. Uses FFT algorithm.
-"""
-conv
-
-doc"""
-    unsafe_store!(p::Ptr{T},x,i::Integer)
-
-Store a value of type `T` to the address of the ith element (1-indexed) starting at `p`. This is equivalent to the C expression `p[i-1] = x`.
-
-The `unsafe` prefix on this function indicates that no validation is performed on the pointer `p` to ensure that it is valid. Incorrect usage may corrupt or segfault your program, in the same manner as C.
-"""
-unsafe_store!
-
-doc"""
-```rst
-..  expm(A)
-
-Compute the matrix exponential of ``A``, defined by
-
-.. math::
-   e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.
-
-For symmetric or Hermitian ``A``, an eigendecomposition (:func:`eigfact`) is used, otherwise the scaling and squaring algorithm (see [H05]_) is chosen.
-
-.. [H05] Nicholas J. Higham, "The squaring and scaling method for the matrix
-   exponential revisited", SIAM Journal on Matrix Analysis and Applications,
-   26(4), 2005, 1179-1193.
-   `doi:10.1137/090768539 <http://dx.doi.org/10.1137/090768539>`_
-```
-"""
-expm
-
-doc"""
-```rst
-..  hessfact!(A)
-
-``hessfact!`` is the same as :func:`hessfact`, but saves space by overwriting the input ``A``, instead of creating a copy.
-```
-"""
-hessfact!
-
-doc"""
-    Sys.get_process_title()
-
-Get the process title. On some systems, will always return empty string. (not exported)
-"""
-Sys.get_process_title
-
-doc"""
-    readcsv(source, [T::Type]; options...)
-
-Equivalent to `readdlm` with `delim` set to comma.
-"""
-readcsv
-
-doc"""
-    current_module() -> Module
-
-Get the *dynamically* current `Module`, which is the `Module` code is currently being read from. In general, this is not the same as the module containing the call to this function.
-"""
-current_module
-
-doc"""
-    erfcx(x)
-
-Compute the scaled complementary error function of `x`,
-defined by $e^{x^2} \operatorname{erfc}(x)$.  Note
-also that $\operatorname{erfcx}(-ix)$ computes the
-Faddeeva function $w(x)$.
-"""
-erfcx
-
-doc"""
-    UndefVarError(var::Symbol)
-
-A symbol in the current scope is not defined.
-"""
-UndefVarError
-
-doc"""
-    gc()
-
-Perform garbage collection. This should not generally be used.
-"""
-gc
-
-doc"""
-    iscntrl(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is a control character, or whether this is true for all elements of a string. Control characters are the non-printing characters of the Latin-1 subset of Unicode.
-"""
-iscntrl
-
-doc"""
-    hist!(counts, v, e) -> e, counts
-
-Compute the histogram of `v`, using a vector/range `e` as the edges for the bins. This function writes the resultant counts to a pre-allocated array `counts`.
-"""
-hist!
-
-doc"""
-    minimum!(r, A)
-
-Compute the minimum value of `A` over the singleton dimensions of `r`, and write results to `r`.
-"""
-minimum!
-
-doc"""
-    diagm(v[, k])
-
-Construct a diagonal matrix and place `v` on the `k`th diagonal.
-"""
-diagm
-
-doc"""
-    .-(x, y)
-
-Element-wise subtraction operator.
-"""
-Base.(:(.-))
-
-doc"""
-    imag(z)
-
-Return the imaginary part of the complex number `z`
-"""
-imag
-
-doc"""
-    unsafe_trunc(T, x)
-
-`unsafe_trunc(T, x)` returns the nearest integral value of type `T` whose absolute value is less than or equal to `x`. If the value is not representable by `T`, an arbitrary value will be returned.
-"""
-unsafe_trunc
-
-doc"""
-    parent(A)
-
-Returns the "parent array" of an array view type (e.g., `SubArray`), or the array itself if it is not a view
-"""
-parent
-
-doc"""
-    <(x, y)
-
-Less-than comparison operator. New numeric types should implement this function for two arguments of the new type. Because of the behavior of floating-point NaN values, `<` implements a partial order. Types with a canonical partial order should implement `<`, and types with a canonical total order should implement `isless`.
-"""
-Base.(:(<))
-
-doc"""
-    EnvHash() -> EnvHash
-
-A singleton of this type provides a hash table interface to environment variables.
-"""
-EnvHash
-
-doc"""
-```rst
-..  method_exists(f, Tuple type) -> Bool
-
-Determine whether the given generic function has a method matching the given :obj:`Tuple` of argument types.
-
-.. doctest::
-
-	julia> method_exists(length, Tuple{Array})
-	true
-```
-"""
-method_exists
-
-doc"""
-    nextpow(a, x)
-
-The smallest `a^n` not less than `x`, where `n` is a non-negative integer. `a` must be greater than 1, and `x` must be greater than 0.
-"""
-nextpow
-
-doc"""
-    rad2deg(x)
-
-Convert `x` from radians to degrees
-"""
-rad2deg
-
-doc"""
-    gc_enable(on::Bool)
-
-Control whether garbage collection is enabled using a boolean argument (`true` for enabled, `false` for disabled). Returns previous GC state. Disabling garbage collection should be used only with extreme caution, as it can cause memory use to grow without bound.
-"""
-gc_enable
-
-doc"""
-    sub2ind(dims, i, j, k...) -> index
-
-The inverse of `ind2sub`, returns the linear index corresponding to the provided subscripts
-"""
-sub2ind
-
-doc"""
-    isperm(v) -> Bool
-
-Returns `true` if `v` is a valid permutation.
-"""
-isperm
-
-doc"""
-    super(T::DataType)
-
-Return the supertype of DataType `T`.
-"""
-super
-
-doc"""
-    readline(stream=STDIN)
-
-Read a single line of text, including a trailing newline character (if one is reached before the end of the input), from the given `stream` (defaults to `STDIN`),
-"""
-readline
-
-doc"""
-    atan(x)
-
-Compute the inverse tangent of `x`, where the output is in radians
-"""
-atan
-
-doc"""
-    logabsdet(M)
-
-Log of absolute value of determinant of real matrix. Equivalent to `(log(abs(det(M))), sign(det(M)))`, but may provide increased accuracy and/or speed.
-"""
-logabsdet
-
-doc"""
-    joinpath(parts...) -> AbstractString
-
-Join path components into a full path. If some argument is an absolute path, then prior components are dropped.
-"""
-joinpath
-
-doc"""
-    get_bigfloat_precision()
-
-Get the precision (in bits) currently used for `BigFloat` arithmetic.
-"""
-get_bigfloat_precision
-
-doc"""
-    homedir() -> AbstractString
-
-Return the current user's home directory.
-"""
-homedir
-
-doc"""
-    count_zeros(x::Integer) -> Integer
-
-Number of zeros in the binary representation of `x`.
-
-```jldoctest
-julia> count_zeros(Int32(2 ^ 16 - 1))
-16
-```
-"""
-count_zeros
-
-doc"""
-    isinf(f) -> Bool
-
-Test whether a number is infinite
-"""
-isinf
-
-doc"""
-    @fetchfrom
-
-Equivalent to `fetch(@spawnat p expr)`.
-"""
-:@fetchfrom
-
-doc"""
-    secd(x)
-
-Compute the secant of `x`, where `x` is in degrees
-"""
-secd
-
-doc"""
-    varm(v, m)
-
-Compute the sample variance of a vector `v` with known mean `m`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-varm
-
-doc"""
-    OverflowError()
-
-The result of an expression is too large for the specified type and will cause a wraparound.
-"""
-OverflowError
-
-doc"""
-    redirect_stderr([stream])
-
-Like redirect\_stdout, but for STDERR
-"""
-redirect_stderr
-
-doc"""
-    ctranspose!(dest,src)
-
-Conjugate transpose array `src` and store the result in the preallocated array `dest`, which should have a size corresponding to `(size(src,2),size(src,1))`. No in-place transposition is supported and unexpected results will happen if `src` and `dest` have overlapping memory regions.
-"""
-ctranspose!
-
-doc"""
-    object_id(x)
-
-Get a unique integer id for `x`. `object_id(x)==object_id(y)` if and only if `is(x,y)`.
-"""
-object_id
-
-doc"""
-```rst
-..  norm(A, [p])
-
-Compute the ``p``-norm of a vector or the operator norm of a matrix ``A``, defaulting to the ``p=2``-norm.
-
-For vectors, ``p`` can assume any numeric value (even though not all values produce a mathematically valid vector norm). In particular, ``norm(A, Inf)`` returns the largest value in ``abs(A)``, whereas ``norm(A, -Inf)`` returns the smallest.
-
-For matrices, the matrix norm induced by the vector ``p``-norm is used, where valid values of ``p`` are ``1``, ``2``, or ``Inf``. (Note that for sparse matrices, ``p=2`` is currently not implemented.) Use :func:`vecnorm` to compute the Frobenius norm.
-```
-"""
-norm
-
-doc"""
-```rst
-..  print_unescaped(io, s::AbstractString)
-
-General unescaping of traditional C and Unicode escape sequences. Reverse of :func:`print_escaped`.
-```
-"""
-print_unescaped
-
-doc"""
-    digits!(array, n, [base])
-
-Fills an array of the digits of `n` in the given base. More significant digits are at higher indexes. If the array length is insufficient, the least significant digits are filled up to the array length. If the array length is excessive, the excess portion is filled with zeros.
-"""
-digits!
-
-doc"""
-    MethodError(f, args)
-
-A method with the required type signature does not exist in the given generic function.
-"""
-MethodError
-
-doc"""
-    cat(dims, A...)
-
-Concatenate the input arrays along the specified dimensions in the iterable `dims`. For dimensions not in `dims`, all input arrays should have the same size, which will also be the size of the output array along that dimension. For dimensions in `dims`, the size of the output array is the sum of the sizes of the input arrays along that dimension. If `dims` is a single number, the different arrays are tightly stacked along that dimension. If `dims` is an iterable containing several dimensions, this allows to construct block diagonal matrices and their higher-dimensional analogues by simultaneously increasing several dimensions for every new input array and putting zero blocks elsewhere. For example, `cat([1,2], matrices...)` builds a block diagonal matrix, i.e. a block matrix with `matrices[1]`, `matrices[2]`, ... as diagonal blocks and matching zero blocks away from the diagonal.
-"""
-cat
-
-doc"""
-```rst
-..  factorial(n)
-
-Factorial of ``n``.  If ``n`` is an :obj:`Integer`, the factorial
-is computed as an integer (promoted to at least 64 bits).  Note
-that this may overflow if ``n`` is not small, but you can use
-``factorial(big(n))`` to compute the result exactly in arbitrary
-precision.  If ``n`` is not an ``Integer``, ``factorial(n)`` is
-equivalent to :func:`gamma(n+1) <gamma>`.
-```
-"""
-factorial(n)
-
-doc"""
-```rst
-..  factorial(n,k)
-
-Compute ``factorial(n)/factorial(k)``
-```
-"""
-factorial(n,k)
-
-doc"""
-    bitrand([rng], [dims...])
-
-Generate a `BitArray` of random boolean values.
-"""
-bitrand
-
-doc"""
-```rst
-..  randcycle([rng,] n)
-
-Construct a random cyclic permutation of length ``n``. The optional ``rng``
-argument specifies a random number generator, see :ref:`Random Numbers
-<random-numbers>`.
-```
-"""
-randcycle
-
-doc"""
-    leading_zeros(x::Integer) -> Integer
-
-Number of zeros leading the binary representation of `x`.
-
-```jldoctest
-julia> leading_zeros(Int32(1))
-31
-```
-"""
-leading_zeros
-
-doc"""
-    hankelh2(nu, x)
-
-Bessel function of the third kind of order `nu`, $H^{(2)}_\nu(x)$.
-"""
-hankelh2
-
-doc"""
-    lexcmp(x, y)
-
-Compare `x` and `y` lexicographically and return -1, 0, or 1 depending on whether `x` is less than, equal to, or greater than `y`, respectively. This function should be defined for lexicographically comparable types, and `lexless` will call `lexcmp` by default.
-"""
-lexcmp
-
-doc"""
-    inf(f)
-
-Returns positive infinity of the floating point type `f` or of the same floating point type as `f`
-"""
-inf
-
-doc"""
-    isupper(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is an uppercase letter, or whether this is true for all elements of a string. A character is classified as uppercase if it belongs to Unicode category Lu, Letter: Uppercase, or Lt, Letter: Titlecase.
-"""
-isupper
-
-doc"""
-    pointer_to_array(pointer, dims[, take_ownership::Bool])
-
-Wrap a native pointer as a Julia Array object. The pointer element type determines the array element type. `own` optionally specifies whether Julia should take ownership of the memory, calling `free` on the pointer when the array is no longer referenced.
-"""
-pointer_to_array
-
-doc"""
-    show(x)
-
-Write an informative text representation of a value to the current output stream. New types should overload `show(io, x)` where the first argument is a stream. The representation used by `show` generally includes Julia-specific formatting and type information.
-"""
-show
-
-doc"""
-    @allocated
-
-A macro to evaluate an expression, discarding the resulting value, instead returning the total number of bytes allocated during evaluation of the expression. Note: the expression is evaluated inside a local function, instead of the current context, in order to eliminate the effects of compilation, however, there still may be some allocations due to JIT compilation. This also makes the results inconsistent with the `@time` macros, which do not try to adjust for the effects of compilation.
-"""
-:@allocated
-
-doc"""
-    Array(dims)
-
-`Array{T}(dims)` constructs an uninitialized dense array with element type `T`. `dims` may be a tuple or a series of integer arguments. The syntax `Array(T, dims)` is also available, but deprecated.
-"""
-Array
-
-doc"""
-    isreal(x) -> Bool
-
-Test whether `x` or all its elements are numerically equal to some real number
-"""
-isreal
-
-doc"""
-    randsubseq(A, p) -> Vector
-
-Return a vector consisting of a random subsequence of the given array `A`, where each element of `A` is included (in order) with independent probability `p`. (Complexity is linear in `p*length(A)`, so this function is efficient even if `p` is small and `A` is large.) Technically, this process is known as "Bernoulli sampling" of `A`.
-"""
-randsubseq
-
-doc"""
-    issubtype(type1, type2)
-
-Return `true` if and only if all values of `type1` are also of `type2`. Can also be written using the `<:` infix operator as `type1 <: type2`.
-"""
-issubtype(type1, type2)
-
-doc"""
-    finalizer(x, function)
-
-Register a function `f(x)` to be called when there are no program-accessible references to `x`. The behavior of this function is unpredictable if `x` is of a bits type.
-"""
-finalizer
-
-doc"""
-    nextprod([k_1,k_2,...], n)
-
-Next integer not less than `n` that can be written as $\prod k_i^{p_i}$ for integers $p_1$, $p_2$, etc.
-"""
-nextprod
-
-doc"""
-    <<(x, n)
-
-Left bit shift operator.
-"""
-Base.(:(<<))
-
-doc"""
-    csch(x)
-
-Compute the hyperbolic cosecant of `x`
-"""
-csch
-
-doc"""
-    isequal(x, y)
-
-Similar to `==`, except treats all floating-point `NaN` values as equal to each other, and treats `-0.0` as unequal to `0.0`. The default implementation of `isequal` calls `==`, so if you have a type that doesn't have these floating-point subtleties then you probably only need to define `==`.
-
-`isequal` is the comparison function used by hash tables (`Dict`). `isequal(x,y)` must imply that `hash(x) == hash(y)`.
-
-This typically means that if you define your own `==` function then you must define a corresponding `hash` (and vice versa). Collections typically implement `isequal` by calling `isequal` recursively on all contents.
-
-Scalar types generally do not need to implement `isequal` separate from `==`, unless they represent floating-point numbers amenable to a more efficient implementation than that provided as a generic fallback (based on `isnan`, `signbit`, and `==`).
-"""
-isequal
-
-doc"""
-    lyap(A, C)
-
-Computes the solution `X` to the continuous Lyapunov equation `AX + XA' + C = 0`, where no eigenvalue of `A` has a zero real part and no two eigenvalues are negative complex conjugates of each other.
-"""
-lyap
-
-doc"""
-    condskeel(M, [x, p])
-
-$$\kappa_S(M, p) & = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert  \right\Vert_p \\
-\kappa_S(M, x, p) & = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p$$
-
-Skeel condition number $\kappa_S$ of the matrix `M`, optionally with respect to
-the vector `x`, as computed using the operator `p`-norm. `p` is `Inf` by
-default, if not provided. Valid values for `p` are `1`, `2`, or `Inf`.
-
-This quantity is also known in the literature as the Bauer condition number,
-relative condition number, or componentwise relative condition number.
-"""
-condskeel
-
-doc"""
-    sec(x)
-
-Compute the secant of `x`, where `x` is in radians
-"""
-sec
-
-doc"""
-    recv(socket::UDPSocket)
-
-Read a UDP packet from the specified socket, and return the bytes received. This call blocks.
-"""
-recv
-
-doc"""
-    acoth(x)
-
-Compute the inverse hyperbolic cotangent of `x`
-"""
-acoth
-
-doc"""
-    det(M)
-
-Matrix determinant
-"""
-det
-
-doc"""
-    TypeError(func::Symbol, context::AbstractString, expected::Type, got)
-
-A type assertion failure, or calling an intrinsic function with an incorrect argument type.
-"""
-TypeError
-
-doc"""
-```rst
-..  plan_fft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Pre-plan an optimized FFT along given dimensions (``dims``) of arrays
-matching the shape and type of ``A``.  (The first two arguments have
-the same meaning as for :func:`fft`.)  Returns an object ``P`` which
-represents the linear operator computed by the FFT, and which contains
-all of the information needed to compute ``fft(A, dims)`` quickly.
-
-To apply ``P`` to an array ``A``, use ``P * A``; in general, the
-syntax for applying plans is much like that of matrices.  (A plan
-can only be applied to arrays of the same size as the ``A`` for
-which the plan was created.)  You can also apply a plan with a
-preallocated output array ``Â`` by calling ``A_mul_B!(Â, plan,
-A)``.  You can compute the inverse-transform plan by ``inv(P)`` and
-apply the inverse plan with ``P \ Â`` (the inverse plan is cached
-and reused for subsequent calls to ``inv`` or ``\``), and apply the
-inverse plan to a pre-allocated output array ``A`` with
-``A_ldiv_B!(A, P, Â)``.
-
-The ``flags`` argument is a bitwise-or of FFTW planner flags, defaulting
-to ``FFTW.ESTIMATE``.  e.g. passing ``FFTW.MEASURE`` or ``FFTW.PATIENT``
-will instead spend several seconds (or more) benchmarking different
-possible FFT algorithms and picking the fastest one; see the FFTW manual
-for more information on planner flags.  The optional ``timelimit`` argument
-specifies a rough upper bound on the allowed planning time, in seconds.
-Passing ``FFTW.MEASURE`` or ``FFTW.PATIENT`` may cause the input array ``A``
-to be overwritten with zeros during plan creation.
-
-:func:`plan_fft!` is the same as :func:`plan_fft` but creates a plan
-that operates in-place on its argument (which must be an array of
-complex floating-point numbers).  :func:`plan_ifft` and so on
-are similar but produce plans that perform the equivalent of
-the inverse transforms :func:`ifft` and so on.
-```
-"""
-plan_fft
-
-doc"""
-    A_rdiv_Bt(A, B)
-
-For matrices or vectors `A` and `B`, calculates `A / Bᵀ`
-"""
-A_rdiv_Bt
-
-doc"""
-    pwd() -> AbstractString
-
-Get the current working directory.
-"""
-pwd
-
-doc"""
-    getipaddr() -> AbstractString
-
-Get the IP address of the local machine, as a string of the form "x.x.x.x".
-"""
-getipaddr
-
-doc"""
-    uppercase(string)
-
-Returns `string` with all characters converted to uppercase.
-"""
-uppercase
-
-doc"""
-    cosd(x)
-
-Compute cosine of `x`, where `x` is in degrees
-"""
-cosd
-
-doc"""
-```rst
-..  brfft(A, d [, dims])
-
-Similar to :func:`irfft` but computes an unnormalized inverse transform
-(similar to :func:`bfft`), which must be divided by the product
-of the sizes of the transformed dimensions (of the real output array)
-in order to obtain the inverse transform.
-```
-"""
-brfft
-
-doc"""
-    cycle(iter)
-
-An iterator that cycles through `iter` forever.
-"""
-cycle
-
-doc"""
-    put!(RemoteRef, value)
-
-Store a value to a remote reference. Implements "shared queue of length 1" semantics: if a value is already present, blocks until the value is removed with `take!`. Returns its first argument.
-"""
-put!(::RemoteRef, value)
-
-doc"""
-    put!(Channel, value)
-
-Appends an item to the channel. Blocks if the channel is full.
-"""
-put!(::Channel, value)
-
-doc"""
-    operm(file)
-
-Like uperm but gets the permissions for people who neither own the file nor are a member of the group owning the file
-"""
-operm
-
-doc"""
-```rst
-..  cumsum(A, [dim])
-
-Cumulative sum along a dimension ``dim`` (defaults to 1).
-See also :func:`cumsum!` to use a preallocated output array,
-both for performance and to control the precision of the
-output (e.g. to avoid overflow).
-```
-"""
-cumsum
-
-doc"""
-    rmprocs(pids...)
-
-Removes the specified workers.
-"""
-rmprocs
-
-doc"""
-    rpad(string, n, p)
-
-Make a string at least `n` columns wide when printed, by padding on the right with copies of `p`.
-"""
-rpad
-
-doc"""
-    setfield!(value, name::Symbol, x)
-
-Assign `x` to a named field in `value` of composite type. The syntax `a.b = c` calls `setfield!(a, :b, c)`, and the syntax `a.(b) = c` calls `setfield!(a, b, c)`.
-"""
-setfield!
-
-doc"""
-    @printf([io::IOStream], "%Fmt", args...)
-
-Print `args` using C `printf()` style format specification string. Optionally, an `IOStream` may be passed as the first argument to redirect output.
-"""
-:@printf
-
-doc"""
-    rstrip(string, [chars])
-
-Return `string` with any trailing whitespace removed. If `chars` (a character, or vector or set of characters) is provided, instead remove characters contained in it.
-"""
-rstrip
-
-doc"""
-    countlines(io,[eol::Char])
-
-Read `io` until the end of the stream/file and count the number of lines. To specify a file pass the filename as the first argument. EOL markers other than '\\n' are supported by passing them as the second argument.
-"""
-countlines
-
-doc"""
-    *(A, B)
-
-Matrix multiplication
-"""
-Base.(:(*))(::AbstractMatrix, ::AbstractMatrix)
-
-doc"""
-```rst
-..  \\(A, B)
-
-Matrix division using a polyalgorithm. For input matrices ``A`` and ``B``, the result ``X`` is such that ``A*X == B`` when ``A`` is square.  The solver that is used depends upon the structure of ``A``.  A direct solver is used for upper or lower triangular ``A``.  For Hermitian ``A`` (equivalent to symmetric ``A`` for non-complex ``A``) the ``BunchKaufman`` factorization is used.  Otherwise an LU factorization is used. For rectangular ``A`` the result is the minimum-norm least squares solution computed by a pivoted QR factorization of ``A`` and a rank estimate of ``A`` based on the R factor.
-
-When ``A`` is sparse, a similar polyalgorithm is used. For indefinite matrices, the ``LDLt`` factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.
-```
-"""
-Base.(:(\))(A,B)
-
-doc"""
-```rst
-..  .\\(x, y)
-
-Element-wise left division operator.
-```
-"""
-Base.(:(.\))(x,y)
-
-doc"""
-```rst
-..  \\(x, y)
-
-Left division operator: multiplication of ``y`` by the inverse of ``x`` on the left.
-Gives floating-point results for integer arguments.
-```
-"""
-Base.(:(\))(x::Number,y::Number)
-
-
-doc"""
-    *(x, y...)
-
-Multiplication operator. `x*y*z*...` calls this function with all arguments, i.e.
-`*(x, y, z, ...)`.
-"""
-Base.(:(*))(x, y...)
-
-doc"""
-    *(s, t)
-
-Concatenate strings. The `*` operator is an alias to this function.
-
-```jldoctest
-julia> "Hello " * "world"
-"Hello world"
-```
-"""
-Base.(:(*))(s::AbstractString, t::AbstractString)
-
-doc"""
-```rst
-..  complement!(s)
-
-Mutates :obj:`IntSet` ``s`` into its set-complement.
-```
-"""
-complement!
-
-doc"""
-```rst
-..  slice(A, inds...)
-
-Returns a view of array ``A`` with the given indices like :func:`sub`, but drops all dimensions indexed with scalars.
-```
-"""
-slice
-
-doc"""
-    time()
-
-Get the system time in seconds since the epoch, with fairly high (typically, microsecond) resolution.
-"""
-time()
-
-doc"""
-    procs()
-
-Returns a list of all process identifiers.
-"""
-procs
-
-doc"""
-    procs(S::SharedArray)
-
-Get the vector of processes that have mapped the shared array
-"""
-procs(::SharedArray)
-
-doc"""
-```rst
-..  plan_bfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as :func:`plan_fft`, but produces a plan that performs an unnormalized
-backwards transform :func:`bfft`.
-```
-"""
-plan_bfft
-
-doc"""
-    mod(x, y)
-
-Modulus after division, returning in the range \[0,`y`), if `y` is positive, or (`y`,0\] if `y` is negative.
-"""
-mod
-
-doc"""
-    trues(dims)
-
-Create a `BitArray` with all values set to `true`
-"""
-trues
-
-doc"""
-    qr(A [,pivot=Val{false}][;thin=true]) -> Q, R, [p]
-
-Compute the (pivoted) QR factorization of `A` such that either `A = Q*R` or `A[:,p] = Q*R`. Also see `qrfact`. The default is to compute a thin factorization. Note that `R` is not extended with zeros when the full `Q` is requested.
-"""
-qr
-
-doc"""
-    invmod(x,m)
-
-Take the inverse of `x` modulo `m`: `y` such that $xy = 1 \pmod m$.
-"""
-invmod
-
-doc"""
-    TextDisplay(stream)
-
-Returns a `TextDisplay <: Display`, which can display any object as the text/plain MIME type (only), writing the text representation to the given I/O stream. (The text representation is the same as the way an object is printed in the Julia REPL.)
-"""
-TextDisplay
-
-doc"""
-    factor(n) -> Dict
-
-Compute the prime factorization of an integer `n`. Returns a dictionary. The
-keys of the dictionary correspond to the factors, and hence are of the same type
-as `n`. The value associated with each key indicates the number of times the
-factor appears in the factorization.
-
-```jldoctest
-julia> factor(100) # == 2*2*5*5
-Dict{Int64,Int64} with 2 entries:
-  2 => 2
-  5 => 2
-```
-"""
-factor
-
-doc"""
-    ismatch(r::Regex, s::AbstractString) -> Bool
-
-Test whether a string contains a match of the given regular expression.
-"""
-ismatch
-
-doc"""
-    exp(x)
-
-Compute $e^x$.
-"""
-exp
-
-doc"""
-    with_bigfloat_precision(f::Function,precision::Integer)
-
-Change the `BigFloat` arithmetic precision (in bits) for the duration of `f`. It is logically equivalent to:
-
-    old = get_bigfloat_precision()
-    set_bigfloat_precision(precision)
-    f()
-    set_bigfloat_precision(old)
-"""
-with_bigfloat_precision
-
-doc"""
-    searchindex(string, substring, [start])
-
-Similar to `search`, but return only the start index at which the substring is found, or `0` if it is not.
-"""
-searchindex
-
-doc"""
-    listenany(port_hint) -> (UInt16,TcpServer)
-
-Create a TcpServer on any port, using hint as a starting point. Returns a tuple of the actual port that the server was created on and the server itself.
-"""
-listenany
-
-doc"""
-    getpid() -> Int32
-
-Get julia's process ID.
-"""
-getpid
-
-doc"""
-    cbrt(x)
-
-Return $x^{1/3}$.  The prefix operator `∛` is equivalent to `cbrt`.
-"""
-cbrt
-
-doc"""
-```rst
-..  Tridiagonal(dl, d, du)
-
-Construct a tridiagonal matrix from the lower diagonal, diagonal, and upper diagonal, respectively.  The result is of type ``Tridiagonal`` and provides efficient specialized linear solvers, but may be converted into a regular matrix with :func:`full`.
-```
-"""
-Tridiagonal
-
-doc"""
-    findprev(A, i)
-
-Find the previous index <= `i` of a non-zero element of `A`, or `0` if not found.
-"""
-findprev(A,i)
-
-doc"""
-    findprev(predicate, A, i)
-
-Find the previous index <= `i` of an element of `A` for which `predicate` returns `true`, or `0` if not found.
-"""
-findprev(predicate::Function,A,i)
-
-doc"""
-    findprev(A, v, i)
-
-Find the previous index <= `i` of an element of `A` equal to `v` (using `==`), or `0` if not found.
-"""
-findprev(A,v,i)
-
-doc"""
-    matchall(r::Regex, s::AbstractString[, overlap::Bool=false]) -> Vector{AbstractString}
-
-Return a vector of the matching substrings from eachmatch.
-"""
-matchall
-
-doc"""
-    get!(collection, key, default)
-
-Return the value stored for the given key, or if no mapping for the key is present, store `key => default`, and return `default`.
-"""
-get!(collection,key,default)
-
-doc"""
-    get!(f::Function, collection, key)
-
-Return the value stored for the given key, or if no mapping for the key is present, store `key => f()`, and return `f()`.
-
-This is intended to be called using `do` block syntax:
-
-    get!(dict, key) do
-        # default value calculated here
-        time()
-    end
-"""
-get!(f::Function,collection,key)
-
-doc"""
-    inv(M)
-
-Matrix inverse
-"""
-inv
-
-doc"""
-    mod1(x,m)
-
-Modulus after division, returning in the range (0,m\]
-"""
-mod1
-
-doc"""
-    @assert cond [text]
-
-Throw an `AssertionError` if `cond` is `false`. Preferred syntax for writing assertions.
-Message `text` is optionally displayed upon assertion failure.
-"""
-:@assert
-
-doc"""
-    intersect!(s1, s2)
-
-Intersects sets `s1` and `s2` and overwrites the set `s1` with the result. If needed, `s1` will be expanded to the size of `s2`.
-"""
-intersect!
-
-doc"""
-    listen([addr,]port) -> TcpServer
-
-Listen on port on the address specified by `addr`. By default this listens on localhost only. To listen on all interfaces pass `IPv4(0)` or `IPv6(0)` as appropriate.
-"""
-listen(addr,port)
-
-doc"""
-    listen(path) -> PipeServer
-
-Create and listen on a Named Pipe / Domain Socket
-"""
-listen(path)
-
-doc"""
-    leading_ones(x::Integer) -> Integer
-
-Number of ones leading the binary representation of `x`.
-
-```jldoctest
-julia> leading_ones(UInt32(2 ^ 32 - 2))
-31
-```
-"""
-leading_ones
-
-doc"""
-    deserialize(stream)
-
-Read a value written by `serialize`.
-"""
-deserialize
-
-doc"""
-    asech(x)
-
-Compute the inverse hyperbolic secant of `x`
-"""
-asech
-
-doc"""
-    sprandn(m,n,p)
-
-Create a random `m` by `n` sparse matrix with the specified (independent) probability `p` of any entry being nonzero, where nonzero values are sampled from the normal distribution.
-"""
-sprandn
-
-doc"""
-```rst
-..  ismarked(s)
-
-Returns ``true`` if stream ``s`` is marked.
-
-See also :func:`mark`, :func:`unmark`, :func:`reset`
-```
-"""
-ismarked
-
-doc"""
-```rst
-..  first(coll)
-
-Get the first element of an iterable collection. Returns the start point of a :obj:`Range`
-even if it is empty.
-```
-"""
-first
-
-doc"""
-    median!(v)
-
-Like `median`, but may overwrite the input vector.
-"""
-median!
-
-doc"""
-    cumprod!(B, A, [dim])
-
-Cumulative product of `A` along a dimension, storing the result in `B`. The dimension defaults to 1.
-"""
-cumprod!
-
-doc"""
-    @linux
-
-Given `@linux? a : b`, do `a` on Linux and `b` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
-"""
-:@linux
-
-doc"""
-```rst
-..  complement(s)
-
-Returns the set-complement of :obj:`IntSet` ``s``.
-```
-"""
-complement
-
-doc"""
-    rethrow([e])
-
-Throw an object without changing the current exception backtrace. The default argument is the current exception (if called within a `catch` block).
-"""
-rethrow
-
-doc"""
-    reprmime(mime, x)
-
-Returns an `AbstractString` or `Vector{UInt8}` containing the representation of `x` in the requested `mime` type, as written by `writemime` (throwing a `MethodError` if no appropriate `writemime` is available). An `AbstractString` is returned for MIME types with textual representations (such as `"text/html"` or `"application/postscript"`), whereas binary data is returned as `Vector{UInt8}`. (The function `istext(mime)` returns whether or not Julia treats a given `mime` type as text.)
-
-As a special case, if `x` is an `AbstractString` (for textual MIME types) or a `Vector{UInt8}` (for binary MIME types), the `reprmime` function assumes that `x` is already in the requested `mime` format and simply returns `x`.
-"""
-reprmime
-
-doc"""
-    rm(path::AbstractString; recursive=false)
-
-Delete the file, link, or empty directory at the given path. If `recursive=true` is passed and the path is a directory, then all contents are removed recursively.
-"""
-rm
-
-doc"""
-    MersenneTwister([seed])
-
-Create a `MersenneTwister` RNG object. Different RNG objects can have their own seeds, which may be useful for generating different streams of random numbers.
-"""
-MersenneTwister
-
-doc"""
-    graphemes(s) -> iterator over substrings of s
-
-Returns an iterator over substrings of `s` that correspond to the extended graphemes in the string, as defined by Unicode UAX \#29. (Roughly, these are what users would perceive as single characters, even though they may contain more than one codepoint; for example a letter combined with an accent mark is a single grapheme.)
-"""
-graphemes
-
-doc"""
-    @__FILE__ -> AbstractString
-
-`@__FILE__` expands to a string with the absolute path and file name of the script being run. Returns `nothing` if run from a REPL or an empty string if evaluated by `julia -e <expr>`.
-"""
-:@__FILE__
-
-keywords[symbol("@__LINE__")] = doc"""
-    @__LINE__ -> Int
-
-`@__LINE__` expands to the line number of the call-site.
-"""
-
-doc"""
-    charwidth(c)
-
-Gives the number of columns needed to print a character.
-"""
-charwidth
-
-doc"""
-    abspath(path::AbstractString) -> AbstractString
-
-Convert a path to an absolute path by adding the current directory if necessary.
-"""
-abspath
-
-doc"""
-    ispunct(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character belongs to the Unicode general category Punctuation, i.e. a character whose category code begins with 'P'. For strings, tests whether this is true for all elements of the string.
-"""
-ispunct
-
-doc"""
-    bitunpack(B::BitArray{N}) -> Array{Bool,N}
-
-Converts a packed boolean array to an array of booleans
-"""
-bitunpack
-
-doc"""
-    @which
-
-Applied to a function call, it evaluates the arguments to the specified function call, and returns the `Method` object for the method that would be called for those arguments. Applied to a variable, it returns the module in which the variable was bound. It calls out to the `which` function.
-"""
-:@which
-
-doc"""
-    size(A, [dim...])
-
-Returns a tuple containing the dimensions of `A`. Optionally you can specify the dimension(s) you want the length of, and get the length of that dimension, or a tuple of the lengths of dimensions you asked for.:
-
-    julia> A = rand(2,3,4);
-
-    julia> size(A, 2)
-    3
-
-    julia> size(A,3,2)
-    (4,3)
-"""
-size
-
-doc"""
-    trigamma(x)
-
-Compute the trigamma function of `x` (the logarithmic second derivative of `gamma(x)`)
-"""
-trigamma
-
-doc"""
-    findmin(itr) -> (x, index)
-
-Returns the minimum element and its index.
-"""
-findmin(itr)
-
-doc"""
-    findmin(A, dims) -> (minval, index)
-
-For an array input, returns the value and index of the minimum over the given dimensions.
-"""
-findmin(A,dims)
-
-doc"""
-    ismount(path) -> Bool
-
-Returns `true` if `path` is a mount point, `false` otherwise.
-"""
-ismount
-
-doc"""
-    endswith(string, suffix | chars)
-
-Returns `true` if `string` ends with `suffix`. If the second argument is a vector or set of characters, tests whether the last character of `string` belongs to that set.
-"""
-endswith
-
-doc"""
-    airy(k,x)
-
-The `k`th derivative of the Airy function $\operatorname{Ai}(x)$.
-"""
-airy
-
-doc"""
-    !(x)
-
-Boolean not
-"""
-Base.(:(!))
-
-doc"""
-    length(A) -> Integer
-
-Returns the number of elements in `A`.
-"""
-length(::AbstractArray)
-
-doc"""
-    length(collection) -> Integer
-
-For ordered, indexable collections, the maximum index `i` for which `getindex(collection, i)` is valid. For unordered collections, the number of elements.
-"""
-length(collection)
-
-doc"""
-    length(s)
-
-The number of characters in string `s`.
-"""
-length(::AbstractString)
-
-doc"""
-    rand!([rng], A, [coll])
-
-Populate the array `A` with random values. If the indexable collection `coll` is specified, the values are picked randomly from `coll`. This is equivalent to `copy!(A, rand(rng, coll, size(A)))` or `copy!(A, rand(rng, eltype(A), size(A)))` but without allocating a new array.
-"""
-rand!
-
-doc"""
-```rst
-..  bkfact(A) -> BunchKaufman
-
-Compute the Bunch-Kaufman [Bunch1977]_ factorization of a real symmetric or complex Hermitian matrix ``A`` and return a ``BunchKaufman`` object. The following functions are available for ``BunchKaufman`` objects: ``size``, ``\``, ``inv``, ``issym``, ``ishermitian``.
-
-.. [Bunch1977] J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. `url <http://www.ams.org/journals/mcom/1977-31-137/S0025-5718-1977-0428694-0>`_.
-```
-"""
-bkfact
-
-doc"""
-    searchsortedlast(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Returns the index of the last value in `a` less than or equal to `x`, according to the specified order. Returns `0` if `x` is less than all values in `a`.
-"""
-searchsortedlast
-
-doc"""
-    InterruptException()
-
-The process was stopped by a terminal interrupt (CTRL+C).
-"""
-InterruptException
-
-doc"""
-    cov(v1[, v2][, vardim=1, corrected=true, mean=nothing])
-
-Compute the Pearson covariance between the vector(s) in `v1` and `v2`. Here, `v1` and `v2` can be either vectors or matrices.
-
-This function accepts three keyword arguments:
-
--   `vardim`: the dimension of variables. When `vardim = 1`, variables are considered in columns while observations in rows; when `vardim = 2`, variables are in rows while observations in columns. By default, it is set to `1`.
--   `corrected`: whether to apply Bessel's correction (divide by `n-1` instead of `n`). By default, it is set to `true`.
--   `mean`: allow users to supply mean values that are known. By default, it is set to `nothing`, which indicates that the mean(s) are unknown, and the function will compute the mean. Users can use `mean=0` to indicate that the input data are centered, and hence there's no need to subtract the mean.
-
-The size of the result depends on the size of `v1` and `v2`. When both `v1` and `v2` are vectors, it returns the covariance between them as a scalar. When either one is a matrix, it returns a covariance matrix of size `(n1, n2)`, where `n1` and `n2` are the numbers of slices in `v1` and `v2`, which depend on the setting of `vardim`.
-
-Note: `v2` can be omitted, which indicates `v2 = v1`.
-"""
-cov
-
-doc"""
-    den(x)
-
-Denominator of the rational representation of `x`
-"""
-den
-
-doc"""
-    issubnormal(f) -> Bool
-
-Test whether a floating point number is subnormal
-"""
-issubnormal
-
-doc"""
-    Ac_ldiv_B(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᴴ \ B`
-"""
-Ac_ldiv_B
-
-doc"""
-    NullException()
-
-An attempted access to a `Nullable` with no defined value.
-"""
-NullException
-
-doc"""
-    .==(x, y)
-
-Element-wise equality comparison operator.
-"""
-Base.(:(.==))
-
-doc"""
-    cfunction(function::Function, ReturnType::Type, (ArgumentTypes...))
-
-Generate C-callable function pointer from Julia function. Type annotation of the return value in the callback function is a must for situations where Julia cannot infer the return type automatically.
-
-For example:
-
-    function foo()
-        # body
-
-        retval::Float64
-    end
-
-    bar = cfunction(foo, Float64, ())
-"""
-cfunction
-
-doc"""
-    recvfrom(socket::UDPSocket) -> (address, data)
-
-Read a UDP packet from the specified socket, returning a tuple of (address, data), where address will be either IPv4 or IPv6 as appropriate.
-"""
-recvfrom
-
-doc"""
-```rst
-..  @code_llvm
-
-Evaluates the arguments to the function call, determines their types, and calls :func:`code_llvm` on the resulting expression.
-```
-"""
-:@code_llvm
-
-doc"""
-    nextfloat(f)
-
-Get the next floating point number in lexicographic order
-"""
-nextfloat
-
-doc"""
-    intersect(s1,s2...)
-    ∩(s1,s2)
-
-Construct the intersection of two or more sets. Maintains order and multiplicity of the first argument for arrays and ranges.
-"""
-intersect
-
-doc"""
-    !=(x, y)
-    ≠(x,y)
-
-Not-equals comparison operator. Always gives the opposite answer as `==`. New types should generally not implement this, and rely on the fallback definition `!=(x,y) = !(x==y)` instead.
-"""
-Base.(:(!=))
-
-doc"""
-    @spawn
-
-Creates a closure around an expression and runs it on an automatically-chosen process, returning a `RemoteRef` to the result.
-"""
-:@spawn
-
-doc"""
-    findfirst(A)
-
-Return the index of the first non-zero value in `A` (determined by `A[i]!=0`).
-"""
-findfirst(A)
-
-doc"""
-    findfirst(A,v)
-
-Return the index of the first element equal to `v` in `A`.
-"""
-findfirst(A,v)
-
-doc"""
-    findfirst(predicate, A)
-
-Return the index of the first element of `A` for which `predicate` returns `true`.
-"""
-findfirst
-
-doc"""
-    factorize(A)
-
-Compute a convenient factorization (including LU, Cholesky, Bunch-Kaufman, LowerTriangular, UpperTriangular) of `A`, based upon the type of the input matrix. The return value can then be reused for efficient solving of multiple systems. For example: `A=factorize(A); x=A\b; y=A\C`.
-"""
-factorize
-
-doc"""
-    promote_rule(type1, type2)
-
-Specifies what type should be used by `promote` when given values of types `type1` and `type2`. This function should not be called directly, but should have definitions added to it for new types as appropriate.
-"""
-promote_rule
-
-doc"""
-    mtime(file)
-
-Equivalent to `stat(file).mtime`
-"""
-mtime
-
-doc"""
-    SharedArray(T::Type, dims::NTuple; init=false, pids=Int[])
-
-Construct a `SharedArray` of a bitstype `T` and size `dims` across the processes specified by `pids` - all of which have to be on the same host.
-
-If `pids` is left unspecified, the shared array will be mapped across all processes on the current host, including the master. But, `localindexes` and `indexpids` will only refer to worker processes. This facilitates work distribution code to use workers for actual computation with the master process acting as a driver.
-
-If an `init` function of the type `initfn(S::SharedArray)` is specified, it is called on all the participating workers.
-"""
-SharedArray
-
-doc"""
-    logspace(start, stop, n=50)
-
-Construct a vector of `n` logarithmically spaced numbers from `10^start` to `10^stop`.
-"""
-logspace
-
-doc"""
-    @gensym
-
-Generates a gensym symbol for a variable. For example, `@gensym x y` is transformed into `x = gensym("x"); y = gensym("y")`.
-"""
-:@gensym
-
-doc"""
-    sumabs2(itr)
-
-Sum squared absolute values of all elements in a collection. This is equivalent to `sum(abs2(itr))` but faster.
-"""
-sumabs2(itr)
-
-doc"""
-    sumabs2(A, dims)
-
-Sum squared absolute values of elements of an array over the given dimensions.
-"""
-sumabs2(A,dims)
-
-doc"""
-```rst
-..  uperm(file)
-
-Gets the permissions of the owner of the file as a bitfield of
-
-==== =====================
- 01   Execute Permission
- 02   Write Permission
- 04   Read Permission
-==== =====================
-
-For allowed arguments, see ``stat``.
-```
-"""
-uperm
-
-doc"""
-    run(command)
-
-Run a command object, constructed with backticks. Throws an error if anything goes wrong, including the process exiting with a non-zero status.
-"""
-run
-
-doc"""
-    showall(x)
-
-Similar to `show`, except shows all elements of arrays.
-"""
-showall
-
-doc"""
-    mimewritable(mime, x)
-
-Returns a boolean value indicating whether or not the object `x` can be written as the given `mime` type. (By default, this is determined automatically by the existence of the corresponding `writemime` function for `typeof(x)`.)
-"""
-mimewritable
-
-doc"""
-    vecdot(x, y)
-
-For any iterable containers `x` and `y` (including arrays of any dimension) of numbers (or any element type for which `dot` is defined), compute the Euclidean dot product (the sum of `dot(x[i],y[i])`) as if they were vectors.
-"""
-vecdot
-
-doc"""
-    isprime(x::Integer) -> Bool
-
-Returns `true` if `x` is prime, and `false` otherwise.
-
-```jldoctest
-julia> isprime(3)
-true
-```
-"""
-isprime(::Integer)
-
-doc"""
-    isprime(x::BigInt, [reps = 25]) -> Bool
-
-Probabilistic primality test. Returns `true` if `x` is prime; and
-`false` if `x` is not prime with high probability. The false positive
-rate is about `0.25^reps`. `reps = 25` is considered safe for
-cryptographic applications (Knuth, Seminumerical Algorithms).
-
-```jldoctest
-julia> isprime(big(3))
-true
-```
-"""
-isprime(::BigInt, ?)
-
-doc"""
-    >(x, y)
-
-Greater-than comparison operator. Generally, new types should implement `<` instead of this function, and rely on the fallback definition `>(x,y) = y<x`.
-"""
-Base.(:(>))
-
-doc"""
-    match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])
-
-Search for the first match of the regular expression `r` in `s` and return a `RegexMatch` object containing the match, or nothing if the match failed. The matching substring can be retrieved by accessing `m.match` and the captured sequences can be retrieved by accessing `m.captures` The optional `idx` argument specifies an index at which to start the search.
-"""
-match
-
-doc"""
-    nprocs()
-
-Get the number of available processes.
-"""
-nprocs
-
-doc"""
-    Ac_mul_B(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᴴ B`
-"""
-Ac_mul_B
-
-doc"""
-```rst
-..  qrfact!(A [,pivot=Val{false}])
-
-``qrfact!`` is the same as :func:`qrfact` when ``A`` is a subtype of ``StridedMatrix``, but saves space by overwriting the input ``A``, instead of creating a copy.
-```
-"""
-qrfact!
-
-doc"""
-    At_rdiv_B(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᵀ / B`
-"""
-At_rdiv_B
-
-doc"""
-    coth(x)
-
-Compute the hyperbolic cotangent of `x`
-"""
-coth
-
-doc"""
-    conj(z)
-
-Compute the complex conjugate of a complex number `z`
-"""
-conj
-
-doc"""
-    conj!(A)
-
-Convert an array to its complex conjugate in-place
-"""
-conj!
-
-doc"""
-    start(iter) -> state
-
-Get initial iteration state for an iterable object
-"""
-start
-
-doc"""
-    div(x, y)
-    ÷(x, y)
-
-The quotient from Euclidean division. Computes `x/y`, truncated to an integer.
-"""
-div
-
-doc"""
-    relpath(path::AbstractString, startpath::AbstractString = ".") -> AbstractString
-
-Return a relative filepath to path either from the current directory or from an optional start directory. This is a path computation: the filesystem is not accessed to confirm the existence or nature of path or startpath.
-"""
-relpath
-
-doc"""
-    readavailable(stream)
-
-Read all available data on the stream, blocking the task only if no data is available. The result is a `Vector{UInt8,1}`.
-"""
-readavailable
-
-doc"""
-    remotecall(id, func, args...)
-
-Call a function asynchronously on the given arguments on the specified process. Returns a `RemoteRef`.
-"""
-remotecall
-
-doc"""
-    slicedim(A, d, i)
-
-Return all the data of `A` where the index for dimension `d` equals `i`. Equivalent to `A[:,:,...,i,:,:,...]` where `i` is in position `d`.
-"""
-slicedim
-
-doc"""
-    isa(x, type) -> Bool
-
-Determine whether `x` is of the given `type`.
-"""
-isa
-
-doc"""
-    <=(x, y)
-    ≤(x,y)
-
-Less-than-or-equals comparison operator.
-"""
-Base.(:(<=))
-
-doc"""
-    ProcessExitedException()
-
-After a client Julia process has exited, further attempts to reference the dead child will throw this exception.
-"""
-ProcessExitedException
-
-doc"""
-    unsafe_load(p::Ptr{T},i::Integer)
-
-Load a value of type `T` from the address of the ith element (1-indexed) starting at `p`. This is equivalent to the C expression `p[i-1]`.
-
-The `unsafe` prefix on this function indicates that no validation is performed on the pointer `p` to ensure that it is valid. Incorrect usage may segfault your program or return garbage answers, in the same manner as C.
-"""
-unsafe_load
-
-doc"""
-    catch_backtrace()
-
-Get the backtrace of the current exception, for use within `catch` blocks.
-"""
-catch_backtrace
-
-doc"""
-    airyx(k,x)
-
-scaled `k`th derivative of the Airy function, return $\operatorname{Ai}(x) e^{\frac{2}{3} x \sqrt{x}}$
-for `k == 0 || k == 1`, and $\operatorname{Ai}(x) e^{- \left| \operatorname{Re} \left( \frac{2}{3} x \sqrt{x} \right) \right|}$
-for `k == 2 || k == 3`.
-"""
-airyx
-
-doc"""
-    get_zero_subnormals() -> Bool
-
-Returns `false` if operations on subnormal floating-point values ("denormals") obey rules for IEEE arithmetic, and ``true`` if they might be converted to zeros.
-"""
-get_zero_subnormals
-
-doc"""
-    cos(x)
-
-Compute cosine of `x`, where `x` is in radians
-"""
-cos
-
-doc"""
-    base64encode(writefunc, args...)
-    base64encode(args...)
-
-Given a `write`-like function `writefunc`, which takes an I/O stream as its first argument, `base64(writefunc, args...)` calls `writefunc` to write `args...` to a base64-encoded string, and returns the string. `base64(args...)` is equivalent to `base64(write, args...)`: it converts its arguments into bytes using the standard `write` functions and returns the base64-encoded string.
-"""
-base64encode
-
-doc"""
-    Condition()
-
-Create an edge-triggered event source that tasks can wait for. Tasks that call `wait` on a `Condition` are suspended and queued. Tasks are woken up when `notify` is later called on the `Condition`. Edge triggering means that only tasks waiting at the time `notify` is called can be woken up. For level-triggered notifications, you must keep extra state to keep track of whether a notification has happened. The `Channel` type does this, and so can be used for level-triggered events.
-"""
-Condition
-
-doc"""
-```rst
-..  filt!(out, b, a, x, [si])
-
-Same as :func:`filt` but writes the result into the ``out`` argument,
-which may alias the input ``x`` to modify it in-place.
-```
-"""
-filt!
-
-doc"""
-    ascii(::Array{UInt8,1})
-
-Create an ASCII string from a byte array.
-"""
-ascii(::Vector{UInt8})
-
-doc"""
-    ascii(s)
-
-Convert a string to a contiguous ASCII string (all characters must be valid ASCII characters).
-"""
-ascii(s)
-
-doc"""
-    ascii(::Ptr{UInt8}, [length])
-
-Create an ASCII string from the address of a C (0-terminated) string encoded in ASCII. A copy is made; the ptr can be safely freed. If `length` is specified, the string does not have to be 0-terminated.
-"""
-ascii(::Ptr{UInt8},?)
-
-doc"""
-```rst
-..  plan_idct(A [, dims [, flags [, timelimit]]])
-
-Pre-plan an optimized inverse discrete cosine transform (DCT), similar to
-:func:`plan_fft` except producing a function that computes :func:`idct`.
-The first two arguments have the same meaning as for :func:`idct`.
-```
-"""
-plan_idct
-
-doc"""
-    maxabs(itr)
-
-Compute the maximum absolute value of a collection of values.
-"""
-maxabs(itr)
-
-doc"""
-    maxabs(A, dims)
-
-Compute the maximum absolute values over given dimensions.
-"""
-maxabs(A,dims)
-
-doc"""
-    done(iter, state) -> Bool
-
-Test whether we are done iterating
-"""
-done
-
-doc"""
-```rst
-..  convert(T, x)
-
-Convert ``x`` to a value of type ``T``.
-
-If ``T`` is an ``Integer`` type, an :exc:`InexactError` will be raised if
-``x`` is not representable by ``T``, for example if ``x`` is not
-integer-valued, or is outside the range supported by ``T``.
-
-.. doctest::
-
-   julia> convert(Int, 3.0)
-   3
-
-   julia> convert(Int, 3.5)
-   ERROR: InexactError()
-    in convert at int.jl:209
-
-If ``T`` is a :obj:`AbstractFloat` or :obj:`Rational` type, then it will return
-the closest value to ``x`` representable by ``T``.
-
-.. doctest::
-
-   julia> x = 1/3
-   0.3333333333333333
-
-   julia> convert(Float32, x)
-   0.33333334f0
-
-   julia> convert(Rational{Int32}, x)
-   1//3
-
-   julia> convert(Rational{Int64}, x)
-   6004799503160661//18014398509481984
-```
-"""
-convert
-
-doc"""
-    A_ldiv_Bt(A, B)
-
-For matrices or vectors `A` and `B`, calculates `A \ Bᵀ`
-"""
-A_ldiv_Bt
-
-doc"""
-    applicable(f, args...) -> Bool
-
-Determine whether the given generic function has a method applicable to the given arguments.
-
-```jldoctest
-julia> function f(x, y)
-           x + y
-       end;
-
-julia> applicable(f, 1)
-false
-
-julia> applicable(f, 1, 2)
-true
-```
-"""
-applicable
-
-doc"""
-    xdump(x)
-
-Show all structure of a value, including all fields of objects.
-"""
-xdump
-
-doc"""
-    Base.process_messages(instrm::AsyncStream, outstrm::AsyncStream)
-
-Called by cluster managers using custom transports. It should be called when the custom transport implementation receives the first message from a remote worker. The custom transport must manage a logical connection to the remote worker and provide two `AsyncStream` objects, one for incoming messages and the other for messages addressed to the remote worker.
-"""
-Base.process_messages
-
-doc"""
-    RandomDevice()
-
-Create a `RandomDevice` RNG object. Two such objects will always generate different streams of random numbers.
-"""
-RandomDevice
-
-doc"""
-```rst
-..  plan_fft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as :func:`plan_fft`, but operates in-place on ``A``.
-```
-"""
-plan_fft!
-
-doc"""
-    fma(x, y, z)
-
-Computes `x*y+z` without rounding the intermediate result `x*y`. On some systems this is significantly more expensive than `x*y+z`. `fma` is used to improve accuracy in certain algorithms. See `muladd`.
-"""
-fma
-
-doc"""
-```rst
-..  eigvals(A,[irange,][vl,][vu])
-
-Returns the eigenvalues of ``A``. If ``A`` is :class:`Symmetric`,
-:class:`Hermitian` or :class:`SymTridiagonal`, it is possible to calculate
-only a subset of the eigenvalues by specifying either a :class:`UnitRange`
-``irange`` covering indices of the sorted eigenvalues, or a pair ``vl`` and
-``vu`` for the lower and upper boundaries of the eigenvalues.
-
-For general non-symmetric matrices it is possible to specify how the matrix
-is balanced before the eigenvector calculation. The option ``permute=true``
-permutes the matrix to become closer to upper triangular, and ``scale=true``
-scales the matrix by its diagonal elements to make rows and columns more
-equal in norm. The default is ``true`` for both options.
-```
-"""
-eigvals
-
-doc"""
-    A_ldiv_Bc(A, B)
-
-For matrices or vectors `A` and `B`, calculates `A \ Bᴴ`
-"""
-A_ldiv_Bc
-
-doc"""
-```rst
-..  escape_string(str::AbstractString) -> AbstractString
-
-General escaping of traditional C and Unicode escape sequences. See :func:`print_escaped` for more general escaping.
-```
-"""
-escape_string
-
-doc"""
-    significand(x)
-
-Extract the `significand(s)` (a.k.a. mantissa), in binary representation, of
-a floating-point number or array. If `x` is a non-zero finite number,
-than the result will be a number of the same type on the interval
-$[1,2)$. Otherwise `x` is returned.
-
-```jldoctest
-julia> significand(15.2)/15.2
-0.125
-
-julia> significand(15.2)*8
-15.2
-```
-"""
-significand
-
-doc"""
-    pointer_from_objref(object_instance)
-
-Get the memory address of a Julia object as a `Ptr`. The existence of the resulting `Ptr` will not protect the object from garbage collection, so you must ensure that the object remains referenced for the whole time that the `Ptr` will be used.
-"""
-pointer_from_objref
-
-doc"""
-    cumsum_kbn(A, [dim])
-
-Cumulative sum along a dimension, using the Kahan-Babuska-Neumaier compensated summation algorithm for additional accuracy. The dimension defaults to 1.
-"""
-cumsum_kbn
-
-doc"""
-    cmp(x,y)
-
-Return -1, 0, or 1 depending on whether `x` is less than, equal to, or greater than `y`, respectively. Uses the total order implemented by `isless`. For floating-point numbers, uses `<` but throws an error for unordered arguments.
-"""
-cmp
-
-doc"""
-    tand(x)
-
-Compute tangent of `x`, where `x` is in degrees
-"""
-tand
-
-doc"""
-    issorted(v, [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Test whether a vector is in sorted order. The `by`, `lt` and `rev` keywords modify what order is considered to be sorted just as they do for `sort`.
-"""
-issorted
-
-doc"""
-    set_bigfloat_precision(x::Int64)
-
-Set the precision (in bits) to be used to `BigFloat` arithmetic.
-"""
-set_bigfloat_precision
-
-doc"""
-    isbits(T)
-
-Return `true` if `T` is a "plain data" type, meaning it is immutable and
-contains no references to other values. Typical examples are numeric types such
-as `UInt8`, `Float64`, and `Complex{Float64}`.
-
-```jldoctest
-julia> isbits(Complex{Float64})
-true
-
-julia> isbits(Complex)
-false
-```
-"""
-isbits
-
-doc"""
-    findlast(A)
-
-Return the index of the last non-zero value in `A` (determined by `A[i]!=0`).
-"""
-findlast(A)
-
-doc"""
-    findlast(A, v)
-
-Return the index of the last element equal to `v` in `A`.
-"""
-findlast(A,v)
-
-doc"""
-    findlast(predicate, A)
-
-Return the index of the last element of `A` for which `predicate` returns `true`.
-"""
-findlast(::Function, A)
-
-doc"""
-    @elapsed
-
-A macro to evaluate an expression, discarding the resulting value, instead returning the number of seconds it took to execute as a floating-point number.
-"""
-:@elapsed
-
-doc"""
-    findnext(A, i)
-
-Find the next index >= `i` of a non-zero element of `A`, or `0` if not found.
-"""
-findnext
-
-doc"""
-    findnext(predicate, A, i)
-
-Find the next index >= `i` of an element of `A` for which `predicate` returns `true`, or `0` if not found.
-"""
-findnext(::Function,A,i)
-
-doc"""
-    findnext(A, v, i)
-
-Find the next index >= `i` of an element of `A` equal to `v` (using `==`), or `0` if not found.
-"""
-findnext(A,v,i)
-
-doc"""
-    fetch(x)
-
-Waits and fetches a value from `x` depending on the type of `x`. Does not remove the item fetched:
-
-* `RemoteRef`: Wait for and get the value of a remote reference. If the remote value is an exception, throws a `RemoteException` which captures the remote exception and backtrace.
-* `Channel` : Wait for and get the first available item from the channel.
-"""
-fetch
-
-doc"""
-    angle(z)
-
-Compute the phase angle in radians of a complex number `z`
-"""
-angle
-
-doc"""
-```rst
-..  tic()
-
-Set a timer to be read by the next call to :func:`toc` or :func:`toq`. The macro call ``@time expr`` can also be used to time evaluation.
-```
-"""
-tic
-
-doc"""
-    LoadError(file::AbstractString, line::Int, error)
-
-An error occurred while `include`ing, `require`ing, or `using` a file. The error specifics should be available in the `.error` field.
-"""
-LoadError
-
-doc"""
-    InitError(mod::Symbol, error)
-
-An error occurred when running a module's `__init__` function. The actual error thrown is available in the `.error` field.
-"""
-InitError
-
-doc"""
-    vec(Array) -> Vector
-
-Vectorize an array using column-major convention.
-"""
-vec
-
-doc"""
-    copy!(dest, src)
-
-Copy all elements from collection `src` to array `dest`. Returns `dest`.
-"""
-copy!(dest,src)
-
-doc"""
-    copy!(dest, do, src, so, N)
-
-Copy `N` elements from collection `src` starting at offset `so`, to array `dest` starting at offset `do`. Returns `dest`.
-"""
-copy!(dest,d,src,so,N)
-
-doc"""
-    broadcast(f, As...)
-
-Broadcasts the arrays `As` to a common size by expanding singleton dimensions, and returns an array of the results `f(as...)` for each position.
-"""
-broadcast
-
-doc"""
-```rst
-..  eigvecs(A, [eigvals,][permute=true,][scale=true]) -> Matrix
-
-Returns a matrix ``M`` whose columns are the eigenvectors of ``A``.
-(The ``k``\ th eigenvector can be obtained from the slice ``M[:, k]``.)
-The ``permute`` and ``scale`` keywords are the same as for :func:`eigfact`.
-
-For :class:`SymTridiagonal` matrices, if the optional vector of eigenvalues
-``eigvals`` is specified, returns the specific corresponding eigenvectors.
-```
-"""
-eigvecs
-
-doc"""
-    ntoh(x)
-
-Converts the endianness of a value from Network byte order (big-endian) to that used by the Host.
-"""
-ntoh
-
-doc"""
-```rst
-..  qrfact(A [,pivot=Val{false}]) -> F
-
-Computes the QR factorization of ``A``. The return type of ``F`` depends on the element type of ``A`` and whether pivoting is specified (with ``pivot==Val{true}``).
-
-   ================ ================= ============== =====================================
-   Return type      ``eltype(A)``     ``pivot``      Relationship between ``F`` and ``A``
-   ---------------- ----------------- -------------- -------------------------------------
-   ``QR``           not ``BlasFloat`` either          ``A==F[:Q]*F[:R]``
-   ``QRCompactWY``  ``BlasFloat``     ``Val{false}``  ``A==F[:Q]*F[:R]``
-   ``QRPivoted``    ``BlasFloat``     ``Val{true}``   ``A[:,F[:p]]==F[:Q]*F[:R]``
-   ================ ================= ============== =====================================
-
-``BlasFloat`` refers to any of: ``Float32``, ``Float64``, ``Complex64`` or ``Complex128``.
-
-The individual components of the factorization ``F`` can be accessed by indexing:
-
-   =========== ============================================= ================== ===================== ==================
-   Component   Description                                   ``QR``             ``QRCompactWY``       ``QRPivoted``
-   ----------- --------------------------------------------- ------------------ --------------------- ------------------
-   ``F[:Q]``   ``Q`` (orthogonal/unitary) part of ``QR``      ✓ (``QRPackedQ``)  ✓ (``QRCompactWYQ``)  ✓ (``QRPackedQ``)
-   ``F[:R]``   ``R`` (upper right triangular) part of ``QR``  ✓                  ✓                     ✓
-   ``F[:p]``   pivot ``Vector``                                                                        ✓
-   ``F[:P]``   (pivot) permutation ``Matrix``                                                          ✓
-   =========== ============================================= ================== ===================== ==================
-
-The following functions are available for the ``QR`` objects: ``size``, ``\``. When ``A`` is rectangular, ``\`` will return a least squares solution and if the solution is not unique, the one with smallest norm is returned.
-
-Multiplication with respect to either thin or full ``Q`` is allowed, i.e. both ``F[:Q]*F[:R]`` and ``F[:Q]*A`` are supported. A ``Q`` matrix can be converted into a regular matrix with :func:`full` which has a named argument ``thin``.
-
-.. note::
-
-   ``qrfact`` returns multiple types because LAPACK uses several representations that minimize the memory storage requirements of products of Householder elementary reflectors, so that the ``Q`` and ``R`` matrices can be stored compactly rather as two separate dense matrices.
-
-   The data contained in ``QR`` or ``QRPivoted`` can be used to construct the ``QRPackedQ`` type, which is a compact representation of the rotation matrix:
-
-      .. math::
-
-         Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T)
-
-   where :math:`\tau_i` is the scale factor and :math:`v_i` is the projection vector associated with the :math:`i^{th}` Householder elementary reflector.
-
-   The data contained in ``QRCompactWY`` can be used to construct the ``QRCompactWYQ`` type, which is a compact representation of the rotation matrix
-
-      .. math::
-
-         Q = I + Y T Y^T
-
-   where ``Y`` is :math:`m \times r` lower trapezoidal and ``T`` is :math:`r \times r` upper triangular. The *compact WY* representation [Schreiber1989]_ is not to be confused with the older, *WY* representation [Bischof1987]_. (The LAPACK documentation uses ``V`` in lieu of ``Y``.)
-
-.. [Bischof1987] C Bischof and C Van Loan, "The WY representation for products
-   of Householder matrices", SIAM J Sci Stat Comput 8 (1987), s2-s13.
-   `doi:10.1137/0908009 <http://dx.doi.org/10.1137/0908009>`_
-.. [Schreiber1989] R Schreiber and C Van Loan, "A storage-efficient WY
-   representation for products of Householder transformations",
-   SIAM J Sci Stat Comput 10 (1989), 53-57.
-   `doi:10.1137/0910005 <http://dx.doi.org/10.1137/0910005>`_
-```
-"""
-qrfact(A,?)
-
-
-doc"""
-```rst
-..  qrfact(A) -> SPQR.Factorization
-
-Compute the QR factorization of a sparse matrix ``A``. A fill-reducing permutation is used. The main application of this type is to solve least squares problems with ``\``. The function calls the C library SPQR and a few additional functions from the library are wrapped but not exported.
-```
-"""
-qrfact(A)
-
-doc"""
-    +(x, y...)
-
-Addition operator. `x+y+z+...` calls this function with all arguments, i.e. `+(x, y, z, ...)`.
-"""
-+
-
-doc"""
-    identity(x)
-
-The identity function. Returns its argument.
-"""
-identity
-
-doc"""
-    iseven(x::Integer) -> Bool
-
-Returns `true` is `x` is even (that is, divisible by 2), and `false` otherwise.
-
-```jldoctest
-julia> iseven(9)
-false
-
-julia> iseven(10)
-true
-```
-"""
-iseven
-
-doc"""
-    setindex!(A, X, inds...)
-
-Store values from array `X` within some subset of `A` as specified by `inds`.
-"""
-setindex!(A::AbstractArray,X,inds...)
-
-doc"""
-    setindex!(collection, value, key...)
-
-Store the given value at the given key or index within a collection. The syntax `a[i,j,...] = x` is converted by the compiler to `(setindex!(a, x, i, j, ...); x)`.
-"""
-setindex!(collection,value,key...)
-
-doc"""
-    signif(x, digits, [base])
-
-Rounds (in the sense of `round`) `x` so that there are `digits` significant digits, under a base `base` representation, default 10. E.g., `signif(123.456, 2)` is `120.0`, and `signif(357.913, 4, 2)` is `352.0`.
-"""
-signif
-
-doc"""
-    sprandbool(m,n,p)
-
-Create a random `m` by `n` sparse boolean matrix with the specified (independent) probability `p` of any entry being `true`.
-"""
-sprandbool
-
-doc"""
-    nextpow2(n)
-
-The smallest power of two not less than `n`. Returns 0 for `n==0`, and returns `-nextpow2(-n)` for negative arguments.
-"""
-nextpow2
-
-doc"""
-    ipermute!(v, p)
-
-Like permute!, but the inverse of the given permutation is applied.
-"""
-ipermute!
-
-doc"""
-```rst
-..  full(S)
-
-Convert a sparse matrix ``S`` into a dense matrix.
-```
-"""
-full(::AbstractSparseMatrix)
-
-doc"""
-```rst
-..  full(F)
-
-Reconstruct the matrix ``A`` from the factorization ``F=factorize(A)``.
-```
-"""
-full(F)
-
-doc"""
-```rst
-..  full(QRCompactWYQ[, thin=true]) -> Matrix
-
-Converts an orthogonal or unitary matrix stored as a ``QRCompactWYQ``
-object, i.e. in the compact WY format [Bischof1987]_, to a dense matrix.
-
-Optionally takes a ``thin`` Boolean argument, which if ``true`` omits the
-columns that span the rows of ``R`` in the QR factorization that are zero.
-The resulting matrix is the ``Q`` in a thin QR factorization (sometimes
-called the reduced QR factorization).  If ``false``, returns a ``Q`` that
-spans all rows of ``R`` in its corresponding QR factorization.
-```
-"""
-full(::LinAlg.QRCompactWYQ, ?)
-
-doc"""
-    map(f, c...) -> collection
-
-Transform collection `c` by applying `f` to each element.
-For multiple collection arguments, apply `f` elementwise.
-
-```jldoctest
-julia> map((x) -> x * 2, [1, 2, 3])
-3-element Array{Int64,1}:
- 2
- 4
- 6
-
-julia> map(+, [1, 2, 3], [10, 20, 30])
-3-element Array{Int64,1}:
- 11
- 22
- 33
-```
-"""
-map
-
-doc"""
-    @parallel
-
-A parallel for loop of the form :
-
-    @parallel [reducer] for var = range
-        body
-    end
-
-The specified range is partitioned and locally executed across all workers. In case an optional reducer function is specified, `@parallel` performs local reductions on each worker with a final reduction on the calling process.
-
-Note that without a reducer function, `@parallel` executes asynchronously, i.e. it spawns independent tasks on all available workers and returns immediately without waiting for completion. To wait for completion, prefix the call with `@sync`, like :
-
-    @sync @parallel for var = range
-        body
-    end
-"""
-:@parallel
-
-doc"""
-    throw(e)
-
-Throw an object as an exception
-"""
-throw
-
-doc"""
-    isxdigit(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is a valid hexadecimal digit, or whether this is true for all elements of a string.
-"""
-isxdigit
-
-doc"""
-    fill(x, dims)
-
-Create an array filled with the value `x`. For example, `fill(1.0, (10,10))` returns a 10x10 array of floats, with each element initialized to `1.0`.
-
-If `x` is an object reference, all elements will refer to the same object. `fill(Foo(), dims)` will return an array filled with the result of evaluating `Foo()` once.
-"""
-fill
-
-doc"""
-    rol!(dest::BitArray{1}, src::BitArray{1}, i::Integer) -> BitArray{1}
-
-Performs a left rotation operation on `src` and put the result into `dest`.
-"""
-rol!(::BitArray,::BitArray,::Integer)
-
-doc"""
-    rol!(B::BitArray{1}, i::Integer) -> BitArray{1}
-
-Performs a left rotation operation on `B`.
-"""
-rol!(::BitArray,::Integer)
-
-doc"""
-```rst
-..  issubset(a, b)
-           ⊆(a,b) -> Bool
-           ⊈(a,b) -> Bool
-           ⊊(a,b) -> Bool
-
-Determine whether every element of ``a`` is also in ``b``, using :func:`in`.
-```
-"""
-issubset(a,b)
-
-doc"""
-```rst
-..  issubset(A, S) -> Bool
-             ⊆(A,S) -> Bool
-
-Return ``true`` if ``A`` is a subset of or equal to ``S``.
-```
-"""
-issubset
-
-doc"""
-    istriu(A) -> Bool
-
-Test whether a matrix is upper triangular.
-"""
-istriu
-
-doc"""
-```rst
-..  map!(function, collection)
-
-In-place version of :func:`map`.
-```
-"""
-map!(f,collection)
-
-doc"""
-```rst
-..  map!(function, destination, collection...)
-
-Like :func:`map`, but stores the result in ``destination`` rather than a
-new collection. ``destination`` must be at least as large as the first
-collection.
-```
-"""
-map!(f,destination,collection...)
-
-doc"""
-```rst
-..  unescape_string(s::AbstractString) -> AbstractString
-
-General unescaping of traditional C and Unicode escape sequences. Reverse of :func:`escape_string`. See also :func:`print_unescaped`.
-```
-"""
-unescape_string
-
-doc"""
-    redirect_stdout()
-
-Create a pipe to which all C and Julia level STDOUT output will be redirected. Returns a tuple (rd,wr) representing the pipe ends. Data written to STDOUT may now be read from the rd end of the pipe. The wr end is given for convenience in case the old STDOUT object was cached by the user and needs to be replaced elsewhere.
-"""
-redirect_stdout
-
-doc"""
-    redirect_stdout(stream)
-
-Replace STDOUT by stream for all C and julia level output to STDOUT. Note that `stream` must be a TTY, a Pipe or a TcpSocket.
-"""
-redirect_stdout(stream)
-
-doc"""
-    print_with_color(color::Symbol, [io], strings...)
-
-Print strings in a color specified as a symbol, for example `:red` or `:blue`.
-"""
-print_with_color
-
-doc"""
-    stringmime(mime, x)
-
-Returns an `AbstractString` containing the representation of `x` in the requested `mime` type. This is similar to `reprmime` except that binary data is base64-encoded as an ASCII string.
-"""
-stringmime
-
-doc"""
-    ischardev(path) -> Bool
-
-Returns `true` if `path` is a character device, `false` otherwise.
-"""
-ischardev
-
-doc"""
-    zero(x)
-
-Get the additive identity element for the type of `x` (`x` can also specify the type itself).
-"""
-zero
-
-doc"""
-    any(itr) -> Bool
-
-Test whether any elements of a boolean collection are `true`.
-"""
-any(itr)
-
-doc"""
-    any(A, dims)
-
-Test whether any values along the given dimensions of an array are `true`.
-"""
-any(::AbstractArray,dims)
-
-doc"""
-    any(p, itr) -> Bool
-
-Determine whether predicate `p` returns `true` for any elements of `itr`.
-"""
-any(p,itr)
-
-doc"""
-```rst
-..  plan_ifft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as :func:`plan_fft`, but produces a plan that performs inverse transforms
-:func:`ifft`.
-```
-"""
-plan_ifft
-
-doc"""
-    cosc(x)
-
-Compute $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ if $x \neq 0$, and $0$
-if $x = 0$. This is the derivative of `sinc(x)`.
-"""
-cosc
-
-doc"""
-    getkey(collection, key, default)
-
-Return the key matching argument `key` if one exists in `collection`, otherwise return `default`.
-"""
-getkey
-
-doc"""
-    At_ldiv_Bt(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᵀ \ Bᵀ`
-"""
-At_ldiv_Bt
-
-doc"""
-    Ac_mul_Bc(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᴴ Bᴴ`
-"""
-Ac_mul_Bc
-
-doc"""
-    acotd(x)
-
-Compute the inverse cotangent of `x`, where the output is in degrees
-"""
-acotd
-
-doc"""
-    zeros(type, dims)
-
-Create an array of all zeros of specified type. The type defaults to Float64 if not specified.
-"""
-zeros(t,dims)
-
-doc"""
-    zeros(A)
-
-Create an array of all zeros with the same element type and shape as `A`.
-"""
-zeros(A)
-
-doc"""
-    symbol(x...) -> Symbol
-
-Create a `Symbol` by concatenating the string representations of the arguments together.
-"""
-symbol
-
-doc"""
-    zeta(s)
-
-Riemann zeta function $\zeta(s)$.
-"""
-zeta(s)
-
-doc"""
-    zeta(s, z)
-
-Hurwitz zeta function $\zeta(s, z)$.  (This is equivalent to
-the Riemann zeta function $\zeta(s)$ for the case of `z=1`.)
-"""
-zeta(s,z)
-
-doc"""
-```rst
-..  sprand([rng,] m,n,p [,rfn])
-
-Create a random ``m`` by ``n`` sparse matrix, in which the probability of any element being nonzero is independently given by ``p`` (and hence the mean density of nonzeros is also exactly ``p``). Nonzero values are sampled from the distribution specified by ``rfn``. The uniform distribution is used in case ``rfn`` is not specified. The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`.
-```
-"""
-sprand
-
-doc"""
-    A_mul_Bt(A, B)
-
-For matrices or vectors `A` and `B`, calculates `A Bᵀ`
-"""
-A_mul_Bt
-
-doc"""
-    vecnorm(A, [p])
-
-For any iterable container `A` (including arrays of any dimension) of numbers (or any element type for which `norm` is defined), compute the `p`-norm (defaulting to `p=2`) as if `A` were a vector of the corresponding length.
-
-For example, if `A` is a matrix and `p=2`, then this is equivalent to the Frobenius norm.
-"""
-vecnorm
-
-doc"""
-    isvalid(value) -> Bool
-
-Returns `true` if the given value is valid for its type, which currently can be one of `Char`, `ASCIIString`, `UTF8String`, `UTF16String`, or `UTF32String`.
-"""
-isvalid(value)
-
-doc"""
-    isvalid(T, value) -> Bool
-
-Returns `true` if the given value is valid for that type. Types currently can be `Char`, `ASCIIString`, `UTF8String`, `UTF16String`, or `UTF32String` Values for `Char` can be of type `Char` or `UInt32` Values for `ASCIIString` and `UTF8String` can be of that type, or `Vector{UInt8}` Values for `UTF16String` can be `UTF16String` or `Vector{UInt16}` Values for `UTF32String` can be `UTF32String`, `Vector{Char}` or `Vector{UInt32}`
-"""
-isvalid(T,value)
-
-doc"""
-    isvalid(str, i)
-
-Tells whether index `i` is valid for the given string
-"""
-isvalid(::AbstractString,i)
-
-doc"""
-```rst
-..  esc(e::ANY)
-
-Only valid in the context of an ``Expr`` returned from a macro. Prevents the macro hygiene pass from turning embedded variables into gensym variables. See the :ref:`man-macros`
-section of the Metaprogramming chapter of the manual for more details and examples.
-```
-"""
-esc
-
-doc"""
-    bitbroadcast(f, As...)
-
-Like `broadcast`, but allocates a `BitArray` to store the result, rather then an `Array`.
-"""
-bitbroadcast
-
-doc"""
-    set_zero_subnormals(yes::Bool) -> Bool
-
-If `yes` is `false`, subsequent floating-point operations follow rules for IEEE arithmetic on subnormal values ("denormals"). Otherwise, floating-point operations are permitted (but not required) to convert subnormal inputs or outputs to zero. Returns `true` unless `yes==true` but the hardware does not support zeroing of subnormal numbers.
-
-`set_zero_subnormals(true)` can speed up some computations on some hardware. However, it can break identities such as `(x-y==0) == (x==y)`.
-"""
-set_zero_subnormals
-
-doc"""
-    take(iter, n)
-
-An iterator that generates at most the first `n` elements of `iter`.
-"""
-take
-
-doc"""
-    combinations(array, n)
-
-Generate all combinations of `n` elements from an indexable object. Because the number of combinations can be very large, this function returns an iterator object. Use `collect(combinations(array,n))` to get an array of all combinations.
-"""
-combinations
-
-doc"""
-    frexp(val)
-
-Return `(x,exp)` such that `x` has a magnitude in the interval $[1/2, 1)$ or 0,
-and val = $x \times 2^{exp}$.
-"""
-frexp
-
-doc"""
-    sortcols(A, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
-
-Sort the columns of matrix `A` lexicographically.
-"""
-sortcols
-
-doc"""
-    rsplit(string, [chars]; limit=0, keep=true)
-
-Similar to `split`, but starting from the end of the string.
-"""
-rsplit
-
-doc"""
-    trace(M)
-
-Matrix trace
-"""
-trace
-
-doc"""
-    runtests([tests=["all"] [, numcores=iceil(CPU_CORES/2) ]])
-
-Run the Julia unit tests listed in `tests`, which can be either a string or an array of strings, using `numcores` processors. (not exported)
-"""
-runtests
-
-doc"""
-    time_ns()
-
-Get the time in nanoseconds. The time corresponding to 0 is undefined, and wraps every 5.8 years.
-"""
-time_ns
-
-doc"""
-    exponent(x) -> Int
-
-Get the exponent of a normalized floating-point number.
-"""
-exponent
-
-doc"""
-    rsearchindex(string, substring, [start])
-
-Similar to `rsearch`, but return only the start index at which the substring is found, or `0` if it is not.
-"""
-rsearchindex
-
-doc"""
-    muladd(x, y, z)
-
-Combined multiply-add, computes `x*y+z` in an efficient manner. This may on some systems be equivalent to `x*y+z`, or to `fma(x,y,z)`. `muladd` is used to improve performance. See `fma`.
-"""
-muladd
-
-doc"""
-    unsigned(x) -> Unsigned
-
-Convert a number to an unsigned integer. If the argument is signed, it is reinterpreted as unsigned without checking for negative values.
-"""
-unsigned
-
-doc"""
-```rst
-..  eigfact(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> Eigen
-
-Computes the eigenvalue decomposition of ``A``, returning an ``Eigen``
-factorization object ``F`` which contains the eigenvalues in ``F[:values]``
-and the eigenvectors in the columns of the matrix ``F[:vectors]``.
-(The ``k``\ th eigenvector can be obtained from the slice ``F[:vectors][:, k]``.)
-
-The following functions are available for ``Eigen`` objects: ``inv``,
-``det``.
-
-If ``A`` is :class:`Symmetric`, :class:`Hermitian` or :class:`SymTridiagonal`,
-it is possible to calculate only a subset of the eigenvalues by specifying
-either a :class:`UnitRange` ``irange`` covering indices of the sorted
-eigenvalues or a pair ``vl`` and ``vu`` for the lower and upper boundaries
-of the eigenvalues.
-
-For general nonsymmetric matrices it is possible to specify how the matrix
-is balanced before the eigenvector calculation. The option ``permute=true``
-permutes the matrix to become closer to upper triangular, and ``scale=true``
-scales the matrix by its diagonal elements to make rows and columns more
-equal in norm. The default is ``true`` for both options.
-```
-"""
-eigfact(A,?,?,?,?)
-
-doc"""
-```rst
-..  eigfact(A, B) -> GeneralizedEigen
-
-Computes the generalized eigenvalue decomposition of ``A`` and ``B``,
-returning a ``GeneralizedEigen`` factorization object ``F`` which contains
-the generalized eigenvalues in ``F[:values]`` and the generalized
-eigenvectors in the columns of the matrix ``F[:vectors]``. (The ``k``\ th
-generalized eigenvector can be obtained from the slice ``F[:vectors][:,
-k]``.)
-```
-"""
-eigfact(A,B)
-
-doc"""
-```rst
-..  plan_brfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Pre-plan an optimized real-input unnormalized transform, similar to
-:func:`plan_rfft` except for :func:`brfft` instead of :func:`rfft`.
-The first two arguments and the size of the transformed result, are
-the same as for :func:`brfft`.
-```
-"""
-plan_brfft
-
-doc"""
-    rowvals(A)
-
-Return a vector of the row indices of `A`, and any modifications to the returned vector will mutate `A` as well. Given the internal storage format of sparse matrices, providing access to how the row indices are stored internally can be useful in conjuction with iterating over structural nonzero values. See `nonzeros(A)` and `nzrange(A, col)`.
-"""
-rowvals
-
-doc"""
-    mkdir(path, [mode])
-
-Make a new directory with name `path` and permissions `mode`. `mode` defaults to 0o777, modified by the current file creation mask.
-"""
-mkdir
-
-doc"""
-    bytestring(::Ptr{UInt8}, [length])
-
-Create a string from the address of a C (0-terminated) string encoded in ASCII or UTF-8. A copy is made; the ptr can be safely freed. If `length` is specified, the string does not have to be 0-terminated.
-"""
-bytestring(::Ptr{UInt8},?)
-
-doc"""
-    bytestring(s)
-
-Convert a string to a contiguous byte array representation appropriate for passing it to C functions. The string will be encoded as either ASCII or UTF-8.
-"""
-bytestring(s)
-
-doc"""
-    midpoints(e)
-
-Compute the midpoints of the bins with edges `e`. The result is a vector/range of length `length(e) - 1`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-midpoints
-
-doc"""
-    .+(x, y)
-
-Element-wise addition operator.
-"""
-Base.(:(.+))
-
-doc"""
-    reverseind(v, i)
-
-Given an index `i` in `reverse(v)`, return the corresponding index in `v` so that `v[reverseind(v,i)] == reverse(v)[i]`. (This can be nontrivial in the case where `v` is a Unicode string.)
-"""
-reverseind
-
-doc"""
-    nan(f)
-
-Returns NaN (not-a-number) of the floating point type `f` or of the same floating point type as `f`
-"""
-nan
-
-doc"""
-    float(x)
-
-Convert a number, array, or string to a `AbstractFloat` data type. For numeric data, the smallest suitable `AbstractFloat` type is used. Converts strings to `Float64`.
-"""
-float
-
-doc"""
-    include_dependency(path::AbstractString)
-
-In a module, declare that the file specified by `path` (relative or absolute) is a dependency for precompilation; that is, the module will need to be recompiled if this file changes.
-
-This is only needed if your module depends on a file that is not used via `include`. It has no effect outside of compilation.
-"""
-include_dependency
-
-doc"""
-    __precompile__(isprecompilable::Bool=true)
-
-Specify whether the file calling this function is precompilable. If `isprecompilable` is `true`, then `__precompile__` throws an exception when the file is loaded by `using`/`import`/`require` *unless* the file is being precompiled, and in a module file it causes the module to be automatically precompiled when it is imported. Typically, `__precompile__()` should occur before the `module` declaration in the file, or better yet `VERSION >= v"0.4" && __precompile__()` in order to be backward-compatible with Julia 0.3.
-
-If a module or file is *not* safely precompilable, it should call `__precompile__(false)` in order to throw an error if Julia attempts to precompile it.
-"""
-__precompile__
-
-doc"""
-    randn!([rng], A::Array{Float64,N})
-
-Fill the array `A` with normally-distributed (mean 0, standard deviation 1) random numbers. Also see the rand function.
-"""
-randn!
-
-doc"""
-    ldexp(x, n)
-
-Compute $x \times 2^n$.
-"""
-ldexp
-
-doc"""
-    quadgk(f, a,b,c...; reltol=sqrt(eps), abstol=0, maxevals=10^7, order=7, norm=vecnorm)
-
-Numerically integrate the function `f(x)` from `a` to `b`, and optionally over additional intervals `b` to `c` and so on. Keyword options include a relative error tolerance `reltol` (defaults to `sqrt(eps)` in the precision of the endpoints), an absolute error tolerance `abstol` (defaults to 0), a maximum number of function evaluations `maxevals` (defaults to `10^7`), and the `order` of the integration rule (defaults to 7).
-
-Returns a pair `(I,E)` of the estimated integral `I` and an estimated upper bound on the absolute error `E`. If `maxevals` is not exceeded then `E <= max(abstol, reltol*norm(I))` will hold. (Note that it is useful to specify a positive `abstol` in cases where `norm(I)` may be zero.)
-
-The endpoints `a` etcetera can also be complex (in which case the integral is performed over straight-line segments in the complex plane). If the endpoints are `BigFloat`, then the integration will be performed in `BigFloat` precision as well (note: it is advisable to increase the integration `order` in rough proportion to the precision, for smooth integrands). More generally, the precision is set by the precision of the integration endpoints (promoted to floating-point types).
-
-The integrand `f(x)` can return any numeric scalar, vector, or matrix type, or in fact any type supporting `+`, `-`, multiplication by real values, and a `norm` (i.e., any normed vector space). Alternatively, a different norm can be specified by passing a `norm`-like function as the `norm` keyword argument (which defaults to `vecnorm`).
-
-\[Only one-dimensional integrals are provided by this function. For multi-dimensional integration (cubature), there are many different algorithms (often much better than simple nested 1d integrals) and the optimal choice tends to be very problem-dependent. See the Julia external-package listing for available algorithms for multidimensional integration or other specialized tasks (such as integrals of highly oscillatory or singular functions).\]
-
-The algorithm is an adaptive Gauss-Kronrod integration technique: the integral in each interval is estimated using a Kronrod rule (`2*order+1` points) and the error is estimated using an embedded Gauss rule (`order` points). The interval with the largest error is then subdivided into two intervals and the process is repeated until the desired error tolerance is achieved.
-
-These quadrature rules work best for smooth functions within each interval, so if your function has a known discontinuity or other singularity, it is best to subdivide your interval to put the singularity at an endpoint. For example, if `f` has a discontinuity at `x=0.7` and you want to integrate from 0 to 1, you should use `quadgk(f, 0,0.7,1)` to subdivide the interval at the point of discontinuity. The integrand is never evaluated exactly at the endpoints of the intervals, so it is possible to integrate functions that diverge at the endpoints as long as the singularity is integrable (for example, a `log(x)` or `1/sqrt(x)` singularity).
-
-For real-valued endpoints, the starting and/or ending points may be infinite. (A coordinate transformation is performed internally to map the infinite interval to a finite one.)
-"""
-quadgk
-
-doc"""
-    hist(v[, n]) -> e, counts
-
-Compute the histogram of `v`, optionally using approximately `n` bins. The return values are a range `e`, which correspond to the edges of the bins, and `counts` containing the number of elements of `v` in each bin. Note: Julia does not ignore `NaN` values in the computation.
-"""
-hist(v,n::Int=?)
-
-doc"""
-    hist(v, e) -> e, counts
-
-Compute the histogram of `v` using a vector/range `e` as the edges for the bins. The result will be a vector of length `length(e) - 1`, such that the element at location `i` satisfies `sum(e[i] .< v .<= e[i+1])`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-hist(v,e)
-
-doc"""
-    islower(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is a lowercase letter, or whether this is true for all elements of a string. A character is classified as lowercase if it belongs to Unicode category Ll, Letter: Lowercase.
-"""
-islower
-
-doc"""
-```rst
-..  nthperm!(v, k)
-
-In-place version of :func:`nthperm`.
-```
-"""
-nthperm!
-
-doc"""
-    cell(dims)
-
-Construct an uninitialized cell array (heterogeneous array). `dims` can be either a tuple or a series of integer arguments.
-"""
-cell
-
-doc"""
-    readbytes(stream, nb=typemax(Int); all=true)
-
-Read at most `nb` bytes from the stream, returning a `Vector{UInt8}` of the bytes read.
-
-If `all` is `true` (the default), this function will block repeatedly trying to read all requested bytes, until an error or end-of-file occurs. If `all` is `false`, at most one `read` call is performed, and the amount of data returned is device-dependent. Note that not all stream types support the `all` option.
-"""
-readbytes
-
-doc"""
-```rst
-..  eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> D, V
-
-Computes eigenvalues and eigenvectors of ``A``. See :func:`eigfact` for
-details on the ``balance`` keyword argument.
-
-.. doctest::
-
-   julia> eig([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
-   ([1.0,3.0,18.0],
-   3x3 Array{Float64,2}:
-    1.0  0.0  0.0
-    0.0  1.0  0.0
-    0.0  0.0  1.0)
-
-``eig`` is a wrapper around :func:`eigfact`, extracting all parts of the
-factorization to a tuple; where possible, using :func:`eigfact` is
-recommended.
-```
-"""
-eig(A,?,?,?)
-
-doc"""
-```rst
-..  eig(A, B) -> D, V
-
-Computes generalized eigenvalues and vectors of ``A`` with respect to ``B``.
-
-``eig`` is a wrapper around :func:`eigfact`, extracting all parts of the
-factorization to a tuple; where possible, using :func:`eigfact` is
-recommended.
-```
-"""
-eig(A,B)
-
-doc"""
-    exp2(x)
-
-Compute $2^x$.
-"""
-exp2
-
-doc"""
-    gcd(x,y)
-
-Greatest common (positive) divisor (or zero if `x` and `y` are both zero).
-"""
-gcd
-
-doc"""
-    signbit(x)
-
-Returns `true` if the value of the sign of `x` is negative, otherwise `false`.
-"""
-signbit
-
-doc"""
-    istaskstarted(task) -> Bool
-
-Tell whether a task has started executing.
-"""
-istaskstarted
-
-doc"""
-    clamp(x, lo, hi)
-
-Return `x` if `lo <= x <= hi`. If `x < lo`, return `lo`. If `x > hi`, return `hi`. Arguments are promoted to a common type. Operates elementwise over `x` if it is an array.
-"""
-clamp
-
-doc"""
-```rst
-..  plan_dct(A [, dims [, flags [, timelimit]]])
-
-Pre-plan an optimized discrete cosine transform (DCT), similar to
-:func:`plan_fft` except producing a function that computes :func:`dct`.
-The first two arguments have the same meaning as for :func:`dct`.
-```
-"""
-plan_dct
-
-doc"""
-    cscd(x)
-
-Compute the cosecant of `x`, where `x` is in degrees
-"""
-cscd
-
-doc"""
-    tryparse(type, str, [base])
-
-Like `parse`, but returns a `Nullable` of the requested type. The result will be null if the string does not contain a valid number.
-"""
-tryparse
-
-doc"""
-    lexless(x, y)
-
-Determine whether `x` is lexicographically less than `y`.
-"""
-lexless
-
-doc"""
-    all!(r, A)
-
-Test whether all values in `A` along the singleton dimensions of `r` are `true`, and write results to `r`.
-"""
-all!
-
-doc"""
-    is_assigned_char(c) -> Bool
-
-Returns `true` if the given char or integer is an assigned Unicode code point.
-"""
-is_assigned_char
-
-doc"""
-    exit([code])
-
-Quit (or control-D at the prompt). The default exit code is zero, indicating that the processes completed successfully.
-"""
-exit
-
-doc"""
-    nonzeros(A)
-
-Return a vector of the structural nonzero values in sparse matrix `A`. This includes zeros that are explicitly stored in the sparse matrix. The returned vector points directly to the internal nonzero storage of `A`, and any modifications to the returned vector will mutate `A` as well. See `rowvals(A)` and `nzrange(A, col)`.
-"""
-nonzeros
-
-doc"""
-    istext(m::MIME)
-
-Determine whether a MIME type is text data.
-"""
-istext
-
-doc"""
-    merge!(collection, others...)
-
-Update collection with pairs from the other collections
-"""
-merge!
-
-doc"""
-    realpath(path::AbstractString) -> AbstractString
-
-Canonicalize a path by expanding symbolic links and removing "." and ".." entries.
-"""
-realpath
-
-doc"""
-    skipchars(stream, predicate; linecomment::Char)
-
-Advance the stream until before the first character for which `predicate` returns `false`. For example `skipchars(stream, isspace)` will skip all whitespace. If keyword argument `linecomment` is specified, characters from that character through the end of a line will also be skipped.
-"""
-skipchars
-
-doc"""
-    realmin(T)
-
-The smallest in absolute value non-subnormal value representable by the given floating-point DataType `T`.
-"""
-realmin
-
-doc"""
-    union!(s, iterable)
-
-Union each element of `iterable` into set `s` in-place.
-"""
-union!
-
-doc"""
-    At_ldiv_B(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᵀ \ B`
-"""
-At_ldiv_B
-
-doc"""
-    dot(x, y)
-    ⋅(x,y)
-
-Compute the dot product. For complex vectors, the first vector is conjugated.
-"""
-dot
-
-doc"""
-    cond(M, [p])
-
-Condition number of the matrix `M`, computed using the operator `p`-norm. Valid values for `p` are `1`, `2` (default), or `Inf`.
-"""
-cond
-
-doc"""
-    deepcopy(x)
-
-Create a deep copy of `x`: everything is copied recursively, resulting in a fully independent object. For example, deep-copying an array produces a new array whose elements are deep copies of the original elements. Calling `deepcopy` on an object should generally have the same effect as serializing and then deserializing it.
-
-As a special case, functions can only be actually deep-copied if they are anonymous, otherwise they are just copied. The difference is only relevant in the case of closures, i.e. functions which may contain hidden internal references.
-
-While it isn't normally necessary, user-defined types can override the default `deepcopy` behavior by defining a specialized version of the function `deepcopy_internal(x::T, dict::ObjectIdDict)` (which shouldn't otherwise be used), where `T` is the type to be specialized for, and `dict` keeps track of objects copied so far within the recursion. Within the definition, `deepcopy_internal` should be used in place of `deepcopy`, and the `dict` variable should be updated as appropriate before returning.
-"""
-deepcopy
-
-doc"""
-    widen(type | x)
-
-If the argument is a type, return a "larger" type (for numeric types, this will be
-a type with at least as much range and precision as the argument, and usually more).
-Otherwise the argument `x` is converted to `widen(typeof(x))`.
-
-```jldoctest
-julia> widen(Int32)
-Int64
-
-julia> widen(1.5f0)
-1.5
-```
-"""
-widen
-
-doc"""
-    @eval
-
-Evaluate an expression and return the value.
-"""
-:@eval
-
-doc"""
-    eval([m::Module], expr::Expr)
-
-Evaluate an expression in the given module and return the result. Every `Module` (except those defined with `baremodule`) has its own 1-argument definition of `eval`, which evaluates expressions in that module.
-"""
-eval
-
-doc"""
-```rst
-..  Set([itr])
-
-Construct a :obj:`Set` of the values generated by the given iterable object, or an empty set.
-Should be used instead of :obj:`IntSet` for sparse integer sets, or for sets of arbitrary objects.
-```
-"""
-Set
-
-doc"""
-    erf(x)
-
-Compute the error function of `x`, defined by
-$\frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} dt$
-for arbitrary complex `x`.
-"""
-erf
-
-doc"""
-    lcm(x,y)
-
-Least common (non-negative) multiple.
-"""
-lcm
-
-doc"""
-    isprint(c::Union{Char,AbstractString}) -> Bool
-
-Tests whether a character is printable, including spaces, but not a control character. For strings, tests whether this is true for all elements of the string.
-"""
-isprint
-
-doc"""
-    splitdir(path::AbstractString) -> (AbstractString,AbstractString)
-
-Split a path into a tuple of the directory name and file name.
-"""
-splitdir
-
-doc"""
-    sign(x)
-
-Return zero if `x==0` and $x/|x|$ otherwise (i.e., ±1 for real `x`).
-"""
-sign
-
-doc"""
-    signed(x)
-
-Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as signed without checking for overflow.
-"""
-signed
-
-doc"""
-    Val{c}
-
-Create a "value type" out of `c`, which must be an `isbits` value. The intent of this construct is to be able to dispatch on constants, e.g., `f(Val{false})` allows you to dispatch directly (at compile-time) to an implementation `f(::Type{Val{false}})`, without having to test the boolean value at runtime.
-"""
-Val
-
-doc"""
-    iswritable(path) -> Bool
-
-Returns `true` if the current user has permission to write to `path`, `false` otherwise.
-"""
-iswritable
-
-doc"""
-    |(x, y)
-
-Bitwise or
-"""
-Base.(:(|))
-
-doc"""
-    yieldto(task, arg = nothing)
-
-Switch to the given task. The first time a task is switched to, the task's function is called with no arguments. On subsequent switches, `arg` is returned from the task's last call to `yieldto`. This is a low-level call that only switches tasks, not considering states or scheduling in any way. Its use is discouraged.
-"""
-yieldto
-
-doc"""
-    readandwrite(command)
-
-Starts running a command asynchronously, and returns a tuple (stdout,stdin,process) of the output stream and input stream of the process, and the process object itself.
-"""
-readandwrite
-
-doc"""
-    splitdrive(path::AbstractString) -> (AbstractString,AbstractString)
-
-On Windows, split a path into the drive letter part and the path part. On Unix systems, the first component is always the empty string.
-"""
-splitdrive
-
-doc"""
-    pop!(collection, key[, default])
-
-Delete and return the mapping for `key` if it exists in `collection`,
-otherwise return `default`, or throw an error if default is not specified.
-"""
-pop!(collection,key,?)
-
-doc"""
-    pop!(collection) -> item
-
-Remove the last item in `collection` and return it.
-
-```jldoctest
-julia> A=[1, 2, 3, 4, 5, 6]
-6-element Array{Int64,1}:
- 1
- 2
- 3
- 4
- 5
- 6
-
-julia> pop!(A)
-6
-
-julia> A
-5-element Array{Int64,1}:
- 1
- 2
- 3
- 4
- 5
-```
-"""
-pop!(collection)
-
-doc"""
-    filter(function, collection)
-
-Return a copy of `collection`, removing elements for which `function` is `false`. For associative collections, the function is passed two arguments (key and value).
-"""
-filter
-
-doc"""
-```rst
-..  plan_idct!(A [, dims [, flags [, timelimit]]])
-
-Same as :func:`plan_idct`, but operates in-place on ``A``.
-```
-"""
-plan_idct!
-
-doc"""
-```rst
-..  randperm([rng,] n)
-
-Construct a random permutation of length ``n``. The optional ``rng`` argument
-specifies a random number generator, see :ref:`Random Numbers <random-numbers>`.
-```
-"""
-randperm
-
-doc"""
-    seekend(s)
-
-Seek a stream to its end.
-"""
-seekend
-
-doc"""
-```rst
-..  plan_ifft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
-
-Same as :func:`plan_ifft`, but operates in-place on ``A``.
-```
-"""
-plan_ifft!
-
-doc"""
-    DivideError()
-
-Integer division was attempted with a denominator value of 0.
-"""
-DivideError
-
-doc"""
-    AssertionError([msg])
-
-The asserted condition did not evalutate to `true`.
-Optional argument `msg` is a descriptive error string.
-"""
-AssertionError
-
-doc"""
-    ror(B::BitArray{1}, i::Integer) -> BitArray{1}
-
-Performs a right rotation operation.
-"""
-ror
-
-doc"""
-    Ac_ldiv_Bc(A, B)
-
-For matrices or vectors `A` and `B`, calculates `Aᴴ \ Bᴴ`
-"""
-Ac_ldiv_Bc
-
-doc"""
-```rst
-..  rfft(A [, dims])
-
-Multidimensional FFT of a real array ``A``, exploiting the fact that
-the transform has conjugate symmetry in order to save roughly half
-the computational time and storage costs compared with :func:`fft`.
-If ``A`` has size ``(n_1, ..., n_d)``, the result has size
-``(div(n_1,2)+1, ..., n_d)``.
-
-The optional ``dims`` argument specifies an iterable subset of one or
-more dimensions of ``A`` to transform, similar to :func:`fft`.  Instead
-of (roughly) halving the first dimension of ``A`` in the result, the
-``dims[1]`` dimension is (roughly) halved in the same way.
-```
-"""
-rfft
-
-doc"""
-```rst
-..  @enum EnumName EnumValue1[=x] EnumValue2[=y]
-
-Create an :obj:`Enum` type with name ``EnumName`` and enum member values of ``EnumValue1`` and ``EnumValue2`` with optional assigned values of ``x`` and ``y``, respectively. ``EnumName`` can be used just like other types and enum member values as regular values, such as
-
-.. doctest::
-
-   julia> @enum FRUIT apple=1 orange=2 kiwi=3
-
-   julia> f(x::FRUIT) = "I'm a FRUIT with value: $(Int(x))"
-   f (generic function with 1 method)
-
-   julia> f(apple)
-   "I'm a FRUIT with value: 1"
-```
-"""
-:@enum
-
-doc"""
-    asind(x)
-
-Compute the inverse sine of `x`, where the output is in degrees
-"""
-asind
-
-doc"""
-    widemul(x, y)
-
-Multiply `x` and `y`, giving the result as a larger type.
-"""
-widemul
-
-doc"""
-    unsafe_pointer_to_objref(p::Ptr)
-
-Convert a `Ptr` to an object reference. Assumes the pointer refers to a valid heap-allocated Julia object. If this is not the case, undefined behavior results, hence this function is considered "unsafe" and should be used with care.
-"""
-unsafe_pointer_to_objref
-
-doc"""
-    chomp(string)
-
-Remove a trailing newline from a string.
-"""
-chomp
-
-doc"""
-    enumerate(iter)
-
-An iterator that yields `(i, x)` where `i` is an index starting at 1, and
-`x` is the `i`th value from the given iterator. It's useful when you need
-not only the values `x` over which you are iterating, but also the index `i`
-of the iterations.
-
-```jldoctest
-julia> a = ["a", "b", "c"];
-
-julia> for (index, value) in enumerate(a)
-           println("$index $value")
-       end
-1 a
-2 b
-3 c
-```
-"""
-enumerate
-
-doc"""
-    >=(x, y)
-    ≥(x,y)
-
-Greater-than-or-equals comparison operator.
-"""
-Base.(:(>=))
-
-doc"""
-    dawson(x)
-
-Compute the Dawson function (scaled imaginary error function) of `x`,
-defined by $\frac{\sqrt{\pi}}{2} e^{-x^2} \operatorname{erfi}(x)$.
-"""
-dawson
-
-doc"""
-    current_task()
-
-Get the currently running `Task`.
-"""
-current_task
-
-# Dates
-
-doc"""
-    firstdayofweek(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the Monday of its week.
-"""
-Dates.firstdayofweek
-
-doc"""
-    datetime2unix(dt::DateTime) -> Float64
-
-Takes the given `DateTime` and returns the number of seconds since the unix epoch as a `Float64`.
-"""
-Dates.datetime2unix
-
-doc"""
-    dayofweekofmonth(dt::TimeType) -> Int
-
-For the day of week of `dt`, returns which number it is in `dt`'s month. So if the day of the week of `dt` is Monday, then `1 = First Monday of the month, 2 = Second Monday of the month, etc.` In the range 1:5.
-"""
-Dates.dayofweekofmonth
-
-doc"""
-    monthabbr(dt::TimeType; locale="english") -> AbstractString
-
-Return the abbreviated month name of the `Date` or `DateTime` in the given `locale`.
-"""
-Dates.monthabbr
-
-doc"""
-    datetime2julian(dt::DateTime) -> Float64
-
-Takes the given `DateTime` and returns the number of Julian calendar days since the julian epoch as a `Float64`.
-"""
-Dates.datetime2julian
-
-doc"""
-    dayabbr(dt::TimeType; locale="english") -> AbstractString
-
-Return the abbreviated name corresponding to the day of the week of the `Date` or `DateTime` in the given `locale`.
-"""
-Dates.dayabbr
-
-doc"""
-```rst
-..  DateTime(y, [m, d, h, mi, s, ms]) -> DateTime
-
-Construct a ``DateTime`` type by parts. Arguments must be convertible to ``Int64``.
-```
-"""
-Dates.DateTime(y)
-
-doc"""
-```rst
-..  DateTime(periods::Period...) -> DateTime
-
-Constuct a ``DateTime`` type by ``Period`` type parts. Arguments may be in any order.
-DateTime parts not provided will default to the value of ``Dates.default(period)``.
-```
-"""
-Dates.DateTime(periods::Dates.Period...)
-
-doc"""
-```rst
-..  DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), negate=false, limit=10000) -> DateTime
-
-Create a ``DateTime`` through the adjuster API. The starting point will be constructed from the
-provided ``y, m, d...`` arguments, and will be adjusted until ``f::Function`` returns ``true``. The step size in
-adjusting can be provided manually through the ``step`` keyword. If ``negate=true``, then the adjusting
-will stop when ``f::Function`` returns ``false`` instead of ``true``. ``limit`` provides a limit to
-the max number of iterations the adjustment API will pursue before throwing an error (in the case that ``f::Function`` is never satisfied).
-```
-"""
-Dates.DateTime(f::Function, y)
-
-doc"""
-```rst
-..  DateTime(dt::Date) -> DateTime
-
-Converts a ``Date`` type to a ``DateTime``.
-The hour, minute, second, and millisecond parts of the new ``DateTime`` are assumed to be zero.
-```
-"""
-Dates.DateTime(dt::Date)
-
-doc"""
-```rst
-..  DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime
-
-Construct a ``DateTime`` type by parsing the ``dt`` date string following the pattern given in
-the ``format`` string. The following codes can be used for constructing format strings:
-
-=============== ========= ===============================================================
-Code            Matches    Comment
---------------- --------- ---------------------------------------------------------------
-``y``           1996, 96  Returns year of 1996, 0096
-``m``           1, 01     Matches 1 or 2-digit months
-``u``           Jan       Matches abbreviated months according to the ``locale`` keyword
-``U``           January   Matches full month names according to the ``locale`` keyword
-``d``           1, 01     Matches 1 or 2-digit days
-``H``           00        Matches hours
-``M``           00        Matches minutes
-``S``           00        Matches seconds
-``s``           .500      Matches milliseconds
-``e``           Mon, Tues Matches abbreviated days of the week
-``E``           Monday    Matches full name days of the week
-``yyyymmdd``    19960101  Matches fixed-width year, month, and day
-=============== ========= ===============================================================
-
-All characters not listed above are treated as delimiters between date and time slots.
-So a ``dt`` string of "1996-01-15T00:00:00.0" would have a ``format`` string like "y-m-dTH:M:S.s".
-```
-"""
-Dates.DateTime(dt::AbstractString, format::AbstractString)
-
-doc"""
-```rst
-..  DateTime(dt::AbstractString, df::DateFormat) -> DateTime
-
-Similar form as above for parsing a ``DateTime``, but passes a ``DateFormat`` object instead of a raw formatting string. It is more efficient if similarly formatted date strings will be parsed repeatedly to first create a ``DateFormat`` object then use this method for parsing.
-```
-"""
-Dates.DateTime(dt::AbstractString, df::Dates.DateFormat)
-
-doc"""
-    datetime2rata(dt::TimeType) -> Int64
-
-Returns the number of Rata Die days since epoch from the given `Date` or `DateTime`.
-"""
-Dates.datetime2rata
-
-doc"""
-    monthname(dt::TimeType; locale="english") -> AbstractString
-
-Return the full name of the month of the `Date` or `DateTime` in the given `locale`.
-"""
-Dates.monthname
-
-doc"""
-    dayname(dt::TimeType; locale="english") -> AbstractString
-
-Return the full day name corresponding to the day of the week of the `Date` or `DateTime` in the given `locale`.
-"""
-Dates.dayname
-
-doc"""
-    Date(y, [m, d]) -> Date
-
-Construct a `Date` type by parts. Arguments must be convertible to `Int64`.
-"""
-Dates.Date(y)
-
-doc"""
-    Date(period::Period...) -> Date
-
-Constuct a `Date` type by `Period` type parts. Arguments may be in any order. `Date` parts not provided will default to the value of `Dates.default(period)`.
-"""
-Dates.Date(period::Dates.Period...)
-
-doc"""
-    Date(f::Function, y[, m]; step=Day(1), negate=false, limit=10000) -> Date
-
-Create a `Date` through the adjuster API. The starting point will be constructed from the provided `y, m` arguments, and will be adjusted until `f::Function` returns `true`. The step size in adjusting can be provided manually through the `step` keyword. If `negate=true`, then the adjusting will stop when `f::Function` returns `false` instead of `true`. `limit` provides a limit to the max number of iterations the adjustment API will pursue before throwing an error (given that `f::Function` is never satisfied).
-"""
-Dates.Date(f::Function, y)
-
-doc"""
-    Date(dt::DateTime) -> Date
-
-Converts a `DateTime` type to a `Date`. The hour, minute, second, and millisecond parts of the `DateTime` are truncated, so only the year, month and day parts are used in construction.
-"""
-Dates.Date(dt::DateTime)
-
-doc"""
-    Date(dt::AbstractString, format::AbstractString; locale="english") -> Date
-
-Construct a `Date` type by parsing a `dt` date string following the pattern given in the `format` string. Follows the same conventions as `DateTime` above.
-"""
-Dates.Date(dt::AbstractString, format::AbstractString)
-
-doc"""
-    Date(dt::AbstractString, df::DateFormat) -> Date
-
-Parse a date from a date string `dt` using a `DateFormat` object `df`.
-"""
-Dates.Date(dt::AbstractString, df::Dates.DateFormat)
-
-doc"""
-    firstdayofmonth(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the first day of its month.
-"""
-Dates.firstdayofmonth
-
-doc"""
-    tonext(dt::TimeType,dow::Int;same::Bool=false) -> TimeType
-
-Adjusts `dt` to the next day of week corresponding to `dow` with `1 = Monday, 2 = Tuesday, etc`. Setting `same=true` allows the current `dt` to be considered as the next `dow`, allowing for no adjustment to occur.
-"""
-Dates.tonext(::Dates.TimeType,::Int,?)
-
-doc"""
-    tonext(func::Function,dt::TimeType;step=Day(1),negate=false,limit=10000,same=false) -> TimeType
-
-Adjusts `dt` by iterating at most `limit` iterations by `step` increments until `func` returns `true`. `func` must take a single `TimeType` argument and return a `Bool`. `same` allows `dt` to be considered in satisfying `func`. `negate` will make the adjustment process terminate when `func` returns `false` instead of `true`.
-"""
-Dates.tonext(::Function,::Dates.TimeType)
-
-doc"""
-    dayofyear(dt::TimeType) -> Int
-
-Returns the day of the year for `dt` with January 1st being day 1.
-"""
-Dates.dayofyear
-
-doc"""
-    tolast(dt::TimeType,dow::Int;of=Month) -> TimeType
-
-Adjusts `dt` to the last `dow` of its month. Alternatively, `of=Year` will adjust to the last `dow` of the year.
-"""
-Dates.tolast
-
-doc"""
-    firstdayofquarter(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the first day of its quarter.
-"""
-Dates.firstdayofquarter
-
-doc"""
-```rst
-..  julian2datetime(julian_days) -> DateTime
-
-Takes the number of Julian calendar days since epoch
-``-4713-11-24T12:00:00`` and returns the corresponding ``DateTime``.
-```
-"""
-Dates.julian2datetime
-
-doc"""
-    year(dt::TimeType) -> Int64
-    month(dt::TimeType) -> Int64
-    week(dt::TimeType) -> Int64
-    day(dt::TimeType) -> Int64
-    hour(dt::TimeType) -> Int64
-    minute(dt::TimeType) -> Int64
-    second(dt::TimeType) -> Int64
-    millisecond(dt::TimeType) -> Int64
-
-Return the field part of a `Date` or `DateTime` as an `Int64`.
-"""
-Dates.year
-
-doc"""
-    toprev(dt::TimeType,dow::Int;same::Bool=false) -> TimeType
-
-Adjusts `dt` to the previous day of week corresponding to `dow` with `1 = Monday, 2 = Tuesday, etc`. Setting `same=true` allows the current `dt` to be considered as the previous `dow`, allowing for no adjustment to occur.
-"""
-Dates.toprev(::Dates.TimeType,::Int,?)
-
-doc"""
-    toprev(func::Function,dt::TimeType;step=Day(-1),negate=false,limit=10000,same=false) -> TimeType
-
-Adjusts `dt` by iterating at most `limit` iterations by `step` increments until `func` returns `true`. `func` must take a single `TimeType` argument and return a `Bool`. `same` allows `dt` to be considered in satisfying `func`. `negate` will make the adjustment process terminate when `func` returns `false` instead of `true`.
-"""
-Dates.toprev(::Function,::Dates.TimeType)
-
-doc"""
-    daysinyear(dt::TimeType) -> Int
-
-Returns 366 if the year of `dt` is a leap year, otherwise returns 365.
-"""
-Dates.daysinyear
-
-doc"""
-```rst
-..  trunc(dt::TimeType, ::Type{Period}) -> TimeType
-
-Truncates the value of ``dt`` according to the provided ``Period`` type.
-E.g. if ``dt`` is ``1996-01-01T12:30:00``, then ``trunc(dt,Day) == 1996-01-01T00:00:00``.
-```
-"""
-Dates.trunc(::Dates.TimeType, ::Type{Dates.Period})
-
-doc"""
-    daysinmonth(dt::TimeType) -> Int
-
-Returns the number of days in the month of `dt`. Value will be 28, 29, 30, or 31.
-"""
-Dates.daysinmonth
-
-doc"""
-    yearmonth(dt::TimeType) -> (Int64, Int64)
-
-Simultaneously return the year and month parts of a `Date` or `DateTime`.
-"""
-Dates.yearmonth
-
-doc"""
-    daysofweekinmonth(dt::TimeType) -> Int
-
-For the day of week of `dt`, returns the total number of that day of the week in `dt`'s month. Returns 4 or 5. Useful in temporal expressions for specifying the last day of a week in a month by including `dayofweekofmonth(dt) == daysofweekinmonth(dt)` in the adjuster function.
-"""
-Dates.daysofweekinmonth
-
-doc"""
-    yearmonthday(dt::TimeType) -> (Int64, Int64, Int64)
-
-Simultaneously return the year, month, and day parts of a `Date` or `DateTime`.
-"""
-Dates.yearmonthday
-
-doc"""
-    Dates.DateFormat(format::AbstractString) -> DateFormat
-
-Construct a date formatting object that can be passed repeatedly for parsing similarly formatted date strings. `format` is a format string in the form described above (e.g. `"yyyy-mm-dd"`).
-"""
-Dates.Dates.DateFormat
-
-doc"""
-    lastdayofweek(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the Sunday of its week.
-"""
-Dates.lastdayofweek
-
-doc"""
-    recur{T<:TimeType}(func::Function,dr::StepRange{T};negate=false,limit=10000) -> Vector{T}
-
-`func` takes a single TimeType argument and returns a `Bool` indicating whether the input should be "included" in the final set. `recur` applies `func` over each element in the range of `dr`, including those elements for which `func` returns `true` in the resulting Array, unless `negate=true`, then only elements where `func` returns `false` are included.
-"""
-Dates.recur
-
-doc"""
-    monthday(dt::TimeType) -> (Int64, Int64)
-
-Simultaneously return the month and day parts of a `Date` or `DateTime`.
-"""
-Dates.monthday
-
-doc"""
-    default(p::Period) -> Period
-
-Returns a sensible "default" value for the input Period by returning `one(p)` for Year, Month, and Day, and `zero(p)` for Hour, Minute, Second, and Millisecond.
-"""
-Dates.default
-
-doc"""
-```rst
-..  unix2datetime(x) -> DateTime
-
-Takes the number of seconds since unix epoch ``1970-01-01T00:00:00``
-and converts to the corresponding ``DateTime``.
-```
-"""
-Dates.unix2datetime
-
-doc"""
-    eps(::DateTime) -> Millisecond
-    eps(::Date) -> Day
-
-Returns `Millisecond(1)` for `DateTime` values and `Day(1)` for `Date` values.
-"""
-Dates.eps(::Union{Date,DateTime})
-
-doc"""
-    firstdayofyear(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the first day of its year.
-"""
-Dates.firstdayofyear
-
-doc"""
-```rst
-..  rata2datetime(days) -> DateTime
-
-Takes the number of Rata Die days since epoch ``0000-12-31T00:00:00``
-and returns the corresponding ``DateTime``.
-```
-"""
-Dates.rata2datetime
-
-doc"""
-    now() -> DateTime
-
-Returns a `DateTime` corresponding to the user's system time including the system timezone locale.
-"""
-now
-
-doc"""
-    now(::Type{UTC}) -> DateTime
-
-Returns a `DateTime` corresponding to the user's system time as UTC/GMT.
-"""
-Dates.now(::Type{Dates.UTC})
-
-doc"""
-    isleapyear(dt::TimeType) -> Bool
-
-Returns `true` if the year of `dt` is a leap year.
-"""
-Dates.isleapyear
-
-doc"""
-    today() -> Date
-
-Returns the date portion of `now()`.
-"""
-Dates.today
-
-doc"""
-    lastdayofyear(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the last day of its year.
-"""
-Dates.lastdayofyear
-
-doc"""
-    tofirst(dt::TimeType,dow::Int;of=Month) -> TimeType
-
-Adjusts `dt` to the first `dow` of its month. Alternatively, `of=Year` will adjust to the first `dow` of the year.
-"""
-Dates.tofirst
-
-doc"""
-    lastdayofmonth(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the last day of its month.
-"""
-Dates.lastdayofmonth
-
-doc"""
-    dayofweek(dt::TimeType) -> Int64
-
-Returns the day of the week as an `Int64` with `1 = Monday, 2 = Tuesday, etc.`.
-"""
-Dates.dayofweek
-
-doc"""
-    Year(dt::TimeType) -> Year
-    Month(dt::TimeType) -> Month
-    Week(dt::TimeType) -> Week
-    Day(dt::TimeType) -> Day
-    Hour(dt::TimeType) -> Hour
-    Minute(dt::TimeType) -> Minute
-    Second(dt::TimeType) -> Second
-    Millisecond(dt::TimeType) -> Millisecond
-
-Return the field part of a `Date` or `DateTime` as a `Period` type.
-"""
-Dates.Year(dt::Dates.TimeType)
-
-doc"""
-    Year(v)
-    Month(v)
-    Week(v)
-    Day(v)
-    Hour(v)
-    Minute(v)
-    Second(v)
-    Millisecond(v)
-
-Construct a `Period` type with the given `v` value. Input must be losslessly
-convertible to an `Int64`.
-"""
-Dates.Year(v)
-
-doc"""
-    quarterofyear(dt::TimeType) -> Int
-
-Returns the quarter that `dt` resides in. Range of value is 1:4.
-"""
-Dates.quarterofyear
-
-doc"""
-    dayofquarter(dt::TimeType) -> Int
-
-Returns the day of the current quarter of `dt`. Range of value is 1:92.
-"""
-Dates.dayofquarter
-
-doc"""
-    lastdayofquarter(dt::TimeType) -> TimeType
-
-Adjusts `dt` to the last day of its quarter.
-"""
-Dates.lastdayofquarter
-
-# Base.Pkg
-
-doc"""
-    build()
-
-Run the build scripts for all installed packages in depth-first recursive order.
-"""
-Pkg.build()
-
-doc"""
-    build(pkgs...)
-
-Run the build script in `deps/build.jl` for each package in `pkgs` and all of their dependencies in depth-first recursive order. This is called automatically by `Pkg.resolve()` on all installed or updated packages.
-"""
-Pkg.build(pkgs...)
-
-doc"""
-    init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH)
-
-Initialize `Pkg.dir()` as a package directory. This will be done automatically when the `JULIA_PKGDIR` is not set and `Pkg.dir()` uses its default value. As part of this process, clones a local METADATA git repository from the site and branch specified by its arguments, which are typically not provided. Explicit (non-default) arguments can be used to support a custom METADATA setup.
-"""
-Pkg.init()
-
-doc"""
-    publish()
-
-For each new package version tagged in `METADATA` not already published, make sure that the tagged package commits have been pushed to the repo at the registered URL for the package and if they all have, open a pull request to `METADATA`.
-"""
-Pkg.publish()
-
-doc"""
-    pin(pkg)
-
-Pin `pkg` at the current version. To go back to using the newest compatible released version, use `Pkg.free(pkg)`
-"""
-Pkg.pin(pkg)
-
-doc"""
-    pin(pkg, version)
-
-Pin `pkg` at registered version `version`.
-"""
-Pkg.pin(pkg, version)
-
-doc"""
-    resolve()
-
-Determines an optimal, consistent set of package versions to install or upgrade to. The optimal set of package versions is based on the contents of `Pkg.dir("REQUIRE")` and the state of installed packages in `Pkg.dir()`, Packages that are no longer required are moved into `Pkg.dir(".trash")`.
-"""
-Pkg.resolve()
-
-doc"""
-    available() -> Vector{ASCIIString}
-
-Returns the names of available packages.
-"""
-Pkg.available()
-
-doc"""
-    available(pkg) -> Vector{VersionNumber}
-
-Returns the version numbers available for package `pkg`.
-"""
-Pkg.available(pkg)
-
-doc"""
-    register(pkg, [url])
-
-Register `pkg` at the git URL `url`, defaulting to the configured origin URL of the git repo `Pkg.dir(pkg)`.
-"""
-Pkg.register(pkg, url=?)
-
-doc"""
-    rm(pkg)
-
-Remove all requirement entries for `pkg` from `Pkg.dir("REQUIRE")` and call `Pkg.resolve()`.
-"""
-Pkg.rm(pkg)
-
-doc"""
-    free(pkg)
-
-Free the package `pkg` to be managed by the package manager again. It calls `Pkg.resolve()` to determine optimal package versions after. This is an inverse for both `Pkg.checkout` and `Pkg.pin`.
-
-You can also supply an iterable collection of package names, e.g., `Pkg.free(("Pkg1", "Pkg2"))` to free multiple packages at once.
-"""
-Pkg.free()
-
-doc"""
-    status()
-
-Prints out a summary of what packages are installed and what version and state they're in.
-"""
-Pkg.status
-
-doc"""
-    edit()
-
-Opens `Pkg.dir("REQUIRE")` in the editor specified by the `VISUAL` or `EDITOR` environment variables; when the editor command returns, it runs `Pkg.resolve()` to determine and install a new optimal set of installed package versions.
-"""
-Pkg.edit()
-
-doc"""
-    clone(url, [pkg])
-
-Clone a package directly from the git URL `url`. The package does not need to be a registered in `Pkg.dir("METADATA")`. The package repo is cloned by the name `pkg` if provided; if not provided, `pkg` is determined automatically from `url`.
-"""
-Pkg.clone(url,?)
-
-doc"""
-    clone(pkg)
-
-If `pkg` has a URL registered in `Pkg.dir("METADATA")`, clone it from that URL on the default branch. The package does not need to have any registered versions.
-"""
-Pkg.clone(pkg)
-
-doc"""
-    checkout(pkg, [branch="master"])
-
-Checkout the `Pkg.dir(pkg)` repo to the branch `branch`. Defaults to checking out the "master" branch. To go back to using the newest compatible released version, use `Pkg.free(pkg)`
-"""
-Pkg.checkout(pkg)
-
-doc"""
-    update()
-
-Update package the metadata repo – kept in `Pkg.dir("METADATA")` – then update any fixed packages that can safely be pulled from their origin; then call `Pkg.resolve()` to determine a new optimal set of packages versions.
-"""
-Pkg.update
-
-doc"""
-    add(pkg, vers...)
-
-Add a requirement entry for `pkg` to `Pkg.dir("REQUIRE")` and call `Pkg.resolve()`. If `vers` are given, they must be `VersionNumber` objects and they specify acceptable version intervals for `pkg`.
-"""
-Pkg.add(pkg, vers...)
-
-doc"""
-    tag(pkg, [ver, [commit]])
-
-Tag `commit` as version `ver` of package `pkg` and create a version entry in `METADATA`. If not provided, `commit` defaults to the current commit of the `pkg` repo. If `ver` is one of the symbols `:patch`, `:minor`, `:major` the next patch, minor or major version is used. If `ver` is not provided, it defaults to `:patch`.
-"""
-Pkg.tag(pkg)
-
-doc"""
-    test()
-
-Run the tests for all installed packages ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its `test/runtests.jl` file and test dependencies are specified in `test/REQUIRE`.
-"""
-Pkg.test()
-
-doc"""
-    test(pkgs...)
-
-Run the tests for each package in `pkgs` ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its `test/runtests.jl` file and test dependencies are specified in `test/REQUIRE`.
-"""
-Pkg.test(pkgs...)
-
-doc"""
-    generate(pkg,license)
-
-Generate a new package named `pkg` with one of these license keys: `"MIT"`, `"BSD"` or `"ASL"`. If you want to make a package with a different license, you can edit it afterwards. Generate creates a git repo at `Pkg.dir(pkg)` for the package and inside it `LICENSE.md`, `README.md`, `REQUIRE`, the julia entrypoint `$pkg/src/$pkg.jl`, and Travis and AppVeyor CI configuration files `.travis.yml` and `appveyor.yml`.
-"""
-Pkg.generate(pkg,license)
-
-doc"""
-    dir() -> AbstractString
-
-Returns the absolute path of the package directory. This defaults to `joinpath(homedir(),".julia","v$(VERSION.major).$(VERSION.minor)")` on all platforms (i.e. `~/.julia/v0.4` in UNIX shell syntax). If the `JULIA_PKGDIR` environment variable is set, then that path is used in the returned value as `joinpath(ENV["JULIA_PKGDIR"],"v$(VERSION.major).$(VERSION.minor)")`. If `JULIA_PKGDIR` is a relative path, it is interpreted relative to whatever the current working directory is.
-"""
-Pkg.dir()
-
-doc"""
-    dir(names...) -> AbstractString
-
-Equivalent to `normpath(Pkg.dir(),names...)` – i.e. it appends path components to the package directory and normalizes the resulting path. In particular, `Pkg.dir(pkg)` returns the path to the package `pkg`.
-"""
-Pkg.dir(names...)
-
-doc"""
-    installed() -> Dict{ASCIIString,VersionNumber}
-
-Returns a dictionary mapping installed package names to the installed version number of each package.
-"""
-Pkg.installed()
-
-doc"""
-    installed(pkg) -> Void | VersionNumber
-
-If `pkg` is installed, return the installed version number, otherwise return `nothing`.
-"""
-Pkg.installed(pkg)
-
-doc"""
-    randjump(r::MersenneTwister, jumps, [jumppoly]) -> Vector{MersenneTwister}
-
-Create an array of the size `jumps` of initialized `MersenneTwister` RNG objects where the first RNG object given as a parameter and following `MersenneTwister` RNGs in the array initialized such that a state of the RNG object in the array would be moved forward (without generating numbers) from a previous RNG object array element on a particular number of steps encoded by the jump polynomial `jumppoly`.
-
-Default jump polynomial moves forward `MersenneTwister` RNG state by 10^20 steps.
-"""
-randjump
-
-doc"""
-```rst
-..  \:(start, [step], stop)
-
-Range operator. ``a:b`` constructs a range from ``a`` to ``b`` with a step size of 1, and ``a:s:b`` is similar but uses a step size of ``s``. These syntaxes call the function ``colon``.
-The colon is also used in indexing to select whole dimensions.
-```
-"""
-colon(start, step, stop)
-
-doc"""
-```rst
-..  $(x, y)
-
-Bitwise exclusive or
-```
-"""
-Base.(:$)(x, y)
+include("helpdb/Base.jl")
+include("helpdb/Dates.jl")
diff --git a/base/docs/helpdb/Base.jl b/base/docs/helpdb/Base.jl
new file mode 100644
index 0000000000000..52aceaba93d46
--- /dev/null
+++ b/base/docs/helpdb/Base.jl
@@ -0,0 +1,10672 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# Base
+
+"""
+    @time
+
+A macro to execute an expression, printing the time it took to execute, the number of
+allocations, and the total number of bytes its execution caused to be allocated, before
+returning the value of the expression.
+"""
+:@time
+
+"""
+    systemerror(sysfunc, iftrue)
+
+Raises a `SystemError` for `errno` with the descriptive string `sysfunc` if `iftrue` is `true`
+"""
+systemerror
+
+"""
+    writedlm(f, A, delim='\\t')
+
+Write `A` (a vector, matrix or an iterable collection of iterable rows) as text to `f`
+(either a filename string or an `IO` stream) using the given delimeter `delim` (which
+defaults to tab, but can be any printable Julia object, typically a `Char` or
+`AbstractString`).
+
+For example, two vectors `x` and `y` of the same length can be written as two columns of
+tab-delimited text to `f` by either `writedlm(f, [x y])` or by `writedlm(f, zip(x, y))`.
+"""
+writedlm
+
+"""
+    digamma(x)
+
+Compute the digamma function of `x` (the logarithmic derivative of `gamma(x)`)
+"""
+digamma
+
+"""
+    fill!(A, x)
+
+Fill array `A` with the value `x`. If `x` is an object reference, all elements will refer to
+the same object. `fill!(A, Foo())` will return `A` filled with the result of evaluating
+`Foo()` once.
+"""
+fill!
+
+"""
+    read!(stream::IO, array::Union{Array, BitArray})
+    read!(filename::AbstractString, array::Union{Array, BitArray})
+
+Read binary data from an I/O stream or file, filling in `array`.
+"""
+read!
+
+"""
+    empty!(collection) -> collection
+
+Remove all elements from a `collection`.
+"""
+empty!
+
+"""
+    asin(x)
+
+Compute the inverse sine of `x`, where the output is in radians.
+"""
+asin
+
+"""
+    <:(T1, T2)
+
+Subtype operator, equivalent to `issubtype(T1,T2)`.
+"""
+Base.(:(<:))
+
+"""
+    schedule(t::Task, [val]; error=false)
+
+Add a task to the scheduler's queue. This causes the task to run constantly when the system
+is otherwise idle, unless the task performs a blocking operation such as `wait`.
+
+If a second argument is provided, it will be passed to the task (via the return value of
+`yieldto`) when it runs again. If `error` is `true`, the value is raised as an exception in
+the woken task.
+"""
+schedule
+
+"""
+    step(r)
+
+Get the step size of a [`Range`](:obj:`Range`) object.
+"""
+step
+
+"""
+    utf32(s)
+
+Create a UTF-32 string from a byte array, array of `Char` or `UInt32`, or any other string
+type. (Conversions of byte arrays check for a byte-order marker in the first four bytes, and
+do not include it in the resulting string.)
+
+Note that the resulting `UTF32String` data is terminated by the NUL codepoint (32-bit zero),
+which is not treated as a character in the string (so that it is mostly invisible in Julia);
+this allows the string to be passed directly to external functions requiring NUL-terminated
+data. This NUL is appended automatically by the `utf32(s)` conversion function. If you have
+a `Char` or `UInt32` array `A` that is already NUL-terminated UTF-32 data, then you can
+instead use `UTF32String(A)` to construct the string without making a copy of the data and
+treating the NUL as a terminator rather than as part of the string.
+"""
+utf32(s)
+
+"""
+    utf32(::Union{Ptr{Char},Ptr{UInt32},Ptr{Int32}} [, length])
+
+Create a string from the address of a NUL-terminated UTF-32 string. A copy is made; the
+pointer can be safely freed. If `length` is specified, the string does not have to be
+NUL-terminated.
+"""
+utf32(::Union{Ptr{Char},Ptr{UInt32},Ptr{Int32}}, length=?)
+
+"""
+    takebuf_array(b::IOBuffer)
+
+Obtain the contents of an `IOBuffer` as an array, without copying. Afterwards, the
+`IOBuffer` is reset to its initial state.
+"""
+takebuf_array
+
+"""
+    download(url,[localfile])
+
+Download a file from the given url, optionally renaming it to the given local file name.
+Note that this function relies on the availability of external tools such as `curl`, `wget`
+or `fetch` to download the file and is provided for convenience. For production use or
+situations in which more options are needed, please use a package that provides the desired
+functionality instead.
+"""
+download
+
+"""
+    @everywhere
+
+Execute an expression on all processes. Errors on any of the processes are collected into a
+`CompositeException` and thrown.
+"""
+:@everywhere
+
+"""
+    lstrip(string, [chars])
+
+Return `string` with any leading whitespace removed. If `chars` (a character, or vector or
+set of characters) is provided, instead remove characters contained in it.
+"""
+lstrip
+
+"""
+    reenable_sigint(f::Function)
+
+Re-enable Ctrl-C handler during execution of a function. Temporarily reverses the effect of
+`disable_sigint`.
+"""
+reenable_sigint
+
+"""
+    indmin(itr) -> Integer
+
+Returns the index of the minimum element in a collection.
+"""
+indmin
+
+"""
+    powermod(x, p, m)
+
+Compute ``x^p \\pmod m``.
+"""
+powermod
+
+"""
+    typeintersect(T, S)
+
+Compute a type that contains the intersection of `T` and `S`. Usually this will be the
+smallest such type or one close to it.
+"""
+typeintersect
+
+"""
+    pointer(array [, index])
+
+Get the native address of an array or string element. Be careful to ensure that a julia
+reference to `a` exists as long as this pointer will be used. This function is "unsafe" like
+`unsafe_convert`.
+
+Calling `Ref(array[, index])` is generally preferable to this function.
+"""
+pointer
+
+"""
+    isnan(f) -> Bool
+
+Test whether a floating point number is not a number (NaN).
+"""
+isnan
+
+"""
+    println(x)
+
+Print (using [`print`](:func:`print`)) `x` followed by a newline.
+"""
+println
+
+"""
+    besselj(nu, x)
+
+Bessel function of the first kind of order `nu`, ``J_\\nu(x)``.
+"""
+besselj
+
+"""
+    @code_lowered
+
+Evaluates the arguments to the function call, determines their types, and calls
+[`code_lowered`](:func:`code_lowered`) on the resulting expression.
+"""
+:@code_lowered
+
+"""
+    //(num, den)
+
+Divide two integers or rational numbers, giving a `Rational` result.
+"""
+Base.(:(//))
+
+"""
+    At_mul_B(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ⋅B``.
+"""
+At_mul_B
+
+"""
+    methods(f, [types])
+
+Returns the method table for `f`.
+
+If `types` is specified, returns an array of methods whose types match.
+"""
+methods
+
+"""
+    pmap(f, lsts...; err_retry=true, err_stop=false, pids=workers())
+
+Transform collections `lsts` by applying `f` to each element in parallel. (Note that
+`f` must be made available to all worker processes; see [Code Availability and Loading Packages](:ref:`Code Availability and Loading Packages <man-parallel-computing-code-availability>`)
+for details.) If `nprocs() > 1`, the calling process will be dedicated to assigning tasks.
+All other available processes will be used as parallel workers, or on the processes
+specified by `pids`.
+
+If `err_retry` is `true`, it retries a failed application of `f` on a different worker. If
+`err_stop` is `true`, it takes precedence over the value of `err_retry` and `pmap` stops
+execution on the first error.
+"""
+pmap
+
+"""
+    workers()
+
+Returns a list of all worker process identifiers.
+"""
+workers
+
+"""
+    isinteger(x) -> Bool
+
+Test whether `x` or all its elements are numerically equal to some integer
+"""
+isinteger
+
+"""
+    sortrows(A, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Sort the rows of matrix `A` lexicographically.
+"""
+sortrows
+
+"""
+    ./(x, y)
+
+Element-wise right division operator.
+"""
+Base.(:(./))
+
+"""
+    IPv6(host::Integer) -> IPv6
+
+Returns IPv6 object from ip address formatted as Integer
+"""
+IPv6
+
+"""
+    prod!(r, A)
+
+Multiply elements of `A` over the singleton dimensions of `r`, and write results to `r`.
+"""
+prod!
+
+"""
+    hist2d!(counts, M, e1, e2) -> (e1, e2, counts)
+
+Compute a "2d histogram" with respect to the bins delimited by the edges given in `e1` and
+`e2`. This function writes the results to a pre-allocated array `counts`.
+"""
+hist2d!
+
+"""
+    hypot(x, y)
+
+Compute the ``\\sqrt{x^2+y^2}`` avoiding overflow and underflow.
+"""
+hypot
+
+"""
+    airybi(x)
+
+Airy function ``\\operatorname{Bi}(x)``.
+"""
+airybi
+
+"""
+    gensym([tag])
+
+Generates a symbol which will not conflict with other variable names.
+"""
+gensym
+
+"""
+    cummin(A, [dim])
+
+Cumulative minimum along a dimension. The dimension defaults to 1.
+"""
+cummin
+
+"""
+    minabs!(r, A)
+
+Compute the minimum absolute values over the singleton dimensions of `r`, and write values to `r`.
+"""
+minabs!
+
+"""
+    @evalpoly(z, c...)
+
+Evaluate the polynomial ``\\sum_k c[k] z^{k-1}`` for the coefficients `c[1]`, `c[2]`, ...;
+that is, the coefficients are given in ascending order by power of `z`.  This macro expands
+to efficient inline code that uses either Horner's method or, for complex `z`, a more
+efficient Goertzel-like algorithm.
+"""
+:@evalpoly
+
+"""
+    eigfact!(A, [B])
+
+Same as [`eigfact`](:func:`eigfact`), but saves space by overwriting the input `A` (and
+`B`), instead of creating a copy.
+"""
+eigfact!
+
+"""
+    cosh(x)
+
+Compute hyperbolic cosine of `x`.
+"""
+cosh
+
+"""
+    ipermutedims(A, perm)
+
+Like [`permutedims`](:func:`permutedims`), except the inverse of the given permutation is applied.
+"""
+ipermutedims
+
+"""
+    dirname(path::AbstractString) -> AbstractString
+
+Get the directory part of a path.
+"""
+dirname
+
+"""
+    isfile(path) -> Bool
+
+Returns `true` if `path` is a regular file, `false` otherwise.
+"""
+isfile
+
+"""
+    symlink(target, link)
+
+Creates a symbolic link to `target` with the name `link`.
+
+**note**
+
+This function raises an error under operating systems that do not support soft symbolic
+links, such as Windows XP.
+"""
+symlink
+
+"""
+    task_local_storage(symbol)
+
+Look up the value of a symbol in the current task's task-local storage.
+"""
+task_local_storage(symbol)
+
+"""
+    task_local_storage(symbol, value)
+
+Assign a value to a symbol in the current task's task-local storage.
+"""
+task_local_storage(symbol, value)
+
+"""
+    task_local_storage(body, symbol, value)
+
+Call the function `body` with a modified task-local storage, in which `value` is assigned to
+`symbol`; the previous value of `symbol`, or lack thereof, is restored afterwards. Useful
+for emulating dynamic scoping.
+"""
+task_local_storage(body, symbol, value)
+
+"""
+    diff(A, [dim])
+
+Finite difference operator of matrix or vector.
+"""
+diff
+
+"""
+    precision(num::AbstractFloat)
+
+Get the precision of a floating point number, as defined by the effective number of bits in
+the mantissa.
+"""
+precision
+
+"""
+    readlines(stream::IO)
+    readlines(filename::AbstractString)
+
+Read all lines of an I/O stream or a file as a vector of strings.
+The text is assumed to be encoded in UTF-8.
+"""
+readlines
+
+"""
+    findnz(A)
+
+Return a tuple `(I, J, V)` where `I` and `J` are the row and column indexes of the non-zero
+values in matrix `A`, and `V` is a vector of the non-zero values.
+"""
+findnz
+
+"""
+    Future()
+
+Create a `Future` on the local machine.
+"""
+Future()
+
+"""
+    Future(n)
+
+Create a `Future` on process `n`.
+"""
+Future(::Integer)
+
+"""
+    RemoteChannel()
+
+Make an reference to a `Channel{Any}(1)` on the local machine.
+"""
+RemoteChannel()
+
+"""
+    RemoteChannel(n)
+
+Make an reference to a `Channel{Any}(1)` on process `n`.
+"""
+RemoteChannel(::Integer)
+
+"""
+    RemoteChannel(f::Function, pid)
+
+Create references to remote channels of a specific size and type. `f()` is a function that
+when executed on `pid` must return an implementation of an `AbstractChannel`.
+
+For example, `RemoteChannel(()->Channel{Int}(10), pid)`, will return a reference to a
+channel of type `Int` and size 10 on `pid`.
+"""
+RemoteChannel(f::Function, pid)
+
+"""
+    foldl(op, v0, itr)
+
+Like [`reduce`](:func:`reduce`), but with guaranteed left associativity. `v0` will be used
+exactly once.
+"""
+foldl(op, v0, itr)
+
+"""
+    foldl(op, itr)
+
+Like `foldl(op, v0, itr)`, but using the first element of `itr` as `v0`. In general, this
+cannot be used with empty collections (see `reduce(op, itr)`).
+"""
+foldl(op, itr)
+
+"""
+    airybiprime(x)
+
+Airy function derivative ``\\operatorname{Bi}'(x)``.
+"""
+airybiprime
+
+"""
+    Ac_rdiv_B(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ / B``.
+"""
+Ac_rdiv_B
+
+
+"""
+    linspace(start, stop, n=50)
+
+Construct a range of `n` linearly spaced elements from `start` to `stop`.
+"""
+linspace
+
+"""
+    promote_type(type1, type2)
+
+Determine a type big enough to hold values of each argument type without loss, whenever
+possible. In some cases, where no type exists to which both types can be promoted
+losslessly, some loss is tolerated; for example, `promote_type(Int64,Float64)` returns
+`Float64` even though strictly, not all `Int64` values can be represented exactly as
+`Float64` values.
+"""
+promote_type
+
+"""
+    ind2sub(dims, index) -> subscripts
+
+Returns a tuple of subscripts into an array with dimensions `dims`,
+corresponding to the linear index `index`.
+
+**Example**: `i, j, ... = ind2sub(size(A), indmax(A))` provides the
+indices of the maximum element
+"""
+ind2sub(dims::Tuple, index::Int)
+
+"""
+    ind2sub(a, index) -> subscripts
+
+Returns a tuple of subscripts into array `a` corresponding to the linear index `index`.
+"""
+ind2sub(a, index)
+
+"""
+```
+.*(x, y)
+```
+
+Element-wise multiplication operator.
+"""
+Base.(:(.*))
+
+"""
+    ror!(dest::BitArray{1}, src::BitArray{1}, i::Integer) -> BitArray{1}
+
+Performs a right rotation operation on `src` and put the result into `dest`.
+"""
+ror!(dest::BitArray{1}, src::BitArray{1}, i::Integer)
+
+"""
+    ror!(B::BitArray{1}, i::Integer) -> BitArray{1}
+
+Performs a right rotation operation on `B`.
+"""
+ror!(B::BitArray{1}, i::Integer)
+
+"""
+    range(start, [step], length)
+
+Construct a range by length, given a starting value and optional step (defaults to 1).
+"""
+range
+
+"""
+    eltype(type)
+
+Determine the type of the elements generated by iterating a collection of the given `type`.
+For associative collection types, this will be a `Pair{KeyType,ValType}`. The definition
+`eltype(x) = eltype(typeof(x))` is provided for convenience so that instances can be passed
+instead of types. However the form that accepts a type argument should be defined for new
+types.
+"""
+eltype
+
+"""
+    keytype(type)
+
+Get the key type of an associative collection type. Behaves similarly to `eltype`.
+"""
+keytype
+
+"""
+    valtype(type)
+
+Get the value type of an associative collection type. Behaves similarly to `eltype`.
+"""
+valtype
+
+"""
+    edit(path::AbstractString, [line])
+
+Edit a file or directory optionally providing a line number to edit the file at. Returns to
+the julia prompt when you quit the editor.
+"""
+edit(path::AbstractString, line=?)
+
+"""
+    edit(function, [types])
+
+Edit the definition of a function, optionally specifying a tuple of types to indicate which
+method to edit.
+"""
+edit(::Function, types=?)
+
+"""
+    backtrace()
+
+Get a backtrace object for the current program point.
+"""
+backtrace
+
+"""
+    reducedim(f, A, dims[, initial])
+
+Reduce 2-argument function `f` along dimensions of `A`. `dims` is a vector specifying the
+dimensions to reduce, and `initial` is the initial value to use in the reductions. For `+`, `*`,
+`max` and `min` the `initial` argument is optional.
+
+The associativity of the reduction is implementation-dependent; if you need a particular
+associativity, e.g. left-to-right, you should write your own loop. See documentation for
+`reduce`.
+"""
+reducedim
+
+"""
+    -(x)
+
+Unary minus operator.
+"""
+-(x)
+
+"""
+    -(x, y)
+
+Subtraction operator.
+"""
+-(x, y)
+
+"""
+    mapfoldr(f, op, v0, itr)
+
+Like [`mapreduce`](:func:`mapreduce`), but with guaranteed right associativity. `v0` will be
+used exactly once.
+"""
+mapfoldr(f, op, v0, itr)
+
+"""
+    mapfoldr(f, op, itr)
+
+Like `mapfoldr(f, op, v0, itr)`, but using the first element of `itr` as `v0`. In general,
+this cannot be used with empty collections (see `reduce(op, itr)`).
+"""
+mapfoldr(f, op, itr)
+
+"""
+    broadcast_setindex!(A, X, inds...)
+
+Broadcasts the `X` and `inds` arrays to a common size and stores the value from each
+position in `X` at the indices given by the same positions in `inds`.
+"""
+broadcast_setindex!
+
+"""
+    Nullable(x)
+
+Wrap value `x` in an object of type `Nullable`, which indicates whether a value is present.
+`Nullable(x)` yields a non-empty wrapper, and `Nullable{T}()` yields an empty instance of a
+wrapper that might contain a value of type `T`.
+"""
+Nullable
+
+"""
+    bits(n)
+
+A string giving the literal bit representation of a number.
+"""
+bits
+
+"""
+    launch(manager::FooManager, params::Dict, launched::Vector{WorkerConfig}, launch_ntfy::Condition)
+
+Implemented by cluster managers. For every Julia worker launched by this function, it should
+append a `WorkerConfig` entry to `launched` and notify `launch_ntfy`. The function MUST exit
+once all workers, requested by `manager` have been launched. `params` is a dictionary of all
+keyword arguments `addprocs` was called with.
+"""
+launch
+
+"""
+    @code_typed
+
+Evaluates the arguments to the function call, determines their types, and calls
+[`code_typed`](:func:`code_typed`) on the resulting expression.
+"""
+:@code_typed
+
+"""
+    invdigamma(x)
+
+Compute the inverse digamma function of `x`.
+"""
+invdigamma
+
+"""
+    getindex(type[, elements...])
+
+Construct a 1-d array of the specified type. This is usually called with the syntax
+`Type[]`. Element values can be specified using `Type[a,b,c,...]`.
+"""
+getindex(::Type, elements...)
+
+"""
+    getindex(A, inds...)
+
+Returns a subset of array `A` as specified by `inds`, where each `ind` may be an
+`Int`, a `Range`, or a `Vector`. See the manual section on
+[array indexing](:ref:`array indexing <man-array-indexing>`) for details.
+"""
+getindex(::AbstractArray, inds...)
+
+"""
+    getindex(collection, key...)
+
+Retrieve the value(s) stored at the given key or index within a collection. The syntax
+`a[i,j,...]` is converted by the compiler to `getindex(a, i, j, ...)`.
+"""
+getindex(collection, key...)
+
+"""
+    cconvert(T,x)
+
+Convert `x` to a value of type `T`, typically by calling `convert(T,x)`
+
+In cases where `x` cannot be safely converted to `T`, unlike `convert`, `cconvert` may
+return an object of a type different from `T`, which however is suitable for
+`unsafe_convert` to handle.
+
+Neither `convert` nor `cconvert` should take a Julia object and turn it into a `Ptr`.
+"""
+cconvert
+
+"""
+    |>(x, f)
+
+Applies a function to the preceding argument. This allows for easy function chaining.
+
+```jldoctest
+julia> [1:5;] |> x->x.^2 |> sum |> inv
+0.01818181818181818
+```
+"""
+Base.(:(|>))
+
+"""
+    assert(cond)
+
+Throw an `AssertionError` if `cond` is `false`. Also available as the macro `@assert expr`.
+"""
+assert
+
+"""
+    sech(x)
+
+Compute the hyperbolic secant of `x`
+"""
+sech
+
+"""
+    nworkers()
+
+Get the number of available worker processes. This is one less than `nprocs()`. Equal to
+`nprocs()` if `nprocs() == 1`.
+"""
+nworkers
+
+"""
+    filemode(file)
+
+Equivalent to `stat(file).mode`
+"""
+filemode
+
+"""
+    print_joined(io, items, delim, [last])
+
+Print elements of `items` to `io` with `delim` between them. If `last` is specified, it is
+used as the final delimiter instead of `delim`.
+"""
+print_joined
+
+"""
+    lfact(x)
+
+Compute the logarithmic factorial of `x`
+"""
+lfact
+
+"""
+    deconv(b,a)
+
+Construct vector `c` such that `b = conv(a,c) + r`. Equivalent to polynomial division.
+"""
+deconv
+
+"""
+    insert!(collection, index, item)
+
+Insert an `item` into `collection` at the given `index`. `index` is the index of `item` in
+the resulting `collection`.
+
+```jldoctest
+julia> insert!([6, 5, 4, 2, 1], 4, 3)
+6-element Array{Int64,1}:
+ 6
+ 5
+ 4
+ 3
+ 2
+ 1
+```
+"""
+insert!
+
+"""
+    repmat(A, n, m)
+
+Construct a matrix by repeating the given matrix `n` times in dimension 1 and `m` times in
+dimension 2.
+"""
+repmat
+
+"""
+    acos(x)
+
+Compute the inverse cosine of `x`, where the output is in radians
+"""
+acos
+
+"""
+    ispath(path) -> Bool
+
+Returns `true` if `path` is a valid filesystem path, `false` otherwise.
+"""
+ispath
+
+"""
+    fdio([name::AbstractString, ]fd::Integer[, own::Bool]) -> IOStream
+
+Create an `IOStream` object from an integer file descriptor. If `own` is `true`, closing
+this object will close the underlying descriptor. By default, an `IOStream` is closed when
+it is garbage collected. `name` allows you to associate the descriptor with a named file.
+"""
+fdio
+
+"""
+    unsafe_copy!(dest::Ptr{T}, src::Ptr{T}, N)
+
+Copy `N` elements from a source pointer to a destination, with no checking. The size of an
+element is determined by the type of the pointers.
+
+The `unsafe` prefix on this function indicates that no validation is performed on the
+pointers `dest` and `src` to ensure that they are valid. Incorrect usage may corrupt or
+segfault your program, in the same manner as C.
+"""
+unsafe_copy!{T}(dest::Ptr{T}, src::Ptr{T}, N)
+
+"""
+    unsafe_copy!(dest::Array, do, src::Array, so, N)
+
+Copy `N` elements from a source array to a destination, starting at offset `so` in the
+source and `do` in the destination (1-indexed).
+
+The `unsafe` prefix on this function indicates that no validation is performed to ensure
+that N is inbounds on either array. Incorrect usage may corrupt or segfault your program, in
+the same manner as C.
+"""
+unsafe_copy!(dest::Array, d, src::Array, so, N)
+
+"""
+    diag(M[, k])
+
+The `k`th diagonal of a matrix, as a vector. Use `diagm` to construct a diagonal matrix.
+"""
+diag
+
+"""
+    .^(x, y)
+
+Element-wise exponentiation operator.
+"""
+Base.(:(.^))
+
+"""
+    isspace(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is any whitespace character. Includes ASCII characters '\\t',
+'\\n', '\\v', '\\f', '\\r', and ' ', Latin-1 character U+0085, and characters in Unicode
+category Zs. For strings, tests whether this is true for all elements of the string.
+"""
+isspace
+
+"""
+    splitext(path::AbstractString) -> (AbstractString,AbstractString)
+
+If the last component of a path contains a dot, split the path into everything before the
+dot and everything including and after the dot. Otherwise, return a tuple of the argument
+unmodified and the empty string.
+"""
+splitext
+
+"""
+    gethostname() -> AbstractString
+
+Get the local machine's host name.
+"""
+gethostname
+
+"""
+    code_typed(f, types; optimize=true)
+
+Returns an array of lowered and type-inferred ASTs for the methods matching the given
+generic function and type signature. The keyword argument `optimize` controls whether
+additional optimizations, such as inlining, are also applied.
+"""
+code_typed
+
+"""
+    hankelh1x(nu, x)
+
+Scaled Bessel function of the third kind of order `nu`, ``H^{(1)}_\\nu(x) e^{-x i}``.
+"""
+hankelh1x
+
+"""
+    replace(string, pat, r[, n])
+
+Search for the given pattern `pat`, and replace each occurrence with `r`. If `n` is
+provided, replace at most `n` occurrences. As with search, the second argument may be a
+single character, a vector or a set of characters, a string, or a regular expression. If `r`
+is a function, each occurrence is replaced with `r(s)` where `s` is the matched substring.
+If `pat` is a regular expression and `r` is a `SubstitutionString`, then capture group
+references in `r` are replaced with the corresponding matched text.
+"""
+replace
+
+"""
+    randexp([rng], [dims...])
+
+Generate a random number according to the exponential distribution with scale 1. Optionally
+generate an array of such random numbers.
+"""
+randexp
+
+"""
+    chop(string)
+
+Remove the last character from a string.
+"""
+chop
+
+"""
+    Float32(x [, mode::RoundingMode])
+
+Create a Float32 from `x`. If `x` is not exactly representable then `mode` determines how
+`x` is rounded.
+
+```jldoctest
+julia> Float32(1/3, RoundDown)
+0.3333333f0
+
+julia> Float32(1/3, RoundUp)
+0.33333334f0
+```
+
+See `rounding` for available rounding modes.
+"""
+Float32
+
+"""
+    readuntil(stream::IO, delim)
+    readuntil(filename::AbstractString, delim)
+
+Read a string from an I/O stream or a file, up to and including the given delimiter byte.
+The text is assumed to be encoded in UTF-8.
+"""
+readuntil
+
+"""
+    isimmutable(v)
+
+Return `true` iff value `v` is immutable.  See [manual](:ref:`man-immutable-composite-types`)
+for a discussion of immutability. Note that this function works on values, so if you give it
+a type, it will tell you that a value of `DataType` is mutable.
+"""
+isimmutable
+
+"""
+    macroexpand(x)
+
+Takes the expression `x` and returns an equivalent expression with all macros removed (expanded).
+"""
+macroexpand
+
+"""
+    issticky(path) -> Bool
+
+Returns `true` if `path` has the sticky bit set, `false` otherwise.
+"""
+issticky
+
+"""
+    rol(B::BitArray{1}, i::Integer) -> BitArray{1}
+
+Performs a left rotation operation.
+"""
+rol
+
+"""
+    Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)
+           Mmap.mmap(type::Type{Array{T,N}}, dims)
+
+Create an `Array` whose values are linked to a file, using memory-mapping. This provides a
+convenient way of working with data too large to fit in the computer's memory.
+
+The type is an `Array{T,N}` with a bits-type element of `T` and dimension `N` that
+determines how the bytes of the array are interpreted. Note that the file must be stored in
+binary format, and no format conversions are possible (this is a limitation of operating
+systems, not Julia).
+
+`dims` is a tuple or single `Integer` specifying the size or length of the array.
+
+The file is passed via the stream argument, either as an open `IOStream` or filename string.
+When you initialize the stream, use `"r"` for a "read-only" array, and `"w+"` to create a
+new array used to write values to disk.
+
+If no `type` argument is specified, the default is `Vector{UInt8}`.
+
+Optionally, you can specify an offset (in bytes) if, for example, you want to skip over a
+header in the file. The default value for the offset is the current stream position for an
+`IOStream`.
+
+The `grow` keyword argument specifies whether the disk file should be grown to accommodate
+the requested size of array (if the total file size is < requested array size). Write
+privileges are required to grow the file.
+
+The `shared` keyword argument specifies whether the resulting `Array` and changes made to it
+will be visible to other processes mapping the same file.
+
+For example, the following code
+
+```julia
+# Create a file for mmapping
+# (you could alternatively use mmap to do this step, too)
+A = rand(1:20, 5, 30)
+s = open("/tmp/mmap.bin", "w+")
+# We'll write the dimensions of the array as the first two Ints in the file
+write(s, size(A,1))
+write(s, size(A,2))
+# Now write the data
+write(s, A)
+close(s)
+
+# Test by reading it back in
+s = open("/tmp/mmap.bin")   # default is read-only
+m = read(s, Int)
+n = read(s, Int)
+A2 = Mmap.mmap(s, Matrix{Int}, (m,n))
+```
+
+creates a `m`-by-`n` `Matrix{Int}`, linked to the file associated with stream `s`.
+
+A more portable file would need to encode the word size -- 32 bit or 64 bit -- and endianness
+information in the header. In practice, consider encoding binary data using standard formats
+like HDF5 (which can be used with memory-mapping).
+"""
+Mmap.mmap(io, ::Type, dims, offset)
+
+"""
+    Mmap.mmap(io, BitArray, [dims, offset])
+
+Create a `BitArray` whose values are linked to a file, using memory-mapping; it has the same
+purpose, works in the same way, and has the same arguments, as [`mmap`](:func:`mmap`), but
+the byte representation is different.
+
+**Example**: `B = Mmap.mmap(s, BitArray, (25,30000))`
+
+This would create a 25-by-30000 `BitArray`, linked to the file associated with stream `s`.
+"""
+Mmap.mmap(io, ::BitArray, dims = ?, offset = ?)
+
+"""
+    airyprime(x)
+
+Airy function derivative ``\\operatorname{Ai}'(x)``.
+"""
+airyprime
+
+"""
+    bessely0(x)
+
+Bessel function of the second kind of order 0, ``Y_0(x)``.
+"""
+bessely0
+
+"""
+    any!(r, A)
+
+Test whether any values in `A` along the singleton dimensions of `r` are `true`, and write
+results to `r`.
+"""
+any!
+
+"""
+    falses(dims)
+
+Create a `BitArray` with all values set to `false`.
+"""
+falses
+
+"""
+    filter!(function, collection)
+
+Update `collection`, removing elements for which `function` is `false`. For associative
+collections, the function is passed two arguments (key and value).
+"""
+filter!
+
+"""
+    base64decode(string)
+
+Decodes the base64-encoded `string` and returns a `Vector{UInt8}` of the decoded bytes.
+"""
+base64decode
+
+"""
+    besselkx(nu, x)
+
+Scaled modified Bessel function of the second kind of order `nu`, ``K_\\nu(x) e^x``.
+"""
+besselkx
+
+"""
+    myid()
+
+Get the id of the current process.
+"""
+myid
+
+"""
+    oct(n, [pad])
+
+Convert an integer to an octal string, optionally specifying a number of digits to pad to.
+"""
+oct
+
+"""
+    timedwait(testcb::Function, secs::Float64; pollint::Float64=0.1)
+
+Waits till `testcb` returns `true` or for `secs` seconds, whichever is earlier. `testcb` is
+polled every `pollint` seconds.
+"""
+timedwait
+
+"""
+    sizeof(T)
+
+Size, in bytes, of the canonical binary representation of the given DataType `T`, if any.
+"""
+sizeof(::Type)
+
+"""
+    sizeof(s::AbstractString)
+
+The number of bytes in string `s`.
+"""
+sizeof(::AbstractString)
+
+"""
+    ===(x, y)
+    ≡(x,y)
+
+See the [`is`](:func:`is`) operator.
+"""
+Base.(:(===))
+
+"""
+    ReadOnlyMemoryError()
+
+An operation tried to write to memory that is read-only.
+"""
+ReadOnlyMemoryError
+
+"""
+    startswith(string, prefix)
+
+Returns `true` if `string` starts with `prefix`. If `prefix` is a vector or set
+of characters, tests whether the first character of `string` belongs to that set.
+"""
+startswith
+
+"""
+    permutedims!(dest, src, perm)
+
+Permute the dimensions of array `src` and store the result in the array `dest`. `perm` is a
+vector specifying a permutation of length `ndims(src)`. The preallocated array `dest` should
+have `size(dest) == size(src)[perm]` and is completely overwritten. No in-place permutation
+is supported and unexpected results will happen if `src` and `dest` have overlapping memory
+regions.
+"""
+permutedims!
+
+"""
+    functionloc(f::Function, types)
+
+Returns a tuple `(filename,line)` giving the location of a generic `Function` definition.
+"""
+functionloc(f, types)
+
+"""
+    functionloc(m::Method)
+
+Returns a tuple `(filename,line)` giving the location of a `Method` definition.
+"""
+functionloc(m)
+
+"""
+    stride(A, k)
+
+Returns the distance in memory (in number of elements) between adjacent elements in dimension `k`.
+"""
+stride
+
+"""
+    last(coll)
+
+Get the last element of an ordered collection, if it can be computed in O(1) time. This is
+accomplished by calling [`endof`](:func:`endof`) to get the last index. Returns the end
+point of a [`Range`](:obj:`Range`) even if it is empty.
+"""
+last
+
+"""
+    islink(path) -> Bool
+
+Returns `true` if `path` is a symbolic link, `false` otherwise.
+"""
+islink
+
+"""
+    istril(A) -> Bool
+
+Test whether a matrix is lower triangular.
+"""
+istril
+
+"""
+    lgamma(x)
+
+Compute the logarithm of the absolute value of [`gamma`](:func:`gamma`) for
+[`Real`](:obj:`Real`) `x`, while for [`Complex`](:obj:`Complex`) `x` it computes the
+logarithm of `gamma(x)`.
+"""
+lgamma
+
+"""
+    bin(n, [pad])
+
+Convert an integer to a binary string, optionally specifying a number of digits to pad to.
+"""
+bin
+
+"""
+    cis(z)
+
+Return ``\\exp(iz)``.
+"""
+cis
+
+"""
+    isapprox(x, y; rtol::Real=sqrt(eps), atol::Real=0)
+
+Inexact equality comparison: `true` if `norm(x-y) <= atol + rtol*max(norm(x), norm(y))`. The
+default `atol` is zero and the default `rtol` depends on the types of `x` and `y`.
+
+For real or complex floating-point values, `rtol` defaults to
+`sqrt(eps(typeof(real(x-y))))`. This corresponds to requiring equality of about half of the
+significand digits. For other types, `rtol` defaults to zero.
+
+`x` and `y` may also be arrays of numbers, in which case `norm` defaults to `vecnorm` but
+may be changed by passing a `norm::Function` keyword argument. (For numbers, `norm` is the
+same thing as `abs`.)
+
+The binary operator `≈` is equivalent to `isapprox` with the default arguments, and `x ≉ y`
+is equivalent to `!isapprox(x,y)`.
+"""
+isapprox
+
+"""
+    primes([lo,] hi)
+
+Returns a collection of the prime numbers (from `lo`, if specified) up to `hi`.
+"""
+primes
+
+"""
+    primesmask([lo,] hi)
+
+Returns a prime sieve, as a `BitArray`, of the positive integers (from `lo`, if specified)
+up to `hi`. Useful when working with either primes or composite numbers.
+"""
+primesmask
+
+"""
+    sinh(x)
+
+Compute hyperbolic sine of `x`.
+"""
+sinh
+
+"""
+    ceil([T,] x, [digits, [base]])
+
+`ceil(x)` returns the nearest integral value of the same type as `x` that is greater than or
+equal to `x`.
+
+`ceil(T, x)` converts the result to type `T`, throwing an `InexactError` if the value is not
+representable.
+
+`digits` and `base` work as for [`round`](:func:`round`).
+"""
+ceil
+
+"""
+    mapslices(f, A, dims)
+
+Transform the given dimensions of array `A` using function `f`. `f` is called on each slice
+of `A` of the form `A[...,:,...,:,...]`. `dims` is an integer vector specifying where the
+colons go in this expression. The results are concatenated along the remaining dimensions.
+For example, if `dims` is `[1,2]` and `A` is 4-dimensional, `f` is called on `A[:,:,i,j]`
+for all `i` and `j`.
+"""
+mapslices
+
+"""
+    issocket(path) -> Bool
+
+Returns `true` if `path` is a socket, `false` otherwise.
+"""
+issocket
+
+"""
+    srand([rng], [seed])
+
+Reseed the random number generator. If a `seed` is provided, the RNG will give a
+reproducible sequence of numbers, otherwise Julia will get entropy from the system. For
+`MersenneTwister`, the `seed` may be a non-negative integer, a vector of `UInt32` integers
+or a filename, in which case the seed is read from a file. `RandomDevice` does not support
+seeding.
+"""
+srand
+
+"""
+    acot(x)
+
+Compute the inverse cotangent of `x`, where the output is in radians.
+"""
+acot
+
+"""
+    oftype(x, y)
+
+Convert `y` to the type of `x` (`convert(typeof(x), y)`).
+"""
+oftype
+
+"""
+    maxabs!(r, A)
+
+Compute the maximum absolute values over the singleton dimensions of `r`, and write values to `r`.
+"""
+maxabs!
+
+"""
+    nullspace(M)
+
+Basis for nullspace of `M`.
+"""
+nullspace
+
+"""
+    isfinite(f) -> Bool
+
+Test whether a number is finite
+"""
+isfinite
+
+"""
+    push!(collection, items...) -> collection
+
+Insert one or more `items` at the end of `collection`.
+
+```jldoctest
+julia> push!([1, 2, 3], 4, 5, 6)
+6-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+```
+
+Use [`append!`](:func:`append!`) to add all the elements of another collection to
+`collection`. The result of the preceding example is equivalent to `append!([1, 2, 3], [4,
+5, 6])`.
+"""
+push!
+
+"""
+    prevpow(a, x)
+
+The largest `a^n` not greater than `x`, where `n` is a non-negative integer. `a` must be
+greater than 1, and `x` must not be less than 1.
+"""
+prevpow
+
+"""
+    indexin(a, b)
+
+Returns a vector containing the highest index in `b` for each value in `a` that is a member
+of `b` . The output vector contains 0 wherever `a` is not a member of `b`.
+"""
+indexin
+
+"""
+    permutedims(A, perm)
+
+Permute the dimensions of array `A`. `perm` is a vector specifying a permutation of length
+`ndims(A)`. This is a generalization of transpose for multi-dimensional arrays. Transpose is
+equivalent to `permutedims(A, [2,1])`.
+"""
+permutedims
+
+"""
+    shuffle!([rng,] v)
+
+In-place version of [`shuffle`](:func:`shuffle`).
+"""
+shuffle!
+
+"""
+    fldmod(x, y)
+
+The floored quotient and modulus after division. Equivalent to `(fld(x,y), mod(x,y))`.
+"""
+fldmod
+
+"""
+    promote(xs...)
+
+Convert all arguments to their common promotion type (if any), and return them all (as a tuple).
+"""
+promote
+
+"""
+    @schedule
+
+Wrap an expression in a `Task` and add it to the local machine's scheduler queue.
+"""
+:@schedule
+
+"""
+    bessely(nu, x)
+
+Bessel function of the second kind of order `nu`, ``Y_\\nu(x)``.
+"""
+bessely
+
+"""
+    gradient(F, [h])
+
+Compute differences along vector `F`, using `h` as the spacing between points. The default
+spacing is one.
+"""
+gradient
+
+"""
+    tan(x)
+
+Compute tangent of `x`, where `x` is in radians.
+"""
+tan
+
+"""
+    sprint(f::Function, args...)
+
+Call the given function with an I/O stream and the supplied extra arguments. Everything
+written to this I/O stream is returned as a string.
+"""
+sprint
+
+"""
+    fd(stream)
+
+Returns the file descriptor backing the stream or file. Note that this function only applies
+to synchronous `File`'s and `IOStream`'s not to any of the asynchronous streams.
+"""
+fd
+
+"""
+    require(module::Symbol)
+
+This function is part of the implementation of `using` / `import`, if a module is not
+already defined in `Main`. It can also be called directly to force reloading a module,
+regardless of whether it has been loaded before (for example, when interactively developing
+libraries).
+
+Loads a source files, in the context of the `Main` module, on every active node, searching
+standard locations for files. `require` is considered a top-level operation, so it sets the
+current `include` path but does not use it to search for files (see help for `include`).
+This function is typically used to load library code, and is implicitly called by `using` to
+load packages.
+
+When searching for files, `require` first looks for package code under `Pkg.dir()`, then tries
+paths in the global array `LOAD_PATH`.
+"""
+require
+
+"""
+    expand(x)
+
+Takes the expression `x` and returns an equivalent expression in lowered form.
+"""
+expand
+
+"""
+    peakflops(n; parallel=false)
+
+`peakflops` computes the peak flop rate of the computer by using double precision
+[`gemm!`](:func:`Base.LinAlg.BLAS.gemm!`). By default, if no arguments are specified, it
+multiplies a matrix of size `n x n`, where `n = 2000`. If the underlying BLAS is using
+multiple threads, higher flop rates are realized. The number of BLAS threads can be set with
+`blas_set_num_threads(n)`.
+
+If the keyword argument `parallel` is set to `true`, `peakflops` is run in parallel on all
+the worker processors. The flop rate of the entire parallel computer is returned. When
+running in parallel, only 1 BLAS thread is used. The argument `n` still refers to the size
+of the problem that is solved on each processor.
+"""
+peakflops
+
+"""
+    ones(type, dims)
+
+Create an array of all ones of specified type. The type defaults to `Float64` if not specified.
+"""
+ones(t,dims)
+
+"""
+    ones(A)
+
+Create an array of all ones with the same element type and shape as `A`.
+"""
+ones(A)
+
+"""
+    ind2chr(string, i)
+
+Convert a byte index to a character index.
+"""
+ind2chr
+
+"""
+    reshape(A, dims)
+
+Create an array with the same data as the given array, but with different dimensions. An
+implementation for a particular type of array may choose whether the data is copied or
+shared.
+"""
+reshape
+
+"""
+    randsubseq!(S, A, p)
+
+Like `randsubseq`, but the results are stored in `S` (which is resized as needed).
+"""
+randsubseq!
+
+"""
+    maximum(itr)
+
+Returns the largest element in a collection.
+"""
+maximum(itr)
+
+"""
+    maximum(A, dims)
+
+Compute the maximum value of an array over the given dimensions.
+"""
+maximum(A,dims)
+
+"""
+    redisplay(x)
+    redisplay(d::Display, x)
+    redisplay(mime, x)
+    redisplay(d::Display, mime, x)
+
+By default, the `redisplay` functions simply call `display`. However, some display backends
+may override `redisplay` to modify an existing display of `x` (if any). Using `redisplay` is
+also a hint to the backend that `x` may be redisplayed several times, and the backend may
+choose to defer the display until (for example) the next interactive prompt.
+"""
+redisplay
+
+"""
+    A_mul_Bc(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``A⋅Bᴴ``.
+"""
+A_mul_Bc
+
+"""
+    searchsorted(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Returns the range of indices of `a` which compare as equal to `x` according to the order
+specified by the `by`, `lt` and `rev` keywords, assuming that `a` is already sorted in that
+order. Returns an empty range located at the insertion point if `a` does not contain values
+equal to `x`.
+"""
+searchsorted
+
+"""
+    /(x, y)
+
+Right division operator: multiplication of `x` by the inverse of `y` on the right. Gives
+floating-point results for integer arguments.
+"""
+Base.(:(/))
+
+"""
+    connect([host],port) -> TCPSocket
+
+Connect to the host `host` on port `port`.
+"""
+connect(host=?, port)
+
+"""
+    connect(path) -> PipeEndpoint
+
+Connect to the Named Pipe / Domain Socket at `path`.
+"""
+connect(path)
+
+"""
+    connect(manager::FooManager, pid::Int, config::WorkerConfig) -> (instrm::AsyncStream, outstrm::AsyncStream)
+
+Implemented by cluster managers using custom transports. It should establish a logical
+connection to worker with id `pid`, specified by `config` and return a pair of `AsyncStream`
+objects. Messages from `pid` to current process will be read off `instrm`, while messages to
+be sent to `pid` will be written to `outstrm`. The custom transport implementation must
+ensure that messages are delivered and received completely and in order.
+`Base.connect(manager::ClusterManager.....)` sets up TCP/IP socket connections in-between
+workers.
+"""
+connect(manager, pid::Int, config::WorkerConfig)
+
+"""
+    mean(v[, region])
+
+Compute the mean of whole array `v`, or optionally along the dimensions in `region`. Note:
+Julia does not ignore `NaN` values in the computation. For applications requiring the
+handling of missing data, the `DataArray` package is recommended.
+"""
+mean
+
+"""
+    split(string, [chars]; limit=0, keep=true)
+
+Return an array of substrings by splitting the given string on occurrences of the given
+character delimiters, which may be specified in any of the formats allowed by `search`'s
+second argument (i.e. a single character, collection of characters, string, or regular
+expression). If `chars` is omitted, it defaults to the set of all space characters, and
+`keep` is taken to be `false`. The two keyword arguments are optional: they are are a
+maximum size for the result and a flag determining whether empty fields should be kept in
+the result.
+"""
+split
+
+"""
+    dump(x)
+
+Show all user-visible structure of a value.
+"""
+dump
+
+"""
+    sumabs(itr)
+
+Sum absolute values of all elements in a collection. This is equivalent to `sum(abs(itr))` but faster.
+"""
+sumabs(itr)
+
+"""
+    sumabs(A, dims)
+
+Sum absolute values of elements of an array over the given dimensions.
+"""
+sumabs(A, dims)
+
+"""
+    consume(task, values...)
+
+Receive the next value passed to `produce` by the specified task. Additional arguments may
+be passed, to be returned from the last `produce` call in the producer.
+"""
+consume
+
+"""
+    hankelh2x(nu, x)
+
+Scaled Bessel function of the third kind of order `nu`, ``H^{(2)}_\\nu(x) e^{x i}``.
+"""
+hankelh2x
+
+"""
+    ndigits(n, b)
+
+Compute the number of digits in number `n` written in base `b`.
+"""
+ndigits
+
+"""
+    cummax(A, [dim])
+
+Cumulative maximum along a dimension. The dimension defaults to 1.
+"""
+cummax
+
+"""
+    watch_file(path, timeout_s::Real)
+
+Watch file or directory `path` for changes until a change occurs or `timeout_s` seconds have
+elapsed.
+
+The returned value is an object with boolean fields `changed`, `renamed`, and `timedout`,
+giving the result of watching the file.
+
+This behavior of this function varies slightly across platforms. See
+<https://nodejs.org/api/fs.html#fs_caveats> for more detailed information.
+"""
+watch_file
+
+"""
+    At_rdiv_Bt(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ / Bᵀ``.
+"""
+At_rdiv_Bt
+
+"""
+    isinteractive() -> Bool
+
+Determine whether Julia is running an interactive session.
+"""
+isinteractive
+
+"""
+    At_mul_Bt(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ⋅Bᵀ``.
+"""
+At_mul_Bt
+
+"""
+    sum!(r, A)
+
+Sum elements of `A` over the singleton dimensions of `r`, and write results to `r`.
+"""
+sum!
+
+"""
+    close(stream)
+
+Close an I/O stream. Performs a `flush` first.
+"""
+close(stream::IO)
+
+"""
+    close(Channel)
+
+Closes a channel. An exception is thrown by:
+
+* `put!` on a closed channel.
+* `take!` and `fetch` on an empty, closed channel.
+"""
+close(::Channel)
+
+"""
+    cospi(x)
+
+Compute ``\\cos(\\pi x)`` more accurately than `cos(pi*x)`, especially for large `x`.
+"""
+cospi
+
+"""
+    parentindexes(A)
+
+From an array view `A`, returns the corresponding indexes in the parent.
+"""
+parentindexes
+
+"""
+    display(x)
+    display(d::Display, x)
+    display(mime, x)
+    display(d::Display, mime, x)
+
+Display `x` using the topmost applicable display in the display stack, typically using the
+richest supported multimedia output for `x`, with plain-text `STDOUT` output as a fallback.
+The `display(d, x)` variant attempts to display `x` on the given display `d` only, throwing
+a `MethodError` if `d` cannot display objects of this type.
+
+There are also two variants with a `mime` argument (a MIME type string, such as
+`"image/png"`), which attempt to display `x` using the requested MIME type *only*, throwing
+a `MethodError` if this type is not supported by either the display(s) or by `x`. With these
+variants, one can also supply the "raw" data in the requested MIME type by passing
+`x::AbstractString` (for MIME types with text-based storage, such as text/html or
+application/postscript) or `x::Vector{UInt8}` (for binary MIME types).
+"""
+display
+
+"""
+    @spawnat
+
+Accepts two arguments, `p` and an expression. A closure is created around the expression and
+run asynchronously on process `p`. Returns a `Future` to the result.
+"""
+:@spawnat
+
+"""
+    print_shortest(io, x)
+
+Print the shortest possible representation, with the minimum number of consecutive non-zero
+digits, of number `x`, ensuring that it would parse to the exact same number.
+"""
+print_shortest
+
+"""
+    merge(collection, others...)
+
+Construct a merged collection from the given collections. If necessary, the
+types of the resulting collection will be promoted to accommodate the types of
+the merged collections. If the same key is present in another collection, the
+value for that key will be the value it has in the last collection listed.
+
+```jldoctest
+julia> a = Dict("foo" => 0.0, "bar" => 42.0)
+Dict{ASCIIString,Float64} with 2 entries:
+  "bar" => 42.0
+  "foo" => 0.0
+
+julia> b = Dict(utf8("baz") => 17, utf8("bar") => 4711)
+Dict{UTF8String,Int64} with 2 entries:
+  "bar" => 4711
+  "baz" => 17
+
+julia> merge(a, b)
+Dict{UTF8String,Float64} with 3 entries:
+  "bar" => 4711.0
+  "baz" => 17.0
+  "foo" => 0.0
+
+julia> merge(b, a)
+Dict{UTF8String,Float64} with 3 entries:
+  "bar" => 42.0
+  "baz" => 17.0
+  "foo" => 0.0
+```
+"""
+merge
+
+"""
+    circshift(A,shifts)
+
+Circularly shift the data in an array. The second argument is a vector giving the amount to
+shift in each dimension.
+"""
+circshift
+
+"""
+    yield()
+
+Switch to the scheduler to allow another scheduled task to run. A task that calls this
+function is still runnable, and will be restarted immediately if there are no other runnable
+tasks.
+"""
+yield
+
+"""
+    transpose!(dest,src)
+
+Transpose array `src` and store the result in the preallocated array `dest`, which should
+have a size corresponding to `(size(src,2),size(src,1))`. No in-place transposition is
+supported and unexpected results will happen if `src` and `dest` have overlapping memory
+regions.
+"""
+transpose!
+
+"""
+    isconst([m::Module], s::Symbol) -> Bool
+
+Determine whether a global is declared `const` in a given `Module`. The default `Module`
+argument is `current_module()`.
+"""
+isconst
+
+"""
+    open(command, mode::AbstractString="r", stdio=DevNull)
+
+Start running `command` asynchronously, and return a tuple `(stream,process)`.  If `mode` is
+`"r"`, then `stream` reads from the process's standard output and `stdio` optionally
+specifies the process's standard input stream.  If `mode` is `"w"`, then `stream` writes to
+the process's standard input and `stdio` optionally specifies the process's standard output
+stream.
+"""
+open(command::Cmd, mod::AbstractString="r", stdio=DevNull)
+
+"""
+    open(f::Function, command, mode::AbstractString="r", stdio=DevNull)
+
+Similar to `open(command, mode, stdio)`, but calls `f(stream)` on the resulting read or
+write stream, then closes the stream and waits for the process to complete.  Returns the
+value returned by `f`.
+"""
+open(f::Function, command::Cmd, mod::AbstractString="r", stdio=DevNull)
+
+"""
+    open(filename, [read, write, create, truncate, append]) -> IOStream
+
+Open a file in a mode specified by five boolean arguments. The default is to open files for
+reading only. Returns a stream for accessing the file.
+"""
+open(filename, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool)
+
+"""
+    open(filename, [mode]) -> IOStream
+
+Alternate syntax for open, where a string-based mode specifier is used instead of the five
+booleans. The values of `mode` correspond to those from `fopen(3)` or Perl `open`, and are
+equivalent to setting the following boolean groups:
+
+| Mode | Description                   |
+|:-----|:------------------------------|
+| r    | read                          |
+| r+   | read, write                   |
+| w    | write, create, truncate       |
+| w+   | read, write, create, truncate |
+| a    | write, create, append         |
+| a+   | read, write, create, append   |
+"""
+open(filename, mode="r")
+
+"""
+    open(f::Function, args...)
+
+Apply the function `f` to the result of `open(args...)` and close the resulting file
+descriptor upon completion.
+
+**Example**: `open(readstring, "file.txt")`
+"""
+open(f::Function, args...)
+
+"""
+    sort(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Variant of `sort!` that returns a sorted copy of `v` leaving `v` itself unmodified.
+"""
+sort(v,?,?,?,?)
+
+"""
+    sort(A, dim, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Sort a multidimensional array `A` along the given dimension.
+"""
+sort(A,dim,?,?,?,?)
+
+"""
+    kron(A, B)
+
+Kronecker tensor product of two vectors or two matrices.
+"""
+kron
+
+"""
+    randn([rng], [dims...])
+
+Generate a normally-distributed random number with mean 0 and standard deviation 1.
+Optionally generate an array of normally-distributed random numbers.
+"""
+randn
+
+"""
+    process_exited(p::Process)
+
+Determine whether a process has exited.
+"""
+process_exited
+
+"""
+    tuple(xs...)
+
+Construct a tuple of the given objects.
+"""
+tuple
+
+"""
+    besseli(nu, x)
+
+Modified Bessel function of the first kind of order `nu`, ``I_\\nu(x)``.
+"""
+besseli
+
+"""
+    eachmatch(r::Regex, s::AbstractString[, overlap::Bool=false])
+
+Search for all matches of a the regular expression `r` in `s` and return a iterator over the
+matches. If overlap is `true`, the matching sequences are allowed to overlap indices in the
+original string, otherwise they must be from distinct character ranges.
+"""
+eachmatch
+
+"""
+    log10(x)
+
+Compute the logarithm of `x` to base 10. Throws `DomainError` for negative `Real` arguments.
+"""
+log10
+
+"""
+    @profile
+
+`@profile <expression>` runs your expression while taking periodic backtraces. These are
+appended to an internal buffer of backtraces.
+"""
+:@profile
+
+"""
+    extrema(itr)
+
+Compute both the minimum and maximum element in a single pass, and return them as a 2-tuple.
+"""
+extrema
+
+"""
+    isdigit(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is a numeric digit (0-9), or whether this is true for all elements
+of a string.
+"""
+isdigit
+
+"""
+    @windows
+
+Given `@windows? a : b`, do `a` on Windows and `b` elsewhere. See documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@windows
+
+"""
+    @unix
+
+Given `@unix? a : b`, do `a` on Unix systems (including Linux and OS X) and `b` elsewhere.
+See documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@unix
+
+"""
+    @windows_only
+
+A macro that evaluates the given expression only on Windows systems. See documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@windows_only
+
+"""
+    @unix_only
+
+A macro that evaluates the given expression only on Unix systems (including Linux and OS X). See
+documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@unix_only
+
+"""
+    num2hex(f)
+
+Get a hexadecimal string of the binary representation of a floating point number.
+"""
+num2hex
+
+"""
+    count_ones(x::Integer) -> Integer
+
+Number of ones in the binary representation of `x`.
+
+```jldoctest
+julia> count_ones(7)
+3
+```
+"""
+count_ones
+
+"""
+    reim(z)
+
+Return both the real and imaginary parts of the complex number `z`.
+"""
+reim
+
+"""
+    displayable(mime) -> Bool
+    displayable(d::Display, mime) -> Bool
+
+Returns a boolean value indicating whether the given `mime` type (string) is displayable by
+any of the displays in the current display stack, or specifically by the display `d` in the
+second variant.
+"""
+displayable
+
+"""
+    sdata(S::SharedArray)
+
+Returns the actual `Array` object backing `S`.
+"""
+sdata
+
+"""
+    truncate(file,n)
+
+Resize the file or buffer given by the first argument to exactly `n` bytes, filling
+previously unallocated space with '\\0' if the file or buffer is grown.
+"""
+truncate
+
+"""
+    stat(file)
+
+Returns a structure whose fields contain information about the file. The fields of the
+structure are:
+
+| Name    | Description                                                        |
+|:--------|:-------------------------------------------------------------------|
+| size    | The size (in bytes) of the file                                    |
+| device  | ID of the device that contains the file                            |
+| inode   | The inode number of the file                                       |
+| mode    | The protection mode of the file                                    |
+| nlink   | The number of hard links to the file                               |
+| uid     | The user id of the owner of the file                               |
+| gid     | The group id of the file owner                                     |
+| rdev    | If this file refers to a device, the ID of the device it refers to |
+| blksize | The file-system preferred block size for the file                  |
+| blocks  | The number of such blocks allocated                                |
+| mtime   | Unix timestamp of when the file was last modified                  |
+| ctime   | Unix timestamp of when the file was created                        |
+
+"""
+stat
+
+"""
+    exp10(x)
+
+Compute ``10^x``.
+"""
+exp10
+
+"""
+    &(x, y)
+
+Bitwise and.
+"""
+&
+
+"""
+    besselyx(nu, x)
+
+Scaled Bessel function of the second kind of order `nu`,
+``Y_\\nu(x) e^{- | \\operatorname{Im}(x) |}``.
+"""
+besselyx
+
+"""
+    eigmax(A)
+
+Returns the largest eigenvalue of `A`.
+"""
+eigmax
+
+"""
+    PipeBuffer()
+
+An IOBuffer that allows reading and performs writes by appending. Seeking and truncating are
+not supported. See IOBuffer for the available constructors.
+"""
+PipeBuffer()
+
+"""
+    PipeBuffer(data::Vector{UInt8},[maxsize])
+
+Create a PipeBuffer to operate on a data vector, optionally specifying a size beyond which
+the underlying Array may not be grown.
+"""
+PipeBuffer(data)
+
+"""
+    sortperm(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Return a permutation vector of indices of `v` that puts it in sorted order. Specify `alg` to
+choose a particular sorting algorithm (see Sorting Algorithms). `MergeSort` is used by
+default, and since it is stable, the resulting permutation will be the lexicographically
+first one that puts the input array into sorted order – i.e. indices of equal elements
+appear in ascending order. If you choose a non-stable sorting algorithm such as `QuickSort`,
+a different permutation that puts the array into order may be returned. The order is
+specified using the same keywords as `sort!`.
+
+See also [`sortperm!`](:func:`sortperm!`).
+"""
+sortperm
+
+"""
+    mod2pi(x)
+
+Modulus after division by 2pi, returning in the range \[0,2pi).
+
+This function computes a floating point representation of the modulus after division by
+numerically exact 2pi, and is therefore not exactly the same as mod(x,2pi), which would
+compute the modulus of `x` relative to division by the floating-point number 2pi.
+"""
+mod2pi
+
+"""
+    cumsum!(B, A, [dim])
+
+Cumulative sum of `A` along a dimension, storing the result in `B`. The dimension defaults
+to 1.
+"""
+cumsum!
+
+"""
+    logdet(M)
+
+Log of matrix determinant. Equivalent to `log(det(M))`, but may provide increased accuracy
+and/or speed.
+"""
+logdet
+
+"""
+    hcat(A...)
+
+Concatenate along dimension 2.
+"""
+hcat
+
+"""
+    select(v, k, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Variant of `select!` which copies `v` before partially sorting it, thereby returning the
+same thing as `select!` but leaving `v` unmodified.
+"""
+select
+
+"""
+    lpad(string, n, p)
+
+Make a string at least `n` columns wide when printed, by padding on the left with copies of `p`.
+"""
+lpad
+
+"""
+    mapreduce(f, op, v0, itr)
+
+Apply function `f` to each element in `itr`, and then reduce the result using the binary
+function `op`. `v0` must be a neutral element for `op` that will be returned for empty
+collections. It is unspecified whether `v0` is used for non-empty collections.
+
+[`mapreduce`](:func:`mapreduce`) is functionally equivalent to calling `reduce(op, v0,
+map(f, itr))`, but will in general execute faster since no intermediate collection needs to
+be created. See documentation for [`reduce`](:func:`reduce`) and [`map`](:func:`map`).
+
+```jldoctest
+julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
+14
+```
+
+The associativity of the reduction is implementation-dependent. Additionally, some
+implementations may reuse the return value of `f` for elements that appear multiple times in
+`itr`. Use [`mapfoldl`](:func:`mapfoldl`) or [`mapfoldr`](:func:`mapfoldr`) instead for
+guaranteed left or right associativity and invocation of `f` for every value.
+"""
+mapreduce(f, op, v0, itr)
+
+"""
+    mapreduce(f, op, itr)
+
+Like `mapreduce(f, op, v0, itr)`. In general, this cannot be used with empty collections
+(see `reduce(op, itr)`).
+"""
+mapreduce(f, op, itr)
+
+"""
+    accept(server[,client])
+
+Accepts a connection on the given server and returns a connection to the client. An
+uninitialized client stream may be provided, in which case it will be used instead of
+creating a new stream.
+"""
+accept
+
+"""
+    triu!(M)
+
+Upper triangle of a matrix, overwriting `M` in the process.
+"""
+triu!(M)
+
+"""
+    triu!(M, k)
+
+Returns the upper triangle of `M` starting from the `k`th superdiagonal, overwriting `M` in
+the process.
+"""
+triu!(M, k)
+
+"""
+    readstring(stream::IO)
+    readstring(filename::AbstractString)
+
+Read the entire contents of an I/O stream or a file as a string.
+The text is assumed to be encoded in UTF-8.
+"""
+readstring
+
+"""
+    poll_file(path, interval_s::Real, timeout_s::Real) -> (previous::StatStruct, current::StatStruct)
+
+Monitor a file for changes by polling every `interval_s` seconds until a change occurs or
+`timeout_s` seconds have elapsed. The `interval_s` should be a long period; the default is
+5.007 seconds.
+
+Returns a pair of `StatStruct` objects `(previous, current)` when a change is detected.
+
+To determine when a file was modified, compare `mtime(prev) != mtime(current)` to detect
+notification of changes. However, using `watch_file` for this operation is preferred, since
+it is more reliable and efficient, although in some situations it may not be available.
+"""
+poll_file
+
+"""
+    eachline(stream::IO)
+    eachline(filename::AbstractString)
+
+Create an iterable object that will yield each line from an I/O stream or a file.
+The text is assumed to be encoded in UTF-8.
+"""
+eachline
+
+"""
+    isposdef!(A) -> Bool
+
+Test whether a matrix is positive definite, overwriting `A` in the processes.
+"""
+isposdef!
+
+"""
+    complex(r, [i])
+
+Convert real numbers or arrays to complex. `i` defaults to zero.
+"""
+complex
+
+"""
+    setopt(sock::UDPSocket; multicast_loop = nothing, multicast_ttl=nothing, enable_broadcast=nothing, ttl=nothing)
+
+Set UDP socket options. `multicast_loop`: loopback for multicast packets (default: `true`).
+`multicast_ttl`: TTL for multicast packets. `enable_broadcast`: flag must be set to `true`
+if socket will be used for broadcast messages, or else the UDP system will return an access
+error (default: `false`). `ttl`: Time-to-live of packets sent on the socket.
+"""
+setopt
+
+"""
+    Mmap.Anonymous(name, readonly, create)
+
+Create an `IO`-like object for creating zeroed-out mmapped-memory that is not tied to a file
+for use in `Mmap.mmap`. Used by `SharedArray` for creating shared memory arrays.
+"""
+Mmap.Anonymous
+
+"""
+    A_rdiv_Bc(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``A / Bᴴ``.
+"""
+A_rdiv_Bc
+
+"""
+    round([T,] x, [digits, [base]], [r::RoundingMode])
+
+`round(x)` rounds `x` to an integer value according to the default rounding mode (see
+[`rounding`](:func:`rounding`)), returning a value of the same type as `x`. By default
+([`RoundNearest`](:obj:`RoundNearest`)), this will round to the nearest integer, with ties
+(fractional values of 0.5) being rounded to the even integer.
+
+```jldoctest
+julia> round(1.7)
+2.0
+
+julia> round(1.5)
+2.0
+
+julia> round(2.5)
+2.0
+```
+
+The optional [`RoundingMode`](:obj:`RoundingMode`) argument will change how the number gets
+rounded.
+
+`round(T, x, [r::RoundingMode])` converts the result to type `T`, throwing an
+[`InexactError`](:exc:`InexactError`) if the value is not representable.
+
+`round(x, digits)` rounds to the specified number of digits after the decimal place (or
+before if negative). `round(x, digits, base)` rounds using a base other than 10.
+
+```jldoctest
+julia> round(pi, 2)
+3.14
+
+julia> round(pi, 3, 2)
+3.125
+```
+
+**note**
+
+Rounding to specified digits in bases other than 2 can be inexact when operating on binary
+floating point numbers. For example, the `Float64` value represented by `1.15` is actually
+*less* than 1.15, yet will be rounded to 1.2.
+
+```jldoctest
+julia> x = 1.15
+1.15
+
+julia> @sprintf "%.20f" x
+"1.14999999999999991118"
+
+julia> x < 115//100
+true
+
+julia> round(x, 1)
+1.2
+```
+"""
+round(T::Type, x)
+
+"""
+    round(z, RoundingModeReal, RoundingModeImaginary)
+
+Returns the nearest integral value of the same type as the complex-valued `z` to `z`,
+breaking ties using the specified [`RoundingMode`](:obj:`RoundingMode`)s. The first
+[`RoundingMode`](:obj:`RoundingMode`) is used for rounding the real components while the
+second is used for rounding the imaginary components.
+"""
+round(z::Real, ::Type{RoundingMode}, ::Type{RoundingMode})
+
+"""
+    strwidth(s)
+
+Gives the number of columns needed to print a string.
+"""
+strwidth
+
+"""
+    function_module(f::Function, types) -> Module
+
+Determine the module containing a given definition of a generic function.
+"""
+function_module
+
+"""
+    hex(n, [pad])
+
+Convert an integer to a hexadecimal string, optionally specifying a number of digits to pad to.
+"""
+hex
+
+"""
+    workspace()
+
+Replace the top-level module (`Main`) with a new one, providing a clean workspace. The
+previous `Main` module is made available as `LastMain`. A previously-loaded package can be
+accessed using a statement such as `using LastMain.Package`.
+
+This function should only be used interactively.
+"""
+workspace
+
+"""
+    tempdir()
+
+Obtain the path of a temporary directory (possibly shared with other processes).
+"""
+tempdir
+
+"""
+    reduce(op, v0, itr)
+
+Reduce the given collection `ìtr` with the given binary operator `op`. `v0` must be a
+neutral element for `op` that will be returned for empty collections. It is unspecified
+whether `v0` is used for non-empty collections.
+
+Reductions for certain commonly-used operators have special implementations which should be
+used instead: `maximum(itr)`, `minimum(itr)`, `sum(itr)`, `prod(itr)`, `any(itr)`,
+`all(itr)`.
+
+The associativity of the reduction is implementation dependent. This means that you can't
+use non-associative operations like `-` because it is undefined whether `reduce(-,[1,2,3])`
+should be evaluated as `(1-2)-3` or `1-(2-3)`. Use `foldl` or `foldr` instead for guaranteed
+left or right associativity.
+
+Some operations accumulate error, and parallelism will also be easier if the reduction can
+be executed in groups. Future versions of Julia might change the algorithm. Note that the
+elements are not reordered if you use an ordered collection.
+"""
+reduce(op, v0, itr)
+
+"""
+    reduce(op, itr)
+
+Like `reduce(op, v0, itr)`. This cannot be used with empty collections, except for some
+special cases (e.g. when `op` is one of `+`, `*`, `max`, `min`, `&`, `|`) when Julia can
+determine the neutral element of `op`.
+"""
+reduce(op, itr)
+
+"""
+    .>=(x, y)
+    .≥(x,y)
+
+Element-wise greater-than-or-equals comparison operator.
+"""
+Base.(:(.>=))
+
+"""
+    stdm(v, m)
+
+Compute the sample standard deviation of a vector `v` with known mean `m`. Note: Julia does
+not ignore `NaN` values in the computation.
+"""
+stdm
+
+"""
+    mv(src::AbstractString,dst::AbstractString; remove_destination::Bool=false)
+
+Move the file, link, or directory from `src` to `dst`. `remove_destination=true` will first
+remove an existing `dst`.
+"""
+mv
+
+"""
+    erfi(x)
+
+Compute the imaginary error function of `x`, defined by ``-i \\operatorname{erf}(ix)``.
+"""
+erfi
+
+"""
+    floor([T,] x, [digits, [base]])
+
+`floor(x)` returns the nearest integral value of the same type as `x` that is less than or
+equal to `x`.
+
+`floor(T, x)` converts the result to type `T`, throwing an `InexactError` if the value is
+not representable.
+
+`digits` and `base` work as for [`round`](:func:`round`).
+"""
+floor
+
+"""
+    tril!(M)
+
+Lower triangle of a matrix, overwriting `M` in the process.
+"""
+tril!(M)
+
+"""
+    tril!(M, k)
+
+Returns the lower triangle of `M` starting from the `k`th superdiagonal, overwriting `M` in
+the process.
+"""
+tril!(M, k)
+
+"""
+    divrem(x, y)
+
+The quotient and remainder from Euclidean division. Equivalent to `(div(x,y), rem(x,y))` or
+`(x÷y, x%y)`.
+"""
+divrem
+
+"""
+    ErrorException(msg)
+
+Generic error type. The error message, in the `.msg` field, may provide more specific details.
+"""
+ErrorException
+
+"""
+    reverse(v [, start=1 [, stop=length(v) ]] )
+
+Return a copy of `v` reversed from start to stop.
+"""
+reverse
+
+"""
+    reverse(s::AbstractString) -> AbstractString
+
+Reverses a string.
+"""
+reverse(s::AbstractString)
+
+"""
+    reverse!(v [, start=1 [, stop=length(v) ]]) -> v
+
+In-place version of [`reverse`](:func:`reverse`).
+"""
+reverse!
+
+"""
+    flipdim(A, d)
+
+Reverse `A` in dimension `d`.
+"""
+flipdim
+
+"""
+    num(x)
+
+Numerator of the rational representation of `x`.
+"""
+num
+
+"""
+    eachindex(A...)
+
+Creates an iterable object for visiting each index of an AbstractArray `A` in an efficient
+manner. For array types that have opted into fast linear indexing (like `Array`), this is
+simply the range `1:length(A)`. For other array types, this returns a specialized Cartesian
+range to efficiently index into the array with indices specified for every dimension. For
+other iterables, including strings and dictionaries, this returns an iterator object
+supporting arbitrary index types (e.g. unevenly spaced or non-integer indices).
+
+Example for a sparse 2-d array:
+
+```jldoctest
+julia> A = sparse([1, 1, 2], [1, 3, 1], [1, 2, -5])
+2x3 sparse matrix with 3 Int64 entries:
+        [1, 1]  =  1
+        [2, 1]  =  -5
+        [1, 3]  =  2
+
+julia> for iter in eachindex(A)
+           @show iter.I[1], iter.I[2]
+           @show A[iter]
+       end
+(iter.I[1],iter.I[2]) = (1,1)
+A[iter] = 1
+(iter.I[1],iter.I[2]) = (2,1)
+A[iter] = -5
+(iter.I[1],iter.I[2]) = (1,2)
+A[iter] = 0
+(iter.I[1],iter.I[2]) = (2,2)
+A[iter] = 0
+(iter.I[1],iter.I[2]) = (1,3)
+A[iter] = 2
+(iter.I[1],iter.I[2]) = (2,3)
+A[iter] = 0
+```
+
+If you supply more than one `AbstractArray` argument, `eachindex` will create an
+iterable object that is fast for all arguments (a `UnitRange` if all inputs have fast
+linear indexing, a CartesianRange otherwise).  If the arrays have different sizes and/or
+dimensionalities, `eachindex` returns an iterable that spans the largest range along each
+dimension.
+"""
+eachindex
+
+"""
+    .<(x, y)
+
+Element-wise less-than comparison operator.
+"""
+Base.(:(.<))
+
+"""
+    UndefRefError()
+
+The item or field is not defined for the given object.
+"""
+UndefRefError
+
+"""
+    bessely1(x)
+
+Bessel function of the second kind of order 1, ``Y_1(x)``.
+"""
+bessely1
+
+"""
+    cumprod(A, [dim])
+
+Cumulative product along a dimension `dim` (defaults to 1). See also
+[`cumprod!`](:func:`cumprod!`) to use a preallocated output array, both for performance and
+to control the precision of the output (e.g. to avoid overflow).
+"""
+cumprod
+
+"""
+    besseljx(nu, x)
+
+Scaled Bessel function of the first kind of order `nu`, ``J_\\nu(x) e^{- | \\operatorname{Im}(x) |}``.
+"""
+besseljx
+
+"""
+    print(x)
+
+Write (to the default output stream) a canonical (un-decorated) text representation of a
+value if there is one, otherwise call `show`. The representation used by `print` includes
+minimal formatting and tries to avoid Julia-specific details.
+"""
+print
+
+"""
+    filt(b, a, x, [si])
+
+Apply filter described by vectors `a` and `b` to vector `x`, with an optional initial filter
+state vector `si` (defaults to zeros).
+"""
+filt
+
+"""
+    indexpids(S::SharedArray)
+
+Returns the index of the current worker into the `pids` vector, i.e., the list of workers
+mapping the SharedArray
+"""
+indexpids
+
+"""
+    remotecall_wait(func, id, args...)
+
+Perform `wait(remotecall(...))` in one message.
+"""
+remotecall_wait
+
+"""
+    append!(collection, collection2) -> collection.
+
+Add the elements of `collection2` to the end of `collection`.
+
+```jldoctest
+julia> append!([1],[2,3])
+3-element Array{Int64,1}:
+ 1
+ 2
+ 3
+```
+
+```jldoctest
+julia> append!([1, 2, 3], [4, 5, 6])
+6-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+```
+
+Use [`push!`](:func:`push!`) to add individual items to `collection` which are not already
+themselves in another collection. The result is of the preceding example is equivalent to
+`push!([1, 2, 3], 4, 5, 6)`.
+"""
+append!
+
+"""
+    find(A)
+
+Return a vector of the linear indexes of the non-zeros in `A` (determined by `A[i]!=0`). A
+common use of this is to convert a boolean array to an array of indexes of the `true`
+elements.
+"""
+find(A)
+
+"""
+    find(f,A)
+
+Return a vector of the linear indexes of `A` where `f` returns `true`.
+"""
+find(f, A)
+
+"""
+    ctranspose(A)
+
+The conjugate transposition operator (`'`).
+"""
+ctranspose
+
+"""
+    skip(s, offset)
+
+Seek a stream relative to the current position.
+"""
+skip
+
+"""
+    lu(A) -> L, U, p
+
+Compute the LU factorization of `A`, such that `A[p,:] = L*U`.
+"""
+lu
+
+"""
+    @task
+
+Wrap an expression in a `Task` without executing it, and return the `Task`. This only
+creates a task, and does not run it.
+"""
+:@task
+
+"""
+    fld(x, y)
+
+Largest integer less than or equal to `x/y`.
+"""
+fld
+
+"""
+    indmax(itr) -> Integer
+
+Returns the index of the maximum element in a collection.
+"""
+indmax
+
+"""
+    writecsv(filename, A)
+
+Equivalent to `writedlm` with `delim` set to comma.
+"""
+writecsv
+
+"""
+    wstring(s)
+
+This is a synonym for either `utf32(s)` or `utf16(s)`, depending on whether `Cwchar_t` is 32
+or 16 bits, respectively. The synonym `WString` for `UTF32String` or `UTF16String` is also
+provided.
+"""
+wstring
+
+"""
+    withenv(f::Function, kv::Pair...)
+
+Execute `f()` in an environment that is temporarily modified (not replaced as in `setenv`)
+by zero or more `"var"=>val` arguments `kv`. `withenv` is generally used via the
+`withenv(kv...) do ... end` syntax. A value of `nothing` can be used to temporarily unset an
+environment variable (if it is set). When `withenv` returns, the original environment has
+been restored.
+"""
+withenv
+
+"""
+    setdiff!(s, iterable)
+
+Remove each element of `iterable` from set `s` in-place.
+"""
+setdiff!
+
+"""
+    EOFError()
+
+No more data was available to read from a file or stream.
+"""
+EOFError
+
+"""
+    isascii(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character belongs to the ASCII character set, or whether this is true for
+all elements of a string.
+"""
+isascii
+
+"""
+    ucfirst(string)
+
+Returns `string` with the first character converted to uppercase.
+"""
+ucfirst
+
+"""
+    copysign(x, y)
+
+Return `x` such that it has the same sign as `y`
+"""
+copysign
+
+"""
+    getaddrinfo(host)
+
+Gets the IP address of the `host` (may have to do a DNS lookup)
+"""
+getaddrinfo
+
+"""
+    @show
+
+Show an expression and result, returning the result.
+"""
+:@show
+
+"""
+    showcompact(x)
+
+
+Show a more compact representation of a value. This is used for printing array elements. If
+a new type has a different compact representation,
+it should test `Base.limit_output(io)` in its normal `show` method.
+"""
+showcompact
+
+"""
+    isleaftype(T)
+
+Determine whether `T` is a concrete type that can have instances, meaning its only subtypes
+are itself and `None` (but `T` itself is not `None`).
+"""
+isleaftype
+
+"""
+    string(xs...)
+
+Create a string from any values using the `print` function.
+"""
+string
+
+"""
+    erfc(x)
+
+Compute the complementary error function of `x`, defined by ``1 - \\operatorname{erf}(x)``.
+"""
+erfc
+
+"""
+    prevfloat(f) -> AbstractFloat
+
+Get the previous floating point number in lexicographic order.
+"""
+prevfloat
+
+"""
+    rest(iter, state)
+
+An iterator that yields the same elements as `iter`, but starting at the given `state`.
+"""
+rest
+
+"""
+    getfield(value, name::Symbol)
+
+Extract a named field from a `value` of composite type. The syntax `a.b` calls
+`getfield(a, :b)`, and the syntax `a.(b)` calls `getfield(a, b)`.
+"""
+getfield
+
+"""
+    utf8(::Array{UInt8,1})
+
+Create a UTF-8 string from a byte array.
+"""
+utf8(::Vector{UInt8})
+
+"""
+    utf8(::Ptr{UInt8}, [length])
+
+Create a UTF-8 string from the address of a C (0-terminated) string encoded in UTF-8. A copy
+is made; the ptr can be safely freed. If `length` is specified, the string does not have to
+be 0-terminated.
+"""
+utf8(::Ptr{UInt8}, length::Int = 1)
+
+"""
+    utf8(s)
+
+Convert a string to a contiguous UTF-8 string (all characters must be valid UTF-8 characters).
+"""
+utf8(s)
+
+"""
+    hvcat(rows::Tuple{Vararg{Int}}, values...)
+
+Horizontal and vertical concatenation in one call. This function is called for block matrix
+syntax. The first argument specifies the number of arguments to concatenate in each block
+row.
+
+```jldoctest
+julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
+(1,2,3,4,5,6)
+
+julia> [a b c; d e f]
+2x3 Array{Int64,2}:
+ 1  2  3
+ 4  5  6
+
+julia> hvcat((3,3), a,b,c,d,e,f)
+2x3 Array{Int64,2}:
+ 1  2  3
+ 4  5  6
+
+julia> [a b;c d; e f]
+3x2 Array{Int64,2}:
+ 1  2
+ 3  4
+ 5  6
+
+julia> hvcat((2,2,2), a,b,c,d,e,f)
+3x2 Array{Int64,2}:
+ 1  2
+ 3  4
+ 5  6
+```
+
+If the first argument is a single integer `n`, then all block rows are assumed to have `n`
+block columns.
+"""
+hvcat
+
+"""
+    besselj1(x)
+
+Bessel function of the first kind of order 1, ``J_1(x)``.
+"""
+besselj1
+
+"""
+    sinpi(x)
+
+Compute ``\\sin(\\pi x)`` more accurately than `sin(pi*x)`, especially for large `x`.
+"""
+sinpi
+
+"""
+    select!(v, k, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Partially sort the vector `v` in place, according to the order specified by `by`, `lt` and
+`rev` so that the value at index `k` (or range of adjacent values if `k` is a range) occurs
+at the position where it would appear if the array were fully sorted via a non-stable
+algorithm. If `k` is a single index, that value is returned; if `k` is a range, an array of
+values at those indices is returned. Note that `select!` does not fully sort the input
+array.
+"""
+select!
+
+"""
+    maximum!(r, A)
+
+Compute the maximum value of `A` over the singleton dimensions of `r`, and write results to `r`.
+"""
+maximum!
+
+"""
+    prod(itr)
+
+Returns the product of all elements of a collection.
+"""
+prod(itr)
+
+"""
+    prod(A, dims)
+
+Multiply elements of an array over the given dimensions.
+"""
+prod(A, dims)
+
+"""
+    Base.linearindexing(A)
+
+`linearindexing` defines how an AbstractArray most efficiently accesses its elements. If
+`Base.linearindexing(A)` returns `Base.LinearFast()`, this means that linear indexing with
+only one index is an efficient operation. If it instead returns `Base.LinearSlow()` (by
+default), this means that the array intrinsically accesses its elements with indices
+specified for every dimension. Since converting a linear index to multiple indexing
+subscripts is typically very expensive, this provides a traits-based mechanism to enable
+efficient generic code for all array types.
+
+An abstract array subtype `MyArray` that wishes to opt into fast linear indexing behaviors
+should define `linearindexing` in the type-domain:
+
+    Base.linearindexing{T<:MyArray}(::Type{T}) = Base.LinearFast()
+"""
+Base.linearindexing
+
+"""
+    isqrt(n)
+
+Integer square root: the largest integer `m` such that `m*m <= n`.
+"""
+isqrt
+
+"""
+    log1p(x)
+
+Accurate natural logarithm of `1+x`. Throws `DomainError` for `Real` arguments less than -1.
+
+There is an experimental variant in the `Base.Math.JuliaLibm` module, which is typically
+faster and more accurate.
+"""
+log1p
+
+"""
+    flipsign(x, y)
+
+Return `x` with its sign flipped if `y` is negative. For example `abs(x) = flipsign(x,x)`.
+"""
+flipsign
+
+"""
+    lbeta(x, y)
+
+Natural logarithm of the absolute value of the beta function ``\\log(|\\operatorname{B}(x,y)|)``.
+"""
+lbeta
+
+"""
+    randstring([rng,] len=8)
+
+Create a random ASCII string of length `len`, consisting of upper- and
+lower-case letters and the digits 0-9. The optional `rng` argument
+specifies a random number generator, see [Random Numbers](:ref:`Random Numbers <random-numbers>`).
+"""
+randstring
+
+"""
+    Float64(x [, mode::RoundingMode])
+
+Create a Float64 from `x`. If `x` is not exactly representable then `mode` determines how
+`x` is rounded.
+
+```jldoctest
+julia> Float64(pi, RoundDown)
+3.141592653589793
+
+julia> Float64(pi, RoundUp)
+3.1415926535897936
+```
+
+See `rounding` for available rounding modes.
+"""
+Float64
+
+"""
+    function_name(f::Function) -> Symbol
+
+Get the name of a generic `Function` as a symbol, or `:anonymous`.
+"""
+function_name
+
+"""
+```
+addprocs(n::Integer; exeflags=``) -> List of process identifiers
+```
+
+Launches workers using the in-built `LocalManager` which only launches workers on the
+local host. This can be used to take advantage of multiple cores. `addprocs(4)` will add 4
+processes on the local machine.
+"""
+addprocs(n::Integer)
+
+"""
+    addprocs() -> List of process identifiers
+
+Equivalent to `addprocs(CPU_CORES)`
+
+Note that workers do not run a `.juliarc.jl` startup script, nor do they synchronize their
+global state (such as global variables, new method definitions, and loaded modules) with any
+of the other running processes.
+"""
+addprocs()
+
+"""
+```
+addprocs(machines; keyword_args...) -> List of process identifiers
+```
+
+Add processes on remote machines via SSH. Requires julia to be installed in the same
+location on each node, or to be available via a shared file system.
+
+`machines` is a vector of machine specifications.  Worker are started for each specification.
+
+A machine specification is either a string `machine_spec` or a tuple - `(machine_spec, count)`.
+
+`machine_spec` is a string of the form `[user@]host[:port] [bind_addr[:port]]`. `user` defaults
+to current user, `port` to the standard ssh port. If `[bind_addr[:port]]` is specified, other
+workers will connect to this worker at the specified `bind_addr` and `port`.
+
+`count` is the number of workers to be launched on the specified host. If specified as `:auto`
+it will launch as many workers as the number of cores on the specific host.
+
+
+Keyword arguments:
+
+* `tunnel`: if `true` then SSH tunneling will be used to connect to the worker from the
+            master process. Default is `false`.
+
+* `sshflags`: specifies additional ssh options, e.g.
+
+    sshflags=`-i /home/foo/bar.pem`
+
+* `max_parallel`: specifies the maximum number of workers connected to in parallel at a host.
+                  Defaults to 10.
+
+* `dir`: specifies the working directory on the workers. Defaults to the host's current
+         directory (as found by `pwd()`)
+
+* `exename`: name of the julia executable. Defaults to `"\$JULIA_HOME/julia"` or
+             `"\$JULIA_HOME/julia-debug"` as the case may be.
+
+* `exeflags`: additional flags passed to the worker processes.
+
+* `topology`: Specifies how the workers connect to each other. Sending a message
+            between unconnected workers results in an error.
+
+  + `topology=:all_to_all`  :  All processes are connected to each other.
+                      This is the default.
+
+  + `topology=:master_slave`  :  Only the driver process, i.e. pid 1 connects to the
+                        workers. The workers do not connect to each other.
+
+  + `topology=:custom`  :  The `launch` method of the cluster manager specifes the
+                  connection topology via fields `ident` and `connect_idents` in
+                  `WorkerConfig`. A worker with a cluster manager identity `ident`
+                  will connect to all workers specified in `connect_idents`.
+
+
+Environment variables :
+
+If the master process fails to establish a connection with a newly launched worker within
+60.0 seconds, the worker treats it a fatal situation and terminates. This timeout can be
+controlled via environment variable `JULIA_WORKER_TIMEOUT`. The value of
+`JULIA_WORKER_TIMEOUT` on the master process, specifies the number of seconds a newly
+launched worker waits for connection establishment.
+"""
+addprocs(machines)
+
+"""
+    addprocs(manager::ClusterManager; kwargs...) -> List of process identifiers
+
+Launches worker processes via the specified cluster manager.
+
+For example Beowulf clusters are  supported via a custom cluster manager implemented in
+package `ClusterManagers`.
+
+The number of seconds a newly launched worker waits for connection establishment from the
+master can be specified via variable `JULIA_WORKER_TIMEOUT` in the worker process's
+environment. Relevant only when using TCP/IP as transport.
+"""
+addprocs(manager::ClusterManager)
+
+"""
+    mkpath(path, [mode])
+
+Create all directories in the given `path`, with permissions `mode`. `mode` defaults to
+`0o777`, modified by the current file creation mask.
+"""
+mkpath
+
+"""
+    besselix(nu, x)
+
+Scaled modified Bessel function of the first kind of order `nu`, ``I_\\nu(x) e^{- | \\operatorname{Re}(x) |}``.
+"""
+besselix
+
+"""
+    union(s1,s2...)
+    ∪(s1,s2...)
+
+Construct the union of two or more sets. Maintains order with arrays.
+"""
+union
+
+"""
+    lstat(file)
+
+Like stat, but for symbolic links gets the info for the link itself rather than the file it
+refers to. This function must be called on a file path rather than a file object or a file
+descriptor.
+"""
+lstat
+
+"""
+    mapfoldl(f, op, v0, itr)
+
+Like [`mapreduce`](:func:`mapreduce`), but with guaranteed left associativity. `v0` will be
+used exactly once.
+"""
+mapfoldl(f, op, v0, itr)
+
+"""
+    mapfoldl(f, op, itr)
+
+Like `mapfoldl(f, op, v0, itr)`, but using the first element of `itr` as `v0`. In general,
+this cannot be used with empty collections (see `reduce(op, itr)`).
+"""
+mapfoldl(f, op, itr)
+
+"""
+    realmax(T)
+
+The highest finite value representable by the given floating-point DataType `T`.
+"""
+realmax
+
+"""
+    takebuf_string(b::IOBuffer)
+
+Obtain the contents of an `IOBuffer` as a string, without copying. Afterwards, the IOBuffer
+is reset to its initial state.
+"""
+takebuf_string
+
+"""
+    pipeline(from, to, ...)
+
+Create a pipeline from a data source to a destination. The source and destination can be
+commands, I/O streams, strings, or results of other `pipeline` calls. At least one argument
+must be a command. Strings refer to filenames. When called with more than two arguments,
+they are chained together from left to right. For example `pipeline(a,b,c)` is equivalent to
+`pipeline(pipeline(a,b),c)`. This provides a more concise way to specify multi-stage
+pipelines.
+
+**Examples**:
+
+```julia
+run(pipeline(`ls`, `grep xyz`))
+run(pipeline(`ls`, "out.txt"))
+run(pipeline("out.txt", `grep xyz`))
+```
+"""
+pipeline(from, to, rest...)
+
+"""
+    pipeline(command; stdin, stdout, stderr, append=false)
+
+Redirect I/O to or from the given `command`. Keyword arguments specify which of the
+command's streams should be redirected. `append` controls whether file output appends to the
+file. This is a more general version of the 2-argument `pipeline` function.
+`pipeline(from, to)` is equivalent to `pipeline(from, stdout=to)` when `from` is a command,
+and to `pipe(to, stdin=from)` when `from` is another kind of data source.
+
+**Examples**:
+
+```julia
+run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
+run(pipeline(`update`, stdout="log.txt", append=true))
+```
+"""
+pipeline(command)
+
+"""
+    serialize(stream, value)
+
+Write an arbitrary value to a stream in an opaque format, such that it can be read back by
+`deserialize`. The read-back value will be as identical as possible to the original. In
+general, this process will not work if the reading and writing are done by different
+versions of Julia, or an instance of Julia with a different system image. `Ptr` values are
+serialized as all-zero bit patterns (`NULL`).
+"""
+serialize
+
+"""
+    sum(itr)
+
+Returns the sum of all elements in a collection.
+"""
+sum(itr)
+
+"""
+    sum(A, dims)
+
+Sum elements of an array over the given dimensions.
+"""
+sum(A, dims)
+
+"""
+    sum(f, itr)
+
+Sum the results of calling function `f` on each element of `itr`.
+"""
+sum(f::Function, itr)
+
+"""
+    typemin(T)
+
+The lowest value representable by the given (real) numeric DataType `T`.
+"""
+typemin
+
+"""
+    call(x, args...)
+
+If `x` is not a `Function`, then `x(args...)` is equivalent to `call(x, args...)`. This
+means that function-like behavior can be added to any type by defining new `call` methods.
+"""
+call
+
+"""
+    countfrom(start=1, step=1)
+
+An iterator that counts forever, starting at `start` and incrementing by `step`.
+"""
+countfrom
+
+"""
+    eof(stream) -> Bool
+
+Tests whether an I/O stream is at end-of-file. If the stream is not yet exhausted, this
+function will block to wait for more data if necessary, and then return `false`. Therefore
+it is always safe to read one byte after seeing `eof` return `false`. `eof` will return
+`false` as long as buffered data is still available, even if the remote end of a connection
+is closed.
+"""
+eof
+
+"""
+    mktempdir([parent=tempdir()])
+
+Create a temporary directory in the `parent` directory and return its path.
+"""
+mktempdir()
+
+"""
+    mktempdir(f::Function, [parent=tempdir()])
+
+Apply the function `f` to the result of `mktempdir(parent)` and remove the temporary
+directory upon completion.
+"""
+mktempdir(f::Function)
+
+"""
+    tril(M)
+
+Lower triangle of a matrix.
+"""
+tril(M)
+
+"""
+    tril(M, k)
+
+Returns the lower triangle of `M` starting from the `k`th superdiagonal.
+"""
+tril(M,k)
+
+"""
+    @edit
+
+Evaluates the arguments to the function call, determines their types, and calls the `edit`
+function on the resulting expression.
+"""
+:@edit
+
+"""
+    subtypes(T::DataType)
+
+Return a list of immediate subtypes of DataType `T`. Note that all currently loaded subtypes
+are included, including those not visible in the current module.
+"""
+subtypes
+
+"""
+    digits([T], n, [base], [pad])
+
+Returns an array with element type `T` (default `Int`) of the digits of `n` in the given
+base, optionally padded with zeros to a specified size. More significant digits are at
+higher indexes, such that `n == sum([digits[k]*base^(k-1) for k=1:length(digits)])`.
+"""
+digits
+
+"""
+    bytes2hex(bin_arr::Array{UInt8, 1})
+
+Convert an array of bytes to its hexadecimal representation. All characters are in
+lower-case. Returns an `ASCIIString`.
+"""
+bytes2hex
+
+"""
+    unlock(l::ReentrantLock)
+
+Releases ownership of the lock by the current task. If the lock had been acquired before, it
+just decrements an internal counter and returns immediately.
+"""
+unlock
+
+"""
+    BigFloat(x)
+
+Create an arbitrary precision floating point number. `x` may be an `Integer`, a `Float64` or
+a `BigInt`. The usual mathematical operators are defined for this type, and results are
+promoted to a `BigFloat`.
+
+Note that because decimal literals are converted to floating point numbers when parsed,
+`BigFloat(2.1)` may not yield what you expect. You may instead prefer to initialize
+constants from strings via [`parse`](:func:`parse`), or using the `big` string literal.
+
+```jldoctest
+julia> BigFloat(2.1)
+2.100000000000000088817841970012523233890533447265625000000000000000000000000000
+
+julia> big"2.1"
+2.099999999999999999999999999999999999999999999999999999999999999999999999999986
+```
+"""
+BigFloat
+
+"""
+    xcorr(u,v)
+
+Compute the cross-correlation of two vectors.
+"""
+xcorr
+
+"""
+    typeof(x)
+
+Get the concrete type of `x`.
+"""
+typeof
+
+"""
+    drop(iter, n)
+
+An iterator that generates all but the first `n` elements of `iter`.
+"""
+drop
+
+"""
+    acsc(x)
+
+Compute the inverse cosecant of `x`, where the output is in radians
+"""
+acsc
+
+"""
+    log(x)
+
+Compute the natural logarithm of `x`. Throws `DomainError` for negative `Real` arguments.
+Use complex negative arguments to obtain complex results.
+
+There is an experimental variant in the `Base.Math.JuliaLibm` module, which is typically
+faster and more accurate.
+"""
+log(x)
+
+"""
+    log(b,x)
+
+Compute the base `b` logarithm of `x`. Throws `DomainError` for negative `Real` arguments.
+"""
+log(b, x)
+
+"""
+    trunc([T,] x, [digits, [base]])
+
+`trunc(x)` returns the nearest integral value of the same type as `x` whose absolute value
+is less than or equal to `x`.
+
+`trunc(T, x)` converts the result to type `T`, throwing an `InexactError` if the value is
+not representable.
+
+`digits` and `base` work as for [`round`](:func:`round`).
+"""
+trunc
+
+"""
+    @less
+
+Evaluates the arguments to the function call, determines their types, and calls the `less`
+function on the resulting expression.
+"""
+:@less
+
+"""
+    broadcast_function(f)
+
+Returns a function `broadcast_f` such that
+`broadcast_function(f)(As...) === broadcast(f, As...)`. Most useful in the form
+`const broadcast_f = broadcast_function(f)`.
+"""
+broadcast_function
+
+"""
+    unsafe_convert(T,x)
+
+Convert `x` to a value of type `T`
+
+In cases where `convert` would need to take a Julia object and turn it into a `Ptr`, this
+function should be used to define and perform that conversion.
+
+Be careful to ensure that a julia reference to `x` exists as long as the result of this
+function will be used. Accordingly, the argument `x` to this function should never be an
+expression, only a variable name or field reference. For example, `x=a.b.c` is acceptable,
+but `x=[a,b,c]` is not.
+
+The `unsafe` prefix on this function indicates that using the result of this function after
+the `x` argument to this function is no longer accessible to the program may cause undefined
+behavior, including program corruption or segfaults, at any later time.
+"""
+unsafe_convert
+
+"""
+    warn(msg)
+
+Display a warning. Argument `msg` is a string describing the warning to be displayed.
+"""
+warn
+
+"""
+    erfinv(x)
+
+Compute the inverse error function of a real `x`, defined by ``\\operatorname{erf}(\\operatorname{erfinv}(x)) = x``.
+"""
+erfinv
+
+"""
+    @async
+
+Like `@schedule`, `@async` wraps an expression in a `Task` and adds it to the local
+machine's scheduler queue. Additionally it adds the task to the set of items that the
+nearest enclosing `@sync` waits for. `@async` also wraps the expression in a `let x=x, y=y, ...`
+block to create a new scope with copies of all variables referenced in the expression.
+"""
+:@async
+
+"""
+    rotr90(A)
+
+Rotate matrix `A` right 90 degrees.
+"""
+rotr90(A)
+
+"""
+    rotr90(A, k)
+
+Rotate matrix `A` right 90 degrees an integer `k` number of times. If `k` is zero or a
+multiple of four, this is equivalent to a `copy`.
+"""
+rotr90(A, k)
+
+"""
+    readdir([dir]) -> Vector{ByteString}
+
+Returns the files and directories in the directory `dir` (or the current working directory if not given).
+"""
+readdir
+
+"""
+    seek(s, pos)
+
+Seek a stream to the given position.
+"""
+seek
+
+"""
+    acosd(x)
+
+Compute the inverse cosine of `x`, where the output is in degrees.
+"""
+acosd
+
+"""
+    triu(M)
+
+Upper triangle of a matrix.
+"""
+triu(M)
+
+"""
+    triu(M, k)
+
+Returns the upper triangle of `M` starting from the `k`th superdiagonal.
+"""
+triu(M, k)
+
+"""
+    instances(T::Type)
+
+Return a collection of all instances of the given type, if applicable. Mostly used for
+enumerated types (see `@enum`).
+"""
+instances
+
+"""
+    besselj0(x)
+
+Bessel function of the first kind of order 0, ``J_0(x)``.
+"""
+besselj0
+
+"""
+    erfcinv(x)
+
+Compute the inverse error complementary function of a real `x`, defined by
+``\\operatorname{erfc}(\\operatorname{erfcinv}(x)) = x``.
+"""
+erfcinv
+
+"""
+    minabs(itr)
+
+Compute the minimum absolute value of a collection of values.
+"""
+minabs(itr)
+
+"""
+    minabs(A, dims)
+
+Compute the minimum absolute values over given dimensions.
+"""
+minabs(A, dims)
+
+"""
+    popdisplay()
+    popdisplay(d::Display)
+
+Pop the topmost backend off of the display-backend stack, or the topmost copy of `d` in the
+second variant.
+"""
+popdisplay
+
+"""
+    readdlm(source, delim::Char, T::Type, eol::Char; header=false, skipstart=0, skipblanks=true, use_mmap, ignore_invalid_chars=false, quotes=true, dims, comments=true, comment_char='#')
+
+Read a matrix from the source where each line (separated by `eol`) gives one row, with
+elements separated by the given delimeter. The source can be a text file, stream or byte
+array. Memory mapped files can be used by passing the byte array representation of the
+mapped segment as source.
+
+If `T` is a numeric type, the result is an array of that type, with any non-numeric elements
+as `NaN` for floating-point types, or zero. Other useful values of `T` include
+`ASCIIString`, `AbstractString`, and `Any`.
+
+If `header` is `true`, the first row of data will be read as header and the tuple
+`(data_cells, header_cells)` is returned instead of only `data_cells`.
+
+Specifying `skipstart` will ignore the corresponding number of initial lines from the input.
+
+If `skipblanks` is `true`, blank lines in the input will be ignored.
+
+If `use_mmap` is `true`, the file specified by `source` is memory mapped for potential
+speedups. Default is `true` except on Windows. On Windows, you may want to specify `true` if
+the file is large, and is only read once and not written to.
+
+If `ignore_invalid_chars` is `true`, bytes in `source` with invalid character encoding will
+be ignored. Otherwise an error is thrown indicating the offending character position.
+
+If `quotes` is `true`, column enclosed within double-quote (") characters are allowed to
+contain new lines and column delimiters. Double-quote characters within a quoted field must
+be escaped with another double-quote.  Specifying `dims` as a tuple of the expected rows and
+columns (including header, if any) may speed up reading of large files.  If `comments` is
+`true`, lines beginning with `comment_char` and text following `comment_char` in any line
+are ignored.
+"""
+readdlm(source, delim, T, eol)
+
+"""
+    readdlm(source, delim::Char, eol::Char; options...)
+
+If all data is numeric, the result will be a numeric array. If some elements cannot be
+parsed as numbers, a cell array of numbers and strings is returned.
+"""
+readdlm(source, delim::Char, eol::Char)
+
+"""
+    readdlm(source, delim::Char, T::Type; options...)
+
+The end of line delimiter is taken as `n`.
+"""
+readdlm(source, delim::Char, T::Type)
+
+"""
+    readdlm(source, delim::Char; options...)
+
+The end of line delimiter is taken as `n`. If all data is numeric, the result will be a
+numeric array. If some elements cannot be parsed as numbers, a cell array of numbers and
+strings is returned.
+"""
+readdlm(source, delim::Char)
+
+"""
+    readdlm(source, T::Type; options...)
+
+The columns are assumed to be separated by one or more whitespaces. The end of line
+delimiter is taken as `n`.
+"""
+readdlm(source, T::Type)
+
+"""
+    readdlm(source; options...)
+
+The columns are assumed to be separated by one or more whitespaces. The end of line
+delimiter is taken as `n`. If all data is numeric, the result will be a numeric array. If
+some elements cannot be parsed as numbers, a cell array of numbers and strings is returned.
+"""
+readdlm(source)
+
+"""
+    filesize(path...)
+
+Equivalent to `stat(file).size`.
+"""
+filesize
+
+"""
+    sinc(x)
+
+Compute ``\\sin(\\pi x) / (\\pi x)`` if ``x \\neq 0``, and ``1`` if ``x = 0``.
+"""
+sinc
+
+"""
+    utf16(s)
+
+Create a UTF-16 string from a byte array, array of `UInt16`, or any other string type. (Data
+must be valid UTF-16. Conversions of byte arrays check for a byte-order marker in the first
+two bytes, and do not include it in the resulting string.)
+
+Note that the resulting `UTF16String` data is terminated by the NUL codepoint (16-bit zero),
+which is not treated as a character in the string (so that it is mostly invisible in Julia);
+this allows the string to be passed directly to external functions requiring NUL-terminated
+data. This NUL is appended automatically by the `utf16(s)` conversion function. If you have
+a `UInt16` array `A` that is already NUL-terminated valid UTF-16 data, then you can instead
+use `UTF16String(A)` to construct the string without making a copy of the data and treating
+the NUL as a terminator rather than as part of the string.
+"""
+utf16(s)
+
+"""
+    utf16(::Union{Ptr{UInt16},Ptr{Int16}} [, length])
+
+Create a string from the address of a NUL-terminated UTF-16 string. A copy is made; the
+pointer can be safely freed. If `length` is specified, the string does not have to be
+NUL-terminated.
+"""
+utf16(::Union{Ptr{UInt16},Ptr{Int16}}, length=?)
+
+"""
+    median(v[, region])
+
+Compute the median of whole array `v`, or optionally along the dimensions in `region`. For
+even number of elements no exact median element exists, so the result is equivalent to
+calculating mean of two median elements. `NaN` is returned if the data contains any `NaN`
+values. For applications requiring the handling of missing data, the `DataArrays` package is
+recommended.
+"""
+median
+
+"""
+    cglobal((symbol, library) [, type=Void])
+
+Obtain a pointer to a global variable in a C-exported shared library, specified exactly as
+in `ccall`. Returns a `Ptr{Type}`, defaulting to `Ptr{Void}` if no Type argument is
+supplied. The values can be read or written by `unsafe_load` or `unsafe_store!`,
+respectively.
+"""
+cglobal
+
+"""
+    one(x)
+
+Get the multiplicative identity element for the type of `x` (`x` can also specify the type
+itself). For matrices, returns an identity matrix of the appropriate size and type.
+"""
+one
+
+"""
+    rationalize([Type=Int,] x; tol=eps(x))
+
+Approximate floating point number `x` as a Rational number with components of the given
+integer type. The result will differ from `x` by no more than `tol`.
+"""
+rationalize
+
+"""
+    splice!(collection, index, [replacement]) -> item
+
+Remove the item at the given index, and return the removed item. Subsequent items are
+shifted down to fill the resulting gap. If specified, replacement values from an ordered
+collection will be spliced in place of the removed item.
+
+```jldoctest
+julia> A = [6, 5, 4, 3, 2, 1]; splice!(A, 5)
+2
+
+julia> A
+5-element Array{Int64,1}:
+ 6
+ 5
+ 4
+ 3
+ 1
+
+julia> splice!(A, 5, -1)
+1
+
+julia> A
+5-element Array{Int64,1}:
+  6
+  5
+  4
+  3
+ -1
+
+julia> splice!(A, 1, [-1, -2, -3])
+6
+
+julia> A
+7-element Array{Int64,1}:
+ -1
+ -2
+ -3
+  5
+  4
+  3
+ -1
+```
+
+To insert `replacement` before an index `n` without removing any items, use
+`splice!(collection, n:n-1, replacement)`.
+"""
+splice!(collection, index, replacement = ?)
+
+"""
+    splice!(collection, range, [replacement]) -> items
+
+Remove items in the specified index range, and return a collection containing the removed
+items. Subsequent items are shifted down to fill the resulting gap. If specified,
+replacement values from an ordered collection will be spliced in place of the removed items.
+
+To insert `replacement` before an index `n` without removing any items, use
+`splice!(collection, n:n-1, replacement)`.
+
+```jldoctest
+julia> splice!(A, 4:3, 2)
+0-element Array{Int64,1}
+
+julia> A
+8-element Array{Int64,1}:
+ -1
+ -2
+ -3
+  2
+  5
+  4
+  3
+ -1
+```
+"""
+splice!(collection, range::Range, replacement)
+
+"""
+    endof(collection) -> Integer
+
+Returns the last index of the collection.
+
+```jldoctest
+julia> endof([1,2,4])
+3
+```
+"""
+endof
+
+"""
+    isfifo(path) -> Bool
+
+Returns `true` if `path` is a FIFO, `false` otherwise.
+"""
+isfifo
+
+"""
+    Channel{T}(sz::Int)
+
+Constructs a `Channel` that can hold a maximum of `sz` objects of type `T`. `put!` calls on
+a full channel block till an object is removed with `take!`.
+
+Other constructors:
+
+- `Channel()` - equivalent to `Channel{Any}(32)`
+- `Channel(sz::Int)` equivalent to `Channel{Any}(sz)`
+"""
+Channel
+
+"""
+    next(iter, state) -> item, state
+
+For a given iterable object and iteration state, return the current item and the next iteration state.
+"""
+next
+
+"""
+    unshift!(collection, items...) -> collection
+
+Insert one or more `items` at the beginning of `collection`.
+
+```jldoctest
+  julia> unshift!([1, 2, 3, 4], 5, 6)
+  6-element Array{Int64,1}:
+   5
+   6
+   1
+   2
+   3
+   4
+```
+"""
+unshift!
+
+"""
+    log2(x)
+
+Compute the logarithm of `x` to base 2. Throws `DomainError` for negative `Real` arguments.
+"""
+log2
+
+"""
+    SymTridiagonal(d, du)
+
+Construct a real symmetric tridiagonal matrix from the diagonal and upper diagonal,
+respectively. The result is of type `SymTridiagonal` and provides efficient specialized
+eigensolvers, but may be converted into a regular matrix with [`full`](:func:`full`).
+"""
+SymTridiagonal
+
+"""
+    colon(start, [step], stop)
+
+Called by `:` syntax for constructing ranges.
+"""
+colon
+
+"""
+    Base64EncodePipe(ostream)
+
+Returns a new write-only I/O stream, which converts any bytes written to it into
+base64-encoded ASCII bytes written to `ostream`. Calling `close` on the `Base64Pipe` stream
+is necessary to complete the encoding (but does not close `ostream`).
+"""
+Base64EncodePipe
+
+"""
+    issetgid(path) -> Bool
+
+Returns `true` if `path` has the setgid flag set, `false` otherwise.
+"""
+issetgid
+
+"""
+    isnull(x)
+
+Is the `Nullable` object `x` null, i.e. missing a value?
+"""
+isnull
+
+"""
+    abs2(x)
+
+Squared absolute value of `x`.
+"""
+abs2
+
+"""
+    write(stream::IO, x)
+    write(filename::AbstractString, x)
+
+Write the canonical binary representation of a value to the given I/O stream or file.
+Returns the number of bytes written into the stream.
+
+You can write multiple values with the same :func:`write` call. i.e. the following are
+equivalent:
+
+    write(stream, x, y...)
+    write(stream, x) + write(stream, y...)
+"""
+write
+
+"""
+    sizehint!(s, n)
+
+Suggest that collection `s` reserve capacity for at least `n` elements. This can improve performance.
+"""
+sizehint!
+
+"""
+    ifelse(condition::Bool, x, y)
+
+Return `x` if `condition` is `true`, otherwise return `y`. This differs from `?` or `if` in
+that it is an ordinary function, so all the arguments are evaluated first. In some cases,
+using `ifelse` instead of an `if` statement can eliminate the branch in generated code and
+provide higher performance in tight loops.
+"""
+ifelse
+
+"""
+    ispow2(n) -> Bool
+
+Test whether `n` is a power of two.
+"""
+ispow2
+
+"""
+    vcat(A...)
+
+Concatenate along dimension 1.
+"""
+vcat
+
+"""
+    isgraph(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is printable, and not a space, or whether this is true for all
+elements of a string. Any character that would cause a printer to use ink should be
+classified with `isgraph(c)==true`.
+"""
+isgraph
+
+"""
+    OutOfMemoryError()
+
+An operation allocated too much memory for either the system or the garbage collector to
+handle properly.
+"""
+OutOfMemoryError
+
+"""
+    zip(iters...)
+
+For a set of iterable objects, returns an iterable of tuples, where the `i`th tuple contains
+the `i`th component of each input iterable.
+
+Note that [`zip`](:func:`zip`) is its own inverse: `collect(zip(zip(a...)...)) == collect(a)`.
+"""
+zip
+
+"""
+    SystemError(prefix::AbstractString, [errno::Int32])
+
+A system call failed with an error code (in the `errno` global variable).
+"""
+SystemError
+
+"""
+    binomial(n,k)
+
+Number of ways to choose `k` out of `n` items.
+"""
+binomial
+
+"""
+    rot180(A)
+
+Rotate matrix `A` 180 degrees.
+"""
+rot180(A)
+
+"""
+    rot180(A, k)
+
+Rotate matrix `A` 180 degrees an integer `k` number of times. If `k` is even, this is
+equivalent to a `copy`.
+"""
+rot180(A, k)
+
+"""
+    .<=(x, y)
+    .≤(x,y)
+
+Element-wise less-than-or-equals comparison operator.
+"""
+Base.(:(.<=))
+
+"""
+    checkbounds(array, indexes...)
+
+Throw an error if the specified indexes are not in bounds for the given array. Subtypes of
+`AbstractArray` should specialize this method if they need to provide custom bounds checking
+behaviors.
+"""
+checkbounds(array, indexes...)
+
+"""
+    checkbounds(::Type{Bool}, dimlength::Integer, index)
+
+Return a `Bool` describing if the given index is within the bounds of the given dimension
+length. Custom types that would like to behave as indices for all arrays can extend this
+method in order to provide a specialized bounds checking implementation.
+"""
+checkbounds(::Type{Bool}, ::Integer, index)
+
+"""
+    asec(x)
+
+Compute the inverse secant of `x`, where the output is in radians.
+"""
+asec
+
+"""
+    rank(M)
+
+Compute the rank of a matrix.
+"""
+rank
+
+"""
+    max(x, y, ...)
+
+Return the maximum of the arguments. Operates elementwise over arrays.
+"""
+max
+
+"""
+    versioninfo([verbose::Bool])
+
+Print information about the version of Julia in use. If the `verbose` argument is `true`,
+detailed system information is shown as well.
+"""
+versioninfo
+
+"""
+    DimensionMismatch([msg])
+
+The objects called do not have matching dimensionality. Optional argument `msg` is a
+descriptive error string.
+"""
+DimensionMismatch
+
+"""
+    take!(RemoteChannel)
+
+Fetch a value from a remote channel, also removing it in the processs.
+"""
+take!(::RemoteChannel)
+
+"""
+    take!(Channel)
+
+Removes and returns a value from a `Channel`. Blocks till data is available.
+"""
+take!(::Channel)
+
+"""
+    sort!(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Sort the vector `v` in place. `QuickSort` is used by default for numeric arrays while
+`MergeSort` is used for other arrays. You can specify an algorithm to use via the `alg`
+keyword (see Sorting Algorithms for available algorithms). The `by` keyword lets you provide
+a function that will be applied to each element before comparison; the `lt` keyword allows
+providing a custom "less than" function; use `rev=true` to reverse the sorting order. These
+options are independent and can be used together in all possible combinations: if both `by`
+and `lt` are specified, the `lt` function is applied to the result of the `by` function;
+`rev=true` reverses whatever ordering specified via the `by` and `lt` keywords.
+"""
+sort!
+
+"""
+    kill(p::Process, signum=SIGTERM)
+
+Send a signal to a process. The default is to terminate the process.
+"""
+kill(p::Process, signum=SIGTERM)
+
+"""
+    kill(manager::FooManager, pid::Int, config::WorkerConfig)
+
+Implemented by cluster managers. It is called on the master process, by `rmprocs`. It should
+cause the remote worker specified by `pid` to exit. `Base.kill(manager::ClusterManager.....)`
+executes a remote `exit()` on `pid`
+"""
+kill(manager, pid::Int, config::WorkerConfig)
+
+"""
+    sylvester(A, B, C)
+
+Computes the solution `X` to the Sylvester equation `AX + XB + C = 0`, where `A`, `B` and
+`C` have compatible dimensions and `A` and `-B` have no eigenvalues with equal real part.
+"""
+sylvester
+
+"""
+    broadcast!(f, dest, As...)
+
+Like `broadcast`, but store the result of `broadcast(f, As...)` in the `dest` array. Note
+that `dest` is only used to store the result, and does not supply arguments to `f` unless it
+is also listed in the `As`, as in `broadcast!(f, A, A, B)` to perform `A[:] = broadcast(f, A, B)`.
+"""
+broadcast!
+
+"""
+    cross(x, y)
+    ×(x,y)
+
+Compute the cross product of two 3-vectors.
+"""
+cross
+
+"""
+    strides(A)
+
+Returns a tuple of the memory strides in each dimension.
+"""
+strides
+
+"""
+    keys(collection)
+
+Return an iterator over all keys in a collection. `collect(keys(d))` returns an array of keys.
+"""
+keys
+
+"""
+    repeat(A, inner = Int[], outer = Int[])
+
+Construct an array by repeating the entries of `A`. The i-th element of `inner` specifies
+the number of times that the individual entries of the i-th dimension of `A` should be
+repeated. The i-th element of `outer` specifies the number of times that a slice along the
+i-th dimension of `A` should be repeated.
+"""
+repeat
+
+"""
+    ReentrantLock()
+
+Creates a reentrant lock. The same task can acquire the lock as many times as required. Each
+lock must be matched with an unlock.
+"""
+ReentrantLock
+
+"""
+    real(z)
+
+Return the real part of the complex number `z`.
+"""
+real
+
+"""
+    gperm(file)
+
+Like uperm but gets the permissions of the group owning the file.
+"""
+gperm
+
+"""
+    nb_available(stream)
+
+Returns the number of bytes available for reading before a read from this stream or buffer will block.
+"""
+nb_available
+
+"""
+    finalize(x)
+
+Immediately run finalizers registered for object `x`.
+"""
+finalize
+
+"""
+    rand([rng], [S], [dims...])
+
+Pick a random element or array of random elements from the set of values specified by `S`; `S` can be
+
+* an indexable collection (for example `1:n` or `['x','y','z']`), or
+* a type: the set of values to pick from is then equivalent to `typemin(S):typemax(S)` for
+  integers (this is not applicable to `BigInt`), and to ``[0, 1)`` for floating point numbers;
+
+`S` defaults to `Float64`.
+"""
+rand
+
+"""
+    bitpack(A::AbstractArray{T,N}) -> BitArray
+
+Converts a numeric array to a packed boolean array.
+"""
+bitpack
+
+"""
+    base(base, n, [pad])
+
+Convert an integer to a string in the given base, optionally specifying a number of digits
+to pad to. The base can be specified as either an integer, or as a `UInt8` array of
+character values to use as digit symbols.
+"""
+base
+
+"""
+    Timer(callback::Function, delay, repeat=0)
+
+Create a timer to call the given `callback` function. The `callback` is passed one argument,
+the timer object itself. The callback will be invoked after the specified initial `delay`,
+and then repeating with the given `repeat` interval. If `repeat` is `0`, the timer is only
+triggered once. Times are in seconds. A timer is stopped and has its resources freed by
+calling `close` on it.
+"""
+Timer(::Function,delay,repeat=0)
+
+"""
+    Timer(delay, repeat=0)
+
+Create a timer that wakes up tasks waiting for it (by calling `wait` on the timer object) at
+a specified interval.  Times are in seconds.  Waiting tasks are woken with an error when the
+timer is closed (by `close`). Use `isopen` to check whether a timer is still active.
+"""
+Timer(delay, repeat=0)
+
+"""
+    BoundsError([a],[i])
+
+An indexing operation into an array, `a`, tried to access an out-of-bounds element, `i`.
+"""
+BoundsError
+
+"""
+    disable_sigint(f::Function)
+
+Disable Ctrl-C handler during execution of a function, for calling external code that is not
+interrupt safe. Intended to be called using `do` block syntax as follows:
+
+    disable_sigint() do
+        # interrupt-unsafe code
+        ...
+    end
+"""
+disable_sigint
+
+"""
+    hist2d(M, e1, e2) -> (edge1, edge2, counts)
+
+Compute a "2d histogram" of a set of N points specified by N-by-2 matrix `M`. Arguments `e1`
+and `e2` are bins for each dimension, specified either as integer bin counts or vectors of
+bin edges. The result is a tuple of `edge1` (the bin edges used in the first dimension),
+`edge2` (the bin edges used in the second dimension), and `counts`, a histogram matrix of
+size `(length(edge1)-1, length(edge2)-1)`. Note: Julia does not ignore `NaN` values in the
+computation.
+"""
+hist2d
+
+"""
+    which(f, types)
+
+Returns the method of `f` (a `Method` object) that would be called for arguments of the given `types`.
+
+If `types` is an abstract type, then the method that would be called by `invoke` is returned.
+"""
+which(f, types)
+
+"""
+    which(symbol)
+
+Return the module in which the binding for the variable referenced by `symbol` was created.
+"""
+which(symbol)
+
+"""
+    conv2(u,v,A)
+
+2-D convolution of the matrix `A` with the 2-D separable kernel generated by the vectors `u`
+and `v`. Uses 2-D FFT algorithm.
+"""
+conv2(u, v, A)
+
+"""
+    conv2(B,A)
+
+2-D convolution of the matrix `B` with the matrix `A`. Uses 2-D FFT algorithm.
+"""
+conv2(B, A)
+
+"""
+    broadcast_getindex(A, inds...)
+
+Broadcasts the `inds` arrays to a common size like `broadcast`, and returns an array of the
+results `A[ks...]`, where `ks` goes over the positions in the broadcast.
+"""
+broadcast_getindex
+
+"""
+    findn(A)
+
+Return a vector of indexes for each dimension giving the locations of the non-zeros in `A`
+(determined by `A[i]!=0`).
+"""
+findn
+
+"""
+    invoke(f, (types...), args...)
+
+Invoke a method for the given generic function matching the specified types (as a tuple), on
+the specified arguments. The arguments must be compatible with the specified types. This
+allows invoking a method other than the most specific matching method, which is useful when
+the behavior of a more general definition is explicitly needed (often as part of the
+implementation of a more specific method of the same function).
+"""
+invoke
+
+"""
+    parse(str, start; greedy=true, raise=true)
+
+Parse the expression string and return an expression (which could later be passed to eval
+for execution). `start` is the index of the first character to start parsing. If `greedy` is
+`true` (default), `parse` will try to consume as much input as it can; otherwise, it will
+stop as soon as it has parsed a valid expression. Incomplete but otherwise syntactically
+valid expressions will return `Expr(:incomplete, "(error message)")`. If `raise` is `true`
+(default), syntax errors other than incomplete expressions will raise an error. If `raise`
+is `false`, `parse` will return an expression that will raise an error upon evaluation.
+"""
+parse(str, start)
+
+"""
+    parse(str; raise=true)
+
+Parse the expression string greedily, returning a single expression. An error is thrown if
+there are additional characters after the first expression. If `raise` is `true` (default),
+syntax errors will raise an error; otherwise, `parse` will return an expression that will
+raise an error upon evaluation.
+"""
+parse(str)
+
+"""
+    parse(type, str, [base])
+
+Parse a string as a number. If the type is an integer type, then a base can be specified
+(the default is 10). If the type is a floating point type, the string is parsed as a decimal
+floating point number. If the string does not contain a valid number, an error is raised.
+"""
+parse(T::Type, str, base=Int)
+
+"""
+    touch(path::AbstractString)
+
+Update the last-modified timestamp on a file to the current time.
+"""
+touch
+
+"""
+    bkfact!(A) -> BunchKaufman
+
+`bkfact!` is the same as [`bkfact`](:func:`bkfact`), but saves space by overwriting the
+input `A`, instead of creating a copy.
+"""
+bkfact!
+
+"""
+    ^(x, y)
+
+Exponentiation operator.
+"""
+Base.(:(^))(x, y)
+
+"""
+    ^(s, n)
+
+Repeat `n` times the string `s`. The `repeat` function is an alias to this operator.
+
+```jldoctest
+julia> "Test "^3
+"Test Test Test "
+```
+"""
+Base.(:(^))(s::AbstractString, n::Int)
+
+"""
+    position(s)
+
+Get the current position of a stream.
+"""
+position
+
+"""
+    selectperm(v, k, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Return a partial permutation of the the vector `v`, according to the order specified by
+`by`, `lt` and `rev`, so that `v[output]` returns the first `k` (or range of adjacent values
+if `k` is a range) values of a fully sorted version of `v`. If `k` is a single index
+(Integer), an array of the first `k` indices is returned; if `k` is a range, an array of
+those indices is returned. Note that the handling of integer values for `k` is different
+from `select` in that it returns a vector of `k` elements instead of just the `k` th
+element. Also note that this is equivalent to, but more efficient than, calling
+`sortperm(...)[k]`
+"""
+selectperm
+
+"""
+    isabspath(path::AbstractString) -> Bool
+
+Determines whether a path is absolute (begins at the root directory).
+"""
+isabspath
+
+"""
+    hex2bytes(s::ASCIIString)
+
+Convert an arbitrarily long hexadecimal string to its binary representation. Returns an
+`Array{UInt8,1}`, i.e. an array of bytes.
+"""
+hex2bytes
+
+"""
+    isdir(path) -> Bool
+
+Returns `true` if `path` is a directory, `false` otherwise.
+"""
+isdir
+
+"""
+    reinterpret(type, A)
+
+Change the type-interpretation of a block of memory. For example,
+`reinterpret(Float32, UInt32(7))` interprets the 4 bytes corresponding to `UInt32(7)` as a
+`Float32`. For arrays, this constructs an array with the same binary data as the given
+array, but with the specified element type.
+"""
+reinterpret
+
+"""
+    squeeze(A, dims)
+
+Remove the dimensions specified by `dims` from array `A`. Elements of `dims` must be unique
+and within the range `1:ndims(A)`.
+"""
+squeeze
+
+"""
+    ~(x)
+
+Bitwise not.
+"""
+~
+
+"""
+    hankelh1(nu, x)
+
+Bessel function of the third kind of order `nu`, ``H^{(1)}_\\nu(x)``.
+"""
+hankelh1
+
+"""
+    hessfact(A)
+
+Compute the Hessenberg decomposition of `A` and return a `Hessenberg` object. If `F` is the
+factorization object, the unitary matrix can be accessed with `F[:Q]` and the Hessenberg
+matrix with `F[:H]`. When `Q` is extracted, the resulting type is the `HessenbergQ` object,
+and may be converted to a regular matrix with [`full`](:func:`full`).
+"""
+hessfact
+
+"""
+    gcdx(x,y)
+
+Computes the greatest common (positive) divisor of `x` and `y` and their Bézout
+coefficients, i.e. the integer coefficients `u` and `v` that satisfy
+``ux+vy = d = gcd(x,y)``.
+
+```jldoctest
+julia> gcdx(12, 42)
+(6,-3,1)
+```
+
+```jldoctest
+julia> gcdx(240, 46)
+(2,-9,47)
+```
+
+**note**
+
+Bézout coefficients are *not* uniquely defined. `gcdx` returns the minimal Bézout
+coefficients that are computed by the extended Euclid algorithm. (Ref: D. Knuth, TAoCP, 2/e,
+p. 325, Algorithm X.) These coefficients `u` and `v` are minimal in the sense that
+``|u| < |\\frac y d`` and ``|v| < |\\frac x d``. Furthermore, the signs of `u` and `v` are
+chosen so that `d` is positive.
+"""
+gcdx
+
+"""
+    rem(x, y)
+    %(x, y)
+
+Remainder from Euclidean division, returning a value of the same sign as `x`, and smaller in
+magnitude than `y`. This value is always exact.
+
+```julia
+x == div(x,y)*y + rem(x,y)
+```
+"""
+rem
+
+"""
+    rotl90(A)
+
+Rotate matrix `A` left 90 degrees.
+"""
+rotl90(A)
+
+"""
+    rotl90(A, k)
+
+Rotate matrix `A` left 90 degrees an integer `k` number of times. If `k` is zero or a
+multiple of four, this is equivalent to a `copy`.
+"""
+rotl90(A, k)
+
+"""
+    info(msg)
+
+Display an informational message. Argument `msg` is a string describing the information to be displayed.
+"""
+info
+
+"""
+    eigmin(A)
+
+Returns the smallest eigenvalue of `A`.
+"""
+eigmin
+
+"""
+    acscd(x)
+
+Compute the inverse cosecant of `x`, where the output is in degrees.
+"""
+acscd
+
+"""
+    ltoh(x)
+
+Converts the endianness of a value from Little-endian to that used by the Host.
+"""
+ltoh
+
+"""
+    evalfile(path::AbstractString)
+
+Load the file using `include`, evaluate all expressions, and return the value of the last one.
+"""
+evalfile
+
+"""
+    success(command)
+
+Run a command object, constructed with backticks, and tell whether it was successful (exited
+with a code of 0). An exception is raised if the process cannot be started.
+"""
+success
+
+"""
+    sortperm!(ix, v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false,] [initialized=false])
+
+Like `sortperm`, but accepts a preallocated index vector `ix`.  If `initialized` is `false`
+(the default), ix is initialized to contain the values `1:length(v)`.
+
+See also [`sortperm`](:func:`sortperm`).
+"""
+sortperm!
+
+"""
+    isodd(x::Integer) -> Bool
+
+Returns `true` if `x` is odd (that is, not divisible by 2), and `false` otherwise.
+
+```jldoctest
+julia> isodd(9)
+true
+
+julia> isodd(10)
+false
+```
+"""
+isodd
+
+"""
+    normalize_string(s, normalform::Symbol)
+
+Normalize the string `s` according to one of the four "normal forms" of the Unicode
+standard: `normalform` can be `:NFC`, `:NFD`, `:NFKC`, or `:NFKD`.  Normal forms C
+(canonical composition) and D (canonical decomposition) convert different visually identical
+representations of the same abstract string into a single canonical form, with form C being
+more compact.  Normal forms KC and KD additionally canonicalize "compatibility equivalents":
+they convert characters that are abstractly similar but visually distinct into a single
+canonical choice (e.g. they expand ligatures into the individual characters), with form KC
+being more compact.
+
+Alternatively, finer control and additional transformations may be be obtained by calling
+`normalize_string(s; keywords...)`, where any number of the following boolean keywords
+options (which all default to `false` except for `compose`) are specified:
+
+* `compose=false`: do not perform canonical composition
+* `decompose=true`: do canonical decomposition instead of canonical composition (`compose=true`
+  is ignored if present)
+* `compat=true`: compatibility equivalents are canonicalized
+* `casefold=true`: perform Unicode case folding, e.g. for case-insensitive string comparison
+* `newline2lf=true`, `newline2ls=true`, or `newline2ps=true`: convert various newline sequences
+  (LF, CRLF, CR, NEL) into a linefeed (LF), line-separation (LS), or paragraph-separation (PS)
+  character, respectively
+* `stripmark=true`: strip diacritical marks (e.g. accents)
+* `stripignore=true`: strip Unicode's "default ignorable" characters (e.g. the soft hyphen
+  or the left-to-right marker)
+* `stripcc=true`: strip control characters; horizontal tabs and form feeds are converted to
+  spaces; newlines are also converted to spaces unless a newline-conversion flag was specified
+* `rejectna=true`: throw an error if unassigned code points are found
+* `stable=true`: enforce Unicode Versioning Stability
+
+For example, NFKC corresponds to the options `compose=true, compat=true, stable=true`.
+"""
+normalize_string
+
+"""
+    cd([dir::AbstractString=homedir()])
+
+Set the current working directory.
+"""
+cd(dir::AbstractString)
+
+"""
+    cd(f, [dir=homedir()])
+
+Temporarily changes the current working directory and applies function `f` before returning.
+"""
+cd(f, dir=?)
+
+"""
+    hton(x)
+
+Converts the endianness of a value from that used by the Host to Network byte order (big-endian).
+"""
+hton
+
+"""
+    is(x, y) -> Bool
+    ===(x,y) -> Bool
+    ≡(x,y) -> Bool
+
+Determine whether `x` and `y` are identical, in the sense that no program could distinguish
+them. Compares mutable objects by address in memory, and compares immutable objects (such as
+numbers) by contents at the bit level. This function is sometimes called `egal`.
+"""
+is(x,y)
+
+"""
+    mark(s)
+
+Add a mark at the current position of stream `s`. Returns the marked position.
+
+See also [`unmark`](:func:`unmark`), [`reset`](:func:`reset`), [`ismarked`](:func:`ismarked`).
+"""
+mark
+
+"""
+    cp(src::AbstractString, dst::AbstractString; remove_destination::Bool=false, follow_symlinks::Bool=false)
+
+Copy the file, link, or directory from *src* to *dest*. `remove_destination=true` will first
+remove an existing `dst`.
+
+If `follow_symlinks=false`, and `src` is a symbolic link, `dst` will be created as a
+symbolic link. If `follow_symlinks=true` and `src` is a symbolic link, `dst` will be a copy
+of the file or directory `src` refers to.
+"""
+cp
+
+"""
+    bswap(n)
+
+Byte-swap an integer.
+"""
+bswap
+
+"""
+    manage(manager::FooManager, pid::Int, config::WorkerConfig. op::Symbol)
+
+Implemented by cluster managers. It is called on the master process, during a worker's
+lifetime, with appropriate `op` values:
+
+- with `:register`/`:deregister` when a worker is added / removed from the Julia worker pool.
+- with `:interrupt` when `interrupt(workers)` is called. The [`ClusterManager`](:class:`ClusterManager`)
+  should signal the appropriate worker with an interrupt signal.
+- with `:finalize` for cleanup purposes.
+"""
+manage
+
+"""
+    resize!(collection, n) -> collection
+
+Resize `collection` to contain `n` elements. If `n` is smaller than the current collection
+length, the first `n` elements will be retained. If `n` is larger, the new elements are not
+guaranteed to be initialized.
+
+```jldoctest
+julia> resize!([6, 5, 4, 3, 2, 1], 3)
+3-element Array{Int64,1}:
+ 6
+ 5
+ 4
+```
+
+```julia
+julia> resize!([6, 5, 4, 3, 2, 1], 8)
+8-element Array{Int64,1}:
+ 6
+ 5
+ 4
+ 3
+ 2
+ 1
+ 0
+ 0
+```
+"""
+resize!
+
+"""
+    sumabs2!(r, A)
+
+Sum squared absolute values of elements of `A` over the singleton dimensions of `r`, and
+write results to `r`.
+"""
+sumabs2!
+
+"""
+    IPv4(host::Integer) -> IPv4
+
+Returns IPv4 object from ip address formatted as Integer.
+"""
+IPv4
+
+"""
+    trailing_zeros(x::Integer) -> Integer
+
+Number of zeros trailing the binary representation of `x`.
+
+```jldoctest
+julia> trailing_zeros(2)
+1
+```
+"""
+trailing_zeros
+
+"""
+    isalnum(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is alphanumeric, or whether this is true for all elements of a
+string. A character is classified as alphabetic if it belongs to the Unicode general
+category Letter or Number, i.e. a character whose category code begins with 'L' or 'N'.
+"""
+isalnum
+
+"""
+    @sprintf("%Fmt", args...)
+
+Return `@printf` formatted output as string.
+
+    julia> s = @sprintf "this is a %s %15.1f" "test" 34.567;
+
+    julia> println(s)
+    this is a test            34.6
+"""
+:@sprintf
+
+"""
+    tanh(x)
+
+Compute hyperbolic tangent of `x`.
+"""
+tanh
+
+"""
+    repr(x)
+
+Create a string from any value using the `showall` function.
+"""
+repr
+
+"""
+    maxintfloat(T)
+
+The largest integer losslessly representable by the given floating-point DataType `T`.
+"""
+maxintfloat
+
+"""
+    promote_shape(s1, s2)
+
+Check two array shapes for compatibility, allowing trailing singleton dimensions, and return
+whichever shape has more dimensions.
+"""
+promote_shape
+
+"""
+    methodswith(typ[, module or function][, showparents])
+
+Return an array of methods with an argument of type `typ`. If optional `showparents` is
+`true`, also return arguments with a parent type of `typ`, excluding type `Any`.
+
+The optional second argument restricts the search to a particular module or function.
+"""
+methodswith
+
+"""
+    foldr(op, v0, itr)
+
+Like [`reduce`](:func:`reduce`), but with guaranteed right associativity. `v0` will be used
+exactly once.
+"""
+foldr(op, v0, itr)
+
+"""
+    foldr(op, itr)
+
+Like `foldr(op, v0, itr)`, but using the last element of `itr` as `v0`. In general, this
+cannot be used with empty collections (see `reduce(op, itr)`).
+"""
+foldr(op, itr)
+
+"""
+    ParseError(msg)
+
+The expression passed to the `parse` function could not be interpreted as a valid Julia expression.
+"""
+ParseError
+
+"""
+    delete!(collection, key)
+
+Delete the mapping for the given key in a collection, and return the collection.
+"""
+delete!
+
+"""
+    interrupt([pids...])
+
+Interrupt the current executing task on the specified workers. This is equivalent to
+pressing Ctrl-C on the local machine. If no arguments are given, all workers are interrupted.
+"""
+interrupt
+
+"""
+    std(v[, region])
+
+Compute the sample standard deviation of a vector or array `v`, optionally along dimensions
+in `region`. The algorithm returns an estimator of the generative distribution's standard
+deviation under the assumption that each entry of `v` is an IID drawn from that generative
+distribution. This computation is equivalent to calculating `sqrt(sum((v - mean(v)).^2) /
+(length(v) - 1))`. Note: Julia does not ignore `NaN` values in the computation. For
+applications requiring the handling of missing data, the `DataArray` package is recommended.
+"""
+std
+
+"""
+    chr2ind(string, i)
+
+Convert a character index to a byte index.
+"""
+chr2ind
+
+"""
+    fullname(m::Module)
+
+Get the fully-qualified name of a module as a tuple of symbols. For example,
+`fullname(Base.Pkg)` gives `(:Base,:Pkg)`, and `fullname(Main)` gives `()`.
+"""
+fullname
+
+"""
+    isreadable(io) -> Bool
+
+Returns `true` if the specified IO object is readable (if that can be determined).
+"""
+isreadable
+
+"""
+    eps(T)
+
+The distance between 1.0 and the next larger representable floating-point value of
+`DataType` `T`. Only floating-point types are sensible arguments.
+"""
+eps(::Union{Type{BigFloat},Type{Float64},Type{Float32},Type{Float16}})
+
+"""
+    eps()
+
+The distance between 1.0 and the next larger representable floating-point value of `Float64`.
+"""
+eps()
+
+"""
+    eps(x)
+
+The distance between `x` and the next larger representable floating-point value of the same
+`DataType` as `x`.
+"""
+eps(::AbstractFloat)
+
+"""
+    rem1(x, y)
+
+(Deprecated.) Remainder after division, returning in the range `(0, y]`.
+"""
+rem1
+
+"""
+    isalpha(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is alphabetic, or whether this is true for all elements of a
+string. A character is classified as alphabetic if it belongs to the Unicode general
+category Letter, i.e. a character whose category code begins with 'L'.
+"""
+isalpha
+
+"""
+    lock(l::ReentrantLock)
+
+Associates `l` with the current task. If `l` is already locked by a different task, waits
+for it to become available. The same task can acquire the lock multiple times. Each "lock"
+must be matched by an "unlock"
+"""
+lock
+
+"""
+    transpose(A)
+
+The transposition operator (`.'`).
+"""
+transpose
+
+"""
+    searchsortedfirst(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Returns the index of the first value in `a` greater than or equal to `x`, according to the
+specified order. Returns `length(a)+1` if `x` is greater than all values in `a`.
+"""
+searchsortedfirst
+
+"""
+    big(x)
+
+Convert a number to a maximum precision representation (typically `BigInt` or `BigFloat`).
+See `BigFloat` for information about some pitfalls with floating-point numbers.
+"""
+big
+
+"""
+    names(x::Module[, all=false[, imported=false]])
+
+Get an array of the names exported by a `Module`, with optionally more `Module` globals
+according to the additional parameters.
+"""
+names
+
+"""
+    quit()
+
+Quit the program indicating that the processes completed successfully. This function calls
+`exit(0)` (see [`exit`](:func:`exit`)).
+"""
+quit
+
+"""
+    init_worker(manager::FooManager)
+
+Called by cluster managers implementing custom transports. It initializes a newly launched
+process as a worker. Command line argument `--worker` has the effect of initializing a
+process as a worker using TCP/IP sockets for transport.
+"""
+init_worker
+
+"""
+    print_escaped(io, str::AbstractString, esc::AbstractString)
+
+General escaping of traditional C and Unicode escape sequences, plus any characters in esc
+are also escaped (with a backslash).
+"""
+print_escaped
+
+"""
+    typejoin(T, S)
+
+Compute a type that contains both `T` and `S`.
+"""
+typejoin
+
+"""
+    Base64DecodePipe(istream)
+
+Returns a new read-only I/O stream, which decodes base64-encoded data read from `istream`.
+"""
+Base64DecodePipe
+
+"""
+    module_parent(m::Module) -> Module
+
+Get a module's enclosing `Module`. `Main` is its own parent, as is `LastMain` after `workspace()`.
+"""
+module_parent
+
+"""
+    airyaiprime(x)
+
+Airy function derivative ``\\operatorname{Ai}'(x)``.
+"""
+airyaiprime
+
+"""
+    besselh(nu, k, x)
+
+Bessel function of the third kind of order `nu` (Hankel function). `k` is either 1 or 2,
+selecting `hankelh1` or `hankelh2`, respectively.
+"""
+besselh
+
+"""
+    prepend!(collection, items) -> collection
+
+Insert the elements of `items` to the beginning of `collection`.
+
+```jldoctest
+julia> prepend!([3],[1,2])
+3-element Array{Int64,1}:
+ 1
+ 2
+ 3
+```
+"""
+prepend!
+
+"""
+    sum_kbn(A)
+
+Returns the sum of all array elements, using the Kahan-Babuska-Neumaier compensated
+summation algorithm for additional accuracy.
+"""
+sum_kbn
+
+"""
+    beta(x, y)
+
+Euler integral of the first kind ``\\operatorname{B}(x,y) = \\Gamma(x)\\Gamma(y)/\\Gamma(x+y)``.
+"""
+beta
+
+"""
+    eye(n)
+
+`n`-by-`n` identity matrix.
+"""
+eye(n::Int)
+
+"""
+    eye(m, n)
+
+`m`-by-`n` identity matrix.
+"""
+eye(m, n)
+
+"""
+    eye(A)
+
+Constructs an identity matrix of the same dimensions and type as `A`.
+"""
+eye(A)
+
+"""
+    diagind(M[, k])
+
+A `Range` giving the indices of the `k`th diagonal of the matrix `M`.
+"""
+diagind
+
+"""
+    include_string(code::AbstractString, [filename])
+
+Like `include`, except reads code from the given string rather than from a file. Since there
+is no file path involved, no path processing or fetching from node 1 is done.
+"""
+include_string
+
+"""
+    chmod(path, mode; recursive=false)
+
+Change the permissions mode of `path` to `mode`. Only integer `mode`s (e.g. `0o777`) are
+currently supported. If `recursive=true` and the path is a directory all permissions in
+that directory will be recursively changed.
+"""
+chmod
+
+"""
+    chown(path, owner, group=-1)
+
+Change the owner and/or group of `path` to `owner` and/or `group`. If the value entered for `owner` or `group`
+is `-1` the corresponding ID will not change. Only integer `owner`s and `group`s are currently supported.
+"""
+chown
+
+"""
+    gamma(x)
+
+Compute the gamma function of `x`.
+"""
+gamma
+
+"""
+    sin(x)
+
+Compute sine of `x`, where `x` is in radians.
+"""
+sin
+
+"""
+    Base.compilecache(module::ByteString)
+
+Creates a precompiled cache file for module (see help for `require`) and all of its
+dependencies. This can be used to reduce package load times. Cache files are stored in
+`LOAD_CACHE_PATH[1]`, which defaults to `~/.julia/lib/VERSION`. See
+[Module initialization and precompilation](:ref:`Module initialization and precompilation <man-modules-initialization-precompilation>`)
+for important notes.
+"""
+compilecache
+
+"""
+    clipboard() -> AbstractString
+
+Return a string with the contents of the operating system clipboard ("paste").
+"""
+clipboard
+
+"""
+    clipboard(x)
+
+Send a printed form of `x` to the operating system clipboard ("copy").
+"""
+clipboard(x)
+
+"""
+    code_lowered(f, types)
+
+Returns an array of lowered ASTs for the methods matching the given generic function and type signature.
+"""
+code_lowered
+
+"""
+    values(collection)
+
+Return an iterator over all values in a collection. `collect(values(d))` returns an array of values.
+"""
+values
+
+"""
+    A_mul_B!(Y, A, B) -> Y
+
+Calculates the matrix-matrix or matrix-vector product ``A⋅B`` and stores the result in `Y`,
+overwriting the existing value of `Y`. Note that `Y` must not be aliased with either `A` or
+`B`.
+
+```jldoctest
+julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); A_mul_B!(Y, A, B);
+
+julia> Y
+2x2 Array{Float64,2}:
+ 3.0  3.0
+ 7.0  7.0
+```
+"""
+A_mul_B!
+
+"""
+    ntuple(f::Function, n)
+
+Create a tuple of length `n`, computing each element as `f(i)`, where `i` is the index of the element.
+"""
+ntuple
+
+"""
+    Ac_rdiv_Bc(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ / Bᴴ``.
+"""
+Ac_rdiv_Bc
+
+"""
+    selectperm!(ix, v, k, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false,] [initialized=false])
+
+Like `selectperm`, but accepts a preallocated index vector `ix`. If `initialized` is `false`
+(the default), ix is initialized to contain the values `1:length(ix)`.
+"""
+selectperm!
+
+"""
+    istaskdone(task) -> Bool
+
+Tell whether a task has exited.
+"""
+istaskdone
+
+"""
+    .>(x, y)
+
+Element-wise greater-than comparison operator.
+"""
+Base.(:(.>))
+
+"""
+    search(string, chars, [start])
+
+Search for the first occurrence of the given characters within the given string. The second
+argument may be a single character, a vector or a set of characters, a string, or a regular
+expression (though regular expressions are only allowed on contiguous strings, such as ASCII
+or UTF-8 strings). The third argument optionally specifies a starting index. The return
+value is a range of indexes where the matching sequence is found, such that `s[search(s,x)] == x`:
+
+`search(string, "substring")` = `start:end` such that `string[start:end] == "substring"`, or
+`0:-1` if unmatched.
+
+`search(string, 'c')` = `index` such that `string[index] == 'c'`, or `0` if unmatched.
+"""
+search
+
+"""
+    remotecall_fetch(func, id, args...)
+
+Perform `fetch(remotecall(...))` in one message. Any remote exceptions are captured in a
+`RemoteException` and thrown.
+"""
+remotecall_fetch
+
+"""
+    contains(haystack, needle)
+
+Determine whether the second argument is a substring of the first.
+"""
+contains
+
+"""
+    flush(stream)
+
+Commit all currently buffered writes to the given stream.
+"""
+flush
+
+"""
+    precompile(f,args::Tuple{Vararg{Any}})
+
+Compile the given function `f` for the argument tuple (of types) `args`, but do not execute it.
+"""
+precompile
+
+"""
+    toc()
+
+Print and return the time elapsed since the last [`tic`](:func:`tic`).
+"""
+toc
+
+"""
+    asinh(x)
+
+Compute the inverse hyperbolic sine of `x`.
+"""
+asinh
+
+"""
+    count(p, itr) -> Integer
+
+Count the number of elements in `itr` for which predicate `p` returns `true`.
+"""
+count
+
+"""
+    atreplinit(f)
+
+Register a one-argument function to be called before the REPL interface is initialized in
+interactive sessions; this is useful to customize the interface. The argument of `f` is the
+REPL object. This function should be called from within the `.juliarc.jl` initialization
+file.
+"""
+atreplinit
+
+"""
+    strip(string, [chars])
+
+Return `string` with any leading and trailing whitespace removed. If `chars` (a character,
+or vector or set of characters) is provided, instead remove characters contained in it.
+"""
+strip
+
+"""
+    findin(a, b)
+
+Returns the indices of elements in collection `a` that appear in collection `b`.
+"""
+findin
+
+"""
+    minimum(itr)
+
+Returns the smallest element in a collection.
+"""
+minimum(itr)
+
+"""
+    minimum(A, dims)
+
+Compute the minimum value of an array over the given dimensions.
+"""
+minimum(A,dims)
+
+"""
+    var(v[, region])
+
+Compute the sample variance of a vector or array `v`, optionally along dimensions in
+`region`. The algorithm will return an estimator of the generative distribution's variance
+under the assumption that each entry of `v` is an IID drawn from that generative
+distribution. This computation is equivalent to calculating `sumabs2(v - mean(v)) /
+(length(v) - 1)`. Note: Julia does not ignore `NaN` values in the computation. For
+applications requiring the handling of missing data, the `DataArray` package is recommended.
+"""
+var
+
+"""
+    lcfirst(string)
+
+Returns `string` with the first character converted to lowercase.
+"""
+lcfirst
+
+"""
+    @code_native
+
+Evaluates the arguments to the function call, determines their types, and calls
+[`code_native`](:func:`code_native`) on the resulting expression.
+"""
+:@code_native
+
+"""
+    flipbits!(B::BitArray{N}) -> BitArray{N}
+
+Performs a bitwise not operation on `B`. See [`~`](:ref:`~ operator <~>`).
+"""
+flipbits!
+
+"""
+    readlink(path) -> AbstractString
+
+Returns the value of a symbolic link `path`.
+"""
+readlink
+
+"""
+    @code_warntype
+
+Evaluates the arguments to the function call, determines their types, and calls
+[`code_warntype`](:func:`code_warntype`) on the resulting expression.
+"""
+:@code_warntype
+
+"""
+    deg2rad(x)
+
+Convert `x` from degrees to radians.
+"""
+deg2rad
+
+"""
+    redirect_stdin([stream])
+
+Like redirect_stdout, but for STDIN. Note that the order of the return tuple is still
+(rd,wr), i.e. data to be read from STDIN, may be written to wr.
+"""
+redirect_stdin
+
+"""
+    minmax(x, y)
+
+Return `(min(x,y), max(x,y))`. See also: [`extrema`](:func:`extrema`) that returns `(minimum(x), maximum(x))`.
+"""
+minmax
+
+"""
+    mktemp([parent=tempdir()])
+
+Returns `(path, io)`, where `path` is the path of a new temporary file in `parent` and `io`
+is an open file object for this path.
+"""
+mktemp(?)
+
+"""
+    mktemp(f::Function, [parent=tempdir()])
+
+Apply the function `f` to the result of `mktemp(parent)` and remove the temporary file upon completion.
+"""
+mktemp(::Function, ?)
+
+"""
+    isreadonly(stream) -> Bool
+
+Determine whether a stream is read-only.
+"""
+isreadonly
+
+"""
+    rounding(T)
+
+Get the current floating point rounding mode for type `T`, controlling the rounding of basic
+arithmetic functions ([`+`](:func:`+`), [`-`](:func:`-`), [`*`](:func:`*`), [`/`](:func:`/`)
+and [`sqrt`](:func:`sqrt`)) and type conversion.
+
+Valid modes are `RoundNearest`, `RoundToZero`, `RoundUp`, `RoundDown`, and `RoundFromZero`
+(`BigFloat` only).
+"""
+rounding
+
+"""
+    code_llvm(f, types)
+
+Prints the LLVM bitcodes generated for running the method matching the given generic
+function and type signature to [`STDOUT`](:const:`STDOUT`).
+
+All metadata and dbg.* calls are removed from the printed bitcode. Use code_llvm_raw for the full IR.
+"""
+code_llvm
+
+"""
+    Bidiagonal(dv, ev, isupper)
+
+Constructs an upper (`isupper=true`) or lower (`isupper=false`) bidiagonal matrix using the
+given diagonal (`dv`) and off-diagonal (`ev`) vectors.  The result is of type `Bidiagonal`
+and provides efficient specialized linear solvers, but may be converted into a regular
+matrix with [`full`](:func:`full`).
+"""
+Bidiagonal
+
+"""
+    notify(condition, val=nothing; all=true, error=false)
+
+Wake up tasks waiting for a condition, passing them `val`. If `all` is `true` (the default),
+all waiting tasks are woken, otherwise only one is. If `error` is `true`, the passed value
+is raised as an exception in the woken tasks.
+"""
+notify
+
+"""
+    sub(A, inds...)
+
+Like [`getindex`](:func:`getindex`), but returns a view into the parent array `A` with the
+given indices instead of making a copy.  Calling [`getindex`](:func:`getindex`) or
+[`setindex!`](:func:`setindex!`) on the returned [`SubArray`](:obj:`SubArray`) computes the
+indices to the parent array on the fly without checking bounds.
+"""
+sub
+
+"""
+    expanduser(path::AbstractString) -> AbstractString
+
+On Unix systems, replace a tilde character at the start of a path with the current user's home directory.
+"""
+expanduser
+
+"""
+    haskey(collection, key) -> Bool
+
+Determine whether a collection has a mapping for a given key.
+"""
+haskey
+
+"""
+    cot(x)
+
+Compute the cotangent of `x`, where `x` is in radians.
+"""
+cot
+
+"""
+    get(x)
+
+Attempt to access the value of the `Nullable` object, `x`. Returns the value if it is
+present; otherwise, throws a `NullException`.
+"""
+get(x)
+
+"""
+    get(x, y)
+
+Attempt to access the value of the `Nullable{T}` object, `x`. Returns
+the value if it is present; otherwise, returns `convert(T, y)`.
+"""
+get(x,y)
+
+"""
+    get(collection, key, default)
+
+Return the value stored for the given key, or the given default value if no mapping for the
+key is present.
+"""
+get(collection,key,default)
+
+"""
+    get(f::Function, collection, key)
+
+Return the value stored for the given key, or if no mapping for the key is present, return
+`f()`.  Use [`get!`](:func:`get!`) to also store the default value in the dictionary.
+
+This is intended to be called using `do` block syntax
+
+```julia
+get(dict, key) do
+    # default value calculated here
+    time()
+end
+```
+"""
+get
+
+"""
+    .!=(x, y)
+    .≠(x,y)
+
+Element-wise not-equals comparison operator.
+"""
+Base.(:(.!=))
+
+"""
+    lufact!(A) -> LU
+
+`lufact!` is the same as [`lufact`](:func:`lufact`), but saves space by overwriting the
+input `A`, instead of creating a copy.  For sparse `A` the `nzval` field is not overwritten
+but the index fields, `colptr` and `rowval` are decremented in place, converting from
+1-based indices to 0-based indices.
+"""
+lufact!
+
+"""
+    IOBuffer() -> IOBuffer
+
+Create an in-memory I/O stream.
+"""
+IOBuffer()
+
+"""
+    IOBuffer(size::Int)
+
+Create a fixed size IOBuffer. The buffer will not grow dynamically.
+"""
+IOBuffer(size::Int)
+
+"""
+    IOBuffer(string)
+
+Create a read-only IOBuffer on the data underlying the given string.
+"""
+IOBuffer(::AbstractString)
+
+"""
+    IOBuffer([data,],[readable,writable,[maxsize]])
+
+Create an IOBuffer, which may optionally operate on a pre-existing array. If the
+readable/writable arguments are given, they restrict whether or not the buffer may be read
+from or written to respectively. By default the buffer is readable but not writable. The
+last argument optionally specifies a size beyond which the buffer may not be grown.
+"""
+IOBuffer(data=?)
+
+"""
+    findmax(itr) -> (x, index)
+
+Returns the maximum element and its index.
+"""
+findmax(itr)
+
+"""
+    findmax(A, dims) -> (maxval, index)
+
+For an array input, returns the value and index of the maximum over the given dimensions.
+"""
+findmax(A,dims)
+
+"""
+    tempname()
+
+Generate a unique temporary file path.
+"""
+tempname
+
+"""
+    poll_fd(fd, timeout_s::Real; readable=false, writable=false)
+
+Monitor a file descriptor `fd` for changes in the read or write availability, and with a
+timeout given by `timeout_s` seconds.
+
+The keyword arguments determine which of read and/or write status should be monitored; at
+least one of them must be set to `true`.
+
+The returned value is an object with boolean fields `readable`, `writable`, and `timedout`,
+giving the result of the polling.
+"""
+poll_fd
+
+"""
+    prevpow2(n)
+
+The largest power of two not greater than `n`. Returns 0 for `n==0`, and returns
+`-prevpow2(-n)` for negative arguments.
+"""
+prevpow2
+
+"""
+    code_warntype(f, types)
+
+Displays lowered and type-inferred ASTs for the methods matching the given generic function
+and type signature. The ASTs are annotated in such a way as to cause "non-leaf" types to be
+emphasized (if color is available, displayed in red). This serves as a warning of potential
+type instability. Not all non-leaf types are particularly problematic for performance, so
+the results need to be used judiciously. See [Manual](:ref:`man-code-warntype`) for more
+information.
+"""
+code_warntype
+
+"""
+```
+broadcast!_function(f)
+```
+
+Like `broadcast_function`, but for `broadcast!`.
+"""
+broadcast!_function
+
+"""
+    setrounding(T, mode)
+
+Set the rounding mode of floating point type `T`, controlling the rounding of basic
+arithmetic functions ([`+`](:func:`+`), [`-`](:func:`-`), [`*`](:func:`*`), [`/`](:func:`/`)
+and [`sqrt`](:func:`sqrt`)) and type conversion.
+
+Note that this may affect other types, for instance changing the rounding mode of `Float64`
+will change the rounding mode of `Float32`. See `rounding` for available modes
+"""
+setrounding(T, mode)
+
+"""
+    setrounding(f::Function, T, mode)
+
+Change the rounding mode of floating point type `T` for the duration of `f`. It is logically
+equivalent to:
+
+    old = rounding(T)
+    setrounding(T, mode)
+    f()
+    setrounding(T, old)
+
+See `rounding` for available rounding modes.
+"""
+setrounding(f::Function, T, mode)
+
+"""
+    sleep(seconds)
+
+Block the current task for a specified number of seconds. The minimum sleep time is 1
+millisecond or input of `0.001`.
+"""
+sleep
+
+"""
+    Mmap.sync!(array)
+
+Forces synchronization between the in-memory version of a memory-mapped `Array` or
+`BitArray` and the on-disk version.
+"""
+Mmap.sync!
+
+"""
+    csc(x)
+
+Compute the cosecant of `x`, where `x` is in radians.
+"""
+csc
+
+"""
+    hash(x[, h::UInt])
+
+Compute an integer hash code such that `isequal(x,y)` implies `hash(x)==hash(y)`. The
+optional second argument `h` is a hash code to be mixed with the result.
+
+New types should implement the 2-argument form, typically by calling the 2-argument `hash`
+method recursively in order to mix hashes of the contents with each other (and with `h`).
+Typically, any type that implements `hash` should also implement its own `==` (hence
+`isequal`) to guarantee the property mentioned above.
+"""
+hash
+
+"""
+    atan2(y, x)
+
+Compute the inverse tangent of `y/x`, using the signs of both `x` and `y` to determine the
+quadrant of the return value.
+"""
+atan2
+
+"""
+    send(socket::UDPSocket, host::IPv4, port::Integer, msg)
+
+Send `msg` over `socket` to `host:port`.
+"""
+send
+
+"""
+    atanh(x)
+
+Compute the inverse hyperbolic tangent of `x`.
+"""
+atanh
+
+"""
+    deleteat!(collection, index)
+
+Remove the item at the given `index` and return the modified `collection`. Subsequent items
+are shifted to fill the resulting gap.
+
+```jldoctest
+julia> deleteat!([6, 5, 4, 3, 2, 1], 2)
+5-element Array{Int64,1}:
+ 6
+ 4
+ 3
+ 2
+ 1
+```
+"""
+deleteat!(collection, index::Integer)
+
+"""
+    deleteat!(collection, itr)
+
+Remove the items at the indices given by `itr`, and return the modified `collection`.
+Subsequent items are shifted to fill the resulting gap. `itr` must be sorted and unique.
+
+```jldoctest
+julia> deleteat!([6, 5, 4, 3, 2, 1], 1:2:5)
+3-element Array{Int64,1}:
+ 5
+ 3
+ 1
+
+julia> deleteat!([6, 5, 4, 3, 2, 1], (2, 2))
+ERROR: ArgumentError: indices must be unique and sorted
+ in deleteat! at array.jl:543
+```
+"""
+deleteat!(collection, itr)
+
+"""
+    read(stream::IO, T)
+
+Read a single value of type `T` from `stream`, in canonical binary representation.
+"""
+read(stream, t)
+
+"""
+    read(stream::IO, T, dims)
+
+Read a series of values of type `T` from `stream`, in canonical binary representation.
+`dims` is either a tuple or a series of integer arguments specifying the size of the `Array{T}`
+to return.
+"""
+read(stream, t, dims)
+
+"""
+    read(filename::AbstractString, args...)
+
+Open a file and read its contents. `args` is passed to `read`: this is equivalent to
+`open(io->read(io, args...), filename)`.
+"""
+read(filename, args...)
+
+"""
+    @timev
+
+This is a verbose version of the `@time` macro. It first prints the same information as
+`@time`, then any non-zero memory allocation counters, and then returns the value of the
+expression.
+"""
+:@timev
+
+"""
+    isopen(object) -> Bool
+
+Determine whether an object - such as a stream, timer, or mmap -- is not yet closed. Once an
+object is closed, it will never produce a new event. However, a closed stream may still have
+data to read in its buffer, use `eof` to check for the ability to read data. Use `poll_fd`
+to be notified when a stream might be writable or readable.
+"""
+isopen
+
+"""
+    shift!(collection) -> item
+
+Remove the first `item` from `collection`.
+
+```jldoctest
+julia> A = [1, 2, 3, 4, 5, 6]
+6-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+
+julia> shift!(A)
+1
+
+julia> A
+5-element Array{Int64,1}:
+ 2
+ 3
+ 4
+ 5
+ 6
+```
+"""
+shift!
+
+"""
+    @fetch
+
+Equivalent to `fetch(@spawn expr)`.
+"""
+:@fetch
+
+"""
+    spawn(command)
+
+Run a command object asynchronously, returning the resulting `Process` object.
+"""
+spawn
+
+"""
+    isposdef(A) -> Bool
+
+Test whether a matrix is positive definite.
+"""
+isposdef
+
+"""
+    nextind(str, i)
+
+Get the next valid string index after `i`. Returns a value greater than `endof(str)` at or
+after the end of the string.
+"""
+nextind
+
+"""
+    @timed
+
+A macro to execute an expression, and return the value of the expression, elapsed time,
+total bytes allocated, garbage collection time, and an object with various memory allocation
+counters.
+"""
+:@timed
+
+"""
+    code_native(f, types)
+
+Prints the native assembly instructions generated for running the method matching the given
+generic function and type signature to `STDOUT`.
+"""
+code_native
+
+"""
+    symdiff(s1,s2...)
+
+Construct the symmetric difference of elements in the passed in sets or arrays. Maintains
+order with arrays.
+"""
+symdiff
+
+"""
+    histrange(v, n)
+
+Compute *nice* bin ranges for the edges of a histogram of `v`, using approximately `n` bins.
+The resulting step sizes will be 1, 2 or 5 multiplied by a power of 10. Note: Julia does not
+ignore `NaN` values in the computation.
+"""
+histrange
+
+"""
+    eta(x)
+
+Dirichlet eta function ``\\eta(s) = \\sum^\\infty_{n=1}(-)^{n-1}/n^{s}``.
+"""
+eta
+
+"""
+    isdefined([m::Module,] s::Symbol)
+    isdefined(object, s::Symbol)
+    isdefined(a::AbstractArray, index::Int)
+
+Tests whether an assignable location is defined. The arguments can be a module and a symbol,
+a composite object and field name (as a symbol), or an array and index. With a single
+symbol argument, tests whether a global variable with that name is defined in
+`current_module()`.
+"""
+isdefined
+
+"""
+    cotd(x)
+
+Compute the cotangent of `x`, where `x` is in degrees.
+"""
+cotd
+
+"""
+    dec(n, [pad])
+
+Convert an integer to a decimal string, optionally specifying a number of digits to pad to.
+"""
+dec
+
+"""
+    wait([x])
+
+Block the current task until some event occurs, depending on the type of the argument:
+
+* `RemoteChannel` : Wait for a value to become available on the specified remote channel.
+* `Future` : Wait for a value to become available for the specified future.
+* `Channel`: Wait for a value to be appended to the channel.
+* `Condition`: Wait for `notify` on a condition.
+* `Process`: Wait for a process or process chain to exit. The `exitcode` field of a process
+  can be used to determine success or failure.
+* `Task`: Wait for a `Task` to finish, returning its result value. If the task fails with an
+  exception, the exception is propagated (re-thrown in the task that called `wait`).
+* `RawFD`: Wait for changes on a file descriptor (see `poll_fd` for keyword arguments and return code)
+
+If no argument is passed, the task blocks for an undefined period. A task can only be
+restarted by an explicit call to `schedule` or `yieldto`.
+
+Often `wait` is called within a `while` loop to ensure a waited-for condition is met before proceeding.
+"""
+wait
+
+"""
+    shuffle([rng,] v)
+
+Return a randomly permuted copy of `v`. The optional `rng` argument specifies a random
+number generator, see [Random Numbers](:ref:`Random Numbers <random-numbers>`).
+"""
+shuffle
+
+"""
+    Dict([itr])
+
+`Dict{K,V}()` constructs a hash table with keys of type `K` and values of type `V`.
+
+Given a single iterable argument, constructs a [`Dict`](:obj:`Dict`) whose key-value pairs
+are taken from 2-tuples `(key,value)` generated by the argument.
+
+```jldoctest
+julia> Dict([("A", 1), ("B", 2)])
+Dict{ASCIIString,Int64} with 2 entries:
+  "B" => 2
+  "A" => 1
+```
+
+Alternatively, a sequence of pair arguments may be passed.
+
+```jldoctest
+julia> Dict("A"=>1, "B"=>2)
+Dict{ASCIIString,Int64} with 2 entries:
+  "B" => 2
+  "A" => 1
+```
+"""
+Dict
+
+"""
+    sqrt(x)
+
+Return ``\\sqrt{x}``. Throws `DomainError` for negative `Real` arguments. Use complex
+negative arguments instead.  The prefix operator `√` is equivalent to `sqrt`.
+"""
+sqrt
+
+"""
+    atexit(f)
+
+Register a zero-argument function `f()` to be called at process exit. `atexit()` hooks are
+called in last in first out (LIFO) order and run before object finalizers.
+"""
+atexit
+
+"""
+    besselk(nu, x)
+
+Modified Bessel function of the second kind of order `nu`, ``K_\\nu(x)``.
+"""
+besselk
+
+"""
+    readchomp(x)
+
+Read the entirety of `x` as a string but remove trailing newlines. Equivalent to `chomp(readstring(x))`.
+"""
+readchomp
+
+"""
+    pinv(M[, tol])
+
+Computes the Moore-Penrose pseudoinverse.
+
+For matrices `M` with floating point elements, it is convenient to compute
+the pseudoinverse by inverting only singular values above a given threshold,
+`tol`.
+
+The optimal choice of `tol` varies both with the value of `M` and the intended application
+of the pseudoinverse. The default value of `tol` is
+`eps(real(float(one(eltype(M)))))*maximum(size(A))`, which is essentially machine epsilon
+for the real part of a matrix element multiplied by the larger matrix dimension. For
+inverting dense ill-conditioned matrices in a least-squares sense,
+`tol = sqrt(eps(real(float(one(eltype(M))))))` is recommended.
+
+For more information, see [^issue8859], [^B96], [^S84], [^KY88].
+
+[^issue8859]: Issue 8859, "Fix least squares", https://github.com/JuliaLang/julia/pull/8859
+
+[^B96]: Åke Björck, "Numerical Methods for Least Squares Problems",  SIAM Press, Philadelphia, 1996, "Other Titles in Applied Mathematics", Vol. 51. [doi:10.1137/1.9781611971484](http://epubs.siam.org/doi/book/10.1137/1.9781611971484)
+
+[^S84]: G. W. Stewart, "Rank Degeneracy", SIAM Journal on Scientific and Statistical Computing, 5(2), 1984, 403-413. [doi:10.1137/0905030](http://epubs.siam.org/doi/abs/10.1137/0905030)
+
+[^KY88]: Konstantinos Konstantinides and Kung Yao, "Statistical analysis of effective singular values in matrix rank determination", IEEE Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988, 757-763. [doi:10.1109/29.1585](http://dx.doi.org/10.1109/29.1585)
+"""
+pinv
+
+"""
+    asecd(x)
+
+Compute the inverse secant of `x`, where the output is in degrees.
+"""
+asecd
+
+"""
+    readbytes!(stream::IO, b::AbstractVector{UInt8}, nb=length(b); all=true)
+
+Read at most `nb` bytes from `stream` into `b`, returning the number of bytes read.
+The size of `b` will be increased if needed (i.e. if `nb` is greater than `length(b)`
+and enough bytes could be read), but it will never be decreased.
+
+See `read` for a description of the `all` option.
+"""
+readbytes!
+
+"""
+    basename(path::AbstractString) -> AbstractString
+
+Get the file name part of a path.
+"""
+basename
+
+"""
+    ArgumentError(msg)
+
+The parameters to a function call do not match a valid signature. Argument `msg` is a
+descriptive error string.
+"""
+ArgumentError
+
+"""
+    atand(x)
+
+Compute the inverse tangent of `x`, where the output is in degrees.
+"""
+atand
+
+"""
+    KeyError(key)
+
+An indexing operation into an `Associative` (`Dict`) or `Set` like object tried to access or
+delete a non-existent element.
+"""
+KeyError
+
+"""
+    isdiag(A) -> Bool
+
+Test whether a matrix is diagonal.
+"""
+isdiag
+
+"""
+    !==(x, y)
+    ≢(x,y)
+
+Equivalent to `!is(x, y)`.
+"""
+Base.(:(!==))
+
+"""
+    trailing_ones(x::Integer) -> Integer
+
+Number of ones trailing the binary representation of `x`.
+
+```jldoctest
+julia> trailing_ones(3)
+2
+```
+"""
+trailing_ones
+
+"""
+    repeated(x[, n::Int])
+
+An iterator that generates the value `x` forever. If `n` is specified, generates `x` that
+many times (equivalent to `take(repeated(x), n)`).
+"""
+repeated
+
+"""
+    isnumber(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is numeric, or whether this is true for all elements of a string.
+A character is classified as numeric if it belongs to the Unicode general category Number,
+i.e. a character whose category code begins with 'N'.
+"""
+isnumber
+
+"""
+    similar(array, [element_type=eltype(array)], [dims=size(array)])
+
+Create an uninitialized mutable array with the given element type and size, based upon the
+given source array. The second and third arguments are both optional, defaulting to the
+given array's `eltype` and `size`. The dimensions may be specified either as a single tuple
+argument or as a series of integer arguments.
+
+Custom AbstractArray subtypes may choose which specific array type is best-suited to return
+for the given element type and dimensionality. If they do not specialize this method, the
+default is an `Array(element_type, dims...)`.
+
+For example, `similar(1:10, 1, 4)` returns an uninitialized `Array{Int,2}` since ranges are
+neither mutable nor support 2 dimensions:
+
+    julia> similar(1:10, 1, 4)
+    1x4 Array{Int64,2}:
+     4419743872  4374413872  4419743888  0
+
+Conversely, `similar(trues(10,10), 2)` returns an uninitialized `BitVector` with two
+elements since `BitArray`s are both mutable and can support 1-dimensional arrays:
+
+    julia> similar(trues(10,10), 2)
+    2-element BitArray{1}:
+     false
+     false
+
+Since `BitArray`s can only store elements of type `Bool`, however, if you request a
+different element type it will create a regular `Array` instead:
+
+    julia> similar(falses(10), Float64, 2, 4)
+    2x4 Array{Float64,2}:
+     2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
+     2.18425e-314  2.18425e-314  2.18425e-314  2.18425e-314
+"""
+similar
+
+"""
+    copy(x)
+
+Create a shallow copy of `x`: the outer structure is copied, but not all internal values.
+For example, copying an array produces a new array with identically-same elements as the
+original.
+"""
+copy
+
+"""
+    isempty(collection) -> Bool
+
+Determine whether a collection is empty (has no elements).
+
+```jldoctest
+julia> isempty([])
+true
+
+julia> isempty([1 2 3])
+false
+```
+"""
+isempty
+
+"""
+    sumabs!(r, A)
+
+Sum absolute values of elements of `A` over the singleton dimensions of `r`, and write
+results to `r`.
+"""
+sumabs!
+
+"""
+    Sys.set_process_title(title::AbstractString)
+
+Set the process title. No-op on some operating systems. (not exported)
+"""
+Sys.set_process_title
+
+"""
+    htol(x)
+
+Converts the endianness of a value from that used by the Host to Little-endian.
+"""
+htol
+
+"""
+    ctime(file)
+
+Equivalent to `stat(file).ctime`
+"""
+ctime
+
+"""
+    normpath(path::AbstractString) -> AbstractString
+
+Normalize a path, removing "." and ".." entries.
+"""
+normpath
+
+"""
+    unmark(s)
+
+Remove a mark from stream `s`. Returns `true` if the stream was marked, `false` otherwise.
+
+See also [`mark`](:func:`mark`), [`reset`](:func:`reset`), [`ismarked`](:func:`ismarked`).
+"""
+unmark
+
+"""
+    module_name(m::Module) -> Symbol
+
+Get the name of a `Module` as a `Symbol`.
+"""
+module_name
+
+"""
+    reset(s)
+
+Reset a stream `s` to a previously marked position, and remove the mark. Returns the
+previously marked position. Throws an error if the stream is not marked.
+
+See also [`mark`](:func:`mark`), [`unmark`](:func:`unmark`), [`ismarked`](:func:`ismarked`).
+"""
+reset
+
+"""
+    modf(x)
+
+Return a tuple (fpart,ipart) of the fractional and integral parts of a number. Both parts
+have the same sign as the argument.
+"""
+modf
+
+"""
+    hex2num(str)
+
+Convert a hexadecimal string to the floating point number it represents.
+"""
+hex2num
+
+"""
+    ndims(A) -> Integer
+
+Returns the number of dimensions of `A`.
+"""
+ndims
+
+"""
+    @osx
+
+Given `@osx? a : b`, do `a` on OS X and `b` elsewhere. See documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@osx
+
+"""
+    @osx_only
+
+A macro that evaluates the given expression only on OS X systems. See documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@osx_only
+
+"""
+    ishermitian(A) -> Bool
+
+Test whether a matrix is Hermitian.
+"""
+ishermitian
+
+"""
+    sind(x)
+
+Compute sine of `x`, where `x` is in degrees.
+"""
+sind
+
+"""
+    iseltype(A,T)
+
+Tests whether `A` or its elements are of type `T`.
+"""
+iseltype
+
+"""
+    min(x, y, ...)
+
+Return the minimum of the arguments. Operates elementwise over arrays.
+"""
+min
+
+"""
+    isready(r::RemoteChannel)
+
+Determine whether a `RemoteChannel` has a value stored to it. Note that this function can
+cause race conditions, since by the time you receive its result it may no longer be true.
+However, it can be safely used on a `Future` since they are assigned only once.
+"""
+isready
+
+"""
+    isready(r::Future)
+
+Determine whether a `Future` has a value stored to it.
+
+If the argument `Future` is owned by a different node, this call will block to wait for the
+answer. It is recommended to wait for `r` in a separate task instead, or to use a local
+`Channel` as a proxy:
+
+    c = Channel(1)
+    @async put!(c, remotecall_fetch(long_computation, p))
+    isready(c)  # will not block
+"""
+    isready(r::Future)
+
+"""
+    InexactError()
+
+Type conversion cannot be done exactly.
+"""
+InexactError
+
+"""
+    @sync
+
+Wait until all dynamically-enclosed uses of `@async`, `@spawn`, `@spawnat` and `@parallel`
+are complete. All exceptions thrown by enclosed async operations are collected and thrown as
+a `CompositeException`.
+"""
+:@sync
+
+"""
+    typemax(T)
+
+The highest value representable by the given (real) numeric `DataType`.
+"""
+typemax
+
+"""
+    all(itr) -> Bool
+
+Test whether all elements of a boolean collection are `true`.
+"""
+all(itr)
+
+"""
+    all(A, dims)
+
+Test whether all values along the given dimensions of an array are `true`.
+"""
+all(A::AbstractArray, dims)
+
+"""
+    all(p, itr) -> Bool
+
+Determine whether predicate `p` returns `true` for all elements of `itr`.
+
+```jldoctest
+julia> all(i->(4<=i<=6), [4,5,6])
+true
+```
+"""
+all(p, itr)
+
+"""
+    bind(socket::Union{UDPSocket, TCPSocket}, host::IPAddr, port::Integer; ipv6only=false)
+
+Bind `socket` to the given `host:port`. Note that `0.0.0.0` will listen on all devices.
+`ipv6only` parameter disables dual stack mode. If it's `true`, only IPv6 stack is created.
+"""
+bind
+
+"""
+    cld(x, y)
+
+Smallest integer larger than or equal to `x/y`.
+"""
+cld
+
+"""
+    issetuid(path) -> Bool
+
+Returns `true` if `path` has the setuid flag set, `false` otherwise.
+"""
+issetuid
+
+"""
+    scale!(A, b)
+    scale!(b, A)
+
+Scale an array `A` by a scalar `b` overwriting `A` in-place.
+
+If `A` is a matrix and `b` is a vector, then `scale!(A,b)` scales each column `i` of `A` by
+`b[i]` (similar to `A*Diagonal(b)`), while `scale!(b,A)` scales each row `i` of `A` by `b[i]`
+(similar to `Diagonal(b)*A`), again operating in-place on `A`.
+
+"""
+scale!
+
+"""
+    DomainError()
+
+The arguments to a function or constructor are outside the valid domain.
+"""
+DomainError
+
+"""
+    issymmetric(A) -> Bool
+
+Test whether a matrix is symmetric.
+"""
+issymmetric
+
+"""
+    acosh(x)
+
+Compute the inverse hyperbolic cosine of `x`.
+"""
+acosh
+
+"""
+    IntSet([itr])
+
+Construct a sorted set of positive `Int`s generated by the given iterable object, or an
+empty set. Implemented as a bit string, and therefore designed for dense integer sets. Only
+`Int`s greater than 0 can be stored. If the set will be sparse (for example holding a few
+very large integers), use [`Set`](:obj:`Set`) instead.
+"""
+IntSet
+
+"""
+    Task(func)
+
+Create a `Task` (i.e. thread, or coroutine) to execute the given function (which must be
+callable with no arguments). The task exits when this function returns.
+"""
+Task
+
+"""
+    pushdisplay(d::Display)
+
+Pushes a new display `d` on top of the global display-backend stack. Calling `display(x)` or
+`display(mime, x)` will display `x` on the topmost compatible backend in the stack (i.e.,
+the topmost backend that does not throw a `MethodError`).
+"""
+pushdisplay
+
+"""
+    randexp!([rng], A::Array{Float64,N})
+
+Fill the array `A` with random numbers following the exponential distribution (with scale 1).
+"""
+randexp!
+
+"""
+    prevind(str, i)
+
+Get the previous valid string index before `i`. Returns a value less than `1` at the
+beginning of the string.
+"""
+prevind
+
+"""
+    setenv(command, env; dir=working_dir)
+
+Set environment variables to use when running the given `command`. `env` is either a
+dictionary mapping strings to strings, an array of strings of the form `"var=val"`, or zero
+or more `"var"=>val` pair arguments. In order to modify (rather than replace) the existing
+environment, create `env` by `copy(ENV)` and then setting `env["var"]=val` as desired, or
+use `withenv`.
+
+The `dir` keyword argument can be used to specify a working directory for the command.
+"""
+setenv
+
+"""
+    lowercase(string)
+
+Returns `string` with all characters converted to lowercase.
+"""
+lowercase
+
+"""
+    produce(value)
+
+Send the given value to the last `consume` call, switching to the consumer task. If the next
+`consume` call passes any values, they are returned by `produce`.
+"""
+produce
+
+"""
+    StackOverflowError()
+
+The function call grew beyond the size of the call stack. This usually happens when a call
+recurses infinitely.
+"""
+StackOverflowError
+
+"""
+    acsch(x)
+
+Compute the inverse hyperbolic cosecant of `x`.
+"""
+acsch
+
+"""
+    process_running(p::Process)
+
+Determine whether a process is currently running.
+"""
+process_running
+
+"""
+    BigInt(x)
+
+Create an arbitrary precision integer. `x` may be an `Int` (or anything that can be
+converted to an `Int`).  The usual mathematical operators are defined for this type, and
+results are promoted to a `BigInt`.
+
+Instances can be constructed from strings via [`parse`](:func:`parse`), or using the `big`
+string literal.
+"""
+BigInt
+
+"""
+    rsearch(string, chars, [start])
+
+Similar to `search`, but returning the last occurrence of the given characters within the
+given string, searching in reverse from `start`.
+"""
+rsearch
+
+"""
+    isdirpath(path::AbstractString) -> Bool
+
+Determines whether a path refers to a directory (for example, ends with a path separator).
+"""
+isdirpath
+
+"""
+    in(item, collection) -> Bool
+    ∈(item,collection) -> Bool
+    ∋(collection,item) -> Bool
+    ∉(item,collection) -> Bool
+    ∌(collection,item) -> Bool
+
+Determine whether an item is in the given collection, in the sense that it is `==` to one of
+the values generated by iterating over the collection. Some collections need a slightly
+different definition; for example [`Set`](:obj:`Set`)s check whether the item
+[`isequal`](:func:`isequal`) to one of the elements. [`Dict`](:obj:`Dict`)s look for
+`(key,value)` pairs, and the key is compared using [`isequal`](:func:`isequal`). To test for
+the presence of a key in a dictionary, use [`haskey`](:func:`haskey`) or `k in keys(dict)`.
+"""
+Base.in
+
+"""
+    isblockdev(path) -> Bool
+
+Returns `true` if `path` is a block device, `false` otherwise.
+"""
+isblockdev
+
+"""
+    ==(x, y)
+
+Generic equality operator, giving a single `Bool` result. Falls back to `===`. Should be
+implemented for all types with a notion of equality, based on the abstract value that an
+instance represents. For example, all numeric types are compared by numeric value, ignoring
+type. Strings are compared as sequences of characters, ignoring encoding.
+
+Follows IEEE semantics for floating-point numbers.
+
+Collections should generally implement `==` by calling `==` recursively on all contents.
+
+New numeric types should implement this function for two arguments of the new type, and
+handle comparison to other types via promotion rules where possible.
+"""
+Base.(:(==))
+
+"""
+    mapreducedim(f, op, A, dims[, initial])
+
+Evaluates to the same as `reducedim(op, map(f, A), dims, f(initial))`, but is generally
+faster because the intermediate array is avoided.
+"""
+mapreducedim
+
+"""
+    seekstart(s)
+
+Seek a stream to its beginning.
+"""
+seekstart
+
+"""
+    nfields(x::DataType) -> Int
+
+Get the number of fields of a `DataType`.
+"""
+nfields
+
+"""
+    toq()
+
+Return, but do not print, the time elapsed since the last [`tic`](:func:`tic`).
+"""
+toq
+
+"""
+    writemime(stream, mime, x)
+
+The `display` functions ultimately call `writemime` in order to write an object `x` as a
+given `mime` type to a given I/O `stream` (usually a memory buffer), if possible. In order
+to provide a rich multimedia representation of a user-defined type `T`, it is only necessary
+to define a new `writemime` method for `T`, via: `writemime(stream, ::MIME"mime", x::T) = ...`,
+where `mime` is a MIME-type string and the function body calls `write` (or similar) to write
+that representation of `x` to `stream`. (Note that the `MIME""` notation only supports
+literal strings; to construct `MIME` types in a more flexible manner use
+`MIME{symbol("")}`.)
+
+For example, if you define a `MyImage` type and know how to write it to a PNG file, you
+could define a function `writemime(stream, ::MIME"image/png", x::MyImage) = ...` to allow
+your images to be displayed on any PNG-capable `Display` (such as IJulia). As usual, be sure
+to `import Base.writemime` in order to add new methods to the built-in Julia function
+`writemime`.
+
+Technically, the `MIME"mime"` macro defines a singleton type for the given `mime` string,
+which allows us to exploit Julia's dispatch mechanisms in determining how to display objects
+of any given type.
+"""
+writemime
+
+"""
+    mean!(r, v)
+
+Compute the mean of `v` over the singleton dimensions of `r`, and write results to `r`.
+"""
+mean!
+
+"""
+    join(strings, delim, [last])
+
+Join an array of `strings` into a single string, inserting the given delimiter between
+adjacent strings. If `last` is given, it will be used instead of `delim` between the last
+two strings. For example
+
+    join(["apples", "bananas", "pineapples"], ", ", " and ") == "apples, bananas and pineapples"
+
+`strings` can be any iterable over elements `x` which are convertible to strings via `print(io::IOBuffer, x)`.
+"""
+join
+
+"""
+    linreg(x, y) -> a, b
+
+Perform linear regression. Returns `a` and `b` such that `a + b*x` is the closest straight
+line to the given points `(x, y)`, i.e., such that the squared error between `y` and `a +
+b*x` is minimized.
+
+**Example**:
+
+    using PyPlot
+    x = [1.0:12.0;]
+    y = [5.5, 6.3, 7.6, 8.8, 10.9, 11.79, 13.48, 15.02, 17.77, 20.81, 22.0, 22.99]
+    a, b = linreg(x, y)          # Linear regression
+    plot(x, y, "o")              # Plot (x, y) points
+    plot(x, [a+b*i for i in x])  # Plot line determined by linear regression
+"""
+linreg(x,y)
+
+"""
+    linreg(x, y, w)
+
+Weighted least-squares linear regression.
+"""
+linreg(x,y,w)
+
+"""
+    polygamma(m, x)
+
+Compute the polygamma function of order `m` of argument `x` (the `(m+1)th` derivative of the
+logarithm of `gamma(x)`)
+"""
+polygamma
+
+"""
+    isless(x, y)
+
+Test whether `x` is less than `y`, according to a canonical total order. Values that are
+normally unordered, such as `NaN`, are ordered in an arbitrary but consistent fashion. This
+is the default comparison used by `sort`. Non-numeric types with a canonical total order
+should implement this function. Numeric types only need to implement it if they have special
+values such as `NaN`.
+"""
+isless
+
+"""
+    expm1(x)
+
+Accurately compute ``e^x-1``.
+"""
+expm1
+
+"""
+    showerror(io, e)
+
+Show a descriptive representation of an exception object.
+"""
+showerror
+
+"""
+    setdiff(s1,s2)
+
+Construct the set of elements in `s1` but not `s2`. Maintains order with arrays. Note that
+both arguments must be collections, and both will be iterated over. In particular,
+`setdiff(set,element)` where `element` is a potential member of `set`, will not work in
+general.
+"""
+setdiff
+
+"""
+    airyai(x)
+
+Airy function ``\\operatorname{Ai}(x)``.
+"""
+airyai
+
+"""
+    error(message::AbstractString)
+
+Raise an `ErrorException` with the given message.
+"""
+error
+
+"""
+    less(file::AbstractString, [line])
+
+Show a file using the default pager, optionally providing a starting line number. Returns to
+the julia prompt when you quit the pager.
+"""
+less(f::AbstractString, ?)
+
+"""
+    less(function, [types])
+
+Show the definition of a function using the default pager, optionally specifying a tuple of
+types to indicate which method to see.
+"""
+less(m::Method, ?)
+
+"""
+    sqrtm(A)
+
+If `A` has no negative real eigenvalues, compute the principal matrix square root of `A`,
+that is the unique matrix ``X`` with eigenvalues having positive real part such that
+``X^2 = A``. Otherwise, a nonprincipal square root is returned.
+
+If `A` is symmetric or Hermitian, its eigendecomposition ([`eigfact`](:func:`eigfact`)) is
+used to compute the square root. Otherwise, the square root is determined by means of the
+Björck-Hammarling method, which computes the complex Schur form ([`schur`](:func:`schur`))
+and then the complex square root of the triangular factor.
+
+[^BH83]: Åke Björck and Sven Hammarling, "A Schur method for the square root of a matrix", Linear Algebra and its Applications, 52-53, 1983, 127-140. [doi:10.1016/0024-3795(83)80010-X](http://dx.doi.org/10.1016/0024-3795(83)80010-X)
+
+"""
+sqrtm
+
+"""
+    conv(u,v)
+
+Convolution of two vectors. Uses FFT algorithm.
+"""
+conv
+
+"""
+    unsafe_store!(p::Ptr{T},x,i::Integer)
+
+Store a value of type `T` to the address of the ith element (1-indexed) starting at `p`.
+This is equivalent to the C expression `p[i-1] = x`.
+
+The `unsafe` prefix on this function indicates that no validation is performed on the
+pointer `p` to ensure that it is valid. Incorrect usage may corrupt or segfault your
+program, in the same manner as C.
+"""
+unsafe_store!
+
+"""
+    expm(A)
+
+Compute the matrix exponential of `A`, defined by
+
+```math
+e^A = \\sum_{n=0}^{\\infty} \\frac{A^n}{n!}.
+```
+
+For symmetric or Hermitian `A`, an eigendecomposition ([`eigfact`](:func:`eigfact`)) is
+used, otherwise the scaling and squaring algorithm (see [^H05]) is chosen.
+
+[^H05]: Nicholas J. Higham, "The squaring and scaling method for the matrix exponential revisited", SIAM Journal on Matrix Analysis and Applications, 26(4), 2005, 1179-1193. [doi:10.1137/090768539](http://dx.doi.org/10.1137/090768539)
+
+"""
+expm
+
+"""
+    hessfact!(A)
+
+`hessfact!` is the same as [`hessfact`](:func:`hessfact`), but saves space by overwriting
+the input `A`, instead of creating a copy.
+"""
+hessfact!
+
+"""
+    Sys.get_process_title()
+
+Get the process title. On some systems, will always return empty string. (not exported)
+"""
+Sys.get_process_title
+
+"""
+    readcsv(source, [T::Type]; options...)
+
+Equivalent to `readdlm` with `delim` set to comma.
+"""
+readcsv
+
+"""
+    current_module() -> Module
+
+Get the *dynamically* current `Module`, which is the `Module` code is currently being read
+from. In general, this is not the same as the module containing the call to this function.
+"""
+current_module
+
+"""
+    erfcx(x)
+
+Compute the scaled complementary error function of `x`, defined by ``e^{x^2} \\operatorname{erfc}(x)``.
+Note also that ``\\operatorname{erfcx}(-ix)`` computes the Faddeeva function ``w(x)``.
+"""
+erfcx
+
+"""
+    UndefVarError(var::Symbol)
+
+A symbol in the current scope is not defined.
+"""
+UndefVarError
+
+"""
+    gc()
+
+Perform garbage collection. This should not generally be used.
+"""
+gc
+
+"""
+    iscntrl(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is a control character, or whether this is true for all elements
+of a string. Control characters are the non-printing characters of the Latin-1 subset of Unicode.
+"""
+iscntrl
+
+"""
+    hist!(counts, v, e) -> e, counts
+
+Compute the histogram of `v`, using a vector/range `e` as the edges for the bins. This
+function writes the resultant counts to a pre-allocated array `counts`.
+"""
+hist!
+
+"""
+    minimum!(r, A)
+
+Compute the minimum value of `A` over the singleton dimensions of `r`, and write results to `r`.
+"""
+minimum!
+
+"""
+    diagm(v[, k])
+
+Construct a diagonal matrix and place `v` on the `k`th diagonal.
+"""
+diagm
+
+"""
+    .-(x, y)
+
+Element-wise subtraction operator.
+"""
+Base.(:(.-))
+
+"""
+    imag(z)
+
+Return the imaginary part of the complex number `z`.
+"""
+imag
+
+"""
+    unsafe_trunc(T, x)
+
+`unsafe_trunc(T, x)` returns the nearest integral value of type `T` whose absolute value is
+less than or equal to `x`. If the value is not representable by `T`, an arbitrary value will
+be returned.
+"""
+unsafe_trunc
+
+"""
+    parent(A)
+
+Returns the "parent array" of an array view type (e.g., `SubArray`), or the array itself if
+it is not a view.
+"""
+parent
+
+"""
+    <(x, y)
+
+Less-than comparison operator. New numeric types should implement this function for two
+arguments of the new type. Because of the behavior of floating-point NaN values, `<`
+implements a partial order. Types with a canonical partial order should implement `<`, and
+types with a canonical total order should implement `isless`.
+"""
+Base.(:(<))
+
+"""
+    EnvHash() -> EnvHash
+
+A singleton of this type provides a hash table interface to environment variables.
+"""
+EnvHash
+
+"""
+    method_exists(f, Tuple type) -> Bool
+
+Determine whether the given generic function has a method matching the given
+[`Tuple`](:obj:`Tuple`) of argument types.
+
+```jldoctest
+julia> method_exists(length, Tuple{Array})
+true
+```
+"""
+method_exists
+
+"""
+    nextpow(a, x)
+
+The smallest `a^n` not less than `x`, where `n` is a non-negative integer. `a` must be
+greater than 1, and `x` must be greater than 0.
+"""
+nextpow
+
+"""
+    rad2deg(x)
+
+Convert `x` from radians to degrees.
+"""
+rad2deg
+
+"""
+    gc_enable(on::Bool)
+
+Control whether garbage collection is enabled using a boolean argument (`true` for enabled,
+`false` for disabled). Returns previous GC state. Disabling garbage collection should be
+used only with extreme caution, as it can cause memory use to grow without bound.
+"""
+gc_enable
+
+"""
+    sub2ind(dims, i, j, k...) -> index
+
+The inverse of `ind2sub`, returns the linear index corresponding to the provided subscripts.
+"""
+sub2ind
+
+"""
+    supertype(T::DataType)
+
+Return the supertype of DataType `T`.
+"""
+supertype
+
+"""
+    readline(stream::IO=STDIN)
+    readline(filename::AbstractString)
+
+Read a single line of text, including a trailing newline character (if one is reached before
+the end of the input), from the given I/O stream or file (defaults to `STDIN`).
+When reading from a file, the text is assumed to be encoded in UTF-8.
+"""
+readline
+
+"""
+    atan(x)
+
+Compute the inverse tangent of `x`, where the output is in radians.
+"""
+atan
+
+"""
+    logabsdet(M)
+
+Log of absolute value of determinant of real matrix. Equivalent to `(log(abs(det(M))), sign(det(M)))`,
+but may provide increased accuracy and/or speed.
+"""
+logabsdet
+
+"""
+    joinpath(parts...) -> AbstractString
+
+Join path components into a full path. If some argument is an absolute path, then prior
+components are dropped.
+"""
+joinpath
+
+"""
+    precision(BigFloat)
+
+Get the precision (in bits) currently used for `BigFloat` arithmetic.
+"""
+precision(::Type{BigFloat})
+
+"""
+    homedir() -> AbstractString
+
+Return the current user's home directory.
+"""
+homedir
+
+"""
+    count_zeros(x::Integer) -> Integer
+
+Number of zeros in the binary representation of `x`.
+
+```jldoctest
+julia> count_zeros(Int32(2 ^ 16 - 1))
+16
+```
+"""
+count_zeros
+
+"""
+    isinf(f) -> Bool
+
+Test whether a number is infinite.
+"""
+isinf
+
+"""
+    @fetchfrom
+
+Equivalent to `fetch(@spawnat p expr)`.
+"""
+:@fetchfrom
+
+"""
+    secd(x)
+
+Compute the secant of `x`, where `x` is in degrees.
+"""
+secd
+
+"""
+    varm(v, m)
+
+Compute the sample variance of a vector `v` with known mean `m`. Note: Julia does not ignore
+`NaN` values in the computation.
+"""
+varm
+
+"""
+    OverflowError()
+
+The result of an expression is too large for the specified type and will cause a wraparound.
+"""
+OverflowError
+
+"""
+    redirect_stderr([stream])
+
+Like `redirect_stdout`, but for `STDERR`.
+"""
+redirect_stderr
+
+"""
+    ctranspose!(dest,src)
+
+Conjugate transpose array `src` and store the result in the preallocated array `dest`, which
+should have a size corresponding to `(size(src,2),size(src,1))`. No in-place transposition
+is supported and unexpected results will happen if `src` and `dest` have overlapping memory
+regions.
+"""
+ctranspose!
+
+"""
+    object_id(x)
+
+Get a unique integer id for `x`. `object_id(x)==object_id(y)` if and only if `is(x,y)`.
+"""
+object_id
+
+"""
+    norm(A, [p])
+
+Compute the `p`-norm of a vector or the operator norm of a matrix `A`, defaulting to the `p=2`-norm.
+
+For vectors, `p` can assume any numeric value (even though not all values produce a
+mathematically valid vector norm). In particular, `norm(A, Inf)` returns the largest value
+in `abs(A)`, whereas `norm(A, -Inf)` returns the smallest.
+
+For matrices, the matrix norm induced by the vector `p`-norm is used, where valid values of
+`p` are `1`, `2`, or `Inf`. (Note that for sparse matrices, `p=2` is currently not
+implemented.) Use [`vecnorm`](:func:`vecnorm`) to compute the Frobenius norm.
+"""
+norm
+
+"""
+    print_unescaped(io, s::AbstractString)
+
+General unescaping of traditional C and Unicode escape sequences. Reverse of [`print_escaped`](:func:`print_escaped`).
+"""
+print_unescaped
+
+"""
+    digits!(array, n, [base])
+
+Fills an array of the digits of `n` in the given base. More significant digits are at higher
+indexes. If the array length is insufficient, the least significant digits are filled up to
+the array length. If the array length is excessive, the excess portion is filled with zeros.
+"""
+digits!
+
+"""
+    MethodError(f, args)
+
+A method with the required type signature does not exist in the given generic function.
+"""
+MethodError
+
+"""
+    cat(dims, A...)
+
+Concatenate the input arrays along the specified dimensions in the iterable `dims`. For
+dimensions not in `dims`, all input arrays should have the same size, which will also be the
+size of the output array along that dimension. For dimensions in `dims`, the size of the
+output array is the sum of the sizes of the input arrays along that dimension. If `dims` is
+a single number, the different arrays are tightly stacked along that dimension. If `dims` is
+an iterable containing several dimensions, this allows one to construct block diagonal
+matrices and their higher-dimensional analogues by simultaneously increasing several
+dimensions for every new input array and putting zero blocks elsewhere. For example,
+`cat([1,2], matrices...)` builds a block diagonal matrix, i.e. a block matrix with
+`matrices[1]`, `matrices[2]`, ... as diagonal blocks and matching zero blocks away from the
+diagonal.
+"""
+cat
+
+"""
+    factorial(n)
+
+Factorial of `n`.  If `n` is an [`Integer`](:obj:`Integer`), the factorial is computed as an
+integer (promoted to at least 64 bits).  Note that this may overflow if `n` is not small,
+but you can use `factorial(big(n))` to compute the result exactly in arbitrary precision.
+If `n` is not an `Integer`, `factorial(n)` is equivalent to [`gamma(n+1)`](:func:`gamma(n+1) <gamma>`).
+"""
+factorial(n)
+
+"""
+    factorial(n,k)
+
+Compute `factorial(n)/factorial(k)`.
+"""
+factorial(n,k)
+
+"""
+    bitrand([rng], [dims...])
+
+Generate a `BitArray` of random boolean values.
+"""
+bitrand
+
+"""
+    randcycle([rng,] n)
+
+Construct a random cyclic permutation of length `n`. The optional `rng`
+argument specifies a random number generator, see [Random Numbers](:ref:`Random Numbers <random-numbers>`).
+"""
+randcycle
+
+"""
+    leading_zeros(x::Integer) -> Integer
+
+Number of zeros leading the binary representation of `x`.
+
+```jldoctest
+julia> leading_zeros(Int32(1))
+31
+```
+"""
+leading_zeros
+
+"""
+    hankelh2(nu, x)
+
+Bessel function of the third kind of order `nu`, ``H^{(2)}_\\nu(x)``.
+"""
+hankelh2
+
+"""
+    lexcmp(x, y)
+
+Compare `x` and `y` lexicographically and return -1, 0, or 1 depending on whether `x` is
+less than, equal to, or greater than `y`, respectively. This function should be defined for
+lexicographically comparable types, and `lexless` will call `lexcmp` by default.
+"""
+lexcmp
+
+"""
+    inf(f)
+
+Returns positive infinity of the floating point type `f` or of the same floating point type as `f`.
+"""
+inf
+
+"""
+    isupper(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is an uppercase letter, or whether this is true for all elements
+of a string. A character is classified as uppercase if it belongs to Unicode category Lu,
+Letter: Uppercase, or Lt, Letter: Titlecase.
+"""
+isupper
+
+"""
+    pointer_to_array(pointer, dims[, take_ownership::Bool])
+
+Wrap a native pointer as a Julia Array object. The pointer element type determines the array
+element type. `own` optionally specifies whether Julia should take ownership of the memory,
+calling `free` on the pointer when the array is no longer referenced.
+"""
+pointer_to_array
+
+"""
+    show(x)
+
+Write an informative text representation of a value to the current output stream. New types
+should overload `show(io, x)` where the first argument is a stream. The representation used
+by `show` generally includes Julia-specific formatting and type information.
+"""
+show
+
+"""
+    @allocated
+
+A macro to evaluate an expression, discarding the resulting value, instead returning the
+total number of bytes allocated during evaluation of the expression. Note: the expression is
+evaluated inside a local function, instead of the current context, in order to eliminate the
+effects of compilation, however, there still may be some allocations due to JIT compilation.
+This also makes the results inconsistent with the `@time` macros, which do not try to adjust
+for the effects of compilation.
+"""
+:@allocated
+
+"""
+    Array(dims)
+
+`Array{T}(dims)` constructs an uninitialized dense array with element type `T`. `dims` may
+be a tuple or a series of integer arguments. The syntax `Array(T, dims)` is also available,
+but deprecated.
+"""
+Array
+
+"""
+    isreal(x) -> Bool
+
+Test whether `x` or all its elements are numerically equal to some real number.
+"""
+isreal
+
+"""
+    randsubseq(A, p) -> Vector
+
+Return a vector consisting of a random subsequence of the given array `A`, where each
+element of `A` is included (in order) with independent probability `p`. (Complexity is
+linear in `p*length(A)`, so this function is efficient even if `p` is small and `A` is
+large.) Technically, this process is known as "Bernoulli sampling" of `A`.
+"""
+randsubseq
+
+"""
+    issubtype(type1, type2)
+
+Return `true` if and only if all values of `type1` are also of `type2`. Can also be written
+using the `<:` infix operator as `type1 <: type2`.
+"""
+issubtype(type1, type2)
+
+"""
+    finalizer(x, function)
+
+Register a function `f(x)` to be called when there are no program-accessible references to
+`x`. The behavior of this function is unpredictable if `x` is of a bits type.
+"""
+finalizer
+
+"""
+    csch(x)
+
+Compute the hyperbolic cosecant of `x`.
+"""
+csch
+
+"""
+    isequal(x, y)
+
+Similar to `==`, except treats all floating-point `NaN` values as equal to each other, and
+treats `-0.0` as unequal to `0.0`. The default implementation of `isequal` calls `==`, so if
+you have a type that doesn't have these floating-point subtleties then you probably only
+need to define `==`.
+
+`isequal` is the comparison function used by hash tables (`Dict`). `isequal(x,y)` must imply
+that `hash(x) == hash(y)`.
+
+This typically means that if you define your own `==` function then you must define a
+corresponding `hash` (and vice versa). Collections typically implement `isequal` by calling
+`isequal` recursively on all contents.
+
+Scalar types generally do not need to implement `isequal` separate from `==`, unless they
+represent floating-point numbers amenable to a more efficient implementation than that
+provided as a generic fallback (based on `isnan`, `signbit`, and `==`).
+"""
+isequal
+
+"""
+    lyap(A, C)
+
+Computes the solution `X` to the continuous Lyapunov equation `AX + XA' + C = 0`, where no
+eigenvalue of `A` has a zero real part and no two eigenvalues are negative complex
+conjugates of each other.
+"""
+lyap
+
+"""
+    condskeel(M, [x, p])
+
+```math
+\\kappa_S(M, p) & = \\left\\Vert \\left\\vert M \\right\\vert \\left\\vert M^{-1} \\right\\vert  \\right\\Vert_p \\\\
+\\kappa_S(M, x, p) & = \\left\\Vert \\left\\vert M \\right\\vert \\left\\vert M^{-1} \\right\\vert \\left\\vert x \\right\\vert \\right\\Vert_p
+```
+
+Skeel condition number ``\\kappa_S`` of the matrix `M`, optionally with respect to the
+vector `x`, as computed using the operator `p`-norm. `p` is `Inf` by default, if not
+provided. Valid values for `p` are `1`, `2`, or `Inf`.
+
+This quantity is also known in the literature as the Bauer condition number, relative
+condition number, or componentwise relative condition number.
+"""
+condskeel
+
+"""
+    sec(x)
+
+Compute the secant of `x`, where `x` is in radians.
+"""
+sec
+
+"""
+    recv(socket::UDPSocket)
+
+Read a UDP packet from the specified socket, and return the bytes received. This call blocks.
+"""
+recv
+
+"""
+    acoth(x)
+
+Compute the inverse hyperbolic cotangent of `x`.
+"""
+acoth
+
+"""
+    det(M)
+
+Matrix determinant.
+"""
+det
+
+"""
+    TypeError(func::Symbol, context::AbstractString, expected::Type, got)
+
+A type assertion failure, or calling an intrinsic function with an incorrect argument type.
+"""
+TypeError
+
+"""
+    A_rdiv_Bt(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``A / Bᵀ``.
+"""
+A_rdiv_Bt
+
+"""
+    pwd() -> AbstractString
+
+Get the current working directory.
+"""
+pwd
+
+"""
+    getipaddr() -> IPAddr
+
+Get the IP address of the local machine.
+"""
+getipaddr
+
+"""
+    uppercase(string)
+
+Returns `string` with all characters converted to uppercase.
+"""
+uppercase
+
+"""
+    cosd(x)
+
+Compute cosine of `x`, where `x` is in degrees.
+"""
+cosd
+
+"""
+    cycle(iter)
+
+An iterator that cycles through `iter` forever.
+"""
+cycle
+
+"""
+    put!(RemoteChannel, value)
+
+Store a value to the remote channel. If the channel is full, blocks until space is available.
+Returns its first argument.
+"""
+put!(::RemoteChannel, value)
+
+"""
+    put!(Future, value)
+
+Store a value to a future. Future's are write-once remote references. A `put!` on an already
+set `Future` throws an Exception. All asynchronous remote calls return `Future`s and set the
+value to the return value of the call upon completion.
+"""
+put!(::Future, value)
+
+"""
+    put!(Channel, value)
+
+Appends an item to the channel. Blocks if the channel is full.
+"""
+put!(::Channel, value)
+
+"""
+    operm(file)
+
+Like uperm but gets the permissions for people who neither own the file nor are a member of
+the group owning the file
+"""
+operm
+
+"""
+    cumsum(A, [dim])
+
+Cumulative sum along a dimension `dim` (defaults to 1). See also [`cumsum!`](:func:`cumsum!`)
+to use a preallocated output array, both for performance and to control the precision of the
+output (e.g. to avoid overflow).
+"""
+cumsum
+
+"""
+    rmprocs(pids...)
+
+Removes the specified workers.
+"""
+rmprocs
+
+"""
+    rpad(string, n, p)
+
+Make a string at least `n` columns wide when printed, by padding on the right with copies of `p`.
+"""
+rpad
+
+"""
+    setfield!(value, name::Symbol, x)
+
+Assign `x` to a named field in `value` of composite type. The syntax `a.b = c` calls
+`setfield!(a, :b, c)`, and the syntax `a.(b) = c` calls `setfield!(a, b, c)`.
+"""
+setfield!
+
+"""
+    @printf([io::IOStream], "%Fmt", args...)
+
+Print `args` using C `printf()` style format specification string. Optionally, an `IOStream`
+may be passed as the first argument to redirect output.
+"""
+:@printf
+
+"""
+    rstrip(string, [chars])
+
+Return `string` with any trailing whitespace removed. If `chars` (a character, or vector or
+set of characters) is provided, instead remove characters contained in it.
+"""
+rstrip
+
+"""
+    countlines(io,[eol::Char])
+
+Read `io` until the end of the stream/file and count the number of lines. To specify a file
+pass the filename as the first argument. EOL markers other than '\\n' are supported by
+passing them as the second argument.
+"""
+countlines
+
+"""
+```
+*(A, B)
+```
+
+Matrix multiplication.
+"""
+Base.(:(*))(::AbstractMatrix, ::AbstractMatrix)
+
+"""
+    \\(A, B)
+
+Matrix division using a polyalgorithm. For input matrices `A` and `B`, the result `X` is
+such that `A*X == B` when `A` is square.  The solver that is used depends upon the structure
+of `A`.  A direct solver is used for upper or lower triangular `A`.  For Hermitian `A`
+(equivalent to symmetric `A` for non-complex `A`) the `BunchKaufman` factorization is used.
+Otherwise an LU factorization is used. For rectangular `A` the result is the minimum-norm
+least squares solution computed by a pivoted QR factorization of `A` and a rank estimate of
+`A` based on the R factor.
+
+When `A` is sparse, a similar polyalgorithm is used. For indefinite matrices, the `LDLt`
+factorization does not use pivoting during the numerical factorization and therefore the
+procedure can fail even for invertible matrices.
+"""
+Base.(:(\))(A,B)
+
+"""
+    .\\(x, y)
+
+Element-wise left division operator.
+"""
+Base.(:(.\))(x,y)
+
+"""
+    \\(x, y)
+
+Left division operator: multiplication of `y` by the inverse of `x` on the left. Gives
+floating-point results for integer arguments.
+"""
+Base.(:(\))(x::Number,y::Number)
+
+
+"""
+```
+*(x, y...)
+```
+
+Multiplication operator. `x*y*z*...` calls this function with all arguments, i.e. `*(x, y, z, ...)`.
+"""
+Base.(:(*))(x, y...)
+
+"""
+```
+*(s, t)
+```
+
+Concatenate strings. The `*` operator is an alias to this function.
+
+```jldoctest
+julia> "Hello " * "world"
+"Hello world"
+```
+"""
+Base.(:(*))(s::AbstractString, t::AbstractString)
+
+"""
+    complement!(s)
+
+Mutates [`IntSet`](:obj:`IntSet`) `s` into its set-complement.
+"""
+complement!
+
+"""
+    slice(A, inds...)
+
+Returns a view of array `A` with the given indices like [`sub`](:func:`sub`), but drops all
+dimensions indexed with scalars.
+"""
+slice
+
+"""
+    time()
+
+Get the system time in seconds since the epoch, with fairly high (typically, microsecond) resolution.
+"""
+time()
+
+"""
+    procs()
+
+Returns a list of all process identifiers.
+"""
+procs
+
+"""
+    procs(S::SharedArray)
+
+Get the vector of processes that have mapped the shared array.
+"""
+procs(::SharedArray)
+
+"""
+    mod(x, y)
+
+Modulus after flooring division, returning in the range \[0,`y`), if `y` is positive, or
+(`y`,0\] if `y` is negative.
+
+```julia
+x == fld(x,y)*y + mod(x,y)
+```
+"""
+mod
+
+"""
+    trues(dims)
+
+Create a `BitArray` with all values set to `true`.
+"""
+trues
+
+"""
+    qr(A [,pivot=Val{false}][;thin=true]) -> Q, R, [p]
+
+Compute the (pivoted) QR factorization of `A` such that either `A = Q*R` or `A[:,p] = Q*R`.
+Also see `qrfact`. The default is to compute a thin factorization. Note that `R` is not
+extended with zeros when the full `Q` is requested.
+"""
+qr
+
+"""
+    invmod(x,m)
+
+Take the inverse of `x` modulo `m`: `y` such that ``xy = 1 \\pmod m``.
+"""
+invmod
+
+"""
+    TextDisplay(stream)
+
+Returns a `TextDisplay <: Display`, which can display any object as the text/plain MIME type
+(only), writing the text representation to the given I/O stream. (The text representation is
+the same as the way an object is printed in the Julia REPL.)
+"""
+TextDisplay
+
+"""
+    factor(n) -> Dict
+
+Compute the prime factorization of an integer `n`. Returns a dictionary. The keys of the
+dictionary correspond to the factors, and hence are of the same type as `n`. The value
+associated with each key indicates the number of times the factor appears in the
+factorization.
+
+```jldoctest
+julia> factor(100) # == 2*2*5*5
+Dict{Int64,Int64} with 2 entries:
+  2 => 2
+  5 => 2
+```
+"""
+factor
+
+"""
+    ismatch(r::Regex, s::AbstractString) -> Bool
+
+Test whether a string contains a match of the given regular expression.
+"""
+ismatch
+
+"""
+    exp(x)
+
+Compute ``e^x``.
+"""
+exp
+
+"""
+    searchindex(string, substring, [start])
+
+Similar to `search`, but return only the start index at which the substring is found, or `0` if it is not.
+"""
+searchindex
+
+"""
+    listenany(port_hint) -> (UInt16,TCPServer)
+
+Create a `TCPServer` on any port, using hint as a starting point. Returns a tuple of the
+actual port that the server was created on and the server itself.
+"""
+listenany
+
+"""
+    getpid() -> Int32
+
+Get julia's process ID.
+"""
+getpid
+
+"""
+    cbrt(x)
+
+Return ``x^{1/3}``.  The prefix operator `∛` is equivalent to `cbrt`.
+"""
+cbrt
+
+"""
+    Tridiagonal(dl, d, du)
+
+Construct a tridiagonal matrix from the lower diagonal, diagonal, and upper diagonal,
+respectively.  The result is of type `Tridiagonal` and provides efficient specialized linear
+solvers, but may be converted into a regular matrix with [`full`](:func:`full`).
+"""
+Tridiagonal
+
+"""
+    findprev(A, i)
+
+Find the previous index <= `i` of a non-zero element of `A`, or `0` if not found.
+"""
+findprev(A,i)
+
+"""
+    findprev(predicate, A, i)
+
+Find the previous index <= `i` of an element of `A` for which `predicate` returns `true`, or
+`0` if not found.
+"""
+findprev(predicate::Function,A,i)
+
+"""
+    findprev(A, v, i)
+
+Find the previous index <= `i` of an element of `A` equal to `v` (using `==`), or `0` if not found.
+"""
+findprev(A,v,i)
+
+"""
+    matchall(r::Regex, s::AbstractString[, overlap::Bool=false]) -> Vector{AbstractString}
+
+Return a vector of the matching substrings from eachmatch.
+"""
+matchall
+
+"""
+    get!(collection, key, default)
+
+Return the value stored for the given key, or if no mapping for the key is present, store
+`key => default`, and return `default`.
+"""
+get!(collection,key,default)
+
+"""
+    get!(f::Function, collection, key)
+
+Return the value stored for the given key, or if no mapping for the key is present, store
+`key => f()`, and return `f()`.
+
+This is intended to be called using `do` block syntax:
+
+    get!(dict, key) do
+        # default value calculated here
+        time()
+    end
+"""
+get!(f::Function,collection,key)
+
+"""
+    inv(M)
+
+Matrix inverse.
+"""
+inv
+
+"""
+    fld1(x, y)
+
+Flooring division, returning a value consistent with `mod1(x,y)`
+
+```julia
+x == fld(x,y)*y + mod(x,y)
+x == (fld1(x,y)-1)*y + mod1(x,y)
+```
+"""
+fld1
+
+"""
+    mod1(x, y)
+
+Modulus after flooring division, returning a value in the range `(0, y]`.
+"""
+mod1
+
+"""
+    fldmod1(x, y)
+
+Return `(fld1(x,y), mod1(x,y))`.
+"""
+fldmod1
+
+"""
+    @assert cond [text]
+
+Throw an `AssertionError` if `cond` is `false`. Preferred syntax for writing assertions.
+Message `text` is optionally displayed upon assertion failure.
+"""
+:@assert
+
+"""
+    intersect!(s1, s2)
+
+Intersects sets `s1` and `s2` and overwrites the set `s1` with the result. If needed, `s1`
+will be expanded to the size of `s2`.
+"""
+intersect!
+
+"""
+    listen([addr,]port) -> TCPServer
+
+Listen on port on the address specified by `addr`. By default this listens on localhost
+only. To listen on all interfaces pass `IPv4(0)` or `IPv6(0)` as appropriate.
+"""
+listen(addr,port)
+
+"""
+    listen(path) -> PipeServer
+
+Create and listen on a Named Pipe / Domain Socket.
+"""
+listen(path)
+
+"""
+    leading_ones(x::Integer) -> Integer
+
+Number of ones leading the binary representation of `x`.
+
+```jldoctest
+julia> leading_ones(UInt32(2 ^ 32 - 2))
+31
+```
+"""
+leading_ones
+
+"""
+    deserialize(stream)
+
+Read a value written by `serialize`.
+"""
+deserialize
+
+"""
+    asech(x)
+
+Compute the inverse hyperbolic secant of `x`.
+"""
+asech
+
+"""
+    ismarked(s)
+
+Returns `true` if stream `s` is marked.
+
+See also [`mark`](:func:`mark`), [`unmark`](:func:`unmark`), [`reset`](:func:`reset`).
+"""
+ismarked
+
+"""
+    first(coll)
+
+Get the first element of an iterable collection. Returns the start point of a
+[`Range`](:obj:`Range`) even if it is empty.
+"""
+first
+
+"""
+    median!(v)
+
+Like `median`, but may overwrite the input vector.
+"""
+median!
+
+"""
+    cumprod!(B, A, [dim])
+
+Cumulative product of `A` along a dimension, storing the result in `B`. The dimension defaults to 1.
+"""
+cumprod!
+
+"""
+    @linux
+
+Given `@linux? a : b`, do `a` on Linux and `b` elsewhere. See documentation [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@linux
+
+"""
+    @linux_only
+
+A macro that evaluates the given expression only on Linux systems. See documentation in [Handling Operating System Variation](:ref:`Handling Operating System Variation <man-handling-operating-system-variation>`).
+"""
+:@linux_only
+
+"""
+    complement(s)
+
+Returns the set-complement of [`IntSet`](:obj:`IntSet`) `s`.
+"""
+complement
+
+"""
+    rethrow([e])
+
+Throw an object without changing the current exception backtrace. The default argument is
+the current exception (if called within a `catch` block).
+"""
+rethrow
+
+"""
+    reprmime(mime, x)
+
+Returns an `AbstractString` or `Vector{UInt8}` containing the representation of `x` in the
+requested `mime` type, as written by `writemime` (throwing a `MethodError` if no appropriate
+`writemime` is available). An `AbstractString` is returned for MIME types with textual
+representations (such as `"text/html"` or `"application/postscript"`), whereas binary data
+is returned as `Vector{UInt8}`. (The function `istext(mime)` returns whether or not Julia
+treats a given `mime` type as text.)
+
+As a special case, if `x` is an `AbstractString` (for textual MIME types) or a
+`Vector{UInt8}` (for binary MIME types), the `reprmime` function assumes that `x` is already
+in the requested `mime` format and simply returns `x`.
+"""
+reprmime
+
+"""
+    rm(path::AbstractString; force=false, recursive=false)
+
+Delete the file, link, or empty directory at the given path. If `force=true` is passed, a
+non-existing path is not treated as error. If `recursive=true` is passed and the path is a
+directory, then all contents are removed recursively.
+"""
+rm
+
+"""
+    MersenneTwister([seed])
+
+Create a `MersenneTwister` RNG object. Different RNG objects can have their own seeds, which
+may be useful for generating different streams of random numbers.
+"""
+MersenneTwister
+
+"""
+    graphemes(s) -> iterator over substrings of s
+
+Returns an iterator over substrings of `s` that correspond to the extended graphemes in the
+string, as defined by Unicode UAX #29. (Roughly, these are what users would perceive as
+single characters, even though they may contain more than one codepoint; for example a
+letter combined with an accent mark is a single grapheme.)
+"""
+graphemes
+
+"""
+    @__FILE__ -> AbstractString
+
+`@__FILE__` expands to a string with the absolute file path of the file containing the
+macro. Returns `nothing` if run from a REPL or an empty string if evaluated by
+`julia -e <expr>`. Alternatively see [`PROGRAM_FILE`](:data:`PROGRAM_FILE`).
+"""
+:@__FILE__
+
+"""
+    charwidth(c)
+
+Gives the number of columns needed to print a character.
+"""
+charwidth
+
+"""
+    abspath(path::AbstractString) -> AbstractString
+
+Convert a path to an absolute path by adding the current directory if necessary.
+"""
+abspath
+
+"""
+    ispunct(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character belongs to the Unicode general category Punctuation, i.e. a
+character whose category code begins with 'P'. For strings, tests whether this is true for
+all elements of the string.
+"""
+ispunct
+
+"""
+    bitunpack(B::BitArray{N}) -> Array{Bool,N}
+
+Converts a packed boolean array to an array of booleans.
+"""
+bitunpack
+
+"""
+    @which
+
+Applied to a function call, it evaluates the arguments to the specified function call, and
+returns the `Method` object for the method that would be called for those arguments. Applied
+to a variable, it returns the module in which the variable was bound. It calls out to the
+`which` function.
+"""
+:@which
+
+"""
+    size(A, [dim...])
+
+Returns a tuple containing the dimensions of `A`. Optionally you can specify the
+dimension(s) you want the length of, and get the length of that dimension, or a tuple of the
+lengths of dimensions you asked for.:
+
+    julia> A = rand(2,3,4);
+
+    julia> size(A, 2)
+    3
+
+    julia> size(A,3,2)
+    (4,3)
+"""
+size
+
+"""
+    trigamma(x)
+
+Compute the trigamma function of `x` (the logarithmic second derivative of `gamma(x)`).
+"""
+trigamma
+
+"""
+    findmin(itr) -> (x, index)
+
+Returns the minimum element and its index.
+"""
+findmin(itr)
+
+"""
+    findmin(A, dims) -> (minval, index)
+
+For an array input, returns the value and index of the minimum over the given dimensions.
+"""
+findmin(A,dims)
+
+"""
+    ismount(path) -> Bool
+
+Returns `true` if `path` is a mount point, `false` otherwise.
+"""
+ismount
+
+"""
+    endswith(string, suffix)
+
+Returns `true` if `string` ends with `suffix`. If `suffix` is a vector or set of
+characters, tests whether the last character of `string` belongs to that set.
+"""
+endswith
+
+"""
+    airy(k,x)
+
+The `k`th derivative of the Airy function ``\\operatorname{Ai}(x)``.
+"""
+airy
+
+"""
+    !(x)
+
+Boolean not.
+"""
+Base.(:(!))
+
+"""
+    length(A) -> Integer
+
+Returns the number of elements in `A`.
+"""
+length(::AbstractArray)
+
+"""
+    length(collection) -> Integer
+
+For ordered, indexable collections, the maximum index `i` for which `getindex(collection, i)`
+is valid. For unordered collections, the number of elements.
+"""
+length(collection)
+
+"""
+    length(s)
+
+The number of characters in string `s`.
+"""
+length(::AbstractString)
+
+"""
+    rand!([rng], A, [coll])
+
+Populate the array `A` with random values. If the indexable collection `coll` is specified,
+the values are picked randomly from `coll`. This is equivalent to `copy!(A, rand(rng, coll, size(A)))`
+or `copy!(A, rand(rng, eltype(A), size(A)))` but without allocating a new array.
+"""
+rand!
+
+"""
+    bkfact(A) -> BunchKaufman
+
+Compute the Bunch-Kaufman [^Bunch1977] factorization of a real symmetric or complex Hermitian
+matrix `A` and return a `BunchKaufman` object. The following functions are available for
+`BunchKaufman` objects: `size`, `\\`, `inv`, `issymmetric`, `ishermitian`.
+
+[^Bunch1977]: J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. [url](http://www.ams.org/journals/mcom/1977-31-137/S0025-5718-1977-0428694-0).
+
+"""
+bkfact
+
+"""
+    searchsortedlast(a, x, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Returns the index of the last value in `a` less than or equal to `x`, according to the
+specified order. Returns `0` if `x` is less than all values in `a`.
+"""
+searchsortedlast
+
+"""
+    InterruptException()
+
+The process was stopped by a terminal interrupt (CTRL+C).
+"""
+InterruptException
+
+"""
+    den(x)
+
+Denominator of the rational representation of `x`.
+"""
+den
+
+"""
+    issubnormal(f) -> Bool
+
+Test whether a floating point number is subnormal.
+"""
+issubnormal
+
+"""
+    Ac_ldiv_B(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ`` \\ ``B``.
+"""
+Ac_ldiv_B
+
+"""
+    NullException()
+
+An attempted access to a `Nullable` with no defined value.
+"""
+NullException
+
+"""
+    .==(x, y)
+
+Element-wise equality comparison operator.
+"""
+Base.(:(.==))
+
+"""
+    cfunction(function::Function, ReturnType::Type, (ArgumentTypes...))
+
+Generate C-callable function pointer from Julia function. Type annotation of the return
+value in the callback function is a must for situations where Julia cannot infer the return
+type automatically.
+
+For example:
+
+    function foo()
+        # body
+
+        retval::Float64
+    end
+
+    bar = cfunction(foo, Float64, ())
+"""
+cfunction
+
+"""
+    recvfrom(socket::UDPSocket) -> (address, data)
+
+Read a UDP packet from the specified socket, returning a tuple of (address, data), where
+address will be either IPv4 or IPv6 as appropriate.
+"""
+recvfrom
+
+"""
+    @code_llvm
+
+Evaluates the arguments to the function call, determines their types, and calls
+[`code_llvm`](:func:`code_llvm`) on the resulting expression.
+"""
+:@code_llvm
+
+"""
+    nextfloat(f)
+
+Get the next floating point number in lexicographic order.
+"""
+nextfloat
+
+"""
+    intersect(s1,s2...)
+    ∩(s1,s2)
+
+Construct the intersection of two or more sets. Maintains order and multiplicity of the
+first argument for arrays and ranges.
+"""
+intersect
+
+"""
+    !=(x, y)
+    ≠(x,y)
+
+Not-equals comparison operator. Always gives the opposite answer as `==`. New types should
+generally not implement this, and rely on the fallback definition `!=(x,y) = !(x==y)` instead.
+"""
+Base.(:(!=))
+
+"""
+    @spawn
+
+Creates a closure around an expression and runs it on an automatically-chosen process,
+returning a `Future` to the result.
+"""
+:@spawn
+
+"""
+    findfirst(A)
+
+Return the index of the first non-zero value in `A` (determined by `A[i]!=0`).
+"""
+findfirst(A)
+
+"""
+    findfirst(A,v)
+
+Return the index of the first element equal to `v` in `A`.
+"""
+findfirst(A,v)
+
+"""
+    findfirst(predicate, A)
+
+Return the index of the first element of `A` for which `predicate` returns `true`.
+"""
+findfirst
+
+"""
+    factorize(A)
+
+Compute a convenient factorization (including LU, Cholesky, Bunch-Kaufman, LowerTriangular,
+UpperTriangular) of `A`, based upon the type of the input matrix. The return value can then
+be reused for efficient solving of multiple systems. For example: `A=factorize(A); x=A\\b; y=A\\C`.
+"""
+factorize
+
+"""
+    promote_rule(type1, type2)
+
+Specifies what type should be used by `promote` when given values of types `type1` and
+`type2`. This function should not be called directly, but should have definitions added to
+it for new types as appropriate.
+"""
+promote_rule
+
+"""
+    mtime(file)
+
+Equivalent to `stat(file).mtime`.
+"""
+mtime
+
+"""
+    logspace(start, stop, n=50)
+
+Construct a vector of `n` logarithmically spaced numbers from `10^start` to `10^stop`.
+"""
+logspace
+
+"""
+    @gensym
+
+Generates a gensym symbol for a variable. For example, `@gensym x y` is transformed into
+`x = gensym("x"); y = gensym("y")`.
+"""
+:@gensym
+
+"""
+    sumabs2(itr)
+
+Sum squared absolute values of all elements in a collection. This is equivalent to `sum(abs2(itr))` but faster.
+"""
+sumabs2(itr)
+
+"""
+    sumabs2(A, dims)
+
+Sum squared absolute values of elements of an array over the given dimensions.
+"""
+sumabs2(A,dims)
+
+"""
+    uperm(file)
+
+Gets the permissions of the owner of the file as a bitfield of
+
+| Value | Description        |
+|:------|:-------------------|
+| 01    | Execute Permission |
+| 02    | Write Permission   |
+| 04    | Read Permission    |
+
+For allowed arguments, see `stat`.
+"""
+uperm
+
+"""
+    run(command)
+
+Run a command object, constructed with backticks. Throws an error if anything goes wrong,
+including the process exiting with a non-zero status.
+"""
+run
+
+"""
+    showall(x)
+
+Similar to `show`, except shows all elements of arrays.
+"""
+showall
+
+"""
+    mimewritable(mime, x)
+
+Returns a boolean value indicating whether or not the object `x` can be written as the given
+`mime` type. (By default, this is determined automatically by the existence of the
+corresponding `writemime` function for `typeof(x)`.)
+"""
+mimewritable
+
+"""
+    vecdot(x, y)
+
+For any iterable containers `x` and `y` (including arrays of any dimension) of numbers (or
+any element type for which `dot` is defined), compute the Euclidean dot product (the sum of
+`dot(x[i],y[i])`) as if they were vectors.
+"""
+vecdot
+
+"""
+    isprime(x::Integer) -> Bool
+
+Returns `true` if `x` is prime, and `false` otherwise.
+
+```jldoctest
+julia> isprime(3)
+true
+```
+"""
+isprime(::Integer)
+
+"""
+    isprime(x::BigInt, [reps = 25]) -> Bool
+
+Probabilistic primality test. Returns `true` if `x` is prime; and `false` if `x` is not
+prime with high probability. The false positive rate is about `0.25^reps`. `reps = 25` is
+considered safe for cryptographic applications (Knuth, Seminumerical Algorithms).
+
+```jldoctest
+julia> isprime(big(3))
+true
+```
+"""
+isprime(::BigInt, ?)
+
+"""
+    >(x, y)
+
+Greater-than comparison operator. Generally, new types should implement `<` instead of this
+function, and rely on the fallback definition `>(x,y) = y<x`.
+"""
+Base.(:(>))
+
+"""
+    match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])
+
+Search for the first match of the regular expression `r` in `s` and return a `RegexMatch`
+object containing the match, or nothing if the match failed. The matching substring can be
+retrieved by accessing `m.match` and the captured sequences can be retrieved by accessing
+`m.captures` The optional `idx` argument specifies an index at which to start the search.
+"""
+match
+
+"""
+    nprocs()
+
+Get the number of available processes.
+"""
+nprocs
+
+"""
+    Ac_mul_B(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ⋅B``.
+"""
+Ac_mul_B
+
+"""
+    qrfact!(A [,pivot=Val{false}])
+
+`qrfact!` is the same as [`qrfact`](:func:`qrfact`) when `A` is a subtype of
+`StridedMatrix`, but saves space by overwriting the input `A`, instead of creating a copy.
+"""
+qrfact!
+
+"""
+    At_rdiv_B(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ / B``.
+"""
+At_rdiv_B
+
+"""
+    coth(x)
+
+Compute the hyperbolic cotangent of `x`.
+"""
+coth
+
+"""
+    conj(z)
+
+Compute the complex conjugate of a complex number `z`.
+"""
+conj
+
+"""
+    conj!(A)
+
+Convert an array to its complex conjugate in-place.
+"""
+conj!
+
+"""
+    start(iter) -> state
+
+Get initial iteration state for an iterable object.
+"""
+start
+
+"""
+    div(x, y)
+    ÷(x, y)
+
+The quotient from Euclidean division. Computes `x/y`, truncated to an integer.
+"""
+div
+
+"""
+    relpath(path::AbstractString, startpath::AbstractString = ".") -> AbstractString
+
+Return a relative filepath to path either from the current directory or from an optional
+start directory. This is a path computation: the filesystem is not accessed to confirm the
+existence or nature of path or startpath.
+"""
+relpath
+
+"""
+    readavailable(stream)
+
+Read all available data on the stream, blocking the task only if no data is available. The
+result is a `Vector{UInt8,1}`.
+"""
+readavailable
+
+"""
+    remotecall(func, id, args...)
+
+Call a function asynchronously on the given arguments on the specified process. Returns a `Future`.
+"""
+remotecall
+
+"""
+    slicedim(A, d, i)
+
+Return all the data of `A` where the index for dimension `d` equals `i`. Equivalent to
+`A[:,:,...,i,:,:,...]` where `i` is in position `d`.
+"""
+slicedim
+
+"""
+    isa(x, type) -> Bool
+
+Determine whether `x` is of the given `type`.
+"""
+isa
+
+"""
+    <=(x, y)
+    ≤(x,y)
+
+Less-than-or-equals comparison operator.
+"""
+Base.(:(<=))
+
+"""
+    ProcessExitedException()
+
+After a client Julia process has exited, further attempts to reference the dead child will
+throw this exception.
+"""
+ProcessExitedException
+
+"""
+    unsafe_load(p::Ptr{T},i::Integer)
+
+Load a value of type `T` from the address of the ith element (1-indexed) starting at `p`.
+This is equivalent to the C expression `p[i-1]`.
+
+The `unsafe` prefix on this function indicates that no validation is performed on the
+pointer `p` to ensure that it is valid. Incorrect usage may segfault your program or return
+garbage answers, in the same manner as C.
+"""
+unsafe_load
+
+"""
+    catch_backtrace()
+
+Get the backtrace of the current exception, for use within `catch` blocks.
+"""
+catch_backtrace
+
+"""
+    airyx(k,x)
+
+scaled `k`th derivative of the Airy function, return ``\\operatorname{Ai}(x) e^{\\frac{2}{3} x \\sqrt{x}}``
+for `k == 0 || k == 1`, and ``\\operatorname{Ai}(x) e^{- \\left| \\operatorname{Re} \\left( \\frac{2}{3} x \\sqrt{x} \\right) \\right|}``
+for `k == 2 || k == 3`.
+"""
+airyx
+
+"""
+    get_zero_subnormals() -> Bool
+
+Returns `false` if operations on subnormal floating-point values ("denormals") obey rules
+for IEEE arithmetic, and `true` if they might be converted to zeros.
+"""
+get_zero_subnormals
+
+"""
+    cos(x)
+
+Compute cosine of `x`, where `x` is in radians.
+"""
+cos
+
+"""
+    base64encode(writefunc, args...)
+    base64encode(args...)
+
+Given a `write`-like function `writefunc`, which takes an I/O stream as its first argument,
+`base64(writefunc, args...)` calls `writefunc` to write `args...` to a base64-encoded
+string, and returns the string. `base64(args...)` is equivalent to `base64(write, args...)`:
+it converts its arguments into bytes using the standard `write` functions and returns the
+base64-encoded string.
+"""
+base64encode
+
+"""
+    Condition()
+
+Create an edge-triggered event source that tasks can wait for. Tasks that call `wait` on a
+`Condition` are suspended and queued. Tasks are woken up when `notify` is later called on
+the `Condition`. Edge triggering means that only tasks waiting at the time `notify` is
+called can be woken up. For level-triggered notifications, you must keep extra state to keep
+track of whether a notification has happened. The `Channel` type does this, and so can be
+used for level-triggered events.
+"""
+Condition
+
+"""
+    filt!(out, b, a, x, [si])
+
+Same as [`filt`](:func:`filt`) but writes the result into the `out` argument, which may
+alias the input `x` to modify it in-place.
+"""
+filt!
+
+"""
+    ascii(::Array{UInt8,1})
+
+Create an ASCII string from a byte array.
+"""
+ascii(::Vector{UInt8})
+
+"""
+    ascii(s)
+
+Convert a string to a contiguous ASCII string (all characters must be valid ASCII characters).
+"""
+ascii(s)
+
+"""
+    ascii(::Ptr{UInt8}, [length])
+
+Create an ASCII string from the address of a C (0-terminated) string encoded in ASCII. A
+copy is made; the ptr can be safely freed. If `length` is specified, the string does not
+have to be 0-terminated.
+"""
+ascii(::Ptr{UInt8},?)
+
+"""
+    maxabs(itr)
+
+Compute the maximum absolute value of a collection of values.
+"""
+maxabs(itr)
+
+"""
+    maxabs(A, dims)
+
+Compute the maximum absolute values over given dimensions.
+"""
+maxabs(A,dims)
+
+"""
+    done(iter, state) -> Bool
+
+Test whether we are done iterating.
+"""
+done
+
+"""
+    convert(T, x)
+
+Convert `x` to a value of type `T`.
+
+If `T` is an `Integer` type, an [`InexactError`](:exc:`InexactError`) will be raised if `x`
+is not representable by `T`, for example if `x` is not integer-valued, or is outside the
+range supported by `T`.
+
+```jldoctest
+julia> convert(Int, 3.0)
+3
+
+julia> convert(Int, 3.5)
+ERROR: InexactError()
+ in convert at int.jl:209
+```
+
+If `T` is a [`AbstractFloat`](:obj:`AbstractFloat`) or [`Rational`](:obj:`Rational`) type,
+then it will return the closest value to `x` representable by `T`.
+
+```jldoctest
+julia> x = 1/3
+0.3333333333333333
+
+julia> convert(Float32, x)
+0.33333334f0
+
+julia> convert(Rational{Int32}, x)
+1//3
+
+julia> convert(Rational{Int64}, x)
+6004799503160661//18014398509481984
+```
+"""
+convert
+
+"""
+    A_ldiv_Bt(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``A`` \\ ``Bᵀ``.
+"""
+A_ldiv_Bt
+
+"""
+    applicable(f, args...) -> Bool
+
+Determine whether the given generic function has a method applicable to the given arguments.
+
+```jldoctest
+julia> function f(x, y)
+           x + y
+       end;
+
+julia> applicable(f, 1)
+false
+
+julia> applicable(f, 1, 2)
+true
+```
+"""
+applicable
+
+"""
+    xdump(x)
+
+Show all structure of a value, including all fields of objects.
+"""
+xdump
+
+"""
+    Base.process_messages(instrm::AsyncStream, outstrm::AsyncStream)
+
+Called by cluster managers using custom transports. It should be called when the custom
+transport implementation receives the first message from a remote worker. The custom
+transport must manage a logical connection to the remote worker and provide two
+`AsyncStream` objects, one for incoming messages and the other for messages addressed to the
+remote worker.
+"""
+Base.process_messages
+
+"""
+    RandomDevice()
+
+Create a `RandomDevice` RNG object. Two such objects will always generate different streams of random numbers.
+"""
+RandomDevice
+
+"""
+    fma(x, y, z)
+
+Computes `x*y+z` without rounding the intermediate result `x*y`. On some systems this is
+significantly more expensive than `x*y+z`. `fma` is used to improve accuracy in certain
+algorithms. See `muladd`.
+"""
+fma
+
+"""
+
+    eigvals(A,[irange,][vl,][vu]) -> values
+
+Returns the eigenvalues of `A`. If `A` is `Symmetric`, `Hermitian` or `SymTridiagonal`,
+it is possible to calculate only a subset of the eigenvalues by specifying either a
+`UnitRange` `irange` covering indices of the sorted eigenvalues, or a pair `vl` and `vu`
+for the lower and upper boundaries of the eigenvalues.
+
+For general non-symmetric matrices it is possible to specify how the matrix is balanced
+before the eigenvector calculation. The option `permute=true` permutes the matrix to
+become closer to upper triangular, and `scale=true` scales the matrix by its diagonal
+elements to make rows and columns moreequal in norm. The default is `true` for both
+options.
+"""
+eigvals
+
+"""
+    A_ldiv_Bc(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``A`` \\ ``Bᴴ``.
+"""
+A_ldiv_Bc
+
+"""
+    escape_string(str::AbstractString) -> AbstractString
+
+General escaping of traditional C and Unicode escape sequences. See
+[`print_escaped`](:func:`print_escaped`) for more general escaping.
+"""
+escape_string
+
+"""
+    significand(x)
+
+Extract the `significand(s)` (a.k.a. mantissa), in binary representation, of a
+floating-point number or array. If `x` is a non-zero finite number, than the result will be
+a number of the same type on the interval ``[1,2)``. Otherwise `x` is returned.
+
+```jldoctest
+julia> significand(15.2)/15.2
+0.125
+
+julia> significand(15.2)*8
+15.2
+```
+"""
+significand
+
+"""
+    pointer_from_objref(object_instance)
+
+Get the memory address of a Julia object as a `Ptr`. The existence of the resulting `Ptr`
+will not protect the object from garbage collection, so you must ensure that the object
+remains referenced for the whole time that the `Ptr` will be used.
+"""
+pointer_from_objref
+
+"""
+    cumsum_kbn(A, [dim])
+
+Cumulative sum along a dimension, using the Kahan-Babuska-Neumaier compensated summation
+algorithm for additional accuracy. The dimension defaults to 1.
+"""
+cumsum_kbn
+
+"""
+    cmp(x,y)
+
+Return -1, 0, or 1 depending on whether `x` is less than, equal to, or greater than `y`,
+respectively. Uses the total order implemented by `isless`. For floating-point numbers, uses `<`
+but throws an error for unordered arguments.
+"""
+cmp
+
+"""
+    tand(x)
+
+Compute tangent of `x`, where `x` is in degrees.
+"""
+tand
+
+"""
+    issorted(v, [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Test whether a vector is in sorted order. The `by`, `lt` and `rev` keywords modify what
+order is considered to be sorted just as they do for `sort`.
+"""
+issorted
+
+"""
+    isbits(T)
+
+Return `true` if `T` is a "plain data" type, meaning it is immutable and contains no
+references to other values. Typical examples are numeric types such as `UInt8`, `Float64`,
+and `Complex{Float64}`.
+
+```jldoctest
+julia> isbits(Complex{Float64})
+true
+
+julia> isbits(Complex)
+false
+```
+"""
+isbits
+
+"""
+    findlast(A)
+
+Return the index of the last non-zero value in `A` (determined by `A[i]!=0`).
+"""
+findlast(A)
+
+"""
+    findlast(A, v)
+
+Return the index of the last element equal to `v` in `A`.
+"""
+findlast(A,v)
+
+"""
+    findlast(predicate, A)
+
+Return the index of the last element of `A` for which `predicate` returns `true`.
+"""
+findlast(::Function, A)
+
+"""
+    @elapsed
+
+A macro to evaluate an expression, discarding the resulting value, instead returning the
+number of seconds it took to execute as a floating-point number.
+"""
+:@elapsed
+
+"""
+    findnext(A, i)
+
+Find the next index >= `i` of a non-zero element of `A`, or `0` if not found.
+"""
+findnext
+
+"""
+    findnext(predicate, A, i)
+
+Find the next index >= `i` of an element of `A` for which `predicate` returns `true`, or `0` if not found.
+"""
+findnext(::Function,A,i)
+
+"""
+    findnext(A, v, i)
+
+Find the next index >= `i` of an element of `A` equal to `v` (using `==`), or `0` if not found.
+"""
+findnext(A,v,i)
+
+"""
+    fetch(x)
+
+Waits and fetches a value from `x` depending on the type of `x`. Does not remove the item fetched:
+
+* `Future`: Wait for and get the value of a Future. The fetched value is cached locally.
+  Further calls to `fetch` on the same reference return the cached value. If the remote value
+  is an exception, throws a `RemoteException` which captures the remote exception and backtrace.
+* `RemoteChannel`: Wait for and get the value of a remote reference. Exceptions raised are
+  same as for a `Future` .
+* `Channel` : Wait for and get the first available item from the channel.
+"""
+fetch
+
+"""
+    angle(z)
+
+Compute the phase angle in radians of a complex number `z`.
+"""
+angle
+
+"""
+    tic()
+
+Set a timer to be read by the next call to [`toc`](:func:`toc`) or [`toq`](:func:`toq`). The
+macro call `@time expr` can also be used to time evaluation.
+"""
+tic
+
+"""
+    LoadError(file::AbstractString, line::Int, error)
+
+An error occurred while `include`ing, `require`ing, or `using` a file. The error specifics
+should be available in the `.error` field.
+"""
+LoadError
+
+"""
+    InitError(mod::Symbol, error)
+
+An error occurred when running a module's `__init__` function. The actual error thrown is
+available in the `.error` field.
+"""
+InitError
+
+"""
+    vec(Array) -> Vector
+
+Vectorize an array using column-major convention.
+"""
+vec
+
+"""
+    copy!(dest, src)
+
+Copy all elements from collection `src` to array `dest`. Returns `dest`.
+"""
+copy!(dest,src)
+
+"""
+    copy!(dest, do, src, so, N)
+
+Copy `N` elements from collection `src` starting at offset `so`, to array `dest` starting at
+offset `do`. Returns `dest`.
+"""
+copy!(dest,d,src,so,N)
+
+"""
+    broadcast(f, As...)
+
+Broadcasts the arrays `As` to a common size by expanding singleton dimensions, and returns
+an array of the results `f(as...)` for each position.
+"""
+broadcast
+
+"""
+    eigvecs(A, [eigvals,][permute=true,][scale=true]) -> Matrix
+
+Returns a matrix `M` whose columns are the eigenvectors of `A`. (The `k`th eigenvector can
+be obtained from the slice `M[:, k]`.) The `permute` and `scale` keywords are the same as
+for [`eigfact`](:func:`eigfact`).
+
+For [`SymTridiagonal`](:class:`SymTridiagonal`) matrices, if the optional vector of
+eigenvalues `eigvals` is specified, returns the specific corresponding eigenvectors.
+"""
+eigvecs
+
+"""
+    ntoh(x)
+
+Converts the endianness of a value from Network byte order (big-endian) to that used by the Host.
+"""
+ntoh
+
+"""
+    qrfact(A [,pivot=Val{false}]) -> F
+
+Computes the QR factorization of `A`. The return type of `F` depends on the element type of
+`A` and whether pivoting is specified (with `pivot==Val{true}`).
+
+| Return type   | `eltype(A)`     | `pivot`      | Relationship between `F` and `A` |
+|:--------------|:----------------|:-------------|:---------------------------------|
+| `QR`          | not `BlasFloat` | either       | `A==F[:Q]*F[:R]`                 |
+| `QRCompactWY` | `BlasFloat`     | `Val{false}` | `A==F[:Q]*F[:R]`                 |
+| `QRPivoted`   | `BlasFloat`     | `Val{true}`  | `A[:,F[:p]]==F[:Q]*F[:R]`        |
+
+`BlasFloat` refers to any of: `Float32`, `Float64`, `Complex64` or `Complex128`.
+
+The individual components of the factorization `F` can be accessed by indexing:
+
+| Component | Description                               | `QR`            | `QRCompactWY`      | `QRPivoted`     |
+|:----------|:------------------------------------------|:----------------|:-------------------|:----------------|
+| `F[:Q]`   | `Q` (orthogonal/unitary) part of `QR`     | ✓ (`QRPackedQ`) | ✓ (`QRCompactWYQ`) | ✓ (`QRPackedQ`) |
+| `F[:R]`   | `R` (upper right triangular) part of `QR` | ✓               | ✓                  | ✓               |
+| `F[:p]`   | pivot `Vector`                            |                 |                    | ✓               |
+| `F[:P]`   | (pivot) permutation `Matrix`              |                 |                    | ✓               |
+
+The following functions are available for the `QR` objects: `size`, `\\`. When `A` is
+rectangular, `\\` will return a least squares solution and if the solution is not unique,
+the one with smallest norm is returned.
+
+Multiplication with respect to either thin or full `Q` is allowed, i.e. both `F[:Q]*F[:R]`
+and `F[:Q]*A` are supported. A `Q` matrix can be converted into a regular matrix with
+[`full`](:func:`full`) which has a named argument `thin`.
+
+**note**
+
+`qrfact` returns multiple types because LAPACK uses several representations that minimize
+the memory storage requirements of products of Householder elementary reflectors, so that
+the `Q` and `R` matrices can be stored compactly rather as two separate dense matrices.
+
+The data contained in `QR` or `QRPivoted` can be used to construct the `QRPackedQ` type,
+which is a compact representation of the rotation matrix:
+
+```math
+Q = \\prod_{i=1}^{\\min(m,n)} (I - \\tau_i v_i v_i^T)
+```
+
+where ``\\tau_i`` is the scale factor and ``v_i`` is the projection vector associated with
+the ``i^{th}`` Householder elementary reflector.
+
+The data contained in `QRCompactWY` can be used to construct the `QRCompactWYQ` type,
+which is a compact representation of the rotation matrix
+
+```math
+Q = I + Y T Y^T
+```
+
+where `Y` is ``m \\times r`` lower trapezoidal and `T` is ``r \\times r`` upper
+triangular. The *compact WY* representation [^Schreiber1989] is not to be confused with the
+older, *WY* representation [^Bischof1987]. (The LAPACK documentation uses `V` in lieu of `Y`.)
+
+[^Bischof1987]: C Bischof and C Van Loan, "The WY representation for products of Householder matrices", SIAM J Sci Stat Comput 8 (1987), s2-s13. [doi:10.1137/0908009](http://dx.doi.org/10.1137/0908009)
+
+[^Schreiber1989]: R Schreiber and C Van Loan, "A storage-efficient WY representation for products of Householder transformations", SIAM J Sci Stat Comput 10 (1989), 53-57. [doi:10.1137/0910005](http://dx.doi.org/10.1137/0910005)
+
+"""
+qrfact(A,?)
+
+
+"""
+    qrfact(A) -> SPQR.Factorization
+
+Compute the QR factorization of a sparse matrix `A`. A fill-reducing permutation is used.
+The main application of this type is to solve least squares problems with `\\`. The function
+calls the C library SPQR and a few additional functions from the library are wrapped but not
+exported.
+"""
+qrfact(A)
+
+"""
+    +(x, y...)
+
+Addition operator. `x+y+z+...` calls this function with all arguments, i.e. `+(x, y, z, ...)`.
+"""
++
+
+"""
+    identity(x)
+
+The identity function. Returns its argument.
+"""
+identity
+
+"""
+    iseven(x::Integer) -> Bool
+
+Returns `true` is `x` is even (that is, divisible by 2), and `false` otherwise.
+
+```jldoctest
+julia> iseven(9)
+false
+
+julia> iseven(10)
+true
+```
+"""
+iseven
+
+"""
+    setindex!(A, X, inds...)
+
+Store values from array `X` within some subset of `A` as specified by `inds`.
+"""
+setindex!(A::AbstractArray,X,inds...)
+
+"""
+    setindex!(collection, value, key...)
+
+Store the given value at the given key or index within a collection. The syntax `a[i,j,...] =
+x` is converted by the compiler to `(setindex!(a, x, i, j, ...); x)`.
+"""
+setindex!(collection,value,key...)
+
+"""
+    signif(x, digits, [base])
+
+Rounds (in the sense of `round`) `x` so that there are `digits` significant digits, under a
+base `base` representation, default 10. E.g., `signif(123.456, 2)` is `120.0`, and
+`signif(357.913, 4, 2)` is `352.0`.
+"""
+signif
+
+"""
+    nextpow2(n)
+
+The smallest power of two not less than `n`. Returns 0 for `n==0`, and returns
+`-nextpow2(-n)` for negative arguments.
+"""
+nextpow2
+
+"""
+    full(F)
+
+Reconstruct the matrix `A` from the factorization `F=factorize(A)`.
+"""
+full(F)
+
+"""
+    full(QRCompactWYQ[, thin=true]) -> Matrix
+
+Converts an orthogonal or unitary matrix stored as a `QRCompactWYQ` object, i.e. in the
+compact WY format [^Bischof1987], to a dense matrix.
+
+Optionally takes a `thin` Boolean argument, which if `true` omits the columns that span the
+rows of `R` in the QR factorization that are zero. The resulting matrix is the `Q` in a thin
+QR factorization (sometimes called the reduced QR factorization). If `false`, returns a `Q`
+that spans all rows of `R` in its corresponding QR factorization.
+"""
+full(::LinAlg.QRCompactWYQ, ?)
+
+"""
+    map(f, c...) -> collection
+
+Transform collection `c` by applying `f` to each element. For multiple collection arguments,
+apply `f` elementwise.
+
+```jldoctest
+julia> map((x) -> x * 2, [1, 2, 3])
+3-element Array{Int64,1}:
+ 2
+ 4
+ 6
+
+julia> map(+, [1, 2, 3], [10, 20, 30])
+3-element Array{Int64,1}:
+ 11
+ 22
+ 33
+```
+"""
+map
+
+"""
+    @parallel
+
+A parallel for loop of the form :
+
+    @parallel [reducer] for var = range
+        body
+    end
+
+The specified range is partitioned and locally executed across all workers. In case an
+optional reducer function is specified, `@parallel` performs local reductions on each worker
+with a final reduction on the calling process.
+
+Note that without a reducer function, `@parallel` executes asynchronously, i.e. it spawns
+independent tasks on all available workers and returns immediately without waiting for
+completion. To wait for completion, prefix the call with `@sync`, like :
+
+    @sync @parallel for var = range
+        body
+    end
+"""
+:@parallel
+
+"""
+    throw(e)
+
+Throw an object as an exception.
+"""
+throw
+
+"""
+    isxdigit(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is a valid hexadecimal digit, or whether this is true for all elements of a string.
+"""
+isxdigit
+
+"""
+    fill(x, dims)
+
+Create an array filled with the value `x`. For example, `fill(1.0, (10,10))` returns a 10x10
+array of floats, with each element initialized to `1.0`.
+
+If `x` is an object reference, all elements will refer to the same object. `fill(Foo(),
+dims)` will return an array filled with the result of evaluating `Foo()` once.
+"""
+fill
+
+"""
+    rol!(dest::BitArray{1}, src::BitArray{1}, i::Integer) -> BitArray{1}
+
+Performs a left rotation operation on `src` and put the result into `dest`.
+"""
+rol!(::BitArray,::BitArray,::Integer)
+
+"""
+    rol!(B::BitArray{1}, i::Integer) -> BitArray{1}
+
+Performs a left rotation operation on `B`.
+"""
+rol!(::BitArray,::Integer)
+
+"""
+    issubset(a, b)
+    ⊆(a,b) -> Bool
+    ⊈(a,b) -> Bool
+    ⊊(a,b) -> Bool
+
+Determine whether every element of `a` is also in `b`, using [`in`](:func:`in`).
+"""
+issubset(a,b)
+
+"""
+    issubset(A, S) -> Bool
+    ⊆(A,S) -> Bool
+
+Return `true` if `A` is a subset of or equal to `S`.
+"""
+issubset
+
+"""
+    istriu(A) -> Bool
+
+Test whether a matrix is upper triangular.
+"""
+istriu
+
+"""
+    map!(function, collection)
+
+In-place version of [`map`](:func:`map`).
+"""
+map!(f,collection)
+
+"""
+    map!(function, destination, collection...)
+
+Like [`map`](:func:`map`), but stores the result in `destination` rather than a new
+collection. `destination` must be at least as large as the first collection.
+"""
+map!(f,destination,collection...)
+
+"""
+    unescape_string(s::AbstractString) -> AbstractString
+
+General unescaping of traditional C and Unicode escape sequences. Reverse of
+[`escape_string`](:func:`escape_string`). See also [`print_unescaped`](:func:`print_unescaped`).
+"""
+unescape_string
+
+"""
+    redirect_stdout()
+
+Create a pipe to which all C and Julia level `STDOUT` output will be redirected. Returns a
+tuple `(rd,wr)` representing the pipe ends. Data written to `STDOUT` may now be read from
+the rd end of the pipe. The wr end is given for convenience in case the old `STDOUT` object
+was cached by the user and needs to be replaced elsewhere.
+"""
+redirect_stdout
+
+"""
+    redirect_stdout(stream)
+
+Replace `STDOUT` by stream for all C and julia level output to `STDOUT`. Note that `stream`
+must be a TTY, a `Pipe` or a `TCPSocket`.
+"""
+redirect_stdout(stream)
+
+"""
+    print_with_color(color::Symbol, [io], strings...)
+
+Print strings in a color specified as a symbol.
+
+`color` may take any of the values $(Base.available_text_colors_docstring).
+"""
+print_with_color
+
+"""
+    stringmime(mime, x)
+
+Returns an `AbstractString` containing the representation of `x` in the requested `mime`
+type. This is similar to `reprmime` except that binary data is base64-encoded as an ASCII string.
+"""
+stringmime
+
+"""
+    ischardev(path) -> Bool
+
+Returns `true` if `path` is a character device, `false` otherwise.
+"""
+ischardev
+
+"""
+    zero(x)
+
+Get the additive identity element for the type of `x` (`x` can also specify the type itself).
+"""
+zero
+
+"""
+    any(itr) -> Bool
+
+Test whether any elements of a boolean collection are `true`.
+"""
+any(itr)
+
+"""
+    any(A, dims)
+
+Test whether any values along the given dimensions of an array are `true`.
+"""
+any(::AbstractArray,dims)
+
+"""
+    any(p, itr) -> Bool
+
+Determine whether predicate `p` returns `true` for any elements of `itr`.
+"""
+any(p,itr)
+
+"""
+    cosc(x)
+
+Compute ``\\cos(\\pi x) / x - \\sin(\\pi x) / (\\pi x^2)`` if ``x \\neq 0``, and ``0`` if
+``x = 0``. This is the derivative of `sinc(x)`.
+"""
+cosc
+
+"""
+    getkey(collection, key, default)
+
+Return the key matching argument `key` if one exists in `collection`, otherwise return `default`.
+"""
+getkey
+
+"""
+    At_ldiv_Bt(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ`` \\ ``Bᵀ``.
+"""
+At_ldiv_Bt
+
+"""
+    Ac_mul_Bc(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ Bᴴ``.
+"""
+Ac_mul_Bc
+
+"""
+    acotd(x)
+
+Compute the inverse cotangent of `x`, where the output is in degrees.
+"""
+acotd
+
+"""
+    zeros(type, dims)
+
+Create an array of all zeros of specified type. The type defaults to Float64 if not specified.
+"""
+zeros(t,dims)
+
+"""
+    zeros(A)
+
+Create an array of all zeros with the same element type and shape as `A`.
+"""
+zeros(A)
+
+"""
+    symbol(x...) -> Symbol
+
+Create a `Symbol` by concatenating the string representations of the arguments together.
+"""
+symbol
+
+"""
+    zeta(s)
+
+Riemann zeta function ``\\zeta(s)``.
+"""
+zeta(s)
+
+"""
+    zeta(s, z)
+
+Hurwitz zeta function ``\\zeta(s, z)``.  (This is equivalent to the Riemann zeta function
+``\\zeta(s)`` for the case of `z=1`.)
+"""
+zeta(s,z)
+
+"""
+    A_mul_Bt(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``A⋅Bᵀ``.
+"""
+A_mul_Bt
+
+"""
+    vecnorm(A, [p])
+
+For any iterable container `A` (including arrays of any dimension) of numbers (or any
+element type for which `norm` is defined), compute the `p`-norm (defaulting to `p=2`) as if
+`A` were a vector of the corresponding length.
+
+For example, if `A` is a matrix and `p=2`, then this is equivalent to the Frobenius norm.
+"""
+vecnorm
+
+"""
+    isvalid(value) -> Bool
+
+Returns `true` if the given value is valid for its type, which currently can be one of
+`Char`, `ASCIIString`, `UTF8String`, `UTF16String`, or `UTF32String`.
+"""
+isvalid(value)
+
+"""
+    isvalid(T, value) -> Bool
+
+Returns `true` if the given value is valid for that type. Types currently can be `Char`,
+`ASCIIString`, `UTF8String`, `UTF16String`, or `UTF32String` Values for `Char` can be of
+type `Char` or `UInt32` Values for `ASCIIString` and `UTF8String` can be of that type, or
+`Vector{UInt8}` Values for `UTF16String` can be `UTF16String` or `Vector{UInt16}` Values for
+`UTF32String` can be `UTF32String`, `Vector{Char}` or `Vector{UInt32}`
+"""
+isvalid(T,value)
+
+"""
+    isvalid(str, i)
+
+Tells whether index `i` is valid for the given string.
+"""
+isvalid(::AbstractString,i)
+
+"""
+    esc(e::ANY)
+
+Only valid in the context of an `Expr` returned from a macro. Prevents the macro hygiene
+pass from turning embedded variables into gensym variables. See the [macro](:ref:`man-macros`)
+section of the Metaprogramming chapter of the manual for more details and examples.
+"""
+esc
+
+"""
+    bitbroadcast(f, As...)
+
+Like `broadcast`, but allocates a `BitArray` to store the result, rather then an `Array`.
+"""
+bitbroadcast
+
+"""
+    set_zero_subnormals(yes::Bool) -> Bool
+
+If `yes` is `false`, subsequent floating-point operations follow rules for IEEE arithmetic
+on subnormal values ("denormals"). Otherwise, floating-point operations are permitted (but
+not required) to convert subnormal inputs or outputs to zero. Returns `true` unless
+`yes==true` but the hardware does not support zeroing of subnormal numbers.
+
+`set_zero_subnormals(true)` can speed up some computations on some hardware. However, it can
+break identities such as `(x-y==0) == (x==y)`.
+"""
+set_zero_subnormals
+
+"""
+    take(iter, n)
+
+An iterator that generates at most the first `n` elements of `iter`.
+"""
+take
+
+"""
+    frexp(val)
+
+Return `(x,exp)` such that `x` has a magnitude in the interval ``[1/2, 1)`` or 0, and val =
+``x \\times 2^{exp}``.
+"""
+frexp
+
+"""
+    sortcols(A, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
+
+Sort the columns of matrix `A` lexicographically.
+"""
+sortcols
+
+"""
+    rsplit(string, [chars]; limit=0, keep=true)
+
+Similar to `split`, but starting from the end of the string.
+"""
+rsplit
+
+"""
+    trace(M)
+
+Matrix trace.
+"""
+trace
+
+"""
+    runtests([tests=["all"] [, numcores=iceil(CPU_CORES/2) ]])
+
+Run the Julia unit tests listed in `tests`, which can be either a string or an array of
+strings, using `numcores` processors. (not exported)
+"""
+runtests
+
+"""
+    time_ns()
+
+Get the time in nanoseconds. The time corresponding to 0 is undefined, and wraps every 5.8 years.
+"""
+time_ns
+
+"""
+    exponent(x) -> Int
+
+Get the exponent of a normalized floating-point number.
+"""
+exponent
+
+"""
+    rsearchindex(string, substring, [start])
+
+Similar to `rsearch`, but return only the start index at which the substring is found, or `0` if it is not.
+"""
+rsearchindex
+
+"""
+    muladd(x, y, z)
+
+Combined multiply-add, computes `x*y+z` in an efficient manner. This may on some systems be
+equivalent to `x*y+z`, or to `fma(x,y,z)`. `muladd` is used to improve performance. See `fma`.
+"""
+muladd
+
+"""
+    unsigned(x) -> Unsigned
+
+Convert a number to an unsigned integer. If the argument is signed, it is reinterpreted as
+unsigned without checking for negative values.
+"""
+unsigned
+
+"""
+    eigfact(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> Eigen
+
+Computes the eigenvalue decomposition of `A`, returning an `Eigen` factorization object `F`
+which contains the eigenvalues in `F[:values]` and the eigenvectors in the columns of the
+matrix `F[:vectors]`. (The `k`th eigenvector can be obtained from the slice `F[:vectors][:, k]`.)
+
+The following functions are available for `Eigen` objects: `inv`, `det`.
+
+If `A` is [`Symmetric`](:class:`Symmetric`), [`Hermitian`](:class:`Hermitian`) or
+[`SymTridiagonal`](:class:`SymTridiagonal`), it is possible to calculate only a subset of
+the eigenvalues by specifying either a [`UnitRange`](:class:`UnitRange`) `irange` covering
+indices of the sorted eigenvalues or a pair `vl` and `vu` for the lower and upper boundaries
+of the eigenvalues.
+
+For general nonsymmetric matrices it is possible to specify how the matrix is balanced
+before the eigenvector calculation. The option `permute=true` permutes the matrix to become
+closer to upper triangular, and `scale=true` scales the matrix by its diagonal elements to
+make rows and columns more equal in norm. The default is `true` for both options.
+"""
+eigfact(A,?,?,?,?)
+
+"""
+    eigfact(A, B) -> GeneralizedEigen
+
+Computes the generalized eigenvalue decomposition of `A` and `B`, returning a
+`GeneralizedEigen` factorization object `F` which contains the generalized eigenvalues in
+`F[:values]` and the generalized eigenvectors in the columns of the matrix `F[:vectors]`.
+(The `k`th generalized eigenvector can be obtained from the slice `F[:vectors][:, k]`.)
+"""
+eigfact(A,B)
+
+"""
+    mkdir(path, [mode])
+
+Make a new directory with name `path` and permissions `mode`. `mode` defaults to `0o777`,
+modified by the current file creation mask.
+"""
+mkdir
+
+"""
+    bytestring(::Ptr{UInt8}, [length])
+
+Create a string from the address of a C (0-terminated) string encoded in ASCII or UTF-8. A
+copy is made; the ptr can be safely freed. If `length` is specified, the string does not
+have to be 0-terminated.
+"""
+bytestring(::Ptr{UInt8},?)
+
+"""
+    bytestring(s)
+
+Convert a string to a contiguous byte array representation appropriate for passing it to C
+functions. The string will be encoded as either ASCII or UTF-8.
+"""
+bytestring(s)
+
+"""
+    midpoints(e)
+
+Compute the midpoints of the bins with edges `e`. The result is a vector/range of length
+`length(e) - 1`. Note: Julia does not ignore `NaN` values in the computation.
+"""
+midpoints
+
+"""
+    .+(x, y)
+
+Element-wise addition operator.
+"""
+Base.(:(.+))
+
+"""
+    reverseind(v, i)
+
+Given an index `i` in `reverse(v)`, return the corresponding index in `v` so that
+`v[reverseind(v,i)] == reverse(v)[i]`. (This can be nontrivial in the case where `v` is a
+Unicode string.)
+"""
+reverseind
+
+"""
+    nan(f)
+
+Returns NaN (not-a-number) of the floating point type `f` or of the same floating point type as `f`
+"""
+nan
+
+"""
+    float(x)
+
+Convert a number, array, or string to a `AbstractFloat` data type. For numeric data, the
+smallest suitable `AbstractFloat` type is used. Converts strings to `Float64`.
+"""
+float
+
+"""
+    include_dependency(path::AbstractString)
+
+In a module, declare that the file specified by `path` (relative or absolute) is a
+dependency for precompilation; that is, the module will need to be recompiled if this file
+changes.
+
+This is only needed if your module depends on a file that is not used via `include`. It has
+no effect outside of compilation.
+"""
+include_dependency
+
+"""
+    randn!([rng], A::Array{Float64,N})
+
+Fill the array `A` with normally-distributed (mean 0, standard deviation 1) random numbers.
+Also see the rand function.
+"""
+randn!
+
+"""
+    ldexp(x, n)
+
+Compute ``x \\times 2^n``.
+"""
+ldexp
+
+"""
+    quadgk(f, a,b,c...; reltol=sqrt(eps), abstol=0, maxevals=10^7, order=7, norm=vecnorm)
+
+Numerically integrate the function `f(x)` from `a` to `b`, and optionally over additional
+intervals `b` to `c` and so on. Keyword options include a relative error tolerance `reltol`
+(defaults to `sqrt(eps)` in the precision of the endpoints), an absolute error tolerance
+`abstol` (defaults to 0), a maximum number of function evaluations `maxevals` (defaults to
+`10^7`), and the `order` of the integration rule (defaults to 7).
+
+Returns a pair `(I,E)` of the estimated integral `I` and an estimated upper bound on the
+absolute error `E`. If `maxevals` is not exceeded then `E <= max(abstol, reltol*norm(I))`
+will hold. (Note that it is useful to specify a positive `abstol` in cases where `norm(I)`
+may be zero.)
+
+The endpoints `a` etcetera can also be complex (in which case the integral is performed over
+straight-line segments in the complex plane). If the endpoints are `BigFloat`, then the
+integration will be performed in `BigFloat` precision as well (note: it is advisable to
+increase the integration `order` in rough proportion to the precision, for smooth
+integrands). More generally, the precision is set by the precision of the integration
+endpoints (promoted to floating-point types).
+
+The integrand `f(x)` can return any numeric scalar, vector, or matrix type, or in fact any
+type supporting `+`, `-`, multiplication by real values, and a `norm` (i.e., any normed
+vector space). Alternatively, a different norm can be specified by passing a `norm`-like
+function as the `norm` keyword argument (which defaults to `vecnorm`).
+
+\[Only one-dimensional integrals are provided by this function. For multi-dimensional
+integration (cubature), there are many different algorithms (often much better than simple
+nested 1d integrals) and the optimal choice tends to be very problem-dependent. See the
+Julia external-package listing for available algorithms for multidimensional integration or
+other specialized tasks (such as integrals of highly oscillatory or singular functions).\]
+
+The algorithm is an adaptive Gauss-Kronrod integration technique: the integral in each
+interval is estimated using a Kronrod rule (`2*order+1` points) and the error is estimated
+using an embedded Gauss rule (`order` points). The interval with the largest error is then
+subdivided into two intervals and the process is repeated until the desired error tolerance
+is achieved.
+
+These quadrature rules work best for smooth functions within each interval, so if your
+function has a known discontinuity or other singularity, it is best to subdivide your
+interval to put the singularity at an endpoint. For example, if `f` has a discontinuity at
+`x=0.7` and you want to integrate from 0 to 1, you should use `quadgk(f, 0,0.7,1)` to
+subdivide the interval at the point of discontinuity. The integrand is never evaluated
+exactly at the endpoints of the intervals, so it is possible to integrate functions that
+diverge at the endpoints as long as the singularity is integrable (for example, a `log(x)`
+or `1/sqrt(x)` singularity).
+
+For real-valued endpoints, the starting and/or ending points may be infinite. (A coordinate
+transformation is performed internally to map the infinite interval to a finite one.)
+"""
+quadgk
+
+"""
+    hist(v[, n]) -> e, counts
+
+Compute the histogram of `v`, optionally using approximately `n` bins. The return values are
+a range `e`, which correspond to the edges of the bins, and `counts` containing the number
+of elements of `v` in each bin. Note: Julia does not ignore `NaN` values in the computation.
+"""
+hist(v,n::Int=?)
+
+"""
+    hist(v, e) -> e, counts
+
+Compute the histogram of `v` using a vector/range `e` as the edges for the bins. The result
+will be a vector of length `length(e) - 1`, such that the element at location `i` satisfies
+`sum(e[i] .< v .<= e[i+1])`. Note: Julia does not ignore `NaN` values in the computation.
+"""
+hist(v,e)
+
+"""
+    islower(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is a lowercase letter, or whether this is true for all elements of
+a string. A character is classified as lowercase if it belongs to Unicode category Ll,
+Letter: Lowercase.
+"""
+islower
+
+"""
+    cell(dims)
+
+Construct an uninitialized cell array (heterogeneous array). `dims` can be either a tuple or
+a series of integer arguments.
+"""
+cell
+
+"""
+    read(stream::IO, nb=typemax(Int); all=true)
+
+Read at most `nb` bytes from `stream`, returning a `Vector{UInt8}` of the bytes read.
+
+If `all` is `true` (the default), this function will block repeatedly trying to read all
+requested bytes, until an error or end-of-file occurs. If `all` is `false`, at most one
+`read` call is performed, and the amount of data returned is device-dependent. Note that not
+all stream types support the `all` option.
+"""
+read
+
+"""
+    eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> D, V
+
+Computes eigenvalues and eigenvectors of `A`. See [`eigfact`](:func:`eigfact`) for details
+on the `balance` keyword argument.
+
+```jldoctest
+julia> eig([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
+([1.0,3.0,18.0],
+3x3 Array{Float64,2}:
+ 1.0  0.0  0.0
+ 0.0  1.0  0.0
+ 0.0  0.0  1.0)
+```
+
+`eig` is a wrapper around [`eigfact`](:func:`eigfact`), extracting all parts of the
+factorization to a tuple; where possible, using [`eigfact`](:func:`eigfact`) is recommended.
+"""
+eig(A,?,?,?)
+
+"""
+    eig(A, B) -> D, V
+
+Computes generalized eigenvalues and vectors of `A` with respect to `B`.
+
+`eig` is a wrapper around [`eigfact`](:func:`eigfact`), extracting all parts of the
+factorization to a tuple; where possible, using [`eigfact`](:func:`eigfact`) is recommended.
+"""
+eig(A,B)
+
+"""
+    exp2(x)
+
+Compute ``2^x``.
+"""
+exp2
+
+"""
+    gcd(x,y)
+
+Greatest common (positive) divisor (or zero if `x` and `y` are both zero).
+"""
+gcd
+
+"""
+    signbit(x)
+
+Returns `true` if the value of the sign of `x` is negative, otherwise `false`.
+"""
+signbit
+
+"""
+    clamp(x, lo, hi)
+
+Return `x` if `lo <= x <= hi`. If `x < lo`, return `lo`. If `x > hi`, return `hi`. Arguments
+are promoted to a common type. Operates elementwise over `x` if it is an array.
+"""
+clamp
+
+"""
+    cscd(x)
+
+Compute the cosecant of `x`, where `x` is in degrees.
+"""
+cscd
+
+"""
+    tryparse(type, str, [base])
+
+Like `parse`, but returns a `Nullable` of the requested type. The result will be null if the
+string does not contain a valid number.
+"""
+tryparse
+
+"""
+    lexless(x, y)
+
+Determine whether `x` is lexicographically less than `y`.
+"""
+lexless
+
+"""
+    all!(r, A)
+
+Test whether all values in `A` along the singleton dimensions of `r` are `true`, and write results to `r`.
+"""
+all!
+
+"""
+    is_assigned_char(c) -> Bool
+
+Returns `true` if the given char or integer is an assigned Unicode code point.
+"""
+is_assigned_char
+
+"""
+    exit([code])
+
+Quit (or control-D at the prompt). The default exit code is zero, indicating that the
+processes completed successfully.
+"""
+exit
+
+"""
+    istext(m::MIME)
+
+Determine whether a MIME type is text data.
+"""
+istext
+
+"""
+    merge!(collection, others...)
+
+Update collection with pairs from the other collections.
+"""
+merge!
+
+"""
+    realpath(path::AbstractString) -> AbstractString
+
+Canonicalize a path by expanding symbolic links and removing "." and ".." entries.
+"""
+realpath
+
+"""
+    skipchars(stream, predicate; linecomment::Char)
+
+Advance the stream until before the first character for which `predicate` returns `false`.
+For example `skipchars(stream, isspace)` will skip all whitespace. If keyword argument
+`linecomment` is specified, characters from that character through the end of a line will
+also be skipped.
+"""
+skipchars
+
+"""
+    realmin(T)
+
+The smallest in absolute value non-subnormal value representable by the given floating-point DataType `T`.
+"""
+realmin
+
+"""
+    union!(s, iterable)
+
+Union each element of `iterable` into set `s` in-place.
+"""
+union!
+
+"""
+    At_ldiv_B(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᵀ`` \\ ``B``.
+"""
+At_ldiv_B
+
+"""
+    dot(x, y)
+    ⋅(x,y)
+
+Compute the dot product. For complex vectors, the first vector is conjugated.
+"""
+dot
+
+"""
+    cond(M, [p])
+
+Condition number of the matrix `M`, computed using the operator `p`-norm. Valid values for
+`p` are `1`, `2` (default), or `Inf`.
+"""
+cond
+
+"""
+    deepcopy(x)
+
+Create a deep copy of `x`: everything is copied recursively, resulting in a fully
+independent object. For example, deep-copying an array produces a new array whose elements
+are deep copies of the original elements. Calling `deepcopy` on an object should generally
+have the same effect as serializing and then deserializing it.
+
+As a special case, functions can only be actually deep-copied if they are anonymous,
+otherwise they are just copied. The difference is only relevant in the case of closures,
+i.e. functions which may contain hidden internal references.
+
+While it isn't normally necessary, user-defined types can override the default `deepcopy`
+behavior by defining a specialized version of the function `deepcopy_internal(x::T, dict::ObjectIdDict)`
+(which shouldn't otherwise be used), where `T` is the type to be specialized for, and `dict`
+keeps track of objects copied so far within the recursion. Within the definition,
+`deepcopy_internal` should be used in place of `deepcopy`, and the `dict` variable should be
+updated as appropriate before returning.
+"""
+deepcopy
+
+"""
+    widen(x)
+
+If `x` is a type, return a "larger" type (for numeric types, this will be
+a type with at least as much range and precision as the argument, and usually more).
+Otherwise `x` is converted to `widen(typeof(x))`.
+
+```jldoctest
+julia> widen(Int32)
+Int64
+
+julia> widen(1.5f0)
+1.5
+```
+"""
+widen
+
+"""
+    @eval
+
+Evaluate an expression and return the value.
+"""
+:@eval
+
+"""
+    eval([m::Module], expr::Expr)
+
+Evaluate an expression in the given module and return the result. Every `Module` (except
+those defined with `baremodule`) has its own 1-argument definition of `eval`, which
+evaluates expressions in that module.
+"""
+eval
+
+"""
+    Set([itr])
+
+Construct a [`Set`](:obj:`Set`) of the values generated by the given iterable object, or an
+empty set. Should be used instead of [`IntSet`](:obj:`IntSet`) for sparse integer sets, or
+for sets of arbitrary objects.
+"""
+Set
+
+"""
+    erf(x)
+
+Compute the error function of `x`, defined by ``\\frac{2}{\\sqrt{\\pi}} \\int_0^x e^{-t^2} dt``
+for arbitrary complex `x`.
+"""
+erf
+
+"""
+    lcm(x,y)
+
+Least common (non-negative) multiple.
+"""
+lcm
+
+"""
+    isprint(c::Union{Char,AbstractString}) -> Bool
+
+Tests whether a character is printable, including spaces, but not a control character. For
+strings, tests whether this is true for all elements of the string.
+"""
+isprint
+
+"""
+    splitdir(path::AbstractString) -> (AbstractString,AbstractString)
+
+Split a path into a tuple of the directory name and file name.
+"""
+splitdir
+
+"""
+    sign(x)
+
+Return zero if `x==0` and ``x/|x|`` otherwise (i.e., ±1 for real `x`).
+"""
+sign
+
+"""
+    signed(x)
+
+Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as
+signed without checking for overflow.
+"""
+signed
+
+"""
+    Val{c}
+
+Create a "value type" out of `c`, which must be an `isbits` value. The intent of this
+construct is to be able to dispatch on constants, e.g., `f(Val{false})` allows you to
+dispatch directly (at compile-time) to an implementation `f(::Type{Val{false}})`, without
+having to test the boolean value at runtime.
+"""
+Val
+
+"""
+    iswritable(io) -> Bool
+
+Returns `true` if the specified IO object is writable (if that can be determined).
+"""
+iswritable
+
+"""
+    |(x, y)
+
+Bitwise or.
+"""
+Base.(:(|))
+
+"""
+    yieldto(task, arg = nothing)
+
+Switch to the given task. The first time a task is switched to, the task's function is
+called with no arguments. On subsequent switches, `arg` is returned from the task's last
+call to `yieldto`. This is a low-level call that only switches tasks, not considering states
+or scheduling in any way. Its use is discouraged.
+"""
+yieldto
+
+"""
+    readandwrite(command)
+
+Starts running a command asynchronously, and returns a tuple (stdout,stdin,process) of the
+output stream and input stream of the process, and the process object itself.
+"""
+readandwrite
+
+"""
+    splitdrive(path::AbstractString) -> (AbstractString,AbstractString)
+
+On Windows, split a path into the drive letter part and the path part. On Unix systems, the
+first component is always the empty string.
+"""
+splitdrive
+
+"""
+    pop!(collection, key[, default])
+
+Delete and return the mapping for `key` if it exists in `collection`, otherwise return
+`default`, or throw an error if default is not specified.
+"""
+pop!(collection,key,?)
+
+"""
+    pop!(collection) -> item
+
+Remove the last item in `collection` and return it.
+
+```jldoctest
+julia> A=[1, 2, 3, 4, 5, 6]
+6-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 5
+ 6
+
+julia> pop!(A)
+6
+
+julia> A
+5-element Array{Int64,1}:
+ 1
+ 2
+ 3
+ 4
+ 5
+```
+"""
+pop!(collection)
+
+"""
+    filter(function, collection)
+
+Return a copy of `collection`, removing elements for which `function` is `false`. For
+associative collections, the function is passed two arguments (key and value).
+"""
+filter
+
+"""
+    randperm([rng,] n)
+
+Construct a random permutation of length `n`. The optional `rng` argument specifies a random
+number generator, see [Random Numbers](:ref:`Random Numbers <random-numbers>`).
+"""
+randperm
+
+"""
+    seekend(s)
+
+Seek a stream to its end.
+"""
+seekend
+
+"""
+    DivideError()
+
+Integer division was attempted with a denominator value of 0.
+"""
+DivideError
+
+"""
+    AssertionError([msg])
+
+The asserted condition did not evaluate to `true`.
+Optional argument `msg` is a descriptive error string.
+"""
+AssertionError
+
+"""
+    ror(B::BitArray{1}, i::Integer) -> BitArray{1}
+
+Performs a right rotation operation.
+"""
+ror
+
+"""
+    Ac_ldiv_Bc(A, B)
+
+For matrices or vectors ``A`` and ``B``, calculates ``Aᴴ`` \\ ``Bᴴ``.
+"""
+Ac_ldiv_Bc
+
+"""
+    @enum EnumName EnumValue1[=x] EnumValue2[=y]
+
+Create an [`Enum`](:obj:`Enum`) type with name `EnumName` and enum member values of
+`EnumValue1` and `EnumValue2` with optional assigned values of `x` and `y`, respectively.
+`EnumName` can be used just like other types and enum member values as regular values, such as
+
+```jldoctest
+julia> @enum FRUIT apple=1 orange=2 kiwi=3
+
+julia> f(x::FRUIT) = "I'm a FRUIT with value: \$(Int(x))"
+f (generic function with 1 method)
+
+julia> f(apple)
+"I'm a FRUIT with value: 1"
+```
+"""
+:@enum
+
+"""
+    asind(x)
+
+Compute the inverse sine of `x`, where the output is in degrees.
+"""
+asind
+
+"""
+    widemul(x, y)
+
+Multiply `x` and `y`, giving the result as a larger type.
+"""
+widemul
+
+"""
+    unsafe_pointer_to_objref(p::Ptr)
+
+Convert a `Ptr` to an object reference. Assumes the pointer refers to a valid heap-allocated
+Julia object. If this is not the case, undefined behavior results, hence this function is
+considered "unsafe" and should be used with care.
+"""
+unsafe_pointer_to_objref
+
+"""
+    chomp(string)
+
+Remove a trailing newline from a string.
+"""
+chomp
+
+"""
+    enumerate(iter)
+
+An iterator that yields `(i, x)` where `i` is an index starting at 1, and
+`x` is the `i`th value from the given iterator. It's useful when you need
+not only the values `x` over which you are iterating, but also the index `i`
+of the iterations.
+
+```jldoctest
+julia> a = ["a", "b", "c"];
+
+julia> for (index, value) in enumerate(a)
+           println("\$index \$value")
+       end
+1 a
+2 b
+3 c
+```
+"""
+enumerate
+
+"""
+    >=(x, y)
+    ≥(x,y)
+
+Greater-than-or-equals comparison operator.
+"""
+Base.(:(>=))
+
+"""
+    dawson(x)
+
+Compute the Dawson function (scaled imaginary error function) of `x`, defined by
+``\\frac{\\sqrt{\\pi}}{2} e^{-x^2} \\operatorname{erfi}(x)``.
+"""
+dawson
+
+"""
+    current_task()
+
+Get the currently running `Task`.
+"""
+current_task
+
+"""
+    randjump(r::MersenneTwister, jumps, [jumppoly]) -> Vector{MersenneTwister}
+
+Create an array of the size `jumps` of initialized `MersenneTwister` RNG objects where the
+first RNG object given as a parameter and following `MersenneTwister` RNGs in the array
+initialized such that a state of the RNG object in the array would be moved forward (without
+generating numbers) from a previous RNG object array element on a particular number of steps
+encoded by the jump polynomial `jumppoly`.
+
+Default jump polynomial moves forward `MersenneTwister` RNG state by 10^20 steps.
+"""
+randjump
+
+"""
+    :(start, [step], stop)
+
+Range operator. `a:b` constructs a range from `a` to `b` with a step size of 1, and `a:s:b`
+is similar but uses a step size of `s`. These syntaxes call the function `colon`. The colon
+is also used in indexing to select whole dimensions.
+"""
+colon(start, step, stop)
+
+"""
+    \$(x, y)
+
+Bitwise exclusive or.
+"""
+Base.(:$)(x, y)
+
+"""
+    getsockname(sock::Union{TCPServer, TCPSocket}) -> (IPAddr,UInt16)
+
+Get the IP address and the port that the given TCP socket is connected to (or bound to, in the case of TCPServer).
+"""
+getsockname
+
+"""
+    Base.remoteref_id(r::AbstractRemoteRef) -> (whence, id)
+
+A low-level API which returns the unique identifying tuple for a remote reference. A
+reference id is a tuple of two elements - pid where the reference was created from and a
+one-up number from that node.
+"""
+Base.remoteref_id
+
+"""
+    Base.channel_from_id(refid) -> c
+
+A low-level API which returns the backing AbstractChannel for an id returned by
+`remoteref_id`. The call is valid only on the node where the backing channel exists.
+"""
+Base.channel_from_id
+
+"""
+    Base.worker_id_from_socket(s::IO) -> pid
+
+A low-level API which given a `IO` connection, returns the pid of the worker it is connected
+to. This is useful when writing custom `serialize` methods for a type, which optimizes the
+data written out depending on the receiving process id.
+"""
+Base.worker_id_from_socket
diff --git a/base/docs/helpdb/Dates.jl b/base/docs/helpdb/Dates.jl
new file mode 100644
index 0000000000000..9e9f342631c16
--- /dev/null
+++ b/base/docs/helpdb/Dates.jl
@@ -0,0 +1,139 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# Dates
+
+"""
+    DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), negate=false, limit=10000) -> DateTime
+
+Create a `DateTime` through the adjuster API. The starting point will be constructed from
+the provided `y, m, d...` arguments, and will be adjusted until `f::Function` returns
+`true`. The step size in adjusting can be provided manually through the `step` keyword. If
+`negate=true`, then the adjusting will stop when `f::Function` returns `false` instead of
+`true`. `limit` provides a limit to the max number of iterations the adjustment API will
+pursue before throwing an error (in the case that `f::Function` is never satisfied).
+"""
+Dates.DateTime(f::Function, y)
+
+"""
+    DateTime(dt::Date) -> DateTime
+
+Converts a `Date` type to a `DateTime`. The hour, minute, second, and millisecond parts of
+the new `DateTime` are assumed to be zero.
+"""
+Dates.DateTime(dt::Date)
+
+"""
+    DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime
+
+Construct a `DateTime` type by parsing the `dt` date string following the pattern given in
+the `format` string. The following codes can be used for constructing format strings:
+
+| Code       | Matches   | Comment                                                      |
+|:-----------|:----------|:-------------------------------------------------------------|
+| `y`        | 1996, 96  | Returns year of 1996, 0096                                   |
+| `m`        | 1, 01     | Matches 1 or 2-digit months                                  |
+| `u`        | Jan       | Matches abbreviated months according to the `locale` keyword |
+| `U`        | January   | Matches full month names according to the `locale` keyword   |
+| `d`        | 1, 01     | Matches 1 or 2-digit days                                    |
+| `H`        | 00        | Matches hours                                                |
+| `M`        | 00        | Matches minutes                                              |
+| `S`        | 00        | Matches seconds                                              |
+| `s`        | .500      | Matches milliseconds                                         |
+| `e`        | Mon, Tues | Matches abbreviated days of the week                         |
+| `E`        | Monday    | Matches full name days of the week                           |
+| `yyyymmdd` | 19960101  | Matches fixed-width year, month, and day                     |
+
+All characters not listed above are treated as delimiters between date and time slots. So a
+`dt` string of "1996-01-15T00:00:00.0" would have a `format` string like "y-m-dTH:M:S.s".
+"""
+Dates.DateTime(dt::AbstractString, format::AbstractString)
+
+"""
+    DateTime(dt::AbstractString, df::DateFormat) -> DateTime
+
+Similar form as above for parsing a `DateTime`, but passes a `DateFormat` object instead of
+a raw formatting string. It is more efficient if similarly formatted date strings will be
+parsed repeatedly to first create a `DateFormat` object then use this method for parsing.
+"""
+Dates.DateTime(dt::AbstractString, df::Dates.DateFormat)
+
+
+"""
+    Date(f::Function, y[, m]; step=Day(1), negate=false, limit=10000) -> Date
+
+Create a `Date` through the adjuster API. The starting point will be constructed from the
+provided `y, m` arguments, and will be adjusted until `f::Function` returns `true`. The step
+size in adjusting can be provided manually through the `step` keyword. If `negate=true`,
+then the adjusting will stop when `f::Function` returns `false` instead of `true`. `limit`
+provides a limit to the max number of iterations the adjustment API will pursue before
+throwing an error (given that `f::Function` is never satisfied).
+"""
+Dates.Date(f::Function, y)
+
+"""
+    Date(dt::DateTime) -> Date
+
+Converts a `DateTime` type to a `Date`. The hour, minute, second, and millisecond parts of
+the `DateTime` are truncated, so only the year, month and day parts are used in
+construction.
+"""
+Dates.Date(dt::DateTime)
+
+"""
+    Date(dt::AbstractString, format::AbstractString; locale="english") -> Date
+
+Construct a `Date` type by parsing a `dt` date string following the pattern given in the
+`format` string. Follows the same conventions as `DateTime` above.
+"""
+Dates.Date(dt::AbstractString, format::AbstractString)
+
+"""
+    Date(dt::AbstractString, df::DateFormat) -> Date
+
+Parse a date from a date string `dt` using a `DateFormat` object `df`.
+"""
+Dates.Date(dt::AbstractString, df::Dates.DateFormat)
+
+
+"""
+    year(dt::TimeType) -> Int64
+    month(dt::TimeType) -> Int64
+    week(dt::TimeType) -> Int64
+    day(dt::TimeType) -> Int64
+    hour(dt::TimeType) -> Int64
+    minute(dt::TimeType) -> Int64
+    second(dt::TimeType) -> Int64
+    millisecond(dt::TimeType) -> Int64
+
+Return the field part of a `Date` or `DateTime` as an `Int64`.
+"""
+Dates.year
+
+"""
+    Year(dt::TimeType) -> Year
+    Month(dt::TimeType) -> Month
+    Week(dt::TimeType) -> Week
+    Day(dt::TimeType) -> Day
+    Hour(dt::TimeType) -> Hour
+    Minute(dt::TimeType) -> Minute
+    Second(dt::TimeType) -> Second
+    Millisecond(dt::TimeType) -> Millisecond
+
+Return the field part of a `Date` or `DateTime` as a `Period` type.
+"""
+Dates.Year(dt::Dates.TimeType)
+
+"""
+    Year(v)
+    Month(v)
+    Week(v)
+    Day(v)
+    Hour(v)
+    Minute(v)
+    Second(v)
+    Millisecond(v)
+
+Construct a `Period` type with the given `v` value. Input must be losslessly convertible to
+an `Int64`.
+"""
+Dates.Year(v)
diff --git a/base/docs/utils.jl b/base/docs/utils.jl
index 23b4aac734b3b..65c45a6411570 100644
--- a/base/docs/utils.jl
+++ b/base/docs/utils.jl
@@ -91,10 +91,31 @@ end
 
 # REPL help
 
+function helpmode(line::AbstractString)
+    line = strip(line)
+    expr =
+        if haskey(keywords, symbol(line))
+            # Docs for keywords must be treated separately since trying to parse a single
+            # keyword such as `function` would throw a parse error due to the missing `end`.
+            symbol(line)
+        else
+            x = Base.syntax_deprecation_warnings(false) do
+                parse(line, raise = false)
+            end
+            # Retrieving docs for macros requires us to make a distinction between the text
+            # `@macroname` and `@macroname()`. These both parse the same, but are used by
+            # the docsystem to return different results. The first returns all documentation
+            # for `@macroname`, while the second returns *only* the docs for the 0-arg
+            # definition if it exists.
+            (isexpr(x, :macrocall, 1) && !endswith(line, "()")) ? quot(x) : x
+        end
+    :(Base.Docs.@repl $expr)
+end
+
 function repl_search(io::IO, s)
     pre = "search:"
     print(io, pre)
-    printmatches(io, s, completions(s), cols=Base.tty_size()[2]-length(pre))
+    printmatches(io, s, completions(s), cols = displaysize(io)[2] - length(pre))
     println(io, "\n")
 end
 
@@ -110,21 +131,41 @@ end
 
 repl_corrections(s) = repl_corrections(STDOUT, s)
 
-macro repl(ex)
+macro repl(ex) repl(ex) end
+
+function repl(s::Symbol)
     quote
-        # Fuzzy Searching
-        $(isexpr(ex, Symbol)) && repl_search($(string(ex)))
-        if $(isa(ex, Symbol)) &&
-                !(isdefined($(current_module()), $(Expr(:quote, ex))) ||
-                  haskey(keywords, $(Expr(:quote, ex))))
-            repl_corrections($(string(ex)))
-        else
-            if $(isfield(ex) ? :(isa($(esc(ex.args[1])), DataType)) : false)
-                $(isfield(ex) ? :(fielddoc($(esc(ex.args[1])), $(ex.args[2]))) : nothing)
+        repl_search($(string(s)))
+        ($(isdefined(s) || haskey(keywords, s))) || repl_corrections($(string(s)))
+        $(_repl(s))
+    end
+end
+
+isregex(x) = isexpr(x, :macrocall, 2) && x.args[1] == symbol("@r_str") && !isempty(x.args[2])
+
+repl(ex::Expr) = isregex(ex) ? :(apropos($ex)) : _repl(ex)
+
+repl(str::AbstractString) = :(apropos($str))
+
+repl(other) = :(@doc $(esc(other)))
+
+function _repl(x)
+    docs = :(@doc $(esc(x)))
+    if isexpr(x, :call)
+        # Handles function call syntax where each argument is an atom (symbol, number, etc.)
+        t = Base.gen_call_with_extracted_types(doc, x)
+        (isexpr(t, :call, 3) && t.args[1] == doc) && (docs = t)
+    end
+    if isfield(x)
+        quote
+            if isa($(esc(x.args[1])), DataType)
+                fielddoc($(esc(x.args[1])), $(esc(x.args[2])))
             else
-                $((isa(ex,Symbol) || isfield(ex) || isexpr(ex,:macrocall)) ? :(@doc ($(esc(ex)))) : Base.gen_call_with_extracted_types(doc, ex))
+                $docs
             end
         end
+    else
+        docs
     end
 end
 
@@ -223,7 +264,7 @@ end
 
 printmatch(args...) = printfuzzy(STDOUT, args...)
 
-function printmatches(io::IO, word, matches; cols = Base.tty_size()[2])
+function printmatches(io::IO, word, matches; cols = displaysize(io)[2])
     total = 0
     for match in matches
         total + length(match) + 1 > cols && break
@@ -234,9 +275,9 @@ function printmatches(io::IO, word, matches; cols = Base.tty_size()[2])
     end
 end
 
-printmatches(args...; cols = Base.tty_size()[2]) = printmatches(STDOUT, args..., cols = cols)
+printmatches(args...; cols = displaysize(STDOUT)[2]) = printmatches(STDOUT, args..., cols = cols)
 
-function print_joined_cols(io::IO, ss, delim = "", last = delim; cols = Base.tty_size()[2])
+function print_joined_cols(io::IO, ss, delim = "", last = delim; cols = displaysize(io)[2])
     i = 0
     total = 0
     for i = 1:length(ss)
@@ -246,13 +287,13 @@ function print_joined_cols(io::IO, ss, delim = "", last = delim; cols = Base.tty
     print_joined(io, ss[1:i], delim, last)
 end
 
-print_joined_cols(args...; cols = Base.tty_size()[2]) = print_joined_cols(STDOUT, args...; cols=cols)
+print_joined_cols(args...; cols = displaysize(STDOUT)[2]) = print_joined_cols(STDOUT, args...; cols=cols)
 
 function print_correction(io, word)
     cors = levsort(word, accessible(current_module()))
     pre = "Perhaps you meant "
     print(io, pre)
-    print_joined_cols(io, cors, ", ", " or "; cols = Base.tty_size()[2]-length(pre))
+    print_joined_cols(io, cors, ", ", " or "; cols = displaysize(io)[2] - length(pre))
     println(io)
     return
 end
@@ -299,46 +340,59 @@ function docsearch(haystack, needle)
 end
 
 ## Searching specific documentation objects
-function docsearch(haystack::TypeDoc, needle)
-    docsearch(haystack.main, needle) && return true
-    for v in values(haystack.fields)
-        docsearch(v, needle) && return true
-    end
-    for v in values(haystack.meta)
+function docsearch(haystack::MultiDoc, needle)
+    for v in values(haystack.docs)
         docsearch(v, needle) && return true
     end
     false
 end
 
-function docsearch(haystack::FuncDoc, needle)
-    docsearch(haystack.main, needle) && return true
-    for v in values(haystack.meta)
-        docsearch(v, needle) && return true
+function docsearch(haystack::DocStr, needle)
+    docsearch(parsedoc(haystack), needle) && return true
+    if haskey(haystack.data, :fields)
+        for doc in values(haystack.data[:fields])
+            docsearch(doc, needle) && return true
+        end
     end
     false
 end
 
-## Recursive Markdown search
-docsearch(haystack::Markdown.BlockQuote, needle) = docsearch(haystack.content, needle)
-docsearch(haystack::Markdown.Bold, needle) = docsearch(haystack.text, needle)
-docsearch(haystack::Markdown.Code, needle) = docsearch(haystack.code, needle)
-docsearch(haystack::Markdown.Header, needle) = docsearch(haystack.text, needle)
-docsearch(haystack::Markdown.HorizontalRule, needle) = false
-docsearch(haystack::Markdown.Image, needle) = docsearch(haystack.alt, needle)
-docsearch(haystack::Markdown.Italic, needle) = docsearch(haystack.text, needle)
-docsearch(haystack::Markdown.LaTeX, needle) = docsearch(haystack.formula, needle)
-docsearch(haystack::Markdown.LineBreak, needle) = false
-docsearch(haystack::Markdown.Link, needle) = docsearch(haystack.text, needle) # URL too?
-docsearch(haystack::Markdown.List, needle) = docsearch(haystack.items, needle)
-docsearch(haystack::Markdown.MD, needle) = docsearch(haystack.content, needle)
-docsearch(haystack::Markdown.Paragraph, needle) = docsearch(haystack.content, needle)
-docsearch(haystack::Markdown.Table, needle) = docsearch(haystack.rows, needle)
+## Markdown search simply strips all markup and searches plain text version
+docsearch(haystack::Markdown.MD, needle) =
+    docsearch(stripmd(haystack.content), needle)
+
+"""
+    stripmd(x)
+
+Strip all Markdown markup from x, leaving the result in plain text. Used
+internally by apropos to make docstrings containing more than one markdown
+element searchable.
+"""
+stripmd(x::AbstractString) = x  # base case
+stripmd(x::Void) = " "
+stripmd(x::Vector) = string(map(stripmd, x)...)
+stripmd(x::Markdown.BlockQuote) = "$(stripmd(x.content))"
+stripmd(x::Markdown.Bold) = "$(stripmd(x.text))"
+stripmd(x::Markdown.Code) = "$(stripmd(x.code))"
+stripmd{N}(x::Markdown.Header{N}) = stripmd(x.text)
+stripmd(x::Markdown.HorizontalRule) = " "
+stripmd(x::Markdown.Image) = "$(stripmd(x.alt)) $(x.url)"
+stripmd(x::Markdown.Italic) = "$(stripmd(x.text))"
+stripmd(x::Markdown.LaTeX) = "$(x.formula)"
+stripmd(x::Markdown.LineBreak) = " "
+stripmd(x::Markdown.Link) = "$(stripmd(x.text)) $(x.url)"
+stripmd(x::Markdown.List) = join(map(stripmd, x.items), " ")
+stripmd(x::Markdown.MD) = join(map(stripmd, x.content), " ")
+stripmd(x::Markdown.Paragraph) = stripmd(x.content)
+stripmd(x::Markdown.Footnote) = "$(stripmd(x.id)) $(stripmd(x.text))"
+stripmd(x::Markdown.Table) =
+    join([join(map(stripmd, r), " ") for r in x.rows], " ")
 
 # Apropos searches through all available documentation for some string or regex
 """
     apropos(string)
 
-Search through all documention for a string, ignoring case.
+Search through all documentation for a string, ignoring case.
 """
 apropos(string) = apropos(STDOUT, string)
 apropos(io::IO, string) = apropos(io, Regex("\\Q$string", "i"))
@@ -347,10 +401,7 @@ function apropos(io::IO, needle::Regex)
         # Module doc might be in README.md instead of the META dict
         docsearch(doc(mod), needle) && println(io, mod)
         for (k, v) in meta(mod)
-            (k === meta(mod) || k === mod) && continue
-            if docsearch(v, needle)
-                println(io, k)
-            end
+            docsearch(v, needle) && println(io, k)
         end
     end
 end
diff --git a/base/env.jl b/base/env.jl
index b99f436717c4b..876e32b807b41 100644
--- a/base/env.jl
+++ b/base/env.jl
@@ -1,74 +1,67 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 @unix_only begin
-    _getenv(var::AbstractString) = ccall(:getenv, Ptr{UInt8}, (Cstring,), var)
-    _hasenv(s::AbstractString) = _getenv(s) != C_NULL
-end
 
-@windows_only begin
-const ERROR_ENVVAR_NOT_FOUND = UInt32(203)
-_getenvlen(var::AbstractString) = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Cwstring,Ptr{UInt8},UInt32),var,C_NULL,0)
-_hasenv(s::AbstractString) = _getenvlen(s)!=0 || Libc.GetLastError()!=ERROR_ENVVAR_NOT_FOUND
-function _jl_win_getenv(s::UTF16String,len::UInt32)
-    val=zeros(UInt16,len)
-    ret=ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Cwstring,Ptr{UInt16},UInt32),s,val,len)
-    if (ret == 0 && len != 1) || ret != len-1 || val[end] != 0
-        error(string("getenv: ", s, ' ', len, "-1 != ", ret, ": ", Libc.FormatMessage()))
-    end
-    val
+_getenv(var::AbstractString) = ccall(:getenv, Cstring, (Cstring,), var)
+_hasenv(s::AbstractString) = _getenv(s) != C_NULL
+
+function access_env(onError::Function, var::AbstractString)
+    val = _getenv(var)
+    val == C_NULL ? onError(var) : bytestring(val)
 end
+
+function _setenv(var::AbstractString, val::AbstractString, overwrite::Bool=true)
+    ret = ccall(:setenv, Int32, (Cstring,Cstring,Int32), var, val, overwrite)
+    systemerror(:setenv, ret != 0)
 end
 
-macro accessEnv(var,errorcase)
-    @unix_only return quote
-         val=_getenv($(esc(var)))
-         if val == C_NULL
-            $(esc(errorcase))
-         end
-         bytestring(val)
-    end
-    @windows_only return quote
-        let var = utf16($(esc(var)))
-            len=_getenvlen(var)
-            if len == 0
-                if Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND
-                    return utf8("")
-                else
-                    $(esc(errorcase))
-                end
-            end
-            utf8(UTF16String(_jl_win_getenv(var,len)))
-        end
-    end
+function _unsetenv(var::AbstractString)
+    ret = ccall(:unsetenv, Int32, (Cstring,), var)
+    systemerror(:unsetenv, ret != 0)
 end
 
-function _setenv(var::AbstractString, val::AbstractString, overwrite::Bool)
-    @unix_only begin
-        ret = ccall(:setenv, Int32, (Cstring,Cstring,Int32), var, val, overwrite)
-        systemerror(:setenv, ret != 0)
+end # @unix_only
+
+@windows_only begin
+
+const ERROR_ENVVAR_NOT_FOUND = UInt32(203)
+
+_getenvlen(var::Vector{UInt16}) = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,C_NULL,0)
+_hasenv(s::Vector{UInt16}) = _getenvlen(s) != 0 || Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND
+_hasenv(s::AbstractString) = _hasenv(cwstring(s))
+
+function access_env(onError::Function, str::AbstractString)
+    var = cwstring(str)
+    len = _getenvlen(var)
+    if len == 0
+        return Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND ? utf8("") : onError(str)
     end
-    @windows_only begin
-        var = utf16(var)
-        if overwrite || !_hasenv(var)
-            ret = ccall(:SetEnvironmentVariableW,stdcall,Int32,(Cwstring,Cwstring),var,val)
-            systemerror(:setenv, ret == 0)
-        end
+    val = zeros(UInt16,len)
+    ret = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,val,len)
+    if (ret == 0 && len != 1) || ret != len-1 || val[end] != 0
+        error(string("getenv: ", str, ' ', len, "-1 != ", ret, ": ", Libc.FormatMessage()))
     end
+    pop!(val) # NUL
+    return UTF8String(utf16to8(val))
 end
 
-_setenv(var::AbstractString, val::AbstractString) = _setenv(var, val, true)
-
-function _unsetenv(var::AbstractString)
-    @unix_only begin
-        ret = ccall(:unsetenv, Int32, (Cstring,), var)
-        systemerror(:unsetenv, ret != 0)
-    end
-    @windows_only begin
-        ret = ccall(:SetEnvironmentVariableW,stdcall,Int32,(Cwstring,Ptr{UInt16}),var,C_NULL)
+function _setenv(svar::AbstractString, sval::AbstractString, overwrite::Bool=true)
+    var = cwstring(svar)
+    val = cwstring(sval)
+    if overwrite || !_hasenv(var)
+        ret = ccall(:SetEnvironmentVariableW,stdcall,Int32,(Ptr{UInt16},Ptr{UInt16}),var,val)
         systemerror(:setenv, ret == 0)
     end
 end
 
+function _unsetenv(svar::AbstractString)
+    var = cwstring(svar)
+    ret = ccall(:SetEnvironmentVariableW,stdcall,Int32,(Ptr{UInt16},Ptr{UInt16}),var,C_NULL)
+    systemerror(:setenv, ret == 0)
+end
+
+end # @windows_only
+
 ## ENV: hash interface ##
 
 type EnvHash <: Associative{ByteString,ByteString}; end
@@ -76,19 +69,12 @@ const ENV = EnvHash()
 
 similar(::EnvHash) = Dict{ByteString,ByteString}()
 
-getindex(::EnvHash, k::AbstractString) = @accessEnv k throw(KeyError(k))
-get(::EnvHash, k::AbstractString, def) = @accessEnv k (return def)
+getindex(::EnvHash, k::AbstractString) = access_env(k->throw(KeyError(k)), k)
+get(::EnvHash, k::AbstractString, def) = access_env(k->def, k)
 in(k::AbstractString, ::KeyIterator{EnvHash}) = _hasenv(k)
 pop!(::EnvHash, k::AbstractString) = (v = ENV[k]; _unsetenv(k); v)
 pop!(::EnvHash, k::AbstractString, def) = haskey(ENV,k) ? pop!(ENV,k) : def
-function delete!(::EnvHash, k::AbstractString)
-    warn_once("""
-        delete!(ENV,key) now returns the modified environment.
-        Use pop!(ENV,key) to retrieve the value instead.
-        """)
-    _unsetenv(k)
-    ENV
-end
+delete!(::EnvHash, k::AbstractString) = (_unsetenv(k); ENV)
 delete!(::EnvHash, k::AbstractString, def) = haskey(ENV,k) ? delete!(ENV,k) : def
 setindex!(::EnvHash, v, k::AbstractString) = _setenv(k,string(v))
 push!(::EnvHash, k::AbstractString, v) = setindex!(ENV, v, k)
@@ -114,7 +100,7 @@ end
 @windows_only begin
 start(hash::EnvHash) = (pos = ccall(:GetEnvironmentStringsW,stdcall,Ptr{UInt16},()); (pos,pos))
 function done(hash::EnvHash, block::Tuple{Ptr{UInt16},Ptr{UInt16}})
-    if unsafe_load(block[1])==0
+    if unsafe_load(block[1]) == 0
         ccall(:FreeEnvironmentStringsW,stdcall,Int32,(Ptr{UInt16},),block[2])
         return true
     end
@@ -123,10 +109,10 @@ end
 function next(hash::EnvHash, block::Tuple{Ptr{UInt16},Ptr{UInt16}})
     pos = block[1]
     blk = block[2]
-    len = ccall(:wcslen, UInt, (Ptr{UInt16},), pos)+1
+    len = ccall(:wcslen, UInt, (Ptr{UInt16},), pos)
     buf = Array(UInt16, len)
     unsafe_copy!(pointer(buf), pos, len)
-    env = utf8(UTF16String(buf))
+    env = UTF8String(utf16to8(buf))
     m = match(r"^(=?[^=]+)=(.*)$"s, env)
     if m === nothing
         error("malformed environment entry: $env")
@@ -155,26 +141,13 @@ function withenv{T<:AbstractString}(f::Function, keyvals::Pair{T}...)
     old = Dict{T,Any}()
     for (key,val) in keyvals
         old[key] = get(ENV,key,nothing)
-        val !== nothing ? (ENV[key]=val) : _unsetenv(key)
+        val !== nothing ? (ENV[key]=val) : delete!(ENV, key)
     end
     try f()
     finally
         for (key,val) in old
-            val !== nothing ? (ENV[key]=val) : _unsetenv(key)
+            val !== nothing ? (ENV[key]=val) : delete!(ENV, key)
         end
     end
 end
 withenv(f::Function) = f() # handle empty keyvals case; see #10853
-
-## misc environment-related functionality ##
-
-function tty_size()
-    if isdefined(Base, :active_repl)
-        os = REPL.outstream(Base.active_repl)
-        if isa(os, Terminals.TTYTerminal)
-            return size(os)
-        end
-    end
-    return (parse(Int,get(ENV,"LINES","24")),
-            parse(Int,get(ENV,"COLUMNS","80")))
-end
diff --git a/base/error.jl b/base/error.jl
index 4e27de0805c0f..a5de778a01dc0 100644
--- a/base/error.jl
+++ b/base/error.jl
@@ -18,8 +18,8 @@
 
 ## native julia error handling ##
 
-error(s::AbstractString) = throw(Main.Base.call(Main.Base.ErrorException,s))
-error(s...) = throw(Main.Base.call(Main.Base.ErrorException,Main.Base.string(s...)))
+error(s::AbstractString) = throw(Main.Base.ErrorException(s))
+error(s...) = throw(Main.Base.ErrorException(Main.Base.string(s...)))
 
 rethrow() = ccall(:jl_rethrow, Void, ())::Bottom
 rethrow(e) = ccall(:jl_rethrow_other, Void, (Any,), e)::Bottom
@@ -31,7 +31,7 @@ kwerr(kw) = error("unrecognized keyword argument \"", kw, "\"")
 
 ## system error handling ##
 
-systemerror(p, b::Bool) = b ? throw(Main.Base.SystemError(string(p))) : nothing
+systemerror(p, b::Bool; extrainfo=nothing) = b ? throw(Main.Base.SystemError(string(p), Libc.errno(), extrainfo)) : nothing
 
 ## assertion functions and macros ##
 
diff --git a/base/essentials.jl b/base/essentials.jl
index 582f66bb2584a..7d42dad0efdbb 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -6,8 +6,6 @@ typealias Callable Union{Function,DataType}
 
 const Bottom = Union{}
 
-call(::Type{Union}, args...) = Union{args...}
-
 # The real @inline macro is not available until after array.jl, so this
 # internal macro splices the meta Expr directly into the function body.
 macro _inline_meta()
@@ -16,46 +14,13 @@ end
 macro _noinline_meta()
     Expr(:meta, :noinline)
 end
-
-
-# constructors for Core types in boot.jl
-call(T::Type{BoundsError}) = Core.call(T)
-call(T::Type{BoundsError}, args...) = Core.call(T, args...)
-call(T::Type{DivideError}) = Core.call(T)
-call(T::Type{DomainError}) = Core.call(T)
-call(T::Type{OverflowError}) = Core.call(T)
-call(T::Type{InexactError}) = Core.call(T)
-call(T::Type{OutOfMemoryError}) = Core.call(T)
-call(T::Type{ReadOnlyMemoryError}) = Core.call(T)
-call(T::Type{StackOverflowError}) = Core.call(T)
-call(T::Type{SegmentationFault}) = Core.call(T)
-call(T::Type{UndefRefError}) = Core.call(T)
-call(T::Type{UndefVarError}, var::Symbol) = Core.call(T, var)
-call(T::Type{InterruptException}) = Core.call(T)
-call(T::Type{TypeError}, func::Symbol, context::AbstractString, expected::Type, got) = Core.call(T, func, context, expected, got)
-call(T::Type{SymbolNode}, name::Symbol, t::ANY) = Core.call(T, name, t)
-call(T::Type{GlobalRef}, modu, name::Symbol) = Core.call(T, modu, name)
-call(T::Type{ASCIIString}, d::Array{UInt8,1}) = Core.call(T, d)
-call(T::Type{UTF8String}, d::Array{UInt8,1}) = Core.call(T, d)
-call(T::Type{TypeVar}, args...) = Core.call(T, args...)
-call(T::Type{TypeConstructor}, args...) = Core.call(T, args...)
-call(T::Type{Expr}, args::ANY...) = _expr(args...)
-call(T::Type{LineNumberNode}, f::Symbol, n::Int) = Core.call(T, f, n)
-call(T::Type{LabelNode}, n::Int) = Core.call(T, n)
-call(T::Type{GotoNode}, n::Int) = Core.call(T, n)
-call(T::Type{QuoteNode}, x::ANY) = Core.call(T, x)
-call(T::Type{NewvarNode}, s::Symbol) = Core.call(T, s)
-call(T::Type{TopNode}, s::Symbol) = Core.call(T, s)
-call(T::Type{Module}, args...) = Core.call(T, args...)
-call(T::Type{Task}, f::Function) = Core.call(T, f)
-call(T::Type{GenSym}, n::Int) = Core.call(T, n)
-call(T::Type{WeakRef}) = Core.call(T)
-call(T::Type{WeakRef}, v::ANY) = Core.call(T, v)
-call(T::Type{Void}) = Core.call(Void)
-
-# The specialization for 1 arg is important when running with --inline=no, see #11158
-call{T}(::Type{T}, arg) = convert(T, arg)::T
-call{T}(::Type{T}, args...) = convert(T, args...)::T
+macro _pure_meta()
+    Expr(:meta, :pure)
+end
+# another version of inlining that propagates an inbounds context
+macro _propagate_inbounds_meta()
+    Expr(:meta, :inline, :propagate_inbounds)
+end
 
 convert{T}(::Type{T}, x::T) = x
 
@@ -76,7 +41,9 @@ macro generated(f)
 end
 
 
-@generated function tuple_type_head{T<:Tuple}(::Type{T})
+tuple_type_head(::Type{Union{}}) = throw(MethodError(tuple_type_head, (Type{Union{}},)))
+function tuple_type_head{T<:Tuple}(::Type{T})
+    @_pure_meta
     T.parameters[1]
 end
 
@@ -84,7 +51,8 @@ isvarargtype(t::ANY) = isa(t,DataType)&&is((t::DataType).name,Vararg.name)
 isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
 unwrapva(t::ANY) = isvarargtype(t) ? t.parameters[1] : t
 
-@generated function tuple_type_tail{T<:Tuple}(::Type{T})
+function tuple_type_tail{T<:Tuple}(::Type{T})
+    @_pure_meta
     if isvatuple(T) && length(T.parameters) == 1
         return T
     end
@@ -113,7 +81,7 @@ cconvert{P<:Ptr}(::Type{P}, x) = x # but defer the conversion to Ptr to unsafe_c
 unsafe_convert{T}(::Type{T}, x::T) = x # unsafe_convert (like convert) defaults to assuming the convert occurred
 unsafe_convert{P<:Ptr}(::Type{P}, x::Ptr) = convert(P, x)
 
-reinterpret{T,S}(::Type{T}, x::S) = box(T,unbox(S,x))
+reinterpret{T}(::Type{T}, x) = box(T, x)
 
 sizeof(x) = Core.sizeof(x)
 
@@ -154,26 +122,22 @@ end
 map(f::Function, a::Array{Any,1}) = Any[ f(a[i]) for i=1:length(a) ]
 
 function precompile(f::ANY, args::Tuple)
-    if isa(f,DataType)
-        args = tuple(Type{f}, args...)
-        f = f.name.module.call
-    end
-    if isgeneric(f)
-        ccall(:jl_compile_hint, Void, (Any, Any), f, Tuple{args...})
-    end
+    ccall(:jl_compile_hint, Void, (Any,), Tuple{Core.Typeof(f), args...})
 end
 
 esc(e::ANY) = Expr(:escape, e)
 
-macro boundscheck(yesno,blk)
+macro boundscheck(blk)
     # hack: use this syntax since it avoids introducing line numbers
-    :($(Expr(:boundscheck,yesno));
+    :($(Expr(:boundscheck,true));
       $(esc(blk));
       $(Expr(:boundscheck,:pop)))
 end
 
 macro inbounds(blk)
-    :(@boundscheck false $(esc(blk)))
+    :($(Expr(:inbounds,true));
+      $(esc(blk));
+      $(Expr(:inbounds,:pop)))
 end
 
 macro label(name::Symbol)
@@ -184,24 +148,6 @@ macro goto(name::Symbol)
     Expr(:symbolicgoto, name)
 end
 
-call{T,N}(::Type{Array{T}}, d::NTuple{N,Int}) =
-    ccall(:jl_new_array, Array{T,N}, (Any,Any), Array{T,N}, d)
-call{T}(::Type{Array{T}}, d::Integer...) = Array{T}(convert(Tuple{Vararg{Int}}, d))
-
-call{T}(::Type{Array{T}}, m::Integer) =
-    ccall(:jl_alloc_array_1d, Array{T,1}, (Any,Int), Array{T,1}, m)
-call{T}(::Type{Array{T}}, m::Integer, n::Integer) =
-    ccall(:jl_alloc_array_2d, Array{T,2}, (Any,Int,Int), Array{T,2}, m, n)
-call{T}(::Type{Array{T}}, m::Integer, n::Integer, o::Integer) =
-    ccall(:jl_alloc_array_3d, Array{T,3}, (Any,Int,Int,Int), Array{T,3}, m, n, o)
-
-# TODO: possibly turn these into deprecations
-Array{T,N}(::Type{T}, d::NTuple{N,Int}) = Array{T}(d)
-Array{T}(::Type{T}, d::Integer...)      = Array{T}(convert(Tuple{Vararg{Int}}, d))
-Array{T}(::Type{T}, m::Integer)                       = Array{T}(m)
-Array{T}(::Type{T}, m::Integer,n::Integer)            = Array{T}(m,n)
-Array{T}(::Type{T}, m::Integer,n::Integer,o::Integer) = Array{T}(m,n,o)
-
 # SimpleVector
 
 function getindex(v::SimpleVector, i::Int)
diff --git a/base/exports.jl b/base/exports.jl
index cfc1574f57046..2b7e3349b8452 100644
--- a/base/exports.jl
+++ b/base/exports.jl
@@ -7,6 +7,9 @@ export
     Meta,
     Operators,
     Pkg,
+    Git,
+    LibGit2,
+    StackTraces,
     Profile,
     Dates,
     Sys,
@@ -18,16 +21,12 @@ export
     BLAS,
     LAPACK,
     Serializer,
-    SparseMatrix,
     Docs,
     Markdown,
 
 # Types
     AbstractChannel,
     AbstractMatrix,
-    AbstractSparseArray,
-    AbstractSparseMatrix,
-    AbstractSparseVector,
     AbstractVector,
     AbstractVecOrMat,
     Array,
@@ -60,9 +59,9 @@ export
     Enumerate,
     Factorization,
     FileMonitor,
-    FileOffset,
     Filter,
     FloatRange,
+    Future,
     Hermitian,
     UniformScaling,
     InsertionSort,
@@ -89,7 +88,7 @@ export
     Rational,
     Regex,
     RegexMatch,
-    RemoteRef,
+    RemoteChannel,
     RepString,
     RevString,
     RoundFromZero,
@@ -105,8 +104,6 @@ export
     SharedArray,
     SharedMatrix,
     SharedVector,
-    SparseMatrixCSC,
-    StatStruct,
     StepRange,
     StridedArray,
     StridedMatrix,
@@ -139,7 +136,6 @@ export
     Cintmax_t,
     Clong,
     Clonglong,
-    Coff_t,
     Cptrdiff_t,
     Cshort,
     Csize_t,
@@ -184,6 +180,7 @@ export
     JULIA_HOME,
     LOAD_PATH,
     OS_NAME,
+    PROGRAM_FILE,
     STDERR,
     STDIN,
     STDOUT,
@@ -216,6 +213,7 @@ export
     ≢,
     $,
     %,
+    ÷,
     &,
     *,
     +,
@@ -226,6 +224,7 @@ export
     .-,
     .*,
     ./,
+    .÷,
     .%,
     .<,
     .<=,
@@ -258,7 +257,6 @@ export
     |>,
     ~,
     :,
-    ÷,
     =>,
     A_ldiv_B!,
     A_ldiv_Bc,
@@ -286,7 +284,6 @@ export
     At_mul_Bt!,
     At_rdiv_B,
     At_rdiv_Bt,
-    call,
 
 # scalar math
     @evalpoly,
@@ -359,7 +356,9 @@ export
     factor,
     factorial,
     fld,
+    fld1,
     fldmod,
+    fldmod1,
     flipsign,
     float,
     tryparse,
@@ -386,6 +385,7 @@ export
     isprime,
     isqrt,
     isreal,
+    isimag,
     issubnormal,
     lcm,
     ldexp,
@@ -524,6 +524,8 @@ export
     findin,
     findmax,
     findmin,
+    findmin!,
+    findmax!,
     findn,
     findnext,
     findprev,
@@ -560,7 +562,6 @@ export
     minimum,
     minmax,
     ndims,
-    nnz,
     nonzeros,
     nthperm!,
     nthperm,
@@ -663,7 +664,7 @@ export
     ishermitian,
     isposdef!,
     isposdef,
-    issym,
+    issymmetric,
     istril,
     istriu,
     kron,
@@ -678,6 +679,8 @@ export
     lufact,
     lyap,
     norm,
+    normalize,
+    normalize!,
     nullspace,
     ordschur!,
     ordschur,
@@ -686,6 +689,9 @@ export
     qr,
     qrfact!,
     qrfact,
+    lq,
+    lqfact!,
+    lqfact,
     rank,
     scale!,
     scale,
@@ -713,21 +719,7 @@ export
     ×,
 
 # sparse
-    etree,
     full,
-    issparse,
-    sparse,
-    sparsevec,
-    spdiagm,
-    speye,
-    spones,
-    sprand,
-    sprandbool,
-    sprandn,
-    spzeros,
-    symperm,
-    rowvals,
-    nzrange,
 
 # bitarrays
     bitpack,
@@ -767,6 +759,7 @@ export
     filter,
     foldl,
     foldr,
+    foreach,
     get,
     get!,
     getindex,
@@ -925,12 +918,9 @@ export
 
 # bigfloat & precision
     precision,
-    get_bigfloat_precision,
-    set_bigfloat_precision,
-    with_bigfloat_precision,
-    get_rounding,
-    set_rounding,
-    with_rounding,
+    rounding,
+    setprecision,
+    setrounding,
     get_zero_subnormals,
     set_zero_subnormals,
 
@@ -1026,8 +1016,8 @@ export
     Condition,
     consume,
     current_task,
-    istaskstarted,
     istaskdone,
+    istaskstarted,
     lock,
     notify,
     produce,
@@ -1059,9 +1049,16 @@ export
     rethrow,
     systemerror,
 
+# stack traces
+    StackTrace,
+    StackFrame,
+    stacktrace,
+    catch_stacktrace,
+
 # types
     convert,
-    fieldoffsets,
+    fieldoffset,
+    fieldname,
     fieldnames,
     isleaftype,
     oftype,
@@ -1070,7 +1067,7 @@ export
     promote_type,
     subtypes,
     instances,
-    super,
+    supertype,
     typeintersect,
     typejoin,
     widen,
@@ -1095,9 +1092,9 @@ export
     fullname,
     functionloc,
     isconst,
-    isgeneric,
     isinteractive,
     less,
+    method_exists,
     methods,
     methodswith,
     module_name,
@@ -1133,9 +1130,9 @@ export
 
 # IP address stuff
     @ip_str,
+    IPAddr,
     IPv4,
     IPv6,
-    parseip,
 
 # I/O and events
     accept,
@@ -1152,11 +1149,15 @@ export
     getaddrinfo,
     gethostname,
     getipaddr,
+    getsockname,
     htol,
     hton,
+    IOContext,
+    displaysize,
     ismarked,
     isopen,
     isreadonly,
+    limit_output,
     listen,
     listenany,
     ltoh,
@@ -1173,16 +1174,15 @@ export
     RawFD,
     read,
     read!,
-    readall,
     readavailable,
     readbytes!,
-    readbytes,
     readchomp,
     readcsv,
     readdir,
     readdlm,
     readline,
     readlines,
+    readstring,
     readuntil,
     redirect_stderr,
     redirect_stdin,
@@ -1275,6 +1275,7 @@ export
 # filesystem operations
     cd,
     chmod,
+    chown,
     cp,
     ctime,
     download,
@@ -1313,6 +1314,7 @@ export
     tempname,
     touch,
     uperm,
+    walkdir,
 
 # external processes ## TODO: whittle down these exports.
     detach,
@@ -1340,7 +1342,9 @@ export
     unsafe_copy!,
     unsafe_load,
     unsafe_pointer_to_objref,
+    unsafe_read,
     unsafe_store!,
+    unsafe_write,
 
 # nullable types
     isnull,
@@ -1403,6 +1407,7 @@ export
     @sync,
     @async,
     @task,
+    @threadcall,
 
     # multiprocessing
     @spawn,
@@ -1431,4 +1436,27 @@ export
     @assert,
     @enum,
     @label,
-    @goto
+    @goto,
+
+# SparseArrays module re-exports
+    SparseArrays,
+    AbstractSparseArray,
+    AbstractSparseMatrix,
+    AbstractSparseVector,
+    SparseMatrixCSC,
+    SparseVector,
+    etree,
+    issparse,
+    sparse,
+    sparsevec,
+    spdiagm,
+    speye,
+    spones,
+    sprand,
+    sprandbool,
+    sprandn,
+    spzeros,
+    symperm,
+    rowvals,
+    nzrange,
+    nnz
diff --git a/base/expr.jl b/base/expr.jl
index 9a322edc9c573..bf5f522786726 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -44,18 +44,7 @@ astcopy(x) = x
 
 ==(x::Expr, y::Expr) = x.head === y.head && x.args == y.args
 ==(x::QuoteNode, y::QuoteNode) = x.value == y.value
-
-function show(io::IO, tv::TypeVar)
-    if !is(tv.lb, Bottom)
-        show(io, tv.lb)
-        print(io, "<:")
-    end
-    write(io, tv.name)
-    if !is(tv.ub, Any)
-        print(io, "<:")
-        show(io, tv.ub)
-    end
-end
+==(x::SymbolNode, y::SymbolNode) = x.name === y.name && x.typ === y.typ
 
 expand(x) = ccall(:jl_expand, Any, (Any,), x)
 macroexpand(x) = ccall(:jl_macroexpand, Any, (Any,), x)
@@ -67,18 +56,31 @@ macro eval(x)
 end
 
 macro inline(ex)
-    esc(_inline(ex))
+    esc(isa(ex, Expr) ? pushmeta!(ex, :inline) : ex)
 end
 
-_inline(ex::Expr) = pushmeta!(ex, :inline)
-_inline(arg) = arg
-
 macro noinline(ex)
-    esc(_noinline(ex))
+    esc(isa(ex, Expr) ? pushmeta!(ex, :noinline) : ex)
+end
+
+macro pure(ex)
+    esc(isa(ex, Expr) ? pushmeta!(ex, :pure) : ex)
 end
 
-_noinline(ex::Expr) = pushmeta!(ex, :noinline)
-_noinline(arg) = arg
+"""
+    @propagate_inbounds(ex)
+
+Tells the compiler to inline a function while retaining the caller's inbounds context.
+"""
+macro propagate_inbounds(ex)
+    if isa(ex, Expr)
+        pushmeta!(ex, :inline)
+        pushmeta!(ex, :propagate_inbounds)
+        esc(ex)
+    else
+        esc(ex)
+    end
+end
 
 ## some macro utilities ##
 
@@ -110,11 +112,11 @@ function localize_vars(expr, esca)
     if esca
         v = map(esc,v)
     end
-    Expr(:localize, :(()->($expr)), v...)
+    Expr(:localize, expr, v...)
 end
 
 function pushmeta!(ex::Expr, sym::Symbol, args::Any...)
-    if length(args) == 0
+    if isempty(args)
         tag = sym
     else
         tag = Expr(sym, args...)
@@ -174,3 +176,12 @@ function findmeta_block(ex::Expr)
     end
     return false, Expr(:block)
 end
+
+remove_linenums!(ex) = ex
+function remove_linenums!(ex::Expr)
+    filter!(x->!((isa(x,Expr) && is(x.head,:line)) || isa(x,LineNumberNode)), ex.args)
+    for subex in ex.args
+        remove_linenums!(subex)
+    end
+    ex
+end
diff --git a/base/fastmath.jl b/base/fastmath.jl
index 4f0acb5ff30cc..b0569a0527c16 100644
--- a/base/fastmath.jl
+++ b/base/fastmath.jl
@@ -88,14 +88,17 @@ const rewrite_op =
          :^= => :^)
 
 function make_fastmath(expr::Expr)
+    if expr.head === :quote
+        return expr
+    end
     op = get(rewrite_op, expr.head, :nothing)
-    if op != :nothing
+    if op !== :nothing
         var = expr.args[1]
         rhs = expr.args[2]
         if isa(var, Symbol)
             # simple assignment
-            expr = :($var = $(op)($var, $rhs))
-        elseif isa(var, Expr) && var.head == :ref
+            expr = :($var = $op($var, $rhs))
+        elseif isa(var, Expr) && var.head === :ref
             # array reference
             arr = var.args[1]
             inds = tuple(var.args[2:end]...)
@@ -104,7 +107,7 @@ function make_fastmath(expr::Expr)
             expr = quote
                 $(Expr(:(=), arrvar, arr))
                 $(Expr(:(=), Expr(:tuple, indvars...), Expr(:tuple, inds...)))
-                $(arrvar)[$(indvars...)] = $(op)($(arrvar)[$(indvars...)], $rhs)
+                $arrvar[$(indvars...)] = $op($arrvar[$(indvars...)], $rhs)
             end
         end
     end
@@ -112,10 +115,10 @@ function make_fastmath(expr::Expr)
 end
 function make_fastmath(symb::Symbol)
     fast_symb = get(fast_op, symb, :nothing)
-    if fast_symb == :nothing
+    if fast_symb === :nothing
         return symb
     end
-    :(Base.FastMath.$(fast_symb))
+    :(Base.FastMath.$fast_symb)
 end
 make_fastmath(expr) = expr
 
@@ -125,7 +128,6 @@ end
 
 
 
-
 # Basic arithmetic
 
 FloatTypes = Union{Float32, Float64}
@@ -203,7 +205,7 @@ ComplexTypes = Union{Complex64, Complex128}
     mul_fast{T<:FloatTypes}(a::T, y::Complex{T}) =
         Complex{T}(a*real(y), a*imag(y))
 
-    div_fast{T<:ComplexTypes}(x::T, y::T) =
+    @inline div_fast{T<:ComplexTypes}(x::T, y::T) =
         T(real(x)*real(y) + imag(x)*imag(y),
           imag(x)*real(y) - real(x)*imag(y)) / abs2(y)
     div_fast{T<:FloatTypes}(x::Complex{T}, b::T) =
@@ -250,8 +252,9 @@ end
 
 # builtins
 
-pow_fast{T<:FloatTypes}(x::T, y::Integer) =
-    box(T, Base.powi_llvm(unbox(T,x), unbox(Int32,Int32(y))))
+pow_fast{T<:FloatTypes}(x::T, y::Integer) = pow_fast(x, Int32(y))
+pow_fast{T<:FloatTypes}(x::T, y::Int32) =
+    box(T, Base.powi_llvm(unbox(T,x), unbox(Int32,y)))
 
 # TODO: Change sqrt_llvm intrinsic to avoid nan checking; add nan
 # checking to sqrt in math.jl; remove sqrt_llvm_fast intrinsic
diff --git a/base/fft/FFTW.jl b/base/fft/FFTW.jl
index 694c9eafff451..b560a178720c6 100644
--- a/base/fft/FFTW.jl
+++ b/base/fft/FFTW.jl
@@ -101,16 +101,16 @@ alignment_of(A::FakeArray) = Int32(0)
 # FFTW's api/import-wisdom-from-file.c file].
 
 function export_wisdom(fname::AbstractString)
-    f = ccall(:fopen, Ptr{Void}, (Cstring,Ptr{UInt8}), fname, "w")
+    f = ccall(:fopen, Ptr{Void}, (Cstring,Cstring), fname, :w)
     systemerror("could not open wisdom file $fname for writing", f == C_NULL)
     ccall((:fftw_export_wisdom_to_file,libfftw), Void, (Ptr{Void},), f)
-    ccall(:fputs, Int32, (Ptr{UInt8},Ptr{Void}), " "^256, f)
+    ccall(:fputs, Int32, (Ptr{UInt8},Ptr{Void}), " "^256, f) # no NUL, hence no Cstring
     ccall((:fftwf_export_wisdom_to_file,libfftwf), Void, (Ptr{Void},), f)
     ccall(:fclose, Void, (Ptr{Void},), f)
 end
 
 function import_wisdom(fname::AbstractString)
-    f = ccall(:fopen, Ptr{Void}, (Cstring,Ptr{UInt8}), fname, "r")
+    f = ccall(:fopen, Ptr{Void}, (Cstring,Cstring), fname, :r)
     systemerror("could not open wisdom file $fname for reading", f == C_NULL)
     if ccall((:fftw_import_wisdom_from_file,libfftw),Int32,(Ptr{Void},),f)==0||
        ccall((:fftwf_import_wisdom_from_file,libfftwf),Int32,(Ptr{Void},),f)==0
@@ -430,7 +430,7 @@ function fix_kinds(region, kinds)
         if length(kinds) > length(region)
             throw(ArgumentError("too many transform kinds"))
         else
-            if length(kinds) == 0
+            if isempty(kinds)
                 throw(ArgumentError("must supply a transform kind"))
             end
             k = Array(Int32, length(region))
@@ -454,10 +454,9 @@ end
 for (Tr,Tc,fftw,lib) in ((:Float64,:Complex128,"fftw",libfftw),
                          (:Float32,:Complex64,"fftwf",libfftwf))
 
-    @eval function call{K,inplace,N}(::Type{cFFTWPlan{$Tc,K,inplace,N}},
-                                     X::StridedArray{$Tc,N},
-                                     Y::StridedArray{$Tc,N},
-                                     region, flags::Integer, timelimit::Real)
+    @eval function (::Type{cFFTWPlan{$Tc,K,inplace,N}}){K,inplace,N}(X::StridedArray{$Tc,N},
+                                                                     Y::StridedArray{$Tc,N},
+                                                                     region, flags::Integer, timelimit::Real)
         direction = K
         set_timelimit($Tr, timelimit)
         R = copy(region)
@@ -475,10 +474,9 @@ for (Tr,Tc,fftw,lib) in ((:Float64,:Complex128,"fftw",libfftw),
         return cFFTWPlan{$Tc,K,inplace,N}(plan, flags, R, X, Y)
     end
 
-    @eval function call{inplace,N}(::Type{rFFTWPlan{$Tr,$FORWARD,inplace,N}},
-                                   X::StridedArray{$Tr,N},
-                                   Y::StridedArray{$Tc,N},
-                                   region, flags::Integer, timelimit::Real)
+    @eval function (::Type{rFFTWPlan{$Tr,$FORWARD,inplace,N}}){inplace,N}(X::StridedArray{$Tr,N},
+                                                                          Y::StridedArray{$Tc,N},
+                                                                          region, flags::Integer, timelimit::Real)
         R = copy(region)
         region = circshift([region...],-1) # FFTW halves last dim
         set_timelimit($Tr, timelimit)
@@ -496,10 +494,9 @@ for (Tr,Tc,fftw,lib) in ((:Float64,:Complex128,"fftw",libfftw),
         return rFFTWPlan{$Tr,$FORWARD,inplace,N}(plan, flags, R, X, Y)
     end
 
-    @eval function call{inplace,N}(::Type{rFFTWPlan{$Tc,$BACKWARD,inplace,N}},
-                                   X::StridedArray{$Tc,N},
-                                   Y::StridedArray{$Tr,N},
-                                   region, flags::Integer, timelimit::Real)
+    @eval function (::Type{rFFTWPlan{$Tc,$BACKWARD,inplace,N}}){inplace,N}(X::StridedArray{$Tc,N},
+                                                                           Y::StridedArray{$Tr,N},
+                                                                           region, flags::Integer, timelimit::Real)
         R = copy(region)
         region = circshift([region...],-1) # FFTW halves last dim
         set_timelimit($Tr, timelimit)
@@ -517,11 +514,10 @@ for (Tr,Tc,fftw,lib) in ((:Float64,:Complex128,"fftw",libfftw),
         return rFFTWPlan{$Tc,$BACKWARD,inplace,N}(plan, flags, R, X, Y)
     end
 
-    @eval function call{inplace,N}(::Type{r2rFFTWPlan{$Tr,ANY,inplace,N}},
-                                   X::StridedArray{$Tr,N},
-                                   Y::StridedArray{$Tr,N},
-                                   region, kinds, flags::Integer,
-                                   timelimit::Real)
+    @eval function (::Type{r2rFFTWPlan{$Tr,ANY,inplace,N}}){inplace,N}(X::StridedArray{$Tr,N},
+                                                                       Y::StridedArray{$Tr,N},
+                                                                       region, kinds, flags::Integer,
+                                                                       timelimit::Real)
         R = copy(region)
         knd = fix_kinds(region, kinds)
         set_timelimit($Tr, timelimit)
@@ -540,11 +536,10 @@ for (Tr,Tc,fftw,lib) in ((:Float64,:Complex128,"fftw",libfftw),
     end
 
     # support r2r transforms of complex = transforms of real & imag parts
-    @eval function call{inplace,N}(::Type{r2rFFTWPlan{$Tc,ANY,inplace,N}},
-                                   X::StridedArray{$Tc,N},
-                                   Y::StridedArray{$Tc,N},
-                                   region, kinds, flags::Integer,
-                                   timelimit::Real)
+    @eval function (::Type{r2rFFTWPlan{$Tc,ANY,inplace,N}}){inplace,N}(X::StridedArray{$Tc,N},
+                                                                       Y::StridedArray{$Tc,N},
+                                                                       region, kinds, flags::Integer,
+                                                                       timelimit::Real)
         R = copy(region)
         knd = fix_kinds(region, kinds)
         set_timelimit($Tr, timelimit)
@@ -717,6 +712,25 @@ for (Tr,Tc) in ((:Float32,:Complex64),(:Float64,:Complex128))
     end
 end
 
+"""
+    plan_rfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Pre-plan an optimized real-input FFT, similar to [`plan_fft`](:func:`plan_fft`) except for
+[`rfft`](:func:`rfft`) instead of [`fft`](:func:`fft`). The first two arguments, and the
+size of the transformed result, are the same as for [`rfft`](:func:`rfft`).
+"""
+plan_rfft
+
+"""
+    plan_brfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
+
+Pre-plan an optimized real-input unnormalized transform, similar to
+[`plan_rfft`](:func:`plan_rfft`) except for [`brfft`](:func:`brfft`) instead of
+[`rfft`](:func:`rfft`). The first two arguments and the size of the transformed result, are
+the same as for [`brfft`](:func:`brfft`).
+"""
+plan_brfft
+
 # FFTW r2r transforms (low-level interface)
 
 for f in (:r2r, :r2r!)
@@ -745,6 +759,56 @@ function plan_r2r!{T<:fftwNumber,N}(X::StridedArray{T,N}, kinds, region;
     r2rFFTWPlan{T,ANY,true,N}(X, X, region, kinds, flags, timelimit)
 end
 
+"""
+    r2r(A, kind [, dims])
+
+Performs a multidimensional real-input/real-output (r2r) transform
+of type `kind` of the array `A`, as defined in the FFTW manual.
+`kind` specifies either a discrete cosine transform of various types
+(`FFTW.REDFT00`, `FFTW.REDFT01`, `FFTW.REDFT10`, or
+`FFTW.REDFT11`), a discrete sine transform of various types
+(`FFTW.RODFT00`, `FFTW.RODFT01`, `FFTW.RODFT10`, or
+`FFTW.RODFT11`), a real-input DFT with halfcomplex-format output
+(`FFTW.R2HC` and its inverse `FFTW.HC2R`), or a discrete
+Hartley transform (`FFTW.DHT`).  The `kind` argument may be
+an array or tuple in order to specify different transform types
+along the different dimensions of `A`; `kind[end]` is used
+for any unspecified dimensions.  See the FFTW manual for precise
+definitions of these transform types, at http://www.fftw.org/doc.
+
+The optional `dims` argument specifies an iterable subset of
+dimensions (e.g. an integer, range, tuple, or array) to transform
+along. `kind[i]` is then the transform type for `dims[i]`,
+with `kind[end]` being used for `i > length(kind)`.
+
+See also [`plan_r2r`](:func:`plan_r2r`) to pre-plan optimized r2r transforms.
+"""
+FFTW.r2r
+
+"""
+    r2r!(A, kind [, dims])
+
+Same as [`r2r`](:func:`r2r`), but operates in-place on `A`, which must be
+an array of real or complex floating-point numbers.
+"""
+FFTW.r2r!
+
+"""
+    plan_r2r!(A, kind [, dims [, flags [, timelimit]]])
+
+Similar to [`plan_fft`](:func:`Base.plan_fft`), but corresponds to [`r2r!`](:func:`r2r!`).
+"""
+FFTW.plan_r2r!
+
+"""
+    plan_r2r(A, kind [, dims [, flags [, timelimit]]])
+
+Pre-plan an optimized r2r transform, similar to [`plan_fft`](:func:`Base.plan_fft`)
+except that the transforms (and the first three arguments)
+correspond to [`r2r`](:func:`r2r`) and [`r2r!`](:func:`r2r!`), respectively.
+"""
+FFTW.plan_r2r
+
 # mapping from r2r kind to the corresponding inverse transform
 const inv_kind = Dict{Int,Int}(R2HC => HC2R, HC2R => R2HC, DHT => DHT,
                                REDFT00 => REDFT00,
diff --git a/base/fft/dct.jl b/base/fft/dct.jl
index 53c8f6bb65ee7..487089b4f2698 100644
--- a/base/fft/dct.jl
+++ b/base/fft/dct.jl
@@ -38,6 +38,40 @@ for (pf, pfr, K, inplace) in ((:plan_dct, :plan_r2r, REDFT10, false),
     end
 end
 
+"""
+    plan_dct!(A [, dims [, flags [, timelimit]]])
+
+Same as [`plan_dct`](:func:`plan_dct`), but operates in-place on `A`.
+"""
+plan_dct!
+
+"""
+    plan_idct(A [, dims [, flags [, timelimit]]])
+
+Pre-plan an optimized inverse discrete cosine transform (DCT), similar to
+[`plan_fft`](:func:`plan_fft`) except producing a function that computes
+[`idct`](:func:`idct`). The first two arguments have the same meaning as for
+[`idct`](:func:`idct`).
+"""
+plan_idct
+
+"""
+    plan_dct(A [, dims [, flags [, timelimit]]])
+
+Pre-plan an optimized discrete cosine transform (DCT), similar to
+[`plan_fft`](:func:`plan_fft`) except producing a function that computes
+[`dct`](:func:`dct`). The first two arguments have the same meaning as for
+[`dct`](:func:`dct`).
+"""
+plan_dct
+
+"""
+    plan_idct!(A [, dims [, flags [, timelimit]]])
+
+Same as [`plan_idct`](:func:`plan_idct`), but operates in-place on `A`.
+"""
+plan_idct!
+
 function plan_inv{T,K,inplace}(p::DCTPlan{T,K,inplace})
     X = Array(T, p.plan.sz)
     iK = inv_kind[K]
@@ -59,6 +93,45 @@ for f in (:dct, :dct!, :idct, :idct!)
     end
 end
 
+"""
+    dct(A [, dims])
+
+Performs a multidimensional type-II discrete cosine transform (DCT) of the array `A`, using
+the unitary normalization of the DCT. The optional `dims` argument specifies an iterable
+subset of dimensions (e.g. an integer, range, tuple, or array) to transform along.  Most
+efficient if the size of `A` along the transformed dimensions is a product of small primes;
+see [`nextprod`](:func:`nextprod`). See also [`plan_dct`](:func:`plan_dct`) for even greater
+efficiency.
+"""
+dct
+
+"""
+    idct(A [, dims])
+
+Computes the multidimensional inverse discrete cosine transform (DCT) of the array `A`
+(technically, a type-III DCT with the unitary normalization). The optional `dims` argument
+specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to
+transform along.  Most efficient if the size of `A` along the transformed dimensions is a
+product of small primes; see [`nextprod`](:func:`nextprod`).  See also
+[`plan_idct`](:func:`plan_idct`) for even greater efficiency.
+"""
+idct
+
+"""
+    dct!(A [, dims])
+
+Same as [`dct!`](:func:`dct!`), except that it operates in-place on `A`, which must be an
+array of real or complex floating-point values.
+"""
+dct!
+
+"""
+    idct!(A [, dims])
+
+Same as [`idct!`](:func:`idct!`), but operates in-place on `A`.
+"""
+idct!
+
 const sqrthalf = sqrt(0.5)
 const sqrt2 = sqrt(2.0)
 const onerange = 1:1
diff --git a/base/file.jl b/base/file.jl
index 94f753d8b93d8..5663477661612 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -1,5 +1,31 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+# Operations with the file system (paths) ##
+
+export
+    cd,
+    chmod,
+    chown,
+    cp,
+    cptree,
+    mkdir,
+    mkpath,
+    mktemp,
+    mktempdir,
+    mv,
+    pwd,
+    rename,
+    readlink,
+    readdir,
+    rm,
+    samefile,
+    sendfile,
+    symlink,
+    tempdir,
+    tempname,
+    touch,
+    walkdir
+
 # get and set current directory
 
 function pwd()
@@ -15,7 +41,7 @@ end
 cd() = cd(homedir())
 
 @unix_only function cd(f::Function, dir::AbstractString)
-    fd = ccall(:open,Int32,(Ptr{UInt8},Int32),".",0)
+    fd = ccall(:open,Int32,(Cstring,Int32),:.,0)
     systemerror(:open, fd == -1)
     try
         cd(dir)
@@ -39,7 +65,7 @@ cd(f::Function) = cd(f, homedir())
 function mkdir(path::AbstractString, mode::Unsigned=0o777)
     @unix_only ret = ccall(:mkdir, Int32, (Cstring,UInt32), path, mode)
     @windows_only ret = ccall(:_wmkdir, Int32, (Cwstring,), path)
-    systemerror(:mkdir, ret != 0)
+    systemerror(:mkdir, ret != 0; extrainfo=path)
 end
 
 function mkpath(path::AbstractString, mode::Unsigned=0o777)
@@ -47,25 +73,42 @@ function mkpath(path::AbstractString, mode::Unsigned=0o777)
     dir = dirname(path)
     (path == dir || isdir(path)) && return
     mkpath(dir, mode)
-    mkdir(path, mode)
+    try
+        mkdir(path, mode)
+    # If there is a problem with making the directory, but the directory
+    # does in fact exist, then ignore the error. Else re-throw it.
+    catch err
+        if isa(err, SystemError) && isdir(path)
+            return
+        else
+            rethrow()
+        end
+    end
 end
 
 mkdir(path::AbstractString, mode::Signed) = throw(ArgumentError("mode must be an unsigned integer; try 0o$mode"))
 mkpath(path::AbstractString, mode::Signed) = throw(ArgumentError("mode must be an unsigned integer; try 0o$mode"))
 
-function rm(path::AbstractString; recursive::Bool=false)
+function rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
     if islink(path) || !isdir(path)
-        @windows_only if !iswritable(path); chmod(path, 0o777); end
-        FS.unlink(path)
+        try
+            @windows_only if (filemode(path) & 0o222) == 0; chmod(path, 0o777); end # is writable on windows actually means "is deletable"
+            unlink(path)
+        catch err
+            if force && isa(err, UVError) && err.code==Base.UV_ENOENT
+                return
+            end
+            rethrow()
+        end
     else
         if recursive
             for p in readdir(path)
-                rm(joinpath(path, p), recursive=true)
+                rm(joinpath(path, p), force=force, recursive=true)
             end
         end
         @unix_only ret = ccall(:rmdir, Int32, (Cstring,), path)
         @windows_only ret = ccall(:_wrmdir, Int32, (Cwstring,), path)
-        systemerror(:rmdir, ret != 0)
+        systemerror(:rmdir, ret != 0, extrainfo=path)
     end
 end
 
@@ -106,7 +149,7 @@ function cptree(src::AbstractString, dst::AbstractString; remove_destination::Bo
             cptree(srcname, joinpath(dst, name); remove_destination=remove_destination,
                                                  follow_symlinks=follow_symlinks)
         else
-            FS.sendfile(srcname, joinpath(dst, name))
+            sendfile(srcname, joinpath(dst, name))
         end
     end
 end
@@ -119,23 +162,22 @@ function cp(src::AbstractString, dst::AbstractString; remove_destination::Bool=f
     elseif isdir(src)
         cptree(src, dst; remove_destination=remove_destination, follow_symlinks=follow_symlinks)
     else
-        FS.sendfile(src, dst)
+        sendfile(src, dst)
     end
 end
 
 function mv(src::AbstractString, dst::AbstractString; remove_destination::Bool=false)
     checkfor_mv_cp_cptree(src, dst, "moving"; remove_destination=remove_destination)
-    FS.rename(src, dst)
+    rename(src, dst)
 end
 
 function touch(path::AbstractString)
-    f = FS.open(path,JL_O_WRONLY | JL_O_CREAT, 0o0666)
-    @assert f.handle >= 0
+    f = open(path, JL_O_WRONLY | JL_O_CREAT, 0o0666)
     try
         t = time()
         futime(f,t,t)
     finally
-        FS.close(f)
+        close(f)
     end
 end
 
@@ -143,7 +185,7 @@ end
 # Obtain a temporary filename.
 function tempname()
     d = get(ENV, "TMPDIR", C_NULL) # tempnam ignores TMPDIR on darwin
-    p = ccall(:tempnam, Ptr{UInt8}, (Ptr{UInt8},Ptr{UInt8}), d, "julia")
+    p = ccall(:tempnam, Cstring, (Cstring,Cstring), d, :julia)
     systemerror(:tempnam, p == C_NULL)
     s = bytestring(p)
     Libc.free(p)
@@ -156,7 +198,7 @@ tempdir() = dirname(tempname())
 # Create and return the name of a temporary file along with an IOStream
 function mktemp(parent=tempdir())
     b = joinpath(parent, "tmpXXXXXX")
-    p = ccall(:mkstemp, Int32, (Ptr{UInt8},), b) # modifies b
+    p = ccall(:mkstemp, Int32, (Cstring,), b) # modifies b
     systemerror(:mktemp, p == -1)
     return (b, fdio(p, true))
 end
@@ -164,7 +206,7 @@ end
 # Create and return the name of a temporary directory
 function mktempdir(parent=tempdir())
     b = joinpath(parent, "tmpXXXXXX")
-    p = ccall(:mkdtemp, Ptr{UInt8}, (Ptr{UInt8},), b)
+    p = ccall(:mkdtemp, Cstring, (Cstring,), b)
     systemerror(:mktempdir, p == C_NULL)
     return bytestring(p)
 end
@@ -177,23 +219,25 @@ function tempdir()
     if lentemppath >= length(temppath) || lentemppath == 0
         error("GetTempPath failed: $(Libc.FormatMessage())")
     end
-    resize!(temppath,lentemppath+1)
-    return utf8(UTF16String(temppath))
+    resize!(temppath,lentemppath)
+    return UTF8String(utf16to8(temppath))
 end
 tempname(uunique::UInt32=UInt32(0)) = tempname(tempdir(), uunique)
+const temp_prefix = cwstring("jl_")
 function tempname(temppath::AbstractString,uunique::UInt32)
+    tempp = cwstring(temppath)
     tname = Array(UInt16,32767)
-    uunique = ccall(:GetTempFileNameW,stdcall,UInt32,(Cwstring,Ptr{UInt16},UInt32,Ptr{UInt16}), temppath,utf16("jul"),uunique,tname)
+    uunique = ccall(:GetTempFileNameW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32,Ptr{UInt16}), tempp,temp_prefix,uunique,tname)
     lentname = findfirst(tname,0)-1
     if uunique == 0 || lentname <= 0
         error("GetTempFileName failed: $(Libc.FormatMessage())")
     end
-    resize!(tname,lentname+1)
-    return utf8(UTF16String(tname))
+    resize!(tname,lentname)
+    return UTF8String(utf16to8(tname))
 end
 function mktemp(parent=tempdir())
     filename = tempname(parent, UInt32(0))
-    return (filename, open(filename,"r+"))
+    return (filename, Base.open(filename, "r+"))
 end
 function mktempdir(parent=tempdir())
     seed::UInt32 = rand(UInt32)
@@ -202,7 +246,7 @@ function mktempdir(parent=tempdir())
             seed += 1
         end
         filename = tempname(parent, seed)
-        ret = ccall(:_wmkdir, Int32, (Ptr{UInt16},), utf16(filename))
+        ret = ccall(:_wmkdir, Int32, (Ptr{UInt16},), cwstring(filename))
         if ret == 0
             return filename
         end
@@ -247,7 +291,7 @@ function readdir(path::AbstractString)
     offset = 0
 
     for i = 1:file_count
-        entry = bytestring(ccall(:jl_uv_fs_t_ptr_offset, Ptr{UInt8},
+        entry = bytestring(ccall(:jl_uv_fs_t_ptr_offset, Cstring,
                                  (Ptr{UInt8}, Int32), uv_readdir_req, offset))
         push!(entries, entry)
         offset += sizeof(entry) + 1   # offset to the next entry
@@ -260,3 +304,156 @@ function readdir(path::AbstractString)
 end
 
 readdir() = readdir(".")
+
+"""
+    walkdir(dir; topdown=true, follow_symlinks=false, onerror=throw)
+
+The walkdir method return an iterator that walks the directory tree of a directory. The iterator returns a tuple containing
+`(rootpath, dirs, files)`. The directory tree can be traversed top-down or bottom-up. If walkdir encounters a SystemError
+it will raise the error. A custom error handling function can be provided through `onerror` keyword argument, the function
+is called with a SystemError as argument.
+
+    for (root, dirs, files) in walkdir(".")
+        println("Directories in \$root")
+        for dir in dirs
+            println(joinpath(root, dir)) # path to directories
+        end
+        println("Files in \$root")
+        for file in files
+            println(joinpath(root, file)) # path to files
+        end
+    end
+
+"""
+function walkdir(root; topdown=true, follow_symlinks=false, onerror=throw)
+    content = nothing
+    try
+        content = readdir(root)
+    catch err
+        isa(err, SystemError) || throw(err)
+        onerror(err)
+        #Need to return an empty task to skip the current root folder
+        return Task(()->())
+    end
+    dirs = Array(eltype(content), 0)
+    files = Array(eltype(content), 0)
+    for name in content
+        if isdir(joinpath(root, name))
+            push!(dirs, name)
+        else
+            push!(files, name)
+        end
+    end
+
+    function _it()
+        if topdown
+            produce(root, dirs, files)
+        end
+        for dir in dirs
+            path = joinpath(root,dir)
+            if follow_symlinks || !islink(path)
+                for (root_l, dirs_l, files_l) in walkdir(path, topdown=topdown, follow_symlinks=follow_symlinks, onerror=onerror)
+                    produce(root_l, dirs_l, files_l)
+                end
+            end
+        end
+        if !topdown
+            produce(root, dirs, files)
+        end
+    end
+    Task(_it)
+end
+
+function unlink(p::AbstractString)
+    err = ccall(:jl_fs_unlink, Int32, (Cstring,), p)
+    uv_error("unlink", err)
+    nothing
+end
+
+# For move command
+function rename(src::AbstractString, dst::AbstractString)
+    err = ccall(:jl_fs_rename, Int32, (Cstring, Cstring), src, dst)
+    # on error, default to cp && rm
+    if err < 0
+        # remove_destination: is already done in the mv function
+        cp(src, dst; remove_destination=false, follow_symlinks=false)
+        rm(src; recursive=true)
+    end
+    nothing
+end
+
+function sendfile(src::AbstractString, dst::AbstractString)
+    local src_open = false,
+          dst_open = false,
+          src_file,
+          dst_file
+    try
+        src_file = open(src, JL_O_RDONLY)
+        src_open = true
+        dst_file = open(dst, JL_O_CREAT | JL_O_TRUNC | JL_O_WRONLY,
+             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH)
+        dst_open = true
+
+        bytes = filesize(stat(src_file))
+        sendfile(dst_file, src_file, Int64(0), Int(bytes))
+    finally
+        if src_open && isopen(src_file)
+            close(src_file)
+        end
+        if dst_open && isopen(dst_file)
+            close(dst_file)
+        end
+    end
+end
+
+@windows_only const UV_FS_SYMLINK_JUNCTION = 0x0002
+function symlink(p::AbstractString, np::AbstractString)
+    @windows_only if Base.windows_version() < Base.WINDOWS_VISTA_VER
+        error("Windows XP does not support soft symlinks")
+    end
+    flags = 0
+    @windows_only if isdir(p); flags |= UV_FS_SYMLINK_JUNCTION; p = abspath(p); end
+    err = ccall(:jl_fs_symlink, Int32, (Cstring, Cstring, Cint), p, np, flags)
+    @windows_only if err < 0 && !isdir(p)
+        Base.warn_once("Note: on Windows, creating file symlinks requires Administrator privileges.")
+    end
+    uv_error("symlink",err)
+end
+
+function readlink(path::AbstractString)
+    req = Libc.malloc(_sizeof_uv_fs)
+    try
+        ret = ccall(:uv_fs_readlink, Int32,
+            (Ptr{Void}, Ptr{Void}, Cstring, Ptr{Void}),
+            eventloop(), req, path, C_NULL)
+        if ret < 0
+            ccall(:uv_fs_req_cleanup, Void, (Ptr{Void}, ), req)
+            uv_error("readlink", ret)
+            assert(false)
+        end
+        tgt = bytestring(ccall(:jl_uv_fs_t_ptr, Ptr{Cchar}, (Ptr{Void}, ), req))
+        ccall(:uv_fs_req_cleanup, Void, (Ptr{Void}, ), req)
+        return tgt
+    finally
+        Libc.free(req)
+    end
+end
+
+function chmod(path::AbstractString, mode::Integer; recursive::Bool=false)
+    err = ccall(:jl_fs_chmod, Int32, (Cstring, Cint), path, mode)
+    uv_error("chmod", err)
+    if recursive && isdir(path)
+        for p in readdir(path)
+            if !islink(joinpath(path, p))
+                chmod(joinpath(path, p), mode, recursive=true)
+            end
+        end
+    end
+    nothing
+end
+
+function chown(path::AbstractString, owner::Integer, group::Integer=-1)
+    err = ccall(:jl_fs_chown, Int32, (Cstring, Cint, Cint), path, owner, group)
+    uv_error("chown",err)
+    nothing
+end
diff --git a/base/filesystem.jl b/base/filesystem.jl
new file mode 100644
index 0000000000000..0749b4b29205e
--- /dev/null
+++ b/base/filesystem.jl
@@ -0,0 +1,210 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+## File Operations (Libuv-based) ##
+
+module Filesystem
+
+const S_IRUSR = 0o400
+const S_IWUSR = 0o200
+const S_IXUSR = 0o100
+const S_IRWXU = 0o700
+const S_IRGRP = 0o040
+const S_IWGRP = 0o020
+const S_IXGRP = 0o010
+const S_IRWXG = 0o070
+const S_IROTH = 0o004
+const S_IWOTH = 0o002
+const S_IXOTH = 0o001
+const S_IRWXO = 0o007
+
+export File,
+       StatStruct,
+       # open,
+       futime,
+       unlink,
+       write,
+       JL_O_WRONLY,
+       JL_O_RDONLY,
+       JL_O_RDWR,
+       JL_O_APPEND,
+       JL_O_CREAT,
+       JL_O_EXCL,
+       JL_O_TRUNC,
+       JL_O_TEMPORARY,
+       JL_O_SHORT_LIVED,
+       JL_O_SEQUENTIAL,
+       JL_O_RANDOM,
+       JL_O_NOCTTY,
+       S_IRUSR, S_IWUSR, S_IXUSR, S_IRWXU,
+       S_IRGRP, S_IWGRP, S_IXGRP, S_IRWXG,
+       S_IROTH, S_IWOTH, S_IXOTH, S_IRWXO
+
+import Base:
+    UVError, _sizeof_uv_fs, check_open, close, eof, eventloop, fd, isopen,
+    nb_available, position, read, read!, readavailable, seek, seekend, show,
+    skip, stat, unsafe_read, unsafe_write, utf16to8, utf8to16, uv_error,
+    uvhandle, uvtype, write
+
+@windows_only import Base: cwstring
+
+include("path.jl")
+include("stat.jl")
+include("file.jl")
+include("poll.jl")
+include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","file_constants.jl"))  # include($BUILDROOT/base/file_constants.jl)
+
+## Operations with File (fd) objects ##
+
+abstract AbstractFile <: IO
+
+type File <: AbstractFile
+    open::Bool
+    handle::RawFD
+    File(fd::RawFD) = new(true, fd)
+end
+
+# Not actually a pointer, but that's how we pass it through the C API so it's fine
+uvhandle(file::File) = convert(Ptr{Void}, Base.cconvert(Cint, file.handle) % UInt)
+uvtype(::File) = Base.UV_RAW_FD
+
+function open(path::AbstractString, flags::Integer, mode::Integer=0) # FS.open, not Base.open
+    req = Libc.malloc(_sizeof_uv_fs)
+    local handle
+    try
+        ret = ccall(:uv_fs_open, Int32,
+                    (Ptr{Void}, Ptr{Void}, Cstring, Int32, Int32, Ptr{Void}),
+                    eventloop(), req, path, flags, mode, C_NULL)
+        handle = ccall(:jl_uv_fs_result, Int32, (Ptr{Void},), req)
+        ccall(:uv_fs_req_cleanup, Void, (Ptr{Void},), req)
+        uv_error("open", ret)
+    finally # conversion to Cstring could cause an exception
+        Libc.free(req)
+    end
+    return File(RawFD(handle))
+end
+
+isopen(f::File) = f.open
+function check_open(f::File)
+    if !isopen(f)
+        throw(ArgumentError("file is closed"))
+    end
+end
+
+function close(f::File)
+    check_open(f)
+    err = ccall(:jl_fs_close, Int32, (Int32,), f.handle)
+    uv_error("close", err)
+    f.handle = RawFD(-1)
+    f.open = false
+    return f
+end
+
+# sendfile is the most efficient way to copy a file (or any file descriptor)
+function sendfile(dst::File, src::File, src_offset::Int64, bytes::Int)
+    check_open(dst)
+    check_open(src)
+    err = ccall(:jl_fs_sendfile, Int32, (Int32, Int32, Int64, Csize_t),
+                src.handle, dst.handle, src_offset, bytes)
+    uv_error("sendfile", err)
+    nothing
+end
+
+function unsafe_write(f::File, buf::Ptr{UInt8}, len::UInt, offset::Int64=Int64(-1))
+    check_open(f)
+    err = ccall(:jl_fs_write, Int32, (Int32, Ptr{UInt8}, Csize_t, Int64),
+                f.handle, buf, len, offset)
+    uv_error("write", err)
+    return len
+end
+
+write(f::File, c::UInt8) = write(f, Ref{UInt8}(c))
+
+function truncate(f::File, n::Integer)
+    check_open(f)
+    req = Libc.malloc(_sizeof_uv_fs)
+    err = ccall(:uv_fs_ftruncate, Int32,
+                (Ptr{Void}, Ptr{Void}, Int32, Int64, Ptr{Void}),
+                eventloop(), req, f.handle, n, C_NULL)
+    Libc.free(req)
+    uv_error("ftruncate", err)
+    return f
+end
+
+function futime(f::File, atime::Float64, mtime::Float64)
+    check_open(f)
+    req = Libc.malloc(_sizeof_uv_fs)
+    err = ccall(:uv_fs_futime, Int32,
+                (Ptr{Void}, Ptr{Void}, Int32, Float64, Float64, Ptr{Void}),
+                eventloop(), req, f.handle, atime, mtime, C_NULL)
+    Libc.free(req)
+    uv_error("futime", err)
+    return f
+end
+
+function read(f::File, ::Type{UInt8})
+    check_open(f)
+    ret = ccall(:jl_fs_read_byte, Int32, (Int32,), f.handle)
+    uv_error("read", ret)
+    return ret % UInt8
+end
+
+function unsafe_read(f::File, p::Ptr{UInt8}, nel::UInt)
+    check_open(f)
+    ret = ccall(:jl_fs_read, Int32, (Int32, Ptr{Void}, Csize_t),
+                f.handle, p, nel)
+    uv_error("read",ret)
+    ret == nel || throw(EOFError())
+    nothing
+end
+
+nb_available(f::File) = max(0, filesize(f) - position(f)) # position can be > filesize
+
+eof(f::File) = nb_available(f) == 0
+
+function readbytes!(f::File, b::Array{UInt8}, nb=length(b))
+    nr = min(nb, nb_available(f))
+    if length(b) < nr
+        resize!(b, nr)
+    end
+    ret = ccall(:jl_fs_read, Int32, (Int32, Ptr{Void}, Csize_t),
+                f.handle, b, nr)
+    uv_error("read",ret)
+    return ret
+end
+read(io::File) = read!(io, Array(UInt8, nb_available(io)))
+readavailable(io::File) = read(io)
+read(io::File, nb::Integer) = read!(io, Array(UInt8, min(nb, nb_available(io))))
+
+const SEEK_SET = Int32(0)
+const SEEK_CUR = Int32(1)
+const SEEK_END = Int32(2)
+
+function seek(f::File, n::Integer)
+    ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, n, SEEK_SET)
+    systemerror("seek", ret == -1)
+    return f
+end
+
+function seekend(f::File)
+    ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, 0, SEEK_END)
+    systemerror("seekend", ret == -1)
+    return f
+end
+
+function skip(f::File, n::Integer)
+    ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, n, SEEK_CUR)
+    systemerror("skip", ret == -1)
+    return f
+end
+
+function position(f::File)
+    check_open(f)
+    ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, 0, SEEK_CUR)
+    systemerror("lseek", ret == -1)
+    return ret
+end
+
+fd(f::File) = f.handle
+stat(f::File) = stat(f.handle)
+
+end
diff --git a/base/float.jl b/base/float.jl
index 8f681755f0645..eacecf7def9cc 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -120,6 +120,10 @@ convert(::Type{AbstractFloat}, x::UInt128) = convert(Float64, x) # LOSSY
 
 float(x) = convert(AbstractFloat, x)
 
+# for constructing arrays
+float{T<:Number}(::Type{T}) = typeof(float(zero(T)))
+float{T}(::Type{T}) = Any
+
 for Ti in (Int8, Int16, Int32, Int64)
     @eval begin
         unsafe_trunc(::Type{$Ti}, x::Float32) = box($Ti,fptosi($Ti,unbox(Float32,x)))
@@ -261,12 +265,25 @@ function cmp(x::AbstractFloat, y::Real)
     ifelse(x<y, -1, ifelse(x>y, 1, 0))
 end
 
+# Exact Float (Tf) vs Integer (Ti) comparisons
+# Assumes:
+# - typemax(Ti) == 2^n-1
+# - typemax(Ti) can't be exactly represented by Tf:
+#   => Tf(typemax(Ti)) == 2^n or Inf
+# - typemin(Ti) can be exactly represented by Tf
+#
+# 1. convert y::Ti to float fy::Tf
+# 2. perform Tf comparison x vs fy
+# 3. if x == fy, check if (1) resulted in rounding:
+#  a. convert fy back to Ti and compare with original y
+#  b. unsafe_convert undefined behaviour if fy == Tf(typemax(Ti))
+#     (but consequently x == fy > y)
 for Ti in (Int64,UInt64,Int128,UInt128)
     for Tf in (Float32,Float64)
         @eval begin
             function ==(x::$Tf, y::$Ti)
                 fy = ($Tf)(y)
-                (x == fy) & (y == unsafe_trunc($Ti,fy))
+                (x == fy) & (fy != $(Tf(typemax(Ti)))) & (y == unsafe_trunc($Ti,fy))
             end
             ==(y::$Ti, x::$Tf) = x==y
 
@@ -399,36 +416,6 @@ end
     eps() = eps(Float64)
 end
 
-# fused multiply-add
-fma_libm(x::Float32, y::Float32, z::Float32) =
-    ccall(("fmaf", libm_name), Float32, (Float32,Float32,Float32), x, y, z)
-fma_libm(x::Float64, y::Float64, z::Float64) =
-    ccall(("fma", libm_name), Float64, (Float64,Float64,Float64), x, y, z)
-fma_llvm(x::Float32, y::Float32, z::Float32) =
-    box(Float32,fma_float(unbox(Float32,x),unbox(Float32,y),unbox(Float32,z)))
-fma_llvm(x::Float64, y::Float64, z::Float64) =
-    box(Float64,fma_float(unbox(Float64,x),unbox(Float64,y),unbox(Float64,z)))
-# Disable LLVM's fma if it is incorrect, e.g. because LLVM falls back
-# onto a broken system libm; if so, use openlibm's fma instead
-# 1.0000305f0 = 1 + 1/2^15
-# 1.0000000009313226 = 1 + 1/2^30
-# If fma_llvm() clobbers the rounding mode, the result of 0.1 + 0.2 will be 0.3
-# instead of the properly-rounded 0.30000000000000004; check after calling fma
-if (fma_llvm(1.0000305f0, 1.0000305f0, -1.0f0) == 6.103609f-5 &&
-    (fma_llvm(1.0000000009313226, 1.0000000009313226, -1.0) ==
-     1.8626451500983188e-9) && 0.1 + 0.2 == 0.30000000000000004)
-    fma(x::Float32, y::Float32, z::Float32) = fma_llvm(x,y,z)
-    fma(x::Float64, y::Float64, z::Float64) = fma_llvm(x,y,z)
-else
-    fma(x::Float32, y::Float32, z::Float32) = fma_libm(x,y,z)
-    fma(x::Float64, y::Float64, z::Float64) = fma_libm(x,y,z)
-end
-# This is necessary at least on 32-bit Intel Linux, since fma_llvm may
-# have called glibc, and some broken glibc fma implementations don't
-# properly restore the rounding mode
-Rounding.set_rounding_raw(Float32, Rounding.JL_FE_TONEAREST)
-Rounding.set_rounding_raw(Float64, Rounding.JL_FE_TONEAREST)
-
 ## byte order swaps for arbitrary-endianness serialization/deserialization ##
 bswap(x::Float32) = box(Float32,bswap_int(unbox(Float32,x)))
 bswap(x::Float64) = box(Float64,bswap_int(unbox(Float64,x)))
diff --git a/base/float16.jl b/base/float16.jl
index 2be38b7a7582f..aaef436e2aa84 100644
--- a/base/float16.jl
+++ b/base/float16.jl
@@ -145,7 +145,7 @@ for op in (:<,:<=,:isless)
     @eval ($op)(a::Float16, b::Float16) = ($op)(Float32(a), Float32(b))
 end
 for func in (:sin,:cos,:tan,:asin,:acos,:atan,:sinh,:cosh,:tanh,:asinh,:acosh,
-             :atanh,:exp,:log,:log2,:log10,:sqrt,:lgamma,:log1p)
+             :atanh,:exp,:log,:log2,:log10,:sqrt,:lgamma,:log1p,:erf,:erfc)
     @eval begin
         $func(a::Float16) = Float16($func(Float32(a)))
         $func(a::Complex32) = Complex32($func(Complex64(a)))
diff --git a/base/floatfuncs.jl b/base/floatfuncs.jl
index f3442335f604b..941318da37b6f 100644
--- a/base/floatfuncs.jl
+++ b/base/floatfuncs.jl
@@ -24,7 +24,7 @@ maxintfloat(::Type{Float16}) = Float16(2048f0)
 maxintfloat{T<:AbstractFloat}(x::T)  = maxintfloat(T)
 maxintfloat() = maxintfloat(Float64)
 
-isinteger(x::AbstractFloat) = (trunc(x)==x)&isfinite(x)
+isinteger(x::AbstractFloat) = x-trunc(x) == 0
 
 num2hex(x::Float16) = hex(reinterpret(UInt16,x), 4)
 num2hex(x::Float32) = hex(box(UInt32,unbox(Float32,x)),8)
@@ -176,4 +176,34 @@ const ≈ = isapprox
 # default tolerance arguments
 rtoldefault{T<:AbstractFloat}(::Type{T}) = sqrt(eps(T))
 rtoldefault{T<:Real}(::Type{T}) = 0
-rtoldefault{T<:Number,S<:Number}(x::Union{T,Type{T}}, y::Union{S,Type{S}}) = rtoldefault(promote_type(real(T),real(S)))
+rtoldefault{T<:Number,S<:Number}(x::Union{T,Type{T}}, y::Union{S,Type{S}}) = max(rtoldefault(real(T)),rtoldefault(real(S)))
+
+# fused multiply-add
+fma_libm(x::Float32, y::Float32, z::Float32) =
+    ccall(("fmaf", libm_name), Float32, (Float32,Float32,Float32), x, y, z)
+fma_libm(x::Float64, y::Float64, z::Float64) =
+    ccall(("fma", libm_name), Float64, (Float64,Float64,Float64), x, y, z)
+fma_llvm(x::Float32, y::Float32, z::Float32) =
+    box(Float32,fma_float(unbox(Float32,x),unbox(Float32,y),unbox(Float32,z)))
+fma_llvm(x::Float64, y::Float64, z::Float64) =
+    box(Float64,fma_float(unbox(Float64,x),unbox(Float64,y),unbox(Float64,z)))
+# Disable LLVM's fma if it is incorrect, e.g. because LLVM falls back
+# onto a broken system libm; if so, use openlibm's fma instead
+# 1.0000305f0 = 1 + 1/2^15
+# 1.0000000009313226 = 1 + 1/2^30
+# If fma_llvm() clobbers the rounding mode, the result of 0.1 + 0.2 will be 0.3
+# instead of the properly-rounded 0.30000000000000004; check after calling fma
+if (ARCH != :i686 && fma_llvm(1.0000305f0, 1.0000305f0, -1.0f0) == 6.103609f-5 &&
+    (fma_llvm(1.0000000009313226, 1.0000000009313226, -1.0) ==
+     1.8626451500983188e-9) && 0.1 + 0.2 == 0.30000000000000004)
+    fma(x::Float32, y::Float32, z::Float32) = fma_llvm(x,y,z)
+    fma(x::Float64, y::Float64, z::Float64) = fma_llvm(x,y,z)
+else
+    fma(x::Float32, y::Float32, z::Float32) = fma_libm(x,y,z)
+    fma(x::Float64, y::Float64, z::Float64) = fma_libm(x,y,z)
+end
+# This is necessary at least on 32-bit Intel Linux, since fma_llvm may
+# have called glibc, and some broken glibc fma implementations don't
+# properly restore the rounding mode
+Rounding.setrounding_raw(Float32, Rounding.JL_FE_TONEAREST)
+Rounding.setrounding_raw(Float64, Rounding.JL_FE_TONEAREST)
diff --git a/base/fs.jl b/base/fs.jl
deleted file mode 100644
index db991a47a9206..0000000000000
--- a/base/fs.jl
+++ /dev/null
@@ -1,281 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-## UV based file operations ##
-
-module FS
-
-const S_IRUSR = 0o400
-const S_IWUSR = 0o200
-const S_IXUSR = 0o100
-const S_IRWXU = 0o700
-const S_IRGRP = 0o040
-const S_IWGRP = 0o020
-const S_IXGRP = 0o010
-const S_IRWXG = 0o070
-const S_IROTH = 0o004
-const S_IWOTH = 0o002
-const S_IXOTH = 0o001
-const S_IRWXO = 0o007
-
-export File,
-       # open,
-       # close,
-       write,
-       unlink,
-       rename,
-       sendfile,
-       symlink,
-       readlink,
-       chmod,
-       futime,
-       JL_O_WRONLY,
-       JL_O_RDONLY,
-       JL_O_RDWR,
-       JL_O_APPEND,
-       JL_O_CREAT,
-       JL_O_EXCL,
-       JL_O_TRUNC,
-       JL_O_TEMPORARY,
-       JL_O_SHORT_LIVED,
-       JL_O_SEQUENTIAL,
-       JL_O_RANDOM,
-       JL_O_NOCTTY,
-       S_IRUSR, S_IWUSR, S_IXUSR, S_IRWXU,
-       S_IRGRP, S_IWGRP, S_IXGRP, S_IRWXG,
-       S_IROTH, S_IWOTH, S_IXOTH, S_IRWXO
-
-import Base: uvtype, uvhandle, eventloop, fd, position, stat, close, write, read, read!, readbytes, isopen,
-            _sizeof_uv_fs, uv_error
-
-include("file_constants.jl")
-
-abstract AbstractFile <: IO
-
-type File <: AbstractFile
-    path::AbstractString
-    open::Bool
-    handle::Int32
-    File(path::AbstractString) = new(path,false,-1)
-    File(fd::RawFD) = new("",true,fd.fd)
-end
-
-type AsyncFile <: AbstractFile
-    path::AbstractString
-    open::Bool
-end
-
-isopen(f::Union{File,AsyncFile}) = f.open
-
-# Not actually a pointer, but that's how we pass it through the C API so it's fine
-uvhandle(file::File) = convert(Ptr{Void}, file.handle % UInt)
-uvtype(::File) = Base.UV_RAW_FD
-
-_uv_fs_result(req) = ccall(:jl_uv_fs_result,Int32,(Ptr{Void},),req)
-
-function open(f::File,flags::Integer,mode::Integer=0)
-    req = Libc.malloc(_sizeof_uv_fs)
-    ret = ccall(:uv_fs_open,Int32,(Ptr{Void},Ptr{Void},Cstring,Int32,Int32,Ptr{Void}),
-                eventloop(), req, f.path, flags,mode, C_NULL)
-    f.handle = _uv_fs_result(req)
-    ccall(:uv_fs_req_cleanup,Void,(Ptr{Void},),req)
-    Libc.free(req)
-    uv_error("open",ret)
-    f.open = true
-    f
-end
-open(f::AbstractString,flags,mode) = open(File(f),flags,mode)
-open(f::AbstractString,flags) = open(f,flags,0)
-
-function close(f::File)
-    if !f.open
-        throw(ArgumentError("file \"$(f.path)\" is already closed"))
-    end
-    err = ccall(:jl_fs_close, Int32, (Int32,), f.handle)
-    uv_error("close",err)
-    f.handle = -1
-    f.open = false
-    f
-end
-
-function unlink(p::AbstractString)
-    err = ccall(:jl_fs_unlink, Int32, (Cstring,), p)
-    uv_error("unlink",err)
-end
-function unlink(f::File)
-    if isempty(f.path)
-      throw(ArgumentError("no path associated with this file"))
-    end
-    if f.open
-        close(f)
-    end
-    unlink(f.path)
-    f
-end
-
-# For move command
-function rename(src::AbstractString, dst::AbstractString)
-    err = ccall(:jl_fs_rename, Int32, (Cstring, Cstring), src, dst)
-    # on error, default to cp && rm
-    if err < 0
-        # remove_destination: is already done in the mv function
-        cp(src, dst; remove_destination=false, follow_symlinks=false)
-        rm(src; recursive=true)
-    end
-end
-
-# For copy command
-function sendfile(src::AbstractString, dst::AbstractString)
-    src_file = File(src)
-    dst_file = File(dst)
-    try
-        open(src_file, JL_O_RDONLY)
-        if !src_file.open
-            throw(ArgumentError("source file \"$(src.path)\" is not open"))
-        end
-
-        open(dst_file, JL_O_CREAT | JL_O_TRUNC | JL_O_WRONLY,
-             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH)
-        if !dst_file.open
-            throw(ArgumentError("destination file \"$(dst.path)\" is not open"))
-        end
-
-        src_stat = stat(src_file)
-        err = ccall(:jl_fs_sendfile, Int32, (Int32, Int32, Int64, Csize_t),
-                    fd(src_file), fd(dst_file), 0, src_stat.size)
-        uv_error("sendfile", err)
-    finally
-        if src_file.open
-            close(src_file)
-        end
-        if dst_file.open
-            close(dst_file)
-        end
-    end
-end
-
-@windows_only const UV_FS_SYMLINK_JUNCTION = 0x0002
-function symlink(p::AbstractString, np::AbstractString)
-    @windows_only if Base.windows_version() < Base.WINDOWS_VISTA_VER
-        error("Windows XP does not support soft symlinks")
-    end
-    flags = 0
-    @windows_only if isdir(p); flags |= UV_FS_SYMLINK_JUNCTION; p = abspath(p); end
-    err = ccall(:jl_fs_symlink, Int32, (Cstring, Cstring, Cint), p, np, flags)
-    @windows_only if err < 0
-        Base.warn_once("Note: on Windows, creating file symlinks requires Administrator privileges.")
-    end
-    uv_error("symlink",err)
-end
-
-function readlink(path::AbstractString)
-    req = Libc.malloc(_sizeof_uv_fs)
-    ret = ccall(:uv_fs_readlink, Int32,
-        (Ptr{Void}, Ptr{Void}, Cstring, Ptr{Void}),
-        eventloop(), req, path, C_NULL)
-    uv_error("readlink", ret)
-    tgt = bytestring(ccall(:jl_uv_fs_t_ptr, Ptr{Cchar}, (Ptr{Void}, ), req))
-    ccall(:uv_fs_req_cleanup, Void, (Ptr{Void}, ), req)
-    Libc.free(req)
-    tgt
-end
-
-function chmod(p::AbstractString, mode::Integer)
-    err = ccall(:jl_fs_chmod, Int32, (Cstring, Cint), p, mode)
-    uv_error("chmod",err)
-end
-
-function write(f::File, buf::Ptr{UInt8}, len::Integer, offset::Integer=-1)
-    if !f.open
-        throw(ArgumentError("file \"$(f.path)\" is not open"))
-    end
-    err = ccall(:jl_fs_write, Int32, (Int32, Ptr{UInt8}, Csize_t, Int64),
-                f.handle, buf, len, offset)
-    uv_error("write",err)
-    len
-end
-
-write(f::File, c::UInt8) = write(f,[c])
-
-function write{T}(f::File, a::Array{T})
-    if isbits(T)
-        write(f,pointer(a),length(a)*sizeof(eltype(a)))
-    else
-        invoke(write, Tuple{IO, Array}, f, a)
-    end
-end
-
-function truncate(f::File, n::Integer)
-    req = Base.Libc.malloc(_sizeof_uv_fs)
-    err = ccall(:uv_fs_ftruncate,Int32,(Ptr{Void},Ptr{Void},Int32,Int64,Ptr{Void}),
-                eventloop(),req,f.handle,n,C_NULL)
-    Libc.free(req)
-    uv_error("ftruncate", err)
-    f
-end
-
-function futime(f::File, atime::Float64, mtime::Float64)
-    req = Base.Libc.malloc(_sizeof_uv_fs)
-    err = ccall(:uv_fs_futime,Int32,(Ptr{Void},Ptr{Void},Int32,Float64,Float64,Ptr{Void}),
-                eventloop(),req,f.handle,atime,mtime,C_NULL)
-    Libc.free(req)
-    uv_error("futime", err)
-    f
-end
-
-function read(f::File, ::Type{UInt8})
-    if !f.open
-        throw(ArgumentError("file \"$(f.path)\" is not open"))
-    end
-    ret = ccall(:jl_fs_read_byte, Int32, (Int32,), f.handle)
-    uv_error("read", ret)
-    return ret%UInt8
-end
-
-function read!{T}(f::File, a::Array{T}, nel=length(a))
-    if nel < 0 || nel > length(a)
-        throw(BoundsError())
-    end
-    if isbits(T)
-        nb = nel*sizeof(T)
-        ret = ccall(:jl_fs_read, Int32, (Int32, Ptr{Void}, Csize_t),
-                    f.handle, a, nb)
-        uv_error("read",ret)
-    else
-        invoke(read, Tuple{IO, Array}, s, a)
-    end
-    a
-end
-
-nb_available(f::File) = filesize(f) - position(f)
-
-function readbytes!(f::File, b::Array{UInt8}, nb=length(b))
-    nr = min(nb, nb_available(f))
-    if length(b) < nr
-        resize!(b, nr)
-    end
-    read!(f, b, nr)
-    return nr
-end
-readbytes(io::File) = read!(io, Array(UInt8, nb_available(io)))
-readbytes(io::File, nb) = read!(io, Array(UInt8, min(nb, nb_available(io))))
-
-function readbytes(f::File)
-    a = Array(UInt8, nb_available(f))
-    read!(f,a)
-    a
-end
-
-const SEEK_SET = Int32(0)
-const SEEK_CUR = Int32(1)
-const SEEK_END = Int32(2)
-
-function position(f::File)
-    ret = ccall(:jl_lseek, Coff_t,(Int32,Coff_t,Int32),f.handle,0,SEEK_CUR)
-    systemerror("lseek", ret == -1)
-    ret
-end
-
-fd(f::File) = RawFD(f.handle)
-stat(f::File) = stat(fd(f))
-
-end
diff --git a/base/functors.jl b/base/functors.jl
index 613698192b7ba..b8e847c3ee58b 100644
--- a/base/functors.jl
+++ b/base/functors.jl
@@ -11,91 +11,94 @@
 abstract Func{N}
 
 immutable IdFun <: Func{1} end
-call(::IdFun, x) = x
+(::IdFun)(x) = x
 
 immutable AbsFun <: Func{1} end
-call(::AbsFun, x) = abs(x)
+(::AbsFun)(x) = abs(x)
 
 immutable Abs2Fun <: Func{1} end
-call(::Abs2Fun, x) = abs2(x)
+(::Abs2Fun)(x) = abs2(x)
 
 immutable ExpFun <: Func{1} end
-call(::ExpFun, x) = exp(x)
+(::ExpFun)(x) = exp(x)
 
 immutable LogFun <: Func{1} end
-call(::LogFun, x) = log(x)
+(::LogFun)(x) = log(x)
 
 immutable ConjFun <: Func{1} end
-call(::ConjFun, x) = conj(x)
+(::ConjFun)(x) = conj(x)
 
 immutable AndFun <: Func{2} end
-call(::AndFun, x, y) = x & y
+(::AndFun)(x, y) = x & y
 
 immutable OrFun <: Func{2} end
-call(::OrFun, x, y) = x | y
+(::OrFun)(x, y) = x | y
 
 immutable XorFun <: Func{2} end
-call(::XorFun, x, y) = x $ y
+(::XorFun)(x, y) = x $ y
 
 immutable AddFun <: Func{2} end
-call(::AddFun, x, y) = x + y
+(::AddFun)(x, y) = x + y
 
 immutable DotAddFun <: Func{2} end
-call(::DotAddFun, x, y) = x .+ y
+(::DotAddFun)(x, y) = x .+ y
 
 immutable SubFun <: Func{2} end
-call(::SubFun, x, y) = x - y
+(::SubFun)(x, y) = x - y
 
 immutable DotSubFun <: Func{2} end
-call(::DotSubFun, x, y) = x .- y
+(::DotSubFun)(x, y) = x .- y
 
 immutable MulFun <: Func{2} end
-call(::MulFun, x, y) = x * y
+(::MulFun)(x, y) = x * y
 
 immutable DotMulFun <: Func{2} end
-call(::DotMulFun, x, y) = x .* y
+(::DotMulFun)(x, y) = x .* y
 
 immutable RDivFun <: Func{2} end
-call(::RDivFun, x, y) = x / y
+(::RDivFun)(x, y) = x / y
 
 immutable DotRDivFun <: Func{2} end
-call(::DotRDivFun, x, y) = x ./ y
+(::DotRDivFun)(x, y) = x ./ y
 
 immutable LDivFun <: Func{2} end
-call(::LDivFun, x, y) = x \ y
+(::LDivFun)(x, y) = x \ y
 
 immutable IDivFun <: Func{2} end
-call(::IDivFun, x, y) = div(x, y)
+(::IDivFun)(x, y) = div(x, y)
+
+immutable DotIDivFun <: Func{2} end
+(::DotIDivFun)(x, y) = x .÷ y
 
 immutable ModFun <: Func{2} end
-call(::ModFun, x, y) = mod(x, y)
+(::ModFun)(x, y) = mod(x, y)
 
 immutable RemFun <: Func{2} end
-call(::RemFun, x, y) = rem(x, y)
+(::RemFun)(x, y) = rem(x, y)
 
 immutable DotRemFun <: Func{2} end
-call(::RemFun, x, y) = x .% y
+(::DotRemFun)(x, y) = x .% y
 
 immutable PowFun <: Func{2} end
-call(::PowFun, x, y) = x ^ y
+(::PowFun)(x, y) = x ^ y
 
 immutable MaxFun <: Func{2} end
-call(::MaxFun, x, y) = scalarmax(x,y)
+(::MaxFun)(x, y) = scalarmax(x,y)
 
 immutable MinFun <: Func{2} end
-call(::MinFun, x, y) = scalarmin(x, y)
+(::MinFun)(x, y) = scalarmin(x, y)
 
 immutable LessFun <: Func{2} end
-call(::LessFun, x, y) = x < y
+(::LessFun)(x, y) = x < y
 
 immutable MoreFun <: Func{2} end
-call(::MoreFun, x, y) = x > y
+(::MoreFun)(x, y) = x > y
 
 immutable DotLSFun <: Func{2} end
-call(::DotLSFun, x, y) = x .<< y
+(::DotLSFun)(x, y) = x .<< y
 
 immutable DotRSFun <: Func{2} end
-call(::DotRSFun, x, y) = x .>> y
+(::DotRSFun)(x, y) = x .>> y
 
 # a fallback unspecialized function object that allows code using
 # function objects to not care whether they were able to specialize on
@@ -103,22 +106,25 @@ call(::DotRSFun, x, y) = x .>> y
 immutable UnspecializedFun{N} <: Func{N}
     f::Function
 end
-call(f::UnspecializedFun{1}, x) = f.f(x)
-call(f::UnspecializedFun{2}, x, y) = f.f(x,y)
+(f::UnspecializedFun{1})(x) = f.f(x)
+(f::UnspecializedFun{2})(x, y) = f.f(x,y)
 
 # Special purpose functors
 
 immutable Predicate{F} <: Func{1}
     f::F
 end
-call(pred::Predicate, x) = pred.f(x)::Bool
+(pred::Predicate)(x) = pred.f(x)::Bool
 
 immutable EqX{T} <: Func{1}
     x::T
 end
-EqX{T}(x::T) = EqX{T}(x)
 
-call(f::EqX, y) = f.x == y
+(f::EqX)(y) = f.x == y
+
+# More promote_op rules
+
+promote_op{T<:Integer}(::PowFun, ::Type{Bool}, ::Type{T}) = Bool
 
 #### Bitwise operators ####
 
@@ -143,29 +149,29 @@ call(f::EqX, y) = f.x == y
 
 
 immutable BitFunctorUnary{T,F} <: Func{1} end
-call(::BitFunctorUnary{true,  true},  p) = p | ~p # Must work for bits and ints
-call(::BitFunctorUnary{false, false}, p) = p & ~p # LLVM figures them out nicely
-call(::BitFunctorUnary{true,  false}, p) =  p
-call(::BitFunctorUnary{false, true},  p) = ~p
+(::BitFunctorUnary{true,  true})( p) = p | ~p # Must work for bits and ints
+(::BitFunctorUnary{false, false})(p) = p & ~p # LLVM figures them out nicely
+(::BitFunctorUnary{true,  false})(p) =  p
+(::BitFunctorUnary{false, true})( p) = ~p
 
 immutable BitFunctorBinary{TT,TF,FT,FF} <: Func{2} end
-call(::BitFunctorBinary{true,  true,  true,  true }, p, q) = p | ~p
-call(::BitFunctorBinary{true,  true,  true,  false}, p, q) = p | q
-call(::BitFunctorBinary{true,  true,  false, true }, p, q) = p | ~q
-call(::BitFunctorBinary{true,  true,  false, false}, p, q) = p
-call(::BitFunctorBinary{true,  false, true,  true }, p, q) = ~p | q
-call(::BitFunctorBinary{true,  false, true,  false}, p, q) = q
-call(::BitFunctorBinary{true,  false, false, true }, p, q) = ~(p $ q)
-call(::BitFunctorBinary{true,  false, false, false}, p, q) = p & q
-
-call(::BitFunctorBinary{false, false, false, false}, p, q) = p & ~p
-call(::BitFunctorBinary{false, false, false, true }, p, q) = ~(p | q)
-call(::BitFunctorBinary{false, false, true,  false}, p, q) = ~p & q
-call(::BitFunctorBinary{false, false, true,  true }, p, q) = ~p
-call(::BitFunctorBinary{false, true,  false, false}, p, q) = p & ~q
-call(::BitFunctorBinary{false, true,  false, true }, p, q) = ~q
-call(::BitFunctorBinary{false, true,  true,  false}, p, q) = p $ q
-call(::BitFunctorBinary{false, true,  true,  true }, p, q) = ~(p & q)
+(::BitFunctorBinary{true,  true,  true,  true })(p, q) = p | ~p
+(::BitFunctorBinary{true,  true,  true,  false})(p, q) = p | q
+(::BitFunctorBinary{true,  true,  false, true })(p, q) = p | ~q
+(::BitFunctorBinary{true,  true,  false, false})(p, q) = p
+(::BitFunctorBinary{true,  false, true,  true })(p, q) = ~p | q
+(::BitFunctorBinary{true,  false, true,  false})(p, q) = q
+(::BitFunctorBinary{true,  false, false, true })(p, q) = ~(p $ q)
+(::BitFunctorBinary{true,  false, false, false})(p, q) = p & q
+
+(::BitFunctorBinary{false, false, false, false})(p, q) = p & ~p
+(::BitFunctorBinary{false, false, false, true })(p, q) = ~(p | q)
+(::BitFunctorBinary{false, false, true,  false})(p, q) = ~p & q
+(::BitFunctorBinary{false, false, true,  true })(p, q) = ~p
+(::BitFunctorBinary{false, true,  false, false})(p, q) = p & ~q
+(::BitFunctorBinary{false, true,  false, true })(p, q) = ~q
+(::BitFunctorBinary{false, true,  true,  false})(p, q) = p $ q
+(::BitFunctorBinary{false, true,  true,  true })(p, q) = ~(p & q)
 
 # Specializations by value
 
@@ -186,6 +192,9 @@ function specialized_binary(f::Function)
     is(f, ^) ? PowFun() :
     is(f, &) ? AndFun() :
     is(f, |) ? OrFun()  :
+    is(f, %) ? RemFun() :
+    is(f, rem) ? RemFun() :
+    is(f, ÷) ? IDivFun() :
     is(f, div) ? IDivFun() :
     UnspecializedFun{2}(f)
 end
diff --git a/base/generator.jl b/base/generator.jl
new file mode 100644
index 0000000000000..34da38023886b
--- /dev/null
+++ b/base/generator.jl
@@ -0,0 +1,21 @@
+"""
+    Generator(f, iter)
+
+Given a function `f` and an iterator `iter`, construct an iterator that yields
+the values of `f` applied to the elements of `iter`.
+The syntax `f(x) for x in iter` is syntax for constructing an instance of this
+type.
+"""
+immutable Generator{I,F}
+    f::F
+    iter::I
+end
+
+start(g::Generator) = start(g.iter)
+done(g::Generator, s) = done(g.iter, s)
+function next(g::Generator, s)
+    v, s2 = next(g.iter, s)
+    g.f(v), s2
+end
+
+collect(g::Generator) = map(g.f, g.iter)
diff --git a/base/gmp.jl b/base/gmp.jl
index b6f67fec91b0c..4794a59d01506 100644
--- a/base/gmp.jl
+++ b/base/gmp.jl
@@ -8,7 +8,7 @@ import Base: *, +, -, /, <, <<, >>, >>>, <=, ==, >, >=, ^, (~), (&), (|), ($),
              binomial, cmp, convert, div, divrem, factorial, fld, gcd, gcdx, lcm, mod,
              ndigits, promote_rule, rem, show, isqrt, string, isprime, powermod,
              sum, trailing_zeros, trailing_ones, count_ones, base, tryparse_internal,
-             bin, oct, dec, hex, isequal, invmod, prevpow2, nextpow2, ndigits0z, widen, signed
+             bin, oct, dec, hex, isequal, invmod, prevpow2, nextpow2, ndigits0z, widen, signed, unsafe_trunc, trunc
 
 if Clong == Int32
     typealias ClongMax Union{Int8, Int16, Int32}
@@ -85,7 +85,7 @@ function tryparse_internal(::Type{BigInt}, s::AbstractString, startpos::Int, end
     _n = Nullable{BigInt}()
 
     # don't make a copy in the common case where we are parsing a whole bytestring
-    bstr = startpos == start(s) && endpos == endof(s) ? bytestring(s) : bytestring(SubString(s,i,endpos))
+    bstr = startpos == start(s) && endpos == endof(s) ? bytestring(s) : bytestring(SubString(s,startpos,endpos))
 
     sgn, base, i = Base.parseint_preamble(true,base,bstr,start(bstr),endof(bstr))
     if i == 0
@@ -120,13 +120,23 @@ end
 
 convert(::Type{BigInt}, x::Bool) = BigInt(UInt(x))
 
-function convert(::Type{BigInt}, x::Float64)
-    !isinteger(x) && throw(InexactError())
+
+function unsafe_trunc(::Type{BigInt}, x::Union{Float32,Float64})
     z = BigInt()
     ccall((:__gmpz_set_d, :libgmp), Void, (Ptr{BigInt}, Cdouble), &z, x)
     return z
 end
 
+function convert(::Type{BigInt}, x::Union{Float32,Float64})
+    isinteger(x) || throw(InexactError())
+    unsafe_trunc(BigInt,x)
+end
+
+function trunc(::Type{BigInt}, x::Union{Float32,Float64})
+    isfinite(x) || throw(InexactError())
+    unsafe_trunc(BigInt,x)
+end
+
 convert(::Type{BigInt}, x::Float16) = BigInt(Float64(x))
 convert(::Type{BigInt}, x::Float32) = BigInt(Float64(x))
 
@@ -429,8 +439,8 @@ function powermod(x::BigInt, p::BigInt, m::BigInt)
           &r, &x, &p, &m)
     return m < 0 && r > 0 ? r + m : r # choose sign conistent with mod(x^p, m)
 end
-powermod(x::BigInt, p::Integer, m::BigInt) = powermod(x, BigInt(p), m)
-powermod(x::BigInt, p::Integer, m::Integer) = powermod(x, BigInt(p), BigInt(m))
+
+powermod(x::Integer, p::Integer, m::BigInt) = powermod(big(x), big(p), m)
 
 function gcdx(a::BigInt, b::BigInt)
     if b == 0 # shortcut this to ensure consistent results with gcdx(a,b)
@@ -506,7 +516,7 @@ hex(n::BigInt) = base(16, n)
 function base(b::Integer, n::BigInt)
     2 <= b <= 62 || throw(ArgumentError("base must be 2 ≤ base ≤ 62, got $b"))
     p = ccall((:__gmpz_get_str,:libgmp), Ptr{UInt8}, (Ptr{UInt8}, Cint, Ptr{BigInt}), C_NULL, b, &n)
-    len = Int(ccall(:strlen, Csize_t, (Ptr{UInt8},), p))
+    len = Int(ccall(:strlen, Csize_t, (Cstring,), p))
     ASCIIString(pointer_to_array(p,len,true))
 end
 
@@ -538,8 +548,15 @@ isprime(x::BigInt, reps=25) = ccall((:__gmpz_probab_prime_p,:libgmp), Cint, (Ptr
 prevpow2(x::BigInt) = x.size < 0 ? -prevpow2(-x) : (x <= 2 ? x : one(BigInt) << (ndigits(x, 2)-1))
 nextpow2(x::BigInt) = x.size < 0 ? -nextpow2(-x) : (x <= 2 ? x : one(BigInt) << ndigits(x-1, 2))
 
+Base.checked_abs(x::BigInt) = abs(x)
+Base.checked_neg(x::BigInt) = -x
 Base.checked_add(a::BigInt, b::BigInt) = a + b
 Base.checked_sub(a::BigInt, b::BigInt) = a - b
 Base.checked_mul(a::BigInt, b::BigInt) = a * b
+Base.checked_div(a::BigInt, b::BigInt) = div(a, b)
+Base.checked_rem(a::BigInt, b::BigInt) = rem(a, b)
+Base.checked_fld(a::BigInt, b::BigInt) = fld(a, b)
+Base.checked_mod(a::BigInt, b::BigInt) = mod(a, b)
+Base.checked_cld(a::BigInt, b::BigInt) = cld(a, b)
 
 end # module
diff --git a/base/grisu.jl b/base/grisu.jl
index 5b9837b0e9dd8..055baa5983217 100644
--- a/base/grisu.jl
+++ b/base/grisu.jl
@@ -32,13 +32,13 @@ function grisu(v::AbstractFloat,mode,requested_digits,buffer=DIGITS,bignums=BIGN
     if mode == PRECISION && requested_digits == 0
         buffer[1] = 0x00
         len = 0
-        return 0, 0, neg, buffer
+        return 0, 0, neg
     end
     if v == 0.0
         buffer[1] = 0x30
         buffer[2] = 0x00
         len = point = 1
-        return len, point, neg, buffer
+        return len, point, neg
     end
     if mode == SHORTEST
         status,len,point = fastshortest(v,buffer)
@@ -47,9 +47,9 @@ function grisu(v::AbstractFloat,mode,requested_digits,buffer=DIGITS,bignums=BIGN
     elseif mode == PRECISION
         status,len,point = fastprecision(v,requested_digits,buffer)
     end
-    status && return len-1, point, neg, buffer
+    status && return len-1, point, neg
     status, len, point = bignumdtoa(v,mode,requested_digits,buffer,bignums)
-    return len-1, point, neg, buffer
+    return len-1, point, neg
 end
 
 _show(io::IO, x::AbstractFloat, mode, n::Int, t) =
@@ -67,7 +67,7 @@ function _show(io::IO, x::AbstractFloat, mode, n::Int, typed, nanstr, infstr)
         return
     end
     typed && isa(x,Float16) && write(io, "Float16(")
-    len,pt,neg,buffer = grisu(x,mode,n)
+    (len,pt,neg),buffer = grisu(x,mode,n),DIGITS
     pdigits = pointer(buffer)
     if mode == PRECISION
         while len > 1 && buffer[len] == 0x30
@@ -79,10 +79,10 @@ function _show(io::IO, x::AbstractFloat, mode, n::Int, typed, nanstr, infstr)
     exp_form = exp_form || (pt >= len && abs(mod(x + 0.05, 10^(pt - len)) - 0.05) > 0.05) # see issue #6608
     if exp_form # .00001 to 100000.
         # => #.#######e###
-        write(io, pdigits, 1)
+        unsafe_write(io, pdigits, 1)
         write(io, '.')
         if len > 1
-            write(io, pdigits+1, len-1)
+            unsafe_write(io, pdigits+1, len-1)
         else
             write(io, '0')
         end
@@ -97,26 +97,26 @@ function _show(io::IO, x::AbstractFloat, mode, n::Int, typed, nanstr, infstr)
             write(io, '0')
             pt += 1
         end
-        write(io, pdigits, len)
+        unsafe_write(io, pdigits, len)
     elseif pt >= len
         # => ########00.0
-        write(io, pdigits, len)
+        unsafe_write(io, pdigits, len)
         while pt > len
             write(io, '0')
             len += 1
         end
         write(io, ".0")
     else # => ####.####
-        write(io, pdigits, pt)
+        unsafe_write(io, pdigits, pt)
         write(io, '.')
-        write(io, pdigits+pt, len-pt)
+        unsafe_write(io, pdigits+pt, len-pt)
     end
     typed && isa(x,Float32) && write(io, "f0")
     typed && isa(x,Float16) && write(io, ")")
     nothing
 end
 
-Base.show(io::IO, x::AbstractFloat) = _show(io, x, SHORTEST, 0, true)
+Base.show(io::IO, x::AbstractFloat) = Base.limit_output(io) ? showcompact(io, x) : _show(io, x, SHORTEST, 0, true)
 
 Base.print(io::IO, x::Float32) = _show(io, x, SHORTEST, 0, false)
 Base.print(io::IO, x::Float16) = _show(io, x, SHORTEST, 0, false)
@@ -127,7 +127,7 @@ Base.showcompact(io::IO, x::Float16) = _show(io, x, PRECISION, 5, false)
 
 # normal:
 #   0 < pt < len        ####.####           len+1
-#   pt <= 0             .000########        len-pt+1
+#   pt <= 0             0.000########       len-pt+1
 #   len <= pt (dot)     ########000.        pt+1
 #   len <= pt (no dot)  ########000         pt
 # exponential:
@@ -138,27 +138,27 @@ function _print_shortest(io::IO, x::AbstractFloat, dot::Bool, mode, n::Int)
     isnan(x) && return write(io, "NaN")
     x < 0 && write(io,'-')
     isinf(x) && return write(io, "Inf")
-    len,pt,neg,buffer = grisu(x,mode,n)
+    (len,pt,neg),buffer = grisu(x,mode,n),DIGITS
     pdigits = pointer(buffer)
     e = pt-len
     k = -9<=e<=9 ? 1 : 2
     if -pt > k+1 || e+dot > k+1
         # => ########e###
-        write(io, pdigits+0, len)
+        unsafe_write(io, pdigits+0, len)
         write(io, 'e')
         write(io, dec(e))
         return
     elseif pt <= 0
-        # => .000########
-        write(io, '.')
+        # => 0.000########
+        write(io, "0.")
         while pt < 0
             write(io, '0')
             pt += 1
         end
-        write(io, pdigits+0, len)
+        unsafe_write(io, pdigits+0, len)
     elseif e >= dot
         # => ########000.
-        write(io, pdigits+0, len)
+        unsafe_write(io, pdigits+0, len)
         while e > 0
             write(io, '0')
             e -= 1
@@ -167,9 +167,9 @@ function _print_shortest(io::IO, x::AbstractFloat, dot::Bool, mode, n::Int)
             write(io, '.')
         end
     else # => ####.####
-        write(io, pdigits+0, pt)
+        unsafe_write(io, pdigits+0, pt)
         write(io, '.')
-        write(io, pdigits+pt, len-pt)
+        unsafe_write(io, pdigits+pt, len-pt)
     end
     nothing
 end
diff --git a/base/grisu/bignum.jl b/base/grisu/bignum.jl
index 0c9f6a28d85d1..2182602163537 100644
--- a/base/grisu/bignum.jl
+++ b/base/grisu/bignum.jl
@@ -170,6 +170,9 @@ function init3!(
         Bignums.shiftleft!(plus,exponent)
         Bignums.assignuint16!(minus,UInt16(1))
         Bignums.shiftleft!(minus,exponent)
+    else
+        Bignums.zero!(plus)
+        Bignums.zero!(minus)
     end
     return
 end
@@ -186,6 +189,9 @@ function init1!(
         Bignums.shiftleft!(num,1)
         Bignums.assignuint16!(plus,UInt16(1))
         Bignums.assignuint16!(minus,UInt16(1))
+    else
+        Bignums.zero!(plus)
+        Bignums.zero!(minus)
     end
     return
 end
@@ -198,6 +204,9 @@ function init2!(
     if need_boundary_deltas
         Bignums.assignbignum!(plus,power_ten)
         Bignums.assignbignum!(minus,power_ten)
+    else
+        Bignums.zero!(plus)
+        Bignums.zero!(minus)
     end
     Bignums.multiplybyuint64!(num,UInt64(significand))
     Bignums.assignuint16!(den,UInt16(1))
diff --git a/base/grisu/float.jl b/base/grisu/float.jl
index 109b98b5bcea5..70de682f97d73 100644
--- a/base/grisu/float.jl
+++ b/base/grisu/float.jl
@@ -45,7 +45,7 @@ const FloatSignificandSize = Int32(64)
 
 function normalize(v::Float)
     f = v.s
-    e = v.e
+    e::Int32 = v.e
     while (f & Float10MSBits) == 0
         f <<= 10
         e -= 10
diff --git a/base/hashing.jl b/base/hashing.jl
index ab7ed4631b3de..cc5d6be6007c1 100644
--- a/base/hashing.jl
+++ b/base/hashing.jl
@@ -63,6 +63,7 @@ else
 end
 
 hash(x::QuoteNode, h::UInt) = hash(x.value, hash(QuoteNode, h))
+hash(x::SymbolNode, h::UInt) = hash(x.name, hash(x.typ, hash(SymbolNode, h)))
 
 # hashing ranges by component at worst leads to collisions for very similar ranges
 const hashr_seed = UInt === UInt64 ? 0x80707b6821b70087 : 0x21b70087
diff --git a/base/hashing2.jl b/base/hashing2.jl
index c90639fde2332..5d29eefb842d2 100644
--- a/base/hashing2.jl
+++ b/base/hashing2.jl
@@ -135,14 +135,14 @@ function decompose(x::BigFloat)
     x == 0 && return big(0), 0, Int(x.sign)
     s = BigInt()
     ccall((:__gmpz_realloc2, :libgmp), Void, (Ptr{BigInt}, Culong), &s, x.prec)
-    s.size = -fld(-x.prec,(sizeof(Culong)<<3))
-    ccall(:memcpy, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Csize_t), s.d, x.d, s.size*sizeof(Culong))
+    s.size = -fld(-x.prec,(sizeof(GMP.Limb)<<3))
+    ccall(:memcpy, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Csize_t), s.d, x.d, s.size*sizeof(GMP.Limb))
     s, Int(x.exp - x.prec), Int(x.sign)
 end
 
 ## streamlined hashing for smallish rational types ##
 
-function hash{T<:Integer64}(x::Rational{T}, h::UInt)
+function hash{T<:BitInteger64}(x::Rational{T}, h::UInt)
     num, den = Base.num(x), Base.den(x)
     den == 1 && return hash(num, h)
     den == 0 && return hash(ifelse(num > 0, Inf, -Inf), h)
diff --git a/base/inference.jl b/base/inference.jl
index fc75634665398..d878bc6d803f8 100644
--- a/base/inference.jl
+++ b/base/inference.jl
@@ -2,23 +2,49 @@
 
 # parameters limiting potentially-infinite types
 const MAX_TYPEUNION_LEN = 3
-const MAX_TYPE_DEPTH = 5
-const MAX_TUPLETYPE_LEN  = 8
+const MAX_TYPE_DEPTH = 7
+const MAX_TUPLETYPE_LEN  = 42
 const MAX_TUPLE_DEPTH = 4
 
-type NotFound
+# avoid cycle due to over-specializing `any` when used by inference
+function _any(f::ANY, a)
+    for x in a
+        f(x) && return true
+    end
+    return false
+end
+
+immutable NotFound
 end
 
 const NF = NotFound()
 
-type StaticVarInfo
+type VarInfo
     sp::SimpleVector     # static parameters
-    cenv::ObjectIdDict   # types of closed vars
     vars::Array{Any,1}   # names of args and locals
     gensym_types::Array{Any,1} # types of the GenSym's in this function
     vinfo::Array{Any,1}  # variable properties
     label_counter::Int   # index of the current highest label for this function
     fedbackvars::ObjectIdDict
+    mod::Module
+    linfo::LambdaInfo
+end
+
+function VarInfo(linfo::LambdaInfo, ast=linfo.ast)
+    if !isa(ast,Expr)
+        ast = ccall(:jl_uncompress_ast, Any, (Any,Any), linfo, ast)
+    end
+    vinflist = ast.args[2][1]::Array{Any,1}
+    vars = map(vi->vi[1], vinflist)
+    body = (ast.args[3].args)::Array{Any,1}
+    ngs = ast.args[2][3]
+    if !isa(ngs,Int)
+        ngs = length(ngs::Array)
+    end
+    gensym_types = Any[ NF for i = 1:(ngs::Int) ]
+    nl = label_counter(body)+1
+    sp = linfo.sparam_vals
+    VarInfo(sp, vars, gensym_types, vinflist, nl, ObjectIdDict(), linfo.module, linfo)
 end
 
 type VarState
@@ -31,23 +57,22 @@ end
 
 type CallStack
     ast
-    mod::Module
     types::Type
     recurred::Bool
     cycleid::Int
     result
     prev::Union{EmptyCallStack,CallStack}
-    sv::StaticVarInfo
+    sv::VarInfo
 
-    CallStack(ast, mod, types::ANY, prev) = new(ast, mod, types, false, 0, Bottom, prev)
+    CallStack(ast, types::ANY, prev) = new(ast, types, false, 0, Bottom, prev)
 end
 
 inference_stack = EmptyCallStack()
 
-function is_static_parameter(sv::StaticVarInfo, s::Symbol)
-    sp = sv.sp
-    for i=1:2:length(sp)
-        if is(sp[i].name,s)
+function is_static_parameter(sv::VarInfo, s::Symbol)
+    sp = sv.linfo.sparam_syms
+    for i=1:length(sp)
+        if is(sp[i],s)
             return true
         end
     end
@@ -63,41 +88,23 @@ function contains_is(itr, x::ANY)
     return false
 end
 
-is_local(sv::StaticVarInfo, s::GenSym) = true
-is_local(sv::StaticVarInfo, s::Symbol) = contains_is(sv.vars, s)
-is_closed(sv::StaticVarInfo, s::Symbol) = haskey(sv.cenv, s)
-function is_assigned_inner(sv::StaticVarInfo, s::Symbol)
-    for vi in sv.vinfo
-        if vi[1] === s
-            return (vi[3]&4) != 0
-        end
-    end
-    return false
-end
-is_global(sv::StaticVarInfo, s::Symbol) =
-    !is_local(sv,s) && !is_closed(sv,s) && !is_static_parameter(sv,s)
+is_local(sv::VarInfo, s::GenSym) = true
+is_local(sv::VarInfo, s::Symbol) = contains_is(sv.vars, s)
+is_global(sv::VarInfo, s::Symbol) = !is_local(sv,s) && !is_static_parameter(sv,s)
 
-function _iisconst(s::Symbol)
-    m = (inference_stack::CallStack).mod
+function _iisconst(s::Symbol, sv)
+    m = sv.mod
     isdefined(m,s) && (ccall(:jl_is_const, Int32, (Any, Any), m, s) != 0)
 end
-_iisconst(s::SymbolNode) = _iisconst(s.name)
-_iisconst(s::TopNode) = isconst(_topmod(), s.name)
-_iisconst(s::GlobalRef) = isconst(s.mod, s.name)
-_iisconst(x::Expr) = false
-_iisconst(x::ANY) = true
 
-_ieval(x::ANY) =
-    ccall(:jl_interpret_toplevel_expr_in, Any, (Any, Any, Ptr{Void}, Csize_t),
-          (inference_stack::CallStack).mod, x, C_NULL, 0)
-_iisdefined(x::ANY) = isdefined((inference_stack::CallStack).mod, x)
+_ieval(x::ANY, sv) =
+    ccall(:jl_interpret_toplevel_expr_in, Any, (Any, Any, Any, Any),
+          sv.mod, x, svec(), svec())
 
-function _topmod()
-    m = (inference_stack::CallStack).mod
-    return ccall(:jl_base_relative_to, Any, (Any,), m)::Module
-end
+_topmod(sv::VarInfo) = _topmod(sv.mod)
+_topmod(m::Module) = ccall(:jl_base_relative_to, Any, (Any,), m)::Module
 
-function istopfunction(topmod, f, sym)
+function istopfunction(topmod, f::ANY, sym)
     if isdefined(Main, :Base) && isdefined(Main.Base, sym) && f === getfield(Main.Base, sym)
         return true
     elseif isdefined(topmod, sym) && f === getfield(topmod, sym)
@@ -106,19 +113,21 @@ function istopfunction(topmod, f, sym)
     return false
 end
 
+isknownlength(t::DataType) = !isvatuple(t) && !(t.name===NTuple.name && !isa(t.parameters[1],Int))
+
 cmp_tfunc = (x,y)->Bool
 
 isType(t::ANY) = isa(t,DataType) && is((t::DataType).name,Type.name)
 
 const IInf = typemax(Int) # integer infinity
-const n_ifunc = reinterpret(Int32,llvmcall)+1
-const t_ifunc = Array{Tuple{Int,Int,Function},1}(n_ifunc)
+const n_ifunc = reinterpret(Int32,arraylen)+1
+const t_ifunc = Array{Tuple{Int,Int,Any},1}(n_ifunc)
 const t_ffunc_key = Array{Function,1}(0)
-const t_ffunc_val = Array{Tuple{Int,Int,Function},1}(0)
-function add_tfunc(f::IntrinsicFunction, minarg::Int, maxarg::Int, tfunc::Function)
+const t_ffunc_val = Array{Tuple{Int,Int,Any},1}(0)
+function add_tfunc(f::IntrinsicFunction, minarg::Int, maxarg::Int, tfunc::ANY)
     t_ifunc[reinterpret(Int32,f)+1] = (minarg, maxarg, tfunc)
 end
-function add_tfunc(f::Function, minarg::Int, maxarg::Int, tfunc::Function)
+function add_tfunc(f::Function, minarg::Int, maxarg::Int, tfunc::ANY)
     push!(t_ffunc_key, f)
     push!(t_ffunc_val, (minarg, maxarg, tfunc))
 end
@@ -160,6 +169,7 @@ add_tfunc(eval(Core.Intrinsics,:cglobal), 1, 2,
 add_tfunc(eval(Core.Intrinsics,:select_value), 3, 3,
     # TODO: return Bottom if cnd is definitely not a Bool
     (cnd, x, y)->Union{x,y})
+add_tfunc(eval(Core.Intrinsics,:arraylen), 1, 1, x->Int)
 add_tfunc(is, 2, 2, cmp_tfunc)
 add_tfunc(issubtype, 2, 2, cmp_tfunc)
 add_tfunc(isa, 2, 2, cmp_tfunc)
@@ -167,9 +177,7 @@ add_tfunc(isdefined, 1, IInf, (args...)->Bool)
 add_tfunc(Core.sizeof, 1, 1, x->Int)
 add_tfunc(nfields, 1, 1, x->Int)
 add_tfunc(_expr, 1, IInf, (args...)->Expr)
-add_tfunc(method_exists, 2, 2, cmp_tfunc)
 add_tfunc(applicable, 1, IInf, (f, args...)->Bool)
-add_tfunc(arraylen, 1, 1, x->Int)
 #add_tfunc(arrayref, 2,IInf,(a,i...)->(isa(a,DataType) && a<:Array ?
 #                                     a.parameters[1] : Any))
 #add_tfunc(arrayset, 3, IInf, (a,v,i...)->a)
@@ -177,7 +185,7 @@ add_tfunc(arraysize, 2, 2, (a,d)->Int)
 add_tfunc(pointerref, 2, 2, (a,i)->(isa(a,DataType) && a<:Ptr && isa(a.parameters[1],Union{Type,TypeVar}) ? a.parameters[1] : Any))
 add_tfunc(pointerset, 3, 3, (a,v,i)->a)
 
-const typeof_tfunc = function (t)
+const typeof_tfunc = function (t::ANY)
     if isType(t)
         t = t.parameters[1]
         if isa(t,TypeVar)
@@ -207,6 +215,18 @@ add_tfunc(typeof, 1, 1, typeof_tfunc)
 add_tfunc(typeassert, 2, 2,
     (A, v, t)->(isType(t) ? typeintersect(v,t.parameters[1]) : Any))
 
+function type_depth(t::ANY, d::Int=0)
+    if isa(t,Union)
+        t === Bottom && return d
+        return maximum(x->type_depth(x, d+1), t.types)
+    elseif isa(t,DataType)
+        P = t.parameters
+        isempty(P) && return d
+        return maximum(x->type_depth(x, d+1), P)
+    end
+    return d
+end
+
 function limit_type_depth(t::ANY, d::Int, cov::Bool, vars)
     if isa(t,TypeVar) || isa(t,TypeConstructor)
         return t
@@ -221,12 +241,13 @@ function limit_type_depth(t::ANY, d::Int, cov::Bool, vars)
         end
     elseif isa(t,DataType)
         P = t.parameters
-        length(P) == 0 && return t
+        isempty(P) && return t
         if d > MAX_TYPE_DEPTH
             R = t.name.primary
         else
-            Q = map(x->limit_type_depth(x, d+1, false, vars), P)
-            if !cov && any(p->contains_is(vars,p), Q)
+            stillcov = cov && (t.name === Tuple.name)
+            Q = map(x->limit_type_depth(x, d+1, stillcov, vars), P)
+            if !cov && _any(p->contains_is(vars,p), Q)
                 R = t.name.primary
                 inexact = true
             else
@@ -243,7 +264,7 @@ function limit_type_depth(t::ANY, d::Int, cov::Bool, vars)
     return R
 end
 
-const getfield_tfunc = function (A, s0, name)
+const getfield_tfunc = function (A, s0::ANY, name)
     s = s0
     if isType(s)
         s = typeof(s.parameters[1])
@@ -295,11 +316,11 @@ const getfield_tfunc = function (A, s0, name)
         for i=1:length(snames)
             if is(snames[i],fld)
                 R = s.types[i]
-                if length(s.parameters) == 0
+                if isempty(s.parameters)
                     return R, true
                 else
                     typ = limit_type_depth(R, 0, true,
-                                            filter!(x->isa(x,TypeVar), Any[s.parameters...]))
+                                           filter!(x->isa(x,TypeVar), Any[s.parameters...]))
                     return typ, isleaftype(s) && typeseq(typ, R)
                 end
             end
@@ -324,7 +345,7 @@ const getfield_tfunc = function (A, s0, name)
 end
 add_tfunc(getfield, 2, 2, (A,s,name)->getfield_tfunc(A,s,name)[1])
 add_tfunc(setfield!, 3, 3, (o, f, v)->v)
-const fieldtype_tfunc = function (A, s, name)
+const fieldtype_tfunc = function (A, s::ANY, name)
     if isType(s)
         s = s.parameters[1]
     else
@@ -349,7 +370,7 @@ function valid_tparam(x::ANY)
 end
 
 function extract_simple_tparam(Ai)
-    if !isa(Ai,Symbol) && valid_tparam(Ai)
+    if !isa(Ai,Symbol) && !isa(Ai,GenSym) && valid_tparam(Ai)
         return Ai
     elseif isa(Ai,QuoteNode) && valid_tparam(Ai.value)
         return Ai.value
@@ -368,10 +389,10 @@ function extract_simple_tparam(Ai)
     return Bottom
 end
 
-has_typevars(t::ANY) = ccall(:jl_has_typevars, Cint, (Any,), t)!=0
+has_typevars(t::ANY, all=false) = ccall(:jl_has_typevars_, Cint, (Any,Cint), t, all)!=0
 
 # TODO: handle e.g. apply_type(T, R::Union{Type{Int32},Type{Float64}})
-const apply_type_tfunc = function (A, args...)
+const apply_type_tfunc = function (A::ANY, args...)
     if !isType(args[1])
         return Any
     end
@@ -385,39 +406,43 @@ const apply_type_tfunc = function (A, args...)
         largs == 2 && return args[2]
         args = args[2:end]
         if all(isType, args)
-            return Type{Union{map(t->t.parameters[1],args)...}}
+            try
+                return Type{Union{map(t->t.parameters[1],args)...}}
+            catch
+                return Any
+            end
         else
             return Any
         end
-    elseif Union <: headtype
+    elseif isa(headtype, Union)
         return Any
     end
     istuple = (headtype === Tuple)
     uncertain = false
     lA = length(A)
-    tparams = svec()
+    tparams = Any[]
     for i=2:max(lA,largs)
         ai = args[i]
         if isType(ai)
             aip1 = ai.parameters[1]
             uncertain |= has_typevars(aip1)
-            tparams = svec(tparams..., aip1)
+            push!(tparams, aip1)
         else
             if i<=lA
                 val = extract_simple_tparam(A[i])
                 if val !== Bottom
-                    tparams = svec(tparams..., val)
+                    push!(tparams, val)
                     continue
                 elseif isa(inference_stack,CallStack) && isa(A[i],Symbol)
-                    sp = inference_stack.sv.sp
+                    sp = inference_stack.sv.linfo.sparam_syms
                     s = A[i]
                     found = false
-                    for j=1:2:length(sp)
-                        if is(sp[j].name,s)
+                    for j=1:length(sp)
+                        if is(sp[j],s)
                             # static parameter
-                            val = sp[j+1]
+                            val = inference_stack.sv.sp[j]
                             if valid_tparam(val)
-                                tparams = svec(tparams..., val)
+                                push!(tparams, val)
                                 found = true
                                 break
                             end
@@ -434,9 +459,9 @@ const apply_type_tfunc = function (A, args...)
             end
             uncertain = true
             if istuple
-                tparams = svec(tparams..., Any)
+                push!(tparams, Any)
             else
-                tparams = svec(tparams..., headtype.parameters[i-1])
+                push!(tparams, headtype.parameters[i-1])
             end
         end
     end
@@ -450,10 +475,11 @@ const apply_type_tfunc = function (A, args...)
         appl = headtype
         uncertain = true
     end
+    !uncertain && return Type{appl}
     if type_too_complex(appl,0)
         return Type{TypeVar(:_,headtype)}
     end
-    uncertain && !isa(appl,TypeVar) ? Type{TypeVar(:_,appl)} : Type{appl}
+    !isa(appl,TypeVar) ? Type{TypeVar(:_,appl)} : Type{appl}
 end
 add_tfunc(apply_type, 1, IInf, apply_type_tfunc)
 
@@ -510,7 +536,7 @@ function builtin_tfunction(f::ANY, args::ANY, argtype::ANY)
         end
         tf = t_ffunc_val[fidx]
     end
-    tf = tf::Tuple{Real, Real, Function}
+    tf = tf::Tuple{Real, Real, Any}
     if isva
         # only some t-funcs can handle varargs  (TODO)
         #if !is(f, apply_type)
@@ -527,57 +553,67 @@ function builtin_tfunction(f::ANY, args::ANY, argtype::ANY)
     return tf[3](argtypes...)
 end
 
-function isconstantfunc(f::ANY, sv::StaticVarInfo)
+function isconstantref(f::ANY, sv::VarInfo)
     if isa(f,TopNode)
-        m = _topmod()
+        m = _topmod(sv)
         return isconst(m, f.name) && isdefined(m, f.name) && f
     end
     if isa(f,GlobalRef)
         M = f.mod; s = f.name
         return isdefined(M,s) && isconst(M,s) && f
     end
-    if isa(f,Expr) && is(f.head,:call)
-        if length(f.args) == 3 && isa(f.args[1], TopNode) &&
-            is(f.args[1].name,:getfield) && isa(f.args[3],QuoteNode)
-            s = f.args[3].value
-            if isa(f.args[2],Module)
-                M = f.args[2]
-            else
-                M = isconstantfunc(f.args[2], sv)
-                if M === false
-                    return false
-                end
-                M = _ieval(M)
-                if !isa(M,Module)
-                    return false
+    if isa(f,Expr)
+        if is(f.head,:call)
+            if length(f.args) == 3 && isa(f.args[1], TopNode) &&
+                is(f.args[1].name,:getfield) && isa(f.args[3],QuoteNode)
+                s = f.args[3].value
+                if isa(f.args[2],Module)
+                    M = f.args[2]
+                else
+                    M = isconstantref(f.args[2], sv)
+                    if M === false
+                        return false
+                    end
+                    M = _ieval(M, sv)
+                    if !isa(M,Module)
+                        return false
+                    end
                 end
+                return isdefined(M,s) && isconst(M,s) && f
             end
-            return isdefined(M,s) && isconst(M,s) && f
+        elseif is(f.head,:inert)
+            return f
         end
+        return false
     end
-
-    if isa(f,QuoteNode) && (isa(f.value, Function) || isa(f.value, IntrinsicFunction))
-        return f.value
-    end
-    if isa(f,Function) || isa(f,IntrinsicFunction)
+    if isa(f,QuoteNode)
         return f
-    end
-    if isa(f,SymbolNode)
+    elseif isa(f,GenSym)
+        return false
+    elseif isa(f,SymbolNode)
         f = f.name
     end
-    return isa(f,Symbol) && is_global(sv, f) && _iisconst(f) && f
+    if isa(f,Symbol)
+        return is_global(sv, f) && _iisconst(f, sv) && f
+    elseif !isa(f,Expr)
+        return f
+    end
+    return false
 end
 
-const isconstantref = isconstantfunc
+const isconstantfunc = isconstantref
 
 const limit_tuple_depth = t->limit_tuple_depth_(t,0)
 
-const limit_tuple_depth_ = function (t,d::Int)
+const limit_tuple_depth_ = function (t::ANY,d::Int)
     if isa(t,Union)
         # also limit within Union types.
         # may have to recur into other stuff in the future too.
         return Union{map(x->limit_tuple_depth_(x,d+1), t.types)...}
     end
+    if isa(t,TypeVar)
+        return limit_tuple_depth_(t.ub, d)
+    end
     if !(isa(t,DataType) && t.name === Tuple.name)
         return t
     end
@@ -588,13 +624,13 @@ const limit_tuple_depth_ = function (t,d::Int)
     Tuple{p...}
 end
 
-limit_tuple_type = t -> limit_tuple_type_n(t, MAX_TUPLETYPE_LEN)
+limit_tuple_type = (t::ANY) -> limit_tuple_type_n(t, MAX_TUPLETYPE_LEN)
 
-const limit_tuple_type_n = function (t, lim::Int)
+const limit_tuple_type_n = function (t::ANY, lim::Int)
     p = t.parameters
     n = length(p)
     if n > lim
-        tail = reduce(typejoin, Bottom, svec(p[lim:(n-1)]..., unwrapva(p[n])))
+        tail = reduce(typejoin, Bottom, Any[p[lim:(n-1)]..., unwrapva(p[n])])
         return Tuple{p[1:(lim-1)]..., Vararg{tail}}
     end
     return t
@@ -604,9 +640,9 @@ let stagedcache=Dict{Any,Any}()
     global func_for_method
     function func_for_method(m::Method, tt, env)
         if !m.isstaged
-            return m.func.code
-        elseif haskey(stagedcache,(m,tt,env))
-            return stagedcache[(m,tt,env)].code
+            return m.func
+        elseif haskey(stagedcache, (m, tt))
+            return stagedcache[(m, tt)]
         else
             if !isleaftype(tt)
                 # don't call staged functions on abstract types.
@@ -614,52 +650,40 @@ let stagedcache=Dict{Any,Any}()
                 # we can't guarantee that their type behavior is monotonic.
                 return NF
             end
-            f = ccall(:jl_instantiate_staged,Any,(Any,Any,Any),m,tt,env)
-            stagedcache[(m,tt,env)] = f
-            return f.code
+            f = ccall(:jl_instantiate_staged, Any, (Any, Any, Any), m.func, tt, env)
+            stagedcache[(m, tt)] = f
+            return f
         end
     end
 end
 
-function abstract_call_gf(f, fargs, argtype, e)
+function abstract_call_gf(f::ANY, fargs, argtype::ANY, e)
     argtypes = argtype.parameters
-    tm = _topmod()
-    if length(argtypes)>1 && argtypes[2]===Int && (argtypes[1] <: Tuple ||
-       (isa(argtypes[1], DataType) && isdefined(Main, :Base) && isdefined(Main.Base, :Pair) &&
-        (argtypes[1]::DataType).name === Main.Base.Pair.name))
+    tm = _topmod((inference_stack::CallStack).sv)  # TODO pass in sv instead
+    if length(argtypes)>2 && argtypes[3]===Int &&
+        (argtypes[2] <: Tuple ||
+         (isa(argtypes[2], DataType) && isdefined(Main, :Base) && isdefined(Main.Base, :Pair) &&
+          (argtypes[2]::DataType).name === Main.Base.Pair.name))
         # allow tuple indexing functions to take advantage of constant
         # index arguments.
         if istopfunction(tm, f, :getindex)
-            return getfield_tfunc(fargs, argtypes[1], argtypes[2])[1]
+            return getfield_tfunc(fargs, argtypes[2], argtypes[3])[1]
         elseif istopfunction(tm, f, :next)
-            t1 = getfield_tfunc(fargs, argtypes[1], argtypes[2])[1]
+            t1 = getfield_tfunc(fargs, argtypes[2], argtypes[3])[1]
             return t1===Bottom ? Bottom : Tuple{t1, Int}
         elseif istopfunction(tm, f, :indexed_next)
-            t1 = getfield_tfunc(fargs, argtypes[1], argtypes[2])[1]
+            t1 = getfield_tfunc(fargs, argtypes[2], argtypes[3])[1]
             return t1===Bottom ? Bottom : Tuple{t1, Int}
         end
     end
     if istopfunction(tm, f, :promote_type) || istopfunction(tm, f, :typejoin)
-        la = length(argtypes)
-        c = cell(la)
-        for i = 1:la
-            t = argtypes[i]
-            if isType(t) && !isa(t.parameters[1],TypeVar)
-                c[i] = t.parameters[1]
-            else
-                return Type
-            end
-        end
-        if istopfunction(tm, f, :promote_type)
-            try
-                RT = Type{f(c...)}
-                return RT
-            catch
-            end
-        else
-            return Type{f(c...)}
-        end
+        return Type
     end
+    return abstract_call_gf_by_type(f, argtype, e)
+end
+
+function abstract_call_gf_by_type(f::ANY, argtype::ANY, e)
+    tm = _topmod((inference_stack::CallStack).sv)  # TODO pass in sv instead
     # don't consider more than N methods. this trades off between
     # compiler performance and generated code performance.
     # typically, considering many methods means spending lots of time
@@ -669,7 +693,7 @@ function abstract_call_gf(f, fargs, argtype, e)
     # here I picked 4.
     argtype = limit_tuple_type(argtype)
     argtypes = argtype.parameters
-    applicable = _methods(f, argtype, 4)
+    applicable = _methods_by_ftype(argtype, 4)
     rettype = Bottom
     if is(applicable,false)
         # this means too many methods matched
@@ -685,9 +709,10 @@ function abstract_call_gf(f, fargs, argtype, e)
         return Any
     end
     for (m::SimpleVector) in x
+        sig = m[1]
         local linfo
         linfo = try
-            func_for_method(m[3],argtype,m[2])
+            func_for_method(m[3],sig,m[2])
         catch
             NF
         end
@@ -695,8 +720,7 @@ function abstract_call_gf(f, fargs, argtype, e)
             rettype = Any
             break
         end
-        linfo = linfo::LambdaStaticData
-        sig = m[1]
+        linfo = linfo::LambdaInfo
         lsig = length(m[3].sig.parameters)
         # limit argument type tuple based on size of definition signature.
         # for example, given function f(T, Any...), limit to 3 arguments
@@ -741,12 +765,15 @@ function abstract_call_gf(f, fargs, argtype, e)
     return rettype
 end
 
-function invoke_tfunc(f, types, argtype)
+function invoke_tfunc(f::ANY, types::ANY, argtype::ANY)
     argtype = typeintersect(types,limit_tuple_type(argtype))
     if is(argtype,Bottom)
         return Bottom
     end
-    meth = ccall(:jl_gf_invoke_lookup, Any, (Any, Any), f, types)
+    ft = type_typeof(f)
+    types = Tuple{ft, types.parameters...}
+    argtype = Tuple{ft, argtype.parameters...}
+    meth = ccall(:jl_gf_invoke_lookup, Any, (Any,), types)
     if is(meth, nothing)
         return Any
     end
@@ -760,7 +787,7 @@ function invoke_tfunc(f, types, argtype)
     if linfo === NF
         return Any
     end
-    return typeinf(linfo::LambdaStaticData, ti, env, linfo)[2]
+    return typeinf(linfo::LambdaInfo, ti, env, linfo)[2]
 end
 
 # `types` is an array of inferred types for expressions in `args`.
@@ -776,11 +803,23 @@ function precise_container_types(args, types, vtypes, sv)
         if isa(ai,Expr) && (is_known_call(ai, svec, sv) || is_known_call(ai, tuple, sv))
             aa = ai.args
             result[i] = Any[ (isa(aa[j],Expr) ? aa[j].typ : abstract_eval(aa[j],vtypes,sv)) for j=2:length(aa) ]
-            if any(isvarargtype, result[i])
+            if _any(isvarargtype, result[i])
+                return nothing
+            end
+        elseif isa(ti, Union)
+            return nothing
+        elseif ti<:Tuple
+            if i == n
+                if ti.name === NTuple.name
+                    result[i] = Any[Vararg{ti.parameters[2]}]
+                else
+                    result[i] = ti.parameters
+                end
+            elseif isknownlength(ti)
+                result[i] = ti.parameters
+            else
                 return nothing
             end
-        elseif ti<:Tuple && (i==n || !isvatuple(ti))
-            result[i] = ti.parameters
         elseif ti<:AbstractArray && i==n
             result[i] = Any[Vararg{eltype(ti)}]
         else
@@ -791,156 +830,206 @@ function precise_container_types(args, types, vtypes, sv)
 end
 
 # do apply(af, fargs...), where af is a function value
-function abstract_apply(af, fargs, aargtypes::Vector{Any}, vtypes, sv, e)
+function abstract_apply(af::ANY, fargs, aargtypes::Vector{Any}, vtypes, sv, e)
     ctypes = precise_container_types(fargs, aargtypes, vtypes, sv)
     if ctypes !== nothing
         # apply with known func with known tuple types
         # can be collapsed to a call to the applied func
-        at = append_any(ctypes...)
+        at = append_any(Any[type_typeof(af)], ctypes...)
         n = length(at)
-        if n > MAX_TUPLETYPE_LEN
-            tail = foldl((a,b)->tmerge(a,unwrapva(b)), Bottom, at[MAX_TUPLETYPE_LEN:n])
-            at = vcat(at[1:MAX_TUPLETYPE_LEN-1], Any[Vararg{tail}])
+        if n-1 > MAX_TUPLETYPE_LEN
+            tail = foldl((a,b)->tmerge(a,unwrapva(b)), Bottom, at[MAX_TUPLETYPE_LEN+1:n])
+            at = vcat(at[1:MAX_TUPLETYPE_LEN], Any[Vararg{tail}])
         end
         return abstract_call(af, (), at, vtypes, sv, ())
     end
-    is(af,kwcall) && return Any
     # apply known function with unknown args => f(Any...)
-    return abstract_call(af, (), Any[Vararg{Any}], vtypes, sv, ())
+    return abstract_call(af, (), Any[type_typeof(af), Vararg{Any}], vtypes, sv, ())
 end
 
-function abstract_call(f, fargs, argtypes::Vector{Any}, vtypes, sv::StaticVarInfo, e)
-    if is(f,_apply) && length(fargs)>1
-        af = isconstantfunc(fargs[2], sv)
-        if !is(af,false)
-            af = _ieval(af)
-            if isa(af,Function)
-                return abstract_apply(af, fargs[3:end], argtypes[3:end], vtypes, sv, e)
+function isconstantargs(args, argtypes::Vector{Any}, sv::VarInfo)
+    if length(argtypes) == 1 # just the function
+        return true
+    end
+    if isvarargtype(argtypes[end])
+        return false
+    end
+    for i = 2:length(argtypes)
+        t = argtypes[i]
+        if !isType(t) || has_typevars(t.parameters[1])
+            args === () && return false
+            arg = args[i]
+            if isconstantref(arg, sv) === false
+                return false
             end
         end
-        # TODO: this slows down inference a lot
-        a2type = argtypes[2]
-        if a2type !== Function && isleaftype(a2type)
-            # would definitely use call()
-            call_func = _ieval(isconstantfunc(fargs[1], sv))
-            if isa(call_func,Function)
-                aargtypes = Any[ argtypes[i] for i=2:length(argtypes) ]
-                aargtypes[1] = Tuple{aargtypes[1]}  # don't splat "function"
-                fa = fargs[2:end]
-                fa[1] = Expr(:call, top_tuple, fa[1])
-                return abstract_apply(call_func, fa, aargtypes, vtypes, sv, e)
+    end
+    return true
+end
+
+function _ieval_args(args, argtypes::Vector{Any}, sv::VarInfo)
+    c = cell(length(argtypes) - 1)
+    for i = 2:length(argtypes)
+        t = argtypes[i]
+        if isType(t) && !has_typevars(t.parameters[1])
+            c[i - 1] = t.parameters[1]
+        else
+            c[i - 1] = _ieval(isconstantref(args[i], sv), sv)
+        end
+    end
+    return c
+end
+
+@pure function type_typeof(v::ANY)
+    if isa(v, Type)
+        return Type{v}
+    end
+    return typeof(v)
+end
+
+function pure_eval_call(f::ANY, fargs, argtypes::ANY, sv, e)
+    if !isconstantargs(fargs, argtypes, sv)
+        return false
+    end
+
+    args = _ieval_args(fargs, argtypes, sv)
+    atype = Tuple{type_typeof(f), Any[type_typeof(a) for a in args]...}
+    meth = _methods_by_ftype(atype, 1)
+    if meth === false || length(meth) != 1
+        return false
+    end
+    meth = meth[1]::SimpleVector
+    linfo = try
+        func_for_method(meth[3], meth[1], meth[2])
+    catch
+        NF
+    end
+    if linfo === NF
+        return false
+    end
+    if !linfo.pure
+        typeinf(linfo, meth[1], meth[2], linfo)
+        if !linfo.pure
+            return false
+        end
+    end
+
+    try
+        v = f(args...)
+        return type_typeof(v)
+    catch
+        return false
+    end
+end
+
+
+function abstract_call(f::ANY, fargs, argtypes::Vector{Any}, vtypes, sv::VarInfo, e)
+    t = pure_eval_call(f, fargs, argtypes, sv, e)
+    t !== false && return t
+    if is(f,_apply) && length(fargs)>1
+        af = isconstantfunc(fargs[2], sv)
+        if af === false
+            aft = argtypes[2]
+            if isType(aft) && !isa(aft.parameters[1],TypeVar)
+                af = aft.parameters[1]
+            elseif isleaftype(aft) && isdefined(aft,:instance)
+                af = aft.instance
+            else
+                # TODO jb/functions: take advantage of case where non-constant `af`'s type is known
+                return Any
             end
+        else
+            af = _ieval(af, sv)
         end
-        return Any
+        return abstract_apply(af, fargs[3:end], argtypes[3:end], vtypes, sv, e)
     end
-    for i=1:(length(argtypes)-1)
+    for i=2:(length(argtypes)-1)
         if isvarargtype(argtypes[i])
             return Any
         end
     end
-    if isgeneric(f)
-        return abstract_call_gf(f, fargs, Tuple{argtypes...}, e)
-    end
-    if is(f,invoke) && length(fargs)>1
-        af = isconstantfunc(fargs[1], sv)
-        if !is(af,false) && (af=_ieval(af);isgeneric(af))
-            sig = argtypes[2]
+    if is(f,invoke) && length(fargs)>2
+        af = isconstantfunc(fargs[2], sv)
+        if !is(af,false)
+            af = _ieval(af,sv)
+            sig = argtypes[3]
             if isType(sig) && sig.parameters[1] <: Tuple
-                return invoke_tfunc(af, sig.parameters[1], Tuple{argtypes[3:end]...})
+                return invoke_tfunc(af, sig.parameters[1], Tuple{argtypes[4:end]...})
             end
         end
     end
     if is(f,getfield)
         val = isconstantref(e, sv)
         if !is(val,false)
-            return abstract_eval_constant(_ieval(val))
+            return abstract_eval_constant(_ieval(val,sv))
         end
     end
-    if is(f,kwcall)
-        if length(argtypes) < 4
-            return Bottom
-        end
-        if length(fargs) < 3
-            return Any
-        end
-        kwcount = fargs[2]
-        ff = isconstantfunc(fargs[3 + 2*kwcount], sv)
-        if !(ff===false)
-            ff = _ieval(ff)
-            if isgeneric(ff) && isdefined(ff.env,:kwsorter)
-                # use the fact that kwcall(...) calls ff.env.kwsorter
-                posargt = argtypes[(5+2*kwcount):end]
-                return abstract_call_gf(ff.env.kwsorter, (),
-                                        Tuple{Array{Any,1}, posargt...}, e)
+    if is(f,Core.kwfunc) && length(fargs)==2
+        ft = argtypes[2]
+        if isa(ft,DataType) && !ft.abstract
+            if isdefined(ft.name.mt, :kwsorter)
+                return typeof(ft.name.mt.kwsorter)
             end
         end
-        # TODO: call() case
         return Any
     end
-    if !isa(f,Function) && !isa(f,IntrinsicFunction)
-        if !_iisdefined(:call)
-            return Any
-        end
-        call_func = _ieval(:call)
-        if isa(call_func,Function)
-            return abstract_call(call_func, e.args,
-                                 Any[abstract_eval_constant(f),argtypes...],
-                                 vtypes, sv, e)
-        else
-            return Any
-        end
+    fargs = fargs[2:end]
+    if isa(f,Builtin) || isa(f,IntrinsicFunction)
+        rt = builtin_tfunction(f, fargs, Tuple{argtypes[2:end]...})
+        return isa(rt, TypeVar) ? rt.ub : rt
     end
-    rt = builtin_tfunction(f, fargs, Tuple{argtypes...})
-    #print("=> ", rt, "\n")
-    return rt
+    return abstract_call_gf(f, fargs, Tuple{argtypes...}, e)
 end
 
-function abstract_eval_call(e, vtypes, sv::StaticVarInfo)
-    fargs = e.args[2:end]
-    argtypes = Any[abstract_eval(a, vtypes, sv) for a in fargs]
-    if any(x->is(x,Bottom), argtypes)
-        return Bottom
+function abstract_eval_call(e, vtypes, sv::VarInfo)
+    argtypes = Any[abstract_eval(a, vtypes, sv) for a in e.args]
+    #print("call ", e.args[1], argtypes, "\n\n")
+    for x in argtypes
+        x === Bottom && return Bottom
     end
     called = e.args[1]
     func = isconstantfunc(called, sv)
     if is(func,false)
-        if isa(called, LambdaStaticData)
-            # called lambda expression (let)
-            (_, result) = typeinf(called, Tuple{argtypes...}, called.sparams, called)
-            return result
-        end
-        ft = abstract_eval(called, vtypes, sv)
-        if !(Function <: ft) && _iisdefined(:call)
-            call_func = _ieval(:call)
-            if isa(call_func,Function)
-                return abstract_call(call_func, e.args, Any[ft,argtypes...], vtypes, sv, e)
+        ft = argtypes[1]
+        if isType(ft) && !isa(ft.parameters[1],TypeVar)
+            f = ft.parameters[1]
+        elseif isleaftype(ft) && isdefined(ft,:instance)
+            f = ft.instance
+        else
+            for i = 2:(length(argtypes)-1)
+                if isvarargtype(argtypes[i])
+                    return Any
+                end
+            end
+            # non-constant function, but type is known
+            if (isleaftype(ft) || ft <: Type) && !(ft <: Builtin) && !(ft <: IntrinsicFunction)
+                return abstract_call_gf_by_type(nothing, Tuple{argtypes...}, e)
             end
+            return Any
         end
-        return Any
+    else
+        f = _ieval(func,sv)
     end
-    #print("call ", e.args[1], argtypes, "\n\n")
-    f = _ieval(func)
     if isa(called, Expr)
         # if called thing is a constant, still make sure it gets annotated with a type.
         # issue #11997
         called.typ = abstract_eval_constant(f)
     end
-    return abstract_call(f, fargs, argtypes, vtypes, sv, e)
+    return abstract_call(f, e.args, argtypes, vtypes, sv, e)
 end
 
-function abstract_eval(e::ANY, vtypes, sv::StaticVarInfo)
+function abstract_eval(e::ANY, vtypes, sv::VarInfo)
     if isa(e,QuoteNode)
-        return typeof((e::QuoteNode).value)
+        v = (e::QuoteNode).value
+        return type_typeof(v)
     elseif isa(e,TopNode)
-        return abstract_eval_global(_topmod(), (e::TopNode).name)
+        return abstract_eval_global(_topmod(sv), (e::TopNode).name)
     elseif isa(e,Symbol)
         return abstract_eval_symbol(e::Symbol, vtypes, sv)
     elseif isa(e,SymbolNode)
         return abstract_eval_symbol((e::SymbolNode).name, vtypes, sv)
     elseif isa(e,GenSym)
         return abstract_eval_gensym(e::GenSym, sv)
-    elseif isa(e,LambdaStaticData)
-        return Function
     elseif isa(e,GlobalRef)
         return abstract_eval_global(e.mod, e.name)
     end
@@ -955,7 +1044,7 @@ function abstract_eval(e::ANY, vtypes, sv::StaticVarInfo)
         t = abstract_eval_call(e, vtypes, sv)
     elseif is(e.head,:null)
         t = Void
-    elseif is(e.head,:new)
+    elseif is(e.head,:new) || is(e.head,:stknew)
         t = abstract_eval(e.args[1], vtypes, sv)
         if isType(t)
             t = t.parameters[1]
@@ -1003,9 +1092,12 @@ function abstract_eval(e::ANY, vtypes, sv::StaticVarInfo)
             end
         end
     elseif is(e.head,:method)
-        t = Function
+        t = (length(e.args) == 1) ? Any : Void
     elseif is(e.head,:copyast)
         t = abstract_eval(e.args[1], vtypes, sv)
+    elseif is(e.head,:inert)
+        v = e.args[1]
+        return type_typeof(v)
     else
         t = Any
     end
@@ -1029,17 +1121,14 @@ function abstract_eval_constant(x::ANY)
     return typeof(x)
 end
 
-abstract_eval_global(s::Symbol) =
-    abstract_eval_global((inference_stack::CallStack).mod, s)
-
-function abstract_eval_global(M, s::Symbol)
-    if isconst(M,s)
-        return abstract_eval_constant(eval(M,s))
+function abstract_eval_global(M::Module, s::Symbol)
+    if isdefined(M,s) && isconst(M,s)
+        return abstract_eval_constant(getfield(M,s))
     end
     return Any
 end
 
-function abstract_eval_gensym(s::GenSym, sv::StaticVarInfo)
+function abstract_eval_gensym(s::GenSym, sv::VarInfo)
     typ = sv.gensym_types[s.id+1]
     if typ === NF
         return Bottom
@@ -1047,18 +1136,14 @@ function abstract_eval_gensym(s::GenSym, sv::StaticVarInfo)
     return typ
 end
 
-function abstract_eval_symbol(s::Symbol, vtypes::ObjectIdDict, sv::StaticVarInfo)
-    if haskey(sv.cenv,s)
-        # consider closed vars to always have their propagated (declared) type
-        return sv.cenv[s]
-    end
+function abstract_eval_symbol(s::Symbol, vtypes::ObjectIdDict, sv::VarInfo)
     t = get(vtypes,s,NF)
     if is(t,NF)
-        sp = sv.sp
-        for i=1:2:length(sp)
-            if is(sp[i].name,s)
+        sp = sv.linfo.sparam_syms
+        for i=1:length(sp)
+            if is(sp[i],s)
                 # static parameter
-                val = sp[i+1]
+                val = sv.sp[i]
                 if isa(val,TypeVar)
                     # static param bound to typevar
                     if Any <: val.ub
@@ -1077,7 +1162,7 @@ function abstract_eval_symbol(s::Symbol, vtypes::ObjectIdDict, sv::StaticVarInfo
             return Bottom
         end
         # global
-        return abstract_eval_global(s)
+        return abstract_eval_global(sv.mod, s)
     end
     return t.typ
 end
@@ -1097,7 +1182,7 @@ function getindex(x::StateUpdate, s::Symbol)
     return get(x.state,s,NF)
 end
 
-function abstract_interpret(e::ANY, vtypes, sv::StaticVarInfo)
+function abstract_interpret(e::ANY, vtypes, sv::VarInfo)
     !isa(e,Expr) && return vtypes
     # handle assignment
     if is(e.head,:(=))
@@ -1117,7 +1202,7 @@ function abstract_interpret(e::ANY, vtypes, sv::StaticVarInfo)
     elseif is(e.head,:method)
         fname = e.args[1]
         if isa(fname,Symbol)
-            return StateUpdate(fname, VarState(Function,false), vtypes)
+            return StateUpdate(fname, VarState(Any,false), vtypes)
         end
     end
     return vtypes
@@ -1259,7 +1344,7 @@ function find_gensym_uses(e::ANY, uses, line)
     end
 end
 
-function newvar!(sv::StaticVarInfo, typ)
+function newvar!(sv::VarInfo, typ)
     id = length(sv.gensym_types)
     push!(sv.gensym_types, typ)
     return GenSym(id)
@@ -1270,11 +1355,11 @@ f_argnames(ast) =
 
 is_rest_arg(arg::ANY) = (ccall(:jl_is_rest_arg,Int32,(Any,), arg) != 0)
 
-function typeinf_ext(linfo, atypes::ANY, sparams::ANY, def)
+function typeinf_ext(linfo, atypes::ANY, def)
     global inference_stack
     last = inference_stack
     inference_stack = EmptyCallStack()
-    result = typeinf(linfo, atypes, sparams, def, true, true)
+    result = typeinf(linfo, atypes, svec(), def, true, true)
     inference_stack = last
     return result
 end
@@ -1285,12 +1370,12 @@ typeinf(linfo,atypes::ANY,sparams::ANY,def) = typeinf(linfo,atypes,sparams,def,t
 CYCLE_ID = 1
 
 #trace_inf = false
-#enable_trace_inf() = (global trace_inf=true)
+#enable_trace_inf(on) = (global trace_inf=on)
 
 # def is the original unspecialized version of a method. we aggregate all
 # saved type inference data there.
-function typeinf(linfo::LambdaStaticData,atypes::ANY,sparams::SimpleVector, def, cop, needtree)
-    if linfo.module === Core
+function typeinf(linfo::LambdaInfo, atypes::ANY, sparams::SimpleVector, def, cop, needtree)
+    if linfo.module === Core && isempty(sparams) && isempty(linfo.sparam_vals)
         atypes = Tuple
     end
     #dbg =
@@ -1312,27 +1397,26 @@ function typeinf(linfo::LambdaStaticData,atypes::ANY,sparams::SimpleVector, def,
                     break
                 end
                 if isa(code,Type)
-                    curtype = code
+                    curtype = code::Type
                     # sometimes just a return type is stored here. if a full AST
                     # is not needed, we can return it.
                     if !needtree
                         return (nothing, code)
                     end
                 else
-                    curtype = ccall(:jl_ast_rettype, Any, (Any,Any), def, code)
-                    return (code, curtype)
+                    return code  # else code is a tuple (ast, type)
                 end
             end
         end
     end
     # TODO: typeinf currently gets stuck without this
-    if linfo.name === :abstract_interpret || linfo.name === :tuple_elim_pass || linfo.name === :abstract_call_gf
+    if linfo.name === :abstract_interpret || linfo.name === :alloc_elim_pass || linfo.name === :abstract_call_gf
         return (linfo.ast, Any)
     end
 
     (fulltree, result, rec) = typeinf_uncached(linfo, atypes, sparams, def, curtype, cop, true)
     if fulltree === ()
-        return (fulltree,result)
+        return (fulltree, result::Type)
     end
 
     if !redo
@@ -1354,14 +1438,14 @@ function typeinf(linfo::LambdaStaticData,atypes::ANY,sparams::SimpleVector, def,
         tfarr[idx] = atypes
         # in the "rec" state this tree will not be used again, so store
         # just the return type in place of it.
-        tfarr[idx+1] = rec ? result : fulltree
+        tfarr[idx+1] = rec ? result : (fulltree,result)
         tfarr[idx+2] = rec
     else
-        def.tfunc[tfunc_idx] = rec ? result : fulltree
+        def.tfunc[tfunc_idx] = rec ? result : (fulltree,result)
         def.tfunc[tfunc_idx+1] = rec
     end
 
-    return (fulltree, result)
+    return (fulltree, result::Type)
 end
 
 typeinf_uncached(linfo, atypes::ANY, sparams::ANY; optimize=true) =
@@ -1371,7 +1455,7 @@ typeinf_uncached(linfo, atypes::ANY, sparams::ANY; optimize=true) =
 tupletype_tail(t::ANY, n) = Tuple{t.parameters[n:end]...}
 
 # compute an inferred (optionally optimized) AST without global effects (i.e. updating the cache)
-function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleVector, def, curtype, cop, optimize)
+function typeinf_uncached(linfo::LambdaInfo, atypes::ANY, sparams::SimpleVector, def, curtype, cop, optimize)
     ast0 = def.ast
     #if dbg
     #    print("typeinf ", linfo.name, " ", object_id(ast0), "\n")
@@ -1385,6 +1469,45 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
     #print("typeinf ", ast0, " ", sparams, " ", atypes, "\n")
 
     global inference_stack, CYCLE_ID
+
+    f = inference_stack
+    while !isa(f,EmptyCallStack)
+        if is(f.ast,ast0)
+            # impose limit if we recur and the argument types grow beyond MAX_TYPE_DEPTH
+            td = type_depth(atypes)
+            if td > type_depth(f.types)
+                if td > MAX_TYPE_DEPTH
+                    atypes = limit_type_depth(atypes, 0, true, [])
+                    break
+                else
+                    p1, p2 = atypes.parameters, f.types.parameters
+                    n = length(p1)
+                    if length(p2) == n
+                        limited = false
+                        newatypes = Array(Any, n)
+                        for i = 1:n
+                            if p1[i] <: Function && type_depth(p1[i]) > type_depth(p2[i]) &&
+                                isa(p1[i],DataType)
+                                # if a Function argument is growing (e.g. nested closures)
+                                # then widen to the outermost function type. without this
+                                # inference fails to terminate on do_quadgk.
+                                newatypes[i] = p1[i].name.primary
+                                limited = true
+                            else
+                                newatypes[i] = p1[i]
+                            end
+                        end
+                        if limited
+                            atypes = Tuple{newatypes...}
+                            break
+                        end
+                    end
+                end
+            end
+        end
+        f = f.prev
+    end
+
     # check for recursion
     f = inference_stack
     while !isa(f,EmptyCallStack)
@@ -1413,21 +1536,30 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
     #if dbg print("typeinf ", linfo.name, " ", atypes, "\n") end
 
     if cop
-        sparams = svec(sparams..., linfo.sparams...)
-        ast = ccall(:jl_prepare_ast, Any, (Any,Any), linfo, sparams)::Expr
+        ast = ccall(:jl_prepare_ast, Any, (Any,), linfo)::Expr
     else
         ast = linfo.ast
     end
 
+    sv = VarInfo(linfo, ast)
+
+    if length(linfo.sparam_vals) > 0
+        # handled by VarInfo constructor
+    elseif isempty(sparams) && !isempty(linfo.sparam_syms)
+        sv.sp = svec(Any[ TypeVar(sym, Any, true) for sym in linfo.sparam_syms ]...)
+    else
+        sv.sp = sparams
+    end
+
     args = f_argnames(ast)
     la = length(args)
     assert(is(ast.head,:lambda))
-    vinflist = ast.args[2][1]::Array{Any,1}
-    vars = map(vi->vi[1], vinflist)
+    vinflist = sv.vinfo
+    vars = sv.vars
     body = (ast.args[3].args)::Array{Any,1}
     n = length(body)
 
-    labels = zeros(Int, label_counter(body)+1)
+    labels = zeros(Int, sv.label_counter)
     for i=1:length(body)
         b = body[i]
         if isa(b,LabelNode)
@@ -1436,7 +1568,8 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
     end
 
     # our stack frame
-    frame = CallStack(ast0, linfo.module, atypes, inference_stack)
+    frame = CallStack(ast0, atypes, inference_stack)
+    frame.sv = sv
     inference_stack = frame
     frame.result = curtype
 
@@ -1475,46 +1608,32 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
             lastatype = lastatype.parameters[1]
             laty -= 1
         end
+        if isa(lastatype, TypeVar)
+            lastatype = lastatype.ub
+        end
         if laty > la
             laty = la
         end
         for i=1:laty
-            s[1][args[i]] = VarState(atypes.parameters[i],false)
+            atyp = atypes.parameters[i]
+            if isa(atyp, TypeVar)
+                atyp = atyp.ub
+            end
+            s[1][args[i]] = VarState(atyp, false)
         end
         for i=laty+1:la
-            s[1][args[i]] = VarState(lastatype,false)
-        end
-    else
-        @assert la == 0
-    end
-
-    # types of closed vars
-    cenv = ObjectIdDict()
-    for vi in (ast.args[2][2])::Array{Any,1}
-        vi::Array{Any,1}
-        vname = vi[1]
-        vtype = vi[2]
-        cenv[vname] = vtype
-        s[1][vname] = VarState(vtype,false)
-    end
-    for vi in vinflist
-        vi::Array{Any,1}
-        if (vi[3]&4)!=0
-            # variables assigned by inner functions are treated like
-            # closed variables; we only use the declared type
-            vname = vi[1]
-            vtype = vi[2]
-            cenv[vname] = vtype
-            s[1][vname] = VarState(vtype,false)
+            s[1][args[i]] = VarState(lastatype, false)
         end
+    elseif la != 0
+        return ((), Bottom, false) # wrong number of arguments
     end
 
     gensym_uses = find_gensym_uses(body)
-    gensym_init = Any[ NF for i = 1:length(gensym_uses) ]
-    gensym_types = copy(gensym_init)
-
-    sv = StaticVarInfo(sparams, cenv, vars, gensym_types, vinflist, length(labels), ObjectIdDict())
-    frame.sv = sv
+    if length(sv.gensym_types) != length(gensym_uses)
+        sv.gensym_types = Any[ NF for i=1:length(gensym_uses) ]
+    end
+    gensym_types = sv.gensym_types
+    gensym_init = copy(gensym_types)
 
     recpts = IntSet()  # statements that depend recursively on our value
     W = IntSet()
@@ -1526,6 +1645,7 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
     # exception handlers
     cur_hand = ()
     handler_at = Any[ () for i=1:n ]
+    n_handlers = 0
 
     push!(W,1) #initial pc to visit
 
@@ -1646,6 +1766,16 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
                 elseif is(hd,:enter)
                     l = findlabel(labels,stmt.args[1]::Int)
                     cur_hand = (l,cur_hand)
+                    if handler_at[l] === ()
+                        n_handlers += 1
+                        if n_handlers > 25
+                            # too many exception handlers slows down inference a lot.
+                            # for an example see test/libgit2.jl on 0.5-pre master
+                            # around e.g. commit c072d1ce73345e153e4fddf656cda544013b1219
+                            inference_stack = (inference_stack::CallStack).prev
+                            return (ast0, Any, false)
+                        end
+                    end
                     handler_at[l] = cur_hand
                 elseif is(hd,:leave)
                     for i=1:((stmt.args[1])::Int)
@@ -1694,12 +1824,16 @@ function typeinf_uncached(linfo::LambdaStaticData, atypes::ANY, sparams::SimpleV
             if JLOptions().can_inline == 1
                 fulltree.args[3] = inlining_pass(fulltree.args[3], sv, fulltree)[1]
                 # inlining can add variables
-                sv.vars = append_any(f_argnames(fulltree), fulltree.args[2][1])
+                sv.vars = append_any(f_argnames(fulltree), map(vi->vi[1], fulltree.args[2][1]))
+                inbounds_meta_elim_pass(fulltree.args[3])
             end
-            tuple_elim_pass(fulltree, sv)
+            alloc_elim_pass(fulltree, sv)
             getfield_elim_pass(fulltree.args[3], sv)
         end
         linfo.inferred = true
+        body = Expr(:block)
+        body.args = fulltree.args[3].args::Array{Any,1}
+        linfo.pure = popmeta!(body, :pure)[1]
         fulltree = ccall(:jl_compress_ast, Any, (Any,Any), def, fulltree)
     end
 
@@ -1719,11 +1853,11 @@ function record_var_type(e::Symbol, t::ANY, decls)
     end
 end
 
-function eval_annotate(e::ANY, vtypes::ANY, sv::StaticVarInfo, decls, clo, undefs)
+function eval_annotate(e::ANY, vtypes::ANY, sv::VarInfo, decls, undefs)
     if isa(e, Symbol)
         e = e::Symbol
 
-        if !is_local(sv, e) && !is_closed(sv, e)
+        if !is_local(sv, e)
             # can get types of globals and static params from the environment
             return e
         end
@@ -1751,11 +1885,6 @@ function eval_annotate(e::ANY, vtypes::ANY, sv::StaticVarInfo, decls, clo, undef
         return e
     end
 
-    if isa(e, LambdaStaticData)
-        push!(clo, e)
-        return e
-    end
-
     if !isa(e,Expr)
         return e
     end
@@ -1775,7 +1904,7 @@ function eval_annotate(e::ANY, vtypes::ANY, sv::StaticVarInfo, decls, clo, undef
             # we don't use types on assignment LHS
             s = s.name
         end
-        e.args[2] = eval_annotate(e.args[2], vtypes, sv, decls, clo, undefs)
+        e.args[2] = eval_annotate(e.args[2], vtypes, sv, decls, undefs)
         if isa(s,Symbol)
             # TODO: if this def does not reach any uses, maybe don't do this
             rhstype = exprtype(e.args[2], sv)
@@ -1789,17 +1918,9 @@ function eval_annotate(e::ANY, vtypes::ANY, sv::StaticVarInfo, decls, clo, undef
     for i=i0:length(e.args)
         subex = e.args[i]
         if !(isa(subex,Number) || isa(subex,AbstractString))
-            e.args[i] = eval_annotate(subex, vtypes, sv, decls, clo, undefs)
+            e.args[i] = eval_annotate(subex, vtypes, sv, decls, undefs)
         end
     end
-    if head === :call && isa(e.args[1],LambdaStaticData)
-        called = e.args[1]
-        fargs = e.args[2:end]
-        argtypes = Tuple{[abstract_eval(a, vtypes, sv) for a in fargs]...}
-        # recur inside inner functions once we have all types
-        tr,ty = typeinf(called, argtypes, called.sparams, called, false, true)
-        called.ast = tr
-    end
     return e
 end
 
@@ -1811,56 +1932,31 @@ function type_annotate(ast::Expr, states::Array{Any,1}, sv::ANY, rettype::ANY, a
     for arg in args
         decls[arg] = states[1][arg].typ
     end
-    closures = []
     body = ast.args[3].args::Array{Any,1}
     for i=1:length(body)
         st_i = states[i]
         if st_i !== ()
             # st_i === ()  =>  unreached statement  (see issue #7836)
-            body[i] = eval_annotate(body[i], st_i, sv, decls, closures, undefs)
+            body[i] = eval_annotate(body[i], st_i, sv, decls, undefs)
         end
     end
     ast.args[3].typ = rettype
 
     # add declarations for variables that are always the same type
     for vi in ast.args[2][1]::Array{Any,1}
-        if (vi[3]&4)==0
-            vi[2] = get(decls, vi[1], vi[2])
-        end
+        vi[2] = get(decls, vi[1], vi[2])
         if haskey(undefs, vi[1])
             vi[3] |= 32
         end
     end
     for vi in ast.args[2][2]::Array{Any,1}
-        if (vi[3]&4)==0
-            vi[2] = get(decls, vi[1], vi[2])
-        end
+        vi[2] = get(decls, vi[1], vi[2])
         if haskey(undefs, vi[1])
             vi[3] |= 32
         end
     end
     ast.args[2][3] = sv.gensym_types
 
-    for (li::LambdaStaticData) in closures
-        if !li.inferred
-            a = li.ast
-            # pass on declarations of captured vars
-            for vi in a.args[2][2]::Array{Any,1}
-                if (vi[3]&4)==0
-                    vi[2] = get(decls, vi[1], vi[2])
-                end
-            end
-            # NOTE: this is disabled, as it leads to inlining too early.
-            # See issue #4688. We should wait until inner functions are called
-            # to optimize them; this will be done by the method cache or
-            # builtins.c:jl_trampoline. However if jl_trampoline is changed then
-            # this code will need to be restored.
-            #na = length(a.args[1])
-            #li.ast, _ = typeinf(li, ntuple(i->(i>na ? (Tuple)[1] : Any), na+1),
-            #                    li.sparams, li, false)
-        end
-    end
-
     return ast
 end
 
@@ -1876,6 +1972,14 @@ function sym_replace(e::ANY, from1, from2, to1, to2)
             return SymbolNode(e2, e.typ)
         end
     end
+    if isa(e,NewvarNode)
+        e2 = _sym_repl(e.name::Symbol, from1, from2, to1, to2, e)
+        if isa(e2, NewvarNode) || !isa(e2, Symbol)
+             return e2
+        else
+            return NewvarNode(e2)
+        end
+    end
     if !isa(e,Expr)
         return e
     end
@@ -1919,6 +2023,7 @@ end
 function occurs_more(e::ANY, pred, n)
     if isa(e,Expr)
         e = e::Expr
+        e.head === :line && return 0
         c = 0
         for a = e.args
             c += occurs_more(a, pred, n)
@@ -1936,7 +2041,7 @@ end
 
 const emptydict = ObjectIdDict()
 
-function exprtype(x::ANY, sv::StaticVarInfo)
+function exprtype(x::ANY, sv::VarInfo)
     if isa(x,Expr)
         return (x::Expr).typ
     elseif isa(x,SymbolNode)
@@ -1944,23 +2049,17 @@ function exprtype(x::ANY, sv::StaticVarInfo)
     elseif isa(x,GenSym)
         return abstract_eval_gensym(x::GenSym, sv)
     elseif isa(x,TopNode)
-        return abstract_eval_global(_topmod(), (x::TopNode).name)
+        return abstract_eval_global(_topmod(sv), (x::TopNode).name)
     elseif isa(x,Symbol)
-        sv = inference_stack.sv
         if is_local(sv, x::Symbol)
             return Any
         end
         return abstract_eval(x::Symbol, emptydict, sv)
     elseif isa(x,QuoteNode)
         v = (x::QuoteNode).value
-        if isa(v,Type)
-            return Type{v}
-        end
-        return typeof(v)
+        return type_typeof(v)
     elseif isa(x,Type)
         return Type{x}
-    elseif isa(x,LambdaStaticData)
-        return Function
     elseif isa(x,GlobalRef)
         return abstract_eval_global(x.mod, (x::GlobalRef).name)
     else
@@ -1974,7 +2073,7 @@ const _pure_builtins = Any[tuple, svec, fieldtype, apply_type, is, isa, typeof,
 # known effect-free calls (might not be affect-free)
 const _pure_builtins_volatile = Any[getfield, arrayref]
 
-function is_pure_builtin(f)
+function is_pure_builtin(f::ANY)
     if contains_is(_pure_builtins, f)
         return true
     end
@@ -1985,8 +2084,7 @@ function is_pure_builtin(f)
         if !(f === Intrinsics.pointerref || # this one is volatile
              f === Intrinsics.pointerset || # this one is never effect-free
              f === Intrinsics.ccall ||      # this one is never effect-free
-             f === Intrinsics.llvmcall ||   # this one is never effect-free
-             f === Intrinsics.jl_alloca)
+             f === Intrinsics.llvmcall)     # this one is never effect-free
             return true
         end
     end
@@ -1999,14 +2097,14 @@ end
 function effect_free(e::ANY, sv, allow_volatile::Bool)
     if isa(e,SymbolNode)
         allow_volatile && return true
-        if is_assigned_inner(sv, (e::SymbolNode).name) || is_global(sv, (e::SymbolNode).name)
+        if is_global(sv, (e::SymbolNode).name)
             return false
         end
         return true
     end
     if isa(e,Symbol)
         allow_volatile && return true
-        if is_assigned_inner(sv, e::Symbol) || is_global(sv, e::Symbol)
+        if is_global(sv, e::Symbol)
             return false
         end
         return true
@@ -2019,7 +2117,7 @@ function effect_free(e::ANY, sv, allow_volatile::Bool)
         allow_volatile && return true
         return isconst(e.mod, e.name)
     end
-    if isconstantfunc(e, sv) !== false
+    if isconstantref(e, sv) !== false
         return true
     end
     if isa(e,Expr)
@@ -2031,7 +2129,7 @@ function effect_free(e::ANY, sv, allow_volatile::Bool)
         if e.head === :call
             if is_known_call_p(e, is_pure_builtin, sv)
                 if !allow_volatile
-                    if is_known_call(e, arrayref, sv)
+                    if is_known_call(e, arrayref, sv) || is_known_call(e, arraylen, sv)
                         return false
                     elseif is_known_call(e, getfield, sv)
                         # arguments must be immutable to ensure e is affect_free
@@ -2105,63 +2203,122 @@ function ast_localvars(ast)
     locals
 end
 
-# inline functions whose bodies "inline_worthy"
+# inline functions whose bodies are "inline_worthy"
 # where the function body doesn't contain any argument more than once.
-# functions with closure environments or varargs are also excluded.
 # static parameters are ok if all the static parameter values are leaf types,
 # meaning they are fully known.
-function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_ast::Expr)
-    if !(isa(f,Function) || isa(f,IntrinsicFunction))
-        return NF
-    end
-    atypes = atype.parameters
-    argexprs = e.args[2:end]
+# `ft` is the type of the function. `f` is the exact function if known, or else `nothing`.
+function inlineable(f::ANY, ft::ANY, e::Expr, atypes::Vector{Any}, sv::VarInfo, enclosing_ast::Expr)
+    local linfo,
+        metharg::Type,
+        argexprs = e.args,
+        incompletematch = false
 
-    if is(f, typeassert) && length(atypes)==2
+    if (is(f, typeassert) || is(ft, typeof(typeassert))) && length(atypes)==3
         # typeassert(x::S, T) => x, when S<:T
-        if isType(atypes[2]) && isleaftype(atypes[2]) &&
-            atypes[1] <: atypes[2].parameters[1]
+        if isType(atypes[3]) && isleaftype(atypes[3]) &&
+            atypes[2] <: atypes[3].parameters[1]
             return (e.args[2],())
         end
     end
-    if length(atypes)==2 && is(f,unbox) && isa(atypes[2],DataType) && !atypes[2].mutable && atypes[2].pointerfree
+    if length(atypes)==3 && is(f,unbox) && isa(atypes[3],DataType) && !atypes[3].mutable && atypes[3].pointerfree
         # remove redundant unbox
         return (e.args[3],())
     end
-    topmod = _topmod()
-    if istopfunction(topmod, f, :isbits) && length(atypes)==1 && isType(atypes[1]) &&
-        effect_free(argexprs[1],sv,true) && isleaftype(atypes[1].parameters[1])
-        return (isbits(atypes[1].parameters[1]),())
+    topmod = _topmod(sv)
+    if istopfunction(topmod, f, :isbits) && length(atypes)==2 && isType(atypes[2]) &&
+        effect_free(argexprs[2],sv,true) && isleaftype(atypes[2].parameters[1])
+        return (isbits(atypes[2].parameters[1]),())
     end
     # special-case inliners for known pure functions that compute types
     if isType(e.typ)
         if (is(f,apply_type) || is(f,fieldtype) ||
             istopfunction(topmod, f, :typejoin) ||
             istopfunction(topmod, f, :promote_type)) &&
-                isleaftype(e.typ.parameters[1])
+                !has_typevars(e.typ.parameters[1],true)
             return (e.typ.parameters[1],())
         end
     end
-    if isa(f,IntrinsicFunction)
+    if isa(f,IntrinsicFunction) || ft === IntrinsicFunction
         return NF
     end
 
-    meth = _methods(f, atype, 1)
+    local methfunc
+    atype = Tuple{atypes...}
+    if length(atype.parameters)-1 > MAX_TUPLETYPE_LEN
+        atype = limit_tuple_type(atype)
+    end
+    meth = _methods_by_ftype(atype, 1)
     if meth === false || length(meth) != 1
         return NF
     end
     meth = meth[1]::SimpleVector
-
-    local linfo
+    metharg = meth[1]
+    methsp = meth[2]
     linfo = try
-        func_for_method(meth[3],atype,meth[2])
+        func_for_method(meth[3],metharg,methsp)
     catch
         NF
     end
     if linfo === NF
         return NF
     end
-    linfo = linfo::LambdaStaticData
+    if linfo.pure && isconstantargs(argexprs, atypes, sv)
+        # check if any arguments aren't effect_free and need to be kept around
+        stmts = Any[]
+        for i = 1:length(argexprs)
+            arg = argexprs[i]
+            if !effect_free(arg, sv, false)
+                push!(stmts, arg)
+            end
+        end
+
+        if isType(e.typ) && !has_typevars(e.typ.parameters[1])
+            return (QuoteNode(e.typ.parameters[1]), stmts)
+        end
+
+        constargs = _ieval_args(argexprs, atypes, sv)
+        try
+            v = f(constargs...)
+            return (QuoteNode(v), stmts)
+        catch ex
+            thrw = Expr(:call, TopNode(:throw), QuoteNode(ex))
+            thrw.typ = Bottom
+            return (thrw, stmts)
+        end
+    end
+
+    methfunc = meth[3].func
+    methsig = meth[3].sig
+    if !(atype <: metharg)
+        incompletematch = true
+        if !inline_incompletematch_allowed || !isdefined(Main,:Base)
+            # provide global disable if this optimization is not desirable
+            # need Main.Base defined for MethodError
+            return NF
+        end
+    end
+    linfo = linfo::LambdaInfo
+
+    spnames = Any[s for s in linfo.sparam_syms]
+    if length(linfo.sparam_vals) > 0
+        spvals = Any[x for x in linfo.sparam_vals]
+    else
+        spvals = Any[]
+        for i = 1:length(spnames)
+            si = methsp[i]
+            if isa(si, TypeVar)
+                return NF
+            end
+            push!(spvals, si)
+        end
+    end
+    for i=1:length(spvals)
+        si = spvals[i]
+        if isa(si,Symbol) || isa(si,GenSym)
+            spvals[i] = QuoteNode(si)
+        end
+    end
 
     ## This code tries to limit the argument list length only when it is
     ## growing due to recursion.
@@ -2189,38 +2346,10 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     #     end
     # end
 
-    if !isa(linfo,LambdaStaticData) || length(meth[3].func.env) > 0
-        return NF
-    end
-
-    sp = meth[2]::SimpleVector
-    sp = svec(sp..., linfo.sparams...)
-    spvals = Any[ sp[i] for i in 2:2:length(sp) ]
-    for i=1:length(spvals)
-        si = spvals[i]
-        if isa(si, TypeVar)
-            return NF
-        end
-        if isa(si,Symbol) || isa(si,GenSym)
-            spvals[i] = QuoteNode(si)
-        end
-    end
-
-    metharg = meth[1]::Type
     methargs = metharg.parameters
     nm = length(methargs)
-    if !(atype <: metharg)
-        incompletematch = true
-        if !inline_incompletematch_allowed || !isdefined(Main,:Base)
-            # provide global disable if this optimization is not desirable
-            # need Main.Base defined for MethodError
-            return NF
-        end
-    else
-        incompletematch = false
-    end
 
-    (ast, ty) = typeinf(linfo, metharg, meth[2], linfo, true, true)
+    (ast, ty) = typeinf(linfo, metharg, methsp, linfo, true, true)
     if is(ast,())
         return NF
     end
@@ -2231,25 +2360,21 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     end
     ast = ast::Expr
     vinflist = ast.args[2][1]::Array{Any,1}
-    for vi in vinflist
-        if (vi[3]&1)!=0
-            # captures variables (TODO)
-            return NF
-        end
-    end
 
     body = Expr(:block)
-    body.args = filter(x->!((isa(x,Expr) && is(x.head,:line)) || isa(x,LineNumberNode)),
-                       ast.args[3].args::Array{Any,1})
+    body.args = ast.args[3].args::Array{Any,1}
+    propagate_inbounds, _ = popmeta!(body, :propagate_inbounds)
     cost::Int = 1000
     if incompletematch
         cost *= 4
     end
-    if is(f, next) || is(f, done) || is(f, unsafe_convert) || is(f, cconvert)
+    if (istopfunction(topmod, f, :next) || istopfunction(topmod, f, :done) ||
+       istopfunction(topmod, f, :unsafe_convert) || istopfunction(topmod, f, :cconvert))
         cost ÷= 4
     end
-    inline_op = (f===(+) || f===(*) || f===min || f===max) && (3 <= length(argexprs) <= 9) &&
-        meth[3].sig == Tuple{Any,Any,Any,Vararg{Any}}
+    inline_op = (istopfunction(topmod, f, :+) || istopfunction(topmod, f, :*) ||
+        istopfunction(topmod, f, :min) || istopfunction(topmod, f, :max)) &&
+        (4 <= length(argexprs) <= 10) && methsig == Tuple{ft,Any,Any,Any,Vararg{Any}}
     if !inline_op && !inline_worthy(body, cost)
         if incompletematch
             # inline a typeassert-based call-site, rather than a
@@ -2257,9 +2382,8 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
             # all the fiddly details
             numarg = length(argexprs)
             newnames = unique_names(ast,numarg)
-            sp = ()
+            spnames = []
             spvals = []
-            meth = svec(metharg, sp)
             locals = []
             newcall = Expr(:call, e.args[1])
             newcall.typ = ty
@@ -2280,7 +2404,6 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     body.args = filter(x->!(isa(x,Expr) && x.head === :meta && isempty(x.args)),
                        body.args)
 
-    spnames = Any[ sp[i].name for i=1:2:length(sp) ]
     enc_vinflist = enclosing_ast.args[2][1]::Array{Any,1}
     enc_locllist = ast_localvars(enclosing_ast)
     locllist = ast_localvars(ast)
@@ -2290,11 +2413,14 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     na = length(args)
 
     isva = false
-    if na>0 && is_rest_arg(ast.args[1][na])
+    if na > 0 && is_rest_arg(ast.args[1][na])
+        if length(argexprs) < na - 1
+            return (Expr(:call, TopNode(:error), "too few arguments"), [])
+        end
         vaname = args[na]
         len_argexprs = length(argexprs)
         valen = len_argexprs-na+1
-        if valen>0 && !occurs_outside_getfield(body, vaname, sv, valen)
+        if valen>0 && !occurs_outside_getfield(body, vaname, sv, valen, ())
             # argument tuple is not used as a whole, so convert function body
             # to one accepting the exact number of arguments we have.
             newnames = unique_names(ast,valen)
@@ -2302,7 +2428,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
                 body = astcopy(body)
                 needcopy = false
             end
-            replace_getfield!(ast, body, vaname, newnames, sv, 1)
+            replace_getfield!(ast, body, vaname, newnames, (), sv, 1)
             args = vcat(args[1:na-1], newnames)
             na = length(args)
 
@@ -2331,12 +2457,14 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
         # inference step shortened our call args list, even
         # though we have too many arguments to actually
         # call this function
-        @assert isvarargtype(atypes[na])
         return NF
     end
 
     @assert na == length(argexprs)
 
+    if argexprs === e.args
+        argexprs = copy(argexprs)
+    end
     if needcopy
         body = astcopy(body)
     end
@@ -2357,7 +2485,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     end
 
     # see if each argument occurs only once in the body expression
-    stmts = []
+    stmts = Any[]
     stmts_free = true # true = all entries of stmts are effect_free
 
     # when 1 method matches the inferred types, there is still a chance
@@ -2374,7 +2502,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     end
 
     for i=na:-1:1 # stmts_free needs to be calculated in reverse-argument order
-        a = args[i]
+        args_i = args[i]
         aei = argexprs[i]
         aeitype = argtype = exprtype(aei,sv)
         needtypeassert = false
@@ -2418,7 +2546,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
         islocal = false # if the argument name is also used as a local variable,
                         # we need to keep it as a variable name
         for vi in vinflist
-            if vi[1] === a && vi[3] != 0
+            if vi[1] === args_i && vi[3] != 0
                 islocal = true
                 aeitype = tmerge(aeitype, vi[2])
                 if aeitype === Any
@@ -2434,12 +2562,12 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
             vnew1 = unique_name(enclosing_ast, ast)
             add_variable(enclosing_ast, vnew1, aeitype, !islocal)
             v1 = (aeitype===Any ? vnew1 : SymbolNode(vnew1,aeitype))
-            push!(spnames, a)
+            push!(spnames, args_i)
             push!(spvals, v1)
             vnew2 = unique_name(enclosing_ast, ast)
             v2 = (argtype===Any ? vnew2 : SymbolNode(vnew2,argtype))
-            unshift!(body.args, Expr(:(=), a, v2))
-            args[i] = a = vnew2
+            unshift!(body.args, Expr(:(=), args_i, v2))
+            args[i] = args_i = vnew2
             islocal = false
             aeitype = argtype
             affect_free = stmts_free
@@ -2460,7 +2588,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
             for j = length(body.args):-1:1
                 b = body.args[j]
                 if occ < 6
-                    occ += occurs_more(b, x->is(x,a), 6)
+                    occ += occurs_more(b, x->is(x,args_i), 6)
                 end
                 if occ > 0 && affect_free && !effect_free(b, sv, true) #TODO: we could short-circuit this test better by memoizing effect_free(b) in the for loop over i
                     affect_free = false
@@ -2490,7 +2618,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
             end
         end
         if incompletematch
-            unshift!(argexprs2, (argtype===Any ? a : SymbolNode(a,argtype)))
+            unshift!(argexprs2, (argtype===Any ? args_i : SymbolNode(a,argtype)))
         end
     end
     if incompletematch && partmatch.args[1] != false
@@ -2551,7 +2679,7 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
     lastexpr = pop!(body.args)
     if isa(lastexpr,LabelNode)
         push!(body.args, lastexpr)
-        push!(body.args, Expr(:call,:error,"fatal error in type inference"))
+        push!(body.args, Expr(:call, TopNode(:error), "fatal error in type inference"))
         lastexpr = nothing
     else
         @assert isa(lastexpr,Expr) "inference.jl:1774"
@@ -2584,6 +2712,20 @@ function inlineable(f::ANY, e::Expr, atype::ANY, sv::StaticVarInfo, enclosing_as
         expr = lastexpr.args[1]
     end
 
+    if length(stmts) == 1
+        # remove line number when inlining a single expression. see issue #13725
+        s = stmts[1]
+        if isa(s,Expr)&&is(s.head,:line) || isa(s,LineNumberNode)
+            pop!(stmts)
+        end
+    end
+
+    if !isempty(stmts) && !propagate_inbounds
+        # inlined statements are out-of-bounds by default
+        unshift!(stmts, Expr(:inbounds, false))
+        push!(stmts, Expr(:inbounds, :pop))
+    end
+
     if isa(expr,Expr)
         old_t = e.typ
         if old_t <: expr.typ
@@ -2605,10 +2747,17 @@ function inline_worthy(body::Expr, cost::Integer=1000) # precondition: 0 < cost;
         return false
     end
     symlim = 1000 + 5_000_000 ÷ cost
-    if length(body.args) < (symlim + 500) ÷ 1000
+    nargs = 0
+    for arg in body.args
+        if (!isa(arg, LineNumberNode) &&
+            !(isa(arg, Expr) && (arg::Expr).head === :line))
+            nargs += 1
+        end
+    end
+    if nargs < (symlim + 500) ÷ 1000
         symlim *= 16
         symlim ÷= 1000
-        if occurs_more(body, e->true, symlim) < symlim
+        if occurs_more(body, e->(!isa(e, LineNumberNode)), symlim) < symlim
             return true
         end
     end
@@ -2637,7 +2786,7 @@ function mk_getfield(texpr, i, T)
     e
 end
 
-function mk_tuplecall(args, sv::StaticVarInfo)
+function mk_tuplecall(args, sv::VarInfo)
     e = Expr(:call, top_tuple, args...)
     e.typ = tuple_tfunc(Tuple{Any[exprtype(x,sv) for x in args]...})
     e
@@ -2646,7 +2795,7 @@ end
 const corenumtype = Union{Int32,Int64,Float32,Float64}
 
 function inlining_pass(e::Expr, sv, ast)
-    if e.head == :method
+    if e.head === :method
         # avoid running the inlining pass on function definitions
         return (e,())
     end
@@ -2714,7 +2863,7 @@ function inlining_pass(e::Expr, sv, ast)
             end
             if isa(res[2],Array)
                 res2 = res[2]::Array{Any,1}
-                if length(res2) > 0
+                if !isempty(res2)
                     prepend!(stmts,res2)
                     if !has_stmts
                         for stmt in res2
@@ -2738,18 +2887,16 @@ function inlining_pass(e::Expr, sv, ast)
             end
         end
     end
-    f1 = f = isconstantfunc(arg1, sv)
+
+    f = isconstantfunc(arg1, sv)
     if !is(f,false)
-        f = _ieval(f)
-    end
-    if (!isa(f,Function) && !isa(f,IntrinsicFunction) &&
-        (f1 !== false || typeintersect(exprtype(arg1,sv), Function) === Bottom))
-        modu = (inference_stack::CallStack).mod
-        if !_iisdefined(:call)
-            return (e,stmts)
+        f = _ieval(f,sv); ft = abstract_eval_constant(f)
+    else
+        f = nothing
+        ft = exprtype(arg1, sv)
+        if !( isleaftype(ft) || ft<:Type )
+            return (e, stmts)
         end
-        f = _ieval(:call)
-        e.args = Any[is_global(sv,:call) ? (:call) : GlobalRef(modu, :call), e.args...]
     end
 
     if isdefined(Main, :Base) &&
@@ -2762,27 +2909,26 @@ function inlining_pass(e::Expr, sv, ast)
                                        exprtype(a1,sv) <: basenumtype)
                 if e.args[3]==2
                     e.args = Any[GlobalRef(Main.Base,:*), a1, a1]
-                    f = Main.Base.(:*)
+                    f = Main.Base.(:*); ft = abstract_eval_constant(f)
                 elseif e.args[3]==3
                     e.args = Any[GlobalRef(Main.Base,:*), a1, a1, a1]
-                    f = Main.Base.(:*)
+                    f = Main.Base.(:*); ft = abstract_eval_constant(f)
                 end
             end
         end
     end
 
     for ninline = 1:100
-        ata = Any[exprtype(e.args[i],sv) for i in 2:length(e.args)]
-        for a in ata
+        ata = cell(length(e.args))
+        ata[1] = ft
+        for i = 2:length(e.args)
+            a = exprtype(e.args[i], sv)
             (a === Bottom || isvarargtype(a)) && return (e, stmts)
+            ata[i] = a
         end
-        atype = Tuple{ata...}
-        if length(atype.parameters) > MAX_TUPLETYPE_LEN
-            atype = limit_tuple_type(atype)
-        end
-        res = inlineable(f, e, atype, sv, ast)
+        res = inlineable(f, ft, e, ata, sv, ast)
         if isa(res,Tuple)
-            if isa(res[2],Array)
+            if isa(res[2],Array) && !isempty(res[2])
                 append!(stmts,res[2])
             end
             res = res[1]
@@ -2793,7 +2939,7 @@ function inlining_pass(e::Expr, sv, ast)
             # to simplify long vararg lists as in multi-arg +
             if isa(res,Expr) && is_known_call(res, _apply, sv)
                 e = res::Expr
-                f = _apply
+                f = _apply; ft = abstract_eval_constant(f)
             else
                 return (res,stmts)
             end
@@ -2801,32 +2947,37 @@ function inlining_pass(e::Expr, sv, ast)
 
         if is(f,_apply)
             na = length(e.args)
-            newargs = cell(na-3)
-            for i = 4:na
+            newargs = cell(na-2)
+            for i = 3:na
                 aarg = e.args[i]
                 t = exprtype(aarg,sv)
                 if isa(aarg,Expr) && (is_known_call(aarg, tuple, sv) || is_known_call(aarg, svec, sv))
                     # apply(f,tuple(x,y,...)) => f(x,y,...)
-                    newargs[i-3] = aarg.args[2:end]
+                    newargs[i-2] = aarg.args[2:end]
                 elseif isa(aarg, Tuple)
-                    newargs[i-3] = Any[ QuoteNode(x) for x in aarg ]
-                elseif (t<:Tuple) && !isvatuple(t) && effect_free(aarg,sv,true)
+                    newargs[i-2] = Any[ QuoteNode(x) for x in aarg ]
+                elseif isa(t,DataType) && t.name===Tuple.name && !isvatuple(t) && effect_free(aarg,sv,true)
                     # apply(f,t::(x,y)) => f(t[1],t[2])
                     tp = t.parameters
-                    newargs[i-3] = Any[ mk_getfield(aarg,j,tp[j]) for j=1:length(tp) ]
+                    newargs[i-2] = Any[ mk_getfield(aarg,j,tp[j]) for j=1:length(tp) ]
                 else
                     # not all args expandable
                     return (e,stmts)
                 end
             end
-            e.args = [Any[e.args[3]]; newargs...]
+            e.args = [Any[e.args[2]]; newargs...]
 
             # now try to inline the simplified call
             f = isconstantfunc(e.args[1], sv)
-            if f===false
-                return (e,stmts)
+            if !is(f,false)
+                f = _ieval(f,sv); ft = abstract_eval_constant(f)
+            else
+                f = nothing
+                ft = exprtype(e.args[1], sv)
+                if !( isleaftype(ft) || ft<:Type )
+                    return (e,stmts)
+                end
             end
-            f = _ieval(f)
         else
             return (e,stmts)
         end
@@ -2908,15 +3059,15 @@ function is_known_call(e::Expr, func, sv)
         return false
     end
     f = isconstantfunc(e.args[1], sv)
-    return !is(f,false) && is(_ieval(f), func)
+    return !is(f,false) && is(_ieval(f,sv), func)
 end
 
-function is_known_call_p(e::Expr, pred::Function, sv)
+function is_known_call_p(e::Expr, pred, sv)
     if e.head !== :call
         return false
     end
     f = isconstantfunc(e.args[1], sv)
-    return !is(f,false) && pred(_ieval(f))
+    return !is(f,false) && pred(_ieval(f,sv))
 end
 
 function is_var_assigned(ast, v)
@@ -2947,7 +3098,7 @@ function remove_redundant_temp_vars(ast, sa)
     body = ast.args[3]
     for (v,init) in sa
         if ((isa(init,Symbol) || isa(init,SymbolNode)) &&
-            any(vi->symequal(vi[1],init), varinfo) &&
+            _any(vi->symequal(vi[1],init), varinfo) &&
             !is_var_assigned(ast, init))
 
             # this transformation is not valid for vars used before def.
@@ -3032,28 +3183,27 @@ symequal(x::Symbol    , y::SymbolNode) = is(x,y.name)
 symequal(x::GenSym    , y::GenSym)     = is(x.id,y.id)
 symequal(x::ANY       , y::ANY)        = is(x,y)
 
-function occurs_outside_getfield(e::ANY, sym::ANY, sv::StaticVarInfo, tuplen::Int)
+function occurs_outside_getfield(e::ANY, sym::ANY, sv::VarInfo, field_count, field_names)
     if is(e, sym) || (isa(e, SymbolNode) && is(e.name, sym))
         return true
     end
     if isa(e,Expr)
         e = e::Expr
         if is_known_call(e, getfield, sv) && symequal(e.args[2],sym)
-            targ = e.args[2]
-            if !(exprtype(targ,sv) <: Tuple)
-                return true
-            end
             idx = e.args[3]
-            if !isa(idx,Int) || !(1 <= idx <= tuplen)
-                return true
+            if isa(idx,QuoteNode) && (idx.value in field_names)
+                return false
             end
-            return false
+            if isa(idx,Int) && (1 <= idx <= field_count)
+                return false
+            end
+            return true
         end
         if is(e.head,:(=))
-            return occurs_outside_getfield(e.args[2], sym, sv, tuplen)
+            return occurs_outside_getfield(e.args[2], sym, sv, field_count, field_names)
         else
             for a in e.args
-                if occurs_outside_getfield(a, sym, sv, tuplen)
+                if occurs_outside_getfield(a, sym, sv, field_count, field_names)
                     return true
                 end
             end
@@ -3062,37 +3212,55 @@ function occurs_outside_getfield(e::ANY, sym::ANY, sv::StaticVarInfo, tuplen::In
     return false
 end
 
-# replace getfield(tuple(exprs...), i) with exprs[i]
+# removes inbounds metadata if we never encounter an inbounds=true or
+# boundscheck context in the method body
+function inbounds_meta_elim_pass(e::Expr)
+    if findfirst(x -> isa(x, Expr) &&
+                      ((x.head === :inbounds && x.args[1] == true) || x.head === :boundscheck),
+                 e.args) == 0
+        filter!(x -> !(isa(x, Expr) && x.head === :inbounds), e.args)
+    end
+end
+
+# does the same job as alloc_elim_pass for allocations inline in getfields
+# TODO can probably be removed when we switch to a linear IR
 function getfield_elim_pass(e::Expr, sv)
     for i = 1:length(e.args)
         ei = e.args[i]
         if isa(ei,Expr)
             getfield_elim_pass(ei, sv)
             if is_known_call(ei, getfield, sv) && length(ei.args)==3 &&
-                isa(ei.args[3],Int)
+                (isa(ei.args[3],Int) || isa(ei.args[3],QuoteNode))
                 e1 = ei.args[2]
                 j = ei.args[3]
                 if isa(e1,Expr)
-                    if is_known_call(e1, tuple, sv) && (1 <= j < length(e1.args))
-                        ok = true
-                        for k = 2:length(e1.args)
-                            k == j+1 && continue
-                            if !effect_free(e1.args[k], sv, true)
-                                ok = false; break
-                            end
+                    alloc = is_immutable_allocation(e1, sv)
+                    if !is(alloc, false)
+                        flen, fnames = alloc
+                        if isa(j,QuoteNode)
+                            j = findfirst(fnames, j.value)
                         end
-                        if ok
-                            e.args[i] = e1.args[j+1]
+                        if 1 <= j <= flen
+                            ok = true
+                            for k = 2:length(e1.args)
+                                k == j+1 && continue
+                                if !effect_free(e1.args[k], sv, true)
+                                    ok = false; break
+                                end
+                            end
+                            if ok
+                                e.args[i] = e1.args[j+1]
+                            end
                         end
                     end
-                elseif isa(e1,Tuple) && (1 <= j <= length(e1))
+                elseif isa(e1,Tuple) && isa(j,Int) && (1 <= j <= length(e1))
                     e1j = e1[j]
                     if !(isa(e1j,Number) || isa(e1j,AbstractString) || isa(e1j,Tuple) ||
                          isa(e1j,Type))
                         e1j = QuoteNode(e1j)
                     end
                     e.args[i] = e1j
-                elseif isa(e1,QuoteNode) && isa(e1.value,Tuple) && (1 <= j <= length(e1.value))
+                elseif isa(e1,QuoteNode) && isa(e1.value,Tuple) && isa(j,Int) && (1 <= j <= length(e1.value))
                     e.args[i] = QuoteNode(e1.value[j])
                 end
             end
@@ -3100,8 +3268,34 @@ function getfield_elim_pass(e::Expr, sv)
     end
 end
 
-# eliminate allocation of unnecessary tuples
-function tuple_elim_pass(ast::Expr, sv::StaticVarInfo)
+# check if e is a successful allocation of an immutable struct
+# if it is, returns (n,f) such that it is always valid to call
+# getfield(..., 1 <= x <= n) or getfield(..., x in f) on the result
+function is_immutable_allocation(e :: ANY, sv::VarInfo)
+    isa(e, Expr) || return false
+    if is_known_call(e, tuple, sv)
+        return (length(e.args)-1,())
+    elseif e.head === :new
+        typ = exprtype(e, sv)
+        if isleaftype(typ) && !typ.mutable
+            @assert(isa(typ,DataType))
+            nf = length(e.args)-1
+            names = fieldnames(typ)
+            @assert(nf <= nfields(typ))
+            if nf < nfields(typ)
+                # some fields were left undef
+                # we could potentially propagate Bottom
+                # for pointer fields
+                names = names[1:nf]
+            end
+            return (nf, names)
+        end
+    end
+    false
+end
+# eliminate allocation of unnecessary immutables
+# that are only used as arguments to safe getfield calls
+function alloc_elim_pass(ast::Expr, sv::VarInfo)
     bexpr = ast.args[3]::Expr
     body = (ast.args[3].args)::Array{Any,1}
     vs = find_sa_vars(ast)
@@ -3115,10 +3309,11 @@ function tuple_elim_pass(ast::Expr, sv::StaticVarInfo)
         end
         var = e.args[1]
         rhs = e.args[2]
-        if isa(rhs,Expr) && is_known_call(rhs, tuple, sv)
+        alloc = is_immutable_allocation(rhs, sv)
+        if !is(alloc,false)
+            nv, field_names = alloc
             tup = rhs.args
-            nv = length(tup)-1
-            if occurs_outside_getfield(bexpr, var, sv, nv) || !is_local(sv, var)
+            if occurs_outside_getfield(bexpr, var, sv, nv, field_names) || !is_local(sv, var)
                 i += 1
                 continue
             end
@@ -3141,14 +3336,14 @@ function tuple_elim_pass(ast::Expr, sv::StaticVarInfo)
                 end
             end
             i += n_ins
-            replace_getfield!(ast, bexpr, var, vals, sv, i)
+            replace_getfield!(ast, bexpr, var, vals, field_names, sv, i)
         else
             i += 1
         end
     end
 end
 
-function replace_getfield!(ast, e::ANY, tupname, vals, sv, i0)
+function replace_getfield!(ast, e::ANY, tupname, vals, field_names, sv, i0)
     if !isa(e,Expr)
         return
     end
@@ -3156,7 +3351,14 @@ function replace_getfield!(ast, e::ANY, tupname, vals, sv, i0)
         a = e.args[i]
         if isa(a,Expr) && is_known_call(a, getfield, sv) &&
             symequal(a.args[2],tupname)
-            val = vals[a.args[3]]
+            idx = if isa(a.args[3], Int)
+                a.args[3]
+            else
+                @assert isa(a.args[3], QuoteNode)
+                findfirst(field_names, a.args[3].value)
+            end
+            @assert(idx > 0) # clients should check that all getfields are valid
+            val = vals[idx]
             # original expression might have better type info than
             # the tuple element expression that's replacing it.
             if isa(val,SymbolNode)
@@ -3179,7 +3381,7 @@ function replace_getfield!(ast, e::ANY, tupname, vals, sv, i0)
             end
             e.args[i] = val
         else
-            replace_getfield!(ast, a, tupname, vals, sv, 1)
+            replace_getfield!(ast, a, tupname, vals, field_names, sv, 1)
         end
     end
 end
diff --git a/base/initdefs.jl b/base/initdefs.jl
new file mode 100644
index 0000000000000..9c0e093fe9e2b
--- /dev/null
+++ b/base/initdefs.jl
@@ -0,0 +1,93 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+## initdefs.jl - initialization and runtime management definitions
+
+PROGRAM_FILE = UTF8String("")
+const ARGS = UTF8String[]
+
+exit(n) = ccall(:jl_exit, Void, (Int32,), n)
+exit() = exit(0)
+quit() = exit()
+
+const roottask = current_task()
+
+is_interactive = false
+isinteractive() = (is_interactive::Bool)
+
+const LOAD_PATH = ByteString[]
+const LOAD_CACHE_PATH = ByteString[]
+function init_load_path()
+    vers = "v$(VERSION.major).$(VERSION.minor)"
+    if haskey(ENV,"JULIA_LOAD_PATH")
+        prepend!(LOAD_PATH, split(ENV["JULIA_LOAD_PATH"], @windows? ';' : ':'))
+    end
+    push!(LOAD_PATH,abspath(JULIA_HOME,"..","local","share","julia","site",vers))
+    push!(LOAD_PATH,abspath(JULIA_HOME,"..","share","julia","site",vers))
+    push!(LOAD_CACHE_PATH,abspath(JULIA_HOME,"..","usr","lib","julia")) #TODO: fixme
+end
+
+# initialize the local proc network address / port
+function init_bind_addr()
+    opts = JLOptions()
+    if opts.bindto != C_NULL
+        bind_to = split(bytestring(opts.bindto), ":")
+        bind_addr = string(parse(IPAddr, bind_to[1]))
+        if length(bind_to) > 1
+            bind_port = parse(Int,bind_to[2])
+        else
+            bind_port = 0
+        end
+    else
+        bind_port = 0
+        try
+            bind_addr = string(getipaddr())
+        catch
+            # All networking is unavailable, initialize bind_addr to the loopback address
+            # Will cause an exception to be raised only when used.
+            bind_addr = "127.0.0.1"
+        end
+    end
+    global LPROC
+    LPROC.bind_addr = bind_addr
+    LPROC.bind_port = UInt16(bind_port)
+end
+
+function early_init()
+    global const JULIA_HOME = ccall(:jl_get_julia_home, Any, ())
+    # make sure OpenBLAS does not set CPU affinity (#1070, #9639)
+    ENV["OPENBLAS_MAIN_FREE"] = get(ENV, "OPENBLAS_MAIN_FREE",
+                                    get(ENV, "GOTOBLAS_MAIN_FREE", "1"))
+    if CPU_CORES > 8 && !("OPENBLAS_NUM_THREADS" in keys(ENV)) && !("OMP_NUM_THREADS" in keys(ENV))
+        # Prevent openblas from starting too many threads, unless/until specifically requested
+        ENV["OPENBLAS_NUM_THREADS"] = 8
+    end
+end
+
+function init_parallel()
+    start_gc_msgs_task()
+    atexit(terminate_all_workers)
+
+    init_bind_addr()
+
+    # start in "head node" mode, if worker, will override later.
+    global PGRP
+    global LPROC
+    LPROC.id = 1
+    assert(isempty(PGRP.workers))
+    register_worker(LPROC)
+end
+
+const atexit_hooks = []
+
+atexit(f::Function) = (unshift!(atexit_hooks, f); nothing)
+
+function _atexit()
+    for f in atexit_hooks
+        try
+            f()
+        catch err
+            show(STDERR, err)
+            println(STDERR)
+        end
+    end
+end
diff --git a/base/int.jl b/base/int.jl
index 2ace89965c3dd..db5207dbe66d5 100644
--- a/base/int.jl
+++ b/base/int.jl
@@ -2,23 +2,35 @@
 
 ## integer arithmetic ##
 
-const IntTypes = (Int8, UInt8, Int16, UInt16, Int32, UInt32,
-                  Int64, UInt64, Int128, UInt128)
+# The tuples and types that do not include 128 bit sizes are necessary to handle
+# certain issues on 32-bit machines, and also to simplify promotion rules, as
+# they are also used elsewhere where Int128/UInt128 support is separated out,
+# such as in hashing2.jl
+
+const BitSigned64_types   = (Int8,Int16,Int32,Int64)
+const BitUnsigned64_types = (UInt8,UInt16,UInt32,UInt64)
+const BitInteger64_types  = (BitSigned64_types...,BitUnsigned64_types...)
+const BitSigned_types     = (BitSigned64_types...,Int128)
+const BitUnsigned_types   = (BitUnsigned64_types...,UInt128)
+const BitInteger_types    = (BitSigned_types...,BitUnsigned_types...)
+
+typealias BitSigned64   Union{BitSigned64_types...}
+typealias BitUnsigned64 Union{BitUnsigned64_types...}
+typealias BitInteger64  Union{BitInteger64_types...}
+typealias BitSigned     Union{BitSigned_types...}
+typealias BitUnsigned   Union{BitUnsigned_types...}
+typealias BitInteger    Union{BitInteger_types...}
+typealias BitSigned64T  Union{Type{Int8},Type{Int16},Type{Int32},Type{Int64}}
+typealias BitUnsigned64T Union{Type{UInt8},Type{UInt16},Type{UInt32},Type{UInt64}}
 
-+(x::Int, y::Int) = box(Int,add_int(unbox(Int,x),unbox(Int,y)))
-<(x::Int, y::Int) = slt_int(unbox(Int,x),unbox(Int,y))
+## integer comparisons ##
 
-for T in IntTypes
-    @eval begin
-        -(x::$T) = box($T,neg_int(unbox($T,x)))
+<{T<:BitSigned}(x::T, y::T)  = slt_int(unbox(T,x),unbox(T,y))
 
-        if !($T === Int)  # don't overwrite definition from line 8
-            +(x::$T, y::$T) = box($T, add_int(unbox($T,x),unbox($T,y)))
-        end
-        -(x::$T, y::$T) = box($T, sub_int(unbox($T,x),unbox($T,y)))
-        *(x::$T, y::$T) = box($T, mul_int(unbox($T,x),unbox($T,y)))
-    end
-end
+-{T<:BitInteger}(x::T)       = box(T, neg_int(unbox(T,x)))
+-{T<:BitInteger}(x::T, y::T) = box(T, sub_int(unbox(T,x),unbox(T,y)))
++{T<:BitInteger}(x::T, y::T) = box(T, add_int(unbox(T,x),unbox(T,y)))
+*{T<:BitInteger}(x::T, y::T) = box(T, mul_int(unbox(T,x),unbox(T,y)))
 
 /(x::Integer, y::Integer) = float(x)/float(y)
 inv(x::Integer) = float(one(x))/float(x)
@@ -29,20 +41,33 @@ iseven(n::Integer) = !isodd(n)
 signbit(x::Integer) = x < 0
 signbit(x::Unsigned) = false
 
-for T in (Int8,Int16,Int32,Int64,Int128)
-    @eval flipsign(x::$T, y::$T) = box($T,flipsign_int(unbox($T,x),unbox($T,y)))
-end
+flipsign{T<:BitSigned}(x::T, y::T) = box(T,flipsign_int(unbox(T,x),unbox(T,y)))
 
-flipsign(x::Signed, y::Signed)  = flipsign(promote(x,y)...)
+flipsign(x::Signed, y::Signed)  = convert(typeof(x), flipsign(promote(x,y)...))
+flipsign(x::Signed, y::Float16) = flipsign(x, reinterpret(Int16,y))
 flipsign(x::Signed, y::Float32) = flipsign(x, reinterpret(Int32,y))
 flipsign(x::Signed, y::Float64) = flipsign(x, reinterpret(Int64,y))
 flipsign(x::Signed, y::Real)    = flipsign(x, -oftype(x,signbit(y)))
 
 copysign(x::Signed, y::Signed)  = flipsign(x, x$y)
+copysign(x::Signed, y::Float16) = copysign(x, reinterpret(Int16,y))
 copysign(x::Signed, y::Float32) = copysign(x, reinterpret(Int32,y))
 copysign(x::Signed, y::Float64) = copysign(x, reinterpret(Int64,y))
 copysign(x::Signed, y::Real)    = copysign(x, -oftype(x,signbit(y)))
 
+"""
+    abs(x)
+
+The absolute value of `x`.
+
+When `abs` is applied to signed integers, overflow may occur,
+resulting in the return of a negative value. This overflow occurs only
+when `abs` is applied to the minimum representable value of a signed
+integer. That is, when `x == typemin(typeof(x))`, `abs(x) == x < 0`,
+not `-x` as might be expected.
+"""
+function abs end
+
 abs(x::Unsigned) = x
 abs(x::Signed) = flipsign(x,x)
 
@@ -69,118 +94,100 @@ mod(x::Unsigned, y::Signed) = rem(y+signed(rem(x,y)),y)
 cld(x::Signed, y::Unsigned) = div(x,y)+(!signbit(x)&(rem(x,y)!=0))
 cld(x::Unsigned, y::Signed) = div(x,y)+(!signbit(y)&(rem(x,y)!=0))
 
-# Don't promote integers for div/rem/mod since there no danger of overflow,
+# Don't promote integers for div/rem/mod since there is no danger of overflow,
 # while there is a substantial performance penalty to 64-bit promotion.
-const Signed64Types = (Int8,Int16,Int32,Int64)
-const Unsigned64Types = (UInt8,UInt16,UInt32,UInt64)
-typealias Integer64 Union{Signed64Types...,Unsigned64Types...}
-
-for T in Signed64Types
-    @eval div(x::$T, y::$T) = box($T,sdiv_int(unbox($T,x),unbox($T,y)))
-    @eval rem(x::$T, y::$T) = box($T,srem_int(unbox($T,x),unbox($T,y)))
-    @eval mod(x::$T, y::$T) = box($T,smod_int(unbox($T,x),unbox($T,y)))
-end
-for T in Unsigned64Types
-    @eval div(x::$T, y::$T) = box($T,udiv_int(unbox($T,x),unbox($T,y)))
-    @eval rem(x::$T, y::$T) = box($T,urem_int(unbox($T,x),unbox($T,y)))
-end
+div{T<:BitSigned64}(x::T, y::T) = box(T,checked_sdiv_int(unbox(T,x),unbox(T,y)))
+rem{T<:BitSigned64}(x::T, y::T) = box(T,checked_srem_int(unbox(T,x),unbox(T,y)))
+div{T<:BitUnsigned64}(x::T, y::T) = box(T,checked_udiv_int(unbox(T,x),unbox(T,y)))
+rem{T<:BitUnsigned64}(x::T, y::T) = box(T,checked_urem_int(unbox(T,x),unbox(T,y)))
 
+# x == fld(x,y)*y + mod(x,y)
 mod{T<:Unsigned}(x::T, y::T) = rem(x,y)
+function mod{T<:Integer}(x::T, y::T)
+    y == -1 && return T(0)   # avoid potential overflow in fld
+    x - fld(x,y)*y
+ end
 
+# fld(x,y) == div(x,y) - ((x>=0) != (y>=0) && rem(x,y) != 0 ? 1 : 0)
 fld{T<:Unsigned}(x::T, y::T) = div(x,y)
-fld{T<:Integer }(x::T, y::T) = div(x,y)-(signbit(x$y)&(rem(x,y)!=0))
+function fld{T<:Integer}(x::T, y::T)
+    d = div(x,y)
+    d - (signbit(x$y) & (d*y!=x))
+end
 
-cld{T<:Unsigned}(x::T, y::T) = div(x,y)+(rem(x,y)!=0)
-cld{T<:Integer }(x::T, y::T) = div(x,y)+(!signbit(x$y)&(rem(x,y)!=0))
+# cld(x,y) = div(x,y) + ((x>0) == (y>0) && rem(x,y) != 0 ? 1 : 0)
+function cld{T<:Unsigned}(x::T, y::T)
+    d = div(x,y)
+    d + (d*y!=x)
+end
+function cld{T<:Integer}(x::T, y::T)
+    d = div(x,y)
+    d + (((x>0) == (y>0)) & (d*y!=x))
+end
 
 ## integer bitwise operations ##
 
-for T in IntTypes
-    @eval begin
-        ~(x::$T) = box($T,not_int(unbox($T,x)))
+(~){T<:BitInteger}(x::T)       = box(T,not_int(unbox(T,x)))
+(&){T<:BitInteger}(x::T, y::T) = box(T,and_int(unbox(T,x),unbox(T,y)))
+(|){T<:BitInteger}(x::T, y::T) = box(T, or_int(unbox(T,x),unbox(T,y)))
+($){T<:BitInteger}(x::T, y::T) = box(T,xor_int(unbox(T,x),unbox(T,y)))
 
-        (&)(x::$T, y::$T) = box($T,and_int(unbox($T,x),unbox($T,y)))
-        (|)(x::$T, y::$T) = box($T, or_int(unbox($T,x),unbox($T,y)))
-        ($)(x::$T, y::$T) = box($T,xor_int(unbox($T,x),unbox($T,y)))
-    end
-    for S in IntTypes
-        (S === Int128 || S === UInt128) && continue
-        @eval begin
-            <<(x::$T,  y::$S) = box($T, shl_int(unbox($T,x),unbox($S,y)))
-            >>>(x::$T, y::$S) = box($T,lshr_int(unbox($T,x),unbox($S,y)))
-        end
-        if issubtype(T,Unsigned)
-            @eval >>(x::$T, y::$S) = box($T,lshr_int(unbox($T,x),unbox($S,y)))
-        else
-            @eval >>(x::$T, y::$S) = box($T,ashr_int(unbox($T,x),unbox($S,y)))
-        end
-    end
-end
+>>{T<:BitSigned,S<:BitInteger64}(x::T, y::S)   = box(T,ashr_int(unbox(T,x),unbox(S,y)))
+>>{T<:BitUnsigned,S<:BitInteger64}(x::T, y::S) = box(T,lshr_int(unbox(T,x),unbox(S,y)))
+<<{T<:BitInteger,S<:BitInteger64}(x::T,  y::S) = box(T, shl_int(unbox(T,x),unbox(S,y)))
+>>>{T<:BitInteger,S<:BitInteger64}(x::T, y::S) = box(T,lshr_int(unbox(T,x),unbox(S,y)))
+
+bswap{T<:Union{Int8,UInt8}}(x::T) = x
+bswap{T<:Union{Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128}}(x::T) =
+    box(T,bswap_int(unbox(T,x)))
+
+count_ones{T<:BitInteger}(x::T) = Int(box(T,ctpop_int(unbox(T,x))))
+leading_zeros{T<:BitInteger}(x::T) = Int(box(T,ctlz_int(unbox(T,x))))
+trailing_zeros{T<:BitInteger}(x::T) = Int(box(T,cttz_int(unbox(T,x))))
 
-bswap(x::Int8)    = x
-bswap(x::UInt8)   = x
-bswap(x::Int16)   = box(Int16,bswap_int(unbox(Int16,x)))
-bswap(x::UInt16)  = box(UInt16,bswap_int(unbox(UInt16,x)))
-bswap(x::Int32)   = box(Int32,bswap_int(unbox(Int32,x)))
-bswap(x::UInt32)  = box(UInt32,bswap_int(unbox(UInt32,x)))
-bswap(x::Int64)   = box(Int64,bswap_int(unbox(Int64,x)))
-bswap(x::UInt64)  = box(UInt64,bswap_int(unbox(UInt64,x)))
-bswap(x::Int128)  = box(Int128,bswap_int(unbox(Int128,x)))
-bswap(x::UInt128) = box(UInt128,bswap_int(unbox(UInt128,x)))
-
-for T in IntTypes
-    @eval begin
-        count_ones(x::$T)     = Int(box($T,ctpop_int(unbox($T,x))))
-        leading_zeros(x::$T)  = Int(box($T,ctlz_int(unbox($T,x))))
-        trailing_zeros(x::$T) = Int(box($T,cttz_int(unbox($T,x))))
-    end
-end
 count_zeros(  x::Integer) = count_ones(~x)
 leading_ones( x::Integer) = leading_zeros(~x)
 trailing_ones(x::Integer) = trailing_zeros(~x)
 
 ## integer comparisons ##
 
-for T in IntTypes
-    if issubtype(T,Signed)
-        if !(T === Int)  # don't overwrite definition from line 9
-            @eval <( x::$T, y::$T) = slt_int(unbox($T,x),unbox($T,y))
-        end
-        @eval <=(x::$T, y::$T) = sle_int(unbox($T,x),unbox($T,y))
-    else
-        @eval <( x::$T, y::$T) = ult_int(unbox($T,x),unbox($T,y))
-        @eval <=(x::$T, y::$T) = ule_int(unbox($T,x),unbox($T,y))
-    end
-end
+<{T<:BitUnsigned}(x::T, y::T)  = ult_int(unbox(T,x),unbox(T,y))
+<={T<:BitSigned}(x::T, y::T)   = sle_int(unbox(T,x),unbox(T,y))
+<={T<:BitUnsigned}(x::T, y::T) = ule_int(unbox(T,x),unbox(T,y))
 
 ==(x::Signed,   y::Unsigned) = (x >= 0) & (unsigned(x) == y)
 ==(x::Unsigned, y::Signed  ) = (y >= 0) & (x == unsigned(y))
 <( x::Signed,   y::Unsigned) = (x <  0) | (unsigned(x) <  y)
-<( x::Unsigned, y::Signed  ) = (y >  0) & (x <  unsigned(y))
-<=(x::Signed,   y::Unsigned) = (x <= 0) | (unsigned(x) <= y)
+<( x::Unsigned, y::Signed  ) = (y >= 0) & (x <  unsigned(y))
+<=(x::Signed,   y::Unsigned) = (x <  0) | (unsigned(x) <= y)
 <=(x::Unsigned, y::Signed  ) = (y >= 0) & (x <= unsigned(y))
 
 ## integer conversions ##
 
-for to in tuple(IntTypes...), from in tuple(IntTypes...,Bool)
+for to in BitInteger_types, from in (BitInteger_types...,Bool)
     if !(to === from)
         if to.size < from.size
             if issubtype(to, Signed)
                 if issubtype(from, Unsigned)
-                    @eval convert(::Type{$to}, x::($from)) = box($to,checked_trunc_sint($to,check_top_bit(unbox($from,x))))
+                    @eval convert(::Type{$to}, x::($from)) =
+                        box($to,checked_trunc_sint($to,check_top_bit(unbox($from,x))))
                 else
-                    @eval convert(::Type{$to}, x::($from)) = box($to,checked_trunc_sint($to,unbox($from,x)))
+                    @eval convert(::Type{$to}, x::($from)) =
+                        box($to,checked_trunc_sint($to,unbox($from,x)))
                 end
             else
-                @eval convert(::Type{$to}, x::($from)) = box($to,checked_trunc_uint($to,unbox($from,x)))
+                @eval convert(::Type{$to}, x::($from)) =
+                    box($to,checked_trunc_uint($to,unbox($from,x)))
             end
             @eval rem(x::($from), ::Type{$to}) = box($to,trunc_int($to,unbox($from,x)))
         elseif from.size < to.size || from === Bool
             if issubtype(from, Signed)
                 if issubtype(to, Unsigned)
-                    @eval convert(::Type{$to}, x::($from)) = box($to,sext_int($to,check_top_bit(unbox($from,x))))
+                    @eval convert(::Type{$to}, x::($from)) =
+                        box($to,sext_int($to,check_top_bit(unbox($from,x))))
                 else
-                    @eval convert(::Type{$to}, x::($from)) = box($to,sext_int($to,unbox($from,x)))
+                    @eval convert(::Type{$to}, x::($from)) =
+                        box($to,sext_int($to,unbox($from,x)))
                 end
                 @eval rem(x::($from), ::Type{$to}) = box($to,sext_int($to,unbox($from,x)))
             else
@@ -203,46 +210,21 @@ rem{T<:Integer}(x::T, ::Type{T}) = x
 rem(x::Integer, ::Type{Bool}) = ((x&1)!=0)
 mod{T<:Integer}(x::Integer, ::Type{T}) = rem(x, T)
 
-for to in (Int8, Int16, Int32, Int64)
-    @eval begin
-        convert(::Type{$to}, x::Float32) = box($to,checked_fptosi($to,unbox(Float32,x)))
-        convert(::Type{$to}, x::Float64) = box($to,checked_fptosi($to,unbox(Float64,x)))
-    end
-end
+convert{Tf<:Union{Float32,Float64}}(T::BitSigned64T, x::Tf) =
+    box(T,checked_fptosi(T,unbox(Tf,x)))
+convert{Tf<:Union{Float32,Float64}}(T::BitUnsigned64T, x::Tf) =
+    box(T,checked_fptoui(T,unbox(Tf,x)))
 
-for to in (UInt8, UInt16, UInt32, UInt64)
-    @eval begin
-        convert(::Type{$to}, x::Float32) = box($to,checked_fptoui($to,unbox(Float32,x)))
-        convert(::Type{$to}, x::Float64) = box($to,checked_fptoui($to,unbox(Float64,x)))
-    end
-end
+convert{Tf<:Union{Float32,Float64}}(T::Union{Type{Int128},Type{UInt128}}, x::Tf) =
+    (isinteger(x) || throw(InexactError()) ; trunc(T,x))
 
-for Ti in (Int128,UInt128)
-    for Tf in (Float32,Float64)
-        @eval function convert(::Type{$Ti},x::$Tf)
-            isinteger(x) || throw(InexactError())
-            trunc($Ti,x)
-        end
-    end
+for (Ts, Tu) in ((Int8, UInt8), (Int16, UInt16), (Int32, UInt32), (Int64, UInt64), (Int128, UInt128))
+    @eval convert(::Type{Signed}, x::$Tu) = convert($Ts, x)
+    @eval convert(::Type{Unsigned}, x::$Ts) = convert($Tu, x)
 end
 
-convert(::Type{Signed}, x::UInt8  ) = convert(Int8,x)
-convert(::Type{Signed}, x::UInt16 ) = convert(Int16,x)
-convert(::Type{Signed}, x::UInt32 ) = convert(Int32,x)
-convert(::Type{Signed}, x::UInt64 ) = convert(Int64,x)
-convert(::Type{Signed}, x::UInt128) = convert(Int128,x)
-convert(::Type{Signed}, x::Float32) = convert(Int,x)
-convert(::Type{Signed}, x::Float64) = convert(Int,x)
-convert(::Type{Signed}, x::Bool)    = convert(Int,x)
-
-convert(::Type{Unsigned}, x::Int8   ) = convert(UInt8,x)
-convert(::Type{Unsigned}, x::Int16  ) = convert(UInt16,x)
-convert(::Type{Unsigned}, x::Int32  ) = convert(UInt32,x)
-convert(::Type{Unsigned}, x::Int64  ) = convert(UInt64,x)
-convert(::Type{Unsigned}, x::Int128 ) = convert(UInt128,x)
-convert(::Type{Unsigned}, x::Float32) = convert(UInt,x)
-convert(::Type{Unsigned}, x::Float64) = convert(UInt,x)
-convert(::Type{Unsigned}, x::Bool)    = convert(UInt,x)
+convert{T<:Union{Float32, Float64, Bool}}(::Type{Signed}, x::T) = convert(Int,x)
+convert{T<:Union{Float32, Float64, Bool}}(::Type{Unsigned}, x::T) = convert(UInt,x)
 
 convert(::Type{Integer}, x::Integer) = x
 convert(::Type{Integer}, x::Real) = convert(Signed,x)
@@ -278,67 +260,30 @@ end
 
 ## system word size ##
 
-const WORD_SIZE = Int(Int.size)*8
+const WORD_SIZE = convert(Int, Int.size)*8
 
 ## integer promotions ##
 
-promote_rule(::Type{Int16},  ::Type{Int8} ) = Int16
-promote_rule(::Type{Int32},  ::Type{Int8} ) = Int32
-promote_rule(::Type{Int32},  ::Type{Int16}) = Int32
-promote_rule(::Type{Int64},  ::Type{Int8} ) = Int64
-promote_rule(::Type{Int64},  ::Type{Int16}) = Int64
-promote_rule(::Type{Int64},  ::Type{Int32}) = Int64
-promote_rule(::Type{Int128}, ::Type{Int8} ) = Int128
-promote_rule(::Type{Int128}, ::Type{Int16}) = Int128
-promote_rule(::Type{Int128}, ::Type{Int32}) = Int128
-promote_rule(::Type{Int128}, ::Type{Int64}) = Int128
-
-promote_rule(::Type{UInt16},  ::Type{UInt8} ) = UInt16
-promote_rule(::Type{UInt32},  ::Type{UInt8} ) = UInt32
-promote_rule(::Type{UInt32},  ::Type{UInt16}) = UInt32
-promote_rule(::Type{UInt64},  ::Type{UInt8} ) = UInt64
-promote_rule(::Type{UInt64},  ::Type{UInt16}) = UInt64
-promote_rule(::Type{UInt64},  ::Type{UInt32}) = UInt64
-promote_rule(::Type{UInt128}, ::Type{UInt8} ) = UInt128
-promote_rule(::Type{UInt128}, ::Type{UInt16}) = UInt128
-promote_rule(::Type{UInt128}, ::Type{UInt32}) = UInt128
-promote_rule(::Type{UInt128}, ::Type{UInt64}) = UInt128
-
-promote_rule(::Type{UInt8}, ::Type{Int8}  ) = Int
-promote_rule(::Type{UInt8}, ::Type{Int16} ) = Int
-promote_rule(::Type{UInt8}, ::Type{Int32} ) = Int
-promote_rule(::Type{UInt8}, ::Type{Int64} ) = Int64
-promote_rule(::Type{UInt8}, ::Type{Int128}) = Int128
-
-promote_rule(::Type{UInt16}, ::Type{Int8}  ) = Int
-promote_rule(::Type{UInt16}, ::Type{Int16} ) = Int
-promote_rule(::Type{UInt16}, ::Type{Int32} ) = Int
-promote_rule(::Type{UInt16}, ::Type{Int64} ) = Int64
-promote_rule(::Type{UInt16}, ::Type{Int128}) = Int128
-
-if WORD_SIZE == 64
-    promote_rule(::Type{UInt32}, ::Type{Int8} ) = Int
-    promote_rule(::Type{UInt32}, ::Type{Int16}) = Int
-    promote_rule(::Type{UInt32}, ::Type{Int32}) = Int
-else
-    promote_rule(::Type{UInt32}, ::Type{Int8} ) = UInt
-    promote_rule(::Type{UInt32}, ::Type{Int16}) = UInt
-    promote_rule(::Type{UInt32}, ::Type{Int32}) = UInt
+promote_rule(::Type{Int8}, ::Type{Int16})   = Int16
+promote_rule(::Type{UInt8}, ::Type{UInt16}) = UInt16
+promote_rule{T<:Union{Int8,Int16}}(::Type{Int32}, ::Type{T})    = Int32
+promote_rule{T<:Union{UInt8,UInt16}}(::Type{UInt32}, ::Type{T}) = UInt32
+promote_rule{T<:Union{Int8,Int16,Int32}}(::Type{Int64}, ::Type{T})     = Int64
+promote_rule{T<:Union{UInt8,UInt16,UInt32}}(::Type{UInt64}, ::Type{T}) = UInt64
+promote_rule{T<:BitSigned64}(::Type{Int128}, ::Type{T})    = Int128
+promote_rule{T<:BitUnsigned64}(::Type{UInt128}, ::Type{T}) = UInt128
+for T in BitSigned_types
+    @eval promote_rule{S<:Union{UInt8,UInt16}}(::Type{S}, ::Type{$T}) =
+        $(sizeof(T) < sizeof(Int) ? Int : T)
 end
-promote_rule(::Type{UInt32}, ::Type{Int64} ) = Int64
-promote_rule(::Type{UInt32}, ::Type{Int128}) = Int128
-
-promote_rule(::Type{UInt64}, ::Type{Int8}  ) = UInt64
-promote_rule(::Type{UInt64}, ::Type{Int16} ) = UInt64
-promote_rule(::Type{UInt64}, ::Type{Int32} ) = UInt64
-promote_rule(::Type{UInt64}, ::Type{Int64} ) = UInt64
-promote_rule(::Type{UInt64}, ::Type{Int128}) = Int128
+@eval promote_rule{T<:Union{Int8,Int16,Int32}}(::Type{UInt32}, ::Type{T}) =
+    $(WORD_SIZE == 64 ? Int : UInt)
+promote_rule(::Type{UInt32}, ::Type{Int64}) = Int64
+promote_rule{T<:BitSigned64}(::Type{UInt64}, ::Type{T}) = UInt64
+promote_rule{T<:Union{UInt32, UInt64}}(::Type{T}, ::Type{Int128}) = Int128
+promote_rule{T<:BitSigned}(::Type{UInt128}, ::Type{T}) = UInt128
 
-promote_rule(::Type{UInt128}, ::Type{Int8}  ) = UInt128
-promote_rule(::Type{UInt128}, ::Type{Int16} ) = UInt128
-promote_rule(::Type{UInt128}, ::Type{Int32} ) = UInt128
-promote_rule(::Type{UInt128}, ::Type{Int64} ) = UInt128
-promote_rule(::Type{UInt128}, ::Type{Int128}) = UInt128
+promote_op{R<:Integer,S<:Integer}(op, ::Type{R}, ::Type{S}) = typeof(op(one(R), one(S)))
 
 ## traits ##
 
@@ -358,17 +303,15 @@ typemin(::Type{Int64 }) = -9223372036854775808
 typemax(::Type{Int64 }) = 9223372036854775807
 typemin(::Type{UInt64}) = UInt64(0)
 typemax(::Type{UInt64}) = 0xffffffffffffffff
-@eval typemin(::Type{UInt128}) = $(UInt128(0))
+@eval typemin(::Type{UInt128}) = $(convert(UInt128, 0))
 @eval typemax(::Type{UInt128}) = $(box(UInt128,unbox(Int128,convert(Int128,-1))))
 @eval typemin(::Type{Int128} ) = $(convert(Int128,1)<<127)
 @eval typemax(::Type{Int128} ) = $(box(Int128,unbox(UInt128,typemax(UInt128)>>1)))
 
-widen(::Type{Int8}) = Int
-widen(::Type{Int16}) = Int
+widen{T<:Union{Int8, Int16}}(::Type{T}) = Int32
 widen(::Type{Int32}) = Int64
 widen(::Type{Int64}) = Int128
-widen(::Type{UInt8}) = UInt
-widen(::Type{UInt16}) = UInt
+widen{T<:Union{UInt8, UInt16}}(::Type{T}) = UInt32
 widen(::Type{UInt32}) = UInt64
 widen(::Type{UInt64}) = UInt128
 
@@ -438,13 +381,24 @@ if WORD_SIZE == 32
         (lolo&0xffffffffffffffff) + UInt128(w1)<<64
     end
 
-    div(x::Int128, y::Int128) = Int128(div(BigInt(x),BigInt(y)))
-    div(x::UInt128, y::UInt128) = UInt128(div(BigInt(x),BigInt(y)))
+    function div(x::Int128, y::Int128)
+        (x == typemin(Int128)) & (y == -1) && throw(DivideError())
+        Int128(div(BigInt(x),BigInt(y)))
+    end
+    function div(x::UInt128, y::UInt128)
+        UInt128(div(BigInt(x),BigInt(y)))
+    end
 
-    rem(x::Int128, y::Int128) = Int128(rem(BigInt(x),BigInt(y)))
-    rem(x::UInt128, y::UInt128) = UInt128(rem(BigInt(x),BigInt(y)))
+    function rem(x::Int128, y::Int128)
+        Int128(rem(BigInt(x),BigInt(y)))
+    end
+    function rem(x::UInt128, y::UInt128)
+        UInt128(rem(BigInt(x),BigInt(y)))
+    end
 
-    mod(x::Int128, y::Int128) = Int128(mod(BigInt(x),BigInt(y)))
+    function mod(x::Int128, y::Int128)
+        Int128(mod(BigInt(x),BigInt(y)))
+    end
 
     <<( x::Int128,  y::Int) = y == 0 ? x : box(Int128,shl_int(unbox(Int128,x),unbox(Int,y)))
     <<( x::UInt128, y::Int) = y == 0 ? x : box(UInt128,shl_int(unbox(UInt128,x),unbox(Int,y)))
@@ -453,74 +407,13 @@ if WORD_SIZE == 32
     >>>(x::Int128,  y::Int) = y == 0 ? x : box(Int128,lshr_int(unbox(Int128,x),unbox(Int,y)))
     >>>(x::UInt128, y::Int) = y == 0 ? x : box(UInt128,lshr_int(unbox(UInt128,x),unbox(Int,y)))
 else
-    *(x::Int128,  y::Int128)  = box(Int128,mul_int(unbox(Int128,x),unbox(Int128,y)))
-    *(x::UInt128, y::UInt128) = box(UInt128,mul_int(unbox(UInt128,x),unbox(UInt128,y)))
-
-    div(x::Int128,  y::Int128)  = box(Int128,sdiv_int(unbox(Int128,x),unbox(Int128,y)))
-    div(x::UInt128, y::UInt128) = box(UInt128,udiv_int(unbox(UInt128,x),unbox(UInt128,y)))
+    *{T<:Union{Int128,UInt128}}(x::T, y::T)  = box(T,mul_int(unbox(T,x),unbox(T,y)))
 
-    rem(x::Int128,  y::Int128)  = box(Int128,srem_int(unbox(Int128,x),unbox(Int128,y)))
-    rem(x::UInt128, y::UInt128) = box(UInt128,urem_int(unbox(UInt128,x),unbox(UInt128,y)))
+    div(x::Int128,  y::Int128)  = box(Int128,checked_sdiv_int(unbox(Int128,x),unbox(Int128,y)))
+    div(x::UInt128, y::UInt128) = box(UInt128,checked_udiv_int(unbox(UInt128,x),unbox(UInt128,y)))
 
-    mod(x::Int128, y::Int128) = box(Int128,smod_int(unbox(Int128,x),unbox(Int128,y)))
+    rem(x::Int128,  y::Int128)  = box(Int128,checked_srem_int(unbox(Int128,x),unbox(Int128,y)))
+    rem(x::UInt128, y::UInt128) = box(UInt128,checked_urem_int(unbox(UInt128,x),unbox(UInt128,y)))
 end
 
-## checked +, - and *
-
-# requires int arithmetic defined, for the loops to work
-
-for T in (Int8,Int16,Int32,Int64)#,Int128) ## FIXME: #4905
-    @eval begin
-        checked_add(x::$T, y::$T) = box($T,checked_sadd(unbox($T,x),unbox($T,y)))
-        checked_sub(x::$T, y::$T) = box($T,checked_ssub(unbox($T,x),unbox($T,y)))
-    end
-end
-for T in (Int16,Int32)
-    @eval begin
-        checked_mul(x::$T, y::$T) = box($T,checked_smul(unbox($T,x),unbox($T,y)))
-    end
-end
-for T in (UInt8,UInt16,UInt32,UInt64)#,UInt128) ## FIXME: #4905
-    @eval begin
-        checked_add(x::$T, y::$T) = box($T,checked_uadd(unbox($T,x),unbox($T,y)))
-        checked_sub(x::$T, y::$T) = box($T,checked_usub(unbox($T,x),unbox($T,y)))
-    end
-end
-for T in (UInt16,UInt32)
-    @eval begin
-        checked_mul(x::$T, y::$T) = box($T,checked_umul(unbox($T,x),unbox($T,y)))
-    end
-end
-
-# checked mul is broken for 8-bit types (LLVM bug?) ## FIXME: #4905
-
-for T in (Int8,UInt8)
-    @eval function checked_mul(x::$T, y::$T)
-        xy = widemul(x,y)
-        (typemin($T) <= xy <= typemax($T)) || throw(OverflowError())
-        return xy % $T
-    end
-end
-
-if WORD_SIZE == 32
-    for T in (Int64,UInt64)
-        @eval function checked_mul(x::$T, y::$T)
-            xy = Int128(x)*Int128(y)
-            (typemin($T) <= xy <= typemax($T)) || throw(OverflowError())
-            return xy % $T
-        end
-    end
-else
-    checked_mul(x::Int64, y::Int64)   = box(Int64,checked_smul(unbox(Int64,x),unbox(Int64,y)))
-    checked_mul(x::UInt64, y::UInt64) = box(UInt64,checked_umul(unbox(UInt64,x),unbox(UInt64,y)))
-end
-
-# checked ops are broken for 128-bit types (LLVM bug) ## FIXME: #4905
-
-checked_add(x::Int128, y::Int128) = x + y
-checked_sub(x::Int128, y::Int128) = x - y
-checked_mul(x::Int128, y::Int128) = x * y
-
-checked_add(x::UInt128, y::UInt128) = x + y
-checked_sub(x::UInt128, y::UInt128) = x - y
-checked_mul(x::UInt128, y::UInt128) = x * y
+(::Type{T}){T}(arg) = convert(T, arg)::T
diff --git a/base/interactiveutil.jl b/base/interactiveutil.jl
index 162b3261d12ae..9dcc89e07aef6 100644
--- a/base/interactiveutil.jl
+++ b/base/interactiveutil.jl
@@ -2,49 +2,65 @@
 
 # editing files
 
-function edit(file::AbstractString, line::Integer)
+"""
+    editor()
+
+Determines the editor to use when running functions like `edit`. Returns an Array compatible
+for use within backticks. You can change the editor by setting JULIA_EDITOR, VISUAL, or
+EDITOR as an environmental variable.
+"""
+function editor()
     if OS_NAME == :Windows || OS_NAME == :Darwin
         default_editor = "open"
-    elseif isreadable("/etc/alternatives/editor")
+    elseif isfile("/etc/alternatives/editor")
         default_editor = "/etc/alternatives/editor"
     else
         default_editor = "emacs"
     end
-    editor = get(ENV,"JULIA_EDITOR", get(ENV,"VISUAL", get(ENV,"EDITOR", default_editor)))
-    if ispath(editor)
-        if isreadable(editor)
-            edpath = realpath(editor)
-            edname = basename(edpath)
-        else
-            error("can't find \"$editor\"")
-        end
+    # Note: the editor path can include spaces (if escaped) and flags.
+    args = shell_split(get(ENV,"JULIA_EDITOR", get(ENV,"VISUAL", get(ENV,"EDITOR", default_editor))))
+    isempty(args) && error("editor is empty")
+    return args
+end
+
+function edit(path::AbstractString, line::Integer=0)
+    command = editor()
+    name = basename(first(command))
+    issrc = length(path)>2 && path[end-2:end] == ".jl"
+    if issrc
+        f = find_source_file(path)
+        f !== nothing && (path = f)
+    end
+    background = true
+    line_unsupported = false
+    if startswith(name, "emacs") || name == "gedit"
+        cmd = line != 0 ? `$command +$line $path` : `$command $path`
+    elseif startswith(name, "vim.") || name == "vi" || name == "vim" || name == "nvim" || name == "mvim" || name == "nano"
+        cmd = line != 0 ? `$command +$line $path` : `$command $path`
+        background = false
+    elseif name == "textmate" || name == "mate" || name == "kate"
+        cmd = line != 0 ? `$command $path -l $line` : `$command $path`
+    elseif startswith(name, "subl") || name == "atom"
+        cmd = line != 0 ? `$command $path:$line` : `$command $path`
+    elseif OS_NAME == :Windows && (name == "start" || name == "open")
+        cmd = `cmd /c start /b $path`
+        line_unsupported = true
+    elseif OS_NAME == :Darwin && (name == "start" || name == "open")
+        cmd = `open -t $path`
+        line_unsupported = true
     else
-        edpath = edname = editor
+        cmd = `$command $path`
+        background = false
+        line_unsupported = true
     end
-    issrc = length(file)>2 && file[end-2:end] == ".jl"
-    if issrc
-        f = find_source_file(file)
-        f !== nothing && (file = f)
-    end
-    const no_line_msg = "Unknown editor: no line number information passed.\nThe method is defined at line $line."
-    if startswith(edname, "emacs") || edname == "gedit"
-        spawn(`$edpath +$line $file`)
-    elseif edname == "vi" || edname == "vim" || edname == "nvim" || edname == "mvim" || edname == "nano"
-        run(`$edpath +$line $file`)
-    elseif edname == "textmate" || edname == "mate" || edname == "kate"
-        spawn(`$edpath $file -l $line`)
-    elseif startswith(edname, "subl") || edname == "atom"
-        spawn(`$(shell_split(edpath)) $file:$line`)
-    elseif OS_NAME == :Windows && (edname == "start" || edname == "open")
-        spawn(`cmd /c start /b $file`)
-        println(no_line_msg)
-    elseif OS_NAME == :Darwin && (edname == "start" || edname == "open")
-        spawn(`open -t $file`)
-        println(no_line_msg)
+
+    if background
+        spawn(pipeline(cmd, stderr=STDERR))
     else
-        run(`$(shell_split(edpath)) $file`)
-        println(no_line_msg)
+        run(cmd)
     end
+    line != 0 && line_unsupported && println("Unknown editor: no line number information passed.\nThe method is defined at line $line.")
+
     nothing
 end
 
@@ -53,7 +69,6 @@ function edit(m::Method)
     edit(string(file), line)
 end
 
-edit(file::AbstractString) = edit(file, 1)
 edit(f)          = edit(functionloc(f)...)
 edit(f, t::ANY)  = edit(functionloc(f,t)...)
 edit(file, line::Integer) = error("could not find source file for function")
@@ -74,11 +89,11 @@ less(file, line::Integer) = error("could not find source file for function")
 
 @osx_only begin
     function clipboard(x)
-        open(`pbcopy`, "w") do io
+        open(pipeline(`pbcopy`, stderr=STDERR), "w") do io
             print(io, x)
         end
     end
-    clipboard() = readall(`pbpaste`)
+    clipboard() = readstring(`pbpaste`)
 end
 
 @linux_only begin
@@ -96,7 +111,7 @@ end
         cmd = c == :xsel  ? `xsel --nodetach --input --clipboard` :
               c == :xclip ? `xclip -quiet -in -selection clipboard` :
             error("unexpected clipboard command: $c")
-        open(cmd, "w") do io
+        open(pipeline(cmd, stderr=STDERR), "w") do io
             print(io, x)
         end
     end
@@ -105,7 +120,7 @@ end
         cmd = c == :xsel  ? `xsel --nodetach --output --clipboard` :
               c == :xclip ? `xclip -quiet -out -selection clipboard` :
             error("unexpected clipboard command: $c")
-        readall(cmd)
+        readstring(pipeline(cmd, stderr=STDERR))
     end
 end
 
@@ -116,13 +131,13 @@ end
         end
         systemerror(:OpenClipboard, 0==ccall((:OpenClipboard, "user32"), stdcall, Cint, (Ptr{Void},), C_NULL))
         systemerror(:EmptyClipboard, 0==ccall((:EmptyClipboard, "user32"), stdcall, Cint, ()))
-        x_u16 = utf16(x)
+        x_u16 = cwstring(x)
         # copy data to locked, allocated space
-        p = ccall((:GlobalAlloc, "kernel32"), stdcall, Ptr{UInt16}, (UInt16, Int32), 2, sizeof(x_u16)+2)
+        p = ccall((:GlobalAlloc, "kernel32"), stdcall, Ptr{UInt16}, (UInt16, Int32), 2, sizeof(x_u16))
         systemerror(:GlobalAlloc, p==C_NULL)
         plock = ccall((:GlobalLock, "kernel32"), stdcall, Ptr{UInt16}, (Ptr{UInt16},), p)
         systemerror(:GlobalLock, plock==C_NULL)
-        ccall(:memcpy, Ptr{UInt16}, (Ptr{UInt16},Ptr{UInt16},Int), plock, x_u16, sizeof(x_u16)+2)
+        ccall(:memcpy, Ptr{UInt16}, (Ptr{UInt16},Ptr{UInt16},Int), plock, x_u16, sizeof(x_u16))
         systemerror(:GlobalUnlock, 0==ccall((:GlobalUnlock, "kernel32"), stdcall, Cint, (Ptr{Void},), plock))
         pdata = ccall((:SetClipboardData, "user32"), stdcall, Ptr{UInt16}, (UInt32, Ptr{UInt16}), 13, p)
         systemerror(:SetClipboardData, pdata!=p)
@@ -137,7 +152,11 @@ end
         systemerror(:CloseClipboard, 0==ccall((:CloseClipboard, "user32"), stdcall, Cint, ()))
         plock = ccall((:GlobalLock, "kernel32"), stdcall, Ptr{UInt16}, (Ptr{UInt16},), pdata)
         systemerror(:GlobalLock, plock==C_NULL)
-        s = utf8(utf16(plock))
+        # find NUL terminator (0x0000 16-bit code unit)
+        len = 0
+        while unsafe_load(plock, len+1) != 0; len += 1; end
+        # get Vector{UInt16}, transcode data to UTF-8, make a ByteString of it
+        s = bytestring(utf16to8(pointer_to_array(plock, len)))
         systemerror(:GlobalUnlock, 0==ccall((:GlobalUnlock, "kernel32"), stdcall, Cint, (Ptr{UInt16},), plock))
         return s
     end
@@ -166,11 +185,11 @@ function versioninfo(io::IO=STDOUT, verbose::Bool=false)
     if verbose
         lsb = ""
         @linux_only try lsb = readchomp(pipeline(`lsb_release -ds`, stderr=DevNull)) end
-        @windows_only try lsb = strip(readall(`$(ENV["COMSPEC"]) /c ver`)) end
+        @windows_only try lsb = strip(readstring(`$(ENV["COMSPEC"]) /c ver`)) end
         if lsb != ""
             println(io,     "           ", lsb)
         end
-        println(io,         "  uname: ",readchomp(`uname -mprsv`))
+        @unix_only println(io,         "  uname: ",readchomp(`uname -mprsv`))
         println(io,         "Memory: $(Sys.total_memory()/2^30) GB ($(Sys.free_memory()/2^20) MB free)")
         try println(io,     "Uptime: $(Sys.uptime()) sec") end
         print(io,           "Load Avg: ")
@@ -205,23 +224,19 @@ versioninfo(verbose::Bool) = versioninfo(STDOUT,verbose)
 # displaying type-ambiguity warnings
 
 function code_warntype(io::IO, f, t::ANY)
-    task_local_storage(:TYPEEMPHASIZE, true)
-    try
-        ct = code_typed(f, t)
-        for ast in ct
-            println(io, "Variables:")
-            vars = ast.args[2][1]
-            for v in vars
-                print(io, "  ", v[1])
-                show_expr_type(io, v[2])
-                print(io, '\n')
-            end
-            print(io, "\nBody:\n  ")
-            show_unquoted(io, ast.args[3], 2)
-            print(io, '\n')
+    emph_io = IOContext(io, :TYPEEMPHASIZE => true)
+    ct = code_typed(f, t)
+    for ast in ct
+        println(emph_io, "Variables:")
+        vars = ast.args[2][1]
+        for v in vars
+            print(emph_io, "  ", v[1])
+            show_expr_type(emph_io, v[2], true)
+            print(emph_io, '\n')
         end
-    finally
-        task_local_storage(:TYPEEMPHASIZE, false)
+        print(emph_io, "\nBody:\n  ")
+        show_unquoted(emph_io, ast.args[3], 2)
+        print(emph_io, '\n')
     end
     nothing
 end
@@ -238,20 +253,17 @@ function gen_call_with_extracted_types(fcn, ex0)
         return Expr(:call, fcn, esc(args[1]),
                     Expr(:call, typesof, map(esc, args[2:end])...))
     end
+    exret = Expr(:none)
     ex = expand(ex0)
-    if isa(ex, Expr) && ex.head == :call
-        return Expr(:call, fcn, esc(ex.args[1]),
-                    Expr(:call, typesof, map(esc, ex.args[2:end])...))
-    end
-    exret = Expr(:call, :error, "expression is not a function call or symbol")
     if !isa(ex, Expr)
-        # do nothing -> error
+        exret = Expr(:call, :error, "expression is not a function call or symbol")
     elseif ex.head == :call
         if any(e->(isa(e, Expr) && e.head==:(...)), ex0.args) &&
-            isa(ex.args[1], TopNode) && ex.args[1].name == :apply
+            isa(ex.args[1], TopNode) && ex.args[1].name == :_apply
+            # check for splatting
             exret = Expr(:call, ex.args[1], fcn,
-                         Expr(:tuple, esc(ex.args[2])),
-                         Expr(:call, typesof, map(esc, ex.args[3:end])...))
+                        Expr(:tuple, esc(ex.args[2]),
+                            Expr(:call, typesof, map(esc, ex.args[3:end])...)))
         else
             exret = Expr(:call, fcn, esc(ex.args[1]),
                          Expr(:call, typesof, map(esc, ex.args[2:end])...))
@@ -265,9 +277,10 @@ function gen_call_with_extracted_types(fcn, ex0)
                              Expr(:call, typesof, map(esc, a1.args[2:end])...))
             end
         end
-    elseif ex.head == :thunk
+    end
+    if ex.head == :thunk || exret.head == :none
         exret = Expr(:call, :error, "expression is not a function call, "
-                                  * "or is too complex for @which to analyze; "
+                                  * "or is too complex for @$fcn to analyze; "
                                   * "break it down to simpler parts if possible")
     end
     exret
@@ -287,14 +300,13 @@ end
 function type_close_enough(x::ANY, t::ANY)
     x == t && return true
     return (isa(x,DataType) && isa(t,DataType) && x.name === t.name &&
-            !isleaftype(t) && x <: t)
+            !isleaftype(t) && x <: t) ||
+           (isa(x,Union) && isa(t,DataType) && any(u -> is(u,t), x.types))
 end
 
 function methodswith(t::Type, f::Function, showparents::Bool=false, meths = Method[])
-    if !isa(f.env, MethodTable)
-        return meths
-    end
-    d = f.env.defs
+    mt = typeof(f).name.mt
+    d = mt.defs
     while d !== nothing
         if any(x -> (type_close_enough(x, t) ||
                      (showparents ? (t <: x && (!isa(x,TypeVar) || x.ub != Any)) :
@@ -406,14 +418,14 @@ function runtests(tests = ["all"], numcores = ceil(Int,CPU_CORES/2))
         buf = PipeBuffer()
         versioninfo(buf)
         error("A test has failed. Please submit a bug report (https://github.com/JuliaLang/julia/issues)\n" *
-              "including error messages above and the output of versioninfo():\n$(readall(buf))")
+              "including error messages above and the output of versioninfo():\n$(readstring(buf))")
     end
 end
 
 # testing
 
 
-doc"""
+"""
     whos([io,] [Module,] [pattern::Regex])
 
 Print information about exported global variables in a module, optionally restricted to those matching `pattern`.
@@ -421,7 +433,7 @@ Print information about exported global variables in a module, optionally restri
 The memory consumption estimate is an approximate lower bound on the size of the internal structure of the object.
 """
 function whos(io::IO=STDOUT, m::Module=current_module(), pattern::Regex=r"")
-    maxline = tty_size()[2]
+    maxline = displaysize(io)[2]
     line = zeros(UInt8, maxline)
     head = PipeBuffer(maxline + 1)
     for v in sort!(names(m))
@@ -437,8 +449,6 @@ function whos(io::IO=STDOUT, m::Module=current_module(), pattern::Regex=r"")
                     @printf(head, "%6d KB     ", bytes ÷ (1024))
                 end
                 print(head, summary(value))
-                print(head, " : ")
-                show(head, value)
             catch e
                 print(head, "#=ERROR: unable to show value=#")
             end
@@ -487,7 +497,11 @@ function summarysize(obj::DataType, seen, excl)
     return size
 end
 
-summarysize(obj::TypeName, seen, excl) = Core.sizeof(obj)
+function summarysize(obj::TypeName, seen, excl)
+    key = pointer_from_objref(obj)
+    haskey(seen, key) ? (return 0) : (seen[key] = true)
+    return Core.sizeof(obj) + (isdefined(obj,:mt) ? summarysize(obj.mt, seen, excl) : 0)
+end
 
 summarysize(obj::ANY, seen, excl) = _summarysize(obj, seen, excl)
 # define the general case separately to make sure it is not specialized for every type
@@ -547,6 +561,14 @@ function summarysize(obj::Module, seen, excl)
             value = getfield(obj, binding)
             if !isa(value, Module) || module_parent(value) === obj
                 size += summarysize(value, seen, excl)::Int
+                vt = isa(value,DataType) ? value : typeof(value)
+                if vt.name.module === obj
+                    if vt !== value
+                        size += summarysize(vt, seen, excl)::Int
+                    end
+                    # charge a TypeName to its module
+                    size += summarysize(vt.name, seen, excl)::Int
+                end
             end
         end
     end
@@ -586,7 +608,9 @@ function summarysize(m::Method, seen, excl)
     while true
         haskey(seen, m) ? (return size) : (seen[m] = true)
         size += Core.sizeof(m)
-        size += summarysize(m.func, seen, excl)::Int
+        if isdefined(m, :func)
+            size += summarysize(m.func, seen, excl)::Int
+        end
         size += summarysize(m.sig, seen, excl)::Int
         size += summarysize(m.tvars, seen, excl)::Int
         size += summarysize(m.invokes, seen, excl)::Int
diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index 1825215f65ab6..e586136e6c101 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -8,7 +8,7 @@ function gcd{T<:Integer}(a::T, b::T)
         b = rem(a, b)
         a = t
     end
-    abs(a)
+    checked_abs(a)
 end
 
 # binary GCD (aka Stein's) algorithm
@@ -19,8 +19,8 @@ function gcd{T<:Union{Int64,UInt64,Int128,UInt128}}(a::T, b::T)
     za = trailing_zeros(a)
     zb = trailing_zeros(b)
     k = min(za, zb)
-    u = abs(a >> za)
-    v = abs(b >> zb)
+    u = unsigned(abs(a >> za))
+    v = unsigned(abs(b >> zb))
     while u != v
         if u > v
             u, v = v, u
@@ -28,11 +28,14 @@ function gcd{T<:Union{Int64,UInt64,Int128,UInt128}}(a::T, b::T)
         v -= u
         v >>= trailing_zeros(v)
     end
-    u << k
+    r = u << k
+    # T(r) would throw InexactError; we want OverflowError instead
+    r > typemax(T) && throw(OverflowError())
+    r % T
 end
 
 # explicit a==0 test is to handle case of lcm(0,0) correctly
-lcm{T<:Integer}(a::T, b::T) = a == 0 ? a : abs(a * div(b, gcd(b,a)))
+lcm{T<:Integer}(a::T, b::T) = a == 0 ? a : checked_abs(a * div(b, gcd(b,a)))
 
 gcd(a::Integer) = a
 lcm(a::Integer) = a
@@ -108,11 +111,11 @@ end
 ^(x, p::Integer)          = power_by_squaring(x,p)
 
 # b^p mod m
-function powermod{T}(b::Integer, p::Integer, m::T)
+function powermod{T<:Integer}(x::Integer, p::Integer, m::T)
     p < 0 && throw(DomainError())
-    b = oftype(m,mod(b,m))  # this also checks for divide by zero
-    p == 0 && return mod(one(b),m)
+    p == 0 && return mod(one(m),m)
     (m == 1 || m == -1) && return zero(m)
+    b = oftype(m,mod(x,m))  # this also checks for divide by zero
 
     t = prevpow2(p)
     local r::T
@@ -129,6 +132,9 @@ function powermod{T}(b::Integer, p::Integer, m::T)
     return r
 end
 
+# optimization: promote the modulus m to BigInt only once (cf. widemul in generic powermod above)
+powermod(x::Integer, p::Integer, m::Union{Int128,UInt128}) = oftype(m, powermod(x, p, big(m)))
+
 # smallest power of 2 >= x
 nextpow2(x::Unsigned) = one(x)<<((sizeof(x)<<3)-leading_zeros(x-one(x)))
 nextpow2(x::Integer) = reinterpret(typeof(x),x < 0 ? -nextpow2(unsigned(-x)) : nextpow2(unsigned(x)))
@@ -308,16 +314,16 @@ bits(x::Union{Char,Int32,UInt32,Float32}) = bin(reinterpret(UInt32,x),32)
 bits(x::Union{Int64,UInt64,Float64})      = bin(reinterpret(UInt64,x),64)
 bits(x::Union{Int128,UInt128})            = bin(reinterpret(UInt128,x),128)
 
-function digits{T<:Integer}(n::Integer, base::T=10, pad::Integer=1)
+digits{T<:Integer}(n::Integer, base::T=10, pad::Integer=1) = digits(T, n, base, pad)
+
+function digits{T<:Integer}(::Type{T}, n::Integer, base::Integer=10, pad::Integer=1)
     2 <= base || throw(ArgumentError("base must be ≥ 2, got $base"))
-    m = max(pad,ndigits0z(n,base))
-    a = zeros(T,m)
-    digits!(a, n, base)
-    return a
+    digits!(zeros(T, max(pad, ndigits0z(n,base))), n, base)
 end
 
-function digits!{T<:Integer}(a::AbstractArray{T,1}, n::Integer, base::T=10)
+function digits!{T<:Integer}(a::AbstractArray{T,1}, n::Integer, base::Integer=10)
     2 <= base || throw(ArgumentError("base must be ≥ 2, got $base"))
+    base - 1 <= typemax(T) || throw(ArgumentError("type $T too small for base $base"))
     for i = 1:length(a)
         a[i] = rem(n, base)
         n = div(n, base)
diff --git a/base/intset.jl b/base/intset.jl
index cca0f177b28b8..5b610eae563c7 100644
--- a/base/intset.jl
+++ b/base/intset.jl
@@ -1,6 +1,8 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-type IntSet
+abstract AbstractSet{T}
+
+type IntSet <: AbstractSet{Int}
     bits::Array{UInt32,1}
     limit::Int
     fill1s::Bool
@@ -157,11 +159,16 @@ function symdiff!(s::IntSet, ns)
 end
 
 function copy!(to::IntSet, from::IntSet)
-    empty!(to)
-    union!(to, from)
+    if is(to, from)
+        return to
+    else
+        empty!(to)
+        return union!(to, from)
+    end
 end
 
-function in(n::Integer, s::IntSet)
+in(n, s::IntSet) = n < 0 ? false : (n > typemax(Int) ? s.fill1s : in(convert(Int, n), s))
+function in(n::Int, s::IntSet)
     if n >= s.limit
         # max IntSet length is typemax(Int), so highest possible element is
         # typemax(Int)-1
diff --git a/base/io.jl b/base/io.jl
index 1203f1244e6dd..fd7db0f1daaef 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -1,10 +1,104 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-## core stream types ##
+# Generic IO stubs -- all subtypes should implement these (if meaningful)
 
-# the first argument to any IO MUST be a POINTER (to a JL_STREAM) or using show on it will cause memory corruption
+lock(::IO) = nothing
+unlock(::IO) = nothing
+reseteof(x::IO) = nothing
+
+const SZ_UNBUFFERED_IO = 65536
+buffer_writes(x::IO, bufsize=SZ_UNBUFFERED_IO) = nothing
+
+function isopen end
+function close end
+function flush end
+function wait_connected end
+function wait_readnb end
+function wait_readbyte end
+function wait_close end
+function nb_available end
+function readavailable end
+function isreadable end
+function iswritable end
+function copy end
+function eof end
+
+read(s::IO, ::Type{UInt8}) = error(typeof(s)," does not support byte I/O")
+write(s::IO, x::UInt8) = error(typeof(s)," does not support byte I/O")
+
+"""
+    unsafe_write(io, ref, nbytes)
+
+Copy nbytes from ref (converted to a pointer) into the IO stream object.
+
+It is recommended that IO subtypes override the exact method signature below
+to provide more efficient implementations:
+`unsafe_write(s::IO, p::Ptr{UInt8}, n::UInt)`
+"""
+function unsafe_write(s::IO, p::Ptr{UInt8}, n::UInt)
+    local written::Int = 0
+    for i = 1:n
+        written += write(s, unsafe_load(p, i))
+    end
+    return written
+end
+
+"""
+    unsafe_read(io, ref, nbytes)
+
+Copy nbytes from the IO stream object into ref (converted to a pointer).
+
+It is recommended that IO subtypes override the exact method signature below
+to provide more efficient implementations:
+`unsafe_read(s::IO, p::Ptr{UInt8}, n::UInt)`
+"""
+function unsafe_read(s::IO, p::Ptr{UInt8}, n::UInt)
+    for i = 1:n
+        unsafe_store!(p, read(s, UInt8)::UInt8, i)
+    end
+    nothing
+end
+
+
+# Generic wrappers around other IO objects
+abstract AbstractPipe <: IO
+function pipe_reader end
+function pipe_writer end
+
+write(io::AbstractPipe, byte::UInt8) = write(pipe_writer(io), byte)
+unsafe_write(io::AbstractPipe, p::Ptr{UInt8}, nb::UInt) = unsafe_write(pipe_writer(io), p, nb)
+buffer_writes(io::AbstractPipe, args...) = buffer_writes(pipe_writer(io), args...)
+flush(io::AbstractPipe) = flush(pipe_writer(io))
+
+read(io::AbstractPipe, byte::Type{UInt8}) = read(pipe_reader(io), byte)
+unsafe_read(io::AbstractPipe, p::Ptr{UInt8}, nb::UInt) = unsafe_read(pipe_reader(io), p, nb)
+read(io::AbstractPipe) = read(pipe_reader(io))
+readuntil{T<:AbstractPipe}(io::T, args...) = readuntil(pipe_reader(io), args...)
+readavailable(io::AbstractPipe) = readavailable(pipe_reader(io))
+
+isreadable(io::AbstractPipe) = isreadable(pipe_reader(io))
+iswritable(io::AbstractPipe) = iswritable(pipe_writer(io))
+isopen(io::AbstractPipe) = isopen(pipe_writer(io)) || isopen(pipe_reader(io))
+close(io::AbstractPipe) = (close(pipe_writer(io)); close(pipe_reader(io)))
+wait_readnb(io::AbstractPipe, nb::Int) = wait_readnb(pipe_reader(io), nb)
+wait_readbyte(io::AbstractPipe, byte::UInt8) = wait_readbyte(pipe_reader(io), byte)
+wait_close(io::AbstractPipe) = (wait_close(pipe_writer(io)); wait_close(pipe_reader(io)))
+nb_available(io::AbstractPipe) = nb_available(pipe_reader(io))
+eof(io::AbstractPipe) = eof(pipe_reader(io))
+reseteof(io::AbstractPipe) = reseteof(pipe_reader(io))
+
+
+# Exception-safe wrappers (io = open(); try f(io) finally close(io))
+
+write(filename::AbstractString, args...) = open(io->write(io, args...), filename, "w")
+
+read(filename::AbstractString, args...) = open(io->read(io, args...), filename)
+read!(filename::AbstractString, a) = open(io->read!(io, a), filename)
+readstring(filename::AbstractString) = open(readstring, filename)
+readuntil(filename::AbstractString, args...) = open(io->readuntil(io, args...), filename)
+readline(filename::AbstractString) = open(readline, filename)
+readlines(filename::AbstractString) = open(readlines, filename)
 
-# Generic IO functions
 
 ## byte-order mark, ntoh & hton ##
 
@@ -28,42 +122,25 @@ isreadonly(s) = isreadable(s) && !iswritable(s)
 
 ## binary I/O ##
 
-# all subtypes should implement this
-write(s::IO, x::UInt8) = error(typeof(s)," does not support byte I/O")
-
 write(io::IO, x) = throw(MethodError(write, (io, x)))
 function write(io::IO, xs...)
     local written::Int = 0
     for x in xs
         written += write(io, x)
     end
-    written
+    return written
 end
 
-if ENDIAN_BOM == 0x01020304
-    function write(s::IO, x::Integer)
-        sz = sizeof(x)
-        local written::Int = 0
-        for n = sz:-1:1
-            written += write(s, (x>>>((n-1)<<3))%UInt8)
-        end
-        return written
-    end
-else
-    function write(s::IO, x::Integer)
-        sz = sizeof(x)
-        local written::Int = 0
-        for n = 1:sz
-            written += write(s, (x>>>((n-1)<<3))%UInt8)
-        end
-        return written
-    end
+@noinline unsafe_write{T}(s::IO, p::Ref{T}, n::Integer) = unsafe_write(s, unsafe_convert(Ref{T}, p)::Ptr, n) # mark noinline to ensure ref is gc-rooted somewhere (by the caller)
+unsafe_write(s::IO, p::Ptr, n::Integer) = unsafe_write(s, convert(Ptr{UInt8}, p), convert(UInt, n))
+write{T}(s::IO, x::Ref{T}) = unsafe_write(s, x, Core.sizeof(T))
+write(s::IO, x::Int8) = write(s, reinterpret(UInt8, x))
+function write(s::IO, x::Union{Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128,Float16,Float32,Float64})
+    return write(s, Ref(x))
 end
 
 write(s::IO, x::Bool)    = write(s, UInt8(x))
-write(s::IO, x::Float16) = write(s, reinterpret(Int16,x))
-write(s::IO, x::Float32) = write(s, reinterpret(Int32,x))
-write(s::IO, x::Float64) = write(s, reinterpret(Int64,x))
+write(to::IO, p::Ptr) = write(to, convert(UInt, p))
 
 function write(s::IO, a::AbstractArray)
     nb = 0
@@ -73,6 +150,23 @@ function write(s::IO, a::AbstractArray)
     return nb
 end
 
+@noinline function write(s::IO, a::Array{UInt8}) # mark noinline to ensure the array is gc-rooted somewhere (by the caller)
+    return unsafe_write(s, pointer(a), sizeof(a))
+end
+
+@noinline function write{T}(s::IO, a::Array{T}) # mark noinline to ensure the array is gc-rooted somewhere (by the caller)
+    if isbits(T)
+        return unsafe_write(s, pointer(a), sizeof(a))
+    else
+        nb = 0
+        for i in eachindex(a)
+            nb += write(s, a[i])
+        end
+        return nb
+    end
+end
+
+
 function write(s::IO, ch::Char)
     c = reinterpret(UInt32, ch)
     if c < 0x80
@@ -94,36 +188,28 @@ function write(s::IO, ch::Char)
     end
 end
 
-function write(s::IO, p::Ptr, n::Integer)
-    local written::Int = 0
-    for i=1:n
-        written += write(s, unsafe_load(p, i))
-    end
-    return written
-end
-
 function write(io::IO, s::Symbol)
     pname = unsafe_convert(Ptr{UInt8}, s)
-    return write(io, pname, Int(ccall(:strlen, Csize_t, (Ptr{UInt8},), pname)))
+    return unsafe_write(io, pname, Int(ccall(:strlen, Csize_t, (Cstring,), pname)))
 end
 
-# all subtypes should implement this
-read(s::IO, ::Type{UInt8}) = error(typeof(s)," does not support byte I/O")
+function write(to::IO, from::IO)
+    while !eof(from)
+        write(to, readavailable(from))
+    end
+end
 
-read(s::IO, ::Type{Int8}) = reinterpret(Int8, read(s,UInt8))
+@noinline unsafe_read{T}(s::IO, p::Ref{T}, n::Integer) = unsafe_read(s, unsafe_convert(Ref{T}, p)::Ptr, n) # mark noinline to ensure ref is gc-rooted somewhere (by the caller)
+unsafe_read(s::IO, p::Ptr, n::Integer) = unsafe_read(s, convert(Ptr{UInt8}, p), convert(UInt, n))
+read{T}(s::IO, x::Ref{T}) = (unsafe_read(s, x, Core.sizeof(T)); x)
 
-function read{T <: Integer}(s::IO, ::Type{T})
-    x = zero(T)
-    for n = 1:sizeof(x)
-        x |= (convert(T,read(s,UInt8))<<((n-1)<<3))
-    end
-    return x
+read(s::IO, ::Type{Int8}) = reinterpret(Int8, read(s, UInt8))
+function read(s::IO, T::Union{Type{Int16},Type{UInt16},Type{Int32},Type{UInt32},Type{Int64},Type{UInt64},Type{Int128},Type{UInt128},Type{Float16},Type{Float32},Type{Float64}})
+    return read(s, Ref{T}(0))[]::T
 end
 
 read(s::IO, ::Type{Bool})    = (read(s,UInt8)!=0)
-read(s::IO, ::Type{Float16}) = box(Float16,unbox(Int16,read(s,Int16)))
-read(s::IO, ::Type{Float32}) = box(Float32,unbox(Int32,read(s,Int32)))
-read(s::IO, ::Type{Float64}) = box(Float64,unbox(Int64,read(s,Int64)))
+read{T}(s::IO, ::Type{Ptr{T}}) = convert(Ptr{T}, read(s, UInt))
 
 read{T}(s::IO, t::Type{T}, d1::Int, dims::Int...) = read(s, t, tuple(d1,dims...))
 read{T}(s::IO, t::Type{T}, d1::Integer, dims::Integer...) =
@@ -131,9 +217,18 @@ read{T}(s::IO, t::Type{T}, d1::Integer, dims::Integer...) =
 
 read{T}(s::IO, ::Type{T}, dims::Dims) = read!(s, Array(T, dims))
 
-function read!{T}(s::IO, a::Array{T})
-    for i in eachindex(a)
-        a[i] = read(s, T)
+@noinline function read!(s::IO, a::Array{UInt8}) # mark noinline to ensure the array is gc-rooted somewhere (by the caller)
+    unsafe_read(s, pointer(a), sizeof(a))
+    return a
+end
+
+@noinline function read!{T}(s::IO, a::Array{T}) # mark noinline to ensure the array is gc-rooted somewhere (by the caller)
+    if isbits(T)
+        unsafe_read(s, pointer(a), sizeof(a))
+    else
+        for i in eachindex(a)
+            a[i] = read(s, T)
+        end
     end
     return a
 end
@@ -154,7 +249,7 @@ function read(s::IO, ::Type{Char})
     end
     c += ch
     c -= Base.utf8_offset[trailing+1]
-    Char(c)
+    return Char(c)
 end
 
 function readuntil(s::IO, delim::Char)
@@ -171,7 +266,7 @@ function readuntil(s::IO, delim::Char)
             break
         end
     end
-    takebuf_string(out)
+    return takebuf_string(out)
 end
 
 function readuntil{T}(s::IO, delim::T)
@@ -183,7 +278,7 @@ function readuntil{T}(s::IO, delim::T)
             break
         end
     end
-    out
+    return out
 end
 
 # based on code by Glen Hertz
@@ -219,9 +314,9 @@ function readuntil(s::IO, t::AbstractString)
     return takebuf_string(out)
 end
 
-
+readline() = readline(STDIN)
 readline(s::IO) = readuntil(s, '\n')
-readchomp(x) = chomp!(readall(x))
+readchomp(x) = chomp!(readstring(x))
 
 # read up to nb bytes into nb, returning # bytes read
 function readbytes!(s::IO, b::AbstractArray{UInt8}, nb=length(b))
@@ -243,17 +338,18 @@ function readbytes!(s::IO, b::AbstractArray{UInt8}, nb=length(b))
 end
 
 # read up to nb bytes from s, returning a Vector{UInt8} of bytes read.
-function readbytes(s::IO, nb=typemax(Int))
+function read(s::IO, nb=typemax(Int))
+    # Let readbytes! grow the array progressively by default
+    # instead of taking of risk of over-allocating
     b = Array(UInt8, nb == typemax(Int) ? 1024 : nb)
     nr = readbytes!(s, b, nb)
-    resize!(b, nr)
+    return resize!(b, nr)
 end
 
-function readall(s::IO)
-    b = readbytes(s)
+function readstring(s::IO)
+    b = read(s)
     return isvalid(ASCIIString, b) ? ASCIIString(b) : UTF8String(b)
 end
-readall(filename::AbstractString) = open(readall, filename)
 
 ## high-level iterator interfaces ##
 
@@ -264,6 +360,10 @@ type EachLine
     EachLine(stream, ondone) = new(stream, ondone)
 end
 eachline(stream::IO) = EachLine(stream)
+function eachline(filename::AbstractString)
+    s = open(filename)
+    EachLine(s, ()->close(s))
+end
 
 start(itr::EachLine) = nothing
 function done(itr::EachLine, nada)
@@ -279,9 +379,8 @@ eltype(::Type{EachLine}) = ByteString
 readlines(s=STDIN) = collect(eachline(s))
 
 # IOStream Marking
-
 # Note that these functions expect that io.mark exists for
-# the concrete IO type.  This may not be true for IO types
+# the concrete IO type. This may not be true for IO types
 # not in base.
 
 function mark(io::IO)
@@ -303,8 +402,3 @@ function reset{T<:IO}(io::T)
 end
 
 ismarked(io::IO) = io.mark >= 0
-
-# Generic IO stubs
-
-lock(::IO) = nothing
-unlock(::IO) = nothing
diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index e6f4914741b1e..9395e0bd0ff83 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -39,7 +39,7 @@ function copy(b::AbstractIOBuffer)
                     b.readable, b.writable, b.seekable, b.append, b.maxsize)
     ret.size = b.size
     ret.ptr  = b.ptr
-    ret
+    return ret
 end
 
 show(io::IO, b::AbstractIOBuffer) = print(io, "IOBuffer(data=UInt8[...], ",
@@ -52,7 +52,17 @@ show(io::IO, b::AbstractIOBuffer) = print(io, "IOBuffer(data=UInt8[...], ",
                                       "ptr=",      b.ptr, ", ",
                                       "mark=",     b.mark, ")")
 
-read!(from::AbstractIOBuffer, a::Array) = read_sub(from, a, 1, length(a))
+function unsafe_read(from::AbstractIOBuffer, p::Ptr{UInt8}, nb::UInt)
+    from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
+    avail = nb_available(from)
+    adv = min(avail, nb)
+    unsafe_copy!(p, pointer(from.data, from.ptr), adv)
+    from.ptr += adv
+    if nb > avail
+        throw(EOFError())
+    end
+    nothing
+end
 
 function read_sub{T}(from::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
     from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
@@ -60,18 +70,8 @@ function read_sub{T}(from::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
         throw(BoundsError())
     end
     if isbits(T) && isa(a,Array)
-        nb = nel * sizeof(T)
-        avail = nb_available(from)
-        adv = min(avail, nb)
-        copy!(pointer_to_array(convert(Ptr{UInt8},pointer(a)), sizeof(a)), # reinterpret(UInt8,a) but without setting the shared data property on a
-              1 + (1 - offs) * sizeof(T),
-              from.data,
-              from.ptr,
-              adv)
-        from.ptr += adv
-        if nb > avail
-            throw(EOFError())
-        end
+        nb = UInt(nel * sizeof(T))
+        unsafe_read(from, pointer(a, offs), nb)
     else
         for i = offs:offs+nel-1
             a[i] = read(to, T)
@@ -81,9 +81,9 @@ function read_sub{T}(from::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
 end
 
 @inline function read(from::AbstractIOBuffer, ::Type{UInt8})
+    from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
     ptr = from.ptr
     size = from.size
-    from.readable || throw(ArgumentError("read failed, IOBuffer is not readable"))
     if ptr > size
         throw(EOFError())
     end
@@ -170,7 +170,8 @@ function compact(io::AbstractIOBuffer)
     return io
 end
 
-function ensureroom(io::AbstractIOBuffer, nshort::Int)
+@inline ensureroom(io::AbstractIOBuffer, nshort::Int) = ensureroom(io, UInt(nshort))
+@inline function ensureroom(io::AbstractIOBuffer, nshort::UInt)
     io.writable || throw(ArgumentError("ensureroom failed, IOBuffer is not writeable"))
     if !io.seekable
         nshort >= 0 || throw(ArgumentError("ensureroom failed, requested number of bytes must be ≥ 0, got $nshort"))
@@ -197,7 +198,7 @@ end
 
 eof(io::AbstractIOBuffer) = (io.ptr-1 == io.size)
 
-function close{T}(io::AbstractIOBuffer{T})
+@noinline function close{T}(io::AbstractIOBuffer{T})
     io.readable = false
     io.writable = false
     io.seekable = false
@@ -235,7 +236,7 @@ function takebuf_array(io::AbstractIOBuffer)
         io.ptr = 1
         io.size = 0
     end
-    data
+    return data
 end
 function takebuf_array(io::IOBuffer)
     ismarked(io) && unmark(io)
@@ -257,7 +258,7 @@ function takebuf_array(io::IOBuffer)
         io.ptr = 1
         io.size = 0
     end
-    data
+    return data
 end
 function takebuf_string(io::AbstractIOBuffer)
     b = takebuf_array(io)
@@ -271,21 +272,21 @@ function write(to::AbstractIOBuffer, from::AbstractIOBuffer)
     end
     written::Int = write_sub(to, from.data, from.ptr, nb_available(from))
     from.ptr += written
-    written
+    return written
 end
 
-write(to::AbstractIOBuffer, p::Ptr, nb::Integer) = write(to, p, Int(nb))
-function write(to::AbstractIOBuffer, p::Ptr, nb::Int)
+function unsafe_write(to::AbstractIOBuffer, p::Ptr{UInt8}, nb::UInt)
     ensureroom(to, nb)
     ptr = (to.append ? to.size+1 : to.ptr)
     written = min(nb, length(to.data) - ptr + 1)
-    p_u8 = convert(Ptr{UInt8}, p)
     for i = 0:written - 1
-        @inbounds to.data[ptr + i] = unsafe_load(p_u8 + i)
+        @inbounds to.data[ptr + i] = unsafe_load(p + i)
     end
     to.size = max(to.size, ptr - 1 + written)
-    if !to.append to.ptr += written end
-    written
+    if !to.append
+        to.ptr += written
+    end
+    return written
 end
 
 function write_sub{T}(to::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
@@ -294,28 +295,20 @@ function write_sub{T}(to::AbstractIOBuffer, a::AbstractArray{T}, offs, nel)
     end
     local written::Int
     if isbits(T) && isa(a,Array)
-        nb = nel * sizeof(T)
-        ensureroom(to, Int(nb))
-        ptr = (to.append ? to.size+1 : to.ptr)
-        written = min(nb, length(to.data) - ptr + 1)
-        unsafe_copy!(pointer(to.data, ptr),
-                     convert(Ptr{UInt8}, pointer(a, offs)), written)
-        to.size = max(to.size, ptr - 1 + written)
-        if !to.append to.ptr += written end
+        nb = UInt(nel * sizeof(T))
+        written = unsafe_write(to, pointer(a, offs), nb)
     else
         written = 0
-        ensureroom(to, sizeof(a))
+        ensureroom(to, UInt(sizeof(a)))
         for i = offs:offs+nel-1
             written += write(to, a[i])
         end
     end
-    written
+    return written
 end
 
-write(to::AbstractIOBuffer, a::Array) = write_sub(to, a, 1, length(a))
-
-function write(to::AbstractIOBuffer, a::UInt8)
-    ensureroom(to, 1)
+@inline function write(to::AbstractIOBuffer, a::UInt8)
+    ensureroom(to, UInt(1))
     ptr = (to.append ? to.size+1 : to.ptr)
     if ptr > to.maxsize
         return 0
@@ -323,13 +316,14 @@ function write(to::AbstractIOBuffer, a::UInt8)
         to.data[ptr] = a
     end
     to.size = max(to.size, ptr)
-    if !to.append to.ptr += 1 end
-    sizeof(UInt8)
+    if !to.append
+        to.ptr += 1
+    end
+    return sizeof(UInt8)
 end
 
-write(to::AbstractIOBuffer, p::Ptr) = write(to, convert(UInt, p))
-
-function readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb=length(b))
+readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb=length(b)) = readbytes!(io, b, Int(nb))
+function readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb::Int)
     nr = min(nb, nb_available(io))
     if length(b) < nr
         resize!(b, nr)
@@ -337,8 +331,9 @@ function readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb=length(b))
     read_sub(io, b, 1, nr)
     return nr
 end
-readbytes(io::AbstractIOBuffer) = read!(io, Array(UInt8, nb_available(io)))
-readbytes(io::AbstractIOBuffer, nb) = read!(io, Array(UInt8, min(nb, nb_available(io))))
+read(io::AbstractIOBuffer) = read!(io, Array(UInt8, nb_available(io)))
+readavailable(io::AbstractIOBuffer) = read(io)
+read(io::AbstractIOBuffer, nb::Integer) = read!(io, Array(UInt8, min(nb, nb_available(io))))
 
 function search(buf::IOBuffer, delim::UInt8)
     p = pointer(buf.data, buf.ptr)
diff --git a/base/iostream.jl b/base/iostream.jl
index b1c08cfb0be60..31cf086933789 100644
--- a/base/iostream.jl
+++ b/base/iostream.jl
@@ -2,7 +2,7 @@
 
 ## IOStream
 
-const sizeof_ios_t = Int(ccall(:jl_sizeof_ios_t, Int32, ()))
+const sizeof_ios_t = Int(ccall(:jl_sizeof_ios_t, Cint, ()))
 
 type IOStream <: IO
     handle::Ptr{Void}
@@ -41,12 +41,12 @@ iswritable(s::IOStream) = ccall(:ios_get_writable, Cint, (Ptr{Void},), s.ios)!=0
 isreadable(s::IOStream) = ccall(:ios_get_readable, Cint, (Ptr{Void},), s.ios)!=0
 
 function truncate(s::IOStream, n::Integer)
-    systemerror("truncate", ccall(:ios_trunc, Int32, (Ptr{Void}, UInt), s.ios, n) != 0)
+    systemerror("truncate", ccall(:ios_trunc, Cint, (Ptr{Void}, Csize_t), s.ios, n) != 0)
     return s
 end
 
 function seek(s::IOStream, n::Integer)
-    ret = ccall(:ios_seek, FileOffset, (Ptr{Void}, FileOffset), s.ios, n)
+    ret = ccall(:ios_seek, Int64, (Ptr{Void}, Int64), s.ios, n)
     systemerror("seek", ret == -1)
     ret < -1 && error("seek failed")
     return s
@@ -55,31 +55,31 @@ end
 seekstart(s::IO) = seek(s,0)
 
 function seekend(s::IOStream)
-    systemerror("seekend", ccall(:ios_seek_end, FileOffset, (Ptr{Void},), s.ios) != 0)
+    systemerror("seekend", ccall(:ios_seek_end, Int64, (Ptr{Void},), s.ios) != 0)
     return s
 end
 
 function skip(s::IOStream, delta::Integer)
-    ret = ccall(:ios_skip, FileOffset, (Ptr{Void}, FileOffset), s.ios, delta)
+    ret = ccall(:ios_skip, Int64, (Ptr{Void}, Int64), s.ios, delta)
     systemerror("skip", ret == -1)
     ret < -1 && error("skip failed")
     return s
 end
 
 function position(s::IOStream)
-    pos = ccall(:ios_pos, FileOffset, (Ptr{Void},), s.ios)
+    pos = ccall(:ios_pos, Int64, (Ptr{Void},), s.ios)
     systemerror("position", pos == -1)
     return pos
 end
 
-eof(s::IOStream) = ccall(:ios_eof_blocking, Int32, (Ptr{Void},), s.ios)!=0
+eof(s::IOStream) = ccall(:ios_eof_blocking, Cint, (Ptr{Void},), s.ios)!=0
 
 ## constructing and opening streams ##
 
 # "own" means the descriptor will be closed with the IOStream
 function fdio(name::AbstractString, fd::Integer, own::Bool=false)
     s = IOStream(name)
-    ccall(:ios_fd, Ptr{Void}, (Ptr{Void}, Clong, Int32, Int32),
+    ccall(:ios_fd, Ptr{Void}, (Ptr{Void}, Clong, Cint, Cint),
           s.ios, fd, 0, own);
     return s
 end
@@ -89,10 +89,10 @@ function open(fname::AbstractString, rd::Bool, wr::Bool, cr::Bool, tr::Bool, ff:
     s = IOStream(string("<file ",fname,">"))
     systemerror("opening file $fname",
                 ccall(:ios_file, Ptr{Void},
-                      (Ptr{UInt8}, Cstring, Int32, Int32, Int32, Int32),
+                      (Ptr{UInt8}, Cstring, Cint, Cint, Cint, Cint),
                       s.ios, fname, rd, wr, cr, tr) == C_NULL)
     if ff
-        systemerror("seeking to end of file $fname", ccall(:ios_seek_end, FileOffset, (Ptr{Void},), s.ios) != 0)
+        systemerror("seeking to end of file $fname", ccall(:ios_seek_end, Int64, (Ptr{Void},), s.ios) != 0)
     end
     return s
 end
@@ -119,25 +119,13 @@ end
 
 ## low-level calls ##
 
-write(s::IOStream, b::UInt8) = Int(ccall(:ios_putc, Int32, (UInt8, Ptr{Void}), b, s.ios))
+write(s::IOStream, b::UInt8) = Int(ccall(:ios_putc, Cint, (Cint, Ptr{Void}), b, s.ios))
 
-function write{T}(s::IOStream, a::Array{T})
-    if isbits(T)
-        if !iswritable(s)
-            throw(ArgumentError("write failed, IOStream is not writeable"))
-        end
-        Int(ccall(:ios_write, UInt, (Ptr{Void}, Ptr{Void}, UInt),
-                  s.ios, a, length(a)*sizeof(T)))
-    else
-        invoke(write, Tuple{IO, Array}, s, a)
-    end
-end
-
-function write(s::IOStream, p::Ptr, nb::Integer)
+function unsafe_write(s::IOStream, p::Ptr{UInt8}, nb::UInt)
     if !iswritable(s)
         throw(ArgumentError("write failed, IOStream is not writeable"))
     end
-    Int(ccall(:ios_write, UInt, (Ptr{Void}, Ptr{Void}, UInt), s.ios, p, nb))
+    return Int(ccall(:ios_write, Csize_t, (Ptr{Void}, Ptr{Void}, Csize_t), s.ios, p, nb))
 end
 
 function write{T,N,A<:Array}(s::IOStream, a::SubArray{T,N,A})
@@ -146,10 +134,10 @@ function write{T,N,A<:Array}(s::IOStream, a::SubArray{T,N,A})
     end
     colsz = size(a,1)*sizeof(T)
     if N<=1
-        return write(s, pointer(a, 1), colsz)
+        return unsafe_write(s, pointer(a, 1), colsz)
     else
         for idxs in CartesianRange((1, size(a)[2:end]...))
-            write(s, pointer(a, idxs.I), colsz)
+            unsafe_write(s, pointer(a, idxs.I), colsz)
         end
         return colsz*trailingsize(a,2)
     end
@@ -158,29 +146,28 @@ end
 # num bytes available without blocking
 nb_available(s::IOStream) = ccall(:jl_nb_available, Int32, (Ptr{Void},), s.ios)
 
+readavailable(s::IOStream) = read!(s, Vector{UInt8}(nb_available(s)))
+
 function read(s::IOStream, ::Type{UInt8})
-    b = ccall(:ios_getc, Int32, (Ptr{Void},), s.ios)
+    b = ccall(:ios_getc, Cint, (Ptr{Void},), s.ios)
     if b == -1
         throw(EOFError())
     end
-    b % UInt8
+    return b % UInt8
 end
 
-function read{T<:Union{UInt16, Int16, UInt32, Int32, UInt64, Int64}}(s::IOStream, ::Type{T})
-    ccall(:jl_ios_get_nbyte_int, UInt64, (Ptr{Void}, Csize_t), s.ios, sizeof(T)) % T
+if ENDIAN_BOM == 0x04030201
+function read(s::IOStream, T::Union{Type{Int16},Type{UInt16},Type{Int32},Type{UInt32},Type{Int64},Type{UInt64}})
+    return ccall(:jl_ios_get_nbyte_int, UInt64, (Ptr{Void}, Csize_t), s.ios, sizeof(T)) % T
+end
 end
 
-function read!{T}(s::IOStream, a::Array{T})
-    if isbits(T)
-        nb = length(a)*sizeof(T)
-        if ccall(:ios_readall, UInt,
-                 (Ptr{Void}, Ptr{Void}, UInt), s.ios, a, nb) < nb
-            throw(EOFError())
-        end
-    else
-        invoke(read!, Tuple{IO, Array}, s, a)
+function unsafe_read(s::IOStream, p::Ptr{UInt8}, nb::UInt)
+    if ccall(:ios_readall, Csize_t,
+             (Ptr{Void}, Ptr{Void}, Csize_t), s, p, nb) != nb
+        throw(EOFError())
     end
-    a
+    nothing
 end
 
 ## text I/O ##
@@ -189,9 +176,9 @@ function write(s::IOStream, c::Char)
     if !iswritable(s)
         throw(ArgumentError("write failed, IOStream is not writeable"))
     end
-    Int(ccall(:ios_pututf8, Int32, (Ptr{Void}, Char), s.ios, c))
+    Int(ccall(:ios_pututf8, Cint, (Ptr{Void}, UInt32), s.ios, c))
 end
-read(s::IOStream, ::Type{Char}) = ccall(:jl_getutf8, Char, (Ptr{Void},), s.ios)
+read(s::IOStream, ::Type{Char}) = Char(ccall(:jl_getutf8, UInt32, (Ptr{Void},), s.ios))
 
 takebuf_string(s::IOStream) =
     ccall(:jl_takebuf_string, Any, (Ptr{Void},), s.ios)::ByteString
@@ -205,15 +192,6 @@ function takebuf_raw(s::IOStream)
     return buf, sz
 end
 
-function sprint(size::Integer, f::Function, args...)
-    s = IOBuffer(Array(UInt8,size), true, true)
-    truncate(s,0)
-    f(s, args...)
-    takebuf_string(s)
-end
-
-sprint(f::Function, args...) = sprint(0, f, args...)
-
 write(x) = write(STDOUT::IO, x)
 
 function readuntil(s::IOStream, delim::UInt8)
@@ -228,7 +206,7 @@ function readbytes_all!(s::IOStream, b::Array{UInt8}, nb)
             lb = max(65536, (nr+1) * 2)
             resize!(b, lb)
         end
-        nr += Int(ccall(:ios_readall, UInt, (Ptr{Void}, Ptr{Void}, UInt),
+        nr += Int(ccall(:ios_readall, Csize_t, (Ptr{Void}, Ptr{Void}, Csize_t),
                         s.ios, pointer(b, nr+1), min(lb-nr, nb-nr)))
         eof(s) && break
     end
@@ -243,7 +221,7 @@ function readbytes_some!(s::IOStream, b::Array{UInt8}, nb)
     if nb > lb
         resize!(b, nb)
     end
-    nr = Int(ccall(:ios_read, UInt, (Ptr{Void}, Ptr{Void}, UInt),
+    nr = Int(ccall(:ios_read, Csize_t, (Ptr{Void}, Ptr{Void}, Csize_t),
                    s.ios, pointer(b), nb))
     if lb > olb && lb > nr
         resize!(b, nr)
@@ -255,11 +233,11 @@ function readbytes!(s::IOStream, b::Array{UInt8}, nb=length(b); all::Bool=true)
     return all ? readbytes_all!(s, b, nb) : readbytes_some!(s, b, nb)
 end
 
-function readbytes(s::IOStream)
+function read(s::IOStream)
     sz = 0
     try # filesize is just a hint, so ignore if it fails
         sz = filesize(s)
-        pos = ccall(:ios_pos, FileOffset, (Ptr{Void},), s.ios)
+        pos = ccall(:ios_pos, Int64, (Ptr{Void},), s.ios)
         if pos > 0
             sz -= pos
         end
@@ -269,7 +247,7 @@ function readbytes(s::IOStream)
     resize!(b, nr)
 end
 
-function readbytes(s::IOStream, nb::Integer; all::Bool=true)
+function read(s::IOStream, nb::Integer; all::Bool=true)
     b = Array(UInt8, nb)
     nr = readbytes!(s, b, nb, all=all)
     resize!(b, nr)
@@ -278,14 +256,14 @@ end
 ## Character streams ##
 const _chtmp = Array(Char, 1)
 function peekchar(s::IOStream)
-    if ccall(:ios_peekutf8, Int32, (Ptr{Void}, Ptr{Char}), s, _chtmp) < 0
+    if ccall(:ios_peekutf8, Cint, (Ptr{Void}, Ptr{Char}), s, _chtmp) < 0
         return Char(-1)
     end
     return _chtmp[1]
 end
 
 function peek(s::IOStream)
-    ccall(:ios_peekc, Int32, (Ptr{Void},), s)
+    ccall(:ios_peekc, Cint, (Ptr{Void},), s)
 end
 
 function skipchars(s::IOStream, pred; linecomment::Char=Char(0xffffffff))
diff --git a/base/irrationals.jl b/base/irrationals.jl
index 7e7d1342f4a1f..0fb91aee4f138 100644
--- a/base/irrationals.jl
+++ b/base/irrationals.jl
@@ -15,7 +15,7 @@ convert(::Type{Float16}, x::Irrational) = Float16(Float32(x))
 convert{T<:Real}(::Type{Complex{T}}, x::Irrational) = convert(Complex{T}, convert(T,x))
 convert{T<:Integer}(::Type{Rational{T}}, x::Irrational) = convert(Rational{T}, Float64(x))
 
-@generated function call{T<:Union{Float32,Float64},s}(t::Type{T},c::Irrational{s},r::RoundingMode)
+@generated function (t::Type{T}){T<:Union{Float32,Float64},s}(c::Irrational{s},r::RoundingMode)
     f = T(big(c()),r())
     :($f)
 end
@@ -34,10 +34,10 @@ end
 <(x::Float32, y::Irrational) = x <= Float32(y,RoundDown)
 <(x::Irrational, y::Float16) = Float32(x,RoundUp) <= y
 <(x::Float16, y::Irrational) = x <= Float32(y,RoundDown)
-<(x::Irrational, y::BigFloat) = with_bigfloat_precision(precision(y)+32) do
+<(x::Irrational, y::BigFloat) = setprecision(precision(y)+32) do
     big(x) < y
 end
-<(x::BigFloat, y::Irrational) = with_bigfloat_precision(precision(x)+32) do
+<(x::BigFloat, y::Irrational) = setprecision(precision(x)+32) do
     x < big(y)
 end
 
@@ -122,17 +122,16 @@ const golden = φ
 for T in (Irrational, Rational, Integer, Number)
     ^(::Irrational{:e}, x::T) = exp(x)
 end
-for T in (Range, BitArray, SparseMatrixCSC, StridedArray, AbstractArray)
+for T in (Range, BitArray, StridedArray, AbstractArray)
     .^(::Irrational{:e}, x::T) = exp(x)
 end
-^(::Irrational{:e}, x::AbstractMatrix) = expm(x)
 
 log(::Irrational{:e}) = 1 # use 1 to correctly promote expressions like log(x)/log(e)
 log(::Irrational{:e}, x) = log(x)
 
 # align along = for nice Array printing
-function alignment(x::Irrational)
-    m = match(r"^(.*?)(=.*)$", sprint(showcompact_lim, x))
-    m === nothing ? (length(sprint(showcompact_lim, x)), 0) :
+function alignment(io::IO, x::Irrational)
+    m = match(r"^(.*?)(=.*)$", sprint(0, showcompact_lim, x, env=io))
+    m === nothing ? (length(sprint(0, showcompact_lim, x, env=io)), 0) :
     (length(m.captures[1]), length(m.captures[2]))
 end
diff --git a/base/iterator.jl b/base/iterator.jl
index d3f76c1e83f0c..0b526aae32cbf 100644
--- a/base/iterator.jl
+++ b/base/iterator.jl
@@ -23,11 +23,23 @@ eltype{I}(::Type{Enumerate{I}}) = Tuple{Int, eltype(I)}
 
 abstract AbstractZipIterator
 
+immutable Zip1{I} <: AbstractZipIterator
+    a::I
+end
+zip(a) = Zip1(a)
+length(z::Zip1) = length(z.a)
+eltype{I}(::Type{Zip1{I}}) = Tuple{eltype(I)}
+start(z::Zip1) = (start(z.a),)
+function next(z::Zip1, st)
+    n = next(z.a,st[1])
+    return ((n[1],), (n[2],))
+end
+done(z::Zip1, st) = done(z.a,st[1])
+
 immutable Zip2{I1, I2} <: AbstractZipIterator
     a::I1
     b::I2
 end
-zip(a) = a
 zip(a, b) = Zip2(a, b)
 length(z::Zip2) = min(length(z.a), length(z.b))
 eltype{I1,I2}(::Type{Zip2{I1,I2}}) = Tuple{eltype(I1), eltype(I2)}
@@ -45,7 +57,9 @@ immutable Zip{I, Z<:AbstractZipIterator} <: AbstractZipIterator
 end
 zip(a, b, c...) = Zip(a, zip(b, c...))
 length(z::Zip) = min(length(z.a), length(z.z))
-@generated function tuple_type_cons{S,T<:Tuple}(::Type{S}, ::Type{T})
+tuple_type_cons{S}(::Type{S}, ::Type{Union{}}) = Union{}
+function tuple_type_cons{S,T<:Tuple}(::Type{S}, ::Type{T})
+    @_pure_meta
     Tuple{S, T.parameters...}
 end
 eltype{I,Z}(::Type{Zip{I,Z}}) = tuple_type_cons(eltype(I), eltype(Z))
@@ -210,3 +224,120 @@ next(it::Repeated, state) = (it.x, nothing)
 done(it::Repeated, state) = false
 
 repeated(x, n::Int) = take(repeated(x), n)
+
+# product
+
+abstract AbstractProdIterator
+
+immutable Prod2{I1, I2} <: AbstractProdIterator
+    a::I1
+    b::I2
+end
+
+"""
+    product(iters...)
+
+Returns an iterator over the product of several iterators. Each generated element is
+a tuple whose `i`th element comes from the `i`th argument iterator. The first iterator
+changes the fastest. Example:
+
+    julia> collect(product(1:2,3:5))
+    6-element Array{Tuple{Int64,Int64},1}:
+     (1,3)
+     (2,3)
+     (1,4)
+     (2,4)
+     (1,5)
+     (2,5)
+"""
+product(a) = Zip1(a)
+product(a, b) = Prod2(a, b)
+eltype{I1,I2}(::Type{Prod2{I1,I2}}) = Tuple{eltype(I1), eltype(I2)}
+length(p::AbstractProdIterator) = length(p.a)*length(p.b)
+
+function start(p::AbstractProdIterator)
+    s1, s2 = start(p.a), start(p.b)
+    s1, s2, Nullable{eltype(p.b)}(), (done(p.a,s1) || done(p.b,s2))
+end
+
+@inline function prod_next(p, st)
+    s1, s2 = st[1], st[2]
+    v1, s1 = next(p.a, s1)
+
+    nv2 = st[3]
+    if isnull(nv2)
+        v2, s2 = next(p.b, s2)
+    else
+        v2 = nv2.value
+    end
+
+    if done(p.a, s1)
+        return (v1,v2), (start(p.a), s2, oftype(nv2,nothing), done(p.b,s2))
+    end
+    return (v1,v2), (s1, s2, Nullable(v2), false)
+end
+
+@inline next(p::Prod2, st) = prod_next(p, st)
+@inline done(p::AbstractProdIterator, st) = st[4]
+
+immutable Prod{I1, I2<:AbstractProdIterator} <: AbstractProdIterator
+    a::I1
+    b::I2
+end
+
+product(a, b, c...) = Prod(a, product(b, c...))
+eltype{I1,I2}(::Type{Prod{I1,I2}}) = tuple_type_cons(eltype(I1), eltype(I2))
+
+@inline function next{I1,I2}(p::Prod{I1,I2}, st)
+    x = prod_next(p, st)
+    ((x[1][1],x[1][2]...), x[2])
+end
+
+_size(p::Prod2) = (length(p.a), length(p.b))
+_size(p::Prod) = (length(p.a), _size(p.b)...)
+
+"""
+    IteratorND(iter, dims)
+
+Given an iterator `iter` and dimensions tuple `dims`, return an iterator that
+yields the same values as `iter`, but with the specified multi-dimensional shape.
+For example, this determines the shape of the array returned when `collect` is
+applied to this iterator.
+"""
+immutable IteratorND{I,N}
+    iter::I
+    dims::NTuple{N,Int}
+
+    function (::Type{IteratorND}){I,N}(iter::I, shape::NTuple{N,Integer})
+        li = length(iter)
+        if li != prod(shape)
+            throw(DimensionMismatch("dimensions $shape must be consistent with iterator length $li"))
+        end
+        new{I,N}(iter, shape)
+    end
+    (::Type{IteratorND}){I<:AbstractProdIterator}(p::I) = IteratorND(p, _size(p))
+end
+
+start(i::IteratorND) = start(i.iter)
+done(i::IteratorND, s) = done(i.iter, s)
+next(i::IteratorND, s) = next(i.iter, s)
+
+size(i::IteratorND) = i.dims
+length(i::IteratorND) = prod(size(i))
+ndims{I,N}(::IteratorND{I,N}) = N
+
+eltype{I}(::IteratorND{I}) = eltype(I)
+
+collect(i::IteratorND) = copy!(Array(eltype(i),size(i)), i)
+
+function collect{I<:IteratorND}(g::Generator{I})
+    sz = size(g.iter)
+    if length(g.iter) == 0
+        return Array(Union{}, sz)
+    end
+    st = start(g)
+    first, st = next(g, st)
+    dest = Array(typeof(first), sz)
+    dest[1] = first
+    return map_to!(g.f, 2, st, dest, g.iter)
+end
diff --git a/base/latex_symbols.jl b/base/latex_symbols.jl
index bf63a5ec9f0dc..4826701081d6f 100644
--- a/base/latex_symbols.jl
+++ b/base/latex_symbols.jl
@@ -47,16 +47,21 @@ end
 # Additional symbols were generated from the unicode-math LaTeX package
 # symbol listing, using the following script:
 #=
-# download("http://mirror.math.ku.edu/tex-archive/macros/latex/contrib/unicode-math/unicode-math-table.tex", "unicode-math-table.tex")
+fname = "unicode-math-table.tex"
+isfile(fname) || download("http://mirror.math.ku.edu/tex-archive/macros/latex/contrib/unicode-math/$fname", fname)
 const latex_strings = Set(values(Base.REPLCompletions.latex_symbols))
-open("unicode-math-table.tex") do f
+open(fname) do f
     for L in eachline(f)
         x = map(s -> rstrip(s, [' ','\t','\n']),
                 split(replace(L, r"[{}\"]+", "\t"), "\t"))
         c = Char(parse(Int, x[2], 16))
         if (Base.is_id_char(c) || Base.isoperator(symbol(c))) &&
            string(c) ∉ latex_strings && !isascii(c)
-            println("    \"", escape_string(x[3]), "\" => \"",
+            tabcomname = escape_string(x[3])
+            if startswith(tabcomname, "\\\\math")
+                tabcomname = string("\\\\", tabcomname[7:end])
+            end
+            println("    \"", tabcomname, "\" => \"",
                     escape_string("$c"), "\",  # ", x[5])
         end
     end
@@ -191,6 +196,7 @@ const latex_symbols = Dict(
     "\\_chi" => "ᵪ",
 
     # Misc. Math and Physics
+    "\\ldots" => "…",
     "\\hbar" => "ħ",
     "\\del" => "∇",
 
@@ -2543,4 +2549,21 @@ const latex_symbols = Dict(
     "\\mtteight" => "𝟾",  # mathematical monospace digit 8
     "\\mttnine" => "𝟿",  # mathematical monospace digit 9
 
+    "\\triangleright" => "▷",  # (large) right triangle, open; z notation range restriction
+    "\\triangleleft" => "◁",  # (large) left triangle, open; z notation domain restriction
+    "\\leftouterjoin" => "⟕",  # left outer join
+    "\\rightouterjoin" => "⟖",  # right outer join
+    "\\fullouterjoin" => "⟗",  # full outer join
+    "\\Join" => "⨝",  # join
+    "\\underbar" => "̲",  # combining low line
+    "\\underleftrightarrow" => "͍",  # underleftrightarrow accent
+    "\\leftwavearrow" => "↜",  # left arrow-wavy
+    "\\rightwavearrow" => "↝",  # right arrow-wavy
+    "\\varbarwedge" => "⌅",  # /barwedge b: logical and, bar above [projective (bar over small wedge)]
+    "\\smallblacktriangleright" => "▸",  # right triangle, filled
+    "\\smallblacktriangleleft" => "◂",  # left triangle, filled
+    "\\leftmoon" => "☾",  # last quarter moon
+    "\\smalltriangleright" => "▹",  # right triangle, open
+    "\\smalltriangleleft" => "◃",  # left triangle, open
+
 )
diff --git a/base/libc.jl b/base/libc.jl
index 26e1dc161d90c..7e0b0bef582c4 100644
--- a/base/libc.jl
+++ b/base/libc.jl
@@ -6,7 +6,9 @@ export FILE, TmStruct, strftime, strptime, getpid, gethostname, free, malloc, ca
     errno, strerror, flush_cstdio, systemsleep, time
 @windows_only export GetLastError, FormatMessage
 
-include("errno.jl")
+import Base: utf16to8
+
+include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","errno_h.jl"))  # include($BUILDROOT/base/errno_h.jl)
 
 ## RawFD ##
 
@@ -69,6 +71,12 @@ end
 Base.position(h::FILE) = ccall(:ftell, Clong, (Ptr{Void},), h.ptr)
 
 # flush C stdio output from external libraries
+
+"""
+    flush_cstdio()
+
+Flushes the C `stdout` and `stderr` streams (which may have been written to by external C code).
+"""
 flush_cstdio() = ccall(:jl_flush_cstdio, Void, ())
 
 ## time-related functions ##
@@ -77,6 +85,24 @@ flush_cstdio() = ccall(:jl_flush_cstdio, Void, ())
 @unix_only systemsleep(s::Real) = ccall(:usleep, Int32, (UInt32,), round(UInt32,s*1e6))
 @windows_only systemsleep(s::Real) = (ccall(:Sleep, stdcall, Void, (UInt32,), round(UInt32,s*1e3)); return Int32(0))
 
+immutable TimeVal
+   sec::Int64
+   usec::Int64
+end
+
+function TimeVal()
+    tv = Ref{TimeVal}()
+    status = ccall(:jl_gettimeofday, Cint, (Ref{TimeVal},), tv)
+    status != 0 && error("unable to determine current time: ", status)
+    return tv[]
+end
+
+"""
+    TmStruct([seconds])
+
+Convert a number of seconds since the epoch to broken-down format, with fields `sec`, `min`,
+`hour`, `mday`, `month`, `year`, `wday`, `yday`, and `isdst`.
+"""
 type TmStruct
     sec::Int32
     min::Int32
@@ -106,6 +132,13 @@ type TmStruct
     end
 end
 
+"""
+    strftime([format], time)
+
+Convert time, given as a number of seconds since the epoch or a `TmStruct`, to a formatted
+string using the given format. Supported formats are the same as those in the standard C
+library.
+"""
 strftime(t) = strftime("%c", t)
 strftime(fmt::AbstractString, t::Real) = strftime(fmt, TmStruct(t))
 function strftime(fmt::AbstractString, tm::TmStruct)
@@ -118,10 +151,20 @@ function strftime(fmt::AbstractString, tm::TmStruct)
     bytestring(pointer(timestr), n)
 end
 
+"""
+    strptime([format], timestr)
+
+Parse a formatted time string into a `TmStruct` giving the seconds, minute, hour, date, etc.
+Supported formats are the same as those in the standard C library. On some platforms,
+timezones will not be parsed correctly. If the result of this function will be passed to
+`time` to convert it to seconds since the epoch, the `isdst` field should be filled in
+manually. Setting it to `-1` will tell the C library to use the current system settings to
+determine the timezone.
+"""
 strptime(timestr::AbstractString) = strptime("%c", timestr)
 function strptime(fmt::AbstractString, timestr::AbstractString)
     tm = TmStruct()
-    r = ccall(:strptime, Ptr{UInt8}, (Cstring, Cstring, Ptr{TmStruct}),
+    r = ccall(:strptime, Cstring, (Cstring, Cstring, Ptr{TmStruct}),
               timestr, fmt, &tm)
     # the following would tell mktime() that this is a local time, and that
     # it should try to guess the timezone. not sure if/how this should be
@@ -142,8 +185,14 @@ function strptime(fmt::AbstractString, timestr::AbstractString)
 end
 
 # system date in seconds
+
+"""
+    time(t::TmStruct)
+
+Converts a `TmStruct` struct to a number of seconds since the epoch.
+"""
 time(tm::TmStruct) = Float64(ccall(:mktime, Int, (Ptr{TmStruct},), &tm))
-time() = ccall(:clock_now, Float64, ())
+time() = ccall(:jl_clock_now, Float64, ())
 
 ## process-related functions ##
 
@@ -161,39 +210,99 @@ end
 
 ## system error handling ##
 
+"""
+    errno([code])
+
+Get the value of the C library's `errno`. If an argument is specified, it is used to set the
+value of `errno`.
+
+The value of `errno` is only valid immediately after a `ccall` to a C library routine that
+sets it. Specifically, you cannot call `errno` at the next prompt in a REPL, because lots of
+code is executed between prompts.
+"""
 errno() = ccall(:jl_errno, Cint, ())
 errno(e::Integer) = ccall(:jl_set_errno, Void, (Cint,), e)
-strerror(e::Integer) = bytestring(ccall(:strerror, Ptr{UInt8}, (Int32,), e))
+
+"""
+    strerror(n=errno())
+
+Convert a system call error code to a descriptive string
+"""
+strerror(e::Integer) = bytestring(ccall(:strerror, Cstring, (Int32,), e))
 strerror() = strerror(errno())
 
+"""
+    GetLastError()
+
+Call the Win32 `GetLastError` function [only available on Windows].
+"""
+function GetLastError end
+
+"""
+    FormatMessage(n=GetLastError())
+
+Convert a Win32 system call error code to a descriptive string [only available on Windows].
+"""
+function FormatMessage end
+
 @windows_only begin
-GetLastError() = ccall(:GetLastError,stdcall,UInt32,())
-function FormatMessage(e=GetLastError())
-    const FORMAT_MESSAGE_ALLOCATE_BUFFER = UInt32(0x100)
-    const FORMAT_MESSAGE_FROM_SYSTEM = UInt32(0x1000)
-    const FORMAT_MESSAGE_IGNORE_INSERTS = UInt32(0x200)
-    const FORMAT_MESSAGE_MAX_WIDTH_MASK = UInt32(0xFF)
-    lpMsgBuf = Array(Ptr{UInt16})
-    lpMsgBuf[1] = 0
-    len = ccall(:FormatMessageW,stdcall,UInt32,(Cint, Ptr{Void}, Cint, Cint, Ptr{Ptr{UInt16}}, Cint, Ptr{Void}),
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK,
-        C_NULL, e, 0, lpMsgBuf, 0, C_NULL)
-    p = lpMsgBuf[1]
-    len == 0 && return utf8("")
-    len = len + 1
-    buf = Array(UInt16, len)
-    unsafe_copy!(pointer(buf), p, len)
-    ccall(:LocalFree,stdcall,Ptr{Void},(Ptr{Void},),p)
-    return utf8(UTF16String(buf))
-end
+    GetLastError() = ccall(:GetLastError,stdcall,UInt32,())
+
+    function FormatMessage(e=GetLastError())
+        const FORMAT_MESSAGE_ALLOCATE_BUFFER = UInt32(0x100)
+        const FORMAT_MESSAGE_FROM_SYSTEM = UInt32(0x1000)
+        const FORMAT_MESSAGE_IGNORE_INSERTS = UInt32(0x200)
+        const FORMAT_MESSAGE_MAX_WIDTH_MASK = UInt32(0xFF)
+        lpMsgBuf = Array(Ptr{UInt16})
+        lpMsgBuf[1] = 0
+        len = ccall(:FormatMessageW,stdcall,UInt32,(Cint, Ptr{Void}, Cint, Cint, Ptr{Ptr{UInt16}}, Cint, Ptr{Void}),
+                    FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_MAX_WIDTH_MASK,
+                    C_NULL, e, 0, lpMsgBuf, 0, C_NULL)
+        p = lpMsgBuf[1]
+        len == 0 && return utf8("")
+        buf = Array(UInt16, len)
+        unsafe_copy!(pointer(buf), p, len)
+        ccall(:LocalFree,stdcall,Ptr{Void},(Ptr{Void},),p)
+        return UTF8String(utf16to8(buf))
+    end
 end
 
 ## Memory related ##
 
+"""
+    free(addr::Ptr)
+
+Call `free` from the C standard library. Only use this on memory obtained from `malloc`, not
+on pointers retrieved from other C libraries. `Ptr` objects obtained from C libraries should
+be freed by the free functions defined in that library, to avoid assertion failures if
+multiple `libc` libraries exist on the system.
+"""
 free(p::Ptr) = ccall(:free, Void, (Ptr{Void},), p)
+
+"""
+    malloc(size::Integer) -> Ptr{Void}
+
+Call `malloc` from the C standard library.
+"""
 malloc(size::Integer) = ccall(:malloc, Ptr{Void}, (Csize_t,), size)
+
+"""
+    realloc(addr::Ptr, size::Integer) -> Ptr{Void}
+
+Call `realloc` from the C standard library.
+
+See warning in the documentation for `free` regarding only using this on memory originally
+obtained from `malloc`.
+"""
 realloc(p::Ptr, size::Integer) = ccall(:realloc, Ptr{Void}, (Ptr{Void}, Csize_t), p, size)
+
+"""
+    calloc(num::Integer, size::Integer) -> Ptr{Void}
+
+Call `calloc` from the C standard library.
+"""
 calloc(num::Integer, size::Integer) = ccall(:calloc, Ptr{Void}, (Csize_t, Csize_t), num, size)
+
 free(p::Cstring) = free(convert(Ptr{UInt8}, p))
 free(p::Cwstring) = free(convert(Ptr{Cwchar_t}, p))
 
diff --git a/base/libdl.jl b/base/libdl.jl
index fcecd48c071a0..d4f0be27601e9 100644
--- a/base/libdl.jl
+++ b/base/libdl.jl
@@ -20,36 +20,84 @@ const RTLD_NOLOAD    = 0x00000020
 const RTLD_DEEPBIND  = 0x00000040
 const RTLD_FIRST     = 0x00000080
 
+"""
+    dlsym(handle, sym)
+
+Look up a symbol from a shared library handle, return callable function pointer on success.
+"""
 function dlsym(hnd::Ptr, s::Union{Symbol,AbstractString})
     hnd == C_NULL && throw(ArgumentError("NULL library handle"))
     ccall(:jl_dlsym, Ptr{Void}, (Ptr{Void}, Cstring), hnd, s)
 end
 
+"""
+    dlsym_e(handle, sym)
+
+Look up a symbol from a shared library handle, silently return `NULL` pointer on lookup failure.
+"""
 function dlsym_e(hnd::Ptr, s::Union{Symbol,AbstractString})
     hnd == C_NULL && throw(ArgumentError("NULL library handle"))
     ccall(:jl_dlsym_e, Ptr{Void}, (Ptr{Void}, Cstring), hnd, s)
 end
 
+"""
+    dlopen(libfile::AbstractString [, flags::Integer])
+
+Load a shared library, returning an opaque handle.
+
+The optional flags argument is a bitwise-or of zero or more of `RTLD_LOCAL`, `RTLD_GLOBAL`,
+`RTLD_LAZY`, `RTLD_NOW`, `RTLD_NODELETE`, `RTLD_NOLOAD`, `RTLD_DEEPBIND`, and `RTLD_FIRST`.
+These are converted to the corresponding flags of the POSIX (and/or GNU libc and/or MacOS)
+dlopen command, if possible, or are ignored if the specified functionality is not available
+on the current platform. The default flags are platform specific. On MacOS the default
+`dlopen` flags are `RTLD_LAZY|RTLD_DEEPBIND|RTLD_GLOBAL` while on other platforms the
+defaults are `RTLD_LAZY|RTLD_DEEPBIND|RTLD_LOCAL`. An important usage of these flags is to
+specify non default behavior for when the dynamic library loader binds library references to
+exported symbols and if the bound references are put into process local or global scope. For
+instance `RTLD_LAZY|RTLD_DEEPBIND|RTLD_GLOBAL` allows the library's symbols to be available
+for usage in other shared libraries, addressing situations where there are dependencies
+between shared libraries.
+"""
+function dlopen end
+
 dlopen(s::Symbol, flags::Integer = RTLD_LAZY | RTLD_DEEPBIND) =
     dlopen(string(s), flags)
 
 dlopen(s::AbstractString, flags::Integer = RTLD_LAZY | RTLD_DEEPBIND) =
     ccall(:jl_load_dynamic_library, Ptr{Void}, (Cstring,UInt32), s, flags)
 
+"""
+    dlopen_e(libfile::AbstractString [, flags::Integer])
+
+Similar to [`dlopen`](:func:`dlopen`), except returns a `NULL` pointer instead of raising errors.
+"""
+function dlopen_e end
+
 dlopen_e(s::Symbol, flags::Integer = RTLD_LAZY | RTLD_DEEPBIND) =
     dlopen_e(string(s), flags)
 
 dlopen_e(s::AbstractString, flags::Integer = RTLD_LAZY | RTLD_DEEPBIND) =
     ccall(:jl_load_dynamic_library_e, Ptr{Void}, (Cstring,UInt32), s, flags)
 
+"""
+    dlclose(handle)
+
+Close shared library referenced by handle.
+"""
 function dlclose(p::Ptr)
-    if p != C_NULL
-        ccall(:uv_dlclose,Void,(Ptr{Void},),p)
-        Libc.free(p)
-    end
+    0 == ccall(:jl_dlclose, Cint, (Ptr{Void},), p)
 end
 
-function find_library(libnames::Vector, extrapaths::Vector=ASCIIString[])
+"""
+    find_library(names, locations)
+
+Searches for the first library in `names` in the paths in the `locations` list,
+`DL_LOAD_PATH`, or system library paths (in that order) which can successfully be dlopen'd.
+On success, the return value will be one of the names (potentially prefixed by one of the
+paths in locations). This string can be assigned to a `global const` and used as the library
+name in future `ccall`'s. On failure, it returns the empty string.
+"""
+function find_library(libnames, extrapaths=ASCIIString[])
     for lib in libnames
         for path in extrapaths
             l = joinpath(path, lib)
@@ -67,9 +115,11 @@ function find_library(libnames::Vector, extrapaths::Vector=ASCIIString[])
     end
     return ""
 end
+find_library(libname::Union{Symbol,AbstractString}, extrapaths=ASCIIString[]) =
+    find_library([string(libname)], extrapaths)
 
 function dlpath(handle::Ptr{Void})
-    p = ccall(:jl_pathname_for_handle, Ptr{UInt8}, (Ptr{Void},), handle)
+    p = ccall(:jl_pathname_for_handle, Cstring, (Ptr{Void},), handle)
     s = bytestring(p)
     @windows_only Libc.free(p)
     return s
@@ -91,6 +141,13 @@ else
     const dlext = "so"
 end
 
+"""
+    dlext
+
+File extension for dynamic libraries (e.g. dll, dylib, so) on the current platform.
+"""
+dlext
+
 @linux_only begin
     immutable dl_phdr_info
         # Base address of object
@@ -131,7 +188,7 @@ function dllist()
 
         # start at 1 instead of 0 to skip self
         for i in 1:numImages-1
-            name = bytestring(ccall(:_dyld_get_image_name, Ptr{UInt8}, (UInt32,), i))
+            name = bytestring(ccall(:_dyld_get_image_name, Cstring, (UInt32,), i))
             push!(dynamic_libraries, name)
         end
     end
diff --git a/base/libgit2.jl b/base/libgit2.jl
new file mode 100644
index 0000000000000..3fdae6c88878a
--- /dev/null
+++ b/base/libgit2.jl
@@ -0,0 +1,522 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+module LibGit2
+
+import Base: merge!, cat, ==
+
+export with, GitRepo, GitConfig
+
+const GITHUB_REGEX =
+    r"^(?:git@|git://|https://(?:[\w\.\+\-]+@)?)github.com[:/](([^/].+)/(.+?))(?:\.git)?$"i
+
+include("libgit2/utils.jl")
+include("libgit2/consts.jl")
+include("libgit2/types.jl")
+include("libgit2/error.jl")
+include("libgit2/signature.jl")
+include("libgit2/oid.jl")
+include("libgit2/reference.jl")
+include("libgit2/commit.jl")
+include("libgit2/repository.jl")
+include("libgit2/config.jl")
+include("libgit2/walker.jl")
+include("libgit2/remote.jl")
+include("libgit2/strarray.jl")
+include("libgit2/index.jl")
+include("libgit2/merge.jl")
+include("libgit2/tag.jl")
+include("libgit2/blob.jl")
+include("libgit2/diff.jl")
+include("libgit2/rebase.jl")
+include("libgit2/status.jl")
+include("libgit2/tree.jl")
+include("libgit2/callbacks.jl")
+
+using .Error
+
+immutable State
+    head::Oid
+    index::Oid
+    work::Oid
+end
+
+"""Return HEAD Oid as string"""
+function head(pkg::AbstractString)
+    with(GitRepo, pkg) do repo
+        string(head_oid(repo))
+    end
+end
+
+""" git update-index """
+function need_update(repo::GitRepo)
+    if !isbare(repo)
+        # read updates index from filesystem
+        read!(repo, true)
+    end
+end
+
+""" Checks if commit is in repository """
+function iscommit(id::AbstractString, repo::GitRepo)
+    res = true
+    try
+        c = get(GitCommit, repo, id)
+        if c === nothing
+            res = false
+        else
+            finalize(c)
+        end
+    catch
+        res = false
+    end
+    return res
+end
+
+""" git diff-index HEAD [-- <path>]"""
+isdirty(repo::GitRepo, paths::AbstractString=""; cached::Bool=false) =
+    isdiff(repo, Consts.HEAD_FILE, paths, cached=cached)
+
+""" git diff-index <treeish> [-- <path>]"""
+function isdiff(repo::GitRepo, treeish::AbstractString, paths::AbstractString=""; cached::Bool=false)
+    tree_oid = revparseid(repo, "$treeish^{tree}")
+    iszero(tree_oid) && return true
+    result = false
+    tree = get(GitTree, repo, tree_oid)
+    try
+        diff = diff_tree(repo, tree, paths)
+        result = count(diff) > 0
+        finalize(diff)
+    catch err
+        result = true
+    finally
+        finalize(tree)
+    end
+    return result
+end
+
+""" git diff --name-only --diff-filter=<filter> <branch1> <branch2> """
+function diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractString;
+                    filter::Set{Cint}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED]))
+    b1_id = revparseid(repo, branch1*"^{tree}")
+    b2_id = revparseid(repo, branch2*"^{tree}")
+    tree1 = get(GitTree, repo, b1_id)
+    tree2 = get(GitTree, repo, b2_id)
+    files = AbstractString[]
+    try
+        diff = diff_tree(repo, tree1, tree2)
+        for i in 1:count(diff)
+            delta = diff[i]
+            delta === nothing && break
+            if delta.status in filter
+                push!(files, bytestring(delta.new_file.path))
+            end
+        end
+        finalize(diff)
+    finally
+        finalize(tree1)
+        finalize(tree2)
+    end
+    return files
+end
+
+function is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo)
+    A = revparseid(repo, a)
+    merge_base(repo, a, b) == A
+end
+
+function set_remote_url(repo::GitRepo, url::AbstractString; remote::AbstractString="origin")
+    with(GitConfig, repo) do cfg
+        set!(cfg, "remote.$remote.url", url)
+
+        m = match(GITHUB_REGEX,url)
+        if m !== nothing
+            push = "git@github.com:$(m.captures[1]).git"
+            if push != url
+                set!(cfg, "remote.$remote.pushurl", push)
+            end
+        end
+    end
+end
+
+function set_remote_url(path::AbstractString, url::AbstractString; remote::AbstractString="origin")
+    with(GitRepo, path) do repo
+        set_remote_url(repo, url, remote=remote)
+    end
+end
+
+""" git fetch [<url>|<repository>] [<refspecs>]"""
+function fetch{T<:AbstractString, P<:AbstractPayload}(repo::GitRepo;
+                                  remote::AbstractString="origin",
+                                  remoteurl::AbstractString="",
+                                  refspecs::Vector{T}=AbstractString[],
+                                  payload::Nullable{P}=Nullable{AbstractPayload}())
+    rmt = if isempty(remoteurl)
+        get(GitRemote, repo, remote)
+    else
+        GitRemoteAnon(repo, remoteurl)
+    end
+    try
+        fo = FetchOptions(callbacks=RemoteCallbacks(credentials_cb(), payload))
+        fetch(rmt, refspecs, msg="from $(url(rmt))", options = fo)
+    catch err
+        warn("fetch: $err")
+    finally
+        finalize(rmt)
+    end
+end
+
+""" git push [<url>|<repository>] [<refspecs>]"""
+function push{T<:AbstractString, P<:AbstractPayload}(repo::GitRepo;
+              remote::AbstractString="origin",
+              remoteurl::AbstractString="",
+              refspecs::Vector{T}=AbstractString[],
+              force::Bool=false,
+              payload::Nullable{P}=Nullable{AbstractPayload}())
+    rmt = if isempty(remoteurl)
+        get(GitRemote, repo, remote)
+    else
+        GitRemoteAnon(repo, remoteurl)
+    end
+    try
+        push_opts=PushOptions(callbacks=RemoteCallbacks(credentials_cb(), payload))
+        push(rmt, refspecs, force=force, options=push_opts)
+    finally
+        finalize(rmt)
+    end
+end
+
+""" git branch """
+function branch(repo::GitRepo)
+    head_ref = head(repo)
+    try
+        branch(head_ref)
+    finally
+        finalize(head_ref)
+    end
+end
+
+""" git checkout [-b|-B] <branch> [<start-point>] [--track <remote>/<branch>] """
+function branch!(repo::GitRepo, branch_name::AbstractString,
+                 commit::AbstractString = ""; # start point
+                 track::AbstractString  = "", # track remote branch
+                 force::Bool=false,           # force branch creation
+                 set_head::Bool=true)         # set as head reference on exit
+    # try to lookup branch first
+    branch_ref = force ? nothing : lookup_branch(repo, branch_name)
+    if branch_ref === nothing
+        # if commit is empty get head commit oid
+        commit_id = if isempty(commit)
+             with(head(repo)) do head_ref
+                with(peel(GitCommit, head_ref)) do hrc
+                    Oid(hrc)
+                end
+            end
+        else
+            Oid(commit)
+        end
+        iszero(commit_id) && return
+        cmt =  get(GitCommit, repo, commit_id)
+        try
+            branch_ref = create_branch(repo, branch_name, cmt, force=force)
+        finally
+            finalize(cmt)
+        end
+    end
+    try
+        #TODO: what if branch tracks other then "origin" remote
+        if !isempty(track) # setup tracking
+            try
+                with(GitConfig, repo) do cfg
+                    set!(cfg, "branch.$branch_name.remote", Consts.REMOTE_ORIGIN)
+                    set!(cfg, "branch.$branch_name.merge", name(branch_ref))
+                end
+            catch
+                warn("Please provide remote tracking for branch '$branch_name' in '$(path(repo))'")
+            end
+        end
+
+        if set_head
+            # checkout selected branch
+            with(peel(GitTree, branch_ref)) do btree
+                checkout_tree(repo, btree)
+            end
+
+            # switch head to the branch
+            head!(repo, branch_ref)
+        end
+    finally
+        finalize(branch_ref)
+    end
+    return
+end
+
+""" git checkout [-f] --detach <commit> """
+function checkout!(repo::GitRepo, commit::AbstractString = "";
+                  force::Bool = true)
+    # nothing to do
+    isempty(commit) && return
+
+    # grab head name
+    head_name = Consts.HEAD_FILE
+    try
+        with(head(repo)) do head_ref
+            head_name = shortname(head_ref)
+            # if it is HEAD use short OID instead
+            if head_name == Consts.HEAD_FILE
+                head_name = string(Oid(head_ref))
+            end
+        end
+    end
+
+    # search for commit to get a commit object
+    obj = get(GitAnyObject, repo, Oid(commit))
+    obj === nothing && return
+    try
+        peeled = peel(obj, Consts.OBJ_COMMIT)
+        peeled === nothing && return
+        opts = force ? CheckoutOptions(checkout_strategy = Consts.CHECKOUT_FORCE) :
+                       CheckoutOptions()
+        try
+            # detach commit
+            obj_oid = Oid(peeled)
+            ref = GitReference(repo, obj_oid, force=force,
+                msg="libgit2.checkout: moving from $head_name to $(string(obj_oid))")
+            finalize(ref)
+
+            # checkout commit
+            checkout_tree(repo, peeled, options = opts)
+        finally
+            finalize(peeled)
+        end
+    finally
+        finalize(obj)
+    end
+end
+
+""" git clone [-b <branch>] [--bare] <url> <dir> """
+function clone{P<:AbstractPayload}(repo_url::AbstractString, repo_path::AbstractString;
+               branch::AbstractString="",
+               isbare::Bool = false,
+               remote_cb::Ptr{Void} = C_NULL,
+               payload::Nullable{P}=Nullable{AbstractPayload}())
+    # setup clone options
+    fetch_opts=FetchOptions(callbacks = RemoteCallbacks(credentials_cb(), payload))
+    clone_opts = CloneOptions(
+                bare = Cint(isbare),
+                checkout_branch = isempty(branch) ? Cstring_NULL :
+                                  convert(Cstring, pointer(branch)),
+                fetch_opts=fetch_opts,
+                remote_cb = remote_cb
+            )
+    return clone(repo_url, repo_path, clone_opts)
+end
+
+""" git reset [<committish>] [--] <pathspecs>... """
+function reset!(repo::GitRepo, committish::AbstractString, pathspecs::AbstractString...)
+    target_obj = isempty(committish) ? Nullable{GitAnyObject}() :
+                                       Nullable(revparse(repo, committish))
+    try
+        reset!(repo, target_obj, pathspecs...)
+    finally
+        !isnull(target_obj) && finalize(Base.get(target_obj))
+    end
+end
+
+""" git reset [--soft | --mixed | --hard] <commit> """
+function reset!(repo::GitRepo, commit::Oid, mode::Cint = Consts.RESET_MIXED)
+    obj = get(GitAnyObject, repo, commit)
+    obj === nothing && return
+    try
+        reset!(repo, obj, mode)
+    finally
+        finalize(obj)
+    end
+end
+
+""" git cat-file <commit> """
+function cat{T<:GitObject}(repo::GitRepo, ::Type{T}, object::AbstractString)
+    obj_id = revparseid(repo, object)
+    iszero(obj_id) && return nothing
+
+    obj = get(T, repo, obj_id)
+    if isa(obj, GitBlob)
+        return bytestring(convert(Ptr{UInt8}, content(obj)))
+    else
+        return nothing
+    end
+end
+
+""" git rev-list --count <commit1> <commit2> """
+function revcount(repo::GitRepo, fst::AbstractString, snd::AbstractString)
+    fst_id = revparseid(repo, fst)
+    snd_id = revparseid(repo, snd)
+    base_id = merge_base(repo, string(fst_id), string(snd_id))
+    fc = with(GitRevWalker(repo)) do walker
+        count((i,r)->i!=base_id, walker, oid=fst_id, by=Consts.SORT_TOPOLOGICAL)
+    end
+    sc = with(GitRevWalker(repo)) do walker
+        count((i,r)->i!=base_id, walker, oid=snd_id, by=Consts.SORT_TOPOLOGICAL)
+    end
+    return (fc-1, sc-1)
+end
+
+""" git merge [--ff-only] [<committish> | FETCH_HEAD] """
+function merge!(repo::GitRepo;
+                committish::AbstractString = "",
+                branch::AbstractString = "",
+                fastforward::Bool = false,
+                merge_opts::MergeOptions = MergeOptions(),
+                checkout_opts::CheckoutOptions = CheckoutOptions())
+    # merge into head branch
+    with(head(repo)) do head_ref
+        upst_anns = if !isempty(committish) # merge committish into HEAD
+            if committish == Consts.FETCH_HEAD # merge FETCH_HEAD
+                fheads = fetchheads(repo)
+                filter!(fh->fh.ismerge, fheads)
+                if isempty(fheads)
+                    throw(GitError(Error.Merge, Error.ERROR,
+                                   "There is no fetch reference for this branch."))
+                end
+                map(fh->GitAnnotated(repo,fh), fheads)
+            else # merge commitish
+                [GitAnnotated(repo, committish)]
+            end
+        else
+            if !isempty(branch) # merge provided branch into HEAD
+                with(GitReference(repo, branch)) do brn_ref
+                    [GitAnnotated(repo, brn_ref)]
+                end
+            else # try to get tracking remote branch for the head
+                if !isattached(repo)
+                    throw(GitError(Error.Merge, Error.ERROR,
+                                   "There is no tracking information for the current branch."))
+                end
+                with(upstream(head_ref)) do tr_brn_ref
+                    [GitAnnotated(repo, tr_brn_ref)]
+                end
+            end
+        end
+
+        try
+            merge!(repo, upst_anns, fastforward,
+                   merge_opts=merge_opts,
+                   checkout_opts=checkout_opts)
+        finally
+            map(finalize, upst_anns)
+        end
+    end
+end
+
+""" git rebase --merge [--onto <newbase>] [<upstream>] """
+function rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractString="")
+    with(head(repo)) do head_ref
+        head_ann = GitAnnotated(repo, head_ref)
+        upst_ann  = if isempty(upstream)
+            with(upstream(head_ref)) do brn_ref
+                GitAnnotated(repo, brn_ref)
+            end
+        else
+            GitAnnotated(repo, upstream)
+        end
+        try
+            sig = default_signature(repo)
+            try
+                rbs = GitRebase(repo, head_ann, upst_ann)
+                try
+                    while (rbs_op = next(rbs)) !== nothing
+                        commit(rbs, sig)
+                    end
+                    finish(rbs, sig)
+                catch err
+                    abort(rbs)
+                finally
+                    finalize(rbs)
+                end
+            finally
+                #!isnull(onto_ann) && finalize(get(onto_ann))
+                finalize(sig)
+            end
+        finally
+            finalize(upst_ann)
+            finalize(head_ann)
+        end
+    end
+end
+
+
+""" Returns all commit authors """
+function authors(repo::GitRepo)
+    return with(GitRevWalker(repo)) do walker
+        map((oid,repo)->with(get(GitCommit, repo, oid)) do cmt
+                            author(cmt)::Signature
+                        end,
+            walker) #, by = Consts.SORT_TIME)
+    end
+end
+
+function snapshot(repo::GitRepo)
+    head = Oid(repo, Consts.HEAD_FILE)
+    index = with(GitIndex, repo) do idx; write_tree!(idx) end
+    work = try
+        with(GitIndex, repo) do idx
+            if length(readdir(path(repo))) > 1
+                add!(idx, utf8("."))
+                write!(idx)
+            end
+            write_tree!(idx)
+        end
+    finally
+        # restore index
+        with(GitIndex, repo) do idx
+            read_tree!(idx, index)
+            write!(idx)
+        end
+    end
+    State(head, index, work)
+end
+
+function restore(s::State, repo::GitRepo)
+    reset!(repo, Consts.HEAD_FILE, "*")  # unstage everything
+    with(GitIndex, repo) do idx
+        read_tree!(idx, s.work)            # move work tree to index
+        opts = CheckoutOptions(
+                checkout_strategy = Consts.CHECKOUT_FORCE |     # check the index out to work
+                                    Consts.CHECKOUT_REMOVE_UNTRACKED) # remove everything else
+        checkout_index(repo, Nullable(idx), options = opts)
+
+        read_tree!(idx, s.index)  # restore index
+    end
+    reset!(repo, s.head, Consts.RESET_SOFT) # restore head
+end
+
+function transact(f::Function, repo::GitRepo)
+    state = snapshot(repo)
+    try f(repo) catch
+        restore(state, repo)
+        rethrow()
+    finally
+        finalize(repo)
+    end
+end
+
+function set_ssl_cert_locations(cert_file)
+    GIT_OPT_SET_SSL_CERT_LOCATIONS = 12
+    ccall((:git_libgit2_opts, :libgit2), Cint, (Cint, Cstring, Ptr{Void}),
+                        GIT_OPT_SET_SSL_CERT_LOCATIONS, cert_file, C_NULL)
+end
+
+function __init__()
+    err = ccall((:git_libgit2_init, :libgit2), Cint, ())
+    err > 0 || throw(ErrorException("error initializing LibGit2 module"))
+    atexit() do
+        ccall((:git_libgit2_shutdown, :libgit2), Cint, ())
+    end
+
+    # If we have a bundled ca cert file, point libgit2 at that so SSL connections work.
+    cert_file = abspath(ccall(:jl_get_julia_home, Any, ()),Base.DATAROOTDIR,"julia","cert.pem")
+    if isfile(cert_file)
+        set_ssl_cert_locations(cert_file)
+    end
+end
+
+
+end # module
diff --git a/base/libgit2/blob.jl b/base/libgit2/blob.jl
new file mode 100644
index 0000000000000..0777081cf22ac
--- /dev/null
+++ b/base/libgit2/blob.jl
@@ -0,0 +1,17 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function content(blob::GitBlob)
+    return ccall((:git_blob_rawcontent, :libgit2), Ptr{Void}, (Ptr{Void},), blob.ptr)
+end
+
+function Base.length(blob::GitBlob)
+    return ccall((:git_blob_rawsize, :libgit2), Int64, (Ptr{Void},), blob.ptr)
+end
+
+function lookup(repo::GitRepo, oid::Oid)
+    blob_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_blob_lookup, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ref{Oid}),
+                   blob_ptr_ptr, repo.ptr, Ref(oid))
+    return GitBlob(blob_ptr_ptr[])
+end
diff --git a/base/libgit2/callbacks.jl b/base/libgit2/callbacks.jl
new file mode 100644
index 0000000000000..b44f51530917c
--- /dev/null
+++ b/base/libgit2/callbacks.jl
@@ -0,0 +1,117 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+"""Mirror callback function
+
+Function sets `+refs/*:refs/*` refspecs and `mirror` flag for remote reference.
+"""
+function mirror_callback(remote::Ptr{Ptr{Void}}, repo_ptr::Ptr{Void},
+                         name::Cstring, url::Cstring, payload::Ptr{Void})
+    # Create the remote with a mirroring url
+    fetch_spec = "+refs/*:refs/*"
+    err = ccall((:git_remote_create_with_fetchspec, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring, Cstring),
+                remote, repo_ptr, name, url, fetch_spec)
+    err != 0 && return Cint(err)
+
+    # And set the configuration option to true for the push command
+    config = GitConfig(GitRepo(repo_ptr))
+    name_str = bytestring(name)
+    err= try set!(config, "remote.$name_str.mirror", true)
+         catch -1
+         finally finalize(config)
+         end
+    err != 0 && return Cint(err)
+    return Cint(0)
+end
+
+"""Credentials callback function
+
+Function provides different credential acquisition functionality w.r.t. a connection protocol.
+If payload is provided then `payload_ptr` should contain `LibGit2.AbstractPayload` object.
+
+For `LibGit2.Consts.CREDTYPE_USERPASS_PLAINTEXT` type, if payload contains fields: `user` & `pass` they are used to create authentication credentials.
+In addition, if payload has field `used` it can be set to `true` to indicate that payload was used and abort callback with error. This behavior is required to avoid repeated authentication calls with incorrect credentials.
+"""
+function credentials_callback(cred::Ptr{Ptr{Void}}, url_ptr::Cstring,
+                              username_ptr::Cstring,
+                              allowed_types::Cuint, payload_ptr::Ptr{Void})
+    err = 1
+    url = bytestring(url_ptr)
+
+    if isset(allowed_types, Cuint(Consts.CREDTYPE_USERPASS_PLAINTEXT))
+        username = userpass = ""
+        if payload_ptr != C_NULL
+            payload = unsafe_pointer_to_objref(payload_ptr)
+            if isa(payload, AbstractPayload)
+                isused(payload) && return Cint(-1)
+                username = user(payload)
+                userpass = password(payload)
+                setused!(payload, true)
+            end
+        end
+        if isempty(username)
+            username = prompt("Username for '$url'")
+        end
+        if isempty(userpass)
+            userpass = prompt("Password for '$username@$url'", password=true)
+        end
+
+        isempty(username) && isempty(userpass) && return Cint(-1)
+
+        err = ccall((:git_cred_userpass_plaintext_new, :libgit2), Cint,
+                     (Ptr{Ptr{Void}}, Cstring, Cstring),
+                     cred, username, userpass)
+        err == 0 && return Cint(0)
+    elseif isset(allowed_types, Cuint(Consts.CREDTYPE_SSH_KEY)) && err > 0
+        # use ssh-agent
+        err = ccall((:git_cred_ssh_key_from_agent, :libgit2), Cint,
+                     (Ptr{Ptr{Void}}, Cstring), cred, username_ptr)
+        err == 0 && return Cint(0)
+    elseif isset(allowed_types, Cuint(Consts.CREDTYPE_SSH_CUSTOM)) && err > 0
+        # for SSH we need key info, look for environment vars SSH_* as well
+
+        # if username is not provided, then prompt for it
+        username = if username_ptr == Cstring_NULL
+            prompt("Username for '$url'")
+        else
+            bytestring(username_ptr)
+        end
+
+        publickey = if "SSH_PUB_KEY" in keys(ENV)
+            ENV["GITHUB_PUB_KEY"]
+        else
+            keydef = homedir()*"/.ssh/id_rsa.pub"
+            prompt("Public key location", default=keydef)
+        end
+
+        privatekey = if "SSH_PRV_KEY" in keys(ENV)
+            ENV["GITHUB_PRV_KEY"]
+        else
+            keydef = homedir()*"/.ssh/id_rsa"
+            prompt("Private key location", default=keydef)
+        end
+
+        passphrase= get(ENV,"SSH_PRV_KEY_PASS","0") == "0" ? "" : prompt("Private key passphrase", password=true)
+
+        err = ccall((:git_cred_ssh_key_new, :libgit2), Cint,
+                     (Ptr{Ptr{Void}}, Cstring, Cstring, Cstring, Cstring),
+                     cred, username, publickey, privatekey, passphrase)
+        err == 0 && return Cint(0)
+    end
+
+    return Cint(err)
+end
+
+function fetchhead_foreach_callback(ref_name::Cstring, remote_url::Cstring,
+                        oid::Ptr{Oid}, is_merge::Cuint, payload::Ptr{Void})
+    fhead_vec = unsafe_pointer_to_objref(payload)::Vector{FetchHead}
+    push!(fhead_vec, FetchHead(bytestring(ref_name), bytestring(remote_url), Oid(oid), is_merge == 1))
+    return Cint(0)
+end
+
+"C function pointer for `mirror_callback`"
+mirror_cb() = cfunction(mirror_callback, Cint, (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring, Ptr{Void}))
+"C function pointer for `credentials_callback`"
+credentials_cb() = cfunction(credentials_callback, Cint, (Ptr{Ptr{Void}}, Cstring, Cstring, Cuint, Ptr{Void}))
+"C function pointer for `fetchhead_foreach_callback`"
+fetchhead_foreach_cb() = cfunction(fetchhead_foreach_callback, Cint, (Cstring, Cstring, Ptr{Oid}, Cuint, Ptr{Void}))
\ No newline at end of file
diff --git a/base/libgit2/commit.jl b/base/libgit2/commit.jl
new file mode 100644
index 0000000000000..0db602552d2d8
--- /dev/null
+++ b/base/libgit2/commit.jl
@@ -0,0 +1,89 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function message(c::GitCommit, raw::Bool=false)
+    local msg_ptr::Cstring
+    msg_ptr = raw? ccall((:git_commit_message_raw, :libgit2), Cstring, (Ptr{Void},), c.ptr) :
+                   ccall((:git_commit_message, :libgit2), Cstring, (Ptr{Void},), c.ptr)
+    if msg_ptr == Cstring_NULL
+        return nothing
+    end
+    return bytestring(msg_ptr)
+end
+
+function author(c::GitCommit)
+    ptr = ccall((:git_commit_author, :libgit2), Ptr{SignatureStruct}, (Ptr{Void},), c.ptr)
+    @assert ptr != C_NULL
+    return Signature(ptr)
+end
+
+function committer(c::GitCommit)
+    ptr = ccall((:git_commit_committer, :libgit2), Ptr{SignatureStruct}, (Ptr{Void},), c.ptr)
+    @assert ptr != C_NULL
+    return Signature(ptr)
+end
+
+""" Wrapper around `git_commit_create` """
+function commit(repo::GitRepo,
+                refname::AbstractString,
+                msg::AbstractString,
+                author::GitSignature,
+                committer::GitSignature,
+                tree::GitTree,
+                parents::GitCommit...)
+    commit_id_ptr = Ref(Oid())
+    nparents = length(parents)
+    parentptrs = Ptr{Void}[c.ptr for c in parents]
+    @check ccall((:git_commit_create, :libgit2), Cint,
+                 (Ptr{Oid}, Ptr{Void}, Ptr{UInt8},
+                  Ptr{SignatureStruct}, Ptr{SignatureStruct},
+                  Ptr{UInt8}, Ptr{UInt8}, Ptr{Void},
+                  Csize_t, Ptr{Ptr{Void}}),
+                 commit_id_ptr, repo.ptr, isempty(refname) ? C_NULL : refname,
+                 author.ptr, committer.ptr,
+                 C_NULL, msg, tree.ptr,
+                 nparents, nparents > 0 ? parentptrs : C_NULL)
+    return commit_id_ptr[]
+end
+
+"""Commit changes to repository"""
+function commit(repo::GitRepo, msg::AbstractString;
+                refname::AbstractString=Consts.HEAD_FILE,
+                author::Signature = Signature(repo),
+                committer::Signature = Signature(repo),
+                tree_id::Oid = Oid(),
+                parent_ids::Vector{Oid}=Oid[])
+    # Retrieve tree identifier
+    if iszero(tree_id)
+        tree_id = with(GitIndex, repo) do idx; write_tree!(idx) end
+    end
+
+    # Retrieve parents from HEAD
+    if isempty(parent_ids)
+        try # if throws then HEAD not found -> empty repo
+            push!(parent_ids, Oid(repo, refname))
+        end
+    end
+
+    # return commit id
+    commit_id  = Oid()
+
+    # get necessary objects
+    tree = get(GitTree, repo, tree_id)
+    auth_sig = convert(GitSignature, author)
+    comm_sig = convert(GitSignature, committer)
+    parents = GitCommit[]
+    try
+        for parent in parent_ids
+            push!(parents, get(GitCommit, repo, parent))
+        end
+        commit_id = commit(repo, refname, msg, auth_sig, comm_sig, tree, parents...)
+    finally
+        for parent in parents
+            finalize(parent)
+        end
+        finalize(tree)
+        finalize(auth_sig)
+        finalize(comm_sig)
+    end
+    return commit_id
+end
diff --git a/base/libgit2/config.jl b/base/libgit2/config.jl
new file mode 100644
index 0000000000000..b8aa0b33b2c34
--- /dev/null
+++ b/base/libgit2/config.jl
@@ -0,0 +1,129 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitConfig(path::AbstractString,
+                   level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_APP,
+                   force::Bool=false)
+    # create new config object
+    cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_config_new, :libgit2), Cint, (Ptr{Ptr{Void}},), cfg_ptr_ptr)
+    cfg = GitConfig(cfg_ptr_ptr[])
+    try
+        addfile(cfg, path, level, force)
+    catch ex
+        finalize(cfg)
+        throw(ex)
+    end
+    return cfg
+end
+
+function GitConfig(r::GitRepo)
+    cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_repository_config, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}), cfg_ptr_ptr, r.ptr)
+    return GitConfig(cfg_ptr_ptr[])
+end
+
+function GitConfig(level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_DEFAULT)
+    cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_config_open_default, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, ), cfg_ptr_ptr)
+    cfg = GitConfig(cfg_ptr_ptr[])
+    if level != Consts.CONFIG_LEVEL_DEFAULT
+        glb_cfg_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+        tmpcfg = cfg
+        try
+            @check ccall((:git_config_open_level, :libgit2), Cint,
+                         (Ptr{Ptr{Void}}, Ptr{Void}, Cint),
+                          glb_cfg_ptr_ptr, cfg.ptr, Cint(level))
+            cfg = GitConfig(glb_cfg_ptr_ptr[])
+        finally
+            finalize(tmpcfg)
+        end
+    end
+    return cfg
+end
+
+function addfile(cfg::GitConfig, path::AbstractString,
+                 level::Consts.GIT_CONFIG = Consts.CONFIG_LEVEL_APP,
+                 force::Bool=false)
+    @check ccall((:git_config_add_file_ondisk, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Cstring, Cint, Cint),
+                   cfg.ptr, path, Cint(level), Cint(force))
+end
+
+function get{T<:AbstractString}(::Type{T}, c::GitConfig, name::AbstractString)
+    buf_ptr = Ref(Buffer())
+    @check ccall((:git_config_get_string_buf, :libgit2), Cint,
+                (Ptr{Buffer}, Ptr{Void}, Cstring), buf_ptr, c.ptr, name)
+    return with(buf_ptr[]) do buf
+        bytestring(buf.ptr, buf.size)
+    end
+end
+
+function get(::Type{Bool}, c::GitConfig, name::AbstractString)
+    val_ptr = Ref(Cint(0))
+    @check ccall((:git_config_get_bool, :libgit2), Cint,
+          (Ptr{Cint}, Ptr{Void}, Cstring), val_ptr, c.ptr, name)
+    return Bool(val_ptr[])
+end
+
+function get(::Type{Int32}, c::GitConfig, name::AbstractString)
+    val_ptr = Ref(Cint(0))
+    @check ccall((:git_config_get_int32, :libgit2), Cint,
+          (Ptr{Cint}, Ptr{Void}, Cstring), val_ptr, c.ptr, name)
+    return val_ptr[]
+end
+
+function get(::Type{Int64}, c::GitConfig, name::AbstractString)
+    val_ptr = Ref(Cintmax_t(0))
+    @check ccall((:git_config_get_int64, :libgit2), Cint,
+          (Ptr{Cintmax_t}, Ptr{Void}, Cstring), val_ptr, c.ptr, name)
+    return val_ptr[]
+end
+
+function get{T}(c::GitConfig, name::AbstractString, default::T)
+    res = default
+    try res = get(T,c,name) end
+    return res
+end
+
+function getconfig{T}(r::GitRepo, name::AbstractString, default::T)
+    with(GitConfig, r) do cfg
+        get(cfg, name, default)
+    end
+end
+
+function getconfig{T}(rname::AbstractString, name::AbstractString, default::T)
+    with(GitRepo, rname) do r
+        with(GitConfig, r) do cfg
+            get(cfg, name, default)
+        end
+    end
+end
+
+function getconfig{T}(name::AbstractString, default::T)
+    with(GitConfig) do cfg
+        get(cfg, name, default)
+    end
+end
+
+function set!{T <: AbstractString}(c::GitConfig, name::AbstractString, value::T)
+    @check ccall((:git_config_set_string, :libgit2), Cint,
+                  (Ptr{Void}, Cstring, Cstring), c.ptr, name, value)
+end
+
+function set!(c::GitConfig, name::AbstractString, value::Bool)
+    bval = Int32(value)
+    @check ccall((:git_config_set_bool, :libgit2), Cint,
+                  (Ptr{Void}, Cstring, Cint), c.ptr, name, bval)
+end
+
+function set!(c::GitConfig, name::AbstractString, value::Int32)
+    @check ccall((:git_config_set_int32, :libgit2), Cint,
+                  (Ptr{Void}, Cstring, Cint), c.ptr, name, value)
+end
+
+function set!(c::GitConfig, name::AbstractString, value::Int64)
+    @check ccall((:git_config_set_int64, :libgit2), Cint,
+                  (Ptr{Void}, Cstring, Cintmax_t), c.ptr, name, value)
+end
diff --git a/base/libgit2/consts.jl b/base/libgit2/consts.jl
new file mode 100644
index 0000000000000..ee4c0f88d50fd
--- /dev/null
+++ b/base/libgit2/consts.jl
@@ -0,0 +1,294 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+module Consts
+
+    const HEAD_FILE  = "HEAD"
+    const FETCH_HEAD  = "FETCH_HEAD"
+    const REMOTE_ORIGIN = "origin"
+
+    # objs
+    const OBJ_ANY    = Cint(-2)
+    const OBJ_BAD    = Cint(-1)
+    const OBJ_COMMIT = Cint(1)
+    const OBJ_TREE   = Cint(2)
+    const OBJ_BLOB   = Cint(3)
+    const OBJ_TAG    = Cint(4)
+
+    #revwalk
+    const SORT_NONE        = Cint(0)
+    const SORT_TOPOLOGICAL = Cint(1 << 0)
+    const SORT_TIME        = Cint(1 << 1)
+    const SORT_REVERSE     = Cint(1 << 2)
+
+    # refs
+    const REF_INVALID  = Cint(0)
+    const REF_OID      = Cint(1)
+    const REF_SYMBOLIC = Cint(2)
+    const REF_LISTALL  = REF_OID | REF_SYMBOLIC
+
+    # checkout
+    const CHECKOUT_NONE                    = Cuint(0)
+    const CHECKOUT_SAFE                    = Cuint(1 << 0)
+    const CHECKOUT_FORCE                   = Cuint(1 << 1)
+    const CHECKOUT_RECREATE_MISSING        = Cuint(1 << 2)
+    const CHECKOUT_ALLOW_CONFLICTS         = Cuint(1 << 4)
+    const CHECKOUT_REMOVE_UNTRACKED        = Cuint(1 << 5)
+    const CHECKOUT_REMOVE_IGNORED          = Cuint(1 << 6)
+    const CHECKOUT_UPDATE_ONLY             = Cuint(1 << 7)
+    const CHECKOUT_DONT_UPDATE_INDEX       = Cuint(1 << 8)
+    const CHECKOUT_NO_REFRESH              = Cuint(1 << 9)
+    const CHECKOUT_SKIP_UNMERGED           = Cuint(1 << 10)
+    const CHECKOUT_USE_OURS                = Cuint(1 << 11)
+    const CHECKOUT_USE_THEIRS              = Cuint(1 << 12)
+    const CHECKOUT_DISABLE_PATHSPEC_MATCH  = Cuint(1 << 13)
+    const CHECKOUT_SKIP_LOCKED_DIRECTORIES = Cuint(1 << 18)
+    const CHECKOUT_DONT_OVERWRITE_IGNORED  = Cuint(1 << 19)
+    const CHECKOUT_CONFLICT_STYLE_MERGE    = Cuint(1 << 20)
+    const CHECKOUT_CONFLICT_STYLE_DIFF3    = Cuint(1 << 21)
+    const CHECKOUT_DONT_REMOVE_EXISTING    = Cuint(1 << 22)
+
+    const CHECKOUT_UPDATE_SUBMODULES       = Cuint(1 << 16)
+    const CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED = Cuint(1 << 17)
+
+    const CHECKOUT_NOTIFY_NONE      = Cuint(0)
+    const CHECKOUT_NOTIFY_CONFLICT  = Cuint(1 << 0)
+    const CHECKOUT_NOTIFY_DIRTY     = Cuint(1 << 1)
+    const CHECKOUT_NOTIFY_UPDATED   = Cuint(1 << 2)
+    const CHECKOUT_NOTIFY_UNTRACKED = Cuint(1 << 3)
+    const CHECKOUT_NOTIFY_IGNORED   = Cuint(1 << 4)
+    const CHECKOUT_NOTIFY_ALL       = 0x0FFFF
+
+    # diff
+    const DIFF_OPTIONS_VERSION = Cuint(1)
+
+    const DIFF_NORMAL                     = Cuint(0)
+    const DIFF_REVERSE                    = Cuint(1 << 0)
+    const DIFF_INCLUDE_IGNORED            = Cuint(1 << 1)
+    const DIFF_RECURSE_IGNORED_DIRS       = Cuint(1 << 2)
+    const DIFF_INCLUDE_UNTRACKED          = Cuint(1 << 3)
+    const DIFF_RECURSE_UNTRACKED_DIRS     = Cuint(1 << 4)
+    const DIFF_INCLUDE_UNMODIFIED         = Cuint(1 << 5)
+    const DIFF_INCLUDE_TYPECHANGE         = Cuint(1 << 6)
+    const DIFF_INCLUDE_TYPECHANGE_TREES   = Cuint(1 << 7)
+    const DIFF_IGNORE_FILEMODE            = Cuint(1 << 8)
+    const DIFF_IGNORE_SUBMODULES          = Cuint(1 << 9)
+    const DIFF_IGNORE_CASE                = Cuint(1 << 10)
+    const DIFF_DISABLE_PATHSPEC_MATCH     = Cuint(1 << 12)
+    const DIFF_SKIP_BINARY_CHECK          = Cuint(1 << 13)
+    const DIFF_ENABLE_FAST_UNTRACKED_DIRS = Cuint(1 << 14)
+
+    const DIFF_FORCE_TEXT               = Cuint(1 << 20)
+    const DIFF_FORCE_BINARY             = Cuint(1 << 21)
+    const DIFF_IGNORE_WHITESPACE        = Cuint(1 << 22)
+    const DIFF_IGNORE_WHITESPACE_CHANGE = Cuint(1 << 23)
+    const DIFF_IGNORE_WHITESPACE_EOL    = Cuint(1 << 24)
+    const DIFF_SHOW_UNTRACKED_CONTENT   = Cuint(1 << 25)
+    const DIFF_SHOW_UNMODIFIED          = Cuint(1 << 26)
+    const DIFF_PATIENCE                 = Cuint(1 << 28)
+    const DIFF_MINIMAL                  = Cuint(1 << 29)
+
+    const DIFF_FLAG_BINARY     = Cuint(1 << 0)
+    const DIFF_FLAG_NOT_BINARY = Cuint(1 << 1)
+    const DIFF_FLAG_VALID_OID  = Cuint(1 << 2)
+
+    const DIFF_FORMAT_PATCH        = Cuint(1)
+    const DIFF_FORMAT_PATCH_HEADER = Cuint(2)
+    const DIFF_FORMAT_RAW          = Cuint(3)
+    const DIFF_FORMAT_NAME_ONLY    = Cuint(4)
+    const DIFF_FORMAT_NAME_STATUS  = Cuint(5)
+
+    const DELTA_UNMODIFIED = Cint(0)
+    const DELTA_ADDED      = Cint(1)
+    const DELTA_DELETED    = Cint(2)
+    const DELTA_MODIFIED   = Cint(3)
+    const DELTA_RENAMED    = Cint(4)
+    const DELTA_COPIED     = Cint(5)
+    const DELTA_IGNORED    = Cint(6)
+    const DELTA_UNTRACKED  = Cint(7)
+    const DELTA_TYPECHANGE = Cint(8)
+
+    # index
+    const IDXENTRY_NAMEMASK   = (0x0fff)
+    const IDXENTRY_STAGEMASK  = (0x3000)
+    const IDXENTRY_EXTENDED   = (0x4000)
+    const IDXENTRY_VALID      = (0x8000)
+    const IDXENTRY_STAGESHIFT = Cint(12)
+
+    const IDXENTRY_UPDATE            = Cint(1 << 0)
+    const IDXENTRY_REMOVE            = Cint(1 << 1)
+    const IDXENTRY_UPTODATE          = Cint(1 << 2)
+    const IDXENTRY_ADDED             = Cint(1 << 3)
+
+    const IDXENTRY_HASHED            = Cint(1 << 4)
+    const IDXENTRY_UNHASHED          = Cint(1 << 5)
+    const IDXENTRY_WT_REMOVE         = Cint(1 << 6)
+    const IDXENTRY_CONFLICTED        = Cint(1 << 7)
+
+    const IDXENTRY_UNPACKED          = Cint(1 << 8)
+    const IDXENTRY_NEW_SKIP_WORKTREE = Cint(1 << 9)
+
+    const INDEXCAP_IGNORE_CASE = Cuint(1)
+    const INDEXCAP_NO_FILEMODE = Cuint(2)
+    const INDEXCAP_NO_SYMLINKS = Cuint(4)
+    const INDEXCAP_FROM_OWNER  = ~Cuint(0)
+
+    const INDEX_ADD_DEFAULT                = Cuint(0)
+    const INDEX_ADD_FORCE                  = Cuint(1 << 0)
+    const INDEX_ADD_DISABLE_PATHSPEC_MATCH = Cuint(1 << 1)
+    const INDEX_ADD_CHECK_PATHSPEC         = Cuint(1 << 2)
+
+    const INDEX_STAGE_ANY = Cint(-1)
+
+    # merge
+    const MERGE_TREE_FIND_RENAMES = Cint(1 << 0)
+
+    @enum(GIT_MERGE_FILE, MERGE_FILE_DEFAULT                  = 0,       # Defaults
+                          MERGE_FILE_STYLE_MERGE              = 1 << 0,  # Create standard conflicted merge files
+                          MERGE_FILE_STYLE_DIFF3              = 1 << 1,  # Create diff3-style files
+                          MERGE_FILE_SIMPLIFY_ALNUM           = 1 << 2,  # Condense non-alphanumeric regions for simplified diff file
+                          MERGE_FILE_IGNORE_WHITESPACE        = 1 << 3,  # Ignore all whitespace
+                          MERGE_FILE_IGNORE_WHITESPACE_CHANGE = 1 << 4,  # Ignore changes in amount of whitespace
+                          MERGE_FILE_IGNORE_WHITESPACE_EOL    = 1 << 5,  # Ignore whitespace at end of line
+                          MERGE_FILE_DIFF_PATIENCE            = 1 << 6,  # Use the "patience diff" algorithm
+                          MERGE_FILE_DIFF_MINIMAL             = 1 << 7)  # Take extra time to find minimal diff
+
+    @enum(GIT_MERGE_FILE_FAVOR, MERGE_FILE_FAVOR_NORMAL = 0,
+                                MERGE_FILE_FAVOR_OURS   = 1,
+                                MERGE_FILE_FAVOR_THEIRS = 2,
+                                MERGE_FILE_FAVOR_UNION  = 3)
+
+    @enum(GIT_MERGE_PREFERENCE, MERGE_PREFERENCE_NONE             = 0,
+                                MERGE_PREFERENCE_NO_FASTFORWARD   = 1,
+                                MERGE_PREFERENCE_FASTFORWARD_ONLY = 2)
+
+    @enum(GIT_MERGE_ANALYSIS, MERGE_ANALYSIS_NONE        = 0,
+                              MERGE_ANALYSIS_NORMAL      = 1 << 0,
+                              MERGE_ANALYSIS_UP_TO_DATE  = 1 << 1,
+                              MERGE_ANALYSIS_FASTFORWARD = 1 << 2,
+                              MERGE_ANALYSIS_UNBORN      = 1 << 3)
+
+    # reset
+    const RESET_SOFT  = Cint(1) # Move the head to the given commit
+    const RESET_MIXED = Cint(2) # SOFT plus reset index to the commit
+    const RESET_HARD  = Cint(3) # MIXED plus changes in working tree discarded
+
+    #rebase
+    const REBASE_OPERATION_PICK   = Cint(0)
+    const REBASE_OPERATION_REWORD = Cint(1)
+    const REBASE_OPERATION_EDIT   = Cint(2)
+    const REBASE_OPERATION_SQUASH = Cint(3)
+    const REBASE_OPERATION_FIXUP  = Cint(4)
+    const REBASE_OPERATION_EXEC   = Cint(5)
+
+    # fetch_prune
+    const FETCH_PRUNE_UNSPECIFIED = Cint(0)
+    const FETCH_PRUNE             = Cint(1)
+    const FETCH_NO_PRUNE          = Cint(2)
+
+    # remote_autotag
+    const REMOTE_DOWNLOAD_TAGS_UNSPECIFIED = Cint(0)
+    const REMOTE_DOWNLOAD_TAGS_AUTO        = Cint(1)
+    const REMOTE_DOWNLOAD_TAGS_NONE        = Cint(2)
+    const REMOTE_DOWNLOAD_TAGS_ALL         = Cint(3)
+
+    # clone
+    const CLONE_LOCAL_AUTO     = Cint(0)
+    const CLONE_LOCAL          = Cint(1)
+    const CLONE_NO_LOCAL       = Cint(2)
+    const CLONE_LOCAL_NO_LINKS = Cint(3)
+
+    # status
+    const STATUS_CURRENT          = Cuint(0)
+    const STATUS_INDEX_NEW        = Cuint(1 << 0)
+    const STATUS_INDEX_MODIFIED   = Cuint(1 << 1)
+    const STATUS_INDEX_DELETED    = Cuint(1 << 2)
+    const STATUS_INDEX_RENAMED    = Cuint(1 << 3)
+    const STATUS_INDEX_TYPECHANGE = Cuint(1 << 4)
+    const STATUS_WT_NEW           = Cuint(1 << 7)
+    const STATUS_WT_MODIFIED      = Cuint(1 << 8)
+    const STATUS_WT_DELETED       = Cuint(1 << 9)
+    const STATUS_WT_TYPECHANGE    = Cuint(1 << 10)
+    const STATUS_WT_RENAMED       = Cuint(1 << 11)
+    const STATUS_WT_UNREADABLE    = Cuint(1 << 12)
+    const STATUS_IGNORED          = Cuint(1 << 14)
+    const STATUS_CONFLICTED       = Cuint(1 << 15)
+
+    # status show
+    const STATUS_SHOW_INDEX_AND_WORKDIR = Cint(0)
+    const STATUS_SHOW_INDEX_ONLY        = Cint(1)
+    const STATUS_SHOW_WORKDIR_ONLY      = Cint(2)
+
+    # status options
+    const STATUS_OPT_INCLUDE_UNTRACKED                = Cuint(1 << 0)
+    const STATUS_OPT_INCLUDE_IGNORED                  = Cuint(1 << 1)
+    const STATUS_OPT_INCLUDE_UNMODIFIED               = Cuint(1 << 2)
+    const STATUS_OPT_EXCLUDE_SUBMODULES               = Cuint(1 << 3)
+    const STATUS_OPT_RECURSE_UNTRACKED_DIRS           = Cuint(1 << 4)
+    const STATUS_OPT_DISABLE_PATHSPEC_MATCH           = Cuint(1 << 5)
+    const STATUS_OPT_RECURSE_IGNORED_DIRS             = Cuint(1 << 6)
+    const STATUS_OPT_RENAMES_HEAD_TO_INDEX            = Cuint(1 << 7)
+    const STATUS_OPT_RENAMES_INDEX_TO_WORKDIR         = Cuint(1 << 8)
+    const STATUS_OPT_SORT_CASE_SENSITIVELY            = Cuint(1 << 9)
+    const STATUS_OPT_SORT_CASE_INSENSITIVELY          = Cuint(1 << 10)
+    const STATUS_OPT_RENAMES_FROM_REWRITES            = Cuint(1 << 11)
+    const STATUS_OPT_NO_REFRESH                       = Cuint(1 << 12)
+    const STATUS_OPT_UPDATE_INDEX                     = Cuint(1 << 13)
+    const STATUS_OPT_INCLUDE_UNREADABLE               = Cuint(1 << 14)
+    const STATUS_OPT_INCLUDE_UNREADABLE_AS_UNTRACKED  = Cuint(1 << 15)
+
+    @enum(GIT_SUBMODULE_IGNORE, SUBMODULE_IGNORE_UNSPECIFIED  = -1, # use the submodule's configuration
+                                SUBMODULE_IGNORE_NONE         = 1,  # any change or untracked == dirty
+                                SUBMODULE_IGNORE_UNTRACKED    = 2,  # dirty if tracked files change
+                                SUBMODULE_IGNORE_DIRTY        = 3,  # only dirty if HEAD moved
+                                SUBMODULE_IGNORE_ALL          = 4)  # never dirty
+
+    """
+Option flags for `GitRepo`.
+
+* `REPOSITORY_OPEN_NO_SEARCH` - Only open the repository if it can be immediately found in the `path`.  Do not walk up from the `path` looking at parent directories.
+* `REPOSITORY_OPEN_CROSS_FS` - Unless this flag is set, open will not continue searching across filesystem boundaries. (E.g. Searching in a user's home directory `/home/user/source/` will not return `/.git/` as the found repo if `/` is a different filesystem than `/home`.)
+* `REPOSITORY_OPEN_BARE` - Open repository as a bare repo regardless of core.bare config, and defer loading config file for faster setup.
+    """
+    @enum(GIT_REPOSITORY_OPEN, REPOSITORY_OPEN_DEFAULT   = 0,
+                               REPOSITORY_OPEN_NO_SEARCH = 1<<0,
+                               REPOSITORY_OPEN_CROSS_FS  = 1<<1,
+                               REPOSITORY_OPEN_BARE      = 1<<2)
+
+    @enum(GIT_BRANCH, BRANCH_LOCAL = 1, BRANCH_REMOTE = 2)
+
+    @enum(GIT_FILEMODE, FILEMODE_UNREADABLE          = 0o000000,
+                        FILEMODE_TREE                = 0o040000,
+                        FILEMODE_BLOB                = 0o100644,
+                        FILEMODE_BLOB_EXECUTABLE     = 0o100755,
+                        FILEMODE_LINK                = 0o120000,
+                        FILEMODE_COMMIT              = 0o160000)
+
+    @enum(GIT_CREDTYPE, CREDTYPE_USERPASS_PLAINTEXT = Cuint(1 << 0),
+                        CREDTYPE_SSH_KEY            = Cuint(1 << 1),
+                        CREDTYPE_SSH_CUSTOM         = Cuint(1 << 2),
+                        CREDTYPE_DEFAULT            = Cuint(1 << 3),
+                        CREDTYPE_SSH_INTERACTIVE    = Cuint(1 << 4),
+                        CREDTYPE_USERNAME           = Cuint(1 << 5),
+                        CREDTYPE_SSH_MEMORY         = Cuint(1 << 6))
+
+    """
+Priority level of a config file.
+
+These priority levels correspond to the natural escalation logic (from higher to lower) when searching for config entries in git.
+
+* `CONFIG_LEVEL_DEFAULT` - Open the global, XDG and system configuration files if any available.
+* `CONFIG_LEVEL_SYSTEM` - System-wide configuration file; `/etc/gitconfig` on Linux systems
+* `CONFIG_LEVEL_XDG` - XDG compatible configuration file; typically `~/.config/git/config`
+* `CONFIG_LEVEL_GLOBAL` - User-specific configuration file (also called Global configuration file); typically `~/.gitconfig`
+* `CONFIG_LEVEL_LOCAL` - Repository specific configuration file; `\$WORK_DIR/.git/config` on non-bare repos
+* `CONFIG_LEVEL_APP` - Application specific configuration file; freely defined by applications
+* `CONFIG_HIGHEST_LEVEL` - Represents the highest level available config file (i.e. the most specific config file available that actually is loaded)
+    """
+    @enum(GIT_CONFIG, CONFIG_LEVEL_DEFAULT = 0,
+                      CONFIG_LEVEL_SYSTEM  = 1,
+                      CONFIG_LEVEL_XDG     = 2,
+                      CONFIG_LEVEL_GLOBAL  = 3,
+                      CONFIG_LEVEL_LOCAL   = 4,
+                      CONFIG_LEVEL_APP     = 5,
+                      CONFIG_HIGHEST_LEVEL =-1)
+end
diff --git a/base/libgit2/diff.jl b/base/libgit2/diff.jl
new file mode 100644
index 0000000000000..d515b8a223b1b
--- /dev/null
+++ b/base/libgit2/diff.jl
@@ -0,0 +1,44 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function diff_tree(repo::GitRepo, tree::GitTree, pathspecs::AbstractString=""; cached::Bool=false)
+    emptypathspec = isempty(pathspecs)
+    diff_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    if !emptypathspec
+        sa = StrArrayStruct(pathspecs)
+        diff_opts = DiffOptionsStruct(pathspec = sa)
+    end
+    try
+        if cached
+            @check ccall((:git_diff_tree_to_index, :libgit2), Cint,
+                          (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{DiffOptionsStruct}),
+                           diff_ptr_ptr, repo.ptr, tree.ptr, C_NULL,  emptypathspec ? C_NULL : Ref(diff_opts))
+        else
+            @check ccall((:git_diff_tree_to_workdir_with_index, :libgit2), Cint,
+                          (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{DiffOptionsStruct}),
+                           diff_ptr_ptr, repo.ptr, tree.ptr, emptypathspec ? C_NULL : Ref(diff_opts))
+        end
+    finally
+        !emptypathspec && finalize(sa)
+    end
+    return GitDiff(diff_ptr_ptr[])
+end
+
+function diff_tree(repo::GitRepo, oldtree::GitTree, newtree::GitTree)
+    diff_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_diff_tree_to_tree, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{DiffOptionsStruct}),
+                   diff_ptr_ptr, repo.ptr, oldtree.ptr, newtree.ptr, C_NULL)
+    return GitDiff(diff_ptr_ptr[])
+end
+
+function Base.count(diff::GitDiff)
+    return ccall((:git_diff_num_deltas, :libgit2), Cint, (Ptr{Void},), diff.ptr)
+end
+
+function Base.getindex(diff::GitDiff, i::Csize_t)
+    delta_ptr = ccall((:git_diff_get_delta, :libgit2), Ptr{Void},
+                       (Ptr{Void}, Csize_t), diff.ptr, i-1)
+    delta_ptr == C_NULL && return nothing
+    return unsafe_load(convert(Ptr{DiffDelta}, delta_ptr), 1)
+end
+Base.getindex(diff::GitDiff, i::Int) = getindex(diff, Csize_t(i))
diff --git a/base/libgit2/error.jl b/base/libgit2/error.jl
new file mode 100644
index 0000000000000..e40733e73314b
--- /dev/null
+++ b/base/libgit2/error.jl
@@ -0,0 +1,102 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+module Error
+
+export GitError
+
+@enum(Code, GIT_OK          = Cint(0),   # no error
+            ERROR           = Cint(-01), # generic error
+            ENOTFOUND       = Cint(-03), # requested object could not be found
+            EEXISTS         = Cint(-04), # object exits preventing op
+            EAMBIGUOUS      = Cint(-05), # more than one object matches
+            EBUFS           = Cint(-06), # output buffer too small to hold data
+            EUSER           = Cint(-07), # user callback generated error
+            EBAREREPO       = Cint(-08), # operation not allowed on bare repo
+            EUNBORNBRANCH   = Cint(-09), # HEAD refers to branch with 0 commits
+            EUNMERGED       = Cint(-10), # merge in progress prevented op
+            ENONFASTFORWARD = Cint(-11), # ref not fast-forwardable
+            EINVALIDSPEC    = Cint(-12), # name / ref not in valid format
+            EMERGECONFLICT  = Cint(-13), # merge conflict prevented op
+            ELOCKED         = Cint(-14), # lock file prevented op
+            EMODIFIED       = Cint(-15), # ref value does not match expected
+            EAUTH           = Cint(-16), # authentication error
+            ECERTIFICATE    = Cint(-17), # server certificate is invalid
+            EAPPLIED        = Cint(-18), # patch/merge has already been applied
+            EPEEL           = Cint(-19), # the requested peel operation is not possible
+            PASSTHROUGH     = Cint(-30), # internal only
+            ITEROVER        = Cint(-31)) # signals end of iteration
+
+@enum(Class, None,
+             NoMemory,
+             OS,
+             Invalid,
+             Reference,
+             Zlib,
+             Repository,
+             Config,
+             Regex,
+             Odb,
+             Index,
+             Object,
+             Net,
+             Tag,
+             Tree,
+             Indexer,
+             SSL,
+             Submodule,
+             Thread,
+             Stash,
+             Checkout,
+             FetchHead,
+             Merge,
+             SSH,
+             Filter,
+             Revert,
+             Callback,
+             CherryPick,
+             Describe,
+             Rebase)
+
+immutable ErrorStruct
+    message::Ptr{UInt8}
+    class::Cint
+end
+
+immutable GitError <: Exception
+    class::Class
+    code::Code
+    msg::AbstractString
+end
+Base.show(io::IO, err::GitError) = print(io, "GitError(Code:$(err.code), Class:$(err.class), $(err.msg))")
+
+function last_error()
+    err = ccall((:giterr_last, :libgit2), Ptr{ErrorStruct}, ())
+    if err != C_NULL
+        err_obj   = unsafe_load(err)
+        err_class = Class[err_obj.class][]
+        err_msg   = bytestring(err_obj.message)
+    else
+        err_class = Class[0][]
+        err_msg = "No errors"
+    end
+    return (err_class, err_msg)
+end
+
+function GitError(code::Integer)
+    err_code = Code[code][]
+    err_class, err_msg = last_error()
+    return GitError(err_class, err_code, err_msg)
+end
+
+end # Error module
+
+macro check(git_func)
+    quote
+        local err::Cint
+        err = $(esc(git_func::Expr))
+        if err < 0
+            throw(Error.GitError(err))
+        end
+        err
+    end
+end
diff --git a/base/libgit2/index.jl b/base/libgit2/index.jl
new file mode 100644
index 0000000000000..c5af2191e7704
--- /dev/null
+++ b/base/libgit2/index.jl
@@ -0,0 +1,120 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitIndex(repo::GitRepo)
+    idx_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_repository_index, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Void}), idx_ptr_ptr, repo.ptr)
+    return GitIndex(idx_ptr_ptr[])
+end
+
+function read!(idx::GitIndex, force::Bool = false)
+    @check ccall((:git_index_read, :libgit2), Cint, (Ptr{Void}, Cint), idx.ptr, Cint(force))
+    return idx
+end
+
+function write!(idx::GitIndex)
+    @check ccall((:git_index_write, :libgit2), Cint, (Ptr{Void},), idx.ptr)
+    return idx
+end
+
+function write_tree!(idx::GitIndex)
+    oid_ptr = Ref(Oid())
+    @check ccall((:git_index_write_tree, :libgit2), Cint,
+                 (Ptr{Oid}, Ptr{Void}), oid_ptr, idx.ptr)
+    return oid_ptr[]
+end
+
+function owner(idx::GitIndex)
+    repo_ptr = ccall((:git_index_owner, :libgit2), Ptr{Void},
+                     (Ptr{Void},), idx.ptr)
+    return GitRepo(repo_ptr)
+end
+
+function read_tree!(idx::GitIndex, tree_id::Oid)
+    repo = owner(idx)
+    tree = get(GitTree, repo, tree_id)
+    try
+        @check ccall((:git_index_read_tree, :libgit2), Cint,
+                     (Ptr{Void}, Ptr{Void}), idx.ptr, tree.ptr)
+    finally
+        finalize(tree)
+    end
+end
+
+function add!{T<:AbstractString}(idx::GitIndex, files::T...;
+             flags::Cuint = Consts.INDEX_ADD_DEFAULT)
+    sa = StrArrayStruct(files...)
+    try
+        @check ccall((:git_index_add_all, :libgit2), Cint,
+                     (Ptr{Void}, Ptr{StrArrayStruct}, Cuint, Ptr{Void}, Ptr{Void}),
+                      idx.ptr, Ref(sa), flags, C_NULL, C_NULL)
+    finally
+        finalize(sa)
+    end
+end
+
+function update!{T<:AbstractString}(idx::GitIndex, files::T...)
+    sa = StrArrayStruct(files...)
+    try
+        @check ccall((:git_index_update_all, :libgit2), Cint,
+                     (Ptr{Void}, Ptr{StrArrayStruct}, Ptr{Void}, Ptr{Void}),
+                      idx.ptr, Ref(sa), C_NULL, C_NULL)
+    finally
+        finalize(sa)
+    end
+end
+
+function remove!{T<:AbstractString}(idx::GitIndex, files::T...)
+    sa = StrArrayStruct(files...)
+    try
+        @check ccall((:git_index_remove_all, :libgit2), Cint,
+                     (Ptr{Void}, Ptr{StrArrayStruct}, Ptr{Void}, Ptr{Void}),
+                      idx.ptr, Ref(sa), C_NULL, C_NULL)
+    finally
+        finalize(sa)
+    end
+end
+
+function add!{T<:AbstractString}(repo::GitRepo, files::T...;
+             flags::Cuint = Consts.INDEX_ADD_DEFAULT)
+    with(GitIndex, repo) do idx
+        add!(idx, files..., flags = flags)
+        write!(idx)
+    end
+    return
+end
+
+function update!{T<:AbstractString}(repo::GitRepo, files::T...)
+    with(GitIndex, repo) do idx
+        update!(idx, files...)
+        write!(idx)
+    end
+    return
+end
+
+function remove!{T<:AbstractString}(repo::GitRepo, files::T...)
+    with(GitIndex, repo) do idx
+        remove!(idx, files...)
+        write!(idx)
+    end
+    return
+end
+
+function read!(repo::GitRepo, force::Bool = false)
+    with(GitIndex, repo) do idx
+        read!(idx, force)
+    end
+    return
+end
+
+function Base.count(idx::GitIndex)
+    return ccall((:git_index_entrycount, :libgit2), Csize_t, (Ptr{Void},), idx.ptr)
+end
+
+function Base.getindex(idx::GitIndex, i::Csize_t)
+    ie_ptr = ccall((:git_index_get_byindex, :libgit2), Ptr{Void},
+                  (Ptr{Void}, Csize_t), idx.ptr, i-1)
+    ie_ptr == C_NULL && return nothing
+    return unsafe_load(convert(Ptr{IndexEntry}, ie_ptr), 1)
+end
+Base.getindex(idx::GitIndex, i::Int) = getindex(idx, Csize_t(i))
diff --git a/base/libgit2/merge.jl b/base/libgit2/merge.jl
new file mode 100644
index 0000000000000..db64522ba55e4
--- /dev/null
+++ b/base/libgit2/merge.jl
@@ -0,0 +1,164 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitAnnotated(repo::GitRepo, commit_id::Oid)
+    ann_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_annotated_commit_lookup, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Oid}),
+                   ann_ptr_ptr, repo.ptr, Ref(commit_id))
+    return GitAnnotated(ann_ptr_ptr[])
+end
+
+function GitAnnotated(repo::GitRepo, ref::GitReference)
+    ann_ref_ref = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_annotated_commit_from_ref, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}),
+                   ann_ref_ref, repo.ptr, ref.ptr)
+    return GitAnnotated(ann_ref_ref[])
+end
+
+function GitAnnotated(repo::GitRepo, fh::FetchHead)
+    ann_ref_ref = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_annotated_commit_from_fetchhead, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring, Ptr{Oid}),
+                   ann_ref_ref, repo.ptr, fh.name, fh.url, Ref(fh.oid))
+    return GitAnnotated(ann_ref_ref[])
+end
+
+function GitAnnotated(repo::GitRepo, comittish::AbstractString)
+    obj = revparse(repo, comittish)
+    try
+        cmt = peel(obj, Consts.OBJ_COMMIT)
+        cmt === nothing && return nothing
+        return GitAnnotated(repo, Oid(cmt))
+    finally
+        finalize(obj)
+    end
+end
+
+function commit(ann::GitAnnotated)
+    return Oid(ccall((:git_annotated_commit_id, :libgit2), Ptr{Oid}, (Ptr{Void},), ann.ptr))
+end
+
+function merge_analysis(repo::GitRepo, anns::Vector{GitAnnotated})
+    analysis = Ref{Cint}(0)
+    preference = Ref{Cint}(0)
+    anns_ref = Ref(map(a->a.ptr, anns))
+    anns_size = Csize_t(length(anns))
+    @check ccall((:git_merge_analysis, :libgit2), Cint,
+                  (Ptr{Cint}, Ptr{Cint}, Ptr{Void}, Ptr{Ptr{Void}}, Csize_t),
+                   analysis, preference, repo.ptr, anns_ref, anns_size)
+    return analysis[], preference[]
+end
+
+"""Fastforward merge changes into current head """
+function ffmerge!(repo::GitRepo, ann::GitAnnotated)
+    ann_cmt_oid = commit(ann)
+    cmt = get(GitCommit, repo, ann_cmt_oid)
+    cmt === nothing && return false # could not find commit tree
+    try
+        checkout_tree(repo, cmt)
+        with(head(repo)) do head_ref
+            cmt_oid = Oid(cmt)
+            msg = "libgit2.merge: fastforward $(string(cmt_oid)) into $(name(head_ref))"
+            new_head_ref = if reftype(head_ref) == Consts.REF_OID
+                target!(head_ref, cmt_oid, msg=msg)
+            else
+                GitReference(repo, cmt_oid, fullname(head_ref), msg=msg)
+            end
+            finalize(new_head_ref)
+        end
+    finally
+        finalize(cmt)
+    end
+    return true
+end
+
+""" Merge changes into current head """
+function merge!(repo::GitRepo, anns::Vector{GitAnnotated};
+                merge_opts::MergeOptions = MergeOptions(),
+                checkout_opts::CheckoutOptions = CheckoutOptions())
+    anns_size = Csize_t(length(anns))
+    @check ccall((:git_merge, :libgit2), Cint,
+                  (Ptr{Void}, Ptr{Ptr{Void}}, Csize_t,
+                   Ptr{MergeOptions}, Ptr{CheckoutOptions}),
+                   repo.ptr, anns, anns_size,
+                   Ref(merge_opts), Ref(checkout_opts))
+    info("Review and commit merged changes.")
+    return true
+end
+
+"""Internal implementation of merge.
+Returns `true` if merge was successful, otherwise `false`
+"""
+function merge!(repo::GitRepo, anns::Vector{GitAnnotated}, fastforward::Bool;
+                merge_opts::MergeOptions = MergeOptions(),
+                checkout_opts::CheckoutOptions = CheckoutOptions())
+    ma, mp = merge_analysis(repo, anns)
+    if isset(ma, Cint(Consts.MERGE_ANALYSIS_UP_TO_DATE))
+        return true # no merge - everything is up to date
+    end
+
+    ffpref = if fastforward
+        Consts.MERGE_PREFERENCE_FASTFORWARD_ONLY
+    elseif isset(mp, Cint(Consts.MERGE_PREFERENCE_NONE))
+        Consts.MERGE_PREFERENCE_NONE
+    elseif isset(mp, Cint(Consts.MERGE_PREFERENCE_NO_FASTFORWARD))
+        Consts.MERGE_PREFERENCE_NO_FASTFORWARD
+    elseif isset(mp, Cint(Consts.MERGE_PREFERENCE_FASTFORWARD_ONLY))
+        Consts.MERGE_PREFERENCE_FASTFORWARD_ONLY
+    else
+        throw(ArgumentError("unknown merge preference: $(mp)."))
+    end
+
+    merge_result = if ffpref == Consts.MERGE_PREFERENCE_NONE
+        if isset(ma, Cint(Consts.MERGE_ANALYSIS_FASTFORWARD))
+            if length(anns) > 1
+                warn("Unable to perform Fast-Forward merge with mith multiple merge heads.")
+                false
+            else
+                ffmerge!(repo, anns[1])
+            end
+        elseif isset(ma, Cint(Consts.MERGE_ANALYSIS_NORMAL))
+            merge!(repo, anns,
+                   merge_opts=merge_opts,
+                   checkout_opts=checkout_opts)
+        end
+    elseif ffpref == Consts.MERGE_PREFERENCE_FASTFORWARD_ONLY
+        if isset(ma, Cint(Consts.MERGE_ANALYSIS_FASTFORWARD))
+            if length(anns) > 1
+                warn("Unable to perform Fast-Forward merge with mith multiple merge heads.")
+                false
+            else
+                ffmerge!(repo, anns[1])
+            end
+        else
+            warn("Cannot perform fast-forward merge.")
+            false
+        end
+    elseif ffpref == Consts.MERGE_PREFERENCE_NO_FASTFORWARD
+        if isset(ma, Cint(Consts.MERGE_ANALYSIS_NORMAL))
+            merge!(repo, anns,
+                   merge_opts=merge_opts,
+                   checkout_opts=checkout_opts)
+        end
+    else
+        throw(ArgumentError("unknown merge analysis result: $(ma)"))
+    end
+    return merge_result
+end
+
+function merge_base(repo::GitRepo, one::AbstractString, two::AbstractString)
+    oid1_ptr = Ref(Oid(one))
+    oid2_ptr = Ref(Oid(two))
+    moid_ptr = Ref(Oid())
+    moid = try
+        @check ccall((:git_merge_base, :libgit2), Cint,
+                (Ptr{Oid}, Ptr{Void}, Ptr{Oid}, Ptr{Oid}),
+                moid_ptr, repo.ptr, oid1_ptr, oid2_ptr)
+        moid_ptr[]
+    catch e
+        #warn("Pkg:",path(repo),"=>",e.msg)
+        Oid()
+    end
+    return moid
+end
diff --git a/base/libgit2/oid.jl b/base/libgit2/oid.jl
new file mode 100644
index 0000000000000..d23fcd11ce156
--- /dev/null
+++ b/base/libgit2/oid.jl
@@ -0,0 +1,88 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+Oid(id::Oid) = id
+Oid(ptr::Ptr{Oid}) = unsafe_load(ptr)::Oid
+
+function Oid(ptr::Ptr{UInt8})
+    if ptr == C_NULL
+        throw(ArgumentError("NULL pointer passed to Oid() constructor"))
+    end
+    oid_ptr = Ref(Oid())
+    ccall((:git_oid_fromraw, :libgit2), Void, (Ptr{Oid}, Ptr{UInt8}), oid_ptr, ptr)
+    return oid_ptr[]
+end
+
+function Oid(id::Array{UInt8,1})
+    if length(id) != OID_RAWSZ
+        throw(ArgumentError("invalid raw buffer size"))
+    end
+    return Oid(pointer(id))
+end
+
+function Oid(id::AbstractString)
+    bstr = bytestring(id)
+    len = sizeof(bstr)
+    oid_ptr  = Ref(Oid())
+    err = if len < OID_HEXSZ
+        ccall((:git_oid_fromstrn, :libgit2), Cint,
+              (Ptr{Oid}, Ptr{UInt8}, Csize_t), oid_ptr, bstr, len)
+    else
+        ccall((:git_oid_fromstrp, :libgit2), Cint,
+              (Ptr{Oid}, Ptr{Cchar}), oid_ptr, bstr)
+    end
+    err != 0 && return Oid()
+    return oid_ptr[]
+end
+
+function Oid(ref::GitReference)
+    isempty(ref) && return Oid()
+    reftype(ref) != Consts.REF_OID && return Oid()
+    oid_ptr = ccall((:git_reference_target, :libgit2), Ptr{UInt8}, (Ptr{Void},), ref.ptr)
+    oid_ptr == C_NULL && return Oid()
+    return Oid(oid_ptr)
+end
+
+function Oid(repo::GitRepo, ref_name::AbstractString)
+    isempty(repo) && return Oid()
+    oid_ptr  = Ref(Oid())
+    @check ccall((:git_reference_name_to_id, :libgit2), Cint,
+                    (Ptr{Oid}, Ptr{Void}, Ptr{UInt8}),
+                     oid_ptr, repo.ptr, ref_name)
+    return oid_ptr[]
+end
+
+function Oid(obj::Ptr{Void})
+    oid_ptr = ccall((:git_object_id, :libgit2), Ptr{UInt8}, (Ptr{Void},), obj)
+    oid_ptr == C_NULL && return Oid()
+    return Oid(oid_ptr)
+end
+
+function Oid{T<:GitObject}(obj::T)
+    obj === nothing && return Oid()
+    return Oid(obj.ptr)
+end
+
+Base.hex(id::Oid) = join([hex(i,2) for i in id.val])
+
+raw(id::Oid) = collect(id.val)
+
+Base.string(id::Oid) = hex(id)
+
+Base.show(io::IO, id::Oid) = print(io, "Oid($(string(id)))")
+
+Base.hash(id::Oid, h::UInt) = hash(id.val, h)
+
+cmp(id1::Oid, id2::Oid) = Int(ccall((:git_oid_cmp, :libgit2), Cint,
+                                    (Ptr{Oid}, Ptr{Oid}), Ref(id1), Ref(id2)))
+
+==(id1::Oid, id2::Oid) = cmp(id1, id2) == 0
+Base.isless(id1::Oid, id2::Oid)  = cmp(id1, id2) < 0
+
+function iszero(id::Oid)
+    for i in 1:OID_RAWSZ
+        id.val[i] != zero(UInt8) && return false
+    end
+    return true
+end
+
+Base.zero(::Type{Oid}) = Oid()
diff --git a/base/libgit2/rebase.jl b/base/libgit2/rebase.jl
new file mode 100644
index 0000000000000..32c0da2d2a9af
--- /dev/null
+++ b/base/libgit2/rebase.jl
@@ -0,0 +1,61 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitRebase(repo::GitRepo, branch::GitAnnotated, upstream::GitAnnotated;
+                   onto::Nullable{GitAnnotated}=Nullable{GitAnnotated}(),
+                   opts::RebaseOptions = RebaseOptions())
+    rebase_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_rebase_init, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Void}, Ptr{Void},
+                   Ptr{Void}, Ptr{RebaseOptions}),
+                   rebase_ptr_ptr, repo.ptr, branch.ptr, upstream.ptr,
+                   isnull(onto) ? C_NULL : Base.get(onto).ptr, Ref(opts))
+    return GitRebase(rebase_ptr_ptr[])
+end
+
+function Base.count(rb::GitRebase)
+    return ccall((:git_rebase_operation_entrycount, :libgit2), Csize_t, (Ptr{Void},), rb.ptr)
+end
+
+function current(rb::GitRebase)
+    return ccall((:git_rebase_operation_current, :libgit2), Csize_t, (Ptr{Void},), rb.ptr)
+end
+
+function Base.getindex(rb::GitRebase, i::Csize_t)
+    rb_op_ptr = ccall((:git_rebase_operation_byindex, :libgit2), Ptr{Void},
+                       (Ptr{Void}, Csize_t), rb.ptr, i-1)
+    rb_op_ptr == C_NULL && return nothing
+    return unsafe_load(convert(Ptr{RebaseOperation}, rb_op_ptr), 1)
+end
+Base.getindex(rb::GitRebase, i::Int) = getindex(rb, Csize_t(i))
+
+function Base.next(rb::GitRebase)
+    rb_op_ptr_ptr = Ref{Ptr{RebaseOperation}}(C_NULL)
+    try
+        @check ccall((:git_rebase_next, :libgit2), Cint,
+                      (Ptr{Ptr{RebaseOperation}}, Ptr{Void}),
+                       rb_op_ptr_ptr, rb.ptr)
+    catch err
+        err.code == Error.ITEROVER && return nothing
+        rethrow(err)
+    end
+    return unsafe_load(convert(Ptr{RebaseOperation}, rb_op_ptr_ptr[]), 1)
+end
+
+function commit(rb::GitRebase, sig::GitSignature)
+    oid_ptr = Ref(Oid())
+    @check ccall((:git_rebase_commit, :libgit2), Cint,
+                  (Ptr{Oid}, Ptr{Void}, Ptr{SignatureStruct}, Ptr{SignatureStruct}, Ptr{UInt8}, Ptr{UInt8}),
+                   oid_ptr, rb.ptr, C_NULL, sig.ptr, C_NULL, C_NULL)
+    return oid_ptr[]
+end
+
+function abort(rb::GitRebase)
+    return ccall((:git_rebase_abort, :libgit2), Csize_t,
+                      (Ptr{Void},), rb.ptr)
+end
+
+function finish(rb::GitRebase, sig::GitSignature)
+    return ccall((:git_rebase_finish, :libgit2), Csize_t,
+                  (Ptr{Void}, Ptr{SignatureStruct}),
+                   rb.ptr, sig.ptr)
+end
diff --git a/base/libgit2/reference.jl b/base/libgit2/reference.jl
new file mode 100644
index 0000000000000..38081e3634492
--- /dev/null
+++ b/base/libgit2/reference.jl
@@ -0,0 +1,196 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitReference(repo::GitRepo, refname::AbstractString)
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_reference_lookup, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring),
+                   ref_ptr_ptr, repo.ptr, refname)
+    return GitReference(ref_ptr_ptr[])
+end
+
+function GitReference(repo::GitRepo, obj_oid::Oid, refname::AbstractString = Consts.HEAD_FILE;
+                      force::Bool=false, msg::AbstractString="")
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_reference_create, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{UInt8}, Ptr{Oid}, Cint, Cstring),
+                   ref_ptr_ptr, repo.ptr, refname, Ref(obj_oid), Cint(force),
+                   isempty(msg) ? Cstring_NULL : msg)
+    return GitReference(ref_ptr_ptr[])
+end
+
+function head(repo::GitRepo)
+    head_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_repository_head, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}), head_ptr_ptr, repo.ptr)
+    return GitReference(head_ptr_ptr[])
+end
+
+function shortname(ref::GitReference)
+    isempty(ref) && return ""
+    name_ptr = ccall((:git_reference_shorthand, :libgit2), Cstring, (Ptr{Void},), ref.ptr)
+    name_ptr == C_NULL && return ""
+    return bytestring(name_ptr)
+end
+
+function reftype(ref::GitReference)
+    return ccall((:git_reference_type, :libgit2), Cint, (Ptr{Void},), ref.ptr)
+end
+
+function fullname(ref::GitReference)
+    isempty(ref) && return ""
+    reftype(ref) == Consts.REF_OID && return ""
+    rname = ccall((:git_reference_symbolic_target, :libgit2), Cstring, (Ptr{Void},), ref.ptr)
+    rname == C_NULL && return ""
+    return bytestring(rname)
+end
+
+function name(ref::GitReference)
+    isempty(ref) && return ""
+    name_ptr = ccall((:git_reference_name, :libgit2), Cstring, (Ptr{Void},), ref.ptr)
+    name_ptr == C_NULL && return ""
+    return bytestring(name_ptr)
+end
+
+function branch(ref::GitReference)
+    isempty(ref) && return ""
+    str_ptr_ptr = Ref(LibGit2.Cstring_NULL)
+    @check ccall((:git_branch_name, :libgit2), Cint,
+                  (Ptr{Cstring}, Ptr{Void},), str_ptr_ptr, ref.ptr)
+    return bytestring(str_ptr_ptr[])
+end
+
+function ishead(ref::GitReference)
+    isempty(ref) && return false
+    err = ccall((:git_branch_is_head, :libgit2), Cint,
+                  (Ptr{Void},), ref.ptr)
+    return err == 1
+end
+
+function isbranch(ref::GitReference)
+    isempty(ref) && return false
+    err = ccall((:git_reference_is_branch, :libgit2), Cint,
+                  (Ptr{Void},), ref.ptr)
+    return err == 1
+end
+
+function peel{T <: GitObject}(::Type{T}, ref::GitReference)
+    git_otype = getobjecttype(T)
+    obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    err = ccall((:git_reference_peel, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Void}, Cint), obj_ptr_ptr, ref.ptr, git_otype)
+    if err == Int(Error.ENOTFOUND)
+        return Oid()
+    elseif err != Int(Error.GIT_OK)
+        if obj_ptr_ptr[] != C_NULL
+            finalize(GitAnyObject(obj_ptr_ptr[]))
+        end
+        throw(Error.GitError(err))
+    end
+    return T(obj_ptr_ptr[])
+end
+
+function create_branch(repo::GitRepo,
+                       bname::AbstractString,
+                       commit_obj::GitCommit;
+                       force::Bool=false)
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_branch_create, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Ptr{Void}, Cint),
+                   ref_ptr_ptr, repo.ptr, bname, commit_obj.ptr, Cint(force))
+    return GitReference(ref_ptr_ptr[])
+end
+
+function delete_branch(branch::GitReference)
+    @check ccall((:git_branch_delete, :libgit2), Cint, (Ptr{Void},), branch.ptr)
+end
+
+function head!(repo::GitRepo, ref::GitReference)
+    ref_name = name(ref)
+    @check ccall((:git_repository_set_head, :libgit2), Cint,
+                  (Ptr{Void}, Cstring), repo.ptr, ref_name)
+    return ref
+end
+
+function lookup_branch(repo::GitRepo,
+                       branch_name::AbstractString,
+                       remote::Bool=false)
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    branch_type = remote ? Consts.BRANCH_REMOTE : Consts.BRANCH_LOCAL
+    err = ccall((:git_branch_lookup, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{UInt8}, Cint),
+                  ref_ptr_ptr, repo.ptr, branch_name, branch_type)
+    if err == Int(Error.ENOTFOUND)
+        return nothing
+    elseif err != Int(Error.GIT_OK)
+        if repo_ptr_ptr[] != C_NULL
+            finalize(GitReference(ref_ptr_ptr[]))
+        end
+        throw(Error.GitError(err))
+    end
+    return GitReference(ref_ptr_ptr[])
+end
+
+function upstream(ref::GitReference)
+    isempty(ref) && return nothing
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_branch_upstream, :libgit2), Cint,
+                  (Ref{Ptr{Void}}, Ptr{Void},), ref_ptr_ptr, ref.ptr)
+    return GitReference(ref_ptr_ptr[])
+end
+
+function owner(ref::GitReference)
+    repo_ptr = ccall((:git_reference_owner, :libgit2), Ptr{Void},
+                      (Ptr{Void},), ref.ptr)
+    return GitRepo(repo_ptr)
+end
+
+function target!(ref::GitReference, new_oid::Oid; msg::AbstractString="")
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_reference_set_target, :libgit2), Cint,
+             (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Oid}, Cstring),
+             ref_ptr_ptr, ref.ptr, Ref(new_oid), isempty(msg) ? Cstring_NULL : msg)
+    return GitReference(ref_ptr_ptr[])
+end
+
+function GitBranchIter(r::GitRepo, flags::Cint=Cint(Consts.BRANCH_LOCAL))
+    bi_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_branch_iterator_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Cint), bi_ptr, r.ptr, flags)
+    return GitBranchIter(bi_ptr[])
+end
+
+function Base.start(bi::GitBranchIter)
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    btype = Cint[0]
+    err = ccall((:git_branch_next, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Cint}, Ptr{Void}),
+                  ref_ptr_ptr, btype, bi.ptr)
+    err != Int(Error.GIT_OK) && return (nothing, -1, true)
+    return (GitReference(ref_ptr_ptr[]), btype[1], false)
+end
+
+Base.done(bi::GitBranchIter, state) = Bool(state[3])
+
+function Base.next(bi::GitBranchIter, state)
+    ref_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    btype = Cint[0]
+    err = ccall((:git_branch_next, :libgit2), Cint,
+                 (Ptr{Ptr{Void}}, Ptr{Cint}, Ptr{Void}),
+                  ref_ptr_ptr, btype, bi.ptr)
+    err != Int(Error.GIT_OK) && return (state[1:2], (nothing, -1, true))
+    return (state[1:2], (GitReference(ref_ptr_ptr[]), btype[1], false))
+end
+
+function Base.map(f::Function, bi::GitBranchIter)
+    res = nothing
+    s = start(bi)
+    while !done(bi, s)
+        val = f(s[1:2])
+        if res === nothing
+            res = Array(typeof(val),0)
+        end
+        push!(res, val)
+        val, s = next(bi, s)
+    end
+    return res
+end
diff --git a/base/libgit2/remote.jl b/base/libgit2/remote.jl
new file mode 100644
index 0000000000000..7dba24240a793
--- /dev/null
+++ b/base/libgit2/remote.jl
@@ -0,0 +1,90 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString)
+    rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_remote_create, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring),
+                rmt_ptr_ptr, repo.ptr, rmt_name, rmt_url)
+    return GitRemote(rmt_ptr_ptr[])
+end
+
+function GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString, fetch_spec::AbstractString)
+    rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_remote_create_with_fetchspec, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cstring, Cstring, Cstring),
+                rmt_ptr_ptr, repo.ptr, rmt_name, rmt_url, fetch_spec)
+    return GitRemote(rmt_ptr_ptr[])
+end
+
+function GitRemoteAnon(repo::GitRepo, url::AbstractString)
+    rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_remote_create_anonymous, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cstring),
+                rmt_ptr_ptr, repo.ptr, url)
+    return GitRemote(rmt_ptr_ptr[])
+end
+
+function get(::Type{GitRemote}, repo::GitRepo, rmt_name::AbstractString)
+    rmt_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_remote_lookup, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cstring),
+                rmt_ptr_ptr, repo.ptr, rmt_name)
+    return GitRemote(rmt_ptr_ptr[])
+end
+
+function url(rmt::GitRemote)
+    url_ptr = ccall((:git_remote_url, :libgit2), Cstring, (Ptr{Void}, ), rmt.ptr)
+    url_ptr == Cstring_NULL && return ""
+    return  bytestring(url_ptr)
+end
+
+function fetch_refspecs(rmt::GitRemote)
+    sa_ref = Ref{StrArrayStruct}()
+    try
+        @check ccall((:git_remote_get_fetch_refspecs, :libgit2), Cint,
+                      (Ptr{LibGit2.StrArrayStruct}, Ptr{Void}), sa_ref, rmt.ptr)
+        convert(Vector{AbstractString}, sa_ref[])
+    finally
+        finalize(sa_ref[])
+    end
+end
+
+function push_refspecs(rmt::GitRemote)
+    sa_ref = Ref{StrArrayStruct}()
+    try
+        @check ccall((:git_remote_get_push_refspecs, :libgit2), Cint,
+                      (Ptr{LibGit2.StrArrayStruct}, Ptr{Void}), sa_ref, rmt.ptr)
+        convert(Vector{AbstractString}, sa_ref[])
+    finally
+        finalize(sa_ref[])
+    end
+end
+
+function fetch{T<:AbstractString}(rmt::GitRemote, refspecs::Vector{T};
+               options::FetchOptions = FetchOptions(),
+               msg::AbstractString="")
+    msg = "libgit2.fetch: $msg"
+    no_refs = isempty(refspecs)
+    !no_refs && (sa = StrArrayStruct(refspecs...))
+    try
+        @check ccall((:git_remote_fetch, :libgit2), Cint,
+            (Ptr{Void}, Ptr{StrArrayStruct}, Ptr{FetchOptions}, Cstring),
+            rmt.ptr, no_refs ? C_NULL : Ref(sa), Ref(options), msg)
+    finally
+        !no_refs && finalize(sa)
+    end
+end
+
+function push{T<:AbstractString}(rmt::GitRemote, refspecs::Vector{T};
+                                 force::Bool = false,
+                                 options::PushOptions = PushOptions())
+    no_refs = isempty(refspecs)
+    !no_refs && (sa = StrArrayStruct(refspecs...))
+    try
+        @check ccall((:git_remote_push, :libgit2), Cint,
+                      (Ptr{Void}, Ptr{StrArrayStruct}, Ptr{PushOptions}),
+                       rmt.ptr, no_refs ? C_NULL : Ref(sa), Ref(options))
+    finally
+        !no_refs && finalize(sa)
+    end
+end
diff --git a/base/libgit2/repository.jl b/base/libgit2/repository.jl
new file mode 100644
index 0000000000000..2a52114e12b5e
--- /dev/null
+++ b/base/libgit2/repository.jl
@@ -0,0 +1,209 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitRepo(path::AbstractString)
+    repo_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    err = ccall((:git_repository_open, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Cstring), repo_ptr_ptr, path)
+    if err != Int(Error.GIT_OK)
+        if repo_ptr_ptr[] != C_NULL
+            finalize(GitRepo(repo_ptr_ptr[]))
+        end
+        throw(Error.GitError(err))
+    end
+    return GitRepo(repo_ptr_ptr[])
+end
+
+function GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))
+    separator = @unix? ":" : ";"
+    repo_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    err = ccall((:git_repository_open_ext, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Cstring, Cuint, Cstring),
+                 repo_ptr_ptr, path, flags, separator)
+    if err != Int(Error.GIT_OK)
+        if repo_ptr_ptr[] != C_NULL
+            finalize(GitRepo(repo_ptr_ptr[]))
+        end
+        throw(Error.GitError(err))
+    end
+    return GitRepo(repo_ptr_ptr[])
+end
+
+function cleanup(r::GitRepo)
+    if r.ptr != C_NULL
+        ccall((:git_repository__cleanup, :libgit2), Void, (Ptr{Void},), r.ptr)
+    end
+end
+
+function init(path::AbstractString, bare::Bool=false)
+    repo_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_repository_init, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Cstring, Cuint), repo_ptr_ptr, path, bare)
+    return GitRepo(repo_ptr_ptr[])
+end
+
+function head_oid(repo::GitRepo)
+    head_ref = head(repo)
+    try
+        return Oid(head_ref)
+    finally
+        finalize(head_ref)
+    end
+end
+
+function headname(repo::GitRepo)
+    with(head(repo)) do href
+        if isattached(repo)
+            shortname(href)
+        else
+            "(detached from $(string(Oid(href))[1:7]))"
+        end
+    end
+end
+
+function isbare(repo::GitRepo)
+    return ccall((:git_repository_is_bare, :libgit2), Cint, (Ptr{Void},), repo.ptr) == 1
+end
+
+function isattached(repo::GitRepo)
+    ccall((:git_repository_head_detached, :libgit2), Cint, (Ptr{Void},), repo.ptr) != 1
+end
+
+""" Returns a found object """
+function revparse(repo::GitRepo, objname::AbstractString)
+    obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    err = ccall((:git_revparse_single, :libgit2), Cint,
+            (Ptr{Ptr{Void}}, Ptr{Void}, Cstring), obj_ptr_ptr, repo.ptr, objname)
+    err != 0 && return nothing
+    return GitAnyObject(obj_ptr_ptr[])
+end
+
+""" Returns id of a found object """
+function revparseid(repo::GitRepo, objname::AbstractString)
+    obj = revparse(repo, objname)
+    obj === nothing && return Oid()
+    oid = Oid(obj.ptr)
+    finalize(obj)
+    return oid
+end
+
+function get{T <: GitObject}(::Type{T}, r::GitRepo, oid::Oid, oid_size::Int=OID_HEXSZ)
+    id_ptr  = Ref(oid)
+    obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    git_otype = getobjecttype(T)
+
+    err = if oid_size != OID_HEXSZ
+        ccall((:git_object_lookup_prefix, :libgit2), Cint,
+              (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Oid}, Csize_t, Cint),
+              obj_ptr_ptr, r.ptr, id_ptr, Csize_t(oid_size), git_otype)
+    else
+        ccall((:git_object_lookup, :libgit2), Cint,
+              (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{Oid}, Cint),
+              obj_ptr_ptr, r.ptr, id_ptr, git_otype)
+    end
+    if err == Int(Error.ENOTFOUND)
+        return nothing
+    elseif err != Int(Error.GIT_OK)
+        if obj_ptr_ptr[] != C_NULL
+            finalize(GitAnyObject(obj_ptr_ptr[]))
+        end
+        throw(Error.GitError(err))
+    end
+    return T(obj_ptr_ptr[])
+end
+
+function get{T <: GitObject}(::Type{T}, r::GitRepo, oid::AbstractString)
+    return get(T, r, Oid(oid), length(oid))
+end
+
+function gitdir(repo::GitRepo)
+    return bytestring(ccall((:git_repository_path, :libgit2), Cstring,
+                            (Ptr{Void},), repo.ptr))
+end
+
+function path(repo::GitRepo)
+    rpath = gitdir(repo)
+    return isbare(repo) ? rpath : splitdir(rpath[1:end-1])[1]*"/" # remove '.git' part
+end
+
+function peel(obj::GitObject, obj_type::Cint)
+    peeled_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    git_otype = getobjecttype(obj_type)
+    err = ccall((:git_object_peel, :libgit2), Cint,
+                (Ptr{Ptr{Void}}, Ptr{Void}, Cint), peeled_ptr_ptr, obj.ptr, obj_type)
+    if err == Int(Error.ENOTFOUND)
+        return Oid()
+    elseif err != Int(Error.GIT_OK)
+        if peeled_ptr_ptr[] != C_NULL
+            finalize(GitAnyObject(peeled_ptr_ptr[]))
+        end
+        throw(Error.GitError(err))
+    end
+    return git_otype(peeled_ptr_ptr[])
+end
+
+peel{T <: GitObject}(::Type{T}, obj::GitObject) = peel(obj, getobjecttype(T))
+
+function checkout_tree(repo::GitRepo, obj::GitObject;
+                       options::CheckoutOptions = CheckoutOptions())
+    @check ccall((:git_checkout_tree, :libgit2), Cint,
+                 (Ptr{Void}, Ptr{Void}, Ptr{CheckoutOptions}),
+                 repo.ptr, obj.ptr, Ref(options))
+end
+
+function checkout_index(repo::GitRepo, idx::Nullable{GitIndex} = Nullable{GitIndex}();
+                        options::CheckoutOptions = CheckoutOptions())
+    @check ccall((:git_checkout_index, :libgit2), Cint,
+                 (Ptr{Void}, Ptr{Void}, Ptr{CheckoutOptions}),
+                 repo.ptr,
+                 isnull(idx) ? C_NULL : Base.get(idx).ptr,
+                 Ref(options))
+end
+
+function checkout_head(repo::GitRepo; options::CheckoutOptions = CheckoutOptions())
+    @check ccall((:git_checkout_head, :libgit2), Cint,
+                 (Ptr{Void}, Ptr{CheckoutOptions}),
+                 repo.ptr, Ref(options))
+end
+
+function reset!{T<:AbstractString, S<:GitObject}(repo::GitRepo, obj::Nullable{S}, pathspecs::T...)
+    with(StrArrayStruct(pathspecs...)) do sa
+        @check ccall((:git_reset_default, :libgit2), Cint,
+                (Ptr{Void}, Ptr{Void}, Ptr{StrArrayStruct}),
+                repo.ptr,
+                isnull(obj) ? C_NULL: Base.get(obj).ptr,
+                Ref(sa))
+    end
+end
+
+function reset!(repo::GitRepo, obj::GitObject, mode::Cint;
+               checkout_opts::CheckoutOptions = CheckoutOptions())
+    @check ccall((:git_reset, :libgit2), Cint,
+                 (Ptr{Void}, Ptr{Void}, Cint, Ptr{CheckoutOptions}),
+                  repo.ptr, obj.ptr, mode, Ref(checkout_opts))
+end
+
+function clone(repo_url::AbstractString, repo_path::AbstractString,
+               clone_opts::CloneOptions)
+    clone_opts_ref = Ref(clone_opts)
+    repo_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_clone, :libgit2), Cint,
+            (Ptr{Ptr{Void}}, Cstring, Cstring, Ref{CloneOptions}),
+            repo_ptr_ptr, repo_url, repo_path, clone_opts_ref)
+    return GitRepo(repo_ptr_ptr[])
+end
+
+function fetchheads(repo::GitRepo)
+    fhr = Ref{Vector{FetchHead}}(FetchHead[])
+    ffcb = fetchhead_foreach_cb()
+    @check ccall((:git_repository_fetchhead_foreach, :libgit2), Cint,
+                  (Ptr{Void}, Ptr{Void}, Ptr{Void}),
+                   repo.ptr, ffcb, fhr)
+    return fhr[]
+end
+
+function remotes(repo::GitRepo)
+    out = Ref(StrArrayStruct())
+    @check ccall((:git_remote_list, :libgit2), Cint,
+                  (Ptr{Void}, Ptr{Void}), out, repo.ptr)
+    return convert(Vector{AbstractString}, out[])
+end
diff --git a/base/libgit2/signature.jl b/base/libgit2/signature.jl
new file mode 100644
index 0000000000000..41931daad0c12
--- /dev/null
+++ b/base/libgit2/signature.jl
@@ -0,0 +1,44 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function Signature(ptr::Ptr{SignatureStruct})
+    sig   = unsafe_load(ptr)::SignatureStruct
+    name  = bytestring(sig.name)
+    email = bytestring(sig.email)
+    time   = sig.when.time
+    offset = sig.when.offset
+    return Signature(name, email, time, offset)
+end
+Signature(sig::GitSignature) = Signature(sig.ptr)
+
+function Signature(name::AbstractString, email::AbstractString)
+    sig_ptr_ptr = Ref{Ptr{SignatureStruct}}(C_NULL)
+    @check ccall((:git_signature_now, :libgit2), Cint,
+                 (Ptr{Ptr{SignatureStruct}}, Cstring, Cstring), sig_ptr_ptr, name, email)
+    sig = GitSignature(sig_ptr_ptr[])
+    s = Signature(sig.ptr)
+    finalize(sig)
+    return s
+end
+
+function Signature(repo::GitRepo)
+    sig = default_signature(repo)
+    s = Signature(sig.ptr)
+    finalize(sig)
+    return s
+end
+
+function Base.convert(::Type{GitSignature}, sig::Signature)
+    sig_ptr_ptr = Ref{Ptr{SignatureStruct}}(C_NULL)
+    @check ccall((:git_signature_new, :libgit2), Cint,
+                 (Ptr{Ptr{SignatureStruct}}, Cstring, Cstring, Int64, Cint),
+                 sig_ptr_ptr, sig.name, sig.email, sig.time, sig.time_offset)
+    return GitSignature(sig_ptr_ptr[])
+end
+
+"""Return signature object. Free it after use."""
+function default_signature(repo::GitRepo)
+    sig_ptr_ptr = Ref{Ptr{SignatureStruct}}(C_NULL)
+    @check ccall((:git_signature_default, :libgit2), Cint,
+                 (Ptr{Ptr{SignatureStruct}}, Ptr{Void}), sig_ptr_ptr, repo.ptr)
+    return GitSignature(sig_ptr_ptr[])
+end
diff --git a/base/libgit2/status.jl b/base/libgit2/status.jl
new file mode 100644
index 0000000000000..1cc163f89756d
--- /dev/null
+++ b/base/libgit2/status.jl
@@ -0,0 +1,24 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitStatus(repo::GitRepo; status_opts=StatusOptions())
+    stat_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_status_list_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ptr{StatusOptions}),
+                  stat_ptr_ptr, repo.ptr, Ref(status_opts))
+    return GitStatus(stat_ptr_ptr[])
+end
+
+function Base.length(status::GitStatus)
+    return Int(ccall((:git_status_list_entrycount, :libgit2), Csize_t,
+                      (Ptr{Ptr{Void}}, ), status.ptr))
+end
+
+function Base.getindex(status::GitStatus, i::Csize_t)
+    entry_ptr = ccall((:git_status_byindex, :libgit2), Ptr{Void},
+                       (Ptr{Void}, Csize_t), status.ptr, i-1)
+    entry_ptr == C_NULL && return nothing
+    return unsafe_load(convert(Ptr{StatusEntry}, entry_ptr), 1)
+end
+Base.getindex(status::GitStatus, i::Int) = getindex(status, Csize_t(i))
+
+
diff --git a/base/libgit2/strarray.jl b/base/libgit2/strarray.jl
new file mode 100644
index 0000000000000..aa1483980d45d
--- /dev/null
+++ b/base/libgit2/strarray.jl
@@ -0,0 +1,33 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function StrArrayStruct{T<:AbstractString}(strs::T...)
+    strcount = length(strs)
+    map(s->Base.unsafe_convert(Cstring, bytestring(s)), strs) # check for null-strings
+    sa_strings = convert(Ptr{Cstring}, Libc.malloc(sizeof(Cstring) * strcount))
+    for i=1:strcount
+        len = length(strs[i])
+        in_ptr  = pointer(bytestring(strs[i]))
+        out_ptr = convert(Ptr{UInt8}, Libc.malloc(sizeof(UInt8) * (len + 1)))
+        unsafe_copy!(out_ptr, in_ptr, len)
+        unsafe_store!(out_ptr, zero(UInt8), len + 1) # NULL byte
+        unsafe_store!(sa_strings, convert(Cstring, out_ptr), i)
+    end
+    return StrArrayStruct(sa_strings, strcount)
+end
+StrArrayStruct{T<:AbstractString}(strs::Vector{T}) = StrArrayStruct(strs...)
+
+function Base.convert(::Type{Vector{AbstractString}}, sa::StrArrayStruct)
+    arr = Array(AbstractString, sa.count)
+    for i=1:sa.count
+        arr[i] = bytestring(unsafe_load(sa.strings, i))
+    end
+    return arr
+end
+
+function Base.copy(src::StrArrayStruct)
+    dst_ptr = Ref(StrArrayStruct())
+    @check ccall((:git_strarray_copy, :libgit2), Cint,
+                  (Ptr{StrArrayStruct}, Ptr{StrArrayStruct}),
+                   dst_ptr, Ref(src))
+    return dst_ptr[]
+end
diff --git a/base/libgit2/tag.jl b/base/libgit2/tag.jl
new file mode 100644
index 0000000000000..efaeb5feb1e57
--- /dev/null
+++ b/base/libgit2/tag.jl
@@ -0,0 +1,40 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function tag_list(repo::GitRepo)
+    with(StrArrayStruct()) do sa
+        sa_ref = Ref(sa)
+        @check ccall((:git_tag_list, :libgit2), Cint,
+                      (Ptr{StrArrayStruct}, Ptr{Void}), sa_ref, repo.ptr)
+        convert(Vector{AbstractString}, sa_ref[])
+    end
+end
+
+function tag_delete(repo::GitRepo, tag::AbstractString)
+    @check ccall((:git_tag_delete, :libgit2), Cint,
+                  (Ptr{Void}, Cstring, ), repo.ptr, tag)
+end
+
+function tag_create(repo::GitRepo, tag::AbstractString, commit::Union{AbstractString,Oid};
+                    msg::AbstractString = "",
+                    force::Bool = false,
+                    sig::Signature = Signature(repo))
+    oid_ptr = Ref(Oid())
+    with(get(GitCommit, repo, commit)) do commit_obj
+        commit_obj === nothing && return oid_ptr[] # return empty oid
+        with(convert(GitSignature, sig)) do git_sig
+            @check ccall((:git_tag_create, :libgit2), Cint,
+                 (Ptr{Oid}, Ptr{Void}, Cstring, Ptr{Void}, Ptr{SignatureStruct}, Cstring, Cint),
+                  oid_ptr, repo.ptr, tag, commit_obj.ptr, git_sig.ptr, msg, Cint(force))
+        end
+    end
+    return oid_ptr[]
+end
+
+function name(tag::GitTag)
+    return bytestring(ccall((:git_tag_name, :libgit2), Cstring, (Ptr{Void}, ), tag.ptr))
+end
+
+function target(tag::GitTag)
+    oid_ptr = Ref(ccall((:git_tag_target_id, :libgit2), Ptr{Oid}, (Ptr{Void}, ), tag.ptr))
+    return oid_ptr[]
+end
diff --git a/base/libgit2/tree.jl b/base/libgit2/tree.jl
new file mode 100644
index 0000000000000..a8bf387b5be3d
--- /dev/null
+++ b/base/libgit2/tree.jl
@@ -0,0 +1,36 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+"""
+Traverse the entries in a tree and its subtrees in post or pre order.
+
+Function parameter should have following signature:
+
+    (Cstring, Ptr{Void}, Ptr{Void}) -> Cint
+"""
+function treewalk(f::Function, tree::GitTree, payload=Any[], post::Bool = false)
+    cbf = cfunction(f, Cint, (Cstring, Ptr{Void}, Ptr{Void}))
+    cbf_payload = Ref{typeof(payload)}(payload)
+    @check ccall((:git_tree_walk, :libgit2), Cint,
+                  (Ptr{Void}, Cint, Ptr{Void}, Ptr{Void}),
+                   tree.ptr, post, cbf, cbf_payload)
+    return cbf_payload
+end
+
+function filename(te::GitTreeEntry)
+    str = ccall((:git_tree_entry_name, :libgit2), Cstring, (Ptr{Void},), te.ptr)
+    str != C_NULL && return bytestring(str)
+    return nothing
+end
+
+function filemode(te::GitTreeEntry)
+    return ccall((:git_tree_entry_filemode, :libgit2), Cint, (Ptr{Void},), te.ptr)
+end
+
+
+function object(repo::GitRepo, te::GitTreeEntry)
+    obj_ptr_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_tree_entry_to_object, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}, Ref{Void}),
+                   obj_ptr_ptr, repo.ptr, te.ptr)
+    return GitAnyObject(obj_ptr_ptr[])
+end
diff --git a/base/libgit2/types.jl b/base/libgit2/types.jl
new file mode 100644
index 0000000000000..e9d4135fa7fde
--- /dev/null
+++ b/base/libgit2/types.jl
@@ -0,0 +1,540 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+const Cstring_NULL = convert(Cstring, Ptr{UInt8}(C_NULL))
+
+const OID_RAWSZ = 20
+const OID_HEXSZ = OID_RAWSZ * 2
+const OID_MINPREFIXLEN = 4
+
+immutable Oid
+    val::NTuple{OID_RAWSZ, UInt8}
+    Oid(val::NTuple{OID_RAWSZ, UInt8}) = new(val)
+end
+Oid() = Oid(ntuple(i->zero(UInt8), OID_RAWSZ))
+
+immutable TimeStruct
+    time::Int64     # time in seconds from epoch
+    offset::Cint    # timezone offset in minutes
+end
+TimeStruct() = TimeStruct(zero(Int64), zero(Cint))
+
+immutable SignatureStruct
+    name::Ptr{UInt8}  # full name of the author
+    email::Ptr{UInt8} # email of the author
+    when::TimeStruct  # time when the action happened
+end
+SignatureStruct() = SignatureStruct(Ptr{UInt8}(0),
+                                    Ptr{UInt8}(0),
+                                    TimeStruct())
+
+immutable StrArrayStruct
+   strings::Ptr{Cstring}
+   count::Csize_t
+end
+StrArrayStruct() = StrArrayStruct(Ptr{Cstring}(C_NULL), zero(Csize_t))
+function Base.finalize(sa::StrArrayStruct)
+    sa_ptr = Ref(sa)
+    ccall((:git_strarray_free, :libgit2), Void, (Ptr{StrArrayStruct},), sa_ptr)
+    return sa_ptr[]
+end
+
+immutable Buffer
+    ptr::Ptr{Cchar}
+    asize::Csize_t
+    size::Csize_t
+end
+Buffer() = Buffer(Ptr{Cchar}(C_NULL), zero(Csize_t), zero(Csize_t))
+function Base.finalize(buf::Buffer)
+    buf_ptr = Ref(buf)
+    ccall((:git_buf_free, :libgit2), Void, (Ptr{Buffer},), buf_ptr)
+    return buf_ptr[]
+end
+
+"Abstract payload type for callback functions"
+abstract AbstractPayload
+user(p::AbstractPayload) = throw(AssertionError("Function 'user' is not implemented for type $(typeof(p))"))
+password(p::AbstractPayload) = throw(AssertionError("Function 'password' is not implemented for type $(typeof(p))"))
+isused(p::AbstractPayload) = throw(AssertionError("Function 'isused' is not implemented for type $(typeof(p))"))
+setused!(p::AbstractPayload,v::Bool) = throw(AssertionError("Function 'setused!' is not implemented for type $(typeof(p))"))
+
+immutable CheckoutOptions
+    version::Cuint
+
+    checkout_strategy::Cuint
+
+    disable_filters::Cint
+    dir_mode::Cuint
+    file_mode::Cuint
+    file_open_flags::Cint
+
+    notify_flags::Cuint
+    notify_cb::Ptr{Void}
+    notify_payload::Ptr{Void}
+
+    progress_cb::Ptr{Void}
+    progress_payload::Ptr{Void}
+
+    paths::StrArrayStruct
+
+    baseline::Ptr{Void}
+    baseline_index::Ptr{Void}
+
+    target_directory::Cstring
+    ancestor_label::Cstring
+    our_label::Cstring
+    their_label::Cstring
+
+    perfdata_cb::Ptr{Void}
+    perfdata_payload::Ptr{Void}
+end
+CheckoutOptions(; checkout_strategy::Cuint = Consts.CHECKOUT_SAFE,
+                  disable_filters::Cint = zero(Cint),
+                  dir_mode::Cuint = Cuint(0), # Cuint(0o755),
+                  file_mode::Cuint = Cuint(0), #Cuint(0o644),
+                  file_open_flags::Cint = zero(Cint),
+                  notify_flags::Cuint = Consts.CHECKOUT_NOTIFY_NONE,
+                  notify_cb::Ptr{Void} = Ptr{Void}(0),
+                  notify_payload::Ptr{Void} = Ptr{Void}(0),
+                  progress_cb::Ptr{Void} = Ptr{Void}(0),
+                  progress_payload::Ptr{Void} = Ptr{Void}(0),
+                  paths::StrArrayStruct = StrArrayStruct(),
+                  baseline::Ptr{Void} = Ptr{Void}(0),
+                  baseline_index::Ptr{Void} = Ptr{Void}(0),
+                  target_directory::Cstring = Cstring_NULL,
+                  ancestor_label::Cstring = Cstring_NULL,
+                  our_label::Cstring = Cstring_NULL,
+                  their_label::Cstring = Cstring_NULL,
+                  perfdata_cb::Ptr{Void} = Ptr{Void}(0),
+                  perfdata_payload::Ptr{Void} = Ptr{Void}(0)
+)=CheckoutOptions(one(Cuint),
+                  checkout_strategy,
+                  disable_filters,
+                  dir_mode,
+                  file_mode,
+                  file_open_flags,
+                  notify_flags,
+                  notify_cb,
+                  notify_payload,
+                  progress_cb,
+                  progress_payload,
+                  paths,
+                  baseline,
+                  baseline_index,
+                  target_directory,
+                  ancestor_label,
+                  our_label,
+                  their_label,
+                  perfdata_cb,
+                  perfdata_payload)
+
+immutable RemoteCallbacks
+    version::Cuint
+    sideband_progress::Ptr{Void}
+    completion::Ptr{Void}
+    credentials::Ptr{Void}
+    certificate_check::Ptr{Void}
+    transfer_progress::Ptr{Void}
+    update_tips::Ptr{Void}
+    pack_progress::Ptr{Void}
+    push_transfer_progress::Ptr{Void}
+    push_update_reference::Ptr{Void}
+    push_negotiation::Ptr{Void}
+    transport::Ptr{Void}
+    payload::Ptr{Void}
+end
+RemoteCallbacks(; sideband_progress::Ptr{Void} = C_NULL,
+                  completion::Ptr{Void} = C_NULL,
+                  credentials::Ptr{Void} = C_NULL,
+                  certificate_check::Ptr{Void} = C_NULL,
+                  transfer_progress::Ptr{Void} = C_NULL,
+                  update_tips::Ptr{Void} = C_NULL,
+                  pack_progress::Ptr{Void} = C_NULL,
+                  push_transfer_progress::Ptr{Void} = C_NULL,
+                  push_update_reference::Ptr{Void} = C_NULL,
+                  push_negotiation::Ptr{Void} = C_NULL,
+                  transport::Ptr{Void} = C_NULL,
+                  payload::Ptr{Void} = C_NULL
+)=RemoteCallbacks(one(Cuint),
+                  sideband_progress,
+                  completion,
+                  credentials,
+                  certificate_check,
+                  transfer_progress,
+                  update_tips,
+                  pack_progress,
+                  push_transfer_progress,
+                  push_update_reference,
+                  push_negotiation,
+                  transport,
+                  payload)
+
+function RemoteCallbacks{P<:AbstractPayload}(credentials::Ptr{Void}, payload::Nullable{P})
+    if isnull(payload)
+        RemoteCallbacks(credentials=credentials_cb())
+    else
+        payload_ptr = pointer_from_objref(Base.get(payload))
+        RemoteCallbacks(credentials=credentials_cb(), payload=payload_ptr)
+    end
+end
+
+immutable FetchOptions
+    version::Cuint
+    callbacks::RemoteCallbacks
+    prune::Cint
+    update_fetchhead::Cint
+    download_tags::Cint
+end
+FetchOptions(; callbacks::RemoteCallbacks = RemoteCallbacks(),
+               prune::Cint = Consts.FETCH_PRUNE_UNSPECIFIED,
+               update_fetchhead::Cint = one(Cint),
+               download_tags::Cint = Consts.REMOTE_DOWNLOAD_TAGS_AUTO
+) = FetchOptions(one(Cuint),
+                 callbacks,
+                 prune,
+                 update_fetchhead,
+                 download_tags)
+
+immutable CloneOptions
+    version::Cuint
+    checkout_opts::CheckoutOptions
+    fetch_opts::FetchOptions
+    bare::Cint
+    localclone::Cint
+    checkout_branch::Cstring
+    repository_cb::Ptr{Void}
+    repository_cb_payload::Ptr{Void}
+    remote_cb::Ptr{Void}
+    remote_cb_payload::Ptr{Void}
+end
+CloneOptions(; checkout_opts::CheckoutOptions = CheckoutOptions(),
+               fetch_opts::FetchOptions = FetchOptions(),
+               bare::Cint = zero(Cint),
+               localclone::Cint = Consts.CLONE_LOCAL_AUTO,
+               checkout_branch::Cstring = Cstring_NULL,
+               repository_cb::Ptr{Void} = Ptr{Void}(0),
+               repository_cb_payload::Ptr{Void} = Ptr{Void}(0),
+               remote_cb::Ptr{Void} = Ptr{Void}(0),
+               remote_cb_payload::Ptr{Void} = Ptr{Void}(0)
+)=CloneOptions(one(Cuint),
+               checkout_opts,
+               fetch_opts,
+               bare,
+               localclone,
+               checkout_branch,
+               repository_cb,
+               repository_cb_payload,
+               remote_cb,
+               remote_cb_payload)
+
+# git diff option struct
+immutable DiffOptionsStruct
+    version::Cuint
+    flags::UInt32
+
+    # options controlling which files are in the diff
+    ignore_submodules::Cint
+    pathspec::StrArrayStruct
+    notify_cb::Ptr{Void}
+    notify_payload::Ptr{Void}
+
+    # options controlling how the diff text is generated
+    context_lines::UInt32
+    interhunk_lines::UInt32
+    id_abbrev::UInt16
+    max_size::Int64
+    old_prefix::Cstring
+    new_prefix::Cstring
+end
+DiffOptionsStruct(; flags::UInt32 = Consts.DIFF_NORMAL,
+                    ignore_submodules::Cint = Cint(Consts.SUBMODULE_IGNORE_UNSPECIFIED),
+                    pathspec::StrArrayStruct = StrArrayStruct(),
+                    notify_cb::Ptr{Void} = C_NULL,
+                    notify_payload::Ptr{Void} = C_NULL,
+                    context_lines::UInt32 = UInt32(3),
+                    interhunk_lines::UInt32 = zero(UInt32),
+                    id_abbrev::UInt16 = UInt16(7),
+                    max_size::Int64 = Int64(512*1024*1024), #zero(Int64), #512Mb
+                    old_prefix::Cstring = Cstring_NULL,
+                    new_prefix::Cstring = Cstring_NULL
+)=DiffOptionsStruct(Consts.DIFF_OPTIONS_VERSION,
+                    flags,
+                    ignore_submodules,
+                    pathspec,
+                    notify_cb,
+                    notify_payload,
+                    context_lines,
+                    interhunk_lines,
+                    id_abbrev,
+                    max_size,
+                    old_prefix,
+                    new_prefix
+                )
+
+immutable DiffFile
+    id::Oid
+    path::Cstring
+    size::Int64
+    flags::Cuint
+    mode::UInt16
+end
+DiffFile()=DiffFile(Oid(),Cstring_NULL,Int64(0),Cuint(0),UInt16(0))
+
+immutable DiffDelta
+    status::Cint
+    flags::Cuint
+    similarity::UInt16
+    nfiles::UInt16
+    old_file::DiffFile
+    new_file::DiffFile
+end
+DiffDelta()=DiffDelta(Cint(0),Cuint(0),UInt16(0),UInt16(0),DiffFile(),DiffFile())
+
+immutable MergeOptions
+    version::Cuint
+    tree_flags::Cint
+    rename_threshold::Cuint
+    target_limit::Cuint
+    metric::Ptr{Void}
+    file_favor::Cint
+    file_flags::Cuint
+end
+MergeOptions(; tree_flags::Cint = Cint(0),
+               rename_threshold::Cuint = Cuint(50),
+               target_limit::Cuint = Cuint(200),
+               metric::Ptr{Void} = C_NULL,
+               file_favor::Cint = Cint(Consts.MERGE_FILE_FAVOR_NORMAL),
+               file_flags::Cuint =Cuint(Consts.MERGE_FILE_DEFAULT)
+)=MergeOptions(one(Cuint),
+               tree_flags,
+               rename_threshold,
+               target_limit,
+               metric,
+               file_favor,
+               file_flags
+              )
+
+immutable PushOptions
+    version::Cuint
+    parallelism::Cint
+    callbacks::RemoteCallbacks
+end
+PushOptions(; parallelism::Cint=one(Cint),
+              callbacks::RemoteCallbacks=RemoteCallbacks()
+)=PushOptions(one(Cuint),
+              parallelism,
+              callbacks)
+
+immutable IndexTime
+    seconds::Int64
+    nanoseconds::Cuint
+    IndexTime() = new(zero(Int64), zero(Cuint))
+end
+
+immutable IndexEntry
+    ctime::IndexTime
+    mtime::IndexTime
+
+    dev::Cuint
+    ino::Cuint
+    mode::Cuint
+    uid::Cuint
+    gid::Cuint
+    file_size::Int64
+
+    id::Oid
+
+    flags::UInt16
+    flags_extended::UInt16
+
+    path::Ptr{UInt8}
+end
+IndexEntry() = IndexEntry(IndexTime(),
+                          IndexTime(),
+                          Cuint(0),
+                          Cuint(0),
+                          Cuint(0),
+                          Cuint(0),
+                          Cuint(0),
+                          Int64(0),
+                          Oid(),
+                          UInt16(0),
+                          UInt16(0),
+                          Ptr{UInt8}(0))
+Base.show(io::IO, ie::IndexEntry) = print(io, "IndexEntry($(string(ie.id)))")
+
+immutable RebaseOptions
+    version::Cuint
+    quiet::Cint
+    rewrite_notes_ref::Cstring
+    checkout_opts::CheckoutOptions
+end
+RebaseOptions(; quiet::Cint = Cint(1),
+                rewrite_notes_ref::Cstring = Cstring_NULL,
+                checkout_opts::CheckoutOptions = CheckoutOptions()
+)=RebaseOptions(one(Cuint), quiet, rewrite_notes_ref, checkout_opts)
+
+immutable RebaseOperation
+    optype::Cint
+    id::Oid
+    exec::Cstring
+end
+RebaseOperation()=RebaseOperation(Cint(0), Oid(), Cstring_NULL)
+Base.show(io::IO, rbo::RebaseOperation) = print(io, "RebaseOperation($(string(rbo.id)))")
+
+immutable StatusOptions
+    version::Cuint
+    show::Cint
+    flags::Cuint
+    pathspec::StrArrayStruct
+end
+StatusOptions(; show::Cint = Consts.STATUS_SHOW_INDEX_AND_WORKDIR,
+                flags::Cuint = Consts.STATUS_OPT_INCLUDE_UNTRACKED |
+                               Consts.STATUS_OPT_RECURSE_UNTRACKED_DIRS |
+                               Consts.STATUS_OPT_RENAMES_HEAD_TO_INDEX |
+                               Consts.STATUS_OPT_SORT_CASE_SENSITIVELY,
+                pathspec::StrArrayStruct = StrArrayStruct()
+)=StatusOptions(one(Cuint),
+                show,
+                flags,
+                pathspec)
+
+immutable StatusEntry
+    status::Cuint
+    head_to_index::Ptr{DiffDelta}
+    index_to_workdir::Ptr{DiffDelta}
+end
+StatusEntry()=StatusEntry(Cuint(0), C_NULL, C_NULL)
+
+immutable FetchHead
+    name::AbstractString
+    url::AbstractString
+    oid::Oid
+    ismerge::Bool
+end
+
+# Abstract object types
+abstract AbstractGitObject
+Base.isempty(obj::AbstractGitObject) = (obj.ptr == C_NULL)
+
+abstract GitObject <: AbstractGitObject
+function Base.finalize(obj::GitObject)
+    if obj.ptr != C_NULL
+        ccall((:git_object_free, :libgit2), Void, (Ptr{Void},), obj.ptr)
+        obj.ptr = C_NULL
+    end
+end
+
+# Common types
+for (typ, ref, sup, fnc) in (
+            (:GitRemote,     :Void, :AbstractGitObject, :(:git_remote_free)),
+            (:GitRevWalker,  :Void, :AbstractGitObject, :(:git_revwalk_free)),
+            (:GitConfig,     :Void, :AbstractGitObject, :(:git_config_free)),
+            (:GitReference,  :Void, :AbstractGitObject, :(:git_reference_free)),
+            (:GitDiff,       :Void, :AbstractGitObject, :(:git_diff_free)),
+            (:GitIndex,      :Void, :AbstractGitObject, :(:git_index_free)),
+            (:GitRepo,       :Void, :AbstractGitObject, :(:git_repository_free)),
+            (:GitAnnotated,  :Void, :AbstractGitObject, :(:git_annotated_commit_free)),
+            (:GitRebase,     :Void, :AbstractGitObject, :(:git_rebase_free)),
+            (:GitStatus,     :Void, :AbstractGitObject, :(:git_status_list_free)),
+            (:GitBranchIter, :Void, :AbstractGitObject, :(:git_branch_iterator_free)),
+            (:GitTreeEntry,  :Void, :AbstractGitObject, :(:git_tree_entry_free)),
+            (:GitSignature,  :SignatureStruct, :AbstractGitObject, :(:git_signature_free)),
+            (:GitAnyObject,  :Void, :GitObject, nothing),
+            (:GitCommit,     :Void, :GitObject, nothing),
+            (:GitBlob,       :Void, :GitObject, nothing),
+            (:GitTree,       :Void, :GitObject, nothing),
+            (:GitTag,        :Void, :GitObject, nothing)
+        )
+
+    @eval type $typ <: $sup
+        ptr::Ptr{$ref}
+        function $typ(ptr::Ptr{$ref})
+            @assert ptr != C_NULL
+            obj = new(ptr)
+            return obj
+        end
+    end
+
+    if fnc !== nothing
+        @eval function Base.finalize(obj::$typ)
+            if obj.ptr != C_NULL
+                ccall(($fnc, :libgit2), Void, (Ptr{$ref},), obj.ptr)
+                obj.ptr = C_NULL
+            end
+        end
+    end
+
+end
+
+# Structure has the same layout as SignatureStruct
+type Signature
+    name::AbstractString
+    email::AbstractString
+    time::Int64
+    time_offset::Int32
+end
+
+""" Resource management helper function
+"""
+function with(f::Function, obj)
+    try
+        f(obj)
+    finally
+        finalize(obj)
+    end
+end
+
+with{T}(f::Function, ::Type{T}, args...) = with(f, T(args...))
+
+function with_warn{T}(f::Function, ::Type{T}, args...)
+    obj = T(args...)
+    try
+        with(f, obj)
+    catch err
+        warn("$(string(T)) thrown exception: $err")
+    end
+end
+
+
+function getobjecttype{T<:GitObject}(::Type{T})
+    return if T == GitCommit
+        Consts.OBJ_COMMIT
+    elseif T == GitTree
+        Consts.OBJ_TREE
+    elseif T == GitBlob
+        Consts.OBJ_BLOB
+    elseif T == GitTag
+        Consts.OBJ_TAG
+    elseif T == GitAnyObject
+        Consts.OBJ_ANY
+    else
+        throw(GitError(Error.Object, Error.ENOTFOUND, "Type $T is not supported"))
+    end
+end
+
+function getobjecttype(obj_type::Cint)
+    return if obj_type == Consts.OBJ_COMMIT
+        GitCommit
+    elseif obj_type == Consts.OBJ_TREE
+        GitTree
+    elseif obj_type == Consts.OBJ_BLOB
+        GitBlob
+    elseif obj_type == Consts.OBJ_TAG
+        GitTag
+    elseif obj_type == Consts.OBJ_ANY
+        GitAnyObject
+    else
+        throw(GitError(Error.Object, Error.ENOTFOUND, "Object type $obj_type is not supported"))
+    end
+end
+
+type UserPasswordCredentials <: AbstractPayload
+    user::AbstractString
+    pass::AbstractString
+    used::Bool
+    UserPasswordCredentials(u::AbstractString,p::AbstractString) = new(u,p,false)
+end
+user(p::UserPasswordCredentials) = p.user
+password(p::UserPasswordCredentials) = p.pass
+isused(p::UserPasswordCredentials) = p.used
+setused!(p::UserPasswordCredentials, val::Bool) = (p.used = val)
diff --git a/base/libgit2/utils.jl b/base/libgit2/utils.jl
new file mode 100644
index 0000000000000..b0c841b902e90
--- /dev/null
+++ b/base/libgit2/utils.jl
@@ -0,0 +1,23 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function version()
+    major = Ref{Cint}(0)
+    minor = Ref{Cint}(0)
+    patch = Ref{Cint}(0)
+    ccall((:git_libgit2_version, :libgit2), Void,
+          (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), major, minor, patch)
+    return VersionNumber(major[], minor[], patch[])
+end
+
+isset(val::Integer, flag::Integer) = (val & flag == flag)
+
+function prompt(msg::AbstractString; default::AbstractString="", password::Bool=false)
+    msg = !isempty(default) ? msg*" [$default]:" : msg*":"
+    uinput = if password
+        bytestring(ccall(:getpass, Cstring, (Cstring,), msg))
+    else
+        print(msg)
+        chomp(readline(STDIN))
+    end
+    isempty(uinput) ? default : uinput
+end
diff --git a/base/libgit2/walker.jl b/base/libgit2/walker.jl
new file mode 100644
index 0000000000000..9bf2fa93529df
--- /dev/null
+++ b/base/libgit2/walker.jl
@@ -0,0 +1,104 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+function GitRevWalker(r::GitRepo)
+    w_ptr = Ref{Ptr{Void}}(C_NULL)
+    @check ccall((:git_revwalk_new, :libgit2), Cint,
+                  (Ptr{Ptr{Void}}, Ptr{Void}), w_ptr, r.ptr)
+    return GitRevWalker(w_ptr[])
+end
+
+function Base.start(w::GitRevWalker)
+    id_ptr = Ref(Oid())
+    err = ccall((:git_revwalk_next, :libgit2), Cint,
+                (Ptr{Oid}, Ptr{Void}), id_ptr, w.ptr)
+    err != Int(Error.GIT_OK) && return (nothing, true)
+    return (id_ptr[], false)
+end
+
+Base.done(w::GitRevWalker, state) = Bool(state[2])
+
+function Base.next(w::GitRevWalker, state)
+    id_ptr = Ref(Oid())
+    err = ccall((:git_revwalk_next, :libgit2), Cint,
+                (Ptr{Oid}, Ptr{Void}), id_ptr, w.ptr)
+    err != Int(Error.GIT_OK) && return (state[1], (nothing, true))
+    return (state[1], (id_ptr[], false))
+end
+
+function push_head!(w::GitRevWalker)
+    @check ccall((:git_revwalk_push_head, :libgit2), Cint, (Ptr{Void},), w.ptr)
+    return w
+end
+
+function Base.push!(w::GitRevWalker, cid::Oid)
+    @check ccall((:git_revwalk_push, :libgit2), Cint, (Ptr{Void}, Ptr{Oid}), w.ptr, Ref(cid))
+    return w
+end
+
+function Base.push!(w::GitRevWalker, range::AbstractString)
+    @check ccall((:git_revwalk_push_range, :libgit2), Cint, (Ptr{Void}, Ptr{UInt8}), w.ptr, range)
+    return w
+end
+
+function Base.sort!(w::GitRevWalker; by::Cint = Consts.SORT_NONE, rev::Bool=false)
+    rev && (by |= Consts.SORT_REVERSE)
+    ccall((:git_revwalk_sorting, :libgit2), Void, (Ptr{Void}, Cint), w.ptr, by)
+    return w
+end
+
+function repository(w::GitRevWalker)
+    ptr = ccall((:git_revwalk_repository, :libgit2), Ptr{Void}, (Ptr{Void},), w.ptr)
+    ptr != C_NULL && return GitRepo(ptr)
+    return  nothing
+end
+
+function Base.map(f::Function, walker::GitRevWalker;
+                  oid::Oid=Oid(),
+                  range::AbstractString="",
+                  by::Cint = Consts.SORT_NONE,
+                  rev::Bool=false,
+                  count::Int=0)
+    res = []
+    sort!(walker, by=by, rev=rev)
+    if !iszero(oid)
+        push!(walker, oid)
+    elseif !isempty(range)
+        push!(walker, range)
+    else
+        push_head!(walker)
+    end
+    s = start(walker)
+
+    c = 0
+    repo = repository(walker)
+    while !done(walker, s)
+        val = f(s[1], repo)
+        push!(res, val)
+        val, s = next(walker, s)
+        c +=1
+        count == c && break
+    end
+    return res
+end
+
+function Base.count(f::Function, walker::GitRevWalker;
+                  oid::Oid=Oid(),
+                  by::Cint = Consts.SORT_NONE,
+                  rev::Bool=false)
+    c = 0
+    sort!(walker, by=by, rev=rev)
+    if !iszero(oid)
+        push!(walker, oid)
+    else
+        push_head!(walker)
+    end
+    s = start(walker)
+
+    repo = repository(walker)
+    while !done(walker, s)
+        val = f(s[1], repo)
+        _, s = next(walker, s)
+        c += (val == true)
+    end
+    return c
+end
diff --git a/base/linalg.jl b/base/linalg.jl
index 5947cd6d59d6f..631722bfde676 100644
--- a/base/linalg.jl
+++ b/base/linalg.jl
@@ -2,11 +2,15 @@
 
 module LinAlg
 
-importall Base
-importall ..Base.Operators
-import Base: USE_BLAS64, size, copy, copy_transpose!, power_by_squaring,
-             print_matrix, transpose!, unsafe_getindex, unsafe_setindex!,
-             isapprox
+import Base: \, /, *, ^, +, -, ==, ./, .*
+import Base: A_mul_Bt, At_ldiv_Bt, A_rdiv_Bc, At_ldiv_B, Ac_mul_Bc, A_mul_Bc, Ac_mul_B,
+    Ac_ldiv_B, Ac_ldiv_Bc, At_mul_Bt, A_rdiv_Bt, At_mul_B
+import Base: USE_BLAS64, abs, big, ceil, conj, convert, copy, copy!, copy_transpose!,
+    ctranspose, ctranspose!, eltype, eye, findmax, findmin, fill!, floor, full, getindex,
+    imag, inv, isapprox, kron, ndims, parent, power_by_squaring, print_matrix,
+    promote_rule, real, round, setindex!, show, similar, size, transpose, transpose!,
+    trunc
+using Base: promote_op, MulFun
 
 export
 # Modules
@@ -30,6 +34,7 @@ export
     LDLt,
     QR,
     QRPivoted,
+    LQ,
     Schur,
     SVD,
     Hermitian,
@@ -77,7 +82,7 @@ export
     ishermitian,
     isposdef,
     isposdef!,
-    issym,
+    issymmetric,
     istril,
     istriu,
     kron,
@@ -92,6 +97,8 @@ export
     lufact!,
     lyap,
     norm,
+    normalize,
+    normalize!,
     nullspace,
     ordschur!,
     ordschur,
@@ -100,8 +107,10 @@ export
     qr,
     qrfact!,
     qrfact,
+    lq,
+    lqfact!,
+    lqfact,
     rank,
-    scale,
     scale!,
     schur,
     schurfact!,
@@ -173,14 +182,18 @@ function chkstride1(A...)
     end
 end
 
-# Check that matrix is square
-function chksquare(A)
+"""
+    LinAlg.checksquare(A)
+
+Check that a matrix is square, then return its common dimension. For multiple arguments, return a vector.
+"""
+function checksquare(A)
     m,n = size(A)
     m == n || throw(DimensionMismatch("matrix is not square"))
     m
 end
 
-function chksquare(A...)
+function checksquare(A...)
     sizes = Int[]
     for a in A
         size(a,1)==size(a,2) || throw(DimensionMismatch("matrix is not square: dimensions are $(size(a))"))
@@ -189,17 +202,16 @@ function chksquare(A...)
     return sizes
 end
 
-# Check that upper/lower (for special matrices) is correctly specified
-macro chkuplo()
-   :((uplo=='U' || uplo=='L') || throw(ArgumentError("""invalid uplo = $uplo
-
-Valid choices are 'U' (upper) or 'L' (lower).""")))
+function char_uplo(uplo::Symbol)
+    if uplo == :U
+        'U'
+    elseif uplo == :L
+        'L'
+    else
+        throw(ArgumentError("uplo argument must be either :U (upper) or :L (lower)"))
+    end
 end
 
-const CHARU = 'U'
-const CHARL = 'L'
-char_uplo(uplo::Symbol) = uplo == :U ? CHARU : (uplo == :L ? CHARL : throw(ArgumentError("uplo argument must be either :U or :L")))
-
 copy_oftype{T,N}(A::AbstractArray{T,N}, ::Type{T}) = copy(A)
 copy_oftype{T,N,S}(A::AbstractArray{T,N}, ::Type{S}) = convert(AbstractArray{S,N}, A)
 
@@ -207,6 +219,7 @@ include("linalg/exceptions.jl")
 include("linalg/generic.jl")
 
 include("linalg/blas.jl")
+import .BLAS: gemv! # consider renaming gemv! in matmul
 include("linalg/matmul.jl")
 include("linalg/lapack.jl")
 
@@ -216,6 +229,7 @@ include("linalg/triangular.jl")
 
 include("linalg/factorization.jl")
 include("linalg/qr.jl")
+include("linalg/lq.jl")
 include("linalg/eigen.jl")
 include("linalg/svd.jl")
 include("linalg/schur.jl")
diff --git a/base/linalg/arnoldi.jl b/base/linalg/arnoldi.jl
index aab2d2d01c0d2..ca0fd1075cbf1 100644
--- a/base/linalg/arnoldi.jl
+++ b/base/linalg/arnoldi.jl
@@ -3,20 +3,158 @@
 using .ARPACK
 
 ## eigs
+"""
+    eigs(A; nev=6, ncv=max(20,2*nev+1), which="LM", tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
 
-eigs(A; args...) = eigs(A, I; args...)
+Computes eigenvalues `d` of `A` using implicitly restarted Lanczos or Arnoldi iterations for real symmetric or
+general nonsymmetric matrices respectively.
 
-function eigs(A, B;
+The following keyword arguments are supported:
+
+* `nev`: Number of eigenvalues
+* `ncv`: Number of Krylov vectors used in the computation; should satisfy `nev+1 <= ncv <= n`
+  for real symmetric problems and `nev+2 <= ncv <= n` for other problems, where `n` is the
+  size of the input matrix `A`. The default is `ncv = max(20,2*nev+1)`. Note that these
+  restrictions limit the input matrix `A` to be of dimension at least 2.
+* `which`: type of eigenvalues to compute. See the note below.
+
+| `which` | type of eigenvalues                                                                                                       |
+|:--------|:--------------------------------------------------------------------------------------------------------------------------|
+| `:LM`   | eigenvalues of largest magnitude (default)                                                                                |
+| `:SM`   | eigenvalues of smallest magnitude                                                                                         |
+| `:LR`   | eigenvalues of largest real part                                                                                          |
+| `:SR`   | eigenvalues of smallest real part                                                                                         |
+| `:LI`   | eigenvalues of largest imaginary part (nonsymmetric or complex `A` only)                                                  |
+| `:SI`   | eigenvalues of smallest imaginary part (nonsymmetric or complex `A` only)                                                 |
+| `:BE`   | compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric `A` only) |
+
+* `tol`: parameter defining the relative tolerance for convergence of Ritz values (eigenvalue estimates).
+     A Ritz value ``θ`` is considered converged when its associated residual
+     is less than or equal to the product of `tol` and ``max(ɛ^{2/3}, |θ|)``,
+     where `ɛ = eps(real(eltype(A)))/2` is LAPACK's machine epsilon.
+     The residual associated with ``θ`` and its corresponding Ritz vector ``v``
+     is defined as the norm ``||Av - vθ||``.
+     The specified value of `tol` should be positive; otherwise, it is ignored
+     and ``ɛ`` is used instead.
+     Default: ``ɛ``.
+
+* `maxiter`: Maximum number of iterations (default = 300)
+* `sigma`: Specifies the level shift used in inverse iteration. If `nothing` (default),
+  defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to `sigma`
+  using shift and invert iterations.
+* `ritzvec`: Returns the Ritz vectors `v` (eigenvectors) if `true`
+* `v0`: starting vector from which to start the iterations
+
+`eigs` returns the `nev` requested eigenvalues in `d`, the corresponding Ritz vectors `v`
+(only if `ritzvec=true`), the number of converged eigenvalues `nconv`, the number of
+iterations `niter` and the number of matrix vector multiplications `nmult`, as well as the
+final residual vector `resid`.
+
+**note**
+
+The `sigma` and `which` keywords interact: the description of eigenvalues searched for by
+`which` do _not_ necessarily refer to the eigenvalues of `A`, but rather the linear operator
+constructed by the specification of the iteration mode implied by `sigma`.
+
+| `sigma`         | iteration mode                   | `which` refers to eigenvalues of |
+|:----------------|:---------------------------------|:---------------------------------|
+| `nothing`       | ordinary (forward)               | ``A``                            |
+| real or complex | inverse with level shift `sigma` | ``(A - \\sigma I )^{-1}``        |
+
+**note**
+
+Although `tol` has a default value, the best choice depends strongly on the
+matrix `A`. We recommend that users _always_ specify a value for `tol` which
+suits their specific needs.
+
+For details of how the errors in the computed eigenvalues are estimated, see:
+
+* B. N. Parlett, "The Symmetric Eigenvalue Problem", SIAM: Philadelphia, 2/e
+  (1998), Ch. 13.2, "Accessing Accuracy in Lanczos Problems", pp. 290-292 ff.
+* R. B. Lehoucq and D. C. Sorensen, "Deflation Techniques for an Implicitly
+  Restarted Arnoldi Iteration", SIAM Journal on Matrix Analysis and
+  Applications (1996), 17(4), 789–821.  doi:10.1137/S0895479895281484
+"""
+eigs(A; kwargs...) = eigs(A, I; kwargs...)
+eigs{T<:BlasFloat}(A::AbstractMatrix{T}, ::UniformScaling; kwargs...) = _eigs(A, I; kwargs...)
+
+eigs{T<:BlasFloat}(A::AbstractMatrix{T}, B::AbstractMatrix{T}; kwargs...) = _eigs(A, B; kwargs...)
+eigs(A::AbstractMatrix{BigFloat}, B::AbstractMatrix...; kwargs...) = throw(MethodError(eigs, Any[A,B,kwargs...]))
+eigs(A::AbstractMatrix{BigFloat}, B::UniformScaling; kwargs...) = throw(MethodError(eigs, Any[A,B,kwargs...]))
+function eigs{T}(A::AbstractMatrix{T}, ::UniformScaling; kwargs...)
+    Tnew = typeof(zero(T)/sqrt(one(T)))
+    eigs(convert(AbstractMatrix{Tnew}, A), I; kwargs...)
+end
+function eigs(A::AbstractMatrix, B::AbstractMatrix; kwargs...)
+    T = promote_type(eltype(A), eltype(B))
+    Tnew = typeof(zero(T)/sqrt(one(T)))
+    eigs(convert(AbstractMatrix{Tnew}, A), convert(AbstractMatrix{Tnew}, B); kwargs...)
+end
+"""
+    eigs(A, B; nev=6, ncv=max(20,2*nev+1), which="LM", tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
+
+Computes generalized eigenvalues `d` of `A` and `B` using implicitly restarted Lanczos or Arnoldi iterations for
+real symmetric or general nonsymmetric matrices respectively.
+
+The following keyword arguments are supported:
+
+* `nev`: Number of eigenvalues
+* `ncv`: Number of Krylov vectors used in the computation; should satisfy `nev+1 <= ncv <= n`
+  for real symmetric problems and `nev+2 <= ncv <= n` for other problems, where `n` is the
+  size of the input matrices `A` and `B`. The default is `ncv = max(20,2*nev+1)`. Note that
+  these restrictions limit the input matrix `A` to be of dimension at least 2.
+* `which`: type of eigenvalues to compute. See the note below.
+
+| `which` | type of eigenvalues                                                                                                       |
+|:--------|:--------------------------------------------------------------------------------------------------------------------------|
+| `:LM`   | eigenvalues of largest magnitude (default)                                                                                |
+| `:SM`   | eigenvalues of smallest magnitude                                                                                         |
+| `:LR`   | eigenvalues of largest real part                                                                                          |
+| `:SR`   | eigenvalues of smallest real part                                                                                         |
+| `:LI`   | eigenvalues of largest imaginary part (nonsymmetric or complex `A` only)                                                  |
+| `:SI`   | eigenvalues of smallest imaginary part (nonsymmetric or complex `A` only)                                                 |
+| `:BE`   | compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric `A` only) |
+
+* `tol`: relative tolerance used in the convergence criterion for eigenvalues, similar to
+     `tol` in the [`eigs(A)`](:func:`eigs`) method for the ordinary eigenvalue
+     problem, but effectively for the eigenvalues of ``B^{-1} A`` instead of ``A``.
+     See the documentation for the ordinary eigenvalue problem in
+     [`eigs(A)`](:func:`eigs`) and the accompanying note about `tol`.
+* `maxiter`: Maximum number of iterations (default = 300)
+* `sigma`: Specifies the level shift used in inverse iteration. If `nothing` (default),
+  defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to `sigma`
+  using shift and invert iterations.
+* `ritzvec`: Returns the Ritz vectors `v` (eigenvectors) if `true`
+* `v0`: starting vector from which to start the iterations
+
+`eigs` returns the `nev` requested eigenvalues in `d`, the corresponding Ritz vectors `v`
+(only if `ritzvec=true`), the number of converged eigenvalues `nconv`, the number of
+iterations `niter` and the number of matrix vector multiplications `nmult`, as well as the
+final residual vector `resid`.
+
+**note**
+
+The `sigma` and `which` keywords interact: the description of eigenvalues searched for by
+`which` do _not_ necessarily refer to the eigenvalue problem ``Av = Bv\\lambda``, but rather
+the linear operator constructed by the specification of the iteration mode implied by `sigma`.
+
+| `sigma`         | iteration mode                   | `which` refers to the problem      |
+|:----------------|:---------------------------------|:-----------------------------------|
+| `nothing`       | ordinary (forward)               | ``Av = Bv\\lambda``                |
+| real or complex | inverse with level shift `sigma` | ``(A - \\sigma B )^{-1}B = v\\nu`` |
+"""
+eigs(A, B; kwargs...) = _eigs(A, B; kwargs...)
+function _eigs(A, B;
               nev::Integer=6, ncv::Integer=max(20,2*nev+1), which=:LM,
               tol=0.0, maxiter::Integer=300, sigma=nothing, v0::Vector=zeros(eltype(A),(0,)),
               ritzvec::Bool=true)
 
-    n = chksquare(A)
+    n = checksquare(A)
 
     T = eltype(A)
     iscmplx = T <: Complex
     isgeneral = B !== I
-    sym = issym(A) && !iscmplx
+    sym = issymmetric(A) && !iscmplx
     nevmax=sym ? n-1 : n-2
     if nevmax <= 0
         throw(ArgumentError("Input matrix A is too small. Use eigfact instead."))
@@ -46,7 +184,7 @@ function eigs(A, B;
     end
     if (which != :LM && which != :SM && which != :LR && which != :SR &&
         which != :LI && which != :SI && which != :BE)
-       throw(ArgumentError("which must be :LM, :SM, :LR, :SR, :LI, :SI, or :BE, got $(repr(which))"))
+        throw(ArgumentError("which must be :LM, :SM, :LR, :SR, :LI, :SI, or :BE, got $(repr(which))"))
     end
     if which == :BE && !sym
         throw(ArgumentError("which=:BE only possible for real symmetric problem"))
@@ -101,25 +239,25 @@ function eigs(A, B;
     # Refer to ex-*.doc files in ARPACK/DOCUMENTS for calling sequence
     matvecA(x) = A * x
     if !isgeneral           # Standard problem
-        matvecB(x) = x
+        matvecB = x -> x
         if !isshift         #    Regular mode
             mode       = 1
-            solveSI(x) = x
+            solveSI = x->x
         else                #    Shift-invert mode
             mode       = 3
             F = factorize(sigma==zero(T) ? A : A - UniformScaling(sigma))
-            solveSI(x) = F \ x
+            solveSI = x -> F \ x
         end
     else                    # Generalized eigenproblem
-        matvecB(x) = B * x
+        matvecB = x -> B * x
         if !isshift         #    Regular inverse mode
             mode       = 2
             F = factorize(B)
-            solveSI(x) = F \ x
+            solveSI = x -> F \ x
         else                #    Shift-invert mode
             mode       = 3
             F = factorize(sigma==zero(T) ? A : A-sigma*B)
-            solveSI(x) = F \ x
+            solveSI = x -> F \ x
         end
     end
 
@@ -141,20 +279,77 @@ end
 
 
 ## svds
-
-type SVDOperator{T,S} <: AbstractArray{T, 2}
+### Restrict operator to BlasFloat because ARPACK only supports that. Loosen restriction
+### when we switch to our own implementation
+type SVDOperator{T<:BlasFloat,S} <: AbstractArray{T, 2}
     X::S
     m::Int
     n::Int
-    SVDOperator(X::S) = new(X, size(X,1), size(X,2))
+    SVDOperator(X::AbstractMatrix) = new(X, size(X, 1), size(X, 2))
+end
+
+function SVDOperator{T}(A::AbstractMatrix{T})
+    Tnew = typeof(zero(T)/sqrt(one(T)))
+    Anew = convert(AbstractMatrix{Tnew}, A)
+    SVDOperator{Tnew,typeof(Anew)}(Anew)
 end
 
 ## v = [ left_singular_vector; right_singular_vector ]
 *{T,S}(s::SVDOperator{T,S}, v::Vector{T}) = [s.X * v[s.m+1:end]; s.X' * v[1:s.m]]
 size(s::SVDOperator)  = s.m + s.n, s.m + s.n
-issym(s::SVDOperator) = true
+issymmetric(s::SVDOperator) = true
+
+svds{T<:BlasFloat}(A::AbstractMatrix{T}; kwargs...) = _svds(A; kwargs...)
+svds(A::AbstractMatrix{BigFloat}; kwargs...) = throw(MethodError(svds, Any[A, kwargs...]))
+function svds{T}(A::AbstractMatrix{T}; kwargs...)
+    Tnew = typeof(zero(T)/sqrt(one(T)))
+    svds(convert(AbstractMatrix{Tnew}, A); kwargs...)
+end
+
+"""
+    svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000) -> ([left_sv,] s, [right_sv,] nconv, niter, nmult, resid)
+
+Computes the largest singular values `s` of `A` using implicitly restarted Lanczos
+iterations derived from [`eigs`](:func:`eigs`).
+
+**Inputs**
+
+* `A`: Linear operator whose singular values are desired. `A` may be represented
+  as a subtype of `AbstractArray`, e.g., a sparse matrix, or any other type
+  supporting the four methods `size(A)`, `eltype(A)`, `A * vector`, and
+  `A' * vector`.
+* `nsv`: Number of singular values.
+* `ritzvec`: If `true`, return the left and right singular vectors `left_sv` and `right_sv`.
+   If `false`, omit the singular vectors. Default: `true`.
+* `tol`: tolerance, see [`eigs`](:func:`eigs`).
+* `maxiter`: Maximum number of iterations, see [`eigs`](:func:`eigs`).
+
+**Outputs**
+
+* `left_sv`: Left singular vectors (only if `ritzvec = true`).
+* `s`: A vector of length `nsv` containing the requested singular values.
+* `right_sv`: Right singular vectors (only if `ritzvec = true`).
+* `nconv`: Number of converged singular values.
+* `niter`: Number of iterations.
+* `nmult`: Number of matrix--vector products used.
+* `resid`: Final residual vector.
+
+**Example**
+
+```julia
+X = sprand(10, 5, 0.2)
+svds(X, nsv = 2)
+```
+
+**Implementation note**
 
-function svds{S}(X::S; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxiter::Int = 1000)
+`svds(A)` is formally equivalent to calling `eigs` to perform implicitly restarted
+Lanczos tridiagonalization on the Hermitian matrix
+``\\begin{pmatrix} 0 & A^\\prime \\\\ A & 0 \\end{pmatrix}``, whose eigenvalues are
+plus and minus the singular values of ``A``.
+"""
+svds(A; kwargs...) = _svds(A; kwargs...)
+function _svds(X; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxiter::Int = 1000)
     if nsv < 1
         throw(ArgumentError("number of singular values (nsv) must be ≥ 1, got $nsv"))
     end
@@ -162,7 +357,7 @@ function svds{S}(X::S; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, m
         throw(ArgumentError("number of singular values (nsv) must be ≤ $(minimum(size(X))), got $nsv"))
     end
     otype = eltype(X)
-    ex    = eigs(SVDOperator{otype,S}(X), I; ritzvec = ritzvec, nev = 2*nsv, tol = tol, maxiter = maxiter)
+    ex    = eigs(SVDOperator(X), I; ritzvec = ritzvec, nev = 2*nsv, tol = tol, maxiter = maxiter)
     ind   = [1:2:nsv*2;]
     sval  = abs(ex[1][ind])
 
diff --git a/base/linalg/arpack.jl b/base/linalg/arpack.jl
index 9b31ab38ecb9a..9a2f56f3fcf8c 100644
--- a/base/linalg/arpack.jl
+++ b/base/linalg/arpack.jl
@@ -49,6 +49,9 @@ function aupd_wrapper(T, matvecA::Function, matvecB::Function, solveSI::Function
             naupd(ido, bmat, n, which, nev, TOL, resid, ncv, v, n,
                   iparam, ipntr, workd, workl, lworkl, info)
         end
+        if info[1] != 0
+            throw(ARPACKException(info[1]))
+        end
 
         load_idx = ipntr[1]+zernm1
         store_idx = ipntr[2]+zernm1
@@ -59,7 +62,7 @@ function aupd_wrapper(T, matvecA::Function, matvecB::Function, solveSI::Function
             elseif ido[1] == 99
                 break
             else
-                error("Internal ARPACK error")
+                throw(ARPACKException("unexpected behavior"))
             end
         elseif mode == 3 && bmat == "I" # corresponds to dsdrv2, dndrv2 or zndrv2
             if ido[1] == -1 || ido[1] == 1
@@ -67,7 +70,7 @@ function aupd_wrapper(T, matvecA::Function, matvecB::Function, solveSI::Function
             elseif ido[1] == 99
                 break
             else
-                error("Internal ARPACK error")
+                throw(ARPACKException("unexpected behavior"))
             end
         elseif mode == 2 # corresponds to dsdrv3, dndrv3 or zndrv3
             if ido[1] == -1 || ido[1] == 1
@@ -81,7 +84,7 @@ function aupd_wrapper(T, matvecA::Function, matvecB::Function, solveSI::Function
             elseif ido[1] == 99
                 break
             else
-                error("Internal ARPACK error")
+                throw(ARPACKException("unexpected behavior"))
             end
         elseif mode == 3 && bmat == "G" # corresponds to dsdrv4, dndrv4 or zndrv4
             if ido[1] == -1
@@ -93,7 +96,7 @@ function aupd_wrapper(T, matvecA::Function, matvecB::Function, solveSI::Function
             elseif ido[1] == 99
                 break
             else
-                error("Internal ARPACK error")
+                throw(ARPACKException("unexpected behavior"))
             end
         else
             throw(ArgumentError("ARPACK mode ($mode) not yet supported"))
@@ -133,7 +136,9 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::ByteString,
         neupd(ritzvec, howmny, select, d, v, ldv, sigmar, workev,
               bmat, n, which, nev, TOL, resid, ncv, v, ldv,
               iparam, ipntr, workd, workl, lworkl, rwork, info)
-        if info[1] != 0; throw(ARPACKException(info[1])); end
+        if info[1] != 0
+            throw(ARPACKException(info[1]))
+        end
 
         p = sortperm(dmap(d[1:nev]), rev=true)
         return ritzvec ? (d[p], v[1:n, p],iparam[5],iparam[3],iparam[9],resid) : (d[p],iparam[5],iparam[3],iparam[9],resid)
@@ -145,7 +150,9 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::ByteString,
         seupd(ritzvec, howmny, select, d, v, ldv, sigmar,
               bmat, n, which, nev, TOL, resid, ncv, v, ldv,
               iparam, ipntr, workd, workl, lworkl, info)
-        if info[1] != 0; throw(ARPACKException(info[1])); end
+        if info[1] != 0
+            throw(ARPACKException(info[1]))
+        end
 
         p = sortperm(dmap(d), rev=true)
         return ritzvec ? (d[p], v[1:n, p],iparam[5],iparam[3],iparam[9],resid) : (d,iparam[5],iparam[3],iparam[9],resid)
@@ -162,7 +169,9 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::ByteString,
         neupd(ritzvec, howmny, select, dr, di, v, ldv, sigmar, sigmai,
               workev, bmat, n, which, nev, TOL, resid, ncv, v, ldv,
               iparam, ipntr, workd, workl, lworkl, info)
-        if info[1] != 0; throw(ARPACKException(info[1])); end
+        if info[1] != 0
+            throw(ARPACKException(info[1]))
+        end
         evec = complex(Array(T, n, nev+1), Array(T, n, nev+1))
 
         j = 1
@@ -181,7 +190,7 @@ function eupd_wrapper(T, n::Integer, sym::Bool, cmplx::Bool, bmat::ByteString,
                 evec[:,j] = v[:,j]
                 j += 1
             else
-                error("ARPACK unexpected behavior")
+                throw(ARPACKException("unexpected behavior"))
             end
         end
 
diff --git a/base/linalg/bidiag.jl b/base/linalg/bidiag.jl
index dcf846d11f28d..98117ee41b735 100644
--- a/base/linalg/bidiag.jl
+++ b/base/linalg/bidiag.jl
@@ -5,15 +5,15 @@ type Bidiagonal{T} <: AbstractMatrix{T}
     dv::Vector{T} # diagonal
     ev::Vector{T} # sub/super diagonal
     isupper::Bool # is upper bidiagonal (true) or lower (false)
-    function Bidiagonal{T}(dv::Vector{T}, ev::Vector{T}, isupper::Bool)
+    function Bidiagonal(dv::Vector{T}, ev::Vector{T}, isupper::Bool)
         if length(ev) != length(dv)-1
             throw(DimensionMismatch("length of diagonal vector is $(length(dv)), length of off-diagonal vector is $(length(ev))"))
         end
         new(dv, ev, isupper)
     end
 end
-Bidiagonal{T}(dv::AbstractVector{T}, ev::AbstractVector{T}, isupper::Bool) = Bidiagonal{T}(dv, ev, isupper)
-Bidiagonal{T}(dv::AbstractVector{T}, ev::AbstractVector{T}) = throw(ArgumentError("did you want an upper or lower Bidiagonal? Try again with an additional true (upper) or false (lower) argument."))
+Bidiagonal{T}(dv::AbstractVector{T}, ev::AbstractVector{T}, isupper::Bool) = Bidiagonal{T}(collect(dv), collect(ev), isupper)
+Bidiagonal(dv::AbstractVector, ev::AbstractVector) = throw(ArgumentError("did you want an upper or lower Bidiagonal? Try again with an additional true (upper) or false (lower) argument."))
 
 #Convert from BLAS uplo flag to boolean internal
 Bidiagonal(dv::AbstractVector, ev::AbstractVector, uplo::Char) = begin
@@ -24,7 +24,7 @@ Bidiagonal(dv::AbstractVector, ev::AbstractVector, uplo::Char) = begin
     else
         throw(ArgumentError("Bidiagonal uplo argument must be upper 'U' or lower 'L', got $(repr(uplo))"))
     end
-    Bidiagonal(copy(dv), copy(ev), isupper)
+    Bidiagonal(collect(dv), collect(ev), isupper)
 end
 function Bidiagonal{Td,Te}(dv::AbstractVector{Td}, ev::AbstractVector{Te}, isupper::Bool)
     T = promote_type(Td,Te)
@@ -37,7 +37,32 @@ function getindex{T}(A::Bidiagonal{T}, i::Integer, j::Integer)
     if !((1 <= i <= size(A,2)) && (1 <= j <= size(A,2)))
         throw(BoundsError(A,(i,j)))
     end
-    i == j ? A.dv[i] : (A.isupper && (i == j-1)) || (!A.isupper && (i == j+1)) ? A.ev[min(i,j)] : zero(T)
+    if i == j
+        return A.dv[i]
+    elseif (istriu(A) && (i == j - 1)) || (istril(A) && (i == j + 1))
+        return A.ev[min(i,j)]
+    else
+        return zero(T)
+    end
+end
+
+function setindex!(A::Bidiagonal, x, i::Integer, j::Integer)
+    if i == j
+        A.dv[i] = x
+    elseif (istriu(A) && (i == j - 1)) || (istril(A) && (i == j + 1))
+        return A.ev[min(i,j)] = x
+    else
+        throw(ArgumentError("cannot set elements outside main and $(istriu(A) ? "super": "sub") diagonals."))
+    end
+end
+
+## structured matrix methods ##
+function Base.replace_in_print_matrix(A::Bidiagonal,i::Integer,j::Integer,s::AbstractString)
+    if A.isupper
+        i==j || i==j-1 ? s : Base.replace_with_centered_mark(s)
+    else
+        i==j || i==j+1 ? s : Base.replace_with_centered_mark(s)
+    end
 end
 
 #Converting from Bidiagonal to dense Matrix
@@ -67,23 +92,28 @@ function convert{T}(::Type{Tridiagonal{T}}, A::Bidiagonal)
 end
 promote_rule{T,S}(::Type{Tridiagonal{T}}, ::Type{Bidiagonal{S}})=Tridiagonal{promote_type(T,S)}
 
+# No-op for trivial conversion Bidiagonal{T} -> Bidiagonal{T}
+convert{T}(::Type{Bidiagonal{T}}, A::Bidiagonal{T}) = A
+# Convert Bidiagonal{Told} to Bidiagonal{Tnew} by constructing a new instance with converted elements
+convert{Tnew,Told}(::Type{Bidiagonal{Tnew}}, A::Bidiagonal{Told}) = Bidiagonal(convert(Vector{Tnew}, A.dv), convert(Vector{Tnew}, A.ev), A.isupper)
+# When asked to convert Bidiagonal{Told} to AbstractMatrix{Tnew}, preserve structure by converting to Bidiagonal{Tnew} <: AbstractMatrix{Tnew}
+convert{Tnew,Told}(::Type{AbstractMatrix{Tnew}}, A::Bidiagonal{Told}) = convert(Bidiagonal{Tnew}, A)
+
 big(B::Bidiagonal) = Bidiagonal(big(B.dv), big(B.ev), B.isupper)
 
+similar{T}(B::Bidiagonal, ::Type{T}) = Bidiagonal{T}(similar(B.dv, T), similar(B.ev, T), B.isupper)
+
 ###################
 # LAPACK routines #
 ###################
 
 #Singular values
 svdvals!{T<:BlasReal}(M::Bidiagonal{T}) = LAPACK.bdsdc!(M.isupper ? 'U' : 'L', 'N', M.dv, M.ev)[1]
-function svd{T<:BlasReal}(M::Bidiagonal{T})
-    d, e, U, Vt, Q, iQ = LAPACK.bdsdc!(M.isupper ? 'U' : 'L', 'I', copy(M.dv), copy(M.ev))
-    return U, d, Vt'
-end
-function svdfact!(M::Bidiagonal, thin::Bool=true)
+function svdfact!{T<:BlasReal}(M::Bidiagonal{T}; thin::Bool=true)
     d, e, U, Vt, Q, iQ = LAPACK.bdsdc!(M.isupper ? 'U' : 'L', 'I', M.dv, M.ev)
     SVD(U, d, Vt)
 end
-svdfact(M::Bidiagonal, thin::Bool=true) = svdfact!(copy(M),thin)
+svdfact(M::Bidiagonal; thin::Bool=true) = svdfact!(copy(M),thin=thin)
 
 ####################
 # Generic routines #
@@ -194,7 +224,7 @@ end
 /(A::Bidiagonal, B::Number) = Bidiagonal(A.dv/B, A.ev/B, A.isupper)
 ==(A::Bidiagonal, B::Bidiagonal) = (A.dv==B.dv) && (A.ev==B.ev) && (A.isupper==B.isupper)
 
-SpecialMatrix = Union{Diagonal, Bidiagonal, SymTridiagonal, Tridiagonal, AbstractTriangular}
+SpecialMatrix = Union{Bidiagonal, SymTridiagonal, Tridiagonal, AbstractTriangular}
 *(A::SpecialMatrix, B::SpecialMatrix)=full(A)*full(B)
 
 #Generic multiplication
@@ -204,8 +234,8 @@ end
 
 #Linear solvers
 A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(A, b)
-At_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(transpose(A), b)
-Ac_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(ctranspose(A), b)
+At_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(transpose(A), b)
+Ac_ldiv_B!(A::Bidiagonal, b::AbstractVector) = A_ldiv_B!(ctranspose(A), b)
 function A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix)
     nA,mA = size(A)
     tmp = similar(B,size(B,1))
@@ -220,7 +250,6 @@ function A_ldiv_B!(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix)
     end
     B
 end
-
 for func in (:Ac_ldiv_B!, :At_ldiv_B!)
     @eval function ($func)(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix)
         nA,mA = size(A)
@@ -237,9 +266,6 @@ for func in (:Ac_ldiv_B!, :At_ldiv_B!)
         B
     end
 end
-Ac_ldiv_B(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix) = Ac_ldiv_B!(A,copy(B))
-At_ldiv_B(A::Union{Bidiagonal, AbstractTriangular}, B::AbstractMatrix) = At_ldiv_B!(A,copy(B))
-
 #Generic solver using naive substitution
 function naivesub!{T}(A::Bidiagonal{T}, b::AbstractVector, x::AbstractVector = b)
     N = size(A, 2)
@@ -262,9 +288,15 @@ function naivesub!{T}(A::Bidiagonal{T}, b::AbstractVector, x::AbstractVector = b
     x
 end
 
-function \{T,S}(A::Bidiagonal{T}, B::AbstractVecOrMat{S})
-    TS = typeof(zero(T)*zero(S) + zero(T)*zero(S))
-    TS == S ? A_ldiv_B!(A, copy(B)) : A_ldiv_B!(A, convert(AbstractArray{TS}, B))
+### Generic promotion methods and fallbacks
+for (f,g) in ((:\, :A_ldiv_B!), (:At_ldiv_B, :At_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!))
+    @eval begin
+        function ($f){TA<:Number,TB<:Number}(A::Bidiagonal{TA}, B::AbstractVecOrMat{TB})
+            TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
+            ($g)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
+        end
+        ($f)(A::Bidiagonal, B::AbstractVecOrMat) = ($g)(A, copy(B))
+    end
 end
 
 factorize(A::Bidiagonal) = A
diff --git a/base/linalg/bitarray.jl b/base/linalg/bitarray.jl
index eee50e259145b..992f55f03231d 100644
--- a/base/linalg/bitarray.jl
+++ b/base/linalg/bitarray.jl
@@ -134,8 +134,8 @@ end
 
 ## Structure query functions
 
-issym(A::BitMatrix) = size(A, 1)==size(A, 2) && countnz(A - A.')==0
-ishermitian(A::BitMatrix) = issym(A)
+issymmetric(A::BitMatrix) = size(A, 1)==size(A, 2) && countnz(A - A.')==0
+ishermitian(A::BitMatrix) = issymmetric(A)
 
 function nonzero_chunks(chunks::Vector{UInt64}, pos0::Int, pos1::Int)
     k0, l0 = Base.get_chunks_id(pos0)
diff --git a/base/linalg/blas.jl b/base/linalg/blas.jl
index f1f95019da610..f63a6fb7178f1 100644
--- a/base/linalg/blas.jl
+++ b/base/linalg/blas.jl
@@ -2,15 +2,13 @@
 
 module BLAS
 
-import ..axpy!
-import Base: copy!, blasfunc
+import Base: copy!, @blasfunc
+import Base.LinAlg: axpy!, dot
 
 export
 # Level 1
     asum,
-    axpy!,
     blascopy!,
-    dot,
     dotc,
     dotu,
     scal!,
@@ -57,11 +55,27 @@ export
 
 
 const libblas = Base.libblas_name
+const liblapack = Base.liblapack_name
 
-import ..LinAlg: BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, chksquare, axpy!
+import ..LinAlg: BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, checksquare, axpy!
+
+"""
+    blas_set_num_threads(n)
+
+Set the number of threads the BLAS library should use.
+"""
+blas_set_num_threads
 
 # Level 1
 ## copy
+
+"""
+    blascopy!(n, X, incx, Y, incy)
+
+Copy `n` elements of array `X` with stride `incx` to array `Y` with stride `incy`. Returns `Y`.
+"""
+function blascopy! end
+
 for (fname, elty) in ((:dcopy_,:Float64),
                       (:scopy_,:Float32),
                       (:zcopy_,:Complex128),
@@ -69,7 +83,7 @@ for (fname, elty) in ((:dcopy_,:Float64),
     @eval begin
         # SUBROUTINE DCOPY(N,DX,INCX,DY,INCY)
         function blascopy!(n::Integer, DX::Union{Ptr{$elty},StridedArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},StridedArray{$elty}}, incy::Integer)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &n, DX, &incx, DY, &incy)
             DY
@@ -78,6 +92,21 @@ for (fname, elty) in ((:dcopy_,:Float64),
 end
 
 ## scal
+
+"""
+    scal!(n, a, X, incx)
+
+Overwrite `X` with `a*X`. Returns `X`.
+"""
+function scal! end
+
+"""
+    scal(n, a, X, incx)
+
+Returns `a*X`.
+"""
+function scal end
+
 for (fname, elty) in ((:dscal_,:Float64),
                       (:sscal_,:Float32),
                       (:zscal_,:Complex128),
@@ -85,7 +114,7 @@ for (fname, elty) in ((:dscal_,:Float64),
     @eval begin
         # SUBROUTINE DSCAL(N,DA,DX,INCX)
         function scal!(n::Integer, DA::$elty, DX::Union{Ptr{$elty},DenseArray{$elty}}, incx::Integer)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                   (Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}),
                   &n, &DA, DX, &incx)
             DX
@@ -95,6 +124,29 @@ end
 scal(n, DA, DX, incx) = scal!(n, DA, copy(DX), incx)
 
 ## dot
+
+"""
+    dot(n, X, incx, Y, incy)
+
+Dot product of two vectors consisting of `n` elements of array `X` with stride `incx` and
+`n` elements of array `Y` with stride `incy`.
+"""
+function dot end
+
+"""
+    dotc(n, X, incx, U, incy)
+
+Dot function for two complex vectors conjugating the first vector.
+"""
+function dotc end
+
+"""
+    dotu(n, X, incx, Y, incy)
+
+Dot function for two complex vectors.
+"""
+function dotu end
+
 for (fname, elty) in ((:ddot_,:Float64),
                       (:sdot_,:Float32))
     @eval begin
@@ -105,7 +157,7 @@ for (fname, elty) in ((:ddot_,:Float64),
                 # *     .. Array Arguments ..
                 #       DOUBLE PRECISION DX(*),DY(*)
         function dot(n::Integer, DX::Union{Ptr{$elty},DenseArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},DenseArray{$elty}}, incy::Integer)
-            ccall(($(blasfunc(fname)), libblas), $elty,
+            ccall((@blasfunc($fname), libblas), $elty,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &n, DX, &incx, DY, &incy)
         end
@@ -122,7 +174,7 @@ for (fname, elty) in ((:cblas_zdotc_sub,:Complex128),
                 #       DOUBLE PRECISION DX(*),DY(*)
         function dotc(n::Integer, DX::Union{Ptr{$elty},DenseArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},DenseArray{$elty}}, incy::Integer)
             result = Array($elty, 1)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}),
                  n, DX, incx, DY, incy, result)
             result[1]
@@ -140,7 +192,7 @@ for (fname, elty) in ((:cblas_zdotu_sub,:Complex128),
                 #       DOUBLE PRECISION DX(*),DY(*)
         function dotu(n::Integer, DX::Union{Ptr{$elty},DenseArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},DenseArray{$elty}}, incy::Integer)
             result = Array($elty, 1)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}, BlasInt, Ptr{$elty}),
                  n, DX, incx, DY, incy, result)
             result[1]
@@ -170,6 +222,14 @@ function dotu{T<:BlasComplex}(DX::Union{DenseArray{T},StridedVector{T}}, DY::Uni
 end
 
 ## nrm2
+
+"""
+    nrm2(n, X, incx)
+
+2-norm of a vector consisting of `n` elements of array `X` with stride `incx`.
+"""
+function nrm2 end
+
 for (fname, elty, ret_type) in ((:dnrm2_,:Float64,:Float64),
                                 (:snrm2_,:Float32,:Float32),
                                 (:dznrm2_,:Complex128,:Float64),
@@ -177,7 +237,7 @@ for (fname, elty, ret_type) in ((:dnrm2_,:Float64,:Float64),
     @eval begin
         # SUBROUTINE DNRM2(N,X,INCX)
         function nrm2(n::Integer, X::Union{Ptr{$elty},DenseArray{$elty}}, incx::Integer)
-            ccall(($(blasfunc(fname)), libblas), $ret_type,
+            ccall((@blasfunc($fname), libblas), $ret_type,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &n, X, &incx)
         end
@@ -187,6 +247,14 @@ nrm2(x::StridedVector) = nrm2(length(x), pointer(x), stride(x,1))
 nrm2(x::Array) = nrm2(length(x), pointer(x), 1)
 
 ## asum
+
+"""
+    asum(n, X, incx)
+
+Sum of the absolute values of the first `n` elements of array `X` with stride `incx`.
+"""
+function asum end
+
 for (fname, elty, ret_type) in ((:dasum_,:Float64,:Float64),
                                 (:sasum_,:Float32,:Float32),
                                 (:dzasum_,:Complex128,:Float64),
@@ -194,7 +262,7 @@ for (fname, elty, ret_type) in ((:dasum_,:Float64,:Float64),
     @eval begin
         # SUBROUTINE ASUM(N, X, INCX)
         function asum(n::Integer, X::Union{Ptr{$elty},DenseArray{$elty}}, incx::Integer)
-            ccall(($(blasfunc(fname)), libblas), $ret_type,
+            ccall((@blasfunc($fname), libblas), $ret_type,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &n, X, &incx)
         end
@@ -204,6 +272,14 @@ asum(x::StridedVector) = asum(length(x), pointer(x), stride(x,1))
 asum(x::Array) = asum(length(x), pointer(x), 1)
 
 ## axpy
+
+"""
+    axpy!(a, X, Y)
+
+Overwrite `Y` with `a*X + Y`. Returns `Y`.
+"""
+function axpy! end
+
 for (fname, elty) in ((:daxpy_,:Float64),
                       (:saxpy_,:Float32),
                       (:zaxpy_,:Complex128),
@@ -217,7 +293,7 @@ for (fname, elty) in ((:daxpy_,:Float64),
                 #*     .. Array Arguments ..
                 #      DOUBLE PRECISION DX(*),DY(*)
         function axpy!(n::Integer, alpha::($elty), dx::Union{Ptr{$elty}, DenseArray{$elty}}, incx::Integer, dy::Union{Ptr{$elty}, DenseArray{$elty}}, incy::Integer)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &n, &alpha, dx, &incx, dy, &incy)
             dy
@@ -239,10 +315,10 @@ function axpy!{T<:BlasFloat,Ta<:Number,Ti<:Integer}(alpha::Ta, x::Array{T}, rx::
         throw(DimensionMismatch("ranges of differing lengths"))
     end
     if minimum(rx) < 1 || maximum(rx) > length(x)
-        throw(BoundsError("range out of bounds for x, of length $(length(x))"))
+        throw(ArgumentError("range out of bounds for x, of length $(length(x))"))
     end
     if minimum(ry) < 1 || maximum(ry) > length(y)
-        throw(BoundsError("range out of bounds for y, of length $(length(y))"))
+        throw(ArgumentError("range out of bounds for y, of length $(length(y))"))
     end
     axpy!(length(rx), convert(T, alpha), pointer(x)+(first(rx)-1)*sizeof(T), step(rx), pointer(y)+(first(ry)-1)*sizeof(T), step(ry))
     y
@@ -255,7 +331,7 @@ for (fname, elty) in ((:idamax_,:Float64),
                       (:icamax_,:Complex64))
     @eval begin
         function iamax(n::Integer, dx::Union{Ptr{$elty}, DenseArray{$elty}}, incx::Integer)
-            ccall(($(blasfunc(fname)), libblas),BlasInt,
+            ccall((@blasfunc($fname), libblas),BlasInt,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                 &n, dx, &incx)
         end
@@ -288,7 +364,7 @@ for (fname, elty) in ((:dgemv_,:Float64),
             elseif trans == 'T' && (length(X) != m || length(Y) != n)
                 throw(DimensionMismatch("A.' has dimensions $n, $m, X has length $(length(X)) and Y has length $(length(Y))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}),
@@ -306,7 +382,48 @@ for (fname, elty) in ((:dgemv_,:Float64),
     end
 end
 
+"""
+    gemv!(tA, alpha, A, x, beta, y)
+
+Update the vector `y` as `alpha*A*x + beta*y` or `alpha*A'x + beta*y` according to `tA`
+(transpose `A`). Returns the updated `y`.
+"""
+gemv!
+
+"""
+    gemv(tA, alpha, A, x)
+
+Returns `alpha*A*x` or `alpha*A'x` according to `tA` (transpose `A`).
+"""
+gemv(tA, alpha, A, x)
+
+"""
+    gemv(tA, A, x)
+
+Returns `A*x` or `A'x` according to `tA` (transpose `A`).
+"""
+gemv(tA, A, x)
+
 ### (GB) general banded matrix-vector multiplication
+
+"""
+    gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)
+
+Update vector `y` as `alpha*A*x + beta*y` or `alpha*A'*x + beta*y` according to `trans` ('N'
+or 'T'). The matrix `A` is a general band matrix of dimension `m` by `size(A,2)` with `kl`
+sub-diagonals and `ku` super-diagonals. Returns the updated `y`.
+"""
+function gbmv! end
+
+"""
+    gbmv(trans, m, kl, ku, alpha, A, x, beta, y)
+
+Returns `alpha*A*x` or `alpha*A'*x` according to `trans` ('N' or 'T'). The matrix `A` is a
+general band matrix of dimension `m` by `size(A,2)` with `kl` sub-diagonals and `ku`
+super-diagonals.
+"""
+function gbmv end
+
 for (fname, elty) in ((:dgbmv_,:Float64),
                       (:sgbmv_,:Float32),
                       (:zgbmv_,:Complex128),
@@ -320,7 +437,7 @@ for (fname, elty) in ((:dgbmv_,:Float64),
              # *     .. Array Arguments ..
              #       DOUBLE PRECISION A(LDA,*),X(*),Y(*)
         function gbmv!(trans::Char, m::Integer, kl::Integer, ku::Integer, alpha::($elty), A::StridedMatrix{$elty}, x::StridedVector{$elty}, beta::($elty), y::StridedVector{$elty})
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -342,10 +459,19 @@ for (fname, elty) in ((:dgbmv_,:Float64),
 end
 
 ### symv
-for (fname, elty) in ((:dsymv_,:Float64),
-                      (:ssymv_,:Float32),
-                      (:zsymv_,:Complex128),
-                      (:csymv_,:Complex64))
+
+"""
+    symv!(ul, alpha, A, x, beta, y)
+
+Update the vector `y` as `alpha*A*x + beta*y`. `A` is assumed to be symmetric. Only the `ul`
+triangle of `A` is used. Returns the updated `y`.
+"""
+function symv! end
+
+for (fname, elty, lib) in ((:dsymv_,:Float64,libblas),
+                           (:ssymv_,:Float32,libblas),
+                           (:zsymv_,:Complex128,liblapack),
+                           (:csymv_,:Complex64,liblapack))
     # Note that the complex symv are not BLAS but auiliary functions in LAPACK
     @eval begin
              #      SUBROUTINE DSYMV(UPLO,N,ALPHA,A,LDA,X,INCX,BETA,Y,INCY)
@@ -366,7 +492,7 @@ for (fname, elty) in ((:dsymv_,:Float64),
             if m != length(y)
                 throw(DimensionMismatch("A has size $(size(A)), and y has length $(length(y))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), $lib), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{$elty}, Ptr{BlasInt}),
@@ -384,6 +510,20 @@ for (fname, elty) in ((:dsymv_,:Float64),
     end
 end
 
+"""
+    symv(ul, alpha, A, x)
+
+Returns `alpha*A*x`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used.
+"""
+symv(ul, alpha, A, x)
+
+"""
+    symv(ul, A, x)
+
+Returns `A*x`. `A` is assumed to be symmetric. Only the `ul` triangle of `A` is used.
+"""
+symv(ul, A, x)
+
 ### hemv
 for (fname, elty) in ((:zhemv_,:Complex128),
                       (:chemv_,:Complex64))
@@ -402,7 +542,7 @@ for (fname, elty) in ((:zhemv_,:Complex128),
             lda = max(1, stride(A, 2))
             incx = stride(x, 1)
             incy = stride(y, 1)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{$elty}, Ptr{BlasInt}),
@@ -432,7 +572,7 @@ for (fname, elty) in ((:dsbmv_,:Float64),
              # *     .. Array Arguments ..
              #       DOUBLE PRECISION A(LDA,*),X(*),Y(*)
         function sbmv!(uplo::Char, k::Integer, alpha::($elty), A::StridedMatrix{$elty}, x::StridedVector{$elty}, beta::($elty), y::StridedVector{$elty})
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}),
@@ -451,6 +591,34 @@ for (fname, elty) in ((:dsbmv_,:Float64),
     end
 end
 
+"""
+    sbmv(uplo, k, alpha, A, x)
+
+Returns `alpha*A*x` where `A` is a symmetric band matrix of order `size(A,2)` with `k`
+super-diagonals stored in the argument `A`.
+"""
+sbmv(uplo, k, alpha, A, x)
+
+"""
+    sbmv(uplo, k, A, x)
+
+Returns `A*x` where `A` is a symmetric band matrix of order `size(A,2)` with `k`
+super-diagonals stored in the argument `A`.
+"""
+sbmv(uplo, k, A, x)
+
+"""
+    sbmv!(uplo, k, alpha, A, x, beta, y)
+
+Update vector `y` as `alpha*A*x + beta*y` where `A` is a a symmetric band matrix of order
+`size(A,2)` with `k` super-diagonals stored in the argument `A`. The storage layout for `A`
+is described the reference BLAS module, level-2 BLAS at
+<http://www.netlib.org/lapack/explore-html/>.
+
+Returns the updated `y`.
+"""
+sbmv!
+
 ### hbmv, (HB) Hermitian banded matrix-vector multiplication
 for (fname, elty) in ((:zhbmv_,:Complex128),
                       (:chbmv_,:Complex64))
@@ -463,7 +631,7 @@ for (fname, elty) in ((:zhbmv_,:Complex128),
              # *     .. Array Arguments ..
              #       DOUBLE PRECISION A(LDA,*),X(*),Y(*)
         function hbmv!(uplo::Char, k::Integer, alpha::($elty), A::StridedMatrix{$elty}, x::StridedVector{$elty}, beta::($elty), y::StridedVector{$elty})
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}),
@@ -483,6 +651,26 @@ for (fname, elty) in ((:zhbmv_,:Complex128),
 end
 
 ### trmv, Triangular matrix-vector multiplication
+
+"""
+    trmv(side, ul, tA, dA, alpha, A, b)
+
+Returns `alpha*A*b` or one of the other three variants determined by `side` (`A` on left or
+right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if
+`A` is unit-triangular (the diagonal is assumed to be all ones).
+"""
+function trmv end
+
+"""
+    trmv!(side, ul, tA, dA, alpha, A, b)
+
+Update `b` as `alpha*A*b` or one of the other three variants determined by `side` (`A` on
+left or right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA`
+indicates if `A` is unit-triangular (the diagonal is assumed to be all ones). Returns the
+updated `b`.
+"""
+function trmv! end
+
 for (fname, elty) in ((:dtrmv_,:Float64),
                         (:strmv_,:Float32),
                         (:ztrmv_,:Complex128),
@@ -495,11 +683,11 @@ for (fname, elty) in ((:dtrmv_,:Float64),
                 # *     .. Array Arguments ..
                 #       DOUBLE PRECISION A(LDA,*),X(*)
         function trmv!(uplo::Char, trans::Char, diag::Char, A::StridedMatrix{$elty}, x::StridedVector{$elty})
-            n = chksquare(A)
+            n = checksquare(A)
             if n != length(x)
                 throw(DimensionMismatch("A has size ($n,$n), x has length $(length(x))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &uplo, &trans, &diag, &n,
@@ -511,7 +699,27 @@ for (fname, elty) in ((:dtrmv_,:Float64),
         end
     end
 end
+
 ### trsv, Triangular matrix-vector solve
+
+"""
+    trsv!(ul, tA, dA, A, b)
+
+Overwrite `b` with the solution to `A*x = b` or one of the other two variants determined by
+`tA` (transpose `A`) and `ul` (triangle of `A` used). `dA` indicates if `A` is
+unit-triangular (the diagonal is assumed to be all ones). Returns the updated `b`.
+"""
+function trsv! end
+
+"""
+    trsv(ul, tA, dA, A, b)
+
+Returns the solution to `A*x = b` or one of the other two variants determined by `tA`
+(transpose `A`) and `ul` (triangle of `A` is used.) `dA` indicates if `A` is unit-triangular
+(the diagonal is assumed to be all ones).
+"""
+function trsv end
+
 for (fname, elty) in ((:dtrsv_,:Float64),
                         (:strsv_,:Float32),
                         (:ztrsv_,:Complex128),
@@ -524,11 +732,11 @@ for (fname, elty) in ((:dtrsv_,:Float64),
                 #       .. Array Arguments ..
                 #       DOUBLE PRECISION A(LDA,*),X(*)
         function trsv!(uplo::Char, trans::Char, diag::Char, A::StridedMatrix{$elty}, x::StridedVector{$elty})
-            n = chksquare(A)
+            n = checksquare(A)
             if n != length(x)
                 throw(DimensionMismatch("size of A is $n != length(x) = $(length(x))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &uplo, &trans, &diag, &n,
@@ -542,6 +750,14 @@ for (fname, elty) in ((:dtrsv_,:Float64),
 end
 
 ### ger
+
+"""
+    ger!(alpha, x, y, A)
+
+Rank-1 update of the matrix `A` with vectors `x` and `y` as `alpha*x*y' + A`.
+"""
+function ger! end
+
 for (fname, elty) in ((:dger_,:Float64),
                       (:sger_,:Float32),
                       (:zgerc_,:Complex128),
@@ -552,7 +768,7 @@ for (fname, elty) in ((:dger_,:Float64),
             if m != length(x) || n != length(y)
                 throw(DimensionMismatch("A has size ($m,$n), x has length $(length(x)), y has length $(length(y))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{BlasInt}),
@@ -565,17 +781,26 @@ for (fname, elty) in ((:dger_,:Float64),
 end
 
 ### syr
-for (fname, elty) in ((:dsyr_,:Float64),
-                      (:ssyr_,:Float32),
-                      (:zsyr_,:Complex128),
-                      (:csyr_,:Complex64))
+
+"""
+    syr!(uplo, alpha, x, A)
+
+Rank-1 update of the symmetric matrix `A` with vector `x` as `alpha*x*x.' + A`. When `uplo`
+is 'U' the upper triangle of `A` is updated ('L' for lower triangle). Returns `A`.
+"""
+function syr! end
+
+for (fname, elty, lib) in ((:dsyr_,:Float64,libblas),
+                           (:ssyr_,:Float32,libblas),
+                           (:zsyr_,:Complex128,liblapack),
+                           (:csyr_,:Complex64,liblapack))
     @eval begin
         function syr!(uplo::Char, α::$elty, x::StridedVector{$elty}, A::StridedMatrix{$elty})
-            n = chksquare(A)
+            n = checksquare(A)
             if length(x) != n
                 throw(DimensionMismatch("A has size ($n,$n), x has length $(length(x))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), $lib), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &uplo, &n, &α, x,
@@ -586,15 +811,25 @@ for (fname, elty) in ((:dsyr_,:Float64),
 end
 
 ### her
+
+"""
+    her!(uplo, alpha, x, A)
+
+Methods for complex arrays only. Rank-1 update of the Hermitian matrix `A` with vector `x`
+as `alpha*x*x' + A`. When `uplo` is 'U' the upper triangle of `A` is updated ('L' for lower
+triangle). Returns `A`.
+"""
+function her! end
+
 for (fname, elty, relty) in ((:zher_,:Complex128, :Float64),
                              (:cher_,:Complex64, :Float32))
     @eval begin
         function her!(uplo::Char, α::$relty, x::StridedVector{$elty}, A::StridedMatrix{$elty})
-            n = chksquare(A)
+            n = checksquare(A)
             if length(x) != n
                 throw(DimensionMismatch("A has size ($n,$n), x has length $(length(x))"))
             end
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                  &uplo, &n, &α, x,
@@ -606,6 +841,15 @@ end
 
 # Level 3
 ## (GE) general matrix-matrix multiplication
+
+"""
+    gemm!(tA, tB, alpha, A, B, beta, C)
+
+Update `C` as `alpha*A*B + beta*C` or the other three variants according to `tA` (transpose
+`A`) and `tB`. Returns the updated `C`.
+"""
+function gemm! end
+
 for (gemm, elty) in
         ((:dgemm_,:Float64),
          (:sgemm_,:Float32),
@@ -629,7 +873,7 @@ for (gemm, elty) in
             if m != size(C,1) || n != size(C,2)
                 throw(DimensionMismatch("A has size ($m,$k), B has size ($k,$n), C has size $(size(C))"))
             end
-            ccall(($(blasfunc(gemm)), libblas), Void,
+            ccall((@blasfunc($gemm), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -649,6 +893,21 @@ for (gemm, elty) in
     end
 end
 
+"""
+    gemm(tA, tB, alpha, A, B)
+
+Returns `alpha*A*B` or the other three variants according to `tA` (transpose `A`) and `tB`.
+"""
+gemm(tA, tB, alpha, A, B)
+
+"""
+    gemm(tA, tB, A, B)
+
+Returns `A*B` or the other three variants according to `tA` (transpose `A`) and `tB`.
+"""
+gemm(tA, tB, A, B)
+
+
 ## (SY) symmetric matrix-matrix and matrix-vector multiplication
 for (mfname, elty) in ((:dsymm_,:Float64),
                        (:ssymm_,:Float32),
@@ -664,14 +923,14 @@ for (mfname, elty) in ((:dsymm_,:Float64),
              #     DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
         function symm!(side::Char, uplo::Char, alpha::($elty), A::StridedMatrix{$elty}, B::StridedMatrix{$elty}, beta::($elty), C::StridedMatrix{$elty})
             m, n = size(C)
-            j = chksquare(A)
+            j = checksquare(A)
             if j != (side == 'L' ? m : n)
                 throw(DimensionMismatch("A has size $(size(A)), C has size ($m,$n)"))
             end
             if size(B,2) != n
                 throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs to match second dimension of C, $n"))
             end
-            ccall(($(blasfunc(mfname)), libblas), Void,
+            ccall((@blasfunc($mfname), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}),
@@ -689,6 +948,37 @@ for (mfname, elty) in ((:dsymm_,:Float64),
     end
 end
 
+"""
+    symm(side, ul, alpha, A, B)
+
+Returns `alpha*A*B` or `alpha*B*A` according to `side`. `A` is assumed to be symmetric. Only
+the `ul` triangle of `A` is used.
+"""
+symm(side, ul, alpha, A, B)
+
+"""
+    symm(side, ul, A, B)
+
+Returns `A*B` or `B*A` according to `side`. `A` is assumed to be symmetric. Only the `ul`
+triangle of `A` is used.
+"""
+symm(side, ul, A, B)
+
+"""
+    symm(tA, tB, alpha, A, B)
+
+Returns `alpha*A*B` or the other three variants according to `tA` (transpose `A`) and `tB`.
+"""
+symm(tA::Char, tB::Char, alpha, A, B)
+
+"""
+    symm!(side, ul, alpha, A, B, beta, C)
+
+Update `C` as `alpha*A*B + beta*C` or `alpha*B*A + beta*C` according to `side`. `A` is
+assumed to be symmetric. Only the `ul` triangle of `A` is used. Returns the updated `C`.
+"""
+symm!
+
 ## (HE) Hermitian matrix-matrix and matrix-vector multiplication
 for (mfname, elty) in ((:zhemm_,:Complex128),
                        (:chemm_,:Complex64))
@@ -702,14 +992,14 @@ for (mfname, elty) in ((:zhemm_,:Complex128),
              #     DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
         function hemm!(side::Char, uplo::Char, alpha::($elty), A::StridedMatrix{$elty}, B::StridedMatrix{$elty}, beta::($elty), C::StridedMatrix{$elty})
             m, n = size(C)
-            j = chksquare(A)
+            j = checksquare(A)
             if j != (side == 'L' ? m : n)
                 throw(DimensionMismatch("A has size $(size(A)), C has size ($m,$n)"))
             end
             if size(B,2) != n
                 throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs to match second dimension of C, $n"))
             end
-            ccall(($(blasfunc(mfname)), libblas), Void,
+            ccall((@blasfunc($mfname), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}),
@@ -728,6 +1018,24 @@ for (mfname, elty) in ((:zhemm_,:Complex128),
 end
 
 ## syrk
+
+"""
+    syrk!(uplo, trans, alpha, A, beta, C)
+
+Rank-k update of the symmetric matrix `C` as `alpha*A*A.' + beta*C` or `alpha*A.'*A +
+beta*C` according to whether `trans` is 'N' or 'T'. When `uplo` is 'U' the upper triangle of
+`C` is updated ('L' for lower triangle). Returns `C`.
+"""
+function syrk! end
+
+"""
+    syrk(uplo, trans, alpha, A)
+
+Returns either the upper triangle or the lower triangle, according to `uplo` ('U' or 'L'),
+of `alpha*A*A.'` or `alpha*A.'*A`, according to `trans` ('N' or 'T').
+"""
+function syrk end
+
 for (fname, elty) in ((:dsyrk_,:Float64),
                       (:ssyrk_,:Float32),
                       (:zsyrk_,:Complex128),
@@ -743,11 +1051,11 @@ for (fname, elty) in ((:dsyrk_,:Float64),
        function syrk!(uplo::Char, trans::Char,
                       alpha::($elty), A::StridedVecOrMat{$elty},
                       beta::($elty), C::StridedMatrix{$elty})
-           n = chksquare(C)
+           n = checksquare(C)
            nn = size(A, trans == 'N' ? 1 : 2)
            if nn != n throw(DimensionMismatch("C has size ($n,$n), corresponding dimension of A is $nn")) end
            k  = size(A, trans == 'N' ? 2 : 1)
-           ccall(($(blasfunc(fname)), libblas), Void,
+           ccall((@blasfunc($fname), libblas), Void,
                  (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                   Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                   Ptr{$elty}, Ptr{BlasInt}),
@@ -765,6 +1073,24 @@ function syrk(uplo::Char, trans::Char, alpha::Number, A::StridedVecOrMat)
 end
 syrk(uplo::Char, trans::Char, A::StridedVecOrMat) = syrk(uplo, trans, one(eltype(A)), A)
 
+"""
+    herk!(uplo, trans, alpha, A, beta, C)
+
+Methods for complex arrays only. Rank-k update of the Hermitian matrix `C` as `alpha*A*A' +
+beta*C` or `alpha*A'*A + beta*C` according to whether `trans` is 'N' or 'T'. When `uplo` is
+'U' the upper triangle of `C` is updated ('L' for lower triangle). Returns `C`.
+"""
+function herk! end
+
+"""
+    herk(uplo, trans, alpha, A)
+
+Methods for complex arrays only. Returns either the upper triangle or the lower triangle,
+according to `uplo` ('U' or 'L'), of `alpha*A*A'` or `alpha*A'*A`, according to `trans` ('N'
+or 'T').
+"""
+function herk end
+
 for (fname, elty, relty) in ((:zherk_, :Complex128, :Float64),
                              (:cherk_, :Complex64, :Float32))
    @eval begin
@@ -778,13 +1104,13 @@ for (fname, elty, relty) in ((:zherk_, :Complex128, :Float64),
        #       COMPLEX A(LDA,*),C(LDC,*)
        function herk!(uplo::Char, trans::Char, α::$relty, A::StridedVecOrMat{$elty},
                       β::$relty, C::StridedMatrix{$elty})
-           n = chksquare(C)
+           n = checksquare(C)
            nn = size(A, trans == 'N' ? 1 : 2)
            if nn != n
                throw(DimensionMismatch("the matrix to update has dimension $n but the implied dimension of the update is $(size(A, trans == 'N' ? 1 : 2))"))
            end
            k  = size(A, trans == 'N' ? 2 : 1)
-           ccall(($(blasfunc(fname)), libblas), Void,
+           ccall((@blasfunc($fname), libblas), Void,
                  (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                   Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty},
                   Ptr{$elty}, Ptr{BlasInt}),
@@ -819,11 +1145,11 @@ for (fname, elty) in ((:dsyr2k_,:Float64),
         function syr2k!(uplo::Char, trans::Char,
                         alpha::($elty), A::StridedVecOrMat{$elty}, B::StridedVecOrMat{$elty},
                         beta::($elty), C::StridedMatrix{$elty})
-            n = chksquare(C)
+            n = checksquare(C)
             nn = size(A, trans == 'N' ? 1 : 2)
             if nn != n throw(DimensionMismatch("C has size ($n,$n), corresponding dimension of A is $nn")) end
             k  = size(A, trans == 'N' ? 2 : 1)
-            ccall(($(blasfunc(fname)), libblas), Void,
+            ccall((@blasfunc($fname), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                  Ptr{$elty}, Ptr{BlasInt}),
@@ -856,11 +1182,11 @@ for (fname, elty1, elty2) in ((:zher2k_,:Complex128,:Float64), (:cher2k_,:Comple
        function her2k!(uplo::Char, trans::Char, alpha::($elty1),
                        A::StridedVecOrMat{$elty1}, B::StridedVecOrMat{$elty1},
                        beta::($elty2), C::StridedMatrix{$elty1})
-           n = chksquare(C)
+           n = checksquare(C)
            nn = size(A, trans == 'N' ? 1 : 2)
            if nn != n throw(DimensionMismatch("C has size ($n,$n), corresponding dimension of A is $nn")) end
            k  = size(A, trans == 'N' ? 2 : 1)
-           ccall(($(blasfunc(fname)), libblas), Void,
+           ccall((@blasfunc($fname), libblas), Void,
                  (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                   Ptr{$elty1}, Ptr{$elty1}, Ptr{BlasInt}, Ptr{$elty1}, Ptr{BlasInt},
                   Ptr{$elty2},  Ptr{$elty1}, Ptr{BlasInt}),
@@ -878,6 +1204,45 @@ for (fname, elty1, elty2) in ((:zher2k_,:Complex128,:Float64), (:cher2k_,:Comple
 end
 
 ## (TR) Triangular matrix and vector multiplication and solution
+
+"""
+    trmm!(side, ul, tA, dA, alpha, A, B)
+
+Update `B` as `alpha*A*B` or one of the other three variants determined by `side` (`A` on
+left or right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA`
+indicates if `A` is unit-triangular (the diagonal is assumed to be all ones). Returns the
+updated `B`.
+"""
+function trmm! end
+
+"""
+    trmm(side, ul, tA, dA, alpha, A, B)
+
+Returns `alpha*A*B` or one of the other three variants determined by `side` (`A` on left or
+right) and `tA` (transpose `A`). Only the `ul` triangle of `A` is used. `dA` indicates if
+`A` is unit-triangular (the diagonal is assumed to be all ones).
+"""
+function trmm end
+
+"""
+    trsm!(side, ul, tA, dA, alpha, A, B)
+
+Overwrite `B` with the solution to `A*X = alpha*B` or one of the other three variants
+determined by `side` (`A` on left or right of `X`) and `tA` (transpose `A`). Only the `ul`
+triangle of `A` is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed
+to be all ones). Returns the updated `B`.
+"""
+function trsm! end
+
+"""
+    trsm(side, ul, tA, dA, alpha, A, B)
+
+Returns the solution to `A*X = alpha*B` or one of the other three variants determined by
+`side` (`A` on left or right of `X`) and `tA` (transpose `A`). Only the `ul` triangle of `A`
+is used. `dA` indicates if `A` is unit-triangular (the diagonal is assumed to be all ones).
+"""
+function trsm end
+
 for (mmname, smname, elty) in
         ((:dtrmm_,:dtrsm_,:Float64),
          (:strmm_,:strsm_,:Float32),
@@ -894,11 +1259,11 @@ for (mmname, smname, elty) in
         function trmm!(side::Char, uplo::Char, transa::Char, diag::Char, alpha::Number,
                        A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
             m, n = size(B)
-            nA = chksquare(A)
+            nA = checksquare(A)
             if nA != (side == 'L' ? m : n)
                 throw(DimensionMismatch("size of A, $(size(A)), doesn't match $side size of B with dims, $(size(B))"))
             end
-            ccall(($(blasfunc(mmname)), libblas), Void,
+            ccall((@blasfunc($mmname), libblas), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &side, &uplo, &transa, &diag, &m, &n,
@@ -919,11 +1284,11 @@ for (mmname, smname, elty) in
         function trsm!(side::Char, uplo::Char, transa::Char, diag::Char,
                        alpha::$elty, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
             m, n = size(B)
-            k = chksquare(A)
+            k = checksquare(A)
             if k != (side == 'L' ? m : n)
-                throw(DimensionMismatch("size of A is $n, size(B)=($m,$n) and transa='$transa'"))
+                throw(DimensionMismatch("size of A is ($k,$k), size of B is ($m,$n), side is $side, and transa='$transa'"))
             end
-            ccall(($(blasfunc(smname)), libblas), Void,
+            ccall((@blasfunc($smname), libblas), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
                  Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
@@ -943,10 +1308,10 @@ end # module
 function copy!{T<:BlasFloat,Ti<:Integer}(dest::Array{T}, rdest::Union{UnitRange{Ti},Range{Ti}},
                                           src::Array{T}, rsrc::Union{UnitRange{Ti},Range{Ti}})
     if minimum(rdest) < 1 || maximum(rdest) > length(dest)
-        throw(BoundsError("range out of bounds for dest, of length $(length(dest))"))
+        throw(ArgumentError("range out of bounds for dest, of length $(length(dest))"))
     end
     if minimum(rsrc) < 1 || maximum(rsrc) > length(src)
-        throw(BoundsError("range out of bounds for src, of length $(length(src))"))
+        throw(ArgumentError("range out of bounds for src, of length $(length(src))"))
     end
     if length(rdest) != length(rsrc)
         throw(DimensionMismatch("ranges must be of the same length"))
diff --git a/base/linalg/bunchkaufman.jl b/base/linalg/bunchkaufman.jl
index 86468ff961b60..9f18af795604d 100644
--- a/base/linalg/bunchkaufman.jl
+++ b/base/linalg/bunchkaufman.jl
@@ -9,45 +9,99 @@ immutable BunchKaufman{T,S<:AbstractMatrix} <: Factorization{T}
     ipiv::Vector{BlasInt}
     uplo::Char
     symmetric::Bool
-    BunchKaufman(LD::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetric::Bool) = new(LD, ipiv, uplo, symmetric)
+    rook::Bool
+    BunchKaufman(LD::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetric::Bool, rook::Bool) = new(LD, ipiv, uplo, symmetric, rook)
 end
-BunchKaufman{T}(LD::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetric::Bool) = BunchKaufman{T,typeof(LD)}(LD, ipiv, uplo, symmetric)
+BunchKaufman{T}(LD::AbstractMatrix{T}, ipiv::Vector{BlasInt}, uplo::Char, symmetric::Bool, rook::Bool) = BunchKaufman{T,typeof(LD)}(LD, ipiv, uplo, symmetric, rook)
 
-function bkfact!{T<:BlasReal}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issym(A))
+function bkfact!{T<:BlasReal}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issymmetric(A), rook::Bool=false)
     if !symmetric
         throw(ArgumentError("Bunch-Kaufman decomposition is only valid for symmetric matrices"))
     end
-    LD, ipiv = LAPACK.sytrf!(char_uplo(uplo) , A)
-    BunchKaufman(LD, ipiv, char_uplo(uplo), symmetric)
+    LD, ipiv = rook ? LAPACK.sytrf_rook!(char_uplo(uplo) , A) : LAPACK.sytrf!(char_uplo(uplo) , A)
+    BunchKaufman(LD, ipiv, char_uplo(uplo), symmetric, rook)
 end
-function bkfact!{T<:BlasComplex}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issym(A))
-    LD, ipiv = (symmetric ? LAPACK.sytrf! : LAPACK.hetrf!)(char_uplo(uplo) , A)
-    BunchKaufman(LD, ipiv, char_uplo(uplo), symmetric)
+function bkfact!{T<:BlasComplex}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issymmetric(A), rook::Bool=false)
+    if rook
+        LD, ipiv = (symmetric ? LAPACK.sytrf_rook! : LAPACK.hetrf_rook!)(char_uplo(uplo) , A)
+    else
+        LD, ipiv = (symmetric ? LAPACK.sytrf! : LAPACK.hetrf!)(char_uplo(uplo) , A)
+    end
+    BunchKaufman(LD, ipiv, char_uplo(uplo), symmetric, rook)
 end
-bkfact{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issym(A)) = bkfact!(copy(A), uplo, symmetric)
-bkfact{T}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issym(A)) = bkfact!(convert(Matrix{promote_type(Float32,typeof(sqrt(one(T))))},A),uplo,symmetric)
+bkfact{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issymmetric(A), rook::Bool=false) = bkfact!(copy(A), uplo, symmetric, rook)
+bkfact{T}(A::StridedMatrix{T}, uplo::Symbol=:U, symmetric::Bool=issymmetric(A), rook::Bool=false) = bkfact!(convert(Matrix{promote_type(Float32,typeof(sqrt(one(T))))},A),uplo,symmetric,rook)
 
-convert{T}(::Type{BunchKaufman{T}},B::BunchKaufman) = BunchKaufman(convert(Matrix{T},B.LD),B.ipiv,B.uplo,B.symmetric)
+convert{T}(::Type{BunchKaufman{T}},B::BunchKaufman) = BunchKaufman(convert(Matrix{T},B.LD),B.ipiv,B.uplo,B.symmetric,B.rook)
 convert{T}(::Type{Factorization{T}}, B::BunchKaufman) = convert(BunchKaufman{T}, B)
 
 size(B::BunchKaufman) = size(B.LD)
 size(B::BunchKaufman,d::Integer) = size(B.LD,d)
-issym(B::BunchKaufman) = B.symmetric
+issymmetric(B::BunchKaufman) = B.symmetric
 ishermitian(B::BunchKaufman) = !B.symmetric
 
-inv{T<:BlasReal}(B::BunchKaufman{T}) = copytri!(LAPACK.sytri!(B.uplo, copy(B.LD), B.ipiv), B.uplo, true)
+function inv{T<:BlasReal}(B::BunchKaufman{T})
+    if B.rook
+        copytri!(LAPACK.sytri_rook!(B.uplo, copy(B.LD), B.ipiv), B.uplo, true)
+    else
+        copytri!(LAPACK.sytri!(B.uplo, copy(B.LD), B.ipiv), B.uplo, true)
+    end
+end
 
 function inv{T<:BlasComplex}(B::BunchKaufman{T})
-    if issym(B)
-        copytri!(LAPACK.sytri!(B.uplo, copy(B.LD), B.ipiv), B.uplo)
+    if issymmetric(B)
+        if B.rook
+            copytri!(LAPACK.sytri_rook!(B.uplo, copy(B.LD), B.ipiv), B.uplo)
+        else
+            copytri!(LAPACK.sytri!(B.uplo, copy(B.LD), B.ipiv), B.uplo)
+        end
     else
-        copytri!(LAPACK.hetri!(B.uplo, copy(B.LD), B.ipiv), B.uplo, true)
+        if B.rook
+            copytri!(LAPACK.hetri_rook!(B.uplo, copy(B.LD), B.ipiv), B.uplo, true)
+        else
+            copytri!(LAPACK.hetri!(B.uplo, copy(B.LD), B.ipiv), B.uplo, true)
+        end
     end
 end
 
-A_ldiv_B!{T<:BlasReal}(B::BunchKaufman{T}, R::StridedVecOrMat{T}) = LAPACK.sytrs!(B.uplo, B.LD, B.ipiv, R)
+function A_ldiv_B!{T<:BlasReal}(B::BunchKaufman{T}, R::StridedVecOrMat{T})
+    if B.rook
+        LAPACK.sytrs_rook!(B.uplo, B.LD, B.ipiv, R)
+    else
+        LAPACK.sytrs!(B.uplo, B.LD, B.ipiv, R)
+    end
+end
 function A_ldiv_B!{T<:BlasComplex}(B::BunchKaufman{T}, R::StridedVecOrMat{T})
-    (issym(B) ? LAPACK.sytrs! : LAPACK.hetrs!)(B.uplo, B.LD, B.ipiv, R)
+    if B.rook
+        (issymmetric(B) ? LAPACK.sytrs_rook! : LAPACK.hetrs_rook!)(B.uplo, B.LD, B.ipiv, R)
+    else
+        (issymmetric(B) ? LAPACK.sytrs! : LAPACK.hetrs!)(B.uplo, B.LD, B.ipiv, R)
+    end
+end
+
+function det(F::BunchKaufman)
+    M = F.LD
+    p = F.ipiv
+    n = size(F.LD, 1)
+
+    i = 1
+    d = one(eltype(F))
+    while i <= n
+        if p[i] > 0
+            # 1x1 pivot case
+            d *= M[i,i]
+            i += 1
+        else
+            # 2x2 pivot case. Make sure not to square before the subtraction by scaling with the off-diagonal element. This is safe because the off diagonal is always large for 2x2 pivots.
+            if F.uplo == 'U'
+                d *= M[i, i + 1]*(M[i,i]/M[i, i + 1]*M[i + 1, i + 1] - (issymmetric(F) ? M[i, i + 1] : conj(M[i, i + 1])))
+            else
+                d *= M[i + 1,i]*(M[i, i]/M[i + 1, i]*M[i + 1, i + 1] - (issymmetric(F) ? M[i + 1, i] : conj(M[i + 1, i])))
+            end
+            i += 2
+        end
+    end
+    return d
 end
 
 ## reconstruct the original matrix
diff --git a/base/linalg/cholesky.jl b/base/linalg/cholesky.jl
index fe8579add387a..d70d5a8d880a5 100644
--- a/base/linalg/cholesky.jl
+++ b/base/linalg/cholesky.jl
@@ -23,24 +23,24 @@ function CholeskyPivoted{T}(A::AbstractMatrix{T}, uplo::Char, piv::Vector{BlasIn
     CholeskyPivoted{T,typeof(A)}(A, uplo, piv, rank, tol, info)
 end
 
-function chol!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{:U}})
+function chol!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{UpperTriangular})
     C, info = LAPACK.potrf!('U', A)
     return @assertposdef UpperTriangular(C) info
 end
-function chol!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{:L}})
+function chol!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{LowerTriangular})
     C, info = LAPACK.potrf!('L', A)
     return @assertposdef LowerTriangular(C) info
 end
-chol!(A::StridedMatrix) = chol!(A, Val{:U})
+chol!(A::StridedMatrix) = chol!(A, UpperTriangular)
 
-function chol!{T}(A::AbstractMatrix{T}, ::Type{Val{:U}})
-    n = chksquare(A)
+function chol!{T}(A::AbstractMatrix{T}, ::Type{UpperTriangular})
+    n = checksquare(A)
     @inbounds begin
         for k = 1:n
             for i = 1:k - 1
                 A[k,k] -= A[i,k]'A[i,k]
             end
-            Akk = chol!(A[k,k], Val{:U})
+            Akk = chol!(A[k,k], UpperTriangular)
             A[k,k] = Akk
             AkkInv = inv(Akk')
             for j = k + 1:n
@@ -53,14 +53,14 @@ function chol!{T}(A::AbstractMatrix{T}, ::Type{Val{:U}})
     end
     return UpperTriangular(A)
 end
-function chol!{T}(A::AbstractMatrix{T}, ::Type{Val{:L}})
-    n = chksquare(A)
+function chol!{T}(A::AbstractMatrix{T}, ::Type{LowerTriangular})
+    n = checksquare(A)
     @inbounds begin
         for k = 1:n
             for i = 1:k - 1
                 A[k,k] -= A[k,i]*A[k,i]'
             end
-            Akk = chol!(A[k,k], Val{:L})
+            Akk = chol!(A[k,k], LowerTriangular)
             A[k,k] = Akk
             AkkInv = inv(Akk)
             for j = 1:k
@@ -78,14 +78,16 @@ function chol!{T}(A::AbstractMatrix{T}, ::Type{Val{:L}})
     return LowerTriangular(A)
 end
 
+"""
+    chol(A::AbstractMatrix) -> U
+
+Compute the Cholesky factorization of a positive definite matrix `A`
+and return the UpperTriangular matrix `U` such that `A = U'U`.
+"""
 function chol{T}(A::AbstractMatrix{T})
     S = promote_type(typeof(chol(one(T))), Float32)
     chol!(copy_oftype(A, S))
 end
-function chol{T}(A::AbstractMatrix{T}, uplo::Union{Type{Val{:L}}, Type{Val{:U}}})
-    S = promote_type(typeof(chol(one(T))), Float32)
-    chol!(copy_oftype(A, S), uplo)
-end
 function chol!(x::Number, uplo)
     rx = real(x)
     if rx != abs(x)
@@ -94,50 +96,88 @@ function chol!(x::Number, uplo)
     rxr = sqrt(rx)
     convert(promote_type(typeof(x), typeof(rxr)), rxr)
 end
-chol(x::Number, uplo::Symbol=:U) = chol!(x, uplo)
-
-function cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol=:U,
-                                 pivot::Union{Type{Val{false}},Type{Val{true}}}=Val{false}; tol=0.0)
-    _cholfact!(A, pivot, uplo, tol=tol)
-end
-function _cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{false}}, uplo::Symbol=:U; tol=0.0)
-    return Cholesky(chol!(A, Val{uplo}).data, uplo)
+"""
+    chol(x::Number) -> y
+
+Compute the square root of a non-negative number `x`.
+"""
+chol(x::Number, args...) = chol!(x, nothing)
+
+cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol, ::Type{Val{false}}) =
+    _cholfact!(A, Val{false}, uplo)
+cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol, ::Type{Val{true}}; tol = 0.0) =
+    _cholfact!(A, Val{true}, uplo; tol = tol)
+cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol = :U) =
+    _cholfact!(A, Val{false}, uplo)
+
+function _cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{false}}, uplo::Symbol=:U)
+    if uplo == :U
+        return Cholesky(chol!(A, UpperTriangular).data, uplo)
+    else
+        return Cholesky(chol!(A, LowerTriangular).data, uplo)
+    end
 end
 function _cholfact!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{true}}, uplo::Symbol=:U; tol=0.0)
     uplochar = char_uplo(uplo)
     A, piv, rank, info = LAPACK.pstrf!(uplochar, A, tol)
-    return CholeskyPivoted{T,StridedMatrix{T}}(A, uplochar, piv, rank, tol, info)
-end
-function cholfact!(A::StridedMatrix, uplo::Symbol=:U,
-                   pivot::Union{Type{Val{false}},Type{Val{true}}}=Val{false}; tol=0.0)
-    Cholesky(chol!(A, Val{uplo}).data, uplo)
+    return CholeskyPivoted{T,typeof(A)}(A, uplochar, piv, rank, tol, info)
 end
 
-# function cholfact!{T<:BlasFloat,S}(C::Cholesky{T,S})
-#     _, info = LAPACK.potrf!(C.uplo, C.factors)
-#     info[1]>0 && throw(PosDefException(info[1]))
-#     C
-# end
-
-# cholfact{T<:BlasFloat}(A::StridedMatrix{T}, uplo::Symbol=:U, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false}; tol=0.0) =
-#     cholfact!(copy(A), uplo, pivot, tol=tol)
+"""
+    cholfact!(A::StridedMatrix, uplo::Symbol, Val{false}) -> Cholesky
 
+The same as `cholfact`, but saves space by overwriting the input `A`, instead of creating a copy.
+"""
+function cholfact!(A::StridedMatrix, uplo::Symbol, ::Type{Val{false}})
+    if uplo == :U
+        Cholesky(chol!(A, UpperTriangular).data, 'U')
+    else
+        Cholesky(chol!(A, LowerTriangular).data, 'L')
+    end
+end
 
-cholfact{T}(A::StridedMatrix{T}, uplo::Symbol=:U, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false}; tol=0.0) =
-    cholfact!(copy_oftype(A, promote_type(typeof(chol(one(T))),Float32)), uplo, pivot; tol = tol)
-# _cholfact{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Type{Val{true}}, uplo::Symbol=:U; tol=0.0) =
-#     cholfact!(A, uplo, pivot, tol = tol)
-# _cholfact{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Type{Val{false}}, uplo::Symbol=:U; tol=0.0) =
-#     cholfact!(A, uplo, pivot, tol = tol)
-
-# _cholfact{T}(A::StridedMatrix{T}, ::Type{Val{false}}, uplo::Symbol=:U; tol=0.0) =
-#     cholfact!(A, uplo)
-# _cholfact{T}(A::StridedMatrix{T}, ::Type{Val{true}}, uplo::Symbol=:U; tol=0.0) =
-#     throw(ArgumentError("pivot only supported for Float32, Float64, Complex{Float32} and Complex{Float64}"))
-
+"""
+    cholfact!(A::StridedMatrix, uplo::Symbol, Val{true}) -> PivotedCholesky
+
+The same as `cholfact`, but saves space by overwriting the input `A`, instead of creating a copy.
+"""
+cholfact!(A::StridedMatrix, uplo::Symbol, ::Type{Val{true}}; tol = 0.0) =
+    throw(ArgumentError("generic pivoted Cholesky fectorization is not implemented yet"))
+cholfact!(A::StridedMatrix, uplo::Symbol = :U) = cholfact!(A, uplo, Val{false})
+
+"""
+    cholfact(A::StridedMatrix, uplo::Symbol, Val{false}) -> Cholesky
+
+Compute the Cholesky factorization of a dense symmetric positive definite matrix `A`
+and return a `Cholesky` factorization.
+The `uplo` argument may be `:L` for using the lower part or `:U` for the upper part of `A`.
+The default is to use `:U`.
+The triangular Cholesky factor can be obtained from the factorization `F` with: `F[:L]` and `F[:U]`.
+The following functions are available for `Cholesky` objects: `size`, `\`, `inv`, `det`.
+A `PosDefException` exception is thrown in case the matrix is not positive definite.
+"""
+cholfact{T}(A::StridedMatrix{T}, uplo::Symbol, ::Type{Val{false}}) =
+    cholfact!(copy_oftype(A, promote_type(typeof(chol(one(T))),Float32)), uplo, Val{false})
+
+"""
+    cholfact(A::StridedMatrix, uplo::Symbol, Val{true}; tol = 0.0) -> CholeskyPivoted
+
+Compute the pivoted Cholesky factorization of a dense symmetric positive semi-definite matrix `A`
+and return a `CholeskyPivoted` factorization.
+The `uplo` argument may be `:L` for using the lower part or `:U` for the upper part of `A`.
+The default is to use `:U`.
+The triangular Cholesky factor can be obtained from the factorization `F` with: `F[:L]` and `F[:U]`.
+The following functions are available for `PivotedCholesky` objects: `size`, `\`, `inv`, `det`, and `rank`.
+The argument `tol` determines the tolerance for determining the rank.
+For negative values, the tolerance is the machine precision.
+"""
+cholfact{T}(A::StridedMatrix{T}, uplo::Symbol, ::Type{Val{true}}; tol = 0.0) =
+    cholfact!(copy_oftype(A, promote_type(typeof(chol(one(T))),Float32)), uplo, Val{true}; tol = tol)
+
+cholfact{T}(A::StridedMatrix{T}, uplo::Symbol = :U) = cholfact(A, uplo, Val{false})
 
 function cholfact(x::Number, uplo::Symbol=:U)
-    xf = fill(chol!(x, uplo), 1, 1)
+    xf = fill(chol(x), 1, 1)
     Cholesky(xf, uplo)
 end
 
@@ -155,7 +195,10 @@ convert{T}(::Type{CholeskyPivoted{T}},C::CholeskyPivoted) =
 convert{T}(::Type{Factorization{T}}, C::CholeskyPivoted) = convert(CholeskyPivoted{T}, C)
 
 full{T,S}(C::Cholesky{T,S}) = C.uplo == 'U' ? C[:U]'C[:U] : C[:L]*C[:L]'
-full(F::CholeskyPivoted) = (ip=invperm(F[:p]); (F[:L] * F[:U])[ip,ip])
+function full(F::CholeskyPivoted)
+    ip = invperm(F[:p])
+    return (F[:L] * F[:U])[ip,ip]
+end
 
 copy(C::Cholesky) = Cholesky(copy(C.factors), C.uplo)
 copy(C::CholeskyPivoted) = CholeskyPivoted(copy(C.factors), C.uplo, C.piv, C.rank, C.tol, C.info)
@@ -185,7 +228,7 @@ function getindex{T<:BlasFloat}(C::CholeskyPivoted{T}, d::Symbol)
 end
 
 show{T,S<:AbstractMatrix}(io::IO, C::Cholesky{T,S}) =
-    (println("$(typeof(C)) with factor:");show(io,C[:UL]))
+    (println(io, "$(typeof(C)) with factor:");show(io,C[:UL]))
 
 A_ldiv_B!{T<:BlasFloat,S<:AbstractMatrix}(C::Cholesky{T,S}, B::StridedVecOrMat{T}) =
     LAPACK.potrs!(C.uplo, C.factors, B)
@@ -260,3 +303,110 @@ end
 chkfullrank(C::CholeskyPivoted) = C.rank < size(C.factors, 1) && throw(RankDeficientException(C.info))
 
 rank(C::CholeskyPivoted) = C.rank
+
+"""
+    lowrankupdate!(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+Update a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]` then `CC = cholfact(C[:U]'C[:U] + v*v')` but the computation of `CC` only uses `O(n^2)` operations. The input factorization `C` is updated in place such that on exit `C == CC`. The vector `v` is destroyed during the computation.
+"""
+function lowrankupdate!(C::Cholesky, v::StridedVector)
+    A = C.factors
+    n = length(v)
+    if size(C, 1) != n
+        throw(DimensionMismatch("updating vector must fit size of factorization"))
+    end
+    if C.uplo == 'U'
+        conj!(v)
+    end
+
+    for i = 1:n
+
+        # Compute Givens rotation
+        c, s, r = givensAlgorithm(A[i,i], v[i])
+
+        # Store new diagonal element
+        A[i,i] = r
+
+        # Update remaining elements in row/column
+        if C.uplo == 'U'
+            for j = i + 1:n
+                Aij = A[i,j]
+                vj  = v[j]
+                A[i,j]  =   c*Aij + s*vj
+                v[j]    = -s'*Aij + c*vj
+            end
+        else
+            for j = i + 1:n
+                Aji = A[j,i]
+                vj  = v[j]
+                A[j,i]  =   c*Aji + s*vj
+                v[j]    = -s'*Aji + c*vj
+            end
+        end
+    end
+    return C
+end
+
+"""
+    lowrankdowndate!(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+Downdate a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]` then `CC = cholfact(C[:U]'C[:U] - v*v')` but the computation of `CC` only uses `O(n^2)` operations. The input factorization `C` is updated in place such that on exit `C == CC`. The vector `v` is destroyed during the computation.
+"""
+function lowrankdowndate!(C::Cholesky, v::StridedVector)
+    A = C.factors
+    n = length(v)
+    if size(C, 1) != n
+        throw(DimensionMismatch("updating vector must fit size of factorization"))
+    end
+    if C.uplo == 'U'
+        conj!(v)
+    end
+
+    for i = 1:n
+
+        Aii = A[i,i]
+
+        # Compute Givens rotation
+        s = conj(v[i]/Aii)
+        s2 = abs2(s)
+        if s2 > 1
+            throw(LinAlg.PosDefException(i))
+        end
+        c = sqrt(1 - abs2(s))
+
+        # Store new diagonal element
+        A[i,i] = c*Aii
+
+        # Update remaining elements in row/column
+        if C.uplo == 'U'
+            for j = i + 1:n
+                vj = v[j]
+                Aij = (A[i,j] - s*vj)/c
+                A[i,j] = Aij
+                v[j] = -s'*Aij + c*vj
+            end
+        else
+            for j = i + 1:n
+                vj = v[j]
+                Aji = (A[j,i] - s*vj)/c
+                A[j,i] = Aji
+                v[j] = -s'*Aji + c*vj
+            end
+        end
+    end
+    return C
+end
+
+"""
+    lowrankupdate(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+Update a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]` then `CC = cholfact(C[:U]'C[:U] + v*v')` but the computation of `CC` only uses `O(n^2)` operations.
+"""
+lowrankupdate(C::Cholesky, v::StridedVector) = lowrankupdate!(copy(C), copy(v))
+
+"""
+    lowrankdowndate(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+Downdate a Cholesky factorization `C` with the vector `v`. If `A = C[:U]'C[:U]` then `CC = cholfact(C[:U]'C[:U] - v*v')` but the computation of `CC` only uses `O(n^2)` operations.
+"""
+lowrankdowndate(C::Cholesky, v::StridedVector) = lowrankdowndate!(copy(C), copy(v))
diff --git a/base/linalg/dense.jl b/base/linalg/dense.jl
index 52471aeaa6087..2b43fcfe7331c 100644
--- a/base/linalg/dense.jl
+++ b/base/linalg/dense.jl
@@ -142,7 +142,7 @@ end
 diagm(x::Number) = (X = Array(typeof(x),1,1); X[1,1] = x; X)
 
 function trace{T}(A::Matrix{T})
-    n = chksquare(A)
+    n = checksquare(A)
     t = zero(T)
     for i=1:n
         t += A[i,i]
@@ -175,11 +175,11 @@ function ^(A::Matrix, p::Number)
     if isinteger(p)
         return A^Integer(real(p))
     end
-    chksquare(A)
+    checksquare(A)
     v, X = eig(A)
     any(v.<0) && (v = complex(v))
     Xinv = ishermitian(A) ? X' : inv(X)
-    scale(X, v.^p)*Xinv
+    (X * Diagonal(v.^p)) * Xinv
 end
 
 # Matrix exponential
@@ -190,7 +190,7 @@ expm(x::Number) = exp(x)
 ## Destructive matrix exponential using algorithm from Higham, 2008,
 ## "Functions of Matrices: Theory and Computation", SIAM
 function expm!{T<:BlasFloat}(A::StridedMatrix{T})
-    n = chksquare(A)
+    n = checksquare(A)
     if ishermitian(A)
         return full(expm(Hermitian(A)))
     end
@@ -282,6 +282,25 @@ function rcswap!{T<:Number}(i::Integer, j::Integer, X::StridedMatrix{T})
     end
 end
 
+"""
+    logm(A::StridedMatrix)
+
+If `A` has no negative real eigenvalue, compute the principal matrix logarithm of `A`, i.e.
+the unique matrix ``X`` such that ``e^X = A`` and ``-\\pi < Im(\\lambda) < \\pi`` for all
+the eigenvalues ``\\lambda`` of ``X``. If `A` has nonpositive eigenvalues, a nonprincipal
+matrix function is returned whenever possible.
+
+If `A` is symmetric or Hermitian, its eigendecomposition ([`eigfact`](:func:`eigfact`)) is
+used, if `A` is triangular an improved version of the inverse scaling and squaring method is
+employed (see [^AH12] and [^AHR13]). For general matrices, the complex Schur form
+([`schur`](:func:`schur`)) is computed and the triangular algorithm is used on the
+triangular factor.
+
+[^AH12]: Awad H. Al-Mohy and Nicholas J. Higham, "Improved inverse  scaling and squaring algorithms for the matrix logarithm", SIAM Journal on Scientific Computing, 34(4), 2012, C153-C169. [doi:10.1137/110852553](http://dx.doi.org/10.1137/110852553)
+
+[^AHR13]: Awad H. Al-Mohy, Nicholas J. Higham and Samuel D. Relton, "Computing the Fréchet derivative of the matrix logarithm and estimating the condition number", SIAM Journal on Scientific Computing, 35(4), 2013, C394-C410. [doi:10.1137/120885991](http://dx.doi.org/10.1137/120885991)
+
+"""
 function logm(A::StridedMatrix)
     # If possible, use diagonalization
     if ishermitian(A)
@@ -289,7 +308,7 @@ function logm(A::StridedMatrix)
     end
 
     # Use Schur decomposition
-    n = chksquare(A)
+    n = checksquare(A)
     if istriu(A)
         retmat = full(logm(UpperTriangular(complex(A))))
         d = diag(A)
@@ -307,9 +326,6 @@ function logm(A::StridedMatrix)
             break
         end
     end
-    if np_real_eigs
-        warn("Matrix with nonpositive real eigenvalues, a nonprincipal matrix logarithm will be returned.")
-    end
 
     if isreal(A) && ~np_real_eigs
         return real(retmat)
@@ -317,14 +333,17 @@ function logm(A::StridedMatrix)
         return retmat
     end
 end
-logm(a::Number) = (b = log(complex(a)); imag(b) == 0 ? real(b) : b)
+function logm(a::Number)
+    b = log(complex(a))
+    return imag(b) == 0 ? real(b) : b
+end
 logm(a::Complex) = log(a)
 
 function sqrtm{T<:Real}(A::StridedMatrix{T})
-    if issym(A)
+    if issymmetric(A)
         return full(sqrtm(Symmetric(A)))
     end
-    n = chksquare(A)
+    n = checksquare(A)
     if istriu(A)
         return full(sqrtm(UpperTriangular(A)))
     else
@@ -337,7 +356,7 @@ function sqrtm{T<:Complex}(A::StridedMatrix{T})
     if ishermitian(A)
         return full(sqrtm(Hermitian(A)))
     end
-    n = chksquare(A)
+    n = checksquare(A)
     if istriu(A)
         return full(sqrtm(UpperTriangular(A)))
     else
@@ -359,7 +378,7 @@ function inv{T}(A::StridedMatrix{T})
     else
         Ai = inv(lufact(AA))
     end
-    return convert(typeof(AA), Ai)
+    return convert(typeof(parent(Ai)), Ai)
 end
 
 function factorize{T}(A::Matrix{T})
@@ -433,21 +452,7 @@ function factorize{T}(A::Matrix{T})
         end
         return lufact(A)
     end
-    qrfact(A,typeof(zero(T)/sqrt(zero(T) + zero(T)))<:BlasFloat?Val{true}:Val{false}) # Generic pivoted QR not implemented yet
-end
-
-(\)(a::Vector, B::StridedVecOrMat) = (\)(reshape(a, length(a), 1), B)
-
-function (\)(A::StridedMatrix, B::StridedVecOrMat)
-    m, n = size(A)
-    if m == n
-        if istril(A)
-            return istriu(A) ? \(Diagonal(A),B) : \(LowerTriangular(A),B)
-        end
-        istriu(A) && return \(UpperTriangular(A),B)
-        return \(lufact(A),B)
-    end
-    return qrfact(A,Val{true})\B
+    qrfact(A, Val{true})
 end
 
 ## Moore-Penrose pseudoinverse
@@ -478,7 +483,7 @@ function pinv{T}(A::StridedMatrix{T}, tol::Real)
     index       = SVD.S .> tol*maximum(SVD.S)
     Sinv[index] = one(Stype) ./ SVD.S[index]
     Sinv[find(!isfinite(Sinv))] = zero(Stype)
-    return SVD.Vt'scale(Sinv, SVD.U')
+    return SVD.Vt' * (Diagonal(Sinv) * SVD.U')
 end
 function pinv{T}(A::StridedMatrix{T})
     tol = eps(real(float(one(T))))*maximum(size(A))
@@ -506,7 +511,7 @@ function cond(A::AbstractMatrix, p::Real=2)
         maxv = maximum(v)
         return maxv == 0.0 ? oftype(real(A[1,1]),Inf) : maxv / minimum(v)
     elseif p == 1 || p == Inf
-        chksquare(A)
+        checksquare(A)
         return cond(lufact(A), p)
     end
     throw(ArgumentError("p-norm must be 1, 2 or Inf, got $p"))
diff --git a/base/linalg/diagonal.jl b/base/linalg/diagonal.jl
index bdcb6dd35361f..fe537cf305517 100644
--- a/base/linalg/diagonal.jl
+++ b/base/linalg/diagonal.jl
@@ -5,7 +5,8 @@
 immutable Diagonal{T} <: AbstractMatrix{T}
     diag::Vector{T}
 end
-Diagonal(A::Matrix) = Diagonal(diag(A))
+Diagonal(A::AbstractMatrix) = Diagonal(diag(A))
+Diagonal(V::AbstractVector) = Diagonal(collect(V))
 
 convert{T}(::Type{Diagonal{T}}, D::Diagonal{T}) = D
 convert{T}(::Type{Diagonal{T}}, D::Diagonal) = Diagonal{T}(convert(Vector{T}, D.diag))
@@ -13,11 +14,8 @@ convert{T}(::Type{AbstractMatrix{T}}, D::Diagonal) = convert(Diagonal{T}, D)
 convert{T}(::Type{UpperTriangular}, A::Diagonal{T}) = UpperTriangular(A)
 convert{T}(::Type{LowerTriangular}, A::Diagonal{T}) = LowerTriangular(A)
 
-function similar{T}(D::Diagonal, ::Type{T}, d::Tuple{Int,Int})
-    if d[1] != d[2]
-        throw(ArgumentError("diagonal matrix must be square"))
-    end
-    return Diagonal{T}(Array(T,d[1]))
+function similar{T}(D::Diagonal, ::Type{T})
+    return Diagonal{T}(similar(D.diag, T))
 end
 
 copy!(D1::Diagonal, D2::Diagonal) = (copy!(D1.diag, D2.diag); D1)
@@ -35,22 +33,39 @@ fill!(D::Diagonal, x) = (fill!(D.diag, x); D)
 
 full(D::Diagonal) = diagm(D.diag)
 
-getindex(D::Diagonal, i::Int, j::Int) = (checkbounds(D, i, j); unsafe_getindex(D, i, j))
-unsafe_getindex{T}(D::Diagonal{T}, i::Int, j::Int) = i == j ? unsafe_getindex(D.diag, i) : zero(T)
+@inline function getindex(D::Diagonal, i::Int, j::Int)
+    @boundscheck checkbounds(D, i, j)
+    if i == j
+        @inbounds r = D.diag[i]
+    else
+        r = diagzero(D, i, j)
+    end
+    r
+end
+diagzero{T}(::Diagonal{T},i,j) = zero(T)
+diagzero{T}(D::Diagonal{Matrix{T}},i,j) = zeros(T, size(D.diag[i], 1), size(D.diag[j], 2))
 
-setindex!(D::Diagonal, v, i::Int, j::Int) = (checkbounds(D, i, j); unsafe_setindex!(D, v, i, j))
-function unsafe_setindex!(D::Diagonal, v, i::Int, j::Int)
+function setindex!(D::Diagonal, v, i::Int, j::Int)
+    @boundscheck checkbounds(D, i, j)
     if i == j
-        unsafe_setindex!(D.diag, v, i)
+        @inbounds D.diag[i] = v
     elseif v != 0
         throw(ArgumentError("cannot set an off-diagonal index ($i, $j) to a nonzero value ($v)"))
     end
     D
 end
 
+
+## structured matrix methods ##
+function Base.replace_in_print_matrix(A::Diagonal,i::Integer,j::Integer,s::AbstractString)
+    i==j ? s : Base.replace_with_centered_mark(s)
+end
+
+parent(D::Diagonal) = D.diag
+
 ishermitian{T<:Real}(D::Diagonal{T}) = true
 ishermitian(D::Diagonal) = all(D.diag .== real(D.diag))
-issym(D::Diagonal) = true
+issymmetric(D::Diagonal) = true
 isposdef(D::Diagonal) = all(D.diag .> 0)
 
 factorize(D::Diagonal) = D
@@ -90,9 +105,11 @@ end
 *{T<:Number}(D::Diagonal, x::T) = Diagonal(D.diag * x)
 /{T<:Number}(D::Diagonal, x::T) = Diagonal(D.diag / x)
 *(Da::Diagonal, Db::Diagonal) = Diagonal(Da.diag .* Db.diag)
-*(D::Diagonal, V::Vector) = D.diag .* V
-*(A::Matrix, D::Diagonal) = scale(A,D.diag)
-*(D::Diagonal, A::Matrix) = scale(D.diag,A)
+*(D::Diagonal, V::AbstractVector) = D.diag .* V
+*(A::AbstractMatrix, D::Diagonal) =
+    scale!(similar(A, promote_op(MulFun(), eltype(A), eltype(D.diag))), A, D.diag)
+*(D::Diagonal, A::AbstractMatrix) =
+    scale!(similar(A, promote_op(MulFun(), eltype(A), eltype(D.diag))), D.diag, A)
 
 A_mul_B!(A::Diagonal,B::AbstractMatrix) = scale!(A.diag,B)
 At_mul_B!(A::Diagonal,B::AbstractMatrix)= scale!(A.diag,B)
@@ -121,7 +138,10 @@ function A_ldiv_B!{T}(D::Diagonal{T}, V::AbstractMatrix{T})
         if d == zero(T)
             throw(SingularException(i))
         end
-        V[i,:] *= inv(d)
+        d⁻¹ = inv(d)
+        for j=1:size(V,2)
+            @inbounds V[i,j] *= d⁻¹
+        end
     end
     V
 end
@@ -163,12 +183,12 @@ function A_ldiv_B!(D::Diagonal, B::StridedVecOrMat)
     end
     return B
 end
-\(D::Diagonal, B::StridedMatrix) = scale(1 ./ D.diag, B)
-\(D::Diagonal, b::StridedVector) = reshape(scale(1 ./ D.diag, reshape(b, length(b), 1)), length(b))
-\(Da::Diagonal, Db::Diagonal) = Diagonal(Db.diag ./ Da.diag)
+(\)(D::Diagonal, A::AbstractMatrix) = D.diag .\ A
+(\)(D::Diagonal, b::AbstractVector) = D.diag .\ b
+(\)(Da::Diagonal, Db::Diagonal) = Diagonal(Db.diag ./ Da.diag)
 
 function inv{T}(D::Diagonal{T})
-    Di = similar(D.diag)
+    Di = similar(D.diag, typeof(inv(zero(T))))
     for i = 1:length(D.diag)
         if D.diag[i] == zero(T)
             throw(SingularException(i))
@@ -179,15 +199,15 @@ function inv{T}(D::Diagonal{T})
 end
 
 function pinv{T}(D::Diagonal{T})
-    Di = similar(D.diag)
+    Di = similar(D.diag, typeof(inv(zero(T))))
     for i = 1:length(D.diag)
         isfinite(inv(D.diag[i])) ? Di[i]=inv(D.diag[i]) : Di[i]=zero(T)
     end
     Diagonal(Di)
 end
 function pinv{T}(D::Diagonal{T}, tol::Real)
-    Di = similar(D.diag)
-    if( length(D.diag) != 0 ) maxabsD = maximum(abs(D.diag)) end
+    Di = similar(D.diag, typeof(inv(zero(T))))
+    if( !isempty(D.diag) ) maxabsD = maximum(abs(D.diag)) end
     for i = 1:length(D.diag)
         if( abs(D.diag[i]) > tol*maxabsD && isfinite(inv(D.diag[i])) )
             Di[i]=inv(D.diag[i])
diff --git a/base/linalg/eigen.jl b/base/linalg/eigen.jl
index 2a412c7bb285d..3096d309d27df 100644
--- a/base/linalg/eigen.jl
+++ b/base/linalg/eigen.jl
@@ -28,7 +28,7 @@ isposdef(A::Union{Eigen,GeneralizedEigen}) = isreal(A.values) && all(A.values .>
 function eigfact!{T<:BlasReal}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
     n = size(A, 2)
     n==0 && return Eigen(zeros(T, 0), zeros(T, 0, 0))
-    issym(A) && return eigfact!(Symmetric(A))
+    issymmetric(A) && return eigfact!(Symmetric(A))
     A, WR, WI, VL, VR, _ = LAPACK.geevx!(permute ? (scale ? 'B' : 'P') : (scale ? 'S' : 'N'), 'N', 'V', 'N', A)
     all(WI .== 0.) && return Eigen(WR, VR)
     evec = zeros(Complex{T}, n, n)
@@ -58,21 +58,30 @@ function eigfact{T}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
 end
 eigfact(x::Number) = Eigen([x], fill(one(x), 1, 1))
 
-# function eig(A::Union{Number, AbstractMatrix}; permute::Bool=true, scale::Bool=true)
-#     F = eigfact(A, permute=permute, scale=scale)
-#     F[:values], F[:vectors]
-# end
-function eig(A::Union{Number, AbstractMatrix}; kwargs...)
-    F = eigfact(A; kwargs...)
+function eig(A::Union{Number, StridedMatrix}; permute::Bool=true, scale::Bool=true)
+    F = eigfact(A, permute=permute, scale=scale)
     F.values, F.vectors
 end
+function eig(A::AbstractMatrix, args...)
+    F = eigfact(A, args...)
+    F.values, F.vectors
+end
+
 #Calculates eigenvectors
-eigvecs(A::Union{Number, AbstractMatrix}, args...; kwargs...) = eigvecs(eigfact(A, args...; kwargs...))
+eigvecs(A::Union{Number, AbstractMatrix}; permute::Bool=true, scale::Bool=true) =
+    eigvecs(eigfact(A, permute=permute, scale=scale))
 eigvecs{T,V,S,U}(F::Union{Eigen{T,V,S,U}, GeneralizedEigen{T,V,S,U}}) = F[:vectors]::S
 
 eigvals{T,V,S,U}(F::Union{Eigen{T,V,S,U}, GeneralizedEigen{T,V,S,U}}) = F[:values]::U
+
+"""
+
+    eigvals!(A,[irange,][vl,][vu]) -> values
+
+Same as `eigvals`, but saves space by overwriting the input `A` (and `B`), instead of creating a copy.
+"""
 function eigvals!{T<:BlasReal}(A::StridedMatrix{T}; permute::Bool=true, scale::Bool=true)
-    issym(A) && return eigvals!(Symmetric(A))
+    issymmetric(A) && return eigvals!(Symmetric(A))
     _, valsre, valsim, _ = LAPACK.geevx!(permute ? (scale ? 'B' : 'P') : (scale ? 'S' : 'N'), 'N', 'N', 'N', A)
     return all(valsim .== 0) ? valsre : complex(valsre, valsim)
 end
@@ -111,7 +120,7 @@ det(A::Eigen) = prod(A.values)
 
 # Generalized eigenproblem
 function eigfact!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
-    issym(A) && isposdef(B) && return eigfact!(Symmetric(A), Symmetric(B))
+    issymmetric(A) && isposdef(B) && return eigfact!(Symmetric(A), Symmetric(B))
     n = size(A, 1)
     alphar, alphai, beta, _, vr = LAPACK.ggev!('N', 'V', A, B)
     all(alphai .== 0) && return GeneralizedEigen(alphar ./ beta, vr)
@@ -141,13 +150,19 @@ function eigfact{TA,TB}(A::AbstractMatrix{TA}, B::AbstractMatrix{TB})
     return eigfact!(copy_oftype(A, S), copy_oftype(B, S))
 end
 
-function eig(A::Union{Number, AbstractMatrix}, B::Union{Number, AbstractMatrix})
+eigfact(A::Number, B::Number) = eigfact(fill(A,1,1), fill(B,1,1))
+
+function eig(A::AbstractMatrix, B::AbstractMatrix)
+    F = eigfact(A,B)
+    F.values, F.vectors
+end
+function eig(A::Number, B::Number)
     F = eigfact(A,B)
     F.values, F.vectors
 end
 
 function eigvals!{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T})
-    issym(A) && isposdef(B) && return eigvals!(Symmetric(A), Symmetric(B))
+    issymmetric(A) && isposdef(B) && return eigvals!(Symmetric(A), Symmetric(B))
     alphar, alphai, beta, vl, vr = LAPACK.ggev!('N', 'N', A, B)
     return (all(alphai .== 0) ? alphar : complex(alphar, alphai))./beta
 end
@@ -161,5 +176,7 @@ function eigvals{TA,TB}(A::AbstractMatrix{TA}, B::AbstractMatrix{TB})
     return eigvals!(copy_oftype(A, S), copy_oftype(B, S))
 end
 
+eigvecs(A::AbstractMatrix, B::AbstractMatrix) = eigvecs(eigfact(A, B))
+
 ## Can we determine the source/result is Real?  This is not stored in the type Eigen
 full(F::Eigen) = F.vectors * Diagonal(F.values) / F.vectors
diff --git a/base/linalg/exceptions.jl b/base/linalg/exceptions.jl
index bd7686193c11e..c8975e45d53fc 100644
--- a/base/linalg/exceptions.jl
+++ b/base/linalg/exceptions.jl
@@ -11,7 +11,18 @@ type LAPACKException <: Exception
 end
 
 type ARPACKException <: Exception
-    info::BlasInt
+    info::ByteString
+end
+
+function ARPACKException(i::Integer)
+    if i == -8
+        return ARPACKException("error return from calculation of a real Schur form.")
+    elseif i == -9
+        return ARPACKException("error return from calculation of eigenvectors.")
+    elseif i == -14
+        return ARPACKException("did not find any eigenvalues to sufficient accuracy. Try with a different starting vector or more Lanczos vectors by increasing the value of ncv.")
+    end
+    return ARPACKException("unspecified ARPACK error: $i")
 end
 
 type SingularException <: Exception
diff --git a/base/linalg/factorization.jl b/base/linalg/factorization.jl
index 0df88a7a71e67..e5f263d48d6f2 100644
--- a/base/linalg/factorization.jl
+++ b/base/linalg/factorization.jl
@@ -20,7 +20,21 @@ end
 ### General promotion rules
 convert{T}(::Type{Factorization{T}}, F::Factorization{T}) = F
 inv{T}(F::Factorization{T}) = A_ldiv_B!(F, eye(T, size(F,1)))
-function \{TF<:Number,TB<:Number,N}(F::Factorization{TF}, B::AbstractArray{TB,N})
+
+# With a real lhs and complex rhs with the same precision, we can reinterpret
+# the complex rhs as a real rhs with twice the number of columns
+function (\){T<:BlasReal}(F::Factorization{T}, B::AbstractVector{Complex{T}})
+    c2r = reshape(transpose(reinterpret(T, B, (2, length(B)))), size(B, 1), 2*size(B, 2))
+    x = A_ldiv_B!(F, c2r)
+    return reinterpret(Complex{T}, transpose(reshape(x, div(length(x), 2), 2)), (size(F,2),))
+end
+function (\){T<:BlasReal}(F::Factorization{T}, B::AbstractMatrix{Complex{T}})
+    c2r = reshape(transpose(reinterpret(T, B, (2, length(B)))), size(B, 1), 2*size(B, 2))
+    x = A_ldiv_B!(F, c2r)
+    return reinterpret(Complex{T}, transpose(reshape(x, div(length(x), 2), 2)), (size(F,2), size(B,2)))
+end
+
+function (\){TF<:Number,TB<:Number,N}(F::Factorization{TF}, B::AbstractArray{TB,N})
     TFB = typeof(one(TF)/one(TB))
     A_ldiv_B!(convert(Factorization{TFB}, F), copy_oftype(B, TFB))
 end
diff --git a/base/linalg/generic.jl b/base/linalg/generic.jl
index bf2bcd1917cde..9042faf621272 100644
--- a/base/linalg/generic.jl
+++ b/base/linalg/generic.jl
@@ -2,14 +2,18 @@
 
 ## linalg.jl: Some generic Linear Algebra definitions
 
-scale(X::AbstractArray, s::Number) = X*s
-scale(s::Number, X::AbstractArray) = s*X
-
 # For better performance when input and output are the same array
 # See https://github.com/JuliaLang/julia/issues/8415#issuecomment-56608729
 function generic_scale!(X::AbstractArray, s::Number)
-    for i = 1:length(X)
-        @inbounds X[i] *= s
+    @simd for I in eachindex(X)
+        @inbounds X[I] *= s
+    end
+    X
+end
+
+function generic_scale!(s::Number, X::AbstractArray)
+    @simd for I in eachindex(X)
+        @inbounds X[I] = s*X[I]
     end
     X
 end
@@ -18,15 +22,39 @@ function generic_scale!(C::AbstractArray, X::AbstractArray, s::Number)
     if length(C) != length(X)
         throw(DimensionMismatch("first array has length $(length(C)) which does not match the length of the second, $(length(X))."))
     end
-    for i = 1:length(X)
-        @inbounds C[i] = X[i]*s
+    if size(C) == size(X)
+        for I in eachindex(C, X)
+            @inbounds C[I] = X[I]*s
+        end
+    else
+        for (IC, IX) in zip(eachindex(C), eachindex(X))
+            @inbounds C[IC] = X[IX]*s
+        end
     end
     C
 end
+
+function generic_scale!(C::AbstractArray, s::Number, X::AbstractArray)
+    if length(C) != length(X)
+        throw(DimensionMismatch("first array has length $(length(C)) which does not
+match the length of the second, $(length(X))."))
+    end
+    if size(C) == size(X)
+        for I in eachindex(C, X)
+            @inbounds C[I] = s*X[I]
+        end
+    else
+        for (IC, IX) in zip(eachindex(C), eachindex(X))
+            @inbounds C[IC] = s*X[IX]
+        end
+    end
+    C
+end
+
 scale!(C::AbstractArray, s::Number, X::AbstractArray) = generic_scale!(C, X, s)
-scale!(C::AbstractArray, X::AbstractArray, s::Number) = generic_scale!(C, X, s)
+scale!(C::AbstractArray, X::AbstractArray, s::Number) = generic_scale!(C, s, X)
 scale!(X::AbstractArray, s::Number) = generic_scale!(X, s)
-scale!(s::Number, X::AbstractArray) = generic_scale!(X, s)
+scale!(s::Number, X::AbstractArray) = generic_scale!(s, X)
 
 cross(a::AbstractVector, b::AbstractVector) = [a[2]*b[3]-a[3]*b[2], a[3]*b[1]-a[1]*b[3], a[1]*b[2]-a[2]*b[1]]
 
@@ -236,17 +264,23 @@ end
 
 @inline norm(x::Number, p::Real=2) = vecnorm(x, p)
 
-function vecdot(x::AbstractVector, y::AbstractVector)
+function vecdot(x::AbstractArray, y::AbstractArray)
     lx = length(x)
     if lx != length(y)
-        throw(DimensionMismatch("vector x has length $lx, but vector y has length $(length(y))"))
+        throw(DimensionMismatch("first array has length $(lx) which does not match the length of the second, $(length(y))."))
     end
     if lx == 0
         return dot(zero(eltype(x)), zero(eltype(y)))
     end
-    s = dot(x[1], y[1])
-    @inbounds for i = 2:lx
-        s += dot(x[i], y[i])
+    s = zero(dot(x[1], y[1]))
+    if size(x) == size(y)
+        for I in eachindex(x, y)
+            @inbounds s += dot(x[I], y[I])
+        end
+    else
+        for (Ix, Iy) in zip(eachindex(x), eachindex(y))
+            @inbounds  s += dot(x[Ix], y[Iy])
+        end
     end
     s
 end
@@ -297,7 +331,7 @@ end
 rank(x::Number) = x==0 ? 0 : 1
 
 function trace(A::AbstractMatrix)
-    chksquare(A)
+    checksquare(A)
     sum(diag(A))
 end
 trace(x::Number) = x
@@ -310,22 +344,29 @@ trace(x::Number) = x
 inv(a::StridedMatrix) = throw(ArgumentError("argument must be a square matrix"))
 function inv{T}(A::AbstractMatrix{T})
     S = typeof(zero(T)/one(T))
-    A_ldiv_B!(factorize(convert(AbstractMatrix{S}, A)), eye(S, chksquare(A)))
+    A_ldiv_B!(factorize(convert(AbstractMatrix{S}, A)), eye(S, checksquare(A)))
 end
 
-function \{T}(A::AbstractMatrix{T}, B::AbstractVecOrMat{T})
-    if size(A,1) != size(B,1)
-        throw(DimensionMismatch("left and right hand sides should have the same number of rows, left hand side has $(size(A,1)) rows, but right hand side has $(size(B,1)) rows."))
+function (\)(A::AbstractMatrix, B::AbstractVecOrMat)
+    m, n = size(A)
+    if m == n
+        if istril(A)
+            if istriu(A)
+                return Diagonal(A) \ B
+            else
+                return LowerTriangular(A) \ B
+            end
+        end
+        if istriu(A)
+            return UpperTriangular(A) \ B
+        end
+        return lufact(A) \ B
     end
-    factorize(A)\B
-end
-function \{TA,TB}(A::AbstractMatrix{TA}, B::AbstractVecOrMat{TB})
-    TC = typeof(one(TA)/one(TB))
-    convert(AbstractMatrix{TC}, A)\convert(AbstractArray{TC}, B)
+    return qrfact(A,Val{true}) \ B
 end
 
-\(a::AbstractVector, b::AbstractArray) = reshape(a, length(a), 1) \ b
-/(A::AbstractVecOrMat, B::AbstractVecOrMat) = (B' \ A')'
+(\)(a::AbstractVector, b::AbstractArray) = reshape(a, length(a), 1) \ b
+(/)(A::AbstractVecOrMat, B::AbstractVecOrMat) = (B' \ A')'
 # \(A::StridedMatrix,x::Number) = inv(A)*x Should be added at some point when the old elementwise version has been deprecated long enough
 # /(x::Number,A::StridedMatrix) = x*inv(A)
 
@@ -338,7 +379,7 @@ condskeel{T<:Integer}(A::AbstractMatrix{T}, p::Real=Inf) = norm(abs(inv(float(A)
 condskeel(A::AbstractMatrix, x::AbstractVector, p::Real=Inf) = norm(abs(inv(A))*abs(A)*abs(x), p)
 condskeel{T<:Integer}(A::AbstractMatrix{T}, x::AbstractVector, p::Real=Inf) = norm(abs(inv(float(A)))*abs(A)*abs(x), p)
 
-function issym(A::AbstractMatrix)
+function issymmetric(A::AbstractMatrix)
     m, n = size(A)
     if m != n
         return false
@@ -351,7 +392,7 @@ function issym(A::AbstractMatrix)
     return true
 end
 
-issym(x::Number) = true
+issymmetric(x::Number) = true
 
 function ishermitian(A::AbstractMatrix)
     m, n = size(A)
@@ -394,7 +435,7 @@ istriu(x::Number) = true
 istril(x::Number) = true
 isdiag(x::Number) = true
 
-linreg{T<:Number}(X::StridedVecOrMat{T}, y::Vector{T}) = [ones(T, size(X,1)) X] \ y
+linreg{T<:Number}(X::AbstractVector{T}, y::AbstractVector{T}) = [ones(T, size(X,1)) X] \ y
 
 # weighted least squares
 function linreg(x::AbstractVector, y::AbstractVector, w::AbstractVector)
@@ -427,20 +468,20 @@ function peakflops(n::Integer=2000; parallel::Bool=false)
     parallel ? sum(pmap(peakflops, [ n for i in 1:nworkers()])) : (2*Float64(n)^3/t)
 end
 
-# BLAS-like in-place y=alpha*x+y function (see also the version in blas.jl
+# BLAS-like in-place y = x*α+y function (see also the version in blas.jl
 #                                          for BlasFloat Arrays)
-function axpy!(alpha, x::AbstractArray, y::AbstractArray)
+function axpy!(α, x::AbstractArray, y::AbstractArray)
     n = length(x)
     if n != length(y)
         throw(DimensionMismatch("x has length $n, but y has length $(length(y))"))
     end
     for i = 1:n
-        @inbounds y[i] += alpha * x[i]
+        @inbounds y[i] += x[i]*α
     end
     y
 end
 
-function axpy!{Ti<:Integer,Tj<:Integer}(alpha, x::AbstractArray, rx::AbstractArray{Ti}, y::AbstractArray, ry::AbstractArray{Tj})
+function axpy!{Ti<:Integer,Tj<:Integer}(α, x::AbstractArray, rx::AbstractArray{Ti}, y::AbstractArray, ry::AbstractArray{Tj})
     if length(x) != length(y)
         throw(DimensionMismatch("x has length $(length(x)), but y has length $(length(y))"))
     elseif minimum(rx) < 1 || maximum(rx) > length(x)
@@ -451,7 +492,7 @@ function axpy!{Ti<:Integer,Tj<:Integer}(alpha, x::AbstractArray, rx::AbstractArr
         throw(ArgumentError("rx has length $(length(rx)), but ry has length $(length(ry))"))
     end
     for i = 1:length(rx)
-        @inbounds y[ry[i]] += alpha * x[rx[i]]
+        @inbounds y[ry[i]] += x[rx[i]]*α
     end
     y
 end
@@ -517,3 +558,75 @@ function isapprox{T<:Number,S<:Number}(x::AbstractArray{T}, y::AbstractArray{S};
     d = norm(x - y)
     return isfinite(d) ? d <= atol + rtol*max(norm(x), norm(y)) : x == y
 end
+
+"""
+    normalize!(v, [p=2])
+
+Normalize the vector `v` in-place with respect to the `p`-norm.
+
+Inputs:
+
+- `v::AbstractVector` - vector to be normalized
+- `p::Real` - The `p`-norm to normalize with respect to. Default: 2
+
+Output:
+
+- `v` - A unit vector being the input vector, rescaled to have norm 1.
+        The input vector is modified in-place.
+
+See also:
+
+`normalize`, `qr`
+
+"""
+function normalize!(v::AbstractVector, p::Real=2)
+    nrm = norm(v, p)
+    __normalize!(v, nrm)
+end
+
+@inline function __normalize!(v::AbstractVector, nrm::AbstractFloat)
+    #The largest positive floating point number whose inverse is less than
+    #infinity
+    δ = inv(prevfloat(typemax(nrm)))
+
+    if nrm ≥ δ #Safe to multiply with inverse
+        invnrm = inv(nrm)
+        scale!(v, invnrm)
+
+    else # scale elements to avoid overflow
+        εδ = eps(one(nrm))/δ
+        scale!(v, εδ)
+        scale!(v, inv(nrm*εδ))
+    end
+
+    v
+end
+
+"""
+    normalize(v, [p=2])
+
+Normalize the vector `v` with respect to the `p`-norm.
+
+Inputs:
+
+- `v::AbstractVector` - vector to be normalized
+- `p::Real` - The `p`-norm to normalize with respect to. Default: 2
+
+Output:
+
+- `v` - A unit vector being a copy of the input vector, scaled to have norm 1
+
+See also:
+
+`normalize!`, `qr`
+"""
+function normalize(v::AbstractVector, p::Real = 2)
+    nrm = norm(v, p)
+    if !isempty(v)
+        vv = copy_oftype(v, typeof(v[1]/nrm))
+        return __normalize!(vv, nrm)
+    else
+        T = typeof(zero(eltype(v))/nrm)
+        return T[]
+    end
+end
diff --git a/base/linalg/givens.jl b/base/linalg/givens.jl
index 7b63429404a16..48055c7b91697 100644
--- a/base/linalg/givens.jl
+++ b/base/linalg/givens.jl
@@ -13,7 +13,17 @@ function A_mul_Bc{T,S}(A::AbstractVecOrMat{T}, R::AbstractRotation{S})
     TS = typeof(zero(T)*zero(S) + zero(T)*zero(S))
     A_mul_Bc!(TS == T ? copy(A) : convert(AbstractArray{TS}, A), convert(AbstractRotation{TS}, R))
 end
+"""
+    LinAlg.Givens(i1,i2,c,s) -> G
 
+A Givens rotation linear operator. The fields `c` and `s` represent the cosine and sine of
+the rotation angle, respectively. The `Givens` type supports left multiplication `G*A` and
+conjugated transpose right multiplication `A*G'`. The type doesn't have a `size` and can
+therefore be multiplied with matrices of arbitrary size as long as `i2<=size(A,2)` for
+`G*A` or `i2<=size(A,1)` for `A*G'`.
+
+See also: [`givens`](:func:`givens`)
+"""
 immutable Givens{T} <: AbstractRotation{T}
     i1::Int
     i2::Int
@@ -220,46 +230,116 @@ function givensAlgorithm{T<:AbstractFloat}(f::Complex{T}, g::Complex{T})
     return cs, sn, r
 end
 
+"""
+
+    givens{T}(f::T, g::T, i1::Integer, i2::Integer) -> (G::Givens, r::T)
+
+Computes the Givens rotation `G` and scalar `r` such that for any vector `x` where
+```
+x[i1] = f
+x[i2] = g
+```
+the result of the multiplication
+```
+y = G*x
+```
+has the property that
+```
+y[i1] = r
+y[i2] = 0
+```
+
+See also: [`LinAlg.Givens`](:class:`LinAlg.Givens`)
+"""
 function givens{T}(f::T, g::T, i1::Integer, i2::Integer)
-    if i1 >= i2
-        throw(ArgumentError("second index must be larger than the first"))
+    if i1 == i2
+        throw(ArgumentError("Indices must be distinct."))
     end
     c, s, r = givensAlgorithm(f, g)
+    if i1 > i2
+        s = -conj(s)
+        i1,i2 = i2,i1
+    end
     Givens(i1, i2, convert(T, c), convert(T, s)), r
 end
+"""
+    givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)
+
+Computes the Givens rotation `G` and scalar `r` such that the result of the multiplication
+```
+B = G*A
+```
+has the property that
+```
+B[i1,j] = r
+B[i2,j] = 0
+```
+
+See also: [`LinAlg.Givens`](:class:`LinAlg.Givens`)
+"""
+givens(A::AbstractMatrix, i1::Integer, i2::Integer, j::Integer) =
+    givens(A[i1,j], A[i2,j],i1,i2)
+
+
+"""
+    givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)
 
-function givens{T}(A::AbstractMatrix{T}, i1::Integer, i2::Integer, col::Integer)
-    if i1 >= i2
-        throw(ArgumentError("second index must be larger than the first"))
+Computes the Givens rotation `G` and scalar `r` such that the result of the multiplication
+```
+B = G*x
+```
+has the property that
+```
+B[i1] = r
+B[i2] = 0
+```
+
+See also: [`LinAlg.Givens`](:class:`LinAlg.Givens`)
+"""
+givens(x::AbstractVector, i1::Integer, i2::Integer) =
+    givens(x[i1], x[i2], i1, i2)
+
+
+function getindex(G::Givens, i::Integer, j::Integer)
+    if i == j
+        if i == G.i1 || i == G.i2
+            G.c
+        else
+            one(G.c)
+        end
+    elseif i == G.i1 && j == G.i2
+        G.s
+    elseif i == G.i2 && j == G.i1
+        -conj(G.s)
+    else
+        zero(G.s)
     end
-    c, s, r = givensAlgorithm(A[i1,col], A[i2,col])
-    Givens(i1, i2, convert(T, c), convert(T, s)), r
 end
 
-getindex(G::Givens, i::Integer, j::Integer) = i == j ? (i == G.i1 || i == G.i2 ? G.c : one(G.c)) : (i == G.i1 && j == G.i2 ? G.s : (i == G.i2 && j == G.i1 ? -G.s : zero(G.s)))
 
 A_mul_B!(G1::Givens, G2::Givens) = error("Operation not supported. Consider *")
+
 function A_mul_B!(G::Givens, A::AbstractVecOrMat)
     m, n = size(A, 1), size(A, 2)
     if G.i2 > m
         throw(DimensionMismatch("column indices for rotation are outside the matrix"))
     end
     @inbounds @simd for i = 1:n
-        tmp = G.c*A[G.i1,i] + G.s*A[G.i2,i]
-        A[G.i2,i] = G.c*A[G.i2,i] - conj(G.s)*A[G.i1,i]
-        A[G.i1,i] = tmp
+        a1, a2 = A[G.i1,i], A[G.i2,i]
+        A[G.i1,i] =       G.c *a1 + G.s*a2
+        A[G.i2,i] = -conj(G.s)*a1 + G.c*a2
     end
     return A
 end
-function A_mul_Bc!(A::AbstractVecOrMat, G::Givens)
+function A_mul_Bc!(A::AbstractMatrix, G::Givens)
     m, n = size(A, 1), size(A, 2)
     if G.i2 > n
         throw(DimensionMismatch("column indices for rotation are outside the matrix"))
     end
     @inbounds @simd for i = 1:m
-        tmp = G.c*A[i,G.i1] + conj(G.s)*A[i,G.i2]
-        A[i,G.i2] = G.c*A[i,G.i2] - G.s*A[i,G.i1]
-        A[i,G.i1] = tmp
+        a1, a2 = A[i,G.i1], A[i,G.i2]
+        A[i,G.i1] =  a1*G.c + a2*conj(G.s)
+        A[i,G.i2] = -a1*G.s + a2*G.c
     end
     return A
 end
diff --git a/base/linalg/lapack.jl b/base/linalg/lapack.jl
index 10724e6c70005..2a3416a444f3f 100644
--- a/base/linalg/lapack.jl
+++ b/base/linalg/lapack.jl
@@ -5,53 +5,107 @@ module LAPACK
 
 const liblapack = Base.liblapack_name
 
-import Base.blasfunc
+import Base.@blasfunc
 
 import ..LinAlg: BlasFloat, Char, BlasInt, LAPACKException,
-    DimensionMismatch, SingularException, PosDefException, chkstride1, chksquare
+    DimensionMismatch, SingularException, PosDefException, chkstride1, checksquare
+
+const VERSION = Ref{VersionNumber}()
+
+function __init__()
+    VERSION[] = VersionNumber(laver()...)
+end
 
 #Generic LAPACK error handlers
-macro assertargsok() #Handle only negative info codes - use only if positive info code is useful!
-    :(info[1]<0 && throw(ArgumentError("invalid argument #$(-info[1]) to LAPACK call")))
+"""
+Handle only negative LAPACK error codes
+
+*NOTE* use only if the positive error code is useful.
+"""
+function chkargsok(ret::BlasInt)
+    if ret < 0
+        throw(ArgumentError("invalid argument #$(-ret) to LAPACK call"))
+    end
 end
-macro lapackerror() #Handle all nonzero info codes
-    :(info[1]>0 ? throw(LAPACKException(info[1])) : @assertargsok )
+
+"Handle all nonzero info codes"
+function chklapackerror(ret::BlasInt)
+    if ret == 0
+        return
+    elseif ret < 0
+        throw(ArgumentError("invalid argument #$(-ret) to LAPACK call"))
+    else # ret > 0
+        throw(LAPACKException(ret))
+    end
 end
 
-macro assertnonsingular()
-    :(info[1]>0 && throw(SingularException(info[1])))
+function chknonsingular(ret::BlasInt)
+    if ret > 0
+        throw(SingularException(ret))
+    end
 end
-macro assertposdef()
-    :(info[1]>0 && throw(PosDefException(info[1])))
+
+function chkposdef(ret::BlasInt)
+    if ret > 0
+        throw(PosDefException(ret))
+    end
 end
 
-#Check that upper/lower (for special matrices) is correctly specified
+"Check that upper/lower (for special matrices) is correctly specified"
 function chkuplo(uplo::Char)
-    (uplo=='U' || uplo=='L') ||
-      throw(ArgumentError(string("uplo argument must be 'U' (upper) or 'L' (lower), got $uplo")))
+    if !(uplo == 'U' || uplo == 'L')
+        throw(ArgumentError("uplo argument must be 'U' (upper) or 'L' (lower), got $uplo"))
+    end
+    uplo
 end
 
-#Check that {c}transpose is correctly specified
+"Check that {c}transpose is correctly specified"
 function chktrans(trans::Char)
-    (trans=='N' || trans=='C' || trans=='T') ||
-      throw(ArgumentError(string("trans argument must be 'N' (no transpose), 'T' (transpose), or 'C' (conjugate transpose), got $trans")))
+    if !(trans == 'N' || trans == 'C' || trans == 'T')
+        throw(ArgumentError("trans argument must be 'N' (no transpose), 'T' (transpose), or 'C' (conjugate transpose), got $trans"))
+    end
+    trans
 end
 
-#Check that left/right hand side multiply is correctly specified
+"Check that left/right hand side multiply is correctly specified"
 function chkside(side::Char)
-    (side=='L' || side=='R') ||
-      throw(ArgumentError(string("side argument must be 'L' (left hand multiply) or 'R' (right hand multiply), got $side")))
+    if !(side == 'L' || side == 'R')
+        throw(ArgumentError("side argument must be 'L' (left hand multiply) or 'R' (right hand multiply), got $side"))
+    end
+    side
 end
 
-#Check that unit diagonal flag is correctly specified
+"Check that unit diagonal flag is correctly specified"
 function chkdiag(diag::Char)
-    (diag=='U' || diag=='N') ||
-      throw(ArgumentError(string("diag argument must be 'U' (unit diagonal) or 'N' (non-unit diagonal), got $diag")))
+    if !(diag == 'U' || diag =='N')
+        throw(ArgumentError("diag argument must be 'U' (unit diagonal) or 'N' (non-unit diagonal), got $diag"))
+    end
+    diag
 end
 
 subsetrows(X::AbstractVector, Y::AbstractArray, k) = Y[1:k]
 subsetrows(X::AbstractMatrix, Y::AbstractArray, k) = Y[1:k, :]
 
+function chkfinite(A::StridedMatrix)
+    for i = eachindex(A)
+        if !isfinite(A[i])
+            throw(ArgumentError("matrix contains NaNs"))
+        end
+    end
+    return true
+end
+
+# LAPACK version number
+function laver()
+    major = Ref{BlasInt}(0)
+    minor = Ref{BlasInt}(0)
+    patch = Ref{BlasInt}(0)
+    ccall((@blasfunc(ilaver_), liblapack), Void,
+        (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
+        major, minor, patch)
+    return major[], minor[], patch[]
+end
+
 # (GB) general banded matrices, LU decomposition and solver
 for (gbtrf, gbtrs, elty) in
     ((:dgbtrf_,:dgbtrs_,:Float64),
@@ -67,17 +121,18 @@ for (gbtrf, gbtrs, elty) in
         #       DOUBLE PRECISION   AB( LDAB, * )
         function gbtrf!(kl::Integer, ku::Integer, m::Integer, AB::StridedMatrix{$elty})
             chkstride1(AB)
-            info = Array(BlasInt, 1)
             n    = size(AB, 2)
             mnmn = min(m, n)
             ipiv = similar(AB, BlasInt, mnmn)
-            ccall(($(blasfunc(gbtrf)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gbtrf), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &m, &n, &kl, &ku, AB, &max(1,stride(AB,2)), ipiv, info)
-            @lapackerror
+            chklapackerror(info[])
             AB, ipiv
         end
+
         # SUBROUTINE DGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB, INFO)
         # *     .. Scalar Arguments ..
         #       CHARACTER          TRANS
@@ -90,23 +145,44 @@ for (gbtrf, gbtrs, elty) in
                         B::StridedVecOrMat{$elty})
             chkstride1(AB, B)
             chktrans(trans)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             n    = size(AB,2)
             if m != n || m != size(B,1)
                 throw(DimensionMismatch("Matrix AB has dimensions $(size(AB)), but right hand side matrix B has dimensions $(size(B))"))
             end
-            ccall(($(blasfunc(gbtrs)), liblapack), Void,
+            ccall((@blasfunc($gbtrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},   Ptr{BlasInt},
                    Ptr{BlasInt}),
                   &trans, &n, &kl, &ku, &size(B,2), AB, &max(1,stride(AB,2)), ipiv,
                   B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
 
+"""
+    gbtrf!(kl, ku, m, AB) -> (AB, ipiv)
+
+Compute the LU factorization of a banded matrix `AB`. `kl` is the first
+subdiagonal containing a nonzero band, `ku` is the last superdiagonal
+containing one, and `m` is the first dimension of the matrix `AB`. Returns
+the LU factorization in-place and `ipiv`, the vector of pivots used.
+"""
+gbtrf!(kl::Integer, ku::Integer, m::Integer, AB::StridedMatrix)
+
+"""
+    gbtrs!(trans, kl, ku, m, AB, ipiv, B)
+
+Solve the equation `AB * X = B`. `trans` determines the orientation of `AB`. It may
+be `N` (no transpose), `T` (transpose), or `C` (conjugate transpose). `kl` is the
+first subdiagonal containing a nonzero band, `ku` is the last superdiagonal
+containing one, and `m` is the first dimension of the matrix `AB`. `ipiv` is the vector
+of pivots returned from `gbtrf!`. Returns the vector or matrix `X`, overwriting `B` in-place.
+"""
+gbtrs!(trans::Char, kl::Integer, ku::Integer, m::Integer, AB::StridedMatrix, ipiv::Vector{BlasInt}, B::StridedVecOrMat)
+
 ## (GE) general matrices: balancing and back-transforming
 for (gebal, gebak, elty, relty) in
     ((:dgebal_, :dgebak_, :Float64, :Float64),
@@ -122,18 +198,20 @@ for (gebal, gebak, elty, relty) in
         #      DOUBLE PRECISION   A( LDA, * ), SCALE( * )
         function gebal!(job::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
-            info    = Array(BlasInt, 1)
-            ihi     = Array(BlasInt, 1)
-            ilo     = Array(BlasInt, 1)
-            scale   = similar(A, $relty, n)
-            ccall(($(blasfunc(gebal)), liblapack), Void,
+            n = checksquare(A)
+            chkfinite(A) # balancing routines don't support NaNs and Infs
+            ihi = Array(BlasInt, 1)
+            ilo = Array(BlasInt, 1)
+            scale = similar(A, $relty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gebal), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{BlasInt}),
                   &job, &n, A, &max(1,stride(A,2)), ilo, ihi, scale, info)
-            @lapackerror
+            chklapackerror(info[])
             ilo[1], ihi[1], scale
         end
+
         #     SUBROUTINE DGEBAK( JOB, SIDE, N, ILO, IHI, SCALE, M, V, LDV, INFO )
         #*     .. Scalar Arguments ..
         #      CHARACTER          JOB, SIDE
@@ -145,28 +223,42 @@ for (gebal, gebak, elty, relty) in
                         V::StridedMatrix{$elty})
             chkstride1(V)
             chkside(side)
-            n = chksquare(V)
-            info    = Array(BlasInt, 1)
-            ccall(($(blasfunc(gebak)), liblapack), Void,
+            chkfinite(V) # balancing routines don't support NaNs and Infs
+            n = checksquare(V)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gebak), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{$relty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &job, &side, &size(V,1), &ilo, &ihi, scale, &n, V, &max(1,stride(V,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             V
         end
     end
 end
 
+"""
+    gebal!(job, A) -> (ilo, ihi, scale)
+
+Balance the matrix `A` before computing its eigensystem or Schur factorization.
+`job` can be one of `N` (`A` will not be permuted or scaled), `P` (`A` will only
+be permuted), `S` (`A` will only be scaled), or `B` (`A` will be both permuted
+and scaled). Modifies `A` in-place and returns `ilo`, `ihi`, and `scale`. If
+permuting was turned on, `A[i,j] = 0` if `j > i` and `1 < j < ilo` or `j > ihi`.
+`scale` contains information about the scaling/permutations performed.
+"""
+gebal!(job::Char, A::StridedMatrix)
+
+"""
+    gebak!(job, side, ilo, ihi, scale, V)
+
+Transform the eigenvectors `V` of a matrix balanced using `gebal!` to
+the unscaled/unpermuted eigenvectors of the original matrix. Modifies `V`
+in-place. `side` can be `L` (left eigenvectors are transformed) or `R`
+(right eigenvectors are transformed).
+"""
+gebak!(job::Char, side::Char, ilo::BlasInt, ihi::BlasInt, scale::Vector, V::StridedMatrix)
+
 # (GE) general matrices, direct decompositions
-# gebrd - reduction to bidiagonal form Q'*A*P=B where Q and P are orthogonal
-# gelqf - unpivoted LQ decomposition
-# geqlf - unpivoted QL decomposition
-# geqrf - unpivoted QR decomposition
-# gegp3 - pivoted QR decomposition
-# geqrt - unpivoted QR by WY representation
-# geqrt3! - recursive algorithm producing compact WY representation of Q
-# gerqf - unpivoted RQ decomposition
-# getrf - LU decomposition
 #
 # These mutating functions take as arguments all the values they
 # return, even if the value of the function does not depend on them
@@ -196,23 +288,24 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             taup  = similar(A, $elty, k)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(gebrd)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($gebrd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{$elty},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                      &m, &n, A, &max(1,stride(A,2)),
                      d, e, tauq, taup,
                      work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, d, e, tauq, taup
         end
+
         # SUBROUTINE DGELQF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, LDA, LWORK, M, N
@@ -220,7 +313,6 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
         #       DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
         function gelqf!(A::StridedMatrix{$elty}, tau::Vector{$elty})
             chkstride1(A)
-            info  = Array(BlasInt, 1)
             m     = BlasInt(size(A, 1))
             n     = BlasInt(size(A, 2))
             lda   = BlasInt(max(1,stride(A, 2)))
@@ -228,20 +320,22 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             lwork = BlasInt(-1)
-            work  = Array($elty, (1,))
-            for i in 1:2                # first call returns lwork as work[1]
-                ccall(($(blasfunc(gelqf)), liblapack), Void,
+            work  = Array($elty, 1)
+            info  = Ref{BlasInt}()
+            for i = 1:2  # first call returns lwork as work[1]
+                ccall((@blasfunc($gelqf), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, A, &lda, tau, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, tau
         end
+
         # SUBROUTINE DGEQLF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, LDA, LWORK, M, N
@@ -249,7 +343,6 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
         #       DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
         function geqlf!(A::StridedMatrix{$elty}, tau::Vector{$elty})
             chkstride1(A)
-            info  = Array(BlasInt, 1)
             m     = BlasInt(size(A, 1))
             n     = BlasInt(size(A, 2))
             lda   = BlasInt(max(1,stride(A, 2)))
@@ -257,20 +350,22 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             lwork = BlasInt(-1)
-            work  = Array($elty, (1,))
-            for i in 1:2                # first call returns lwork as work[1]
-                ccall(($(blasfunc(geqlf)), liblapack), Void,
+            work  = Array($elty, 1)
+            info  = Ref{BlasInt}()
+            for i = 1:2  # first call returns lwork as work[1]
+                ccall((@blasfunc($geqlf), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, A, &lda, tau, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, tau
         end
+
         # SUBROUTINE DGEQP3( M, N, A, LDA, JPVT, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, LDA, LWORK, M, N
@@ -279,25 +374,27 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
         #       DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
         function geqp3!(A::StridedMatrix{$elty}, jpvt::Vector{BlasInt}, tau::Vector{$elty})
             chkstride1(A)
-            m, n  = size(A)
+            m,n = size(A)
             if length(tau) != min(m,n)
                 throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             if length(jpvt) != n
                 throw(DimensionMismatch("jpvt has length $(length(jpvt)), but needs length $n"))
             end
-            lda   = stride(A,2)
+            lda = stride(A,2)
             if lda == 0
                 return A, tau, jpvt
             end # Early exit
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
             cmplx = eltype(A)<:Complex
-            if cmplx; rwork = Array($relty, 2n); end
-            for i in 1:2
+            if cmplx
+                rwork = Array($relty, 2n)
+            end
+            info = Ref{BlasInt}()
+            for i = 1:2
                 if cmplx
-                    ccall(($(blasfunc(geqp3)), liblapack), Void,
+                    ccall((@blasfunc($geqp3), liblapack), Void,
                           (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{$relty}, Ptr{BlasInt}),
@@ -305,7 +402,7 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                           jpvt, tau, work, &lwork,
                           rwork, info)
                 else
-                    ccall(($(blasfunc(geqp3)), liblapack), Void,
+                    ccall((@blasfunc($geqp3), liblapack), Void,
                           (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{BlasInt}),
@@ -313,15 +410,16 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                           jpvt, tau, work,
                           &lwork, info)
                 end
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work  = Array($elty, lwork)
                 end
             end
             return A, tau, jpvt
         end
-        function geqrt!(A::StridedMatrix{$elty}, T::Matrix{$elty})
+
+        function geqrt!(A::StridedMatrix{$elty}, T::StridedMatrix{$elty})
             chkstride1(A)
             m, n = size(A)
             minmn = min(m, n)
@@ -332,21 +430,24 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             lda = max(1, stride(A,2))
             work = Array($elty, nb*n)
             if n > 0
-                info = Array(BlasInt, 1)
-                ccall(($(blasfunc(geqrt)), liblapack), Void,
+                info = Ref{BlasInt}()
+                ccall((@blasfunc($geqrt), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}),
                      &m, &n, &nb, A,
                      &lda, T, &max(1,stride(T,2)), work,
                      info)
-                @lapackerror
+                chklapackerror(info[])
             end
             A, T
         end
-        function geqrt3!(A::StridedMatrix{$elty}, T::Matrix{$elty})
-            chkstride1(A); chkstride1(T)
-            m, n = size(A); p, q = size(T)
+
+        function geqrt3!(A::StridedMatrix{$elty}, T::StridedMatrix{$elty})
+            chkstride1(A)
+            chkstride1(T)
+            m, n = size(A)
+            p, q = size(T)
             if m < n
                 throw(DimensionMismatch("Input matrix A has dimensions ($m,$n), but should have more rows than columns"))
             end
@@ -354,16 +455,17 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
                 throw(DimensionMismatch("Block reflector T has dimensions ($p,$q), but should have dimensions ($n,$n)"))
             end
             if n > 0
-                info = Array(BlasInt, 1)
-                ccall(($(blasfunc(geqrt3)), liblapack), Void,
+                info = Ref{BlasInt}()
+                ccall((@blasfunc($geqrt3), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                      &m, &n, A, &max(1, stride(A, 2)),
                      T, &max(1,stride(T,2)), info)
-                @lapackerror
+                chklapackerror(info[])
             end
             A, T
         end
+
         ## geqrfp! - positive elements on diagonal of R - not defined yet
         # SUBROUTINE DGEQRFP( M, N, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
@@ -378,20 +480,21 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2                # first call returns lwork as work[1]
-                ccall(($(blasfunc(geqrf)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2                # first call returns lwork as work[1]
+                ccall((@blasfunc($geqrf), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, A, &max(1,stride(A,2)), tau, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, tau
         end
+
         # SUBROUTINE DGERQF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, LDA, LWORK, M, N
@@ -399,26 +502,27 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
         #       DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
         function gerqf!(A::StridedMatrix{$elty},tau::Vector{$elty})
             chkstride1(A)
-            info  = Array(BlasInt, 1)
             m, n  = size(A)
             if length(tau) != min(m,n)
                 throw(DimensionMismatch("tau has length $(length(tau)), but needs length $(min(m,n))"))
             end
             lwork = BlasInt(-1)
             work  = Array($elty, 1)
-            for i in 1:2                # first call returns lwork as work[1]
-                ccall(($(blasfunc(gerqf)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2                # first call returns lwork as work[1]
+                ccall((@blasfunc($gerqf), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, A, &max(1,stride(A,2)), tau, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, tau
         end
+
         # SUBROUTINE DGETRF( M, N, A, LDA, IPIV, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, LDA, M, N
@@ -427,33 +531,213 @@ for (gebrd, gelqf, geqlf, geqrf, geqp3, geqrt, geqrt3, gerqf, getrf, elty, relty
         #       DOUBLE PRECISION   A( LDA, * )
         function getrf!(A::StridedMatrix{$elty})
             chkstride1(A)
-            info = Array(BlasInt, 1)
             m, n = size(A)
             lda  = max(1,stride(A, 2))
             ipiv = similar(A, BlasInt, min(m,n))
-            ccall(($(blasfunc(getrf)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($getrf), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                    Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &m, &n, A, &lda, ipiv, info)
-            @assertargsok
-            A, ipiv, info[1] #Error code is stored in LU factorization type
+            chkargsok(info[])
+            A, ipiv, info[] #Error code is stored in LU factorization type
         end
     end
 end
 
+"""
+    gebrd!(A) -> (A, d, e, tauq, taup)
+
+Reduce `A` in-place to bidiagonal form `A = QBP'`. Returns `A`, containing the
+bidiagonal matrix `B`; `d`, containing the diagonal elements of `B`; `e`,
+containing the off-diagonal elements of `B`; `tauq`, containing the
+elementary reflectors representing `Q`; and `taup`, containing the
+elementary reflectors representing `P`.
+"""
+gebrd!(A::StridedMatrix)
+
+"""
+    gelqf!(A, tau)
+
+Compute the `LQ` factorization of `A`, `A = LQ`. `tau` contains scalars
+which parameterize the elementary reflectors of the factorization. `tau`
+must have length greater than or equal to the smallest dimension of `A`.
+
+Returns
+`A` and `tau` modified in-place.
+"""
+gelqf!(A::StridedMatrix, tau::Vector)
+
+"""
+    geqlf!(A, tau)
+
+Compute the `QL` factorization of `A`, `A = QL`. `tau` contains scalars
+which parameterize the elementary reflectors of the factorization. `tau`
+must have length greater than or equal to the smallest dimension of `A`.
+
+Returns `A` and `tau` modified in-place.
+"""
+geqlf!(A::StridedMatrix, tau::Vector)
+
+"""
+    geqp3!(A, jpvt, tau)
+
+Compute the pivoted `QR` factorization of `A`, `AP = QR` using BLAS level 3.
+`P` is a pivoting matrix, represented by `jpvt`. `tau` stores the elementary
+reflectors. `jpvt` must have length length greater than or equal to `n` if `A`
+is an `(m x n)` matrix. `tau` must have length greater than or equal to the
+smallest dimension of `A`.
+
+`A`, `jpvt`, and `tau` are modified in-place.
+"""
+geqp3!(A::StridedMatrix, jpvt::Vector{BlasInt}, tau::Vector)
+
+"""
+    geqrt!(A, T)
+
+Compute the blocked `QR` factorization of `A`, `A = QR`. `T` contains upper
+triangular block reflectors which parameterize the elementary reflectors of
+the factorization. The first dimension of `T` sets the block size and it must
+be between 1 and `n`. The second dimension of `T` must equal the smallest
+dimension of `A`.
+
+Returns `A` and `T` modified in-place.
+"""
+geqrt!(A::StridedMatrix, T::StridedMatrix)
+
+"""
+    geqrt3!(A, T)
+
+Recursively computes the blocked `QR` factorization of `A`, `A = QR`. `T`
+contains upper triangular block reflectors which parameterize the
+elementary reflectors of the factorization.  The first dimension of `T` sets the
+block size and it must be between 1 and `n`. The second dimension of `T` must
+equal the smallest dimension of `A`.
+
+Returns `A` and `T` modified in-place.
+"""
+geqrt3!(A::StridedMatrix, T::StridedMatrix)
+
+"""
+    geqrf!(A, tau)
+
+Compute the `QR` factorization of `A`, `A = QR`. `tau` contains scalars
+which parameterize the elementary reflectors of the factorization. `tau`
+must have length greater than or equal to the smallest dimension of `A`.
+
+Returns `A` and `tau` modified in-place.
+"""
+geqrf!(A::StridedMatrix, tau::Vector)
+
+"""
+    gerqf!(A, tau)
+
+Compute the `RQ` factorization of `A`, `A = RQ`. `tau` contains scalars
+which parameterize the elementary reflectors of the factorization. `tau`
+must have length greater than or equal to the smallest dimension of `A`.
+
+Returns `A` and `tau` modified in-place.
+"""
+gerqf!(A::StridedMatrix, tau::Vector)
+
+"""
+    getrf!(A) -> (A, ipiv, info)
+
+Compute the pivoted `LU` factorization of `A`, `A = LU`.
+
+Returns `A`, modified in-place, `ipiv`, the pivoting information, and an `info`
+code which indicates success (`info = 0`), a singular value in `U`
+(`info = i`, in which case `U[i,i]` is singular), or an error code (`info < 0`).
+"""
+getrf!(A::StridedMatrix, tau::Vector)
+
+"""
+    gelqf!(A) -> (A, tau)
+
+Compute the `LQ` factorization of `A`, `A = LQ`.
+
+Returns `A`, modified in-place, and `tau`, which contains scalars
+which parameterize the elementary reflectors of the factorization.
+"""
 gelqf!{T<:BlasFloat}(A::StridedMatrix{T}) = ((m,n)=size(A); gelqf!(A,similar(A,T,min(m,n))))
+
+"""
+    geqlf!(A) -> (A, tau)
+
+Compute the `QL` factorization of `A`, `A = QL`.
+
+Returns `A`, modified in-place, and `tau`, which contains scalars
+which parameterize the elementary reflectors of the factorization.
+"""
 geqlf!{T<:BlasFloat}(A::StridedMatrix{T}) = ((m,n)=size(A); geqlf!(A,similar(A,T,min(m,n))))
+
+"""
+    geqrt!(A, nb) -> (A, T)
+
+Compute the blocked `QR` factorization of `A`, `A = QR`. `nb` sets the block size
+and it must be between 1 and `n`, the second dimension of `A`.
+
+Returns `A`, modified in-place, and `T`, which contains upper
+triangular block reflectors which parameterize the elementary reflectors of
+the factorization.
+"""
 geqrt!{T<:BlasFloat}(A::StridedMatrix{T}, nb::Integer) = geqrt!(A,similar(A,T,nb,minimum(size(A))))
+
+"""
+    geqrt3!(A) -> (A, T)
+
+Recursively computes the blocked `QR` factorization of `A`, `A = QR`.
+
+Returns `A`, modified in-place, and `T`, which contains upper triangular block
+reflectors which parameterize the elementary reflectors of the factorization.
+"""
 geqrt3!{T<:BlasFloat}(A::StridedMatrix{T}) = (n=size(A,2); geqrt3!(A,similar(A,T,n,n)))
+
+"""
+    geqrf!(A) -> (A, tau)
+
+Compute the `QR` factorization of `A`, `A = QR`.
+
+Returns `A`, modified in-place, and `tau`, which contains scalars
+which parameterize the elementary reflectors of the factorization.
+"""
 geqrf!{T<:BlasFloat}(A::StridedMatrix{T}) = ((m,n)=size(A); geqrf!(A,similar(A,T,min(m,n))))
+
+"""
+    gerqf!(A) -> (A, tau)
+
+Compute the `RQ` factorization of `A`, `A = RQ`.
+
+Returns `A`, modified in-place, and `tau`, which contains scalars
+which parameterize the elementary reflectors of the factorization.
+"""
 gerqf!{T<:BlasFloat}(A::StridedMatrix{T}) = ((m,n)=size(A); gerqf!(A,similar(A,T,min(m,n))))
 
+"""
+    geqp3!(A, jpvt) -> (A, jpvt, tau)
+
+Compute the pivoted `QR` factorization of `A`, `AP = QR` using BLAS level 3.
+`P` is a pivoting matrix, represented by `jpvt`. `jpvt` must have length
+greater than or equal to `n` if `A` is an `(m x n)` matrix.
+
+Returns `A` and `jpvt`, modified in-place, and `tau`, which stores the elementary
+reflectors.
+"""
 function geqp3!{T<:BlasFloat}(A::StridedMatrix{T},jpvt::Vector{BlasInt})
     m,n = size(A)
     geqp3!(A,jpvt,similar(A,T,min(m,n)))
 end
+
+"""
+    geqp3!(A) -> (A, jpvt, tau)
+
+Compute the pivoted `QR` factorization of `A`, `AP = QR` using BLAS level 3.
+
+Returns `A`, modified in-place, `jpvt`, which represents the pivoting matrix `P`,
+and `tau`, which stores the elementary reflectors.
+"""
 function geqp3!{T<:BlasFloat}(A::StridedMatrix{T})
-    m,n=size(A)
+    m,n = size(A)
     geqp3!(A,zeros(BlasInt,n),similar(A,T,min(m,n)))
 end
 
@@ -464,13 +748,13 @@ for (tzrzf, ormrz, elty) in
      (:ztzrzf_,:zunmrz_,:Complex128),
      (:ctzrzf_,:cunmrz_,:Complex64))
     @eval begin
- #      *       SUBROUTINE ZTZRZF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
- #   22 *
- #   23 *       .. Scalar Arguments ..
- #   24 *       INTEGER            INFO, LDA, LWORK, M, N
- #   25 *       ..
- #   26 *       .. Array Arguments ..
- #   27 *       COMPLEX*16         A( LDA, * ), TAU( * ), WORK( * )
+         #       SUBROUTINE ZTZRZF( M, N, A, LDA, TAU, WORK, LWORK, INFO )
+         #
+         #       .. Scalar Arguments ..
+         #       INTEGER            INFO, LDA, LWORK, M, N
+         #       ..
+         #       .. Array Arguments ..
+         #       COMPLEX*16         A( LDA, * ), TAU( * ), WORK( * )
         function tzrzf!(A::StridedMatrix{$elty})
             m, n = size(A)
             if n < m
@@ -478,33 +762,35 @@ for (tzrzf, ormrz, elty) in
             end
             lda = max(1, m)
             tau = similar(A, $elty, m)
-            work = Array($elty, 1)
-            lwork = -1
-            info = Array(BlasInt, 1)
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(tzrzf)), liblapack), Void,
+                ccall((@blasfunc($tzrzf), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                     &m, &n, A, &lda,
                     tau, work, &lwork, info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             A, tau
         end
-   # 21 *       SUBROUTINE ZUNMRZ( SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, LDC,
-   # 22 *                          WORK, LWORK, INFO )
-   # 23 *
-   # 24 *       .. Scalar Arguments ..
-   # 25 *       CHARACTER          SIDE, TRANS
-   # 26 *       INTEGER            INFO, K, L, LDA, LDC, LWORK, M, N
-   # 27 *       ..
-   # 28 *       .. Array Arguments ..
-   # 29 *       COMPLEX*16         A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
-        function ormrz!(side::Char, trans::Char, A::StridedMatrix{$elty}, tau::StridedVector{$elty}, C::StridedMatrix{$elty})
+
+        #       SUBROUTINE ZUNMRZ( SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, LDC,
+        #                          WORK, LWORK, INFO )
+        #
+        #       .. Scalar Arguments ..
+        #       CHARACTER          SIDE, TRANS
+        #       INTEGER            INFO, K, L, LDA, LDC, LWORK, M, N
+        #       ..
+        #       .. Array Arguments ..
+        #       COMPLEX*16         A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
+        function ormrz!(side::Char, trans::Char, A::StridedMatrix{$elty},
+                        tau::StridedVector{$elty}, C::StridedMatrix{$elty})
             chktrans(trans)
             chkside(side)
             m, n = size(C)
@@ -512,11 +798,11 @@ for (tzrzf, ormrz, elty) in
             l = size(A, 2) - size(A, 1)
             lda = max(1, stride(A,2))
             ldc = max(1, stride(C,2))
-            work = Array($elty, 1)
-            lwork = -1
-            info = Array(BlasInt, 1)
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(ormrz)), liblapack), Void,
+                ccall((@blasfunc($ormrz), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                      Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -525,17 +811,37 @@ for (tzrzf, ormrz, elty) in
                     &k, &l, A, &lda,
                     tau, C, &ldc, work,
                     &lwork, info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             C
         end
     end
 end
 
+"""
+    ormrz!(side, trans, A, tau, C)
+
+Multiplies the matrix `C` by `Q` from the transformation supplied by
+`tzrzf!`. Depending on `side` or `trans` the multiplication can be
+left-sided (`side = L, Q*C`) or right-sided (`side = R, C*Q`) and `Q`
+can be unmodified (`trans = N`), transposed (`trans = T`), or conjugate
+transposed (`trans = C`). Returns matrix `C` which is modified in-place
+with the result of the multiplication.
+"""
+ormrz!(side::Char, trans::Char, A::StridedMatrix, tau::StridedVector, C::StridedMatrix)
+
+"""
+    tzrzf!(A) -> (A, tau)
+
+Transforms the upper trapezoidal matrix `A` to upper triangular form in-place.
+Returns `A` and `tau`, the scalar parameters for the elementary reflectors
+of the transformation.
+"""
+tzrzf!(A::StridedMatrix)
 
 ## (GE) general matrices, solvers with factorization, solver and inverse
 for (gels, gesv, getrs, getri, elty) in
@@ -556,33 +862,35 @@ for (gels, gesv, getrs, getri, elty) in
             if size(B,1) != (btrn ? n : m)
                 throw(DimensionMismatch("Matrix A has dimensions ($m,$n), transposed: $btrn, but leading dimension of B is $(size(B,1))"))
             end
-            info  = Array(BlasInt, 1)
+            info  = Ref{BlasInt}()
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            for i in 1:2
-                ccall(($(blasfunc(gels)), liblapack), Void,
+            for i = 1:2
+                ccall((@blasfunc($gels), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &(btrn?'T':'N'), &m, &n, &size(B,2), A, &max(1,stride(A,2)),
                       B, &max(1,stride(B,2)), work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             k   = min(m, n)
             F   = m < n ? tril(A[1:k, 1:k]) : triu(A[1:k, 1:k])
-            ssr = [begin
+            ssr = Array($elty, size(B,2))
+            for i = 1:size(B,2)
                 x = zero($elty)
-                for j=k+1:size(B,1)
-                    x += abs2(B[j, i])
+                for j = k+1:size(B,1)
+                    x += abs2(B[j,i])
                 end
-                x
-            end for i=1:size(B,2)]
+                ssr[i] = x
+            end
             F, subsetrows(B, B, k), ssr
         end
+
         # SUBROUTINE DGESV( N, NRHS, A, LDA, IPIV, B, LDB, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, LDA, LDB, N, NRHS
@@ -592,19 +900,20 @@ for (gels, gesv, getrs, getri, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * )
         function gesv!(A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(A, B)
-            n = chksquare(A)
+            n = checksquare(A)
             if size(B,1) != n
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)), but needs $n"))
             end
-            ipiv    = similar(A, BlasInt, n)
-            info    = Array(BlasInt, 1)
-            ccall(($(blasfunc(gesv)), liblapack), Void,
+            ipiv = similar(A, BlasInt, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gesv), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B, A, ipiv
         end
+
         #     SUBROUTINE DGETRS( TRANS, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
         #*     .. Scalar Arguments ..
         #      CHARACTER          TRANS
@@ -615,19 +924,20 @@ for (gels, gesv, getrs, getri, elty) in
         function getrs!(trans::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
             chktrans(trans)
             chkstride1(A, B)
-            n = chksquare(A)
+            n = checksquare(A)
             if n != size(B, 1)
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)), but needs $n"))
             end
             nrhs = size(B, 2)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(getrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($getrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &trans, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
+
         #     SUBROUTINE DGETRI( N, A, LDA, IPIV, WORK, LWORK, INFO )
         #*     .. Scalar Arguments ..
         #      INTEGER            INFO, LDA, LWORK, N
@@ -636,21 +946,21 @@ for (gels, gesv, getrs, getri, elty) in
         #      DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function getri!(A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             if n != length(ipiv)
                 throw(DimensionMismatch("ipiv has length $(length(ipiv)), but needs $n"))
             end
-            lda     = max(1,stride(A, 2))
-            info    = Array(BlasInt, 1)
-            lwork   = -1
-            work    = Array($elty, 1)
-            for i in 1:2
-                ccall(($(blasfunc(getri)), liblapack), Void,
+            lda = max(1,stride(A, 2))
+            lwork = BlasInt(-1)
+            work  = Array($elty, 1)
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($getri), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &n, A, &lda, ipiv, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work  = Array($elty, lwork)
                 end
@@ -659,6 +969,50 @@ for (gels, gesv, getrs, getri, elty) in
         end
     end
 end
+
+"""
+    gels!(trans, A, B) -> (F, B, ssr)
+
+Solves the linear equation `A * X = B`, `A.' * X =B`, or `A' * X = B` using
+a QR or LQ factorization. Modifies the matrix/vector `B` in place with the
+solution. `A` is overwritten with its `QR` or `LQ` factorization. `trans`
+may be one of `N` (no modification), `T` (transpose), or `C` (conjugate
+transpose). `gels!` searches for the minimum norm/least squares solution.
+`A` may be under or over determined. The solution is returned in `B`.
+"""
+gels!(trans::Char, A::StridedMatrix, B::StridedVecOrMat)
+
+"""
+    gesv!(A, B) -> (B, A, ipiv)
+
+Solves the linear equation `A * X = B` where `A` is a square matrix using
+the `LU` factorization of `A`. `A` is overwritten with its `LU`
+factorization and `B` is overwritten with the solution `X`. `ipiv` contains the
+pivoting information for the `LU` factorization of `A`.
+"""
+gesv!(A::StridedMatrix, B::StridedVecOrMat)
+
+"""
+    getrs!(trans, A, ipiv, B)
+
+Solves the linear equation `A * X = B`, `A.' * X =B`, or `A' * X = B` for
+square `A`. Modifies the matrix/vector `B` in place with the solution. `A`
+is the `LU` factorization from `getrf!`, with `ipiv` the pivoting
+information. `trans` may be one of `N` (no modification), `T` (transpose),
+or `C` (conjugate transpose).
+"""
+getrs!(trans::Char, A::StridedMatrix, ipiv::Vector{BlasInt}, B::StridedVecOrMat)
+
+"""
+    getri!(A, ipiv)
+
+Computes the inverse of `A`, using its `LU` factorization found by
+`getrf!`. `ipiv` is the pivot information output and `A`
+contains the `LU` factorization of `getrf!`. `A` is overwritten with
+its inverse.
+"""
+getri!(A::StridedMatrix, ipiv::Vector{BlasInt})
+
 for (gesvx, elty) in
     ((:dgesvx_,:Float64),
      (:sgesvx_,:Float32))
@@ -679,23 +1033,23 @@ for (gesvx, elty) in
         #    $                   WORK( * ), X( LDX, *
         #
         function gesvx!(fact::Char, trans::Char, A::StridedMatrix{$elty},
-               AF::StridedMatrix{$elty}, ipiv::Vector{BlasInt}, equed::Char,
-               R::Vector{$elty}, C::Vector{$elty}, B::StridedVecOrMat{$elty})
+                        AF::StridedMatrix{$elty}, ipiv::Vector{BlasInt}, equed::Char,
+                        R::Vector{$elty}, C::Vector{$elty}, B::StridedVecOrMat{$elty})
             chktrans(trans)
-            n   = chksquare(A)
-            lda = stride(A,2)
-            n   = chksquare(AF)
+            n    = checksquare(A)
+            lda  = stride(A,2)
+            n    = checksquare(AF)
             ldaf = stride(AF,2)
             nrhs = size(B,2)
-            ldb = stride(B,2)
-            rcond     = Array($elty, 1)
-            ferr      = similar(A, $elty, nrhs)
-            berr      = similar(A, $elty, nrhs)
-            work      = Array($elty, 4n)
-            iwork     = Array(BlasInt, n)
-            info      = Array(BlasInt, 1)
+            ldb  = stride(B,2)
+            rcond = Array($elty, 1)
+            ferr  = similar(A, $elty, nrhs)
+            berr  = similar(A, $elty, nrhs)
+            work  = Array($elty, 4n)
+            iwork = Array(BlasInt, n)
+            info  = Ref{BlasInt}()
             X = similar(A, $elty, n, nrhs)
-            ccall(($(blasfunc(gesvx)), liblapack), Void,
+            ccall((@blasfunc($gesvx), liblapack), Void,
               (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                Ptr{UInt8}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
@@ -703,17 +1057,26 @@ for (gesvx, elty) in
                Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
               &fact, &trans, &n, &nrhs, A, &lda, AF, &ldaf, ipiv, &equed, R, C, B,
               &ldb, X, &n, rcond, ferr, berr, work, iwork, info)
-            @lapackerror
-            if info[1] == n+1 warn("Matrix is singular to working precision.")
-            else @assertnonsingular
+            chklapackerror(info[])
+            if info[] == n + 1
+                warn("matrix is singular to working precision")
+            else
+                chknonsingular(info[])
             end
             #WORK(1) contains the reciprocal pivot growth factor norm(A)/norm(U)
             X, equed, R, C, B, rcond[1], ferr, berr, work[1]
         end
-        #Wrapper for the no-equilibration, no-transpose calculation
+
         function gesvx!(A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
-            n=size(A,1)
-            X, equed, R, C, B, rcond, ferr, berr, rpgf = gesvx!('N', 'N', A, similar(A, $elty, n, n), similar(A, BlasInt, n), 'N', similar(A, $elty, n),  similar(A, $elty, n), B)
+            n = size(A,1)
+            X, equed, R, C, B, rcond, ferr, berr, rpgf =
+                gesvx!('N', 'N', A,
+                       similar(A, $elty, n, n),
+                       similar(A, BlasInt, n),
+                       'N',
+                       similar(A, $elty, n),
+                       similar(A, $elty, n),
+                       B)
             X, rcond, ferr, berr, rpgf
         end
     end
@@ -738,23 +1101,23 @@ for (gesvx, elty, relty) in
         #     COMPLEX*16         A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
         #    $                   WORK( * ), X( LDX, * )
         function gesvx!(fact::Char, trans::Char, A::StridedMatrix{$elty},
-             AF::StridedMatrix{$elty}, ipiv::Vector{BlasInt}, equed::Char,
-             R::Vector{$relty}, C::Vector{$relty}, B::StridedVecOrMat{$elty})
+                        AF::StridedMatrix{$elty}, ipiv::Vector{BlasInt}, equed::Char,
+                        R::Vector{$relty}, C::Vector{$relty}, B::StridedVecOrMat{$elty})
             chktrans(trans)
-            n   = chksquare(A)
+            n   = checksquare(A)
             lda = stride(A,2)
-            n   = chksquare(AF)
+            n   = checksquare(AF)
             ldaf = stride(AF,2)
             nrhs = size(B,2)
             ldb = stride(B,2)
-            rcond     = Array($relty, 1)
-            ferr      = similar(A, $relty, nrhs)
-            berr      = similar(A, $relty, nrhs)
-            work      = Array($elty, 2n)
-            rwork     = Array($relty, 2n)
-            info      = Array(BlasInt, 1)
+            rcond = Array($relty, 1)
+            ferr  = similar(A, $relty, nrhs)
+            berr  = similar(A, $relty, nrhs)
+            work  = Array($elty, 2n)
+            rwork = Array($relty, 2n)
+            info  = Ref{BlasInt}()
             X = similar(A, $elty, n, nrhs)
-            ccall(($(blasfunc(gesvx)), liblapack), Void,
+            ccall((@blasfunc($gesvx), liblapack), Void,
               (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                Ptr{UInt8}, Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt},
@@ -762,20 +1125,65 @@ for (gesvx, elty, relty) in
                Ptr{$elty}, Ptr{$relty}, Ptr{BlasInt}),
               &fact, &trans, &n, &nrhs, A, &lda, AF, &ldaf, ipiv, &equed, R, C, B,
               &ldb, X, &n, rcond, ferr, berr, work, rwork, info)
-            @lapackerror
-            if info[1] == n+1 warn("Matrix is singular to working precision.")
-            else @assertnonsingular end
+            chklapackerror(info[])
+            if info[] == n + 1
+                warn("matrix is singular to working precision")
+            else
+                chknonsingular(info[])
+            end
             #RWORK(1) contains the reciprocal pivot growth factor norm(A)/norm(U)
             X, equed, R, C, B, rcond[1], ferr, berr, rwork[1]
         end
+
         #Wrapper for the no-equilibration, no-transpose calculation
         function gesvx!(A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
-            n=size(A,1)
-            X, equed, R, C, B, rcond, ferr, berr, rpgf = gesvx!('N', 'N', A, similar(A, $elty, n, n), similar(A, BlasInt, n), 'N', similar(A, $relty, n),  similar(A, $relty, n), B)
+            n = size(A,1)
+            X, equed, R, C, B, rcond, ferr, berr, rpgf =
+                gesvx!('N', 'N', A,
+                       similar(A, $elty, n, n),
+                       similar(A, BlasInt, n),
+                       'N',
+                       similar(A, $relty, n),
+                       similar(A, $relty, n),
+                       B)
             X, rcond, ferr, berr, rpgf
         end
     end
- end
+end
+
+"""
+    gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)
+
+Solves the linear equation `A * X = B` (`trans = N`), `A.' * X =B`
+(`trans = T`), or `A' * X = B` (`trans = C`) using the `LU` factorization
+of `A`. `fact` may be `E`, in which case `A` will be equilibrated and copied
+to `AF`; `F`, in which case `AF` and `ipiv` from a previous `LU` factorization
+are inputs; or `N`, in which case `A` will be copied to `AF` and then
+factored. If `fact = F`, `equed` may be `N`, meaning `A` has not been
+equilibrated; `R`, meaning `A` was multiplied by `diagm(R)` from the left;
+`C`, meaning `A` was multiplied by `diagm(C)` from the right; or `B`, meaning
+`A` was multiplied by `diagm(R)` from the left and `diagm(C)` from the right.
+If `fact = F` and `equed = R` or `B` the elements of `R` must all be positive.
+If `fact = F` and `equed = C` or `B` the elements of `C` must all be positive.
+
+Returns the solution `X`; `equed`, which is an output if `fact` is not `N`,
+and describes the equilibration that was performed; `R`, the row equilibration
+diagonal; `C`, the column equilibration diagonal; `B`, which may be overwritten
+with its equilibrated form `diagm(R)*B` (if `trans = N` and `equed = R,B`) or
+`diagm(C)*B` (if `trans = T,C` and `equed = C,B`); `rcond`, the reciprocal
+condition number of `A` after equilbrating; `ferr`, the forward error bound for
+each solution vector in `X`; `berr`, the forward error bound for each solution
+vector in `X`; and `work`, the reciprocal pivot growth factor.
+"""
+gesvx!(fact::Char, trans::Char, A::StridedMatrix, AF::StridedMatrix,
+    ipiv::Vector{BlasInt}, equed::Char, R::Vector, C::Vector, B::StridedVecOrMat)
+
+"""
+    gesvx!(A, B)
+
+The no-equilibration, no-transpose simplification of `gesvx!`.
+"""
+gesvx!(A::StridedMatrix, B::StridedVecOrMat)
 
 for (gelsd, gelsy, elty) in
     ((:dgelsd_,:dgelsy_,:Float64),
@@ -800,20 +1208,20 @@ for (gelsd, gelsy, elty) in
             s     = similar(A, $elty, min(m, n))
             rcond = convert($elty, rcond)
             rnk   = Array(BlasInt, 1)
-            info  = Array(BlasInt, 1)
+            info  = Ref{BlasInt}()
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(gelsd)), liblapack), Void,
+            for i = 1:2
+                ccall((@blasfunc($gelsd), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, &size(B,2), A, &max(1,stride(A,2)),
                       newB, &max(1,stride(B,2),n), s, &rcond, rnk, work, &lwork, iwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                     iwork = Array(BlasInt, iwork[1])
@@ -822,15 +1230,15 @@ for (gelsd, gelsy, elty) in
             subsetrows(B, newB, n), rnk[1]
         end
 
-#       SUBROUTINE DGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK,
-#      $                   WORK, LWORK, INFO )
-# *     .. Scalar Arguments ..
-#       INTEGER            INFO, LDA, LDB, LWORK, M, N, NRHS, RANK
-#       DOUBLE PRECISION   RCOND
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            JPVT( * )
-#       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), WORK( * )
+        #       SUBROUTINE DGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK,
+        #      $                   WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       INTEGER            INFO, LDA, LDB, LWORK, M, N, NRHS, RANK
+        #       DOUBLE PRECISION   RCOND
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            JPVT( * )
+        #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), WORK( * )
         function gelsy!(A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty}, rcond::Real=eps($elty))
             chkstride1(A, B)
             m = size(A, 1)
@@ -846,10 +1254,10 @@ for (gelsd, gelsy, elty) in
             rcond = convert($elty, rcond)
             rnk = Array(BlasInt, 1)
             work = Array($elty, 1)
-            lwork = -1
-            info = Array(BlasInt, 1)
+            lwork = BlasInt(-1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gelsy)), liblapack), Void,
+                ccall((@blasfunc($gelsy), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -858,16 +1266,17 @@ for (gelsd, gelsy, elty) in
                     &lda, newB, &ldb, jpvt,
                     &rcond, rnk, work, &lwork,
                     info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             subsetrows(B, newB, n), rnk[1]
         end
     end
 end
+
 for (gelsd, gelsy, elty, relty) in
     ((:zgelsd_,:zgelsy_,:Complex128,:Float64),
      (:cgelsd_,:cgelsy_,:Complex64,:Float32))
@@ -892,21 +1301,21 @@ for (gelsd, gelsy, elty, relty) in
             s     = similar(A, $relty, min(m, n))
             rcond = convert($relty, rcond)
             rnk   = Array(BlasInt, 1)
-            info  = Array(BlasInt, 1)
+            info  = Ref{BlasInt}()
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
             rwork = Array($relty, 1)
             iwork = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(gelsd)), liblapack), Void,
+            for i = 1:2
+                ccall((@blasfunc($gelsd), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty},
                        Ptr{$relty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$relty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, &size(B,2), A, &max(1,stride(A,2)),
                       newB, &max(1,stride(B,2),n), s, &rcond, rnk, work, &lwork, rwork, iwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                     rwork = Array($relty, BlasInt(rwork[1]))
@@ -916,16 +1325,16 @@ for (gelsd, gelsy, elty, relty) in
             subsetrows(B, newB, n), rnk[1]
         end
 
-#       SUBROUTINE ZGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK,
-#      $                   WORK, LWORK, RWORK, INFO )
-# *     .. Scalar Arguments ..
-#       INTEGER            INFO, LDA, LDB, LWORK, M, N, NRHS, RANK
-#       DOUBLE PRECISION   RCOND
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            JPVT( * )
-#       DOUBLE PRECISION   RWORK( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
+        #       SUBROUTINE ZGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK,
+        #      $                   WORK, LWORK, RWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       INTEGER            INFO, LDA, LDB, LWORK, M, N, NRHS, RANK
+        #       DOUBLE PRECISION   RCOND
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            JPVT( * )
+        #       DOUBLE PRECISION   RWORK( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
         function gelsy!(A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty}, rcond::Real=eps($relty))
             chkstride1(A, B)
             m, n = size(A)
@@ -940,11 +1349,11 @@ for (gelsd, gelsy, elty, relty) in
             rcond = convert($relty, rcond)
             rnk = Array(BlasInt, 1)
             work = Array($elty, 1)
-            lwork = -1
+            lwork = BlasInt(-1)
             rwork = Array($relty, 2n)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gelsy)), liblapack), Void,
+                ccall((@blasfunc($gelsy), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -953,17 +1362,39 @@ for (gelsd, gelsy, elty, relty) in
                     &lda, newB, &ldb, jpvt,
                     &rcond, rnk, work, &lwork,
                     rwork, info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             subsetrows(B, newB, n), rnk[1]
         end
     end
 end
 
+"""
+    gelsd!(A, B, rcond) -> (B, rnk)
+
+Computes the least norm solution of `A * X = B` by finding the `SVD`
+factorization of `A`, then dividing-and-conquering the problem. `B`
+is overwritten with the solution `X`. Singular values below `rcond`
+will be treated as zero. Returns the solution in `B` and the effective rank
+of `A` in `rnk`.
+"""
+gelsd!(A::StridedMatrix, B::StridedVecOrMat, rcond::Real)
+
+"""
+    gelsy!(A, B, rcond) -> (B, rnk)
+
+Computes the least norm solution of `A * X = B` by finding the full `QR`
+factorization of `A`, then dividing-and-conquering the problem. `B`
+is overwritten with the solution `X`. Singular values below `rcond`
+will be treated as zero. Returns the solution in `B` and the effective rank
+of `A` in `rnk`.
+"""
+gelsy!(A::StridedMatrix, B::StridedVecOrMat, rcond::Real)
+
 for (gglse, elty) in ((:dgglse_, :Float64),
                       (:sgglse_, :Float32),
                       (:zgglse_, :Complex128),
@@ -992,19 +1423,19 @@ for (gglse, elty) in ((:dgglse_, :Float64),
                 throw(DimensionMismatch("d has length $(length(d)), needs $p"))
             end
             X = zeros($elty, n)
-            info  = Array(BlasInt, 1)
+            info  = Ref{BlasInt}()
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            for i in 1:2
-                ccall(($(blasfunc(gglse)), liblapack), Void,
+            for i = 1:2
+                ccall((@blasfunc($gglse), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}),
                       &m, &n, &p, A, &max(1,stride(A,2)), B, &max(1,stride(B,2)), c, d, X,
                       work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
@@ -1014,6 +1445,15 @@ for (gglse, elty) in ((:dgglse_, :Float64),
     end
 end
 
+"""
+    gglse!(A, c, B, d) -> (X,res)
+
+Solves the equation `A * x = c` where `x` is subject to the equality
+constraint `B * x = d`. Uses the formula `||c - A*x||^2 = 0` to solve.
+Returns `X` and the residual sum-of-squares.
+"""
+gglse!(A::StridedMatrix, c::StridedVector, B::StridedMatrix, d::StridedVector)
+
 # (GE) general matrices eigenvalue-eigenvector and singular value decompositions
 for (geev, gesvd, gesdd, ggsvd, elty, relty) in
     ((:dgeev_,:dgesvd_,:dgesdd_,:dggsvd_,:Float64,:Float64),
@@ -1031,12 +1471,13 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
         #      $                   WI( * ), WORK( * ), WR( * )
         function geev!(jobvl::Char, jobvr::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
+            chkfinite(A) # balancing routines don't support NaNs and Infs
             lvecs = jobvl == 'V'
             rvecs = jobvr == 'V'
             VL    = similar(A, $elty, (n, lvecs ? n : 0))
             VR    = similar(A, $elty, (n, rvecs ? n : 0))
-            cmplx = eltype(A)<:Complex
+            cmplx = eltype(A) <: Complex
             if cmplx
                 W     = similar(A, $elty, n)
                 rwork = similar(A, $relty, 2n)
@@ -1046,10 +1487,10 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
+            info  = Ref{BlasInt}()
             for i = 1:2
                 if cmplx
-                    ccall(($(blasfunc(geev)), liblapack), Void,
+                    ccall((@blasfunc($geev), liblapack), Void,
                           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1057,7 +1498,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                           &jobvl, &jobvr, &n, A, &max(1,stride(A,2)), W, VL, &n, VR, &n,
                           work, &lwork, rwork, info)
                 else
-                    ccall(($(blasfunc(geev)), liblapack), Void,
+                    ccall((@blasfunc($geev), liblapack), Void,
                           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -1065,14 +1506,15 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                           &jobvl, &jobvr, &n, A, &max(1,stride(A,2)), WR, WI, VL, &n,
                           VR, &n, work, &lwork, info)
                 end
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             cmplx ? (W, VL, VR) : (WR, WI, VL, VR)
         end
+
         #    SUBROUTINE DGESDD( JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK,
         #                   LWORK, IWORK, INFO )
         #*     .. Scalar Arguments ..
@@ -1109,10 +1551,10 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                               minmn*max(5*minmn+7, 2*max(m,n)+2*minmn+1))
             end
             iwork  = Array(BlasInt, 8*minmn)
-            info   = Array(BlasInt, 1)
+            info   = Ref{BlasInt}()
             for i = 1:2
                 if cmplx
-                    ccall(($(blasfunc(gesdd)), liblapack), Void,
+                    ccall((@blasfunc($gesdd), liblapack), Void,
                           (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1120,7 +1562,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                           &job, &m, &n, A, &max(1,stride(A,2)), S, U, &max(1,stride(U,2)), VT, &max(1,stride(VT,2)),
                           work, &lwork, rwork, iwork, info)
                 else
-                    ccall(($(blasfunc(gesdd)), liblapack), Void,
+                    ccall((@blasfunc($gesdd), liblapack), Void,
                           (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                            Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1128,14 +1570,30 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                           &job, &m, &n, A, &max(1,stride(A,2)), S, U, &max(1,stride(U,2)), VT, &max(1,stride(VT,2)),
                           work, &lwork, iwork, info)
                 end
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            job=='O' ? (m>=n? (A, S, VT) : (U, S, A)) : (U, S, VT)
+            if job == 'O'
+                if m >= n
+                    return (A, S, VT)
+                else
+                    # ()__
+                    # ||::Z__
+                    # ||::|:::Z____
+                    # ||::|:::|====|
+                    # ||==|===|====|
+                    # ||""|===|====|
+                    # ||  `"""|====|
+                    # ||      `""""`
+                    return (U, S, A)
+                end
+            end
+            return (U, S, VT)
         end
+
         # SUBROUTINE DGESVD( JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       CHARACTER          JOBU, JOBVT
@@ -1151,13 +1609,15 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
             U      = similar(A, $elty, jobu  == 'A'? (m, m):(jobu  == 'S'? (m, minmn) : (m, 0)))
             VT     = similar(A, $elty, jobvt == 'A'? (n, n):(jobvt == 'S'? (minmn, n) : (n, 0)))
             work   = Array($elty, 1)
-            cmplx  = eltype(A)<:Complex
-            if cmplx; rwork = Array($relty, 5minmn); end
+            cmplx  = eltype(A) <: Complex
+            if cmplx
+                rwork = Array($relty, 5minmn)
+            end
             lwork  = BlasInt(-1)
-            info   = Array(BlasInt, 1)
+            info   = Ref{BlasInt}()
             for i in 1:2
                 if cmplx
-                    ccall(($(blasfunc(gesvd)), liblapack), Void,
+                    ccall((@blasfunc($gesvd), liblapack), Void,
                           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                            Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -1165,7 +1625,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                           &jobu, &jobvt, &m, &n, A, &max(1,stride(A,2)), S, U, &max(1,stride(U,2)), VT, &max(1,stride(VT,2)),
                           work, &lwork, rwork, info)
                 else
-                    ccall(($(blasfunc(gesvd)), liblapack), Void,
+                    ccall((@blasfunc($gesvd), liblapack), Void,
                           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                            Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                            Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -1173,27 +1633,43 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                           &jobu, &jobvt, &m, &n, A, &max(1,stride(A,2)), S, U, &max(1,stride(U,2)), VT, &max(1,stride(VT,2)),
                           work, &lwork, info)
                 end
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            jobu=='O' ? (A, S, VT) : (jobvt=='O' ? (U, S, A) : (U, S, VT))
+            if jobu == 'O'
+                return (A, S, VT)
+            elseif jobvt == 'O'
+                    # =============|===========|()
+                                   # # # #::::::
+                                   # # # #::::::
+                                   # # # #::::::
+                                   # # # #::::::
+                                   # # # # # # #
+                                   # # # # # # #
+                                   # # # # # # #
+                return (U, S, A)   # # # # # # #
+            else                   # # # # # # #
+                return (U, S, VT)  # # # # # # #
+
+            end
         end
-#       SUBROUTINE ZGGSVD( JOBU, JOBV, JOBQ, M, N, P, K, L, A, LDA, B,
-#      $                   LDB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, WORK,
-#      $                   RWORK, IWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBQ, JOBU, JOBV
-#       INTEGER            INFO, K, L, LDA, LDB, LDQ, LDU, LDV, M, N, P
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IWORK( * )
-#       DOUBLE PRECISION   ALPHA( * ), BETA( * ), RWORK( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * ), Q( LDQ, * ),
-#      $                   U( LDU, * ), V( LDV, * ), WORK( * )
-        function ggsvd!(jobu::Char, jobv::Char, jobq::Char, A::Matrix{$elty}, B::Matrix{$elty})
+
+        #       SUBROUTINE ZGGSVD( JOBU, JOBV, JOBQ, M, N, P, K, L, A, LDA, B,
+        #      $                   LDB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, WORK,
+        #      $                   RWORK, IWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBQ, JOBU, JOBV
+        #       INTEGER            INFO, K, L, LDA, LDB, LDQ, LDU, LDV, M, N, P
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IWORK( * )
+        #       DOUBLE PRECISION   ALPHA( * ), BETA( * ), RWORK( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), Q( LDQ, * ),
+        #      $                   U( LDU, * ), V( LDV, * ), WORK( * )
+        function ggsvd!(jobu::Char, jobv::Char, jobq::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
             chkstride1(A, B)
             m, n = size(A)
             if size(B, 2) != n
@@ -1213,12 +1689,14 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
             ldq = max(1, n)
             Q = jobq == 'Q' ? similar(A, $elty, ldq, n) : similar(A, $elty, 0)
             work = Array($elty, max(3n, m, p) + n)
-            cmplx = eltype(A)<:Complex
-            if cmplx; rwork = Array($relty, 2n); end
+            cmplx = eltype(A) <: Complex
+            if cmplx
+                rwork = Array($relty, 2n)
+            end
             iwork = Array(BlasInt, n)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             if cmplx
-                ccall(($(blasfunc(ggsvd)), liblapack), Void,
+                ccall((@blasfunc($ggsvd), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                     Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1232,7 +1710,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                     V, &ldv, Q, &ldq,
                     work, rwork, iwork, info)
             else
-                ccall(($(blasfunc(ggsvd)), liblapack), Void,
+                ccall((@blasfunc($ggsvd), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                     Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1246,7 +1724,7 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
                     V, &ldv, Q, &ldq,
                     work, iwork, info)
             end
-            @lapackerror
+            chklapackerror(info[])
             if m - k[1] - l[1] >= 0
                 R = triu(A[1:k[1] + l[1],n - k[1] - l[1] + 1:n])
             else
@@ -1256,116 +1734,300 @@ for (geev, gesvd, gesdd, ggsvd, elty, relty) in
         end
     end
 end
-## Expert driver and generalized eigenvalue problem
-for (geevx, ggev, elty) in
-    ((:dgeevx_,:dggev_,:Float64),
-     (:sgeevx_,:sggev_,:Float32))
-    @eval begin
-   #     SUBROUTINE DGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, WR, WI,
-   #                          VL, LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM,
-   #                          RCONDE, RCONDV, WORK, LWORK, IWORK, INFO )
-   #
-   #       .. Scalar Arguments ..
-   #       CHARACTER          BALANC, JOBVL, JOBVR, SENSE
-   #       INTEGER            IHI, ILO, INFO, LDA, LDVL, LDVR, LWORK, N
-   #       DOUBLE PRECISION   ABNRM
-   #       ..
-   #       .. Array Arguments ..
-   #       INTEGER            IWORK( * )
-   #       DOUBLE PRECISION   A( LDA, * ), RCONDE( * ), RCONDV( * ),
-   #      $                   SCALE( * ), VL( LDVL, * ), VR( LDVR, * ),
-   #      $                   WI( * ), WORK( * ), WR( * )
-    function geevx!(balanc::Char, jobvl::Char, jobvr::Char, sense::Char, A::StridedMatrix{$elty})
-        n = chksquare(A)
-        lda = max(1,stride(A,2))
-        wr = similar(A, $elty, n)
-        wi = similar(A, $elty, n)
-        if balanc ∉ ['N', 'P', 'S', 'B']
-            throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
-        end
-        ldvl = 0
-        if jobvl == 'V'
-            ldvl = n
-        elseif jobvl == 'N'
-            ldvl = 0
-        else
-            throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
-        end
-        VL = similar(A, $elty, ldvl, n)
-        ldvr = 0
-        if jobvr == 'V'
-            ldvr = n
-        elseif jobvr == 'N'
-            ldvr = 0
-        else
-            throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
-        end
-        VR = similar(A, $elty, ldvr, n)
-        ilo = Array(BlasInt, 1)
-        ihi = Array(BlasInt, 1)
-        scale = similar(A, $elty, n)
-        abnrm = Array($elty, 1)
-        rconde = similar(A, $elty, n)
-        rcondv = similar(A, $elty, n)
-        work = Array($elty, 1)
-        lwork::BlasInt = -1
-        iworksize = 0
-        if sense == 'N' || sense == 'E'
-            iworksize = 0
-        elseif sense == 'V' || sense == 'B'
-            iworksize = 2*n - 2
-        else
-            throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
-        end
-        iwork = Array(BlasInt, iworksize)
-        info = Array(BlasInt, 1)
-        for i = 1:2
-            ccall(($(blasfunc(geevx)), liblapack), Void,
-                  (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
-                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
-                   Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
-                   Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
-                   &balanc, &jobvl, &jobvr, &sense,
-                   &n, A, &lda, wr,
-                   wi, VL, &max(1,ldvl), VR,
-                   &max(1,ldvr), ilo, ihi, scale,
-                   abnrm, rconde, rcondv, work,
-                   &lwork, iwork, info)
-            lwork = convert(BlasInt, work[1])
-            work = Array($elty, lwork)
-        end
-        @lapackerror
-        A, wr, wi, VL, VR, ilo[1], ihi[1], scale, abnrm[1], rconde, rcondv
-    end
 
-    #       SUBROUTINE DGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, ALPHAI,
-#      $                  BETA, VL, LDVL, VR, LDVR, WORK, LWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBVL, JOBVR
-#       INTEGER            INFO, LDA, LDB, LDVL, LDVR, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
-#      $                   B( LDB, * ), BETA( * ), VL( LDVL, * ),
-#      $                   VR( LDVR, * ), WORK( * )
-        function ggev!(jobvl::Char, jobvr::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
-            chkstride1(A,B)
-            n, m = chksquare(A,B)
-            if n != m
-                throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
-            end
-            lda = max(1, stride(A, 2))
-            ldb = max(1, stride(B, 2))
-            alphar = similar(A, $elty, n)
-            alphai = similar(A, $elty, n)
-            beta = similar(A, $elty, n)
-            ldvl = 0
-            if jobvl == 'V'
-                ldvl = n
-            elseif jobvl == 'N'
-                ldvl = 1
+"""
+    geev!(jobvl, jobvr, A) -> (W, VL, VR)
+
+Finds the eigensystem of `A`. If `jobvl = N`, the left eigenvectors of
+`A` aren't computed. If `jobvr = N`, the right eigenvectors of `A`
+aren't computed. If `jobvl = V` or `jobvr = V`, the corresponding
+eigenvectors are computed. Returns the eigenvalues in `W`, the right
+eigenvectors in `VR`, and the left eigenvectors in `VL`.
+"""
+geev!(jobvl::Char, jobvr::Char, A::StridedMatrix)
+
+"""
+    gesdd!(job, A) -> (U, S, VT)
+
+Finds the singular value decomposition of `A`, `A = U * S * V'`,
+using a divide and conquer approach. If `job = A`, all the columns of `U` and
+the rows of `V'` are computed. If `job = N`, no columns of `U` or rows of `V'`
+are computed. If `job = O`, `A` is overwritten with the columns of (thin) `U`
+and the rows of (thin) `V'`. If `job = S`, the columns of (thin) `U` and the
+rows of (thin) `V'` are computed and returned separately.
+"""
+gesdd!(job::Char, A::StridedMatrix)
+
+"""
+    gesvd!(jobu, jobvt, A) -> (U, S, VT)
+
+Finds the singular value decomposition of `A`, `A = U * S * V'`.
+If `jobu = A`, all the columns of `U` are computed. If `jobvt = A` all the rows
+of `V'` are computed. If `jobu = N`, no columns of `U` are computed. If
+`jobvt = N` no rows of `V'` are computed. If `jobu = O`, `A` is overwritten with
+the columns of (thin) `U`. If `jobvt = O`, `A` is overwritten with the rows
+of (thin) `V'`. If `jobu = S`, the columns of (thin) `U` are computed
+and returned separately. If `jobvt = S` the rows of (thin) `V'` are
+computed and returned separately. `jobu` and `jobvt` can't both be `O`.
+
+Returns `U`, `S`, and `Vt`, where `S` are the singular values of `A`.
+"""
+gesvd!(jobu::Char, jobvt::Char, A::StridedMatrix)
+
+"""
+    ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)
+
+Finds the generalized singular value decomposition of `A` and `B`, `U'*A*Q = D1*R`
+and `V'*B*Q = D2*R`. `D1` has `alpha` on its diagonal and `D2` has `beta` on its
+diagonal. If `jobu = U`, the orthogonal/unitary matrix `U` is computed. If
+`jobv = V` the orthogonal/unitary matrix `V` is computed. If `jobq = Q`,
+the orthogonal/unitary matrix `Q` is computed. If `jobu`, `jobv` or `jobq` is
+`N`, that matrix is not computed. This function is only available in LAPACK
+versions prior to 3.6.0.
+"""
+ggsvd!(jobu::Char, jobv::Char, jobq::Char, A::StridedMatrix, B::StridedMatrix)
+
+
+for (f, elty) in ((:dggsvd3_, :Float64),
+                  (:sggsvd3_, :Float32))
+    @eval begin
+        function ggsvd3!(jobu::Char, jobv::Char, jobq::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
+            chkstride1(A, B)
+            m, n = size(A)
+            if size(B, 2) != n
+                throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
+            end
+            p = size(B, 1)
+            k = Ref{BlasInt}()
+            l = Ref{BlasInt}()
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            alpha = similar(A, $elty, n)
+            beta = similar(A, $elty, n)
+            ldu = max(1, m)
+            U = jobu == 'U' ? similar(A, $elty, ldu, m) : similar(A, $elty, 0)
+            ldv = max(1, p)
+            V = jobv == 'V' ? similar(A, $elty, ldv, p) : similar(A, $elty, 0)
+            ldq = max(1, n)
+            Q = jobq == 'Q' ? similar(A, $elty, ldq, n) : similar(A, $elty, 0)
+            work = Array($elty, 1)
+            lwork = BlasInt(-1)
+            iwork = Array(BlasInt, n)
+            info = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($f), liblapack), Void,
+                    (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
+                    Ptr{BlasInt}, Ptr{BlasInt}, Ref{BlasInt}, Ref{BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                    Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ref{BlasInt}),
+                    &jobu, &jobv, &jobq, &m,
+                    &n, &p, k, l,
+                    A, &lda, B, &ldb,
+                    alpha, beta, U, &ldu,
+                    V, &ldv, Q, &ldq,
+                    work, &lwork, iwork, info)
+                chklapackerror(info[])
+                if i == 1
+                    lwork = BlasInt(work[1])
+                    resize!(work, lwork)
+                end
+            end
+            if m - k[] - l[] >= 0
+                R = triu(A[1:k[] + l[],n - k[] - l[] + 1:n])
+            else
+                R = triu([A[1:m, n - k[] - l[] + 1:n]; B[m - k[] + 1:l[], n - k[] - l[] + 1:n]])
+            end
+            return U, V, Q, alpha, beta, k[], l[], R
+        end
+    end
+end
+
+for (f, elty, relty) in ((:zggsvd3_, :Complex128, :Float64),
+                         (:cggsvd3_, :Complex64, :Float32))
+    @eval begin
+        function ggsvd3!(jobu::Char, jobv::Char, jobq::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
+            chkstride1(A, B)
+            m, n = size(A)
+            if size(B, 2) != n
+                throw(DimensionMismatch("B has second dimension $(size(B,2)) but needs $n"))
+            end
+            p = size(B, 1)
+            k = Array(BlasInt, 1)
+            l = Array(BlasInt, 1)
+            lda = max(1,stride(A, 2))
+            ldb = max(1,stride(B, 2))
+            alpha = similar(A, $relty, n)
+            beta = similar(A, $relty, n)
+            ldu = max(1, m)
+            U = jobu == 'U' ? similar(A, $elty, ldu, m) : similar(A, $elty, 0)
+            ldv = max(1, p)
+            V = jobv == 'V' ? similar(A, $elty, ldv, p) : similar(A, $elty, 0)
+            ldq = max(1, n)
+            Q = jobq == 'Q' ? similar(A, $elty, ldq, n) : similar(A, $elty, 0)
+            work = Array($elty, 1)
+            lwork = BlasInt(-1)
+            rwork = Array($relty, 2n)
+            iwork = Array(BlasInt, n)
+            info = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($f), liblapack), Void,
+                    (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
+                    Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                    Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty}, Ptr{BlasInt},
+                    Ptr{BlasInt}),
+                    &jobu, &jobv, &jobq, &m,
+                    &n, &p, k, l,
+                    A, &lda, B, &ldb,
+                    alpha, beta, U, &ldu,
+                    V, &ldv, Q, &ldq,
+                    work, &lwork, rwork, iwork,
+                    info)
+                chklapackerror(info[])
+                if i == 1
+                    lwork = BlasInt(work[1])
+                    work = Array($elty, lwork)
+                end
+            end
+            if m - k[1] - l[1] >= 0
+                R = triu(A[1:k[1] + l[1],n - k[1] - l[1] + 1:n])
+            else
+                R = triu([A[1:m, n - k[1] - l[1] + 1:n]; B[m - k[1] + 1:l[1], n - k[1] - l[1] + 1:n]])
+            end
+            return U, V, Q, alpha, beta, k[1], l[1], R
+        end
+    end
+end
+
+"""
+    ggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)
+
+Finds the generalized singular value decomposition of `A` and `B`, `U'*A*Q = D1*R`
+and `V'*B*Q = D2*R`. `D1` has `alpha` on its diagonal and `D2` has `beta` on its
+diagonal. If `jobu = U`, the orthogonal/unitary matrix `U` is computed. If
+`jobv = V` the orthogonal/unitary matrix `V` is computed. If `jobq = Q`,
+the orthogonal/unitary matrix `Q` is computed. If `jobu`, `jobv`, or `jobq` is
+`N`, that matrix is not computed. This function requires LAPACK 3.6.0.
+"""
+ggsvd3!
+
+## Expert driver and generalized eigenvalue problem
+for (geevx, ggev, elty) in
+    ((:dgeevx_,:dggev_,:Float64),
+     (:sgeevx_,:sggev_,:Float32))
+    @eval begin
+        #     SUBROUTINE DGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, WR, WI,
+        #                          VL, LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM,
+        #                          RCONDE, RCONDV, WORK, LWORK, IWORK, INFO )
+        #
+        #       .. Scalar Arguments ..
+        #       CHARACTER          BALANC, JOBVL, JOBVR, SENSE
+        #       INTEGER            IHI, ILO, INFO, LDA, LDVL, LDVR, LWORK, N
+        #       DOUBLE PRECISION   ABNRM
+        #       ..
+        #       .. Array Arguments ..
+        #       INTEGER            IWORK( * )
+        #       DOUBLE PRECISION   A( LDA, * ), RCONDE( * ), RCONDV( * ),
+        #      $                   SCALE( * ), VL( LDVL, * ), VR( LDVR, * ),
+        #      $                   WI( * ), WORK( * ), WR( * )
+        function geevx!(balanc::Char, jobvl::Char, jobvr::Char, sense::Char, A::StridedMatrix{$elty})
+            n = checksquare(A)
+            chkfinite(A) # balancing routines don't support NaNs and Infs
+            lda = max(1,stride(A,2))
+            wr = similar(A, $elty, n)
+            wi = similar(A, $elty, n)
+            if balanc ∉ ['N', 'P', 'S', 'B']
+                throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
+            end
+            ldvl = 0
+            if jobvl == 'V'
+                ldvl = n
+            elseif jobvl == 'N'
+                ldvl = 0
+            else
+                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+            end
+            VL = similar(A, $elty, ldvl, n)
+            ldvr = 0
+            if jobvr == 'V'
+                ldvr = n
+            elseif jobvr == 'N'
+                ldvr = 0
+            else
+                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+            end
+            VR = similar(A, $elty, ldvr, n)
+            ilo = Array(BlasInt, 1)
+            ihi = Array(BlasInt, 1)
+            scale = similar(A, $elty, n)
+            abnrm = Array($elty, 1)
+            rconde = similar(A, $elty, n)
+            rcondv = similar(A, $elty, n)
+            work = Array($elty, 1)
+            lwork = BlasInt(-1)
+            iworksize = 0
+            if sense == 'N' || sense == 'E'
+                iworksize = 0
+            elseif sense == 'V' || sense == 'B'
+                iworksize = 2*n - 2
+            else
+                throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
+            end
+            iwork = Array(BlasInt, iworksize)
+            info = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($geevx), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
+                       Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
+                       Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
+                       Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
+                       Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
+                       Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
+                       &balanc, &jobvl, &jobvr, &sense,
+                       &n, A, &lda, wr,
+                       wi, VL, &max(1,ldvl), VR,
+                       &max(1,ldvr), ilo, ihi, scale,
+                       abnrm, rconde, rcondv, work,
+                       &lwork, iwork, info)
+                chklapackerror(info[])
+                if i == 1
+                    lwork = BlasInt(work[1])
+                    work = Array($elty, lwork)
+                end
+            end
+            A, wr, wi, VL, VR, ilo[1], ihi[1], scale, abnrm[1], rconde, rcondv
+        end
+
+        #       SUBROUTINE DGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, ALPHAI,
+        #      $                  BETA, VL, LDVL, VR, LDVR, WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBVL, JOBVR
+        #       INTEGER            INFO, LDA, LDB, LDVL, LDVR, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
+        #      $                   B( LDB, * ), BETA( * ), VL( LDVL, * ),
+        #      $                   VR( LDVR, * ), WORK( * )
+        function ggev!(jobvl::Char, jobvr::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
+            chkstride1(A,B)
+            n, m = checksquare(A,B)
+            if n != m
+                throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
+            end
+            lda = max(1, stride(A, 2))
+            ldb = max(1, stride(B, 2))
+            alphar = similar(A, $elty, n)
+            alphai = similar(A, $elty, n)
+            beta = similar(A, $elty, n)
+            ldvl = 0
+            if jobvl == 'V'
+                ldvl = n
+            elseif jobvl == 'N'
+                ldvl = 1
             else
                 throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
             end
@@ -1380,10 +2042,10 @@ for (geevx, ggev, elty) in
             end
             vr = similar(A, $elty, ldvr, n)
             work = Array($elty, 1)
-            lwork = -one(BlasInt)
-            info = Array(BlasInt, 1)
+            lwork = BlasInt(-1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(ggev)), liblapack), Void,
+                ccall((@blasfunc($ggev), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
@@ -1394,107 +2056,111 @@ for (geevx, ggev, elty) in
                     alphai, beta, vl, &ldvl,
                     vr, &ldvr, work, &lwork,
                     info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             alphar, alphai, beta, vl, vr
         end
     end
 end
+
 for (geevx, ggev, elty, relty) in
     ((:zgeevx_,:zggev_,:Complex128,:Float64),
      (:cgeevx_,:cggev_,:Complex64,:Float32))
     @eval begin
-  #     SUBROUTINE ZGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, W, VL,
-  #                          LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM, RCONDE,
-  #                          RCONDV, WORK, LWORK, RWORK, INFO )
-  #
-  #       .. Scalar Arguments ..
-  #       CHARACTER          BALANC, JOBVL, JOBVR, SENSE
-  #       INTEGER            IHI, ILO, INFO, LDA, LDVL, LDVR, LWORK, N
-  #       DOUBLE PRECISION   ABNRM
-  #       ..
-  #       .. Array Arguments ..
-  #       DOUBLE PRECISION   RCONDE( * ), RCONDV( * ), RWORK( * ),
-  #      $                   SCALE( * )
-  #       COMPLEX*16         A( LDA, * ), VL( LDVL, * ), VR( LDVR, * ),
-  #      $                   W( * ), WORK( * )
-    function geevx!(balanc::Char, jobvl::Char, jobvr::Char, sense::Char, A::StridedMatrix{$elty})
-        n = chksquare(A)
-        lda = max(1,stride(A,2))
-        w = similar(A, $elty, n)
-        if balanc ∉ ['N', 'P', 'S', 'B']
-            throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
-        end
-        ldvl = 0
-        if jobvl == 'V'
-            ldvl = n
-        elseif jobvl == 'N'
+        #     SUBROUTINE ZGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, W, VL,
+        #                          LDVL, VR, LDVR, ILO, IHI, SCALE, ABNRM, RCONDE,
+        #                          RCONDV, WORK, LWORK, RWORK, INFO )
+        #
+        #       .. Scalar Arguments ..
+        #       CHARACTER          BALANC, JOBVL, JOBVR, SENSE
+        #       INTEGER            IHI, ILO, INFO, LDA, LDVL, LDVR, LWORK, N
+        #       DOUBLE PRECISION   ABNRM
+        #       ..
+        #       .. Array Arguments ..
+        #       DOUBLE PRECISION   RCONDE( * ), RCONDV( * ), RWORK( * ),
+        #      $                   SCALE( * )
+        #       COMPLEX*16         A( LDA, * ), VL( LDVL, * ), VR( LDVR, * ),
+        #      $                   W( * ), WORK( * )
+        function geevx!(balanc::Char, jobvl::Char, jobvr::Char, sense::Char, A::StridedMatrix{$elty})
+            n = checksquare(A)
+            chkfinite(A) # balancing routines don't support NaNs and Infs
+            lda = max(1,stride(A,2))
+            w = similar(A, $elty, n)
+            if balanc ∉ ['N', 'P', 'S', 'B']
+                throw(ArgumentError("balanc must be 'N', 'P', 'S', or 'B', but $balanc was passed"))
+            end
             ldvl = 0
-        else
-            throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
-        end
-        VL = similar(A, $elty, ldvl, n)
-        ldvr = 0
-        if jobvr == 'V'
-            ldvr = n
-        elseif jobvr == 'N'
+            if jobvl == 'V'
+                ldvl = n
+            elseif jobvl == 'N'
+                ldvl = 0
+            else
+                throw(ArgumentError("jobvl must be 'V' or 'N', but $jobvl was passed"))
+            end
+            VL = similar(A, $elty, ldvl, n)
             ldvr = 0
-        else
-            throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
-        end
-        if sense ∉ ['N','E','V','B']
-            throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
-        end
-        VR = similar(A, $elty, ldvr, n)
-        ilo = Array(BlasInt, 1)
-        ihi = Array(BlasInt, 1)
-        scale = similar(A, $relty, n)
-        abnrm = Array($relty, 1)
-        rconde = similar(A, $relty, n)
-        rcondv = similar(A, $relty, n)
-        work = Array($elty, 1)
-        lwork::BlasInt = -1
-        rwork = Array($relty, 2n)
-        info = Array(BlasInt, 1)
-        for i = 1:2
-            ccall(($(blasfunc(geevx)), liblapack), Void,
-                  (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
-                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
-                   Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
-                   Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$relty},
-                   Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt},
-                   Ptr{$relty}, Ptr{BlasInt}),
-                   &balanc, &jobvl, &jobvr, &sense,
-                   &n, A, &lda, w,
-                   VL, &max(1,ldvl), VR, &max(1,ldvr),
-                   ilo, ihi, scale, abnrm,
-                   rconde, rcondv, work, &lwork,
-                   rwork, info)
-            lwork = convert(BlasInt, work[1])
-            work = Array($elty, lwork)
+            if jobvr == 'V'
+                ldvr = n
+            elseif jobvr == 'N'
+                ldvr = 0
+            else
+                throw(ArgumentError("jobvr must be 'V' or 'N', but $jobvr was passed"))
+            end
+            if sense ∉ ['N','E','V','B']
+                throw(ArgumentError("sense must be 'N', 'E', 'V' or 'B', but $sense was passed"))
+            end
+            VR = similar(A, $elty, ldvr, n)
+            ilo = Array(BlasInt, 1)
+            ihi = Array(BlasInt, 1)
+            scale = similar(A, $relty, n)
+            abnrm = Array($relty, 1)
+            rconde = similar(A, $relty, n)
+            rcondv = similar(A, $relty, n)
+            work = Array($elty, 1)
+            lwork = BlasInt(-1)
+            rwork = Array($relty, 2n)
+            info = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($geevx), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8},
+                       Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
+                       Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                       Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$relty},
+                       Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt},
+                       Ptr{$relty}, Ptr{BlasInt}),
+                       &balanc, &jobvl, &jobvr, &sense,
+                       &n, A, &lda, w,
+                       VL, &max(1,ldvl), VR, &max(1,ldvr),
+                       ilo, ihi, scale, abnrm,
+                       rconde, rcondv, work, &lwork,
+                       rwork, info)
+                chklapackerror(info[])
+                if i == 1
+                    lwork = BlasInt(work[1])
+                    work = Array($elty, lwork)
+                end
+            end
+            A, w, VL, VR, ilo[1], ihi[1], scale, abnrm[1], rconde, rcondv
         end
-        @lapackerror
-        A, w, VL, VR, ilo[1], ihi[1], scale, abnrm[1], rconde, rcondv
-    end
 
-      # SUBROUTINE ZGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHA, BETA,
-     # $                  VL, LDVL, VR, LDVR, WORK, LWORK, RWORK, INFO )
-# *     .. Scalar Arguments ..
-      # CHARACTER          JOBVL, JOBVR
-      # INTEGER            INFO, LDA, LDB, LDVL, LDVR, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-      # DOUBLE PRECISION   RWORK( * )
-      # COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
-     # $                   BETA( * ), VL( LDVL, * ), VR( LDVR, * ),
-     # $                   WORK( * )
+        # SUBROUTINE ZGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHA, BETA,
+        #      $                  VL, LDVL, VR, LDVR, WORK, LWORK, RWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBVL, JOBVR
+        #       INTEGER            INFO, LDA, LDB, LDVL, LDVR, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   RWORK( * )
+        #       COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
+        #      $                   BETA( * ), VL( LDVL, * ), VR( LDVR, * ),
+        #      $                   WORK( * )
         function ggev!(jobvl::Char, jobvr::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
             chkstride1(A, B)
-            n, m = chksquare(A, B)
+            n, m = checksquare(A, B)
             if n != m
                 throw(DimensionMismatch("A has dimensions $(size(A)), and B has dimensions $(size(B)), but A and B must have the same size"))
             end
@@ -1521,11 +2187,11 @@ for (geevx, ggev, elty, relty) in
             end
             vr = similar(A, $elty, ldvr, n)
             work = Array($elty, 1)
-            lwork = -one(BlasInt)
+            lwork = BlasInt(-1)
             rwork = Array($relty, 8n)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(ggev)), liblapack), Void,
+                ccall((@blasfunc($ggev), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -1536,31 +2202,61 @@ for (geevx, ggev, elty, relty) in
                     beta, vl, &ldvl, vr,
                     &ldvr, work, &lwork, rwork,
                     info)
+                chklapackerror(info[])
                 if i == 1
-                    lwork = BlasInt(real(work[1]))
+                    lwork = BlasInt(work[1])
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             alpha, beta, vl, vr
         end
     end
 end
 
+"""
+    geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)
+
+Finds the eigensystem of `A` with matrix balancing. If `jobvl = N`, the
+left eigenvectors of `A` aren't computed. If `jobvr = N`, the right
+eigenvectors of `A` aren't computed. If `jobvl = V` or `jobvr = V`, the
+corresponding eigenvectors are computed. If `balanc = N`, no balancing is
+performed. If `balanc = P`, `A` is permuted but not scaled. If
+`balanc = S`, `A` is scaled but not permuted. If `balanc = B`, `A` is
+permuted and scaled. If `sense = N`, no reciprocal condition numbers are
+computed. If `sense = E`, reciprocal condition numbers are computed for
+the eigenvalues only. If `sense = V`, reciprocal condition numbers are
+computed for the right eigenvectors only. If `sense = B`, reciprocal
+condition numbers are computed for the right eigenvectors and the
+eigenvectors. If `sense = E,B`, the right and left eigenvectors must be
+computed.
+"""
+geevx!(balanc::Char, jobvl::Char, jobvr::Char, sense::Char, A::StridedMatrix)
+
+"""
+    ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)
+
+Finds the generalized eigendecomposition of `A` and `B`. If `jobvl = N`,
+the left eigenvectors aren't computed. If `jobvr = N`, the right
+eigenvectors aren't computed. If `jobvl = V` or `jobvr = V`, the
+corresponding eigenvectors are computed.
+"""
+ggev!(jobvl::Char, jobvr::Char, A::StridedMatrix, B::StridedMatrix)
+
 # One step incremental condition estimation of max/min singular values
 for (laic1, elty) in
     ((:dlaic1_,:Float64),
      (:slaic1_,:Float32))
     @eval begin
-   # 21 *       SUBROUTINE DLAIC1( JOB, J, X, SEST, W, GAMMA, SESTPR, S, C )
-   # 22 *
-   # 23 *       .. Scalar Arguments ..
-   # 24 *       INTEGER            J, JOB
-   # 25 *       DOUBLE PRECISION   C, GAMMA, S, SEST, SESTPR
-   # 26 *       ..
-   # 27 *       .. Array Arguments ..
-   # 28 *       DOUBLE PRECISION   W( J ), X( J )
-        function laic1!(job::Integer, x::StridedVector{$elty}, sest::$elty, w::StridedVector{$elty}, gamma::$elty)
+        #  SUBROUTINE DLAIC1( JOB, J, X, SEST, W, GAMMA, SESTPR, S, C )
+        #
+        #  .. Scalar Arguments ..
+        #  INTEGER            J, JOB
+        #  DOUBLE PRECISION   C, GAMMA, S, SEST, SESTPR
+        #  ..
+        #  .. Array Arguments ..
+        #  DOUBLE PRECISION   W( J ), X( J )
+        function laic1!(job::Integer, x::StridedVector{$elty},
+                        sest::$elty, w::StridedVector{$elty}, gamma::$elty)
             j = length(x)
             if j != length(w)
                 throw(DimensionMismatch("Vectors must have same length, but length of x is $j and length of w is $(length(w))"))
@@ -1568,7 +2264,7 @@ for (laic1, elty) in
             sestpr = Array($elty, 1)
             s = Array($elty, 1)
             c = Array($elty, 1)
-            ccall(($(blasfunc(laic1)), liblapack), Void,
+            ccall((@blasfunc($laic1), liblapack), Void,
                 (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                  Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
                  Ptr{$elty}),
@@ -1583,16 +2279,17 @@ for (laic1, elty, relty) in
     ((:zlaic1_,:Complex128,:Float64),
      (:claic1_,:Complex64,:Float32))
     @eval begin
-   # 21 *       SUBROUTINE ZLAIC1( JOB, J, X, SEST, W, GAMMA, SESTPR, S, C )
-   # 22 *
-   # 23 *       .. Scalar Arguments ..
-   # 24 *       INTEGER            J, JOB
-   # 25 *       DOUBLE PRECISION   SEST, SESTPR
-   # 26 *       COMPLEX*16         C, GAMMA, S
-   # 27 *       ..
-   # 28 *       .. Array Arguments ..
-   # 29 *       COMPLEX*16         W( J ), X( J )
-        function laic1!(job::Integer, x::StridedVector{$elty}, sest::$relty, w::StridedVector{$elty}, gamma::$elty)
+       #  SUBROUTINE ZLAIC1( JOB, J, X, SEST, W, GAMMA, SESTPR, S, C )
+       #
+       #  .. Scalar Arguments ..
+       #  INTEGER            J, JOB
+       #  DOUBLE PRECISION   SEST, SESTPR
+       #  COMPLEX*16         C, GAMMA, S
+       #  ..
+       #  .. Array Arguments ..
+       #  COMPLEX*16         W( J ), X( J )
+        function laic1!(job::Integer, x::StridedVector{$elty},
+                        sest::$relty, w::StridedVector{$elty}, gamma::$elty)
             j = length(x)
             if j != length(w)
                 throw(DimensionMismatch("Vectors must have same length, but length of x is $j and length of w is $(length(w))"))
@@ -1600,7 +2297,7 @@ for (laic1, elty, relty) in
             sestpr = Array($relty, 1)
             s = Array($elty, 1)
             c = Array($elty, 1)
-            ccall(($(blasfunc(laic1)), liblapack), Void,
+            ccall((@blasfunc($laic1), liblapack), Void,
                 (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$relty},
                  Ptr{$elty}, Ptr{$elty}, Ptr{$relty}, Ptr{$elty},
                  Ptr{$elty}),
@@ -1612,7 +2309,6 @@ for (laic1, elty, relty) in
     end
 end
 
-
 # (GT) General tridiagonal, decomposition, solver and direct solver
 for (gtsv, gttrf, gttrs, elty) in
     ((:dgtsv_,:dgttrf_,:dgttrs_,:Float64),
@@ -1641,14 +2337,15 @@ for (gtsv, gttrf, gttrs, elty) in
             if n == 0
                 return B # Early exit if possible
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(gtsv)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gtsv), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &n, &size(B,2), dl, d, du, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
+
         #       SUBROUTINE DGTTRF( N, DL, D, DU, DU2, IPIV, INFO )
         #       .. Scalar Arguments ..
         #       INTEGER            INFO, N
@@ -1665,14 +2362,15 @@ for (gtsv, gttrf, gttrs, elty) in
             end
             du2  = similar(d, $elty, n-2)
             ipiv = similar(d, BlasInt, n)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(gttrf)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gttrf), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
                    Ptr{BlasInt}, Ptr{BlasInt}),
                   &n, dl, d, du, du2, ipiv, info)
-            @lapackerror
+            chklapackerror(info[])
             dl, d, du, du2, ipiv
         end
+
         #       SUBROUTINE DGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, INFO )
         #       .. Scalar Arguments ..
         #       CHARACTER          TRANS
@@ -1695,18 +2393,50 @@ for (gtsv, gttrf, gttrs, elty) in
             if n != size(B,1)
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)), but should have $n"))
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(gttrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gttrs), liblapack), Void,
                    (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
                     Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                    &trans, &n, &size(B,2), dl, d, du, du2, ipiv, B, &max(1,stride(B,2)), info)
-             @lapackerror
-             B
+            chklapackerror(info[])
+            B
          end
     end
 end
 
+"""
+    gtsv!(dl, d, du, B)
+
+Solves the equation `A * X = B` where `A` is a tridiagonal matrix with
+`dl` on the subdiagonal, `d` on the diagonal, and `du` on the
+superdiagonal.
+
+Overwrites `B` with the solution `X` and returns it.
+"""
+gtsv!(dl::Vector, d::Vector, du::Vector, B::StridedVecOrMat)
+
+"""
+    gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)
+
+Finds the `LU` factorization of a tridiagonal matrix with `dl` on the
+subdiagonal, `d` on the diagonal, and `du` on the superdiagonal.
+
+Modifies `dl`, `d`, and `du` in-place and returns them and the second
+superdiagonal `du2` and the pivoting vector `ipiv`.
+"""
+gttrf!(dl::Vector, d::Vector, du::Vector)
+
+"""
+    gttrs!(trans, dl, d, du, du2, ipiv, B)
+
+Solves the equation `A * X = B` (`trans = N`), `A.' * X = B` (`trans = T`),
+or `A' * X = B` (`trans = C`) using the `LU` factorization computed by
+`gttrf!`. `B` is overwritten with the solution `X`.
+"""
+gttrs!(trans::Char, dl::Vector, d::Vector, du::Vector, du2::Vector,
+       ipiv::Vector{BlasInt}, B::StridedVecOrMat)
+
 ## (OR) orthogonal (or UN, unitary) matrices, extractors and multiplication
 for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
     ((:dorglq_,:dorgqr_,:dorgql_,:dorgrq_,:dormlq_,:dormqr_,:dormql_,:dormrq_,:dgemqrt_,:Float64),
@@ -1728,24 +2458,25 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(orglq)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($orglq), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, &k, A, &max(1,stride(A,2)), tau, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            if m<size(A,1)
+            if m < size(A,1)
                 A[1:m,:]
             else
                 A
             end
         end
+
         # SUBROUTINE DORGQR( M, N, K, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, K, LDA, LWORK, M, N
@@ -1760,26 +2491,27 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(orgqr)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($orgqr), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, &k, A,
                       &max(1,stride(A,2)), tau, work, &lwork,
                       info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            if n<size(A,2)
+            if n < size(A,2)
                 A[:,1:n]
             else
                 A
             end
         end
+
         # SUBROUTINE DORGQL( M, N, K, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, K, LDA, LWORK, M, N
@@ -1794,26 +2526,27 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(orgql)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($orgql), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, &k, A,
                       &max(1,stride(A,2)), tau, work, &lwork,
                       info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            if n<size(A,2)
+            if n < size(A,2)
                 A[:,1:n]
             else
                 A
             end
         end
+
         # SUBROUTINE DORGRQ( M, N, K, A, LDA, TAU, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       INTEGER            INFO, K, LDA, LWORK, M, N
@@ -1828,26 +2561,27 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(orgrq)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($orgrq), liblapack), Void,
                       (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &m, &n, &k, A,
                       &max(1,stride(A,2)), tau, work, &lwork,
                       info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            if n<size(A,2)
+            if n < size(A,2)
                 A[:,1:n]
             else
                 A
             end
         end
+
         #      SUBROUTINE DORMLQ( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
         #                         WORK, LWORK, INFO )
         #      .. Scalar Arguments ..
@@ -1860,14 +2594,14 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             chktrans(trans)
             chkside(side)
             chkstride1(A, C)
-            m, n = ndims(C)==2 ? size(C) : (size(C, 1), 1)
-            nA    = size(A, 2)
-            k     = length(tau)
+            m,n = ndims(C) == 2 ? size(C) : (size(C, 1), 1)
+            mA, nA  = size(A)
+            k   = length(tau)
             if side == 'L' && m != nA
                 throw(DimensionMismatch("For a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $nA"))
             end
-            if side == 'R' && n != nA
-                throw(DimensionMismatch("For a right-sided multiplication, the second dimension of C, $m, must equal the second dimension of A, $nA"))
+            if side == 'R' && n != mA
+                throw(DimensionMismatch("For a right-sided multiplication, the second dimension of C, $n, must equal the first dimension of A, $mA"))
             end
             if side == 'L' && k > m
                 throw(DimensionMismatch("Invalid number of reflectors: k = $k should be <= m = $m"))
@@ -1877,22 +2611,23 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(ormlq)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($ormlq), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &side, &trans, &m, &n, &k, A, &max(1,stride(A,2)), tau,
                       C, &max(1,stride(C,2)), work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             C
         end
+
         #      SUBROUTINE DORMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
         #                         WORK, INFO )
         #      .. Scalar Arguments ..
@@ -1905,9 +2640,9 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             chktrans(trans)
             chkside(side)
             chkstride1(A, C)
-            m, n = ndims(C)==2 ? size(C) : (size(C, 1), 1)
-            mA    = size(A, 1)
-            k     = length(tau)
+            m,n = ndims(C) == 2 ? size(C) : (size(C, 1), 1)
+            mA  = size(A, 1)
+            k   = length(tau)
             if side == 'L' && m != mA
                 throw(DimensionMismatch("For a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $mA"))
             end
@@ -1922,9 +2657,9 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(ormqr)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($ormqr), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1933,14 +2668,15 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                       &k, A, &max(1,stride(A,2)), tau,
                       C, &max(1, stride(C,2)), work, &lwork,
                       info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             C
         end
+
         #      SUBROUTINE DORMQL( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
         #                         WORK, INFO )
         #      .. Scalar Arguments ..
@@ -1953,9 +2689,9 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             chktrans(trans)
             chkside(side)
             chkstride1(A, C)
-            m, n = ndims(C)==2 ? size(C) : (size(C, 1), 1)
-            mA    = size(A, 1)
-            k     = length(tau)
+            m,n = ndims(C) == 2 ? size(C) : (size(C, 1), 1)
+            mA  = size(A, 1)
+            k   = length(tau)
             if side == 'L' && m != mA
                 throw(DimensionMismatch("For a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $mA"))
             end
@@ -1970,9 +2706,9 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(ormql)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($ormql), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -1981,14 +2717,15 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
                       &k, A, &max(1,stride(A,2)), tau,
                       C, &max(1, stride(C,2)), work, &lwork,
                       info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             C
         end
+
         #      SUBROUTINE DORMRQ( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
         #                         WORK, LWORK, INFO )
         #      .. Scalar Arguments ..
@@ -2001,9 +2738,9 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             chktrans(trans)
             chkside(side)
             chkstride1(A, C)
-            m, n = ndims(C)==2 ? size(C) : (size(C, 1), 1)
-            nA    = size(A, 2)
-            k     = length(tau)
+            m,n = ndims(C) == 2 ? size(C) : (size(C, 1), 1)
+            nA  = size(A, 2)
+            k   = length(tau)
             if side == 'L' && m != nA
                 throw(DimensionMismatch("For a left-sided multiplication, the first dimension of C, $m, must equal the second dimension of A, $nA"))
             end
@@ -2018,29 +2755,32 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(ormrq)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($ormrq), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &side, &trans, &m, &n, &k, A, &max(1,stride(A,2)), tau,
                       C, &max(1,stride(C,2)), work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             C
         end
-        function gemqrt!(side::Char, trans::Char, V::Matrix{$elty}, T::Matrix{$elty}, C::StridedVecOrMat{$elty})
+
+        function gemqrt!(side::Char, trans::Char, V::StridedMatrix{$elty}, T::StridedMatrix{$elty}, C::StridedVecOrMat{$elty})
             chktrans(trans)
             chkside(side)
-            chkstride1(T, C)
-            m, n = ndims(C)==2 ? size(C) : (size(C, 1), 1)
+            chkstride1(V, T, C)
+            m,n = ndims(C) == 2 ? size(C) : (size(C, 1), 1)
             nb, k = size(T)
-            if k == 0 return C end
+            if k == 0
+                return C
+            end
             if side == 'L'
                 if !(0 <= k <= m)
                     throw(DimensionMismatch("Wrong value for k = $k: must be between 0 and $m"))
@@ -2069,26 +2809,107 @@ for (orglq, orgqr, orgql, orgrq, ormlq, ormqr, ormql, ormrq, gemqrt, elty) in
             if !(1 <= nb <= k)
                 throw(DimensionMismatch("Wrong value for nb = $nb, which must be between 1 and $k"))
             end
-            ldc = max(1, stride(C,2))
+            ldc = stride(C, 2)
             work = Array($elty, wss)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(gemqrt)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gemqrt), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}),
                 &side, &trans, &m, &n,
                 &k, &nb, V, &ldv,
-                T, &max(1,stride(T,2)), C, &ldc,
+                T, &max(1,stride(T,2)), C, &max(1,ldc),
                 work, info)
-            @lapackerror
+            chklapackerror(info[])
             return C
         end
     end
 end
 
+"""
+    orglq!(A, tau, k = length(tau))
+
+Explicitly finds the matrix `Q` of a `LQ` factorization after calling
+`gelqf!` on `A`. Uses the output of `gelqf!`. `A` is overwritten by `Q`.
+"""
+orglq!(A::StridedMatrix, tau::Vector, k::Integer = length(tau))
+
+"""
+    orgqr!(A, tau, k = length(tau))
+
+Explicitly finds the matrix `Q` of a `QR` factorization after calling
+`geqrf!` on `A`. Uses the output of `geqrf!`. `A` is overwritten by `Q`.
+"""
+orgqr!(A::StridedMatrix, tau::Vector, k::Integer = length(tau))
+
+"""
+    orgql!(A, tau, k = length(tau))
+
+Explicitly finds the matrix `Q` of a `QL` factorization after calling
+`geqlf!` on `A`. Uses the output of `geqlf!`. `A` is overwritten by `Q`.
+"""
+orgql!(A::StridedMatrix, tau::Vector, k::Integer = length(tau))
+
+"""
+    orgrq!(A, tau, k = length(tau))
+
+Explicitly finds the matrix `Q` of a `RQ` factorization after calling
+`gerqf!` on `A`. Uses the output of `gerqf!`. `A` is overwritten by `Q`.
+"""
+orgrq!(A::StridedMatrix, tau::Vector, k::Integer = length(tau))
+
+"""
+    ormlq!(side, trans, A, tau, C)
+
+Computes `Q * C` (`trans = N`), `Q.' * C` (`trans = T`), `Q' * C`
+(`trans = C`) for `side = L` or the equivalent right-sided multiplication
+for `side = R` using `Q` from a `LQ` factorization of `A` computed using
+`gelqf!`. `C` is overwritten.
+"""
+ormlq!(side::Char, trans::Char, A::StridedMatrix, tau::Vector, C::StridedVecOrMat)
+
+"""
+    ormqr!(side, trans, A, tau, C)
+
+Computes `Q * C` (`trans = N`), `Q.' * C` (`trans = T`), `Q' * C`
+(`trans = C`) for `side = L` or the equivalent right-sided multiplication
+for `side = R` using `Q` from a `QR` factorization of `A` computed using
+`geqrf!`. `C` is overwritten.
+"""
+ormqr!(side::Char, trans::Char, A::StridedMatrix, tau::Vector, C::StridedVecOrMat)
+
+"""
+    ormql!(side, trans, A, tau, C)
+
+Computes `Q * C` (`trans = N`), `Q.' * C` (`trans = T`), `Q' * C`
+(`trans = C`) for `side = L` or the equivalent right-sided multiplication
+for `side = R` using `Q` from a `QL` factorization of `A` computed using
+`geqlf!`. `C` is overwritten.
+"""
+ormql!(side::Char, trans::Char, A::StridedMatrix, tau::Vector, C::StridedVecOrMat)
+
+"""
+    ormrq!(side, trans, A, tau, C)
+
+Computes `Q * C` (`trans = N`), `Q.' * C` (`trans = T`), `Q' * C`
+(`trans = C`) for `side = L` or the equivalent right-sided multiplication
+for `side = R` using `Q` from a `RQ` factorization of `A` computed using
+`gerqf!`. `C` is overwritten.
+"""
+ormrq!(side::Char, trans::Char, A::StridedMatrix, tau::Vector, C::StridedVecOrMat)
+
+"""
+    gemqrt!(side, trans, V, T, C)
+
+Computes `Q * C` (`trans = N`), `Q.' * C` (`trans = T`), `Q' * C`
+(`trans = C`) for `side = L` or the equivalent right-sided multiplication
+for `side = R` using `Q` from a `QR` factorization of `A` computed using
+`geqrt!`. `C` is overwritten.
+"""
+gemqrt!(side::Char, trans::Char, V::StridedMatrix, T::StridedMatrix, C::StridedVecOrMat)
+
 # (PO) positive-definite symmetric matrices,
-# Cholesky decomposition, solvers (direct and factored) and inverse.
 for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
     ((:dposv_,:dpotrf_,:dpotri_,:dpotrs_,:dpstrf_,:Float64,:Float64),
      (:sposv_,:spotrf_,:spotri_,:spotrs_,:spstrf_,:Float32,:Float32),
@@ -2103,20 +2924,21 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
         #      DOUBLE PRECISION   A( LDA, * ), B( LDB, * )
         function posv!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(A, B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if size(B,1) != n
                 throw(DimensionMismatch("First dimension of B, $(size(B,1)), and size of A, ($n,$n), must match!"))
             end
-            info    = Array(BlasInt, 1)
-            ccall(($(blasfunc(posv)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($posv), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), B, &max(1,stride(B,2)), info)
-            @assertargsok
-            @assertposdef
+            chkargsok(info[])
+            chkposdef(info[])
             A, B
         end
+
         # SUBROUTINE DPOTRF( UPLO, N, A, LDA, INFO )
         # *     .. Scalar Arguments ..
         #       CHARACTER          UPLO
@@ -2125,22 +2947,23 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
         #       DOUBLE PRECISION   A( LDA, * )
         function potrf!(uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            chksquare(A)
+            checksquare(A)
             chkuplo(uplo)
             lda = max(1,stride(A,2))
             if lda == 0
                 return A, 0
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(potrf)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($potrf), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &size(A,1), A, &lda, info)
-            @assertargsok
+            chkargsok(info[])
             #info[1]>0 means the leading minor of order info[i] is not positive definite
             #ordinarily, throw Exception here, but return error code here
             #this simplifies isposdef! and factorize
-            return A, info[1]
+            return A, info[]
         end
+
         #       SUBROUTINE DPOTRI( UPLO, N, A, LDA, INFO )
         #       .. Scalar Arguments ..
         #       CHARACTER          UPLO
@@ -2150,14 +2973,15 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
         function potri!(uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
             chkuplo(uplo)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(potri)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($potri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &size(A,1), A, &max(1,stride(A,2)), info)
-            @assertargsok
-            @assertnonsingular
+            chkargsok(info[])
+            chknonsingular(info[])
             A
         end
+
         #     SUBROUTINE DPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO )
         #     .. Scalar Arguments ..
         #      CHARACTER          UPLO
@@ -2166,7 +2990,7 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
         #      DOUBLE PRECISION   A( LDA, * ), B( LDB, * )
         function potrs!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(A, B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             nrhs = size(B,2)
             if size(B,1) != n
@@ -2177,15 +3001,16 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
                 return B
             end
             ldb = max(1,stride(B,2))
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(potrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($potrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                     Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                    &uplo, &n, &nrhs, A,
                    &lda, B, &ldb, info)
-            @lapackerror
+            chklapackerror(info[])
             return B
         end
+
         #       SUBROUTINE DPSTRF( UPLO, N, A, LDA, PIV, RANK, TOL, WORK, INFO )
         #       .. Scalar Arguments ..
         #       DOUBLE PRECISION   TOL
@@ -2196,24 +3021,79 @@ for (posv, potrf, potri, potrs, pstrf, elty, rtyp) in
         #       INTEGER            PIV( N )
         function pstrf!(uplo::Char, A::StridedMatrix{$elty}, tol::Real)
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             piv  = similar(A, BlasInt, n)
             rank = Array(BlasInt, 1)
             work = Array($rtyp, 2n)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(pstrf)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($pstrf), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$rtyp}, Ptr{$rtyp}, Ptr{BlasInt}),
                   &uplo, &n, A, &max(1,stride(A,2)), piv, rank, &tol, work, info)
-            @assertargsok
-            A, piv, rank[1], info[1] #Stored in PivotedCholesky
+            chkargsok(info[])
+            A, piv, rank[1], info[] #Stored in PivotedCholesky
         end
     end
 end
 
-## (PT) positive-definite, symmetric, tri-diagonal matrices
-## Direct solvers for general tridiagonal and symmetric positive-definite tridiagonal
+"""
+    posv!(uplo, A, B) -> (A, B)
+
+Finds the solution to `A * X = B` where `A` is a symmetric or Hermitian
+positive definite matrix. If `uplo = U` the upper Cholesky decomposition
+of `A` is computed. If `uplo = L` the lower Cholesky decomposition of `A`
+is computed. `A` is overwritten by its Cholesky decomposition. `B` is
+overwritten with the solution `X`.
+"""
+posv!(uplo::Char, A::StridedMatrix, B::StridedVecOrMat)
+
+"""
+    potrf!(uplo, A)
+
+Computes the Cholesky (upper if `uplo = U`, lower if `uplo = L`)
+decomposition of positive-definite matrix `A`. `A` is overwritten and
+returned with an info code.
+"""
+potrf!(uplo::Char, A::StridedMatrix)
+
+"""
+    potri!(uplo, A)
+
+Computes the inverse of positive-definite matrix `A` after calling
+`potrf!` to find its (upper if `uplo = U`, lower if `uplo = L`) Cholesky
+decomposition.
+
+`A` is overwritten by its inverse and returned.
+"""
+potri!(uplo::Char, A::StridedMatrix)
+
+"""
+    potrs!(uplo, A, B)
+
+Finds the solution to `A * X = B` where `A` is a symmetric or Hermitian
+positive definite matrix whose Cholesky decomposition was computed by
+`potrf!`. If `uplo = U` the upper Cholesky decomposition of `A` was
+computed. If `uplo = L` the lower Cholesky decomposition of `A` was
+computed. `B` is overwritten with the solution `X`.
+"""
+potrs!(uplo::Char, A::StridedMatrix, B::StridedVecOrMat)
+
+"""
+    pstrf!(uplo, A, tol) -> (A, piv, rank, info)
+
+Computes the (upper if `uplo = U`, lower if `uplo = L`) pivoted Cholesky
+decomposition of positive-definite matrix `A` with a user-set tolerance
+`tol`. `A` is overwritten by its Cholesky decomposition.
+
+Returns `A`, the pivots `piv`, the rank of `A`, and an `info` code. If `info = 0`,
+the factorization succeeded. If `info = i > 0 `, then `A` is indefinite or
+rank-deficient.
+"""
+pstrf!(uplo::Char, A::StridedMatrix, tol::Real)
+
+# (PT) positive-definite, symmetric, tri-diagonal matrices
+# Direct solvers for general tridiagonal and symmetric positive-definite tridiagonal
 for (ptsv, pttrf, elty, relty) in
     ((:dptsv_,:dpttrf_,:Float64,:Float64),
      (:sptsv_,:spttrf_,:Float32,:Float32),
@@ -2234,14 +3114,15 @@ for (ptsv, pttrf, elty, relty) in
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(ptsv)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($ptsv), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &n, &size(B,2), D, E, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
+
         #       SUBROUTINE DPTTRF( N, D, E, INFO )
         #       .. Scalar Arguments ..
         #       INTEGER            INFO, N
@@ -2252,15 +3133,34 @@ for (ptsv, pttrf, elty, relty) in
             if length(E) != n - 1
                 throw(DimensionMismatch("E has length $(length(E)), but needs $(n - 1)"))
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(pttrf)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($pttrf), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt}),
                   &n, D, E, info)
-            @lapackerror
+            chklapackerror(info[])
             D, E
         end
     end
 end
+
+"""
+    ptsv!(D, E, B)
+
+Solves `A * X = B` for positive-definite tridiagonal `A`. `D` is the
+diagonal of `A` and `E` is the off-diagonal. `B` is overwritten with the
+solution `X` and returned.
+"""
+ptsv!(D::Vector, E::Vector, B::StridedVecOrMat)
+
+"""
+    pttrf!(D, E)
+
+Computes the LDLt factorization of a positive-definite tridiagonal matrix
+with `D` as diagonal and `E` as off-diagonal. `D` and `E` are overwritten
+and returned.
+"""
+pttrf!(D::Vector, E::Vector)
+
 for (pttrs, elty, relty) in
     ((:dpttrs_,:Float64,:Float64),
      (:spttrs_,:Float32,:Float32))
@@ -2279,28 +3179,29 @@ for (pttrs, elty, relty) in
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(pttrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($pttrs), liblapack), Void,
                   (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &n, &size(B,2), D, E, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
+
 for (pttrs, elty, relty) in
     ((:zpttrs_,:Complex128,:Float64),
      (:cpttrs_,:Complex64,:Float32))
     @eval begin
-#       SUBROUTINE ZPTTRS( UPLO, N, NRHS, D, E, B, LDB, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDB, N, NRHS
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   D( * )
-#       COMPLEX*16         B( LDB, * ), E( * )
+        #       SUBROUTINE ZPTTRS( UPLO, N, NRHS, D, E, B, LDB, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDB, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   D( * )
+        #       COMPLEX*16         B( LDB, * ), E( * )
         function pttrs!(uplo::Char, D::Vector{$relty}, E::Vector{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(B)
             chkuplo(uplo)
@@ -2311,17 +3212,26 @@ for (pttrs, elty, relty) in
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(pttrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($pttrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &n, &size(B,2), D, E, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
 
+"""
+    pttrs!(D, E, B)
+
+Solves `A * X = B` for positive-definite tridiagonal `A` with diagonal
+`D` and off-diagonal `E` after computing `A`'s LDLt factorization using
+`pttrf!`. `B` is overwritten with the solution `X`.
+"""
+pttrs!(D::Vector, E::Vector, B::StridedVecOrMat)
+
 ## (TR) triangular matrices: solver and inverse
 for (trtri, trtrs, elty) in
     ((:dtrtri_,:dtrtrs_,:Float64),
@@ -2337,18 +3247,19 @@ for (trtri, trtrs, elty) in
         #      DOUBLE PRECISION   A( LDA, * )
         function trtri!(uplo::Char, diag::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             chkdiag(diag)
-            lda     = max(1,stride(A, 2))
-            info    = Array(BlasInt, 1)
-            ccall(($(blasfunc(trtri)), liblapack), Void,
+            lda = max(1,stride(A, 2))
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($trtri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}),
                   &uplo, &diag, &n, A, &lda, info)
-            @lapackerror
+            chklapackerror(info[])
             A
         end
+
         #      SUBROUTINE DTRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, INFO )
         # *     .. Scalar Arguments ..
         #       CHARACTER          DIAG, TRANS, UPLO
@@ -2360,55 +3271,76 @@ for (trtri, trtrs, elty) in
             chktrans(trans)
             chkdiag(diag)
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)) but needs $n"))
             end
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(trtrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($trtrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &trans, &diag, &n, &size(B,2), A, &max(1,stride(A,2)),
                   B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
 
+"""
+    trtri!(uplo, diag, A)
+
+Finds the inverse of (upper if `uplo = U`, lower if `uplo = L`)
+triangular matrix `A`. If `diag = N`, `A` has non-unit diagonal elements.
+If `diag = U`, all diagonal elements of `A` are one. `A` is overwritten
+with its inverse.
+"""
+trtri!(uplo::Char, diag::Char, A::StridedMatrix)
+
+"""
+    trtrs!(uplo, trans, diag, A, B)
+
+Solves `A * X = B` (`trans = N`), `A.' * X = B` (`trans = T`), or
+`A' * X = B` (`trans = C`) for (upper if `uplo = U`, lower if `uplo = L`)
+triangular matrix `A`. If `diag = N`, `A` has non-unit diagonal elements.
+If `diag = U`, all diagonal elements of `A` are one. `B` is overwritten
+with the solution `X`.
+"""
+trtrs!(uplo::Char, trans::Char, diag::Char, A::StridedMatrix, B::StridedVecOrMat)
+
 #Eigenvector computation and condition number estimation
 for (trcon, trevc, trrfs, elty) in
     ((:dtrcon_,:dtrevc_,:dtrrfs_,:Float64),
      (:strcon_,:strevc_,:strrfs_,:Float32))
     @eval begin
-        #SUBROUTINE DTRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK,
-        #                   IWORK, INFO )
-        #.. Scalar Arguments ..
-        #CHARACTER          DIAG, NORM, UPLO
-        #INTEGER            INFO, LDA, N
-        #DOUBLE PRECISION   RCOND
-        #.. Array Arguments ..
-        #INTEGER            IWORK( * )
-        #DOUBLE PRECISION   A( LDA, * ), WORK( * )
-        function trcon!(norm::Char, uplo::Char, diag::Char,
-                        A::StridedMatrix{$elty})
+        # SUBROUTINE DTRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK,
+        #                  IWORK, INFO )
+        # .. Scalar Arguments ..
+        # CHARACTER          DIAG, NORM, UPLO
+        # INTEGER            INFO, LDA, N
+        # DOUBLE PRECISION   RCOND
+        # .. Array Arguments ..
+        # INTEGER            IWORK( * )
+        # DOUBLE PRECISION   A( LDA, * ), WORK( * )
+        function trcon!(norm::Char, uplo::Char, diag::Char, A::StridedMatrix{$elty})
             chkstride1(A)
             chkdiag(diag)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             rcond = Array($elty, 1)
             work  = Array($elty, 3n)
             iwork = Array(BlasInt, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(trcon)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            ccall((@blasfunc($trcon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &norm, &uplo, &diag, &n,
                   A, &max(1,stride(A,2)), rcond, work, iwork, info)
-            @lapackerror
+            chklapackerror(info[])
             rcond[1]
         end
+
         # SUBROUTINE DTREVC( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR,
         #                    LDVR, MM, M, WORK, INFO )
         #
@@ -2421,12 +3353,13 @@ for (trcon, trevc, trrfs, elty) in
         # DOUBLE PRECISION   T( LDT, * ), VL( LDVL, * ), VR( LDVR, * ),
         #$                   WORK( * )
         function trevc!(side::Char, howmny::Char, select::Vector{BlasInt}, T::StridedMatrix{$elty},
-                VL::StridedMatrix{$elty} = similar(T), VR::StridedMatrix{$elty} = similar(T))
+                        VL::StridedMatrix{$elty} = similar(T),
+                        VR::StridedMatrix{$elty} = similar(T))
             # Extract
             if side ∉ ['L','R','B']
                 throw(ArgumentError("side argument must be 'L' (left eigenvectors), 'R' (right eigenvectors), or 'B' (both), got $side"))
             end
-            n, mm = chksquare(T), size(VL, 2)
+            n, mm = checksquare(T), size(VL, 2)
             ldt, ldvl, ldvr = stride(T, 2), stride(VL, 2), stride(VR, 2)
 
             # Check
@@ -2435,9 +3368,9 @@ for (trcon, trevc, trrfs, elty) in
             # Allocate
             m = Array(BlasInt, 1)
             work = Array($elty, 3n)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
 
-            ccall(($(blasfunc(trevc)), liblapack), Void,
+            ccall((@blasfunc($trevc), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt},Ptr{BlasInt}, Ptr{BlasInt},
@@ -2446,27 +3379,28 @@ for (trcon, trevc, trrfs, elty) in
                 T, &ldt, VL, &ldvl,
                 VR, &ldvr, &mm, m,
                 work, info)
-            @lapackerror
+            chklapackerror(info[])
 
             #Decide what exactly to return
-            if howmny=='S' #compute selected eigenvectors
-                if side=='L' #left eigenvectors only
+            if howmny == 'S' #compute selected eigenvectors
+                if side == 'L' #left eigenvectors only
                     return select, VL[:,1:m[1]]
-                elseif side=='R' #right eigenvectors only
+                elseif side == 'R' #right eigenvectors only
                     return select, VR[:,1:m[1]]
-                else #side=='B' #both eigenvectors
+                else #side == 'B' #both eigenvectors
                     return select, VL[:,1:m[1]], VR[:,1:m[1]]
                 end
             else #compute all eigenvectors
-                if side=='L' #left eigenvectors only
+                if side == 'L' #left eigenvectors only
                     return VL[:,1:m[1]]
-                elseif side=='R' #right eigenvectors only
+                elseif side == 'R' #right eigenvectors only
                     return VR[:,1:m[1]]
-                else #side=='B' #both eigenvectors
+                else #side == 'B' #both eigenvectors
                     return VL[:,1:m[1]], VR[:,1:m[1]]
                 end
             end
         end
+
         # SUBROUTINE DTRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X,
         #                    LDX, FERR, BERR, WORK, IWORK, INFO )
         # .. Scalar Arguments ..
@@ -2478,7 +3412,8 @@ for (trcon, trevc, trrfs, elty) in
         #$                   WORK( * ), X( LDX, * )
         function trrfs!(uplo::Char, trans::Char, diag::Char,
                 A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty}, X::StridedVecOrMat{$elty},
-                Ferr::StridedVector{$elty}=similar(B, $elty, size(B,2)), Berr::StridedVector{$elty} = similar(B, $elty, size(B,2)))
+                Ferr::StridedVector{$elty} = similar(B, $elty, size(B,2)),
+                Berr::StridedVector{$elty} = similar(B, $elty, size(B,2)))
             chktrans(trans)
             chkuplo(uplo)
             chkdiag(diag)
@@ -2489,48 +3424,48 @@ for (trcon, trevc, trrfs, elty) in
             end
             work = Array($elty, 3n)
             iwork = Array(BlasInt, n)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(trrfs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($trrfs), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                 &uplo, &trans, &diag, &n,
                 &nrhs, A, &max(1,stride(A,2)), B, &max(1,stride(B,2)), X, &max(1,stride(X,2)),
                 Ferr, Berr, work, iwork, info)
-            @lapackerror
+            chklapackerror(info[])
             Ferr, Berr
         end
     end
 end
+
 for (trcon, trevc, trrfs, elty, relty) in
     ((:ztrcon_,:ztrevc_,:ztrrfs_,:Complex128,:Float64),
      (:ctrcon_,:ctrevc_,:ctrrfs_,:Complex64, :Float32))
     @eval begin
-        #SUBROUTINE ZTRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK,
+        # SUBROUTINE ZTRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK,
         #                   RWORK, INFO )
-        #.. Scalar Arguments ..
-        #CHARACTER          DIAG, NORM, UPLO
-        #INTEGER            INFO, LDA, N
-        #DOUBLE PRECISION   RCOND
-        #.. Array Arguments ..
-        #DOUBLE PRECISION   RWORK( * )
-        #COMPLEX*16         A( LDA, * ), WORK( * )
-        function trcon!(norm::Char, uplo::Char, diag::Char,
-                        A::StridedMatrix{$elty})
+        # .. Scalar Arguments ..
+        # CHARACTER          DIAG, NORM, UPLO
+        # INTEGER            INFO, LDA, N
+        # DOUBLE PRECISION   RCOND
+        # .. Array Arguments ..
+        # DOUBLE PRECISION   RWORK( * )
+        # COMPLEX*16         A( LDA, * ), WORK( * )
+        function trcon!(norm::Char, uplo::Char, diag::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             chkdiag(diag)
             rcond = Array($relty, 1)
             work  = Array($elty, 2n)
             rwork = Array($relty, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(trcon)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            ccall((@blasfunc($trcon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty}, Ptr{$elty}, Ptr{$relty}, Ptr{BlasInt}),
                   &norm, &uplo, &diag, &n,
                   A, &max(1,stride(A,2)), rcond, work, rwork, info)
-            @lapackerror
+            chklapackerror(info[])
             rcond[1]
         end
 
@@ -2547,9 +3482,10 @@ for (trcon, trevc, trrfs, elty, relty) in
         # COMPLEX*16         T( LDT, * ), VL( LDVL, * ), VR( LDVR, * ),
         #$                   WORK( * )
         function trevc!(side::Char, howmny::Char, select::Vector{BlasInt}, T::StridedMatrix{$elty},
-                VL::StridedMatrix{$elty} = similar(T), VR::StridedMatrix{$elty} = similar(T))
+                        VL::StridedMatrix{$elty} = similar(T),
+                        VR::StridedMatrix{$elty} = similar(T))
             # Extract
-            n, mm = chksquare(T), size(VL, 2)
+            n, mm = checksquare(T), size(VL, 2)
             ldt, ldvl, ldvr = stride(T, 2), stride(VL, 2), stride(VR, 2)
 
             # Check
@@ -2562,9 +3498,8 @@ for (trcon, trevc, trrfs, elty, relty) in
             m = Array(BlasInt, 1)
             work = Array($elty, 2n)
             rwork = Array($relty, n)
-            info = Array(BlasInt, 1)
-
-            ccall(($(blasfunc(trevc)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($trevc), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -2573,27 +3508,28 @@ for (trcon, trevc, trrfs, elty, relty) in
                 T, &ldt, VL, &ldvl,
                 VR, &ldvr, &mm, m,
                 work, rwork, info)
-            @lapackerror
+            chklapackerror(info[])
 
             #Decide what exactly to return
-            if howmny=='S' #compute selected eigenvectors
-                if side=='L' #left eigenvectors only
+            if howmny == 'S' #compute selected eigenvectors
+                if side == 'L' #left eigenvectors only
                     return select, VL[:,1:m[1]]
-                elseif side=='R' #right eigenvectors only
+                elseif side == 'R' #right eigenvectors only
                     return select, VR[:,1:m[1]]
                 else #side=='B' #both eigenvectors
                     return select, VL[:,1:m[1]], VR[:,1:m[1]]
                 end
             else #compute all eigenvectors
-                if side=='L' #left eigenvectors only
+                if side == 'L' #left eigenvectors only
                     return VL[:,1:m[1]]
-                elseif side=='R' #right eigenvectors only
+                elseif side == 'R' #right eigenvectors only
                     return VR[:,1:m[1]]
                 else #side=='B' #both eigenvectors
                     return VL[:,1:m[1]], VR[:,1:m[1]]
                 end
             end
         end
+
         # SUBROUTINE ZTRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X,
         #                    LDX, FERR, BERR, WORK, IWORK, INFO )
         # .. Scalar Arguments ..
@@ -2604,32 +3540,73 @@ for (trcon, trevc, trrfs, elty, relty) in
         # DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), BERR( * ), FERR( * ),
         #$                   WORK( * ), X( LDX, * )
         function trrfs!(uplo::Char, trans::Char, diag::Char,
-                A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty}, X::StridedVecOrMat{$elty},
-                Ferr::StridedVector{$relty}=similar(B, $relty, size(B,2)), Berr::StridedVector{$relty}=similar(B, $relty, size(B,2)))
+                        A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty}, X::StridedVecOrMat{$elty},
+                        Ferr::StridedVector{$relty} = similar(B, $relty, size(B,2)),
+                        Berr::StridedVector{$relty} = similar(B, $relty, size(B,2)))
             chktrans(trans)
             chkuplo(uplo)
             chkdiag(diag)
-            n=size(A,2)
-            nrhs=size(B,2)
+            n = size(A,2)
+            nrhs = size(B,2)
             if nrhs != size(X,2)
                 throw(DimensionMismatch("Second dimensions of B, $nrhs, and X, $(size(X,2)), must match"))
             end
-            work=Array($elty, 2n)
-            rwork=Array($relty, n)
-            info=Array(BlasInt, 1)
-            ccall(($(blasfunc(trrfs)), liblapack), Void,
+            work  = Array($elty, 2n)
+            rwork = Array($relty, n)
+            info  = Ref{BlasInt}()
+            ccall((@blasfunc($trrfs), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{$relty}, Ptr{BlasInt}),
                 &uplo, &trans, &diag, &n,
                 &nrhs, A, &max(1,stride(A,2)), B, &max(1,stride(B,2)), X, &max(1,stride(X,2)),
                 Ferr, Berr, work, rwork, info)
-            @lapackerror
+            chklapackerror(info[])
             Ferr, Berr
         end
     end
 end
 
+"""
+    trcon!(norm, uplo, diag, A)
+
+Finds the reciprocal condition number of (upper if `uplo = U`, lower if
+`uplo = L`) triangular matrix `A`. If `diag = N`, `A` has non-unit
+diagonal elements. If `diag = U`, all diagonal elements of `A` are one.
+If `norm = I`, the condition number is found in the infinity norm. If
+`norm = O` or `1`, the condition number is found in the one norm.
+"""
+trcon!(norm::Char, uplo::Char, diag::Char, A::StridedMatrix)
+
+"""
+    trevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))
+
+Finds the eigensystem of an upper triangular matrix `T`. If `side = R`,
+the right eigenvectors are computed. If `side = L`, the left
+eigenvectors are computed. If `side = B`, both sets are computed. If
+`howmny = A`, all eigenvectors are found. If `howmny = B`, all
+eigenvectors are found and backtransformed using `VL` and `VR`. If
+`howmny = S`, only the eigenvectors corresponding to the values in
+`select` are computed.
+"""
+trevc!(side::Char, howmny::Char, select::Vector{BlasInt}, T::StridedMatrix,
+        VL::StridedMatrix = similar(T), VR::StridedMatrix = similar(T))
+
+"""
+    trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)
+
+Estimates the error in the solution to `A * X = B` (`trans = N`),
+`A.' * X = B` (`trans = T`), `A' * X = B` (`trans = C`) for `side = L`,
+or the equivalent equations a right-handed `side = R` `X * A` after
+computing `X` using `trtrs!`. If `uplo = U`, `A` is upper triangular.
+If `uplo = L`, `A` is lower triangular. If `diag = N`, `A` has non-unit
+diagonal elements. If `diag = U`, all diagonal elements of `A` are one.
+`Ferr` and `Berr` are optional inputs. `Ferr` is the forward error and
+`Berr` is the backward error, each component-wise.
+"""
+trrfs!(uplo::Char, trans::Char, diag::Char, A::StridedMatrix, B::StridedVecOrMat,
+       X::StridedVecOrMat, Ferr::StridedVector, Berr::StridedVector)
+
 ## (ST) Symmetric tridiagonal - eigendecomposition
 for (stev, stebz, stegr, stein, elty) in
     ((:dstev_,:dstebz_,:dstegr_,:dstein_,:Float64),
@@ -2638,8 +3615,6 @@ for (stev, stebz, stegr, stein, elty) in
 #     , (:cstev_,:Complex64)
      )
     @eval begin
-        #*  DSTEV computes all eigenvalues and, optionally, eigenvectors of a
-        #*  real symmetric tridiagonal matrix A.
         function stev!(job::Char, dv::Vector{$elty}, ev::Vector{$elty})
             n = length(dv)
             if length(ev) != n - 1
@@ -2647,14 +3622,15 @@ for (stev, stebz, stegr, stein, elty) in
             end
             Zmat = similar(dv, $elty, (n, job != 'N' ? n : 0))
             work = Array($elty, max(1, 2n-2))
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(stev)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($stev), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &job, &n, dv, ev, Zmat, &n, work, info)
-            @lapackerror
+            chklapackerror(info[])
             dv, Zmat
         end
+
         #*  DSTEBZ computes the eigenvalues of a symmetric tridiagonal
         #*  matrix T.  The user may ask for all eigenvalues, all eigenvalues
         #*  in the half-open interval (VL, VU], or the IL-th through IU-th
@@ -2672,8 +3648,8 @@ for (stev, stebz, stegr, stein, elty) in
             isplit = similar(dv, BlasInt,n)
             work = Array($elty, 4*n)
             iwork = Array(BlasInt,3*n)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(stebz)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($stebz), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                 Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                 Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -2684,17 +3660,10 @@ for (stev, stebz, stegr, stein, elty) in
                 dv, ev, m, nsplit,
                 w, iblock, isplit, work,
                 iwork, info)
-                @lapackerror
+            chklapackerror(info[])
             w[1:m[1]], iblock[1:m[1]], isplit[1:nsplit[1]]
         end
-        #*  DSTEGR computes selected eigenvalues and, optionally, eigenvectors
-        #*  of a real symmetric tridiagonal matrix T. Any such unreduced matrix has
-        #*  a well defined set of pairwise different real eigenvalues, the corresponding
-        #*  real eigenvectors are pairwise orthogonal.
-        #*
-        #*  The spectrum may be computed either completely or partially by specifying
-        #*  either an interval (VL,VU] or a range of indices IL:IU for the desired
-        #*  eigenvalues.
+
         function stegr!(jobz::Char, range::Char, dv::Vector{$elty}, ev::Vector{$elty}, vl::Real, vu::Real, il::Integer, iu::Integer)
             n = length(dv)
             if length(ev) != n - 1
@@ -2708,12 +3677,12 @@ for (stev, stebz, stegr, stein, elty) in
             Z = similar(dv, $elty, ldz, n)
             isuppz = similar(dv, BlasInt, 2n)
             work = Array($elty, 1)
-            lwork = -one(BlasInt)
+            lwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
-            liwork = -one(BlasInt)
-            info = Array(BlasInt, 1)
+            liwork = BlasInt(-1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(stegr)), liblapack), Void,
+                ccall((@blasfunc($stegr), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty},
                     Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                     Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -2724,6 +3693,7 @@ for (stev, stebz, stegr, stein, elty) in
                     &iu, abstol, m, w,
                     Z, &ldz, isuppz, work,
                     &lwork, iwork, &liwork, info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
                     work = Array($elty, lwork)
@@ -2731,16 +3701,9 @@ for (stev, stebz, stegr, stein, elty) in
                     iwork = Array(BlasInt, liwork)
                 end
             end
-            @lapackerror
             w[1:m[1]], Z[:,1:m[1]]
         end
-        #*  DSTEIN computes the eigenvectors of a real symmetric tridiagonal
-        #*  matrix T corresponding to specified eigenvalues, using inverse
-        #*  iteration.
-        #      SUBROUTINE DSTEIN( N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK,
-        #     $                   IWORK, IFAIL, INFO )
-        # We allow the user to specify exactly which eigenvectors to get by
-        # specifying the eigenvalues (which may be approximate) via w_in
+
         function stein!(dv::Vector{$elty}, ev_in::Vector{$elty}, w_in::Vector{$elty}, iblock_in::Vector{BlasInt}, isplit_in::Vector{BlasInt})
             n = length(dv)
             if length(ev_in) != n - 1
@@ -2770,22 +3733,22 @@ for (stev, stebz, stegr, stein, elty) in
             else
                 isplit[1:length(isplit_in)] = isplit_in
             end
-
             z = similar(dv, $elty,(n,m))
-            work = Array($elty, 5*n)
+            work  = Array($elty, 5*n)
             iwork = Array(BlasInt,n)
             ifail = Array(BlasInt,m)
-            info = Array(BlasInt,1)
-
-            ccall(($(blasfunc(stein)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            ccall((@blasfunc($stein), liblapack), Void,
                 (Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                 Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                 Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                 Ptr{BlasInt}),
                 &n, dv, ev, &m, w, iblock, isplit, z, &ldz, work, iwork, ifail, info)
-
-            @lapackerror
-            all(ifail.==0) || error("failed to converge eigenvectors:\n$(nonzeros(ifail))")
+            chklapackerror(info[])
+            if any(ifail .!= 0)
+                # TODO: better error message / type
+                error("failed to converge eigenvectors:\n$(nonzeros(ifail))")
+            end
             z
         end
     end
@@ -2797,6 +3760,53 @@ stein!(dv::Vector, ev::Vector, w_in::Vector)=stein!(dv, ev, w_in, zeros(BlasInt,
 # Allow user to specify just one eigenvector to get in stein!
 stein!(dv::Vector, ev::Vector, eval::Real)=stein!(dv, ev, [eval], zeros(BlasInt,0), zeros(BlasInt,0))
 
+"""
+    stev!(job, dv, ev) -> (dv, Zmat)
+
+Computes the eigensystem for a symmetric tridiagonal matrix with `dv` as
+diagonal and `ev` as off-diagonal. If `job = N` only the eigenvalues are
+found and returned in `dv`. If `job = V` then the eigenvectors are also found
+and returned in `Zmat`.
+"""
+stev!(job::Char, dv::Vector, ev::Vector)
+
+"""
+    stebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)
+
+Computes the eigenvalues for a symmetric tridiagonal matrix with `dv` as
+diagonal and `ev` as off-diagonal. If `range = A`, all the eigenvalues
+are found. If `range = V`, the eigenvalues in the half-open interval
+`(vl, vu]` are found. If `range = I`, the eigenvalues with indices between
+`il` and `iu` are found. If `order = B`, eigvalues are ordered within a
+block. If `order = E`, they are ordered across all the blocks.
+`abstol` can be set as a tolerance for convergence.
+"""
+stebz!(range::Char, order::Char, vl, vu, il::Integer, iu::Integer, abstol::Real, dv::Vector, ev::Vector)
+
+"""
+    stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)
+
+Computes the eigenvalues (`jobz = N`) or eigenvalues and eigenvectors
+(`jobz = V`) for a symmetric tridiagonal matrix with `dv` as diagonal
+and `ev` as off-diagonal. If `range = A`, all the eigenvalues
+are found. If `range = V`, the eigenvalues in the half-open interval
+`(vl, vu]` are found. If `range = I`, the eigenvalues with indices between
+`il` and `iu` are found. The eigenvalues are returned in `w` and the eigenvectors
+in `Z`.
+"""
+stegr!(jobz::Char, range::Char, dv::Vector, ev::Vector, vl::Real, vu::Real, il::Integer, iu::Integer)
+
+"""
+    stein!(dv, ev_in, w_in, iblock_in, isplit_in)
+
+Computes the eigenvectors for a symmetric tridiagonal matrix with `dv`
+as diagonal and `ev_in` as off-diagonal. `w_in` specifies the input
+eigenvalues for which to find corresponding eigenvectors. `iblock_in`
+specifies the submatrices corresponding to the eigenvalues in `w_in`.
+`isplit_in` specifies the splitting points between the submatrix blocks.
+"""
+stein!(dv::Vector, ev_in::Vector, w_in::Vector, iblock_in::Vector{BlasInt}, isplit_in::Vector{BlasInt})
+
 ## (SY) symmetric real matrices - Bunch-Kaufman decomposition,
 ## solvers (direct and factored) and inverse.
 for (syconv, sysv, sytrf, sytri, sytrs, elty) in
@@ -2812,17 +3822,18 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function syconv!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
-            work  = Array($elty, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(syconv)), liblapack), Void,
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($syconv), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &uplo, &'C', &n, A, &max(1,stride(A,2)), ipiv, work, info)
-            @lapackerror
+            chklapackerror(info[])
             A, work
         end
+
         #       SUBROUTINE DSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
         #                         LWORK, INFO )
         #       .. Scalar Arguments ..
@@ -2833,7 +3844,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), WORK( * )
         function sysv!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(A,B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
@@ -2841,22 +3852,23 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             ipiv  = similar(A, BlasInt, n)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(sysv)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sysv), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)),
                       work, &lwork, info)
-                @assertargsok
-                @assertnonsingular
-                if lwork < 0
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             B, A, ipiv
         end
+
         #       SUBROUTINE DSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       CHARACTER          UPLO
@@ -2866,7 +3878,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function sytrf!(uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             ipiv  = similar(A, BlasInt, n)
             if n == 0
@@ -2874,21 +3886,22 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(sytrf)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sytrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &uplo, &n, A, &stride(A,2), ipiv, work, &lwork, info)
-                @assertargsok
-                @assertnonsingular
-                if lwork < 0
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             return A, ipiv
         end
+
         #       SUBROUTINE DSYTRI2( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
         # *     .. Scalar Arguments ..
         #       CHARACTER          UPLO
@@ -2898,18 +3911,18 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
 #         function sytri!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
 #             chkstride1(A)
-#             n = chksquare(A)
+#             n = checksquare(A)
 #             chkuplo(uplo)
 #             work  = Array($elty, 1)
 #             lwork = BlasInt(-1)
-#             info  = Array(BlasInt, 1)
+#             info  = Ref{BlasInt}()
 #             for i in 1:2
-#                 ccall(($(blasfunc(sytri)), liblapack), Void,
+#                 ccall((@blasfunc($sytri), liblapack), Void,
 #                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
 #                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
 #                       &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
 #                 @assertargsok
-#                 @assertnonsingular
+#                 chknonsingular(info[])
 #                 if lwork < 0
 #                     lwork = BlasInt(real(work[1]))
 #                     work = Array($elty, lwork)
@@ -2917,6 +3930,7 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
 #             end
 #             A
 #         end
+
         #      SUBROUTINE DSYTRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
         #     .. Scalar Arguments ..
         #      CHARACTER          UPLO
@@ -2926,18 +3940,19 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         #      DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function sytri!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
-            work  = Array($elty, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(sytri)), liblapack), Void,
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, info)
-            @assertargsok
-            @assertnonsingular
+            chkargsok(info[])
+            chknonsingular(info[])
             A
         end
+
         #       SUBROUTINE DSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
         #
         #       .. Scalar Arguments ..
@@ -2949,60 +3964,184 @@ for (syconv, sysv, sytrf, sytri, sytrs, elty) in
         function sytrs!(uplo::Char, A::StridedMatrix{$elty},
                        ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
             chkstride1(A,B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(sytrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
+
+# Rook-pivoting variants of symmetric-matrix algorithms
+for (sysv, sytrf, sytri, sytrs, elty) in
+    ((:dsysv_rook_,:dsytrf_rook_,:dsytri_rook_,:dsytrs_rook_,:Float64),
+     (:ssysv_rook_,:ssytrf_rook_,:ssytri_rook_,:ssytrs_rook_,:Float32))
+    @eval begin
+        #       SUBROUTINE DSYSV_ROOK(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
+        #                             LWORK, INFO )
+        #       .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
+        #       .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), WORK( * )
+        function sysv_rook!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
+            chkstride1(A,B)
+            n = checksquare(A)
+            chkuplo(uplo)
+            if n != size(B,1)
+                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+            end
+            ipiv  = similar(A, BlasInt, n)
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sysv), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
+                       Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)),
+                      work, &lwork, info)
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
+                    lwork = BlasInt(real(work[1]))
+                    work = Array($elty, lwork)
+                end
+            end
+            B, A, ipiv
+        end
+
+        #       SUBROUTINE DSYTRF_ROOK(UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LWORK, N
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
+        function sytrf_rook!(uplo::Char, A::StridedMatrix{$elty})
+            chkstride1(A)
+            n = checksquare(A)
+            chkuplo(uplo)
+            ipiv  = similar(A, BlasInt, n)
+            if n == 0
+                return A, ipiv
+            end
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sytrf), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                       Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &uplo, &n, A, &stride(A,2), ipiv, work, &lwork, info)
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
+                    lwork = BlasInt(real(work[1]))
+                    work = Array($elty, lwork)
+                end
+            end
+            return A, ipiv
+        end
+
+        #      SUBROUTINE DSYTRI_ROOK( UPLO, N, A, LDA, IPIV, WORK, INFO )
+        #     .. Scalar Arguments ..
+        #      CHARACTER          UPLO
+        #      INTEGER            INFO, LDA, N
+        #     .. Array Arguments ..
+        #      INTEGER            IPIV( * )
+        #      DOUBLE PRECISION   A( LDA, * ), WORK( * )
+        function sytri_rook!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
+            chkstride1(A)
+            n = checksquare(A)
+            chkuplo(uplo)
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytri), liblapack), Void,
+                  (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
+                  &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, info)
+            chkargsok(info[])
+            chknonsingular(info[])
+            A
+        end
+
+        #       SUBROUTINE DSYTRS_ROOK( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
+        #
+        #       .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, N, NRHS
+        #       .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * )
+        function sytrs_rook!(uplo::Char, A::StridedMatrix{$elty},
+                       ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
+            chkstride1(A,B)
+            n = checksquare(A)
+            chkuplo(uplo)
+            if n != size(B,1)
+                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+            end
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytrs), liblapack), Void,
+                  (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                  &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
+            chklapackerror(info[])
+            B
+        end
+    end
+end
+
 ## (SY) hermitian matrices - eigendecomposition, Bunch-Kaufman decomposition,
 ## solvers (direct and factored) and inverse.
 for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
     ((:zsyconv_,:zhesv_,:zhetrf_,:zhetri_,:zhetrs_,:Complex128, :Float64),
      (:csyconv_,:chesv_,:chetrf_,:chetri_,:chetrs_,:Complex64, :Float32))
     @eval begin
-   #   SUBROUTINE ZSYCONV( UPLO, WAY, N, A, LDA, IPIV, WORK, INFO )
-   # 22 *
-   # 23 *       .. Scalar Arguments ..
-   # 24 *       CHARACTER          UPLO, WAY
-   # 25 *       INTEGER            INFO, LDA, N
-   # 26 *       ..
-   # 27 *       .. Array Arguments ..
-   # 28 *       INTEGER            IPIV( * )
-   # 29 *       COMPLEX*16         A( LDA, * ), WORK( * )
+       #   SUBROUTINE ZSYCONV( UPLO, WAY, N, A, LDA, IPIV, WORK, INFO )
+       #
+       #        .. Scalar Arguments ..
+       #        CHARACTER          UPLO, WAY
+       #        INTEGER            INFO, LDA, N
+       #        ..
+       #        .. Array Arguments ..
+       #        INTEGER            IPIV( * )
+       #        COMPLEX*16         A( LDA, * ), WORK( * )
         function syconv!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
-            work  = Array($elty, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(syconv)), liblapack), Void,
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($syconv), liblapack), Void,
                   (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &uplo, &'C', &n, A, &max(1,stride(A,2)), ipiv, work, info)
-            @lapackerror
+            chklapackerror(info[])
             A, work
         end
-#       SUBROUTINE ZHESV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
+
+        #       SUBROUTINE ZHESV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
         function hesv!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(A,B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
@@ -3010,51 +4149,53 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
             ipiv  = similar(A, BlasInt, n)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(hesv)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($hesv), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)),
                       work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             B, A, ipiv
         end
-#       SUBROUTINE ZHETRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * )
+
+        #       SUBROUTINE ZHETRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
         function hetrf!(uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             ipiv  = similar(A, BlasInt, n)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
+            info  = Ref{BlasInt}()
             for i in 1:2
-                ccall(($(blasfunc(hetrf)), liblapack), Void,
+                ccall((@blasfunc($hetrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
-                @assertargsok
-                @assertnonsingular
-                if lwork < 0
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, ipiv
         end
+
 #       SUBROUTINE ZHETRI2( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
 # *     .. Scalar Arguments ..
 #       CHARACTER          UPLO
@@ -3065,17 +4206,17 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
 #       COMPLEX*16         A( LDA, * ), WORK( * )
 #         function hetri!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
 #             chkstride1(A)
-#             n = chksquare(A)
+#             n = checksquare(A)
 #             chkuplo(uplo)
 #             work  = Array($elty, 1)
 #             lwork = BlasInt(-1)
-#             info  = Array(BlasInt, 1)
+#             info  = Ref{BlasInt}()
 #             for i in 1:2
-#                 ccall(($(blasfunc(hetri)), liblapack), Void,
+#                 ccall((@blasfunc($hetri), liblapack), Void,
 #                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
 #                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
 #                       &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
-#                 @lapackerror
+#                 chklapackerror(info[])
 #                 if lwork < 0
 #                     lwork = BlasInt(real(work[1]))
 #                     work = Array($elty, lwork)
@@ -3083,68 +4224,189 @@ for (syconv, hesv, hetrf, hetri, hetrs, elty, relty) in
 #             end
 #             A
 #         end
-#       SUBROUTINE ZHETRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, N
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * )
+
+
+        #       SUBROUTINE ZHETRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
         function hetri!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
-            work  = Array($elty, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(hetri)), liblapack), Void,
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($hetri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, info)
-            @lapackerror
+            chklapackerror(info[])
             A
         end
-#       SUBROUTINE ZHETRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, LDB, N, NRHS
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * )
+
+        #       SUBROUTINE ZHETRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * )
         function hetrs!(uplo::Char, A::StridedMatrix{$elty},
                        ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
             chkstride1(A,B)
-            n = chksquare(A)
+            n = checksquare(A)
+            if n != size(B,1)
+                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+            end
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($hetrs), liblapack), Void,
+                  (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                  &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
+            chklapackerror(info[])
+            B
+        end
+    end
+end
+
+for (hesv, hetrf, hetri, hetrs, elty, relty) in
+    ((:zhesv_rook_,:zhetrf_rook_,:zhetri_rook_,:zhetrs_rook_,:Complex128, :Float64),
+     (:chesv_rook_,:chetrf_rook_,:chetri_rook_,:chetrs_rook_,:Complex64, :Float32))
+    @eval begin
+        #       SUBROUTINE ZHESV_ROOK( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
+        function hesv_rook!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
+            chkstride1(A,B)
+            n = checksquare(A)
+            chkuplo(uplo)
+            if n != size(B,1)
+                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+            end
+            ipiv  = similar(A, BlasInt, n)
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($hesv), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
+                       Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)),
+                      work, &lwork, info)
+                chklapackerror(info[])
+                if i == 1
+                    lwork = BlasInt(real(work[1]))
+                    work = Array($elty, lwork)
+                end
+            end
+            B, A, ipiv
+        end
+
+        #       SUBROUTINE ZHETRF_ROOK( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
+        function hetrf_rook!(uplo::Char, A::StridedMatrix{$elty})
+            chkstride1(A)
+            n = checksquare(A)
+            chkuplo(uplo)
+            ipiv  = similar(A, BlasInt, n)
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
+            for i in 1:2
+                ccall((@blasfunc($hetrf), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                       Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
+                    lwork = BlasInt(real(work[1]))
+                    work = Array($elty, lwork)
+                end
+            end
+            A, ipiv
+        end
+
+        #       SUBROUTINE ZHETRI_ROOK( UPLO, N, A, LDA, IPIV, WORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
+        function hetri_rook!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
+            chkstride1(A)
+            n = checksquare(A)
+            chkuplo(uplo)
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($hetri), liblapack), Void,
+                  (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
+                  &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, info)
+            chklapackerror(info[])
+            A
+        end
+
+        #       SUBROUTINE ZHETRS_ROOK( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * )
+        function hetrs_rook!(uplo::Char, A::StridedMatrix{$elty},
+                             ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
+            chkstride1(A,B)
+            n = checksquare(A)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(hetrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($hetrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
+
 for (sysv, sytrf, sytri, sytrs, elty, relty) in
     ((:zsysv_,:zsytrf_,:zsytri_,:zsytrs_,:Complex128, :Float64),
      (:csysv_,:csytrf_,:csytri_,:csytrs_,:Complex64, :Float32))
     @eval begin
-#       SUBROUTINE ZSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
-#      $                  LWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
+        #       SUBROUTINE ZSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
+        #      $                  LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
         function sysv!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
             chkstride1(A,B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
@@ -3152,55 +4414,57 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
             ipiv  = similar(A, BlasInt, n)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(sysv)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sysv), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)),
                       work, &lwork, info)
-                @assertargsok
-                @assertnonsingular
-                if lwork < 0
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             B, A, ipiv
         end
-#       SUBROUTINE ZSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * )
+
+        #       SUBROUTINE ZSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
         function sytrf!(uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
-            ipiv  = similar(A, BlasInt, n)
+            ipiv = similar(A, BlasInt, n)
             if n == 0
                 return A, ipiv
             end
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(sytrf)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sytrf), liblapack), Void,
                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
-                @assertargsok
-                @assertnonsingular
-                if lwork < 0
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, ipiv
         end
+
 #       SUBROUTINE ZSYTRI2( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
 # *     .. Scalar Arguments ..
 #       CHARACTER          UPLO
@@ -3211,17 +4475,17 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
 #       COMPLEX*16         A( LDA, * ), WORK( * )
 #         function sytri!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
 #             chkstride1(A)
-#             n = chksquare(A)
+#             n = checksquare(A)
 #             chkuplo(uplo)
 #             work  = Array($elty, 1)
 #             lwork = BlasInt(-1)
-#             info  = Array(BlasInt, 1)
+#             info  = Ref{BlasInt}()
 #             for i in 1:2
-#                 ccall(($(blasfunc(sytri)), liblapack), Void,
+#                 ccall((@blasfunc($sytri), liblapack), Void,
 #                       (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
 #                        Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
 #                       &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
-#                 @lapackerror
+#                 chklapackerror(info[])
 #                 if lwork < 0
 #                     lwork = BlasInt(real(work[1]))
 #                     work = Array($elty, lwork)
@@ -3229,54 +4493,273 @@ for (sysv, sytrf, sytri, sytrs, elty, relty) in
 #             end
 #             A
 #         end
-#       SUBROUTINE ZSYTRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, N
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * )
+
+        #       SUBROUTINE ZSYTRI( UPLO, N, A, LDA, IPIV, WORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
         function sytri!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
+            chkuplo(uplo)
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytri), liblapack), Void,
+                  (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
+                  &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, info)
+            chklapackerror(info[])
+            A
+        end
+
+        #       SUBROUTINE ZSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * )
+        function sytrs!(uplo::Char, A::StridedMatrix{$elty},
+                       ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
+            chkstride1(A,B)
+            n = checksquare(A)
+            chkuplo(uplo)
+            if n != size(B,1)
+                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+            end
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytrs), liblapack), Void,
+                  (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                   Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                  &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
+            chklapackerror(info[])
+            B
+        end
+    end
+end
+
+for (sysv, sytrf, sytri, sytrs, elty, relty) in
+    ((:zsysv_rook_,:zsytrf_rook_,:zsytri_rook_,:zsytrs_rook_,:Complex128, :Float64),
+     (:csysv_rook_,:csytrf_rook_,:csytri_rook_,:csytrs_rook_,:Complex64, :Float32))
+    @eval begin
+        #       SUBROUTINE ZSYSV_ROOK(UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK,
+        #      $                      LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, LWORK, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
+        function sysv_rook!(uplo::Char, A::StridedMatrix{$elty}, B::StridedVecOrMat{$elty})
+            chkstride1(A,B)
+            n = checksquare(A)
+            chkuplo(uplo)
+            if n != size(B,1)
+                throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
+            end
+            ipiv  = similar(A, BlasInt, n)
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sysv), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
+                       Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)),
+                      work, &lwork, info)
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
+                    lwork = BlasInt(real(work[1]))
+                    work = Array($elty, lwork)
+                end
+            end
+            B, A, ipiv
+        end
+
+        #       SUBROUTINE ZSYTRF_ROOK( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
+        function sytrf_rook!(uplo::Char, A::StridedMatrix{$elty})
+            chkstride1(A)
+            n = checksquare(A)
+            chkuplo(uplo)
+            ipiv = similar(A, BlasInt, n)
+            if n == 0
+                return A, ipiv
+            end
+            work  = Array($elty, 1)
+            lwork = BlasInt(-1)
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($sytrf), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                       Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, &lwork, info)
+                chkargsok(info[])
+                chknonsingular(info[])
+                if i == 1
+                    lwork = BlasInt(real(work[1]))
+                    work = Array($elty, lwork)
+                end
+            end
+            A, ipiv
+        end
+
+        #       SUBROUTINE ZSYTRI_ROOK( UPLO, N, A, LDA, IPIV, WORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
+        function sytri_rook!(uplo::Char, A::StridedMatrix{$elty}, ipiv::Vector{BlasInt})
+            chkstride1(A)
+            n = checksquare(A)
             chkuplo(uplo)
-            work  = Array($elty, n)
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(sytri)), liblapack), Void,
+            work = Array($elty, n)
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytri), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}),
                   &uplo, &n, A, &max(1,stride(A,2)), ipiv, work, info)
-            @lapackerror
+            chklapackerror(info[])
             A
         end
-#       SUBROUTINE ZSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          UPLO
-#       INTEGER            INFO, LDA, LDB, N, NRHS
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IPIV( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * )
-        function sytrs!(uplo::Char, A::StridedMatrix{$elty},
-                       ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
+
+        #       SUBROUTINE ZSYTRS_ROOK( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          UPLO
+        #       INTEGER            INFO, LDA, LDB, N, NRHS
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IPIV( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * )
+        function sytrs_rook!(uplo::Char, A::StridedMatrix{$elty},
+                             ipiv::Vector{BlasInt}, B::StridedVecOrMat{$elty})
             chkstride1(A,B)
-            n = chksquare(A)
+            n = checksquare(A)
             chkuplo(uplo)
             if n != size(B,1)
                 throw(DimensionMismatch("B has first dimension $(size(B,1)), but needs $n"))
             end
-            info  = Array(BlasInt, 1)
-            ccall(($(blasfunc(sytrs)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($sytrs), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                   &uplo, &n, &size(B,2), A, &max(1,stride(A,2)), ipiv, B, &max(1,stride(B,2)), info)
-            @lapackerror
+            chklapackerror(info[])
             B
         end
     end
 end
 
+"""
+    syconv!(uplo, A, ipiv) -> (A, work)
+
+Converts a symmetric matrix `A` (which has been factorized into a
+triangular matrix) into two matrices `L` and `D`. If `uplo = U`, `A`
+is upper triangular. If `uplo = L`, it is lower triangular. `ipiv` is
+the pivot vector from the triangular factorization. `A` is overwritten
+by `L` and `D`.
+"""
+syconv!(uplo::Char, A::StridedMatrix, ipiv::Vector{BlasInt})
+
+"""
+    sysv!(uplo, A, B) -> (B, A, ipiv)
+
+Finds the solution to `A * X = B` for symmetric matrix `A`. If `uplo = U`,
+the upper half of `A` is stored. If `uplo = L`, the lower half is stored.
+`B` is overwritten by the solution `X`. `A` is overwritten by its
+Bunch-Kaufman factorization. `ipiv` contains pivoting information about the
+factorization.
+"""
+sysv!(uplo::Char, A::StridedMatrix, B::StridedVecOrMat)
+
+"""
+    sytrf!(uplo, A) -> (A, ipiv)
+
+Computes the Bunch-Kaufman factorization of a symmetric matrix `A`. If
+`uplo = U`, the upper half of `A` is stored. If `uplo = L`, the lower
+half is stored.
+
+Returns `A`, overwritten by the factorization, and a pivot vector `ipiv`.
+"""
+sytrf!(uplo::Char, A::StridedMatrix)
+
+"""
+    sytri!(uplo, A, ipiv)
+
+Computes the inverse of a symmetric matrix `A` using the results of
+`sytrf!`. If `uplo = U`, the upper half of `A` is stored. If `uplo = L`,
+the lower half is stored. `A` is overwritten by its inverse.
+"""
+sytri!(uplo::Char, A::StridedMatrix, ipiv::Vector{BlasInt})
+
+"""
+    sytrs!(uplo, A, ipiv, B)
+
+Solves the equation `A * X = B` for a symmetric matrix `A` using the
+results of `sytrf!`. If `uplo = U`, the upper half of `A` is stored.
+If `uplo = L`, the lower half is stored. `B` is overwritten by the
+solution `X`.
+"""
+sytrs!(uplo::Char, A::StridedMatrix, ipiv::Vector{BlasInt}, B::StridedVecOrMat)
+
+
+"""
+    hesv!(uplo, A, B) -> (B, A, ipiv)
+
+Finds the solution to `A * X = B` for Hermitian matrix `A`. If `uplo = U`,
+the upper half of `A` is stored. If `uplo = L`, the lower half is stored.
+`B` is overwritten by the solution `X`. `A` is overwritten by its
+Bunch-Kaufman factorization. `ipiv` contains pivoting information about the
+factorization.
+"""
+hesv!(uplo::Char, A::StridedMatrix, B::StridedVecOrMat)
+
+"""
+    hetrf!(uplo, A) -> (A, ipiv)
+
+Computes the Bunch-Kaufman factorization of a Hermitian matrix `A`. If
+`uplo = U`, the upper half of `A` is stored. If `uplo = L`, the lower
+half is stored.
+
+Returns `A`, overwritten by the factorization, and a pivot vector.
+"""
+hetrf!(uplo::Char, A::StridedMatrix)
+
+"""
+    hetri!(uplo, A, ipiv)
+
+Computes the inverse of a Hermitian matrix `A` using the results of
+`sytrf!`. If `uplo = U`, the upper half of `A` is stored. If `uplo = L`,
+the lower half is stored. `A` is overwritten by its inverse.
+"""
+hetri!(uplo::Char, A::StridedMatrix, ipiv::Vector{BlasInt})
+
+"""
+    hetrs!(uplo, A, ipiv, B)
+
+Solves the equation `A * X = B` for a Hermitian matrix `A` using the
+results of `sytrf!`. If `uplo = U`, the upper half of `A` is stored.
+If `uplo = L`, the lower half is stored. `B` is overwritten by the
+solution `X`.
+"""
+hetrs!(uplo::Char, A::StridedMatrix, ipiv::Vector{BlasInt}, B::StridedVecOrMat)
+
 # Symmetric (real) eigensolvers
 for (syev, syevr, sygvd, elty) in
     ((:dsyev_,:dsyevr_,:dsygvd_,:Float64),
@@ -3290,24 +4773,25 @@ for (syev, syevr, sygvd, elty) in
         #       DOUBLE PRECISION   A( LDA, * ), W( * ), WORK( * )
         function syev!(jobz::Char, uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             W     = similar(A, $elty, n)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(syev)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($syev), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                       Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
                       &jobz, &uplo, &n, A, &max(1,stride(A,2)), W, work, &lwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            jobz=='V' ? (W, A) : W
+            jobz == 'V' ? (W, A) : W
         end
+
         #       SUBROUTINE DSYEVR( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU,
         #      $                   ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK,
         #      $                   IWORK, LIWORK, INFO )
@@ -3319,9 +4803,10 @@ for (syev, syevr, sygvd, elty) in
         # *     .. Array Arguments ..
         #       INTEGER            ISUPPZ( * ), IWORK( * )
         #       DOUBLE PRECISION   A( LDA, * ), W( * ), WORK( * ), Z( LDZ, * )
-        function syevr!(jobz::Char, range::Char, uplo::Char, A::StridedMatrix{$elty}, vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
+        function syevr!(jobz::Char, range::Char, uplo::Char, A::StridedMatrix{$elty},
+                        vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             if range == 'I' && !(1 <= il <= iu <= n)
                 throw(ArgumentError("illegal choice of eigenvalue indices (il = $il, iu = $iu), which must be between 1 and n = $n"))
             end
@@ -3338,13 +4823,13 @@ for (syev, syevr, sygvd, elty) in
                 Z = similar(A, $elty, ldz, n)
             end
             isuppz = similar(A, BlasInt, 2*n)
-            work  = Array($elty, 1)
-            lwork = BlasInt(-1)
-            iwork = Array(BlasInt, 1)
+            work   = Array($elty, 1)
+            lwork  = BlasInt(-1)
+            iwork  = Array(BlasInt, 1)
             liwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(syevr)), liblapack), Void,
+            info   = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($syevr), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
                         Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -3357,8 +4842,8 @@ for (syev, syevr, sygvd, elty) in
                     w, Z, &max(1,ldz), isuppz,
                     work, &lwork, iwork, &liwork,
                     info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                     liwork = iwork[1]
@@ -3367,20 +4852,22 @@ for (syev, syevr, sygvd, elty) in
             end
             w[1:m[1]], Z[:,1:(jobz == 'V' ? m[1] : 0)]
         end
-        syevr!(jobz::Char, A::StridedMatrix{$elty}) = syevr!(jobz, 'A', 'U', A, 0.0, 0.0, 0, 0, -1.0)
+        syevr!(jobz::Char, A::StridedMatrix{$elty}) =
+            syevr!(jobz, 'A', 'U', A, 0.0, 0.0, 0, 0, -1.0)
+
         # Generalized eigenproblem
-#           SUBROUTINE DSYGVD( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK,
-#      $                   LWORK, IWORK, LIWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBZ, UPLO
-#       INTEGER            INFO, ITYPE, LDA, LDB, LIWORK, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IWORK( * )
-#       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), W( * ), WORK( * )
+        #           SUBROUTINE DSYGVD( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK,
+        #      $                   LWORK, IWORK, LIWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBZ, UPLO
+        #       INTEGER            INFO, ITYPE, LDA, LDB, LIWORK, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IWORK( * )
+        #       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), W( * ), WORK( * )
         function sygvd!(itype::Integer, jobz::Char, uplo::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
             chkstride1(A, B)
-            n, m = chksquare(A, B)
+            n, m = checksquare(A, B)
             if n != m
                 throw(DimensionMismatch("Dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
@@ -3388,12 +4875,12 @@ for (syev, syevr, sygvd, elty) in
             ldb = max(1, stride(B, 2))
             w = similar(A, $elty, n)
             work = Array($elty, 1)
-            lwork = -one(BlasInt)
+            lwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
-            liwork = -one(BlasInt)
-            info = Array(BlasInt, 1)
+            liwork = BlasInt(-1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(sygvd)), liblapack), Void,
+                ccall((@blasfunc($sygvd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
@@ -3402,6 +4889,7 @@ for (syev, syevr, sygvd, elty) in
                     A, &lda, B, &ldb,
                     w, work, &lwork, iwork,
                     &liwork, info)
+                chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(work[1])
                     work = Array($elty, lwork)
@@ -3409,8 +4897,7 @@ for (syev, syevr, sygvd, elty) in
                     iwork = Array(BlasInt, liwork)
                 end
             end
-            @assertargsok
-            @assertposdef
+            chkposdef(info[])
             w, A, B
         end
     end
@@ -3420,51 +4907,53 @@ for (syev, syevr, sygvd, elty, relty) in
     ((:zheev_,:zheevr_,:zhegvd_,:Complex128,:Float64),
      (:cheev_,:cheevr_,:chegvd_,:Complex64,:Float32))
     @eval begin
-# SUBROUTINE ZHEEV( JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBZ, UPLO
-#       INTEGER            INFO, LDA, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   RWORK( * ), W( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * )
+        # SUBROUTINE ZHEEV( JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBZ, UPLO
+        #       INTEGER            INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   RWORK( * ), W( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
         function syev!(jobz::Char, uplo::Char, A::StridedMatrix{$elty})
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             W     = similar(A, $relty, n)
             work  = Array($elty, 1)
             lwork = BlasInt(-1)
             rwork = Array($relty, max(1, 3n-2))
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(syev)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($syev), liblapack), Void,
                       (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                       Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty}, Ptr{BlasInt}),
                       &jobz, &uplo, &n, A, &stride(A,2), W, work, &lwork, rwork, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            jobz=='V' ? (W, A) : W
+            jobz == 'V' ? (W, A) : W
         end
-#       SUBROUTINE ZHEEVR( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU,
-#      $                   ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK,
-#      $                   RWORK, LRWORK, IWORK, LIWORK, INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBZ, RANGE, UPLO
-#       INTEGER            IL, INFO, IU, LDA, LDZ, LIWORK, LRWORK, LWORK,
-#      $                   M, N
-#       DOUBLE PRECISION   ABSTOL, VL, VU
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            ISUPPZ( * ), IWORK( * )
-#       DOUBLE PRECISION   RWORK( * ), W( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * ), Z( LDZ, * )
-        function syevr!(jobz::Char, range::Char, uplo::Char, A::StridedMatrix{$elty}, vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
+
+        #       SUBROUTINE ZHEEVR( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU,
+        #      $                   ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK,
+        #      $                   RWORK, LRWORK, IWORK, LIWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBZ, RANGE, UPLO
+        #       INTEGER            IL, INFO, IU, LDA, LDZ, LIWORK, LRWORK, LWORK,
+        #      $                   M, N
+        #       DOUBLE PRECISION   ABSTOL, VL, VU
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            ISUPPZ( * ), IWORK( * )
+        #       DOUBLE PRECISION   RWORK( * ), W( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * ), Z( LDZ, * )
+        function syevr!(jobz::Char, range::Char, uplo::Char, A::StridedMatrix{$elty},
+                        vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             if range == 'I' && !(1 <= il <= iu <= n)
                 throw(ArgumentError("illegal choice of eigenvalue indices (il = $il, iu=$iu), which must be between 1 and n = $n"))
             end
@@ -3482,29 +4971,29 @@ for (syev, syevr, sygvd, elty, relty) in
                 Z = similar(A, $elty, ldz, n)
             end
             isuppz = similar(A, BlasInt, 2*n)
-            work  = Array($elty, 1)
-            lwork = BlasInt(-1)
-            rwork = Array($relty, 1)
+            work   = Array($elty, 1)
+            lwork  = BlasInt(-1)
+            rwork  = Array($relty, 1)
             lrwork = BlasInt(-1)
-            iwork = Array(BlasInt, 1)
+            iwork  = Array(BlasInt, 1)
             liwork = BlasInt(-1)
-            info  = Array(BlasInt, 1)
-            for i in 1:2
-                ccall(($(blasfunc(syevr)), liblapack), Void,
-                    (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
-                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
-                        Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
-                        Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
-                        Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty}, Ptr{BlasInt},
-                            Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
-                        &jobz, &range, &uplo, &n,
-                    A, &lda, &vl, &vu,
-                    &il, &iu, &abstol, m,
-                    w, Z, &ldz, isuppz,
-                    work, &lwork, rwork, &lrwork,
-                    iwork, &liwork, info)
-                @lapackerror
-                if lwork < 0
+            info   = Ref{BlasInt}()
+            for i = 1:2
+                ccall((@blasfunc($syevr), liblapack), Void,
+                      (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
+                       Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
+                       Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                       Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt},
+                       Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty}, Ptr{BlasInt},
+                       Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
+                      &jobz, &range, &uplo, &n,
+                      A, &lda, &vl, &vu,
+                      &il, &iu, &abstol, m,
+                      w, Z, &ldz, isuppz,
+                      work, &lwork, rwork, &lrwork,
+                      iwork, &liwork, info)
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                     lrwork = BlasInt(rwork[1])
@@ -3515,26 +5004,22 @@ for (syev, syevr, sygvd, elty, relty) in
             end
             w[1:m[1]], Z[:,1:(jobz == 'V' ? m[1] : 0)]
         end
-        syevr!(jobz::Char, A::StridedMatrix{$elty}) = syevr!(jobz, 'A', 'U', A, 0.0, 0.0, 0, 0, -1.0)
-#       SUBROUTINE ZHEGVD( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK,
-#      $                   LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO )
-# *
-# *  -- LAPACK driver routine (version 3.3.1) --
-# *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
-# *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
-# *  -- April 2011                                                      --
-# *
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBZ, UPLO
-#       INTEGER            INFO, ITYPE, LDA, LDB, LIWORK, LRWORK, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IWORK( * )
-#       DOUBLE PRECISION   RWORK( * ), W( * )
-#       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
+        syevr!(jobz::Char, A::StridedMatrix{$elty}) =
+            syevr!(jobz, 'A', 'U', A, 0.0, 0.0, 0, 0, -1.0)
+
+        #       SUBROUTINE ZHEGVD( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK,
+        #      $                   LWORK, RWORK, LRWORK, IWORK, LIWORK, INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBZ, UPLO
+        #       INTEGER            INFO, ITYPE, LDA, LDB, LIWORK, LRWORK, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IWORK( * )
+        #       DOUBLE PRECISION   RWORK( * ), W( * )
+        #       COMPLEX*16         A( LDA, * ), B( LDB, * ), WORK( * )
         function sygvd!(itype::Integer, jobz::Char, uplo::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
             chkstride1(A, B)
-            n, m = chksquare(A, B)
+            n, m = checksquare(A, B)
             if n != m
                 throw(DimensionMismatch("Dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
@@ -3542,14 +5027,14 @@ for (syev, syevr, sygvd, elty, relty) in
             ldb = max(1, stride(B, 2))
             w = similar(A, $relty, n)
             work = Array($elty, 1)
-            lwork = -one(BlasInt)
+            lwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
-            liwork = -one(BlasInt)
+            liwork = BlasInt(-1)
             rwork = Array($relty)
-            lrwork = -one(BlasInt)
-            info = Array(BlasInt, 1)
+            lrwork = BlasInt(-1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(sygvd)), liblapack), Void,
+                ccall((@blasfunc($sygvd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt},
                      Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{$relty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$relty},
@@ -3558,6 +5043,7 @@ for (syev, syevr, sygvd, elty, relty) in
                     A, &lda, B, &ldb,
                     w, work, &lwork, rwork,
                     &lrwork, iwork, &liwork, info)
+                chkargsok(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
@@ -3567,13 +5053,51 @@ for (syev, syevr, sygvd, elty, relty) in
                     rwork = Array($relty, lrwork)
                 end
             end
-            @assertargsok
-            @assertposdef
+            chkposdef(info[])
             w, A, B
         end
     end
 end
 
+"""
+    syev!(jobz, uplo, A)
+
+Finds the eigenvalues (`jobz = N`) or eigenvalues and eigenvectors
+(`jobz = V`) of a symmetric matrix `A`. If `uplo = U`, the upper triangle
+of `A` is used. If `uplo = L`, the lower triangle of `A` is used.
+"""
+syev!(jobz::Char, uplo::Char, A::StridedMatrix)
+
+"""
+    syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)
+
+Finds the eigenvalues (`jobz = N`) or eigenvalues and eigenvectors
+(`jobz = V`) of a symmetric matrix `A`. If `uplo = U`, the upper triangle
+of `A` is used. If `uplo = L`, the lower triangle of `A` is used. If
+`range = A`, all the eigenvalues are found. If `range = V`, the
+eigenvalues in the half-open interval `(vl, vu]` are found.
+If `range = I`, the eigenvalues with indices between `il` and `iu` are
+found. `abstol` can be set as a tolerance for convergence.
+
+The eigenvalues are returned in `W` and the eigenvectors in `Z`.
+"""
+syevr!(jobz::Char, range::Char, uplo::Char, A::StridedMatrix,
+       vl::AbstractFloat, vu::AbstractFloat, il::Integer, iu::Integer, abstol::AbstractFloat)
+
+"""
+    sygvd!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (w, A, B)
+
+Finds the generalized eigenvalues (`jobz = N`) or eigenvalues and
+eigenvectors (`jobz = V`) of a symmetric matrix `A` and symmetric
+positive-definite matrix `B`. If `uplo = U`, the upper triangles
+of `A` and `B` are used. If `uplo = L`, the lower triangles of `A` and
+`B` are used. If `itype = 1`, the problem to solve is
+`A * x = lambda * B * x`. If `itype = 2`, the problem to solve is
+`A * B * x = lambda * x`. If `itype = 3`, the problem to solve is
+`B * A * x = lambda * x`.
+"""
+sygvd!(itype::Integer, jobz::Char, uplo::Char, A::StridedMatrix, B::StridedMatrix)
+
 ## (BD) Bidiagonal matrices - singular value decomposition
 for (bdsqr, relty, elty) in
     ((:dbdsqr_,:Float64,:Float64),
@@ -3581,18 +5105,13 @@ for (bdsqr, relty, elty) in
      (:zbdsqr_,:Float64,:Complex128),
      (:cbdsqr_,:Float32,:Complex64))
     @eval begin
-        #*> DBDSQR computes the singular values and, optionally, the right and/or
-        #*> left singular vectors from the singular value decomposition (SVD) of
-        #*> a real N-by-N (upper or lower) bidiagonal matrix B using the implicit
-        #*> zero-shift QR algorithm.
         function bdsqr!(uplo::Char, d::Vector{$relty}, e_::Vector{$relty},
-            Vt::StridedMatrix{$elty}, U::StridedMatrix{$elty}, C::StridedMatrix{$elty})
+                        Vt::StridedMatrix{$elty}, U::StridedMatrix{$elty}, C::StridedMatrix{$elty})
 
             # Extract number
             n = length(d)
             ncvt, nru, ncc = size(Vt, 2), size(U, 1), size(C, 2)
             ldvt, ldu, ldc = max(1, stride(Vt,2)), max(1, stride(U, 2)), max(1, stride(C,2))
-
             # Do checks
             chkuplo(uplo)
             if length(e_) != n - 1
@@ -3610,12 +5129,10 @@ for (bdsqr, relty, elty) in
             if ncc > 0 && ldc < n
                 throw(DimensionMismatch("leading dimension of C, $ldc, must be at least $n"))
             end
-
             # Allocate
             work = Array($relty, 4n)
-            info = Array(BlasInt,1)
-
-            ccall(($(blasfunc(bdsqr)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($bdsqr), liblapack), Void,
                 (Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{BlasInt}, Ptr{$relty}, Ptr{$relty}, Ptr{$elty},
                  Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -3624,13 +5141,24 @@ for (bdsqr, relty, elty) in
                 &ncc, d, e_, Vt,
                 &ldvt, U, &ldu, C,
                 &ldc, work, info)
-
-            @lapackerror
+            chklapackerror(info[])
             d, Vt, U, C #singular values in descending order, P**T * VT, U * Q, Q**T * C
         end
     end
 end
 
+"""
+    bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)
+
+Computes the singular value decomposition of a bidiagonal matrix with
+`d` on the diagonal and `e_` on the off-diagonal. If `uplo = U`, `e_` is
+the superdiagonal. If `uplo = L`, `e_` is the subdiagonal. Can optionally also
+compute the product `Q' * C`.
+
+Returns the singular values in `d`, and the matrix `C` overwritten with `Q' * C`.
+"""
+bdsqr!(uplo::Char, d::Vector, e_::Vector, Vt::StridedMatrix, U::StridedMatrix, C::StridedMatrix)
+
 #Defined only for real types
 for (bdsdc, elty) in
     ((:dbdsdc_,:Float64),
@@ -3651,7 +5179,7 @@ for (bdsdc, elty) in
             n, ldiq, ldq, ldu, ldvt = length(d), 1, 1, 1, 1
             chkuplo(uplo)
             if compq == 'N'
-                lwork = 6n
+                lwork = 6*n
             elseif compq == 'P'
                 warn("COMPQ='P' is not tested")
                 #TODO turn this into an actual LAPACK call
@@ -3659,131 +5187,156 @@ for (bdsdc, elty) in
                 smlsiz=100 #For now, completely overkill
                 ldq = n*(11+2*smlsiz+8*round(Int,log((n/(smlsiz+1)))/log(2)))
                 ldiq = n*(3+3*round(Int,log(n/(smlsiz+1))/log(2)))
-                lwork = 6n
+                lwork = 6*n
             elseif compq == 'I'
                 ldvt=ldu=max(1, n)
-                lwork=3*n^2 + 4n
+                lwork=3*n^2 + 4*n
             else
                 throw(ArgumentError("COMPQ argument must be 'N', 'P' or 'I', got $(repr(compq))"))
             end
-            u = similar(d, $elty, (ldu,  n))
-            vt= similar(d, $elty, (ldvt, n))
-            q = similar(d, $elty, ldq)
-            iq= similar(d, BlasInt, ldiq)
-            work =Array($elty, lwork)
-            iwork=Array(BlasInt, 8n)
-            info =Array(BlasInt, 1)
-            ccall(($(blasfunc(bdsdc)), liblapack), Void,
-           (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
-            Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
-            Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
-            &uplo, &compq, &n, d, e_,
-            u, &ldu, vt, &ldvt,
-            q, iq, work, iwork, info)
-
-            @lapackerror
+            u  = similar(d, $elty, (ldu,  n))
+            vt = similar(d, $elty, (ldvt, n))
+            q  = similar(d, $elty, ldq)
+            iq = similar(d, BlasInt, ldiq)
+            work  = Array($elty, lwork)
+            iwork = Array(BlasInt, 8n)
+            info  = Ref{BlasInt}()
+            ccall((@blasfunc($bdsdc), liblapack), Void,
+               (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
+                Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
+                Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}),
+                &uplo, &compq, &n, d, e_,
+                u, &ldu, vt, &ldvt,
+                q, iq, work, iwork, info)
+            chklapackerror(info[])
             d, e, u, vt, q, iq
         end
     end
 end
 
-# Estimate condition number
+"""
+    bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)
+
+Computes the singular value decomposition of a bidiagonal matrix with `d` on the
+diagonal and `e_` on the off-diagonal using a divide and conqueq method.
+If `uplo = U`, `e_` is the superdiagonal. If `uplo = L`, `e_` is the subdiagonal.
+If `compq = N`, only the singular values are found. If `compq = I`, the singular
+values and vectors are found. If `compq = P`, the singular values
+and vectors are found in compact form. Only works for real types.
+
+Returns the singular values in `d`, and if `compq = P`, the compact singular
+vectors in `iq`.
+"""
+bdsdc!(uplo::Char, compq::Char, d::Vector, e_::Vector)
+
 for (gecon, elty) in
     ((:dgecon_,:Float64),
      (:sgecon_,:Float32))
     @eval begin
+        #  SUBROUTINE DGECON( NORM, N, A, LDA, ANORM, RCOND, WORK, IWORK,
+        #      $                   INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          NORM
+        #       INTEGER            INFO, LDA, N
+        #       DOUBLE PRECISION   ANORM, RCOND
+        # *     ..
+        # *     .. Array Arguments ..
+        #       INTEGER            IWORK( * )
+        #       DOUBLE PRECISION   A( LDA, * ), WORK( * )
         function gecon!(normtype::Char, A::StridedMatrix{$elty}, anorm::$elty)
-#                   SUBROUTINE DGECON( NORM, N, A, LDA, ANORM, RCOND, WORK, IWORK,
-#      $                   INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          NORM
-#       INTEGER            INFO, LDA, N
-#       DOUBLE PRECISION   ANORM, RCOND
-# *     ..
-# *     .. Array Arguments ..
-#       INTEGER            IWORK( * )
-#       DOUBLE PRECISION   A( LDA, * ), WORK( * )
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             lda = max(1, stride(A, 2))
             rcond = Array($elty, 1)
             work = Array($elty, 4n)
             iwork = Array(BlasInt, n)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(gecon)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gecon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{$elty}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}),
                   &normtype, &n, A, &lda, &anorm, rcond, work, iwork,
                   info)
-            @lapackerror
+            chklapackerror(info[])
             rcond[1]
         end
     end
 end
+
 for (gecon, elty, relty) in
     ((:zgecon_,:Complex128,:Float64),
      (:cgecon_,:Complex64, :Float32))
     @eval begin
+        #       SUBROUTINE ZGECON( NORM, N, A, LDA, ANORM, RCOND, WORK, RWORK,
+        #      $                   INFO )
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          NORM
+        #       INTEGER            INFO, LDA, N
+        #       DOUBLE PRECISION   ANORM, RCOND
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   RWORK( * )
+        #       COMPLEX*16         A( LDA, * ), WORK( * )
         function gecon!(normtype::Char, A::StridedMatrix{$elty}, anorm::$relty)
-#       SUBROUTINE ZGECON( NORM, N, A, LDA, ANORM, RCOND, WORK, RWORK,
-#      $                   INFO )
-# *     .. Scalar Arguments ..
-#       CHARACTER          NORM
-#       INTEGER            INFO, LDA, N
-#       DOUBLE PRECISION   ANORM, RCOND
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   RWORK( * )
-#       COMPLEX*16         A( LDA, * ), WORK( * )
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             lda = max(1, stride(A, 2))
             rcond = Array($relty, 1)
             work = Array($elty, 2n)
             rwork = Array($relty, 2n)
-            info = Array(BlasInt, 1)
-            ccall(($(blasfunc(gecon)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($gecon), liblapack), Void,
                   (Ptr{UInt8}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{$relty}, Ptr{$relty}, Ptr{$elty}, Ptr{$relty},
                    Ptr{BlasInt}),
                   &normtype, &n, A, &lda, &anorm, rcond, work, rwork,
                   info)
-            @lapackerror
+            chklapackerror(info[])
             rcond[1]
         end
     end
 end
 
-# Hessenberg form
+"""
+    gecon!(normtype, A, anorm)
+
+Finds the reciprocal condition number of matrix `A`. If `normtype = I`,
+the condition number is found in the infinity norm. If `normtype = O` or
+`1`, the condition number is found in the one norm. `A` must be the
+result of `getrf!` and `anorm` is the norm of `A` in the relevant norm.
+"""
+gecon!(normtype::Char, A::StridedMatrix, anorm)
+
 for (gehrd, elty) in
     ((:dgehrd_,:Float64),
      (:sgehrd_,:Float32),
      (:zgehrd_,:Complex128),
      (:cgehrd_,:Complex64))
     @eval begin
+
+        #                 .. Scalar Arguments ..
+        #       INTEGER            IHI, ILO, INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION  A( LDA, * ), TAU( * ), WORK( * )
         function gehrd!(ilo::Integer, ihi::Integer, A::StridedMatrix{$elty})
-#                 .. Scalar Arguments ..
-#       INTEGER            IHI, ILO, INFO, LDA, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION  A( LDA, * ), TAU( * ), WORK( * )
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
+            chkfinite(A) # balancing routines don't support NaNs and Infs
             tau = similar(A, $elty, max(0,n - 1))
             work = Array($elty, 1)
             lwork = BlasInt(-1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gehrd)), liblapack), Void,
+                ccall((@blasfunc($gehrd), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{BlasInt}),
                     &n, &ilo, &ihi, A,
                     &max(1, stride(A, 2)), tau, work, &lwork,
                     info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
@@ -3794,37 +5347,46 @@ for (gehrd, elty) in
 end
 gehrd!(A::StridedMatrix) = gehrd!(1, size(A, 1), A)
 
-# construct Q from Hessenberg
+"""
+    gehrd!(ilo, ihi, A) -> (A, tau)
+
+Converts a matrix `A` to Hessenberg form. If `A` is balanced with `gebal!`
+then `ilo` and `ihi` are the outputs of `gebal!`. Otherwise they should be
+`ilo = 1` and `ihi = size(A,2)`. `tau` contains the elementary reflectors of
+the factorization.
+"""
+gehrd!(ilo::Integer, ihi::Integer, A::StridedMatrix)
+
 for (orghr, elty) in
     ((:dorghr_,:Float64),
      (:sorghr_,:Float32),
      (:zunghr_,:Complex128),
      (:cunghr_,:Complex64))
     @eval begin
+        # *     .. Scalar Arguments ..
+        #       INTEGER            IHI, ILO, INFO, LDA, LWORK, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
         function orghr!(ilo::Integer, ihi::Integer, A::StridedMatrix{$elty}, tau::StridedVector{$elty})
-# *     .. Scalar Arguments ..
-#       INTEGER            IHI, ILO, INFO, LDA, LWORK, N
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   A( LDA, * ), TAU( * ), WORK( * )
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             if n - length(tau) != 1
                 throw(DimensionMismatch("tau has length $(length(tau)), needs $(n - 1)"))
             end
             work = Array($elty, 1)
             lwork = BlasInt(-1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(orghr)), liblapack), Void,
+                ccall((@blasfunc($orghr), liblapack), Void,
                     (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                      Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt},
                      Ptr{BlasInt}),
                     &n, &ilo, &ihi, A,
                     &max(1, stride(A, 2)), tau, work, &lwork,
                     info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
@@ -3833,22 +5395,30 @@ for (orghr, elty) in
         end
     end
 end
-# Schur forms
+
+"""
+    orghr!(ilo, ihi, A, tau)
+
+Explicitly finds `Q`, the orthogonal/unitary matrix from `gehrd!`. `ilo`,
+`ihi`, `A`, and `tau` must correspond to the input/output to `gehrd!`.
+"""
+orghr!(ilo::Integer, ihi::Integer, A::StridedMatrix, tau::StridedVector)
+
 for (gees, gges, elty) in
     ((:dgees_,:dgges_,:Float64),
      (:sgees_,:sgges_,:Float32))
     @eval begin
+        #     .. Scalar Arguments ..
+        #     CHARACTER          JOBVS, SORT
+        #     INTEGER            INFO, LDA, LDVS, LWORK, N, SDIM
+        #     ..
+        #     .. Array Arguments ..
+        #     LOGICAL            BWORK( * )
+        #     DOUBLE PRECISION   A( LDA, * ), VS( LDVS, * ), WI( * ), WORK( * ),
+        #    $                   WR( * )
         function gees!(jobvs::Char, A::StridedMatrix{$elty})
-#     .. Scalar Arguments ..
-#     CHARACTER          JOBVS, SORT
-#     INTEGER            INFO, LDA, LDVS, LWORK, N, SDIM
-#     ..
-#     .. Array Arguments ..
-#     LOGICAL            BWORK( * )
-#     DOUBLE PRECISION   A( LDA, * ), VS( LDVS, * ), WI( * ), WORK( * ),
-#    $                   WR( * )
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             sdim = Array(BlasInt, 1)
             wr = similar(A, $elty, n)
             wi = similar(A, $elty, n)
@@ -3856,9 +5426,9 @@ for (gees, gges, elty) in
             vs = similar(A, $elty, ldvs, n)
             work = Array($elty, 1)
             lwork = BlasInt(-1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gees)), liblapack), Void,
+                ccall((@blasfunc($gees), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{Void}, Ptr{BlasInt},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                         Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
@@ -3867,26 +5437,27 @@ for (gees, gges, elty) in
                         A, &max(1, stride(A, 2)), sdim, wr,
                         wi, vs, &ldvs, work,
                         &lwork, C_NULL, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, vs, all(wi .== 0) ? wr : complex(wr, wi)
         end
+
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBVSL, JOBVSR, SORT
+        #       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N, SDIM
+        # *     ..
+        # *     .. Array Arguments ..
+        #       LOGICAL            BWORK( * )
+        #       DOUBLE PRECISION   A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
+        #      $                   B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
+        #      $                   VSR( LDVSR, * ), WORK( * )
         function gges!(jobvsl::Char, jobvsr::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBVSL, JOBVSR, SORT
-#       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N, SDIM
-# *     ..
-# *     .. Array Arguments ..
-#       LOGICAL            BWORK( * )
-#       DOUBLE PRECISION   A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
-#      $                   B( LDB, * ), BETA( * ), VSL( LDVSL, * ),
-#      $                   VSR( LDVSR, * ), WORK( * )
             chkstride1(A, B)
-            n, m = chksquare(A, B)
+            n, m = checksquare(A, B)
             if n != m
                 throw(DimensionMismatch("Dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
@@ -3900,9 +5471,9 @@ for (gees, gges, elty) in
             vsr = similar(A, $elty, ldvsr, n)
             work = Array($elty, 1)
             lwork = BlasInt(-1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gges)), liblapack), Void,
+                ccall((@blasfunc($gges), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Void},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                         Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -3915,31 +5486,32 @@ for (gees, gges, elty) in
                     beta, vsl, &ldvsl, vsr,
                     &ldvsr, work, &lwork, C_NULL,
                     info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             A, B, complex(alphar, alphai), beta, vsl[1:(jobvsl == 'V' ? n : 0),:], vsr[1:(jobvsr == 'V' ? n : 0),:]
         end
     end
 end
+
 for (gees, gges, elty, relty) in
     ((:zgees_,:zgges_,:Complex128,:Float64),
      (:cgees_,:cgges_,:Complex64,:Float32))
     @eval begin
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBVS, SORT
+        #       INTEGER            INFO, LDA, LDVS, LWORK, N, SDIM
+        # *     ..
+        # *     .. Array Arguments ..
+        #       LOGICAL            BWORK( * )
+        #       DOUBLE PRECISION   RWORK( * )
+        #       COMPLEX*16         A( LDA, * ), VS( LDVS, * ), W( * ), WORK( * )
         function gees!(jobvs::Char, A::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBVS, SORT
-#       INTEGER            INFO, LDA, LDVS, LWORK, N, SDIM
-# *     ..
-# *     .. Array Arguments ..
-#       LOGICAL            BWORK( * )
-#       DOUBLE PRECISION   RWORK( * )
-#       COMPLEX*16         A( LDA, * ), VS( LDVS, * ), W( * ), WORK( * )
             chkstride1(A)
-            n = chksquare(A)
+            n = checksquare(A)
             sort = 'N'
             sdim = BlasInt(0)
             w = similar(A, $elty, n)
@@ -3948,9 +5520,9 @@ for (gees, gges, elty, relty) in
             work = Array($elty, 1)
             lwork = BlasInt(-1)
             rwork = Array($relty, n)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gees)), liblapack), Void,
+                ccall((@blasfunc($gees), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{Void}, Ptr{BlasInt},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty},
                         Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
@@ -3959,27 +5531,28 @@ for (gees, gges, elty, relty) in
                         A, &max(1, stride(A, 2)), &sdim, w,
                         vs, &ldvs, work, &lwork,
                         rwork, C_NULL, info)
-                @lapackerror
-                if lwork < 0
+                chklapackerror(info[])
+                if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
             A, vs, w
         end
+
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          JOBVSL, JOBVSR, SORT
+        #       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N, SDIM
+        # *     ..
+        # *     .. Array Arguments ..
+        #       LOGICAL            BWORK( * )
+        #       DOUBLE PRECISION   RWORK( * )
+        #       COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
+        #      $                   BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
+        #      $                   WORK( * )
         function gges!(jobvsl::Char, jobvsr::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          JOBVSL, JOBVSR, SORT
-#       INTEGER            INFO, LDA, LDB, LDVSL, LDVSR, LWORK, N, SDIM
-# *     ..
-# *     .. Array Arguments ..
-#       LOGICAL            BWORK( * )
-#       DOUBLE PRECISION   RWORK( * )
-#       COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
-#      $                   BETA( * ), VSL( LDVSL, * ), VSR( LDVSR, * ),
-#      $                   WORK( * )
             chkstride1(A, B)
-            n, m = chksquare(A, B)
+            n, m = checksquare(A, B)
             if n != m
                 throw(DimensionMismatch("Dimensions of A, ($n,$n), and B, ($m,$m), must match"))
             end
@@ -3993,9 +5566,9 @@ for (gees, gges, elty, relty) in
             work = Array($elty, 1)
             lwork = BlasInt(-1)
             rwork = Array($relty, 8n)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             for i = 1:2
-                ccall(($(blasfunc(gges)), liblapack), Void,
+                ccall((@blasfunc($gges), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Void},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                         Ptr{BlasInt}, Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -4008,37 +5581,59 @@ for (gees, gges, elty, relty) in
                     vsl, &ldvsl, vsr, &ldvsr,
                     work, &lwork, rwork, C_NULL,
                     info)
+                chklapackerror(info[])
                 if i == 1
                     lwork = BlasInt(real(work[1]))
                     work = Array($elty, lwork)
                 end
             end
-            @lapackerror
             A, B, alpha, beta, vsl[1:(jobvsl == 'V' ? n : 0),:], vsr[1:(jobvsr == 'V' ? n : 0),:]
         end
     end
 end
-# Reorder Schur forms
+
+"""
+    gees!(jobvs, A) -> (A, vs, w)
+
+Computes the eigenvalues (`jobvs = N`) or the eigenvalues and Schur
+vectors (`jobvs = V`) of matrix `A`. `A` is overwritten by its Schur form.
+
+Returns `A`, `vs` containing the Schur vectors, and `w`, containing the
+eigenvalues.
+"""
+gees!(jobvs::Char, A::StridedMatrix)
+
+
+"""
+    gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)
+
+Computes the generalized eigenvalues, generalized Schur form, left Schur
+vectors (`jobsvl = V`), or right Schur vectors (`jobvsr = V`) of `A` and
+`B`.
+
+The generalized eigenvalues are returned in `alpha` and `beta`. The left Schur
+vectors are returned in `vsl` and the right Schur vectors are returned in `vsr`.
+"""
+gges!(jobvsl::Char, jobvsr::Char, A::StridedMatrix, B::StridedMatrix)
+
 for (trexc, trsen, tgsen, elty) in
     ((:dtrexc_, :dtrsen_, :dtgsen_, :Float64),
      (:strexc_, :strsen_, :stgsen_, :Float32))
     @eval begin
-        trexc!(ifst::BlasInt, ilst::BlasInt, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) = trexc!('V', ifst, ilst, T, Q)
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          COMPQ
+        #       INTEGER            IFST, ILST, INFO, LDQ, LDT, N
+        # *     ..
+        # *     .. Array Arguments ..
+        #       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )
         function trexc!(compq::Char, ifst::BlasInt, ilst::BlasInt, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          COMPQ
-#       INTEGER            IFST, ILST, INFO, LDQ, LDT, N
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )
             chkstride1(T, Q)
-            n = chksquare(T)
+            n = checksquare(T)
             ldt = max(1, stride(T, 2))
             ldq = max(1, stride(Q, 2))
             work = Array($elty, n)
-            info = Array(BlasInt, 1)
-
-            ccall(($(blasfunc(trexc)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($trexc), liblapack), Void,
                   (Ptr{UInt8},  Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{BlasInt},
@@ -4047,23 +5642,25 @@ for (trexc, trsen, tgsen, elty) in
                   T, &ldt, Q, &ldq,
                   &ifst, &ilst,
                   work, info)
-            @lapackerror
+            chklapackerror(info[])
             T, Q
         end
-        trsen!(select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
-            trsen!('N', 'V', select, T, Q)
-        function trsen!(compq::Char, job::Char, select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          COMPQ, JOB
-#       INTEGER            INFO, LDQ, LDT, LIWORK, LWORK, M, N
-#       DOUBLE PRECISION   S, SEP
-# *     ..
-# *     .. Array Arguments ..
-#       LOGICAL            SELECT( * )
-#       INTEGER            IWORK( * )
-#       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WI( * ), WORK( * ), WR( * )
+        trexc!(ifst::BlasInt, ilst::BlasInt, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
+            trexc!('V', ifst, ilst, T, Q)
+
+        # *     .. Scalar Arguments ..
+        #       CHARACTER          COMPQ, JOB
+        #       INTEGER            INFO, LDQ, LDT, LIWORK, LWORK, M, N
+        #       DOUBLE PRECISION   S, SEP
+        # *     ..
+        # *     .. Array Arguments ..
+        #       LOGICAL            SELECT( * )
+        #       INTEGER            IWORK( * )
+        #       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WI( * ), WORK( * ), WR( * )
+        function trsen!(compq::Char, job::Char, select::StridedVector{BlasInt},
+                        T::StridedMatrix{$elty}, Q::StridedMatrix{$elty})
             chkstride1(T, Q)
-            n = chksquare(T)
+            n = checksquare(T)
             ldt = max(1, stride(T, 2))
             ldq = max(1, stride(Q, 2))
             wr = similar(T, $elty, n)
@@ -4073,11 +5670,10 @@ for (trexc, trsen, tgsen, elty) in
             lwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
             liwork = BlasInt(-1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-
             for i = 1:2
-                ccall(($(blasfunc(trsen)), liblapack), Void,
+                ccall((@blasfunc($trsen), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{$elty}, Ptr{BlasInt}, Ptr{Void}, Ptr{Void},
@@ -4088,7 +5684,7 @@ for (trexc, trsen, tgsen, elty) in
                     wr, wi, &m, C_NULL, C_NULL,
                     work, &lwork, iwork, &liwork,
                     info)
-                @lapackerror
+                chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
                     liwork = BlasInt(real(iwork[1]))
@@ -4098,23 +5694,26 @@ for (trexc, trsen, tgsen, elty) in
             end
             T, Q, all(wi .== 0) ? wr : complex(wr, wi)
         end
+        trsen!(select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
+            trsen!('N', 'V', select, T, Q)
+
+        #        .. Scalar Arguments ..
+        #        LOGICAL            WANTQ, WANTZ
+        #        INTEGER            IJOB, INFO, LDA, LDB, LDQ, LDZ, LIWORK, LWORK,
+        #       $                   M, N
+        #        DOUBLE PRECISION   PL, PR
+        #        ..
+        #        .. Array Arguments ..
+        #        LOGICAL            SELECT( * )
+        #        INTEGER            IWORK( * )
+        #        DOUBLE PRECISION   A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
+        #       $                   B( LDB, * ), BETA( * ), DIF( * ), Q( LDQ, * ),
+        #       $                   WORK( * ), Z( LDZ, * )
+        #        ..
         function tgsen!(select::StridedVector{BlasInt}, S::StridedMatrix{$elty}, T::StridedMatrix{$elty},
-                                            Q::StridedMatrix{$elty}, Z::StridedMatrix{$elty})
-# *       .. Scalar Arguments ..
-# *       LOGICAL            WANTQ, WANTZ
-# *       INTEGER            IJOB, INFO, LDA, LDB, LDQ, LDZ, LIWORK, LWORK,
-# *      $                   M, N
-# *       DOUBLE PRECISION   PL, PR
-# *       ..
-# *       .. Array Arguments ..
-# *       LOGICAL            SELECT( * )
-# *       INTEGER            IWORK( * )
-# *       DOUBLE PRECISION   A( LDA, * ), ALPHAI( * ), ALPHAR( * ),
-# *      $                   B( LDB, * ), BETA( * ), DIF( * ), Q( LDQ, * ),
-# *      $                   WORK( * ), Z( LDZ, * )
-# *       ..
+                        Q::StridedMatrix{$elty}, Z::StridedMatrix{$elty})
             chkstride1(S, T, Q, Z)
-            n, nt, nq, nz = chksquare(S, T, Q, Z)
+            n, nt, nq, nz = checksquare(S, T, Q, Z)
             if n != nt
                 throw(DimensionMismatch("Dimensions of S, ($n,$n), and T, ($nt,$nt), must match"))
             end
@@ -4136,11 +5735,10 @@ for (trexc, trsen, tgsen, elty) in
             work = Array($elty, 1)
             liwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-
             for i = 1:2
-                ccall(($(blasfunc(tgsen)), liblapack), Void,
+                ccall((@blasfunc($tgsen), liblapack), Void,
                        (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ptr{$elty},
@@ -4155,7 +5753,7 @@ for (trexc, trsen, tgsen, elty) in
                     &m, C_NULL, C_NULL, C_NULL,
                     work, &lwork, iwork, &liwork,
                     info)
-                @lapackerror
+                chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
                     work   = Array($elty, lwork)
@@ -4172,21 +5770,19 @@ for (trexc, trsen, tgsen, elty) in
     ((:ztrexc_, :ztrsen_, :ztgsen_, :Complex128),
      (:ctrexc_, :ctrsen_, :ctgsen_, :Complex64))
     @eval begin
-        trexc!(ifst::BlasInt, ilst::BlasInt, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) = trexc!('V', ifst, ilst, T, Q)
+        #      .. Scalar Arguments ..
+        #      CHARACTER          COMPQ
+        #      INTEGER            IFST, ILST, INFO, LDQ, LDT, N
+        #      ..
+        #      .. Array Arguments ..
+        #      DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )
         function trexc!(compq::Char, ifst::BlasInt, ilst::BlasInt, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          COMPQ
-#       INTEGER            IFST, ILST, INFO, LDQ, LDT, N
-# *     ..
-# *     .. Array Arguments ..
-#       DOUBLE PRECISION   Q( LDQ, * ), T( LDT, * ), WORK( * )
             chkstride1(T, Q)
-            n = chksquare(T)
+            n = checksquare(T)
             ldt = max(1, stride(T, 2))
             ldq = max(1, stride(Q, 2))
-            info = Array(BlasInt, 1)
-
-            ccall(($(blasfunc(trexc)), liblapack), Void,
+            info = Ref{BlasInt}()
+            ccall((@blasfunc($trexc), liblapack), Void,
                   (Ptr{UInt8},  Ptr{BlasInt},
                    Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                    Ptr{BlasInt}, Ptr{BlasInt},
@@ -4195,33 +5791,34 @@ for (trexc, trsen, tgsen, elty) in
                   T, &ldt, Q, &ldq,
                   &ifst, &ilst,
                   info)
-            @lapackerror
+            chklapackerror(info[])
             T, Q
         end
-        trsen!(select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
-            trsen!('N', 'V', select, T, Q)
-        function trsen!(compq::Char, job::Char, select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty})
-# *     .. Scalar Arguments ..
-#       CHARACTER          COMPQ, JOB
-#       INTEGER            INFO, LDQ, LDT, LWORK, M, N
-#       DOUBLE PRECISION   S, SEP
-# *     ..
-# *     .. Array Arguments ..
-#       LOGICAL            SELECT( * )
-#       COMPLEX            Q( LDQ, * ), T( LDT, * ), W( * ), WORK( * )
+        trexc!(ifst::BlasInt, ilst::BlasInt, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
+            trexc!('V', ifst, ilst, T, Q)
+
+        #      .. Scalar Arguments ..
+        #      CHARACTER          COMPQ, JOB
+        #      INTEGER            INFO, LDQ, LDT, LWORK, M, N
+        #      DOUBLE PRECISION   S, SEP
+        #      ..
+        #      .. Array Arguments ..
+        #      LOGICAL            SELECT( * )
+        #      COMPLEX            Q( LDQ, * ), T( LDT, * ), W( * ), WORK( * )
+        function trsen!(compq::Char, job::Char, select::StridedVector{BlasInt},
+                        T::StridedMatrix{$elty}, Q::StridedMatrix{$elty})
             chkstride1(T, Q)
-            n = chksquare(T)
+            n = checksquare(T)
             ldt = max(1, stride(T, 2))
             ldq = max(1, stride(Q, 2))
             w = similar(T, $elty, n)
             m = sum(select)
             work = Array($elty, 1)
             lwork = BlasInt(-1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-
             for i = 1:2
-                ccall(($(blasfunc(trsen)), liblapack), Void,
+                ccall((@blasfunc($trsen), liblapack), Void,
                     (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                     Ptr{$elty}, Ptr{BlasInt}, Ptr{Void}, Ptr{Void},
@@ -4232,7 +5829,7 @@ for (trexc, trsen, tgsen, elty) in
                     w, &m, C_NULL, C_NULL,
                     work, &lwork,
                     info)
-                @lapackerror
+                chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
                     work   = Array($elty, lwork)
@@ -4240,23 +5837,26 @@ for (trexc, trsen, tgsen, elty) in
             end
             T, Q, w
         end
+        trsen!(select::StridedVector{BlasInt}, T::StridedMatrix{$elty}, Q::StridedMatrix{$elty}) =
+            trsen!('N', 'V', select, T, Q)
+
+        #        .. Scalar Arguments ..
+        #        LOGICAL            WANTQ, WANTZ
+        #        INTEGER            IJOB, INFO, LDA, LDB, LDQ, LDZ, LIWORK, LWORK,
+        #       $                   M, N
+        #        DOUBLE PRECISION   PL, PR
+        #        ..
+        #        .. Array Arguments ..
+        #        LOGICAL            SELECT( * )
+        #        INTEGER            IWORK( * )
+        #        DOUBLE PRECISION   DIF( * )
+        #        COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
+        #       $                   BETA( * ), Q( LDQ, * ), WORK( * ), Z( LDZ, * )
+        #        ..
         function tgsen!(select::StridedVector{BlasInt}, S::StridedMatrix{$elty}, T::StridedMatrix{$elty},
-                                            Q::StridedMatrix{$elty}, Z::StridedMatrix{$elty})
-# *       .. Scalar Arguments ..
-# *       LOGICAL            WANTQ, WANTZ
-# *       INTEGER            IJOB, INFO, LDA, LDB, LDQ, LDZ, LIWORK, LWORK,
-# *      $                   M, N
-# *       DOUBLE PRECISION   PL, PR
-# *       ..
-# *       .. Array Arguments ..
-# *       LOGICAL            SELECT( * )
-# *       INTEGER            IWORK( * )
-# *       DOUBLE PRECISION   DIF( * )
-# *       COMPLEX*16         A( LDA, * ), ALPHA( * ), B( LDB, * ),
-# *      $                   BETA( * ), Q( LDQ, * ), WORK( * ), Z( LDZ, * )
-# *       ..
+                        Q::StridedMatrix{$elty}, Z::StridedMatrix{$elty})
             chkstride1(S, T, Q, Z)
-            n, nt, nq, nz = chksquare(S, T, Q, Z)
+            n, nt, nq, nz = checksquare(S, T, Q, Z)
             if n != nt
                 throw(DimensionMismatch("Dimensions of S, ($n,$n), and T, ($nt,$nt), must match"))
             end
@@ -4277,11 +5877,10 @@ for (trexc, trsen, tgsen, elty) in
             work = Array($elty, 1)
             liwork = BlasInt(-1)
             iwork = Array(BlasInt, 1)
-            info = Array(BlasInt, 1)
+            info = Ref{BlasInt}()
             select = convert(Array{BlasInt}, select)
-
             for i = 1:2
-                ccall(($(blasfunc(tgsen)), liblapack), Void,
+                ccall((@blasfunc($tgsen), liblapack), Void,
                        (Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty},
                         Ptr{BlasInt}, Ptr{$elty}, Ptr{$elty},
@@ -4296,7 +5895,7 @@ for (trexc, trsen, tgsen, elty) in
                     &m, C_NULL, C_NULL, C_NULL,
                     work, &lwork, iwork, &liwork,
                     info)
-                @lapackerror
+                chklapackerror(info[])
                 if i == 1 # only estimated optimal lwork, liwork
                     lwork  = BlasInt(real(work[1]))
                     work   = Array($elty, lwork)
@@ -4309,15 +5908,48 @@ for (trexc, trsen, tgsen, elty) in
     end
 end
 
-# Solves the real Sylvester matrix equation: op(A)*X +- X*op(B) = scale*C and A and B are both upper quasi triangular.
+"""
+    trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
+
+Reorder the Schur factorization of a matrix. If `compq = V`, the Schur
+vectors `Q` are reordered. If `compq = N` they are not modified. `ifst`
+and `ilst` specify the reordering of the vectors.
+"""
+trexc!(compq::Char, ifst::BlasInt, ilst::BlasInt, T::StridedMatrix, Q::StridedMatrix)
+
+"""
+    trsen!(compq, job, select, T, Q) -> (T, Q, w)
+
+Reorder the Schur factorization of a matrix and optionally finds reciprocal
+condition numbers. If `job = N`, no condition numbers are found. If `job = E`,
+only the condition number for this cluster of eigenvalues is found. If
+`job = V`, only the condition number for the invariant subspace is found.
+If `job = B` then the condition numbers for the cluster and subspace are
+found. If `compq = V` the Schur vectors `Q` are updated. If `compq = N`
+the Schur vectors are not modified. `select` determines which
+eigenvalues are in the cluster.
+
+Returns `T`, `Q`, and reordered eigenvalues in `w`.
+"""
+trsen!(compq::Char, job::Char, select::StridedVector{BlasInt}, T::StridedMatrix, Q::StridedMatrix)
+
+"""
+    tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)
+
+Reorders the vectors of a generalized Schur decomposition. `select` specifices
+the eigenvalues in each cluster.
+"""
+tgsen!(select::StridedVector{BlasInt}, S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix)
+
 for (fn, elty, relty) in ((:dtrsyl_, :Float64, :Float64),
                    (:strsyl_, :Float32, :Float32),
                    (:ztrsyl_, :Complex128, :Float64),
                    (:ctrsyl_, :Complex64, :Float32))
     @eval begin
-        function trsyl!(transa::Char, transb::Char, A::StridedMatrix{$elty}, B::StridedMatrix{$elty}, C::StridedMatrix{$elty}, isgn::Int=1)
+        function trsyl!(transa::Char, transb::Char, A::StridedMatrix{$elty},
+                        B::StridedMatrix{$elty}, C::StridedMatrix{$elty}, isgn::Int=1)
             chkstride1(A, B, C)
-            m, n = chksquare(A, B)
+            m, n = checksquare(A, B)
             lda = max(1, stride(A, 2))
             ldb = max(1, stride(B, 2))
             m1, n1 = size(C)
@@ -4325,22 +5957,33 @@ for (fn, elty, relty) in ((:dtrsyl_, :Float64, :Float64),
                 throw(DimensionMismatch("Dimensions of A, ($m,$n), and C, ($m1,$n1), must match"))
             end
             ldc = max(1, stride(C, 2))
-
             scale = Array($relty, 1)
-            info = Array(BlasInt, 1)
-
-            ccall(($(blasfunc(fn)), liblapack), Void,
+            info  = Ref{BlasInt}()
+            ccall((@blasfunc($fn), liblapack), Void,
                 (Ptr{UInt8}, Ptr{UInt8}, Ptr{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt},
                  Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt}, Ptr{$elty}, Ptr{BlasInt},
                  Ptr{$relty}, Ptr{BlasInt}),
                 &transa, &transb, &isgn, &m, &n,
                 A, &lda, B, &ldb, C, &ldc,
                 scale, info)
-            @lapackerror
+            chklapackerror(info[])
             C, scale[1]
         end
     end
 end
 
+"""
+    trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)
+
+Solves the Sylvester matrix equation `A * X +/- X * B = scale*C` where `A` and
+`B` are both quasi-upper triangular. If `transa = N`, `A` is not modified.
+If `transa = T`, `A` is transposed. If `transa = C`, `A` is conjugate
+transposed. Similarly for `transb` and `B`. If `isgn = 1`, the equation
+`A * X + X * B = scale * C` is solved. If `isgn = -1`, the equation
+`A * X - X * B = scale * C` is solved.
+
+Returns `X` (overwriting `C`) and `scale`.
+"""
+trsyl!(transa::Char, transb::Char, A::StridedMatrix, B::StridedMatrix, C::StridedMatrix, isgn::Int=1)
 
 end # module
diff --git a/base/linalg/ldlt.jl b/base/linalg/ldlt.jl
index 1bc5272cf5e15..f3631cc56750e 100644
--- a/base/linalg/ldlt.jl
+++ b/base/linalg/ldlt.jl
@@ -15,6 +15,12 @@ convert{T,S,U<:AbstractMatrix}(::Type{LDLt{T}}, F::LDLt{S,U}) = convert(LDLt{T,U
 convert{T,S,U}(::Type{Factorization{T}}, F::LDLt{S,U}) = convert(LDLt{T,U}, F)
 
 # SymTridiagonal
+"""
+
+    ldltfact!(::SymTridiagonal) -> LDLt
+
+Same as `ldltfact`, but saves space by overwriting the input `A`, instead of creating a copy.
+"""
 function ldltfact!{T<:Real}(S::SymTridiagonal{T})
     n = size(S,1)
     d = S.dv
@@ -26,11 +32,12 @@ function ldltfact!{T<:Real}(S::SymTridiagonal{T})
     return LDLt{T,SymTridiagonal{T}}(S)
 end
 
-doc"""
+"""
     ldltfact(::SymTridiagonal) -> LDLt
 
-Compute an `LDLt` factorization of a real symmetric tridiagonal matrix such that `A = L*Diagonal(d)*L'` where `L` is a unit lower triangular matrix and `d` is a vector. The main use of an `LDLt` factorization `F = ldltfact(A)` is to solve the linear system of equations `Ax = b` with `F\b`.
-
+Compute an `LDLt` factorization of a real symmetric tridiagonal matrix such that `A = L*Diagonal(d)*L'`
+where `L` is a unit lower triangular matrix and `d` is a vector. The main use of an `LDLt`
+factorization `F = ldltfact(A)` is to solve the linear system of equations `Ax = b` with `F\\b`.
 """
 function ldltfact{T}(M::SymTridiagonal{T})
     S = typeof(zero(T)/one(T))
diff --git a/base/linalg/lq.jl b/base/linalg/lq.jl
new file mode 100644
index 0000000000000..8038033770396
--- /dev/null
+++ b/base/linalg/lq.jl
@@ -0,0 +1,169 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# LQ Factorizations
+
+immutable LQ{T,S<:AbstractMatrix} <: Factorization{T}
+    factors::S
+    τ::Vector{T}
+    LQ(factors::AbstractMatrix{T}, τ::Vector{T}) = new(factors, τ)
+end
+
+immutable LQPackedQ{T,S<:AbstractMatrix} <: AbstractMatrix{T}
+    factors::Matrix{T}
+    τ::Vector{T}
+    LQPackedQ(factors::AbstractMatrix{T}, τ::Vector{T}) = new(factors, τ)
+end
+
+LQ{T}(factors::AbstractMatrix{T}, τ::Vector{T}) = LQ{T,typeof(factors)}(factors, τ)
+LQPackedQ{T}(factors::AbstractMatrix{T}, τ::Vector{T}) = LQPackedQ{T,typeof(factors)}(factors, τ)
+
+lqfact!{T<:BlasFloat}(A::StridedMatrix{T}) = LQ(LAPACK.gelqf!(A)...)
+lqfact{T<:BlasFloat}(A::StridedMatrix{T})  = lqfact!(copy(A))
+lqfact(x::Number) = lqfact(fill(x,1,1))
+
+function lq(A::Union{Number, AbstractMatrix}; thin::Bool=true)
+    F = lqfact(A)
+    F[:L], full(F[:Q], thin=thin)
+end
+
+copy(A::LQ) = LQ(copy(A.factors), copy(A.τ))
+convert{T}(::Type{LQ{T}},A::LQ) = LQ(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
+convert{T}(::Type{Factorization{T}}, A::LQ) = convert(LQ{T}, A)
+ctranspose{T}(A::LQ{T}) = QR{T,typeof(A.factors)}(A.factors', A.τ)
+
+function getindex(A::LQ, d::Symbol)
+    m, n = size(A)
+    if d == :L
+        return tril!(A.factors[1:m, 1:min(m,n)])
+    elseif d == :Q
+        return LQPackedQ(A.factors,A.τ)
+    else
+        throw(KeyError(d))
+    end
+end
+
+function getindex(A::LQPackedQ, i::Integer, j::Integer)
+    x = zeros(eltype(A), size(A, 1))
+    x[i] = 1
+    y = zeros(eltype(A), size(A, 2))
+    y[j] = 1
+    return dot(x, A*y)
+end
+
+getq(A::LQ) = LQPackedQ(A.factors, A.τ)
+
+convert{T}(::Type{LQPackedQ{T}}, Q::LQPackedQ) = LQPackedQ(convert(AbstractMatrix{T}, Q.factors), convert(Vector{T}, Q.τ))
+convert{T}(::Type{AbstractMatrix{T}}, Q::LQPackedQ) = convert(LQPackedQ{T}, Q)
+
+size(A::LQ, dim::Integer) = size(A.factors, dim)
+size(A::LQ) = size(A.factors)
+function size(A::LQPackedQ, dim::Integer)
+    if 0 < dim && dim <= 2
+        return size(A.factors, dim)
+    elseif 0 < dim && dim > 2
+        return 1
+    else
+        throw(BoundsError())
+    end
+end
+
+size(A::LQPackedQ) = size(A.factors)
+
+full(A::LQ) = A[:L]*A[:Q]
+#=
+We construct the full eye here, even though it seems ineffecient, because
+every element in the output matrix is a function of all the elements of
+the input matrix. The eye is modified by the elementary reflectors held
+in A, so this is not just an indexing operation. Note that in general
+explicitly constructing Q, rather than using the ldiv or mult methods,
+may be a wasteful allocation.
+=#
+function full{T}(A::LQPackedQ{T}; thin::Bool=true)
+    if thin
+        LAPACK.orglq!(copy(A.factors),A.τ)
+    else
+        A_mul_B!(A, eye(T, size(A.factors,2), size(A.factors,1)))
+    end
+end
+
+## Multiplication by LQ
+A_mul_B!{T<:BlasFloat}(A::LQ{T}, B::StridedVecOrMat{T}) = A[:L]*LAPACK.ormlq!('L','N',A.factors,A.τ,B)
+A_mul_B!{T<:BlasFloat}(A::LQ{T}, B::QR{T}) = A[:L]*LAPACK.ormlq!('L','N',A.factors,A.τ,full(B))
+A_mul_B!{T<:BlasFloat}(A::QR{T}, B::LQ{T}) = A_mul_B!(zeros(full(A)), full(A), full(B))
+function *{TA,TB}(A::LQ{TA},B::StridedVecOrMat{TB})
+    TAB = promote_type(TA, TB)
+    A_mul_B!(convert(Factorization{TAB},A), copy_oftype(B, TAB))
+end
+function *{TA,TB}(A::LQ{TA},B::QR{TB})
+    TAB = promote_type(TA, TB)
+    A_mul_B!(convert(Factorization{TAB},A), convert(Factorization{TAB},B))
+end
+function *{TA,TB}(A::QR{TA},B::LQ{TB})
+    TAB = promote_type(TA, TB)
+    A_mul_B!(convert(Factorization{TAB},A), convert(Factorization{TAB},B))
+end
+
+## Multiplication by Q
+### QB
+A_mul_B!{T<:BlasFloat}(A::LQPackedQ{T}, B::StridedVecOrMat{T})   = LAPACK.ormlq!('L','N',A.factors,A.τ,B)
+function *{TA,TB}(A::LQPackedQ{TA},B::StridedVecOrMat{TB})
+    TAB = promote_type(TA, TB)
+    A_mul_B!(convert(AbstractMatrix{TAB}, A), copy_oftype(B, TAB))
+end
+
+### QcB
+Ac_mul_B!{T<:BlasReal}(A::LQPackedQ{T}, B::StridedVecOrMat{T})    = LAPACK.ormlq!('L','T',A.factors,A.τ,B)
+Ac_mul_B!{T<:BlasComplex}(A::LQPackedQ{T}, B::StridedVecOrMat{T}) = LAPACK.ormlq!('L','C',A.factors,A.τ,B)
+function Ac_mul_B{TA,TB}(A::LQPackedQ{TA}, B::StridedVecOrMat{TB})
+    TAB = promote_type(TA,TB)
+    if size(B,1) == size(A.factors,2)
+        Ac_mul_B!(convert(AbstractMatrix{TAB}, A), copy_oftype(B, TAB))
+    elseif size(B,1) == size(A.factors,1)
+        Ac_mul_B!(convert(AbstractMatrix{TAB}, A), [B; zeros(TAB, size(A.factors, 2) - size(A.factors, 1), size(B, 2))])
+    else
+        throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of A, $(size(A))"))
+    end
+end
+
+### AQ
+A_mul_B!{T<:BlasFloat}(A::StridedMatrix{T}, B::LQPackedQ{T}) = LAPACK.ormlq!('R', 'N', B.factors, B.τ, A)
+function *{TA,TB}(A::StridedMatrix{TA},B::LQPackedQ{TB})
+    TAB = promote_type(TA,TB)
+    if size(B.factors,2) == size(A,2)
+        A_mul_B!(copy_oftype(A, TAB),convert(AbstractMatrix{TAB},B))
+    elseif size(B.factors,1) == size(A,2)
+        A_mul_B!( [A zeros(TAB, size(A,1), size(B.factors,2)-size(B.factors,1))], convert(AbstractMatrix{TAB},B))
+    else
+        throw(DimensionMismatch("second dimension of A, $(size(A,2)), must equal one of the dimensions of B, $(size(B))"))
+    end
+end
+
+### AQc
+A_mul_Bc!{T<:BlasReal}(A::StridedMatrix{T}, B::LQPackedQ{T})    = LAPACK.ormlq!('R','T',B.factors,B.τ,A)
+A_mul_Bc!{T<:BlasComplex}(A::StridedMatrix{T}, B::LQPackedQ{T}) = LAPACK.ormlq!('R','C',B.factors,B.τ,A)
+function A_mul_Bc{TA<:Number,TB<:Number}( A::StridedVecOrMat{TA}, B::LQPackedQ{TB})
+    TAB = promote_type(TA,TB)
+    A_mul_Bc!(copy_oftype(A, TAB), convert(AbstractMatrix{TAB},(B)))
+end
+
+function \{TA,Tb}(A::LQ{TA}, b::StridedVector{Tb})
+    S = promote_type(TA,Tb)
+    m = checksquare(A)
+    m == length(b) || throw(DimensionMismatch("left hand side has $m rows, but right hand side has length $(length(b))"))
+    AA = convert(Factorization{S}, A)
+    x = A_ldiv_B!(AA, copy_oftype(b, S))
+    return x
+end
+function \{TA,TB}(A::LQ{TA},B::StridedMatrix{TB})
+    S = promote_type(TA,TB)
+    m = checksquare(A)
+    m == size(B,1) || throw(DimensionMismatch("left hand side has $m rows, but right hand side has $(size(B,1)) rows"))
+    AA = convert(Factorization{S}, A)
+    X = A_ldiv_B!(AA, copy_oftype(B, S))
+    return X
+end
+
+function A_ldiv_B!{T}(A::LQ{T}, B::StridedVecOrMat{T})
+    Ac_mul_B!(A[:Q], A_ldiv_B!(LowerTriangular(A[:L]),B))
+    return B
+end
diff --git a/base/linalg/lu.jl b/base/linalg/lu.jl
index f3c9f9757dbc0..cc20119186d77 100644
--- a/base/linalg/lu.jl
+++ b/base/linalg/lu.jl
@@ -13,7 +13,9 @@ LU{T}(factors::AbstractMatrix{T}, ipiv::Vector{BlasInt}, info::BlasInt) = LU{T,t
 
 # StridedMatrix
 function lufact!{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true})
-    pivot==Val{false} && return generic_lufact!(A, pivot)
+    if pivot === Val{false}
+        return generic_lufact!(A, pivot)
+    end
     lpt = LAPACK.getrf!(A)
     return LU{T,typeof(A)}(lpt[1], lpt[2], lpt[3])
 end
@@ -70,6 +72,41 @@ end
 lufact{T<:AbstractFloat}(A::Union{AbstractMatrix{T},AbstractMatrix{Complex{T}}}, pivot::Union{Type{Val{false}}, Type{Val{true}}} = Val{true}) = lufact!(copy(A), pivot)
 
 # for all other types we must promote to a type which is stable under division
+"""
+    lufact(A [,pivot=Val{true}]) -> F::LU
+
+Compute the LU factorization of `A`.
+
+In most cases, if `A` is a subtype `S` of `AbstractMatrix{T}` with an element
+type `T` supporting `+`, `-`, `*` and `/`, the return type is `LU{T,S{T}}`. If
+pivoting is chosen (default) the element type should also support `abs` and
+`<`.
+
+The individual components of the factorization `F` can be accessed by indexing:
+
+| Component | Description                         |
+|:----------|:------------------------------------|
+| `F[:L]`   | `L` (lower triangular) part of `LU` |
+| `F[:U]`   | `U` (upper triangular) part of `LU` |
+| `F[:p]`   | (right) permutation `Vector`        |
+| `F[:P]`   | (right) permutation `Matrix`        |
+
+The relationship between `F` and `A` is
+
+`F[:L]*F[:U] == A[F[:p], :]`
+
+`F` further supports the following functions:
+
+| Supported function               | `LU` | `LU{T,Tridiagonal{T}}` |
+|:---------------------------------|:-----|:-----------------------|
+| [`/`](:func:`/`)                 | ✓    |                        |
+| [`\\`](:func:`\\`)               | ✓    | ✓                      |
+| [`cond`](:func:`cond`)           | ✓    |                        |
+| [`det`](:func:`det`)             | ✓    | ✓                      |
+| [`logdet`](:func:`logdet`)       | ✓    | ✓                      |
+| [`logabsdet`](:func:`logabsdet`) | ✓    | ✓                      |
+| [`size`](:func:`size`)           | ✓    | ✓                      |
+"""
 function lufact{T}(A::AbstractMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}})
     S = typeof(zero(T)/one(T))
     lufact!(copy_oftype(A, S), pivot)
@@ -150,7 +187,7 @@ Ac_ldiv_Bc{T<:BlasComplex,S<:StridedMatrix}(A::LU{T,S}, B::StridedVecOrMat{T}) =
 Ac_ldiv_Bc(A::LU, B::StridedVecOrMat) = Ac_ldiv_B(A, ctranspose(B))
 
 function det{T,S}(A::LU{T,S})
-    n = chksquare(A)
+    n = checksquare(A)
     A.info > 0 && return zero(typeof(A.factors[1]))
     P = one(T)
     c = 0
@@ -164,11 +201,11 @@ function det{T,S}(A::LU{T,S})
     return P * s
 end
 
-function logabsdet{T<:Real,S}(A::LU{T,S})  # return log(abs(det)) and sign(det)
-    n = chksquare(A)
+function logabsdet{T,S}(A::LU{T,S})  # return log(abs(det)) and sign(det)
+    n = checksquare(A)
     c = 0
     P = one(T)
-    abs_det = zero(T)
+    abs_det = zero(real(T))
     @inbounds for i = 1:n
         dg_ii = A.factors[i,i]
         P *= sign(dg_ii)
@@ -177,36 +214,13 @@ function logabsdet{T<:Real,S}(A::LU{T,S})  # return log(abs(det)) and sign(det)
         end
         abs_det += log(abs(dg_ii))
     end
-    s = (isodd(c) ? -one(T) : one(T)) * P
+    s = ifelse(isodd(c), -one(real(T)), one(real(T))) * P
     abs_det, s
 end
 
-function logdet{T<:Real,S}(A::LU{T,S})
+function logdet(A::LU)
     d, s = logabsdet(A)
-    if s < 0
-        throw(DomainError())
-    end
-    d
-end
-
-_mod2pi(x::BigFloat) = mod(x, big(2)*π) # we don't want to export this, but we use it below
-_mod2pi(x) = mod2pi(x)
-function logdet{T<:Complex,S}(A::LU{T,S})
-    n = chksquare(A)
-    s = zero(T)
-    c = 0
-    @inbounds for i = 1:n
-        if A.ipiv[i] != i
-            c += 1
-        end
-        s += log(A.factors[i,i])
-    end
-    if isodd(c)
-        s = Complex(real(s), imag(s)+π)
-    end
-    r, a = reim(s)
-    a = π - _mod2pi(π - a) #Take principal branch with argument (-pi,pi]
-    complex(r, a)
+    return d + log(s)
 end
 
 inv!{T<:BlasFloat,S<:StridedMatrix}(A::LU{T,S}) = @assertnonsingular LAPACK.getri!(A.factors, A.ipiv) A.info
@@ -233,7 +247,7 @@ function lufact!{T}(A::Tridiagonal{T}, pivot::Union{Type{Val{false}}, Type{Val{t
         end
         for i = 1:n-2
             # pivot or not?
-            if pivot==Val{false} || abs(d[i]) >= abs(dl[i])
+            if pivot === Val{false} || abs(d[i]) >= abs(dl[i])
                 # No interchange
                 if d[i] != 0
                     fact = dl[i]/d[i]
@@ -256,7 +270,7 @@ function lufact!{T}(A::Tridiagonal{T}, pivot::Union{Type{Val{false}}, Type{Val{t
         end
         if n > 1
             i = n-1
-            if pivot==Val{false} || abs(d[i]) >= abs(dl[i])
+            if pivot === Val{false} || abs(d[i]) >= abs(dl[i])
                 if d[i] != 0
                     fact = dl[i]/d[i]
                     dl[i] = fact
diff --git a/base/linalg/matmul.jl b/base/linalg/matmul.jl
index 2066ff3603efe..8b2f123e9066a 100644
--- a/base/linalg/matmul.jl
+++ b/base/linalg/matmul.jl
@@ -38,8 +38,6 @@ function scale!(C::AbstractMatrix, b::AbstractVector, A::AbstractMatrix)
     end
     C
 end
-scale(A::Matrix, b::Vector) = scale!(similar(A, promote_type(eltype(A),eltype(b))), A, b)
-scale(b::Vector, A::Matrix) = scale!(similar(b, promote_type(eltype(A),eltype(b)), size(A)), b, A)
 
 # Dot products
 
@@ -78,11 +76,11 @@ At_mul_B{T<:BlasComplex}(x::StridedVector{T}, y::StridedVector{T}) = [BLAS.dotu(
 
 # Matrix-vector multiplication
 function (*){T<:BlasFloat,S}(A::StridedMatrix{T}, x::StridedVector{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     A_mul_B!(similar(x, TS, size(A,1)), A, convert(AbstractVector{TS}, x))
 end
 function (*){T,S}(A::AbstractMatrix{T}, x::AbstractVector{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     A_mul_B!(similar(x,TS,size(A,1)),A,x)
 end
 (*)(A::AbstractVector, B::AbstractMatrix) = reshape(A,length(A),1)*B
@@ -101,22 +99,22 @@ end
 A_mul_B!(y::StridedVector, A::StridedVecOrMat, x::StridedVector) = generic_matvecmul!(y, 'N', A, x)
 
 function At_mul_B{T<:BlasFloat,S}(A::StridedMatrix{T}, x::StridedVector{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     At_mul_B!(similar(x,TS,size(A,2)), A, convert(AbstractVector{TS}, x))
 end
 function At_mul_B{T,S}(A::StridedMatrix{T}, x::StridedVector{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     At_mul_B!(similar(x,TS,size(A,2)), A, x)
 end
 At_mul_B!{T<:BlasFloat}(y::StridedVector{T}, A::StridedVecOrMat{T}, x::StridedVector{T}) = gemv!(y, 'T', A, x)
 At_mul_B!(y::StridedVector, A::StridedVecOrMat, x::StridedVector) = generic_matvecmul!(y, 'T', A, x)
 
 function Ac_mul_B{T<:BlasFloat,S}(A::StridedMatrix{T}, x::StridedVector{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     Ac_mul_B!(similar(x,TS,size(A,2)),A,convert(AbstractVector{TS},x))
 end
 function Ac_mul_B{T,S}(A::StridedMatrix{T}, x::StridedVector{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     Ac_mul_B!(similar(x,TS,size(A,2)), A, x)
 end
 
@@ -127,7 +125,7 @@ Ac_mul_B!(y::StridedVector, A::StridedVecOrMat, x::StridedVector) = generic_matv
 # Matrix-matrix multiplication
 
 function (*){T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S})
-    TS = promote_type(arithtype(T), arithtype(S))
+    TS = promote_op(MulFun(), arithtype(T), arithtype(S))
     A_mul_B!(similar(B, TS, (size(A,1), size(B,2))), A, B)
 end
 A_mul_B!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = gemm_wrapper!(C, 'N', 'N', A, B)
@@ -144,14 +142,14 @@ end
 A_mul_B!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_matmatmul!(C, 'N', 'N', A, B)
 
 function At_mul_B{T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S})
-    TS = promote_type(arithtype(T), arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T), arithtype(S))
     At_mul_B!(similar(B, TS, (size(A,2), size(B,2))), A, B)
 end
 At_mul_B!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = is(A,B) ? syrk_wrapper!(C, 'T', A) : gemm_wrapper!(C, 'T', 'N', A, B)
 At_mul_B!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_matmatmul!(C, 'T', 'N', A, B)
 
 function A_mul_Bt{T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S})
-    TS = promote_type(arithtype(T), arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T), arithtype(S))
     A_mul_Bt!(similar(B, TS, (size(A,1), size(B,1))), A, B)
 end
 A_mul_Bt!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = is(A,B) ? syrk_wrapper!(C, 'N', A) : gemm_wrapper!(C, 'N', 'T', A, B)
@@ -168,7 +166,7 @@ end
 A_mul_Bt!(C::StridedVecOrMat, A::StridedVecOrMat, B::StridedVecOrMat) = generic_matmatmul!(C, 'N', 'T', A, B)
 
 function At_mul_Bt{T,S}(A::AbstractMatrix{T}, B::StridedVecOrMat{S})
-    TS = promote_type(arithtype(T), arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T), arithtype(S))
     At_mul_Bt!(similar(B, TS, (size(A,2), size(B,1))), A, B)
 end
 At_mul_Bt!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = gemm_wrapper!(C, 'T', 'T', A, B)
@@ -177,7 +175,7 @@ At_mul_Bt!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_m
 Ac_mul_B{T<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{T}) = At_mul_B(A, B)
 Ac_mul_B!{T<:BlasReal}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = At_mul_B!(C, A, B)
 function Ac_mul_B{T,S}(A::StridedMatrix{T}, B::StridedMatrix{S})
-    TS = promote_type(arithtype(T), arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T), arithtype(S))
     Ac_mul_B!(similar(B, TS, (size(A,2), size(B,2))), A, B)
 end
 Ac_mul_B!{T<:BlasComplex}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = is(A,B) ? herk_wrapper!(C,'C',A) : gemm_wrapper!(C,'C', 'N', A, B)
@@ -186,23 +184,22 @@ Ac_mul_B!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_ma
 A_mul_Bc{T<:BlasFloat,S<:BlasReal}(A::StridedMatrix{T}, B::StridedMatrix{S}) = A_mul_Bt(A, B)
 A_mul_Bc!{T<:BlasFloat,S<:BlasReal}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{S}) = A_mul_Bt!(C, A, B)
 function A_mul_Bc{T,S}(A::StridedMatrix{T}, B::StridedMatrix{S})
-    TS = promote_type(arithtype(T),arithtype(S))
+    TS = promote_op(MulFun(),arithtype(T),arithtype(S))
     A_mul_Bc!(similar(B,TS,(size(A,1),size(B,1))),A,B)
 end
 A_mul_Bc!{T<:BlasComplex}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = is(A,B) ? herk_wrapper!(C, 'N', A) : gemm_wrapper!(C, 'N', 'C', A, B)
 A_mul_Bc!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_matmatmul!(C, 'N', 'C', A, B)
 
-Ac_mul_Bc{T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S}) = Ac_mul_Bc!(similar(B, promote_type(arithtype(T), arithtype(S)), (size(A,2), size(B,1))), A, B)
+Ac_mul_Bc{T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S}) = Ac_mul_Bc!(similar(B, promote_op(MulFun(),arithtype(T), arithtype(S)), (size(A,2), size(B,1))), A, B)
 Ac_mul_Bc!{T<:BlasFloat}(C::StridedMatrix{T}, A::StridedVecOrMat{T}, B::StridedVecOrMat{T}) = gemm_wrapper!(C, 'C', 'C', A, B)
 Ac_mul_Bc!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_matmatmul!(C, 'C', 'C', A, B)
-Ac_mul_Bt{T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S}) = Ac_mul_Bt(similar(B, promote_type(arithtype(A), arithtype(B)), (size(A,2), size(B,1))), A, B)
+Ac_mul_Bt{T,S}(A::AbstractMatrix{T}, B::StridedMatrix{S}) = Ac_mul_Bt(similar(B, promote_op(MulFun(),arithtype(A), arithtype(B)), (size(A,2), size(B,1))), A, B)
 Ac_mul_Bt!(C::StridedMatrix, A::StridedVecOrMat, B::StridedVecOrMat) = generic_matmatmul!(C, 'C', 'T', A, B)
 
 # Supporting functions for matrix multiplication
 
 function copytri!(A::StridedMatrix, uplo::Char, conjugate::Bool=false)
-    n = chksquare(A)
-    @chkuplo
+    n = checksquare(A)
     if uplo == 'U'
         for i = 1:(n-1), j = (i+1):n
             A[j,i] = conjugate ? conj(A[i,j]) : A[i,j]
@@ -211,6 +208,8 @@ function copytri!(A::StridedMatrix, uplo::Char, conjugate::Bool=false)
         for i = 1:(n-1), j = (i+1):n
             A[i,j] = conjugate ? conj(A[j,i]) : A[j,i]
         end
+    else
+        throw(ArgumentError("uplo argument must be 'U' (upper) or 'L' (lower), got $uplo"))
     end
     A
 end
@@ -234,7 +233,7 @@ function gemv!{T<:BlasFloat}(y::StridedVector{T}, tA::Char, A::StridedVecOrMat{T
 end
 
 function syrk_wrapper!{T<:BlasFloat}(C::StridedMatrix{T}, tA::Char, A::StridedVecOrMat{T})
-    nC = chksquare(C)
+    nC = checksquare(C)
     if tA == 'T'
         (nA, mA) = size(A,1), size(A,2)
         tAt = 'N'
@@ -255,14 +254,14 @@ function syrk_wrapper!{T<:BlasFloat}(C::StridedMatrix{T}, tA::Char, A::StridedVe
         return matmul3x3!(C,tA,tAt,A,A)
     end
 
-    if stride(A, 1) == 1 && stride(A, 2) >= size(A, 1)
+    if stride(A, 1) == stride(C, 1) == 1 && stride(A, 2) >= size(A, 1) && stride(C, 2) >= size(C, 1)
         return copytri!(BLAS.syrk!('U', tA, one(T), A, zero(T), C), 'U')
     end
     return generic_matmatmul!(C, tA, tAt, A, A)
 end
 
 function herk_wrapper!{T<:BlasReal}(C::Union{StridedMatrix{T}, StridedMatrix{Complex{T}}}, tA::Char, A::Union{StridedVecOrMat{T}, StridedVecOrMat{Complex{T}}})
-    nC = chksquare(C)
+    nC = checksquare(C)
     if tA == 'C'
         (nA, mA) = size(A,1), size(A,2)
         tAt = 'N'
@@ -286,7 +285,7 @@ function herk_wrapper!{T<:BlasReal}(C::Union{StridedMatrix{T}, StridedMatrix{Com
     # Result array does not need to be initialized as long as beta==0
     #    C = Array(T, mA, mA)
 
-    if stride(A, 1) == 1 && stride(A, 2) >= size(A, 1)
+    if stride(A, 1) == stride(C, 1) == 1 && stride(A, 2) >= size(A, 1) && stride(C, 2) >= size(C, 1)
         return copytri!(BLAS.herk!('U', tA, one(T), A, zero(T), C), 'U', true)
     end
     return generic_matmatmul!(C,tA, tAt, A, A)
@@ -311,12 +310,17 @@ function gemm_wrapper!{T<:BlasFloat}(C::StridedVecOrMat{T}, tA::Char, tB::Char,
         throw(DimensionMismatch("A has dimensions ($mA,$nA) but B has dimensions ($mB,$nB)"))
     end
 
+    if C === A || B === C
+        throw(ArgumentError("output matrix must not be aliased with input matrix"))
+    end
+
     if mA == 0 || nA == 0 || nB == 0
         if size(C) != (mA, nB)
             throw(DimensionMismatch("C has dimensions $(size(C)), should have ($mA,$nB)"))
         end
         return fill!(C,0)
     end
+
     if mA == 2 && nA == 2 && nB == 2
         return matmul2x2!(C,tA,tB,A,B)
     end
@@ -324,7 +328,7 @@ function gemm_wrapper!{T<:BlasFloat}(C::StridedVecOrMat{T}, tA::Char, tB::Char,
         return matmul3x3!(C,tA,tB,A,B)
     end
 
-    if stride(A, 1) == stride(B, 1) == 1 && stride(A, 2) >= size(A, 1) && stride(B, 2) >= size(B, 1)
+    if stride(A, 1) == stride(B, 1) == stride(C, 1) == 1 && stride(A, 2) >= size(A, 1) && stride(B, 2) >= size(B, 1) && stride(C, 2) >= size(C, 1)
         return BLAS.gemm!(tA, tB, one(T), A, B, zero(T), C)
     end
     generic_matmatmul!(C, tA, tB, A, B)
@@ -342,6 +346,7 @@ function copy!{R,S}(B::AbstractVecOrMat{R}, ir_dest::UnitRange{Int}, jr_dest::Un
         Base.copy_transpose!(B, ir_dest, jr_dest, M, jr_src, ir_src)
         tM == 'C' && conj!(B)
     end
+    B
 end
 
 function copy_transpose!{R,S}(B::AbstractMatrix{R}, ir_dest::UnitRange{Int}, jr_dest::UnitRange{Int}, tM::Char, M::AbstractVecOrMat{S}, ir_src::UnitRange{Int}, jr_src::UnitRange{Int})
@@ -420,7 +425,7 @@ end
 function generic_matmatmul{T,S}(tA, tB, A::AbstractVecOrMat{T}, B::AbstractMatrix{S})
     mA, nA = lapack_size(tA, A)
     mB, nB = lapack_size(tB, B)
-    C = similar(B, promote_type(arithtype(T),arithtype(S)), mA, nB)
+    C = similar(B, promote_op(MulFun(),arithtype(T),arithtype(S)), mA, nB)
     generic_matmatmul!(C, tA, tB, A, B)
 end
 
@@ -429,29 +434,41 @@ const Abuf = Array(UInt8, tilebufsize)
 const Bbuf = Array(UInt8, tilebufsize)
 const Cbuf = Array(UInt8, tilebufsize)
 
-function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S})
+function generic_matmatmul!{T,S,R}(C::AbstractMatrix{R}, tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
     mA, nA = lapack_size(tA, A)
     mB, nB = lapack_size(tB, B)
-    if mB != nA
-        throw(DimensionMismatch("matrix A has dimensions ($mA, $nB), matrix B has dimensions ($mB, $nB)"))
-    end
-    if size(C,1) != mA || size(C,2) != nB
-        throw(DimensionMismatch("result C has dimensions $(size(C)), needs ($mA, $nB)"))
-    end
+    mC, nC = size(C)
 
-    if mA == nA == nB == 2
+    if mA == nA == mB == nB == mC == nC == 2
         return matmul2x2!(C, tA, tB, A, B)
     end
-    if mA == nA == nB == 3
+    if mA == nA == mB == nB == mC == nC == 3
         return matmul3x3!(C, tA, tB, A, B)
     end
+    _generic_matmatmul!(C, tA, tB, A, B)
+end
 
+generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S}) = _generic_matmatmul!(C, tA, tB, A, B)
+
+function _generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S})
+    mA, nA = lapack_size(tA, A)
+    mB, nB = lapack_size(tB, B)
+    if mB != nA
+        throw(DimensionMismatch("matrix A has dimensions ($mA,$nA), matrix B has dimensions ($mB,$nB)"))
+    end
+    if size(C,1) != mA || size(C,2) != nB
+        throw(DimensionMismatch("result C has dimensions $(size(C)), needs ($mA,$nB)"))
+    end
+
+    tile_size = 0
+    if isbits(R) && isbits(T) && isbits(S) && (tA == 'N' || tB != 'N')
+        tile_size = floor(Int,sqrt(tilebufsize/max(sizeof(R),sizeof(S),sizeof(T))))
+    end
     @inbounds begin
-    if isbits(R)
-        tile_size = floor(Int,sqrt(tilebufsize/sizeof(R)))
+    if tile_size > 0
         sz = (tile_size, tile_size)
-        Atile = pointer_to_array(convert(Ptr{R}, pointer(Abuf)), sz)
-        Btile = pointer_to_array(convert(Ptr{R}, pointer(Bbuf)), sz)
+        Atile = pointer_to_array(convert(Ptr{T}, pointer(Abuf)), sz)
+        Btile = pointer_to_array(convert(Ptr{S}, pointer(Bbuf)), sz)
 
         z = zero(R)
 
@@ -505,7 +522,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
         if tA == 'N'
             if tB == 'N'
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[i, 1]*B[1, j] + A[i, 1]*B[1, j])
@@ -517,7 +534,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
                 end
             elseif tB == 'T'
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[i, 1]*B[j, 1] + A[i, 1]*B[j, 1])
@@ -529,7 +546,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
                 end
             else
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[i, 1]*B[j, 1] + A[i, 1]*B[j, 1])
@@ -543,7 +560,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
         elseif tA == 'T'
             if tB == 'N'
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[1, i]*B[1, j] + A[1, i]*B[1, j])
@@ -555,7 +572,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
                 end
             elseif tB == 'T'
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[1, i]*B[j, 1] + A[1, i]*B[j, 1])
@@ -567,7 +584,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
                 end
             else
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[1, i]*B[j, 1] + A[1, i]*B[j, 1])
@@ -581,7 +598,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
         else
             if tB == 'N'
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[1, i]*B[1, j] + A[1, i]*B[1, j])
@@ -593,7 +610,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
                 end
             elseif tB == 'T'
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[1, i]*B[j, 1] + A[1, i]*B[j, 1])
@@ -605,7 +622,7 @@ function generic_matmatmul!{T,S,R}(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVe
                 end
             else
                 for i = 1:mA, j = 1:nB
-                    if length(A) == 0 || length(B) == 0
+                    if isempty(A) || isempty(B)
                         Ctmp = zero(R)
                     else
                         Ctmp = zero(A[1, i]*B[j, 1] + A[1, i]*B[j, 1])
@@ -625,7 +642,7 @@ end
 
 # multiply 2x2 matrices
 function matmul2x2{T,S}(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
-    matmul2x2!(similar(B, promote_type(T,S), 2, 2), tA, tB, A, B)
+    matmul2x2!(similar(B, promote_op(MulFun(),T,S), 2, 2), tA, tB, A, B)
 end
 
 function matmul2x2!{T,S,R}(C::AbstractMatrix{R}, tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
@@ -654,7 +671,7 @@ end
 
 # Multiply 3x3 matrices
 function matmul3x3{T,S}(tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
-    matmul3x3!(similar(B, promote_type(T,S), 3, 3), tA, tB, A, B)
+    matmul3x3!(similar(B, promote_op(MulFun(),T,S), 3, 3), tA, tB, A, B)
 end
 
 function matmul3x3!{T,S,R}(C::AbstractMatrix{R}, tA, tB, A::AbstractMatrix{T}, B::AbstractMatrix{S})
diff --git a/base/linalg/qr.jl b/base/linalg/qr.jl
index 5d2d70a0c5418..b4ec2b2582499 100644
--- a/base/linalg/qr.jl
+++ b/base/linalg/qr.jl
@@ -24,8 +24,7 @@ immutable QRPivoted{T,S<:AbstractMatrix} <: Factorization{T}
 end
 QRPivoted{T}(factors::AbstractMatrix{T}, τ::Vector{T}, jpvt::Vector{BlasInt}) = QRPivoted{T,typeof(factors)}(factors, τ, jpvt)
 
-function qrfact!{T}(A::AbstractMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false})
-    pivot==Val{true} && warn("pivoting only implemented for Float32, Float64, Complex64 and Complex128")
+function qrfactUnblocked!{T}(A::AbstractMatrix{T})
     m, n = size(A)
     τ = zeros(T, min(m,n))
     for k = 1:min(m - 1 + !(T<:Real), n)
@@ -36,12 +35,66 @@ function qrfact!{T}(A::AbstractMatrix{T}, pivot::Union{Type{Val{false}}, Type{Va
     end
     QR(A, τ)
 end
-qrfact!{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Type{Val{false}} = Val{false}) = QRCompactWY(LAPACK.geqrt!(A, min(minimum(size(A)), 36))...)
-qrfact!{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Type{Val{true}}) = QRPivoted(LAPACK.geqp3!(A)...)
-qrfact{T<:BlasFloat}(A::StridedMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false}) = qrfact!(copy(A), pivot)
-copy_oftype{T}(A::StridedMatrix{T}, ::Type{T}) = copy(A)
-copy_oftype{T,S}(A::StridedMatrix{T}, ::Type{S}) = convert(AbstractMatrix{S}, A)
-qrfact{T}(A::StridedMatrix{T}, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false}) = qrfact!(copy_oftype(A, typeof(one(T)/norm(one(T)))), pivot)
+
+# Find index for columns with largest two norm
+function indmaxcolumn(A::StridedMatrix)
+    mm = norm(slice(A, :, 1))
+    ii = 1
+    for i = 2:size(A, 2)
+        mi = norm(slice(A, :, i))
+        if abs(mi) > mm
+            mm = mi
+            ii = i
+        end
+    end
+    return ii
+end
+
+function qrfactPivotedUnblocked!(A::StridedMatrix)
+    m, n = size(A)
+    piv = collect(UnitRange{BlasInt}(1,n))
+    τ = Array(eltype(A), min(m,n))
+    for j = 1:min(m,n)
+
+        # Find column with maximum norm in trailing submatrix
+        jm = indmaxcolumn(slice(A, j:m, j:n)) + j - 1
+
+        if jm != j
+            # Flip elements in pivoting vector
+            tmpp = piv[jm]
+            piv[jm] = piv[j]
+            piv[j] = tmpp
+
+            # Update matrix with
+            for i = 1:m
+                tmp = A[i,jm]
+                A[i,jm] = A[i,j]
+                A[i,j] = tmp
+            end
+        end
+
+        # Compute reflector of columns j
+        x = slice(A, j:m, j)
+        τj = LinAlg.reflector!(x)
+        τ[j] = τj
+
+        # Update trailing submatrix with reflector
+        LinAlg.reflectorApply!(x, τj, sub(A, j:m, j+1:n))
+    end
+    return LinAlg.QRPivoted{eltype(A), typeof(A)}(A, τ, piv)
+end
+
+# LAPACK version
+qrfact!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{false}}) = QRCompactWY(LAPACK.geqrt!(A, min(minimum(size(A)), 36))...)
+qrfact!{T<:BlasFloat}(A::StridedMatrix{T}, ::Type{Val{true}}) = QRPivoted(LAPACK.geqp3!(A)...)
+qrfact!{T<:BlasFloat}(A::StridedMatrix{T}) = qrfact!(A, Val{false})
+qrfact{T<:BlasFloat}(A::StridedMatrix{T}, args...) = qrfact!(copy(A), args...)
+
+# Generic fallbacks
+qrfact!(A::StridedMatrix, ::Type{Val{false}}) = qrfactUnblocked!(A)
+qrfact!(A::StridedMatrix, ::Type{Val{true}}) = qrfactPivotedUnblocked!(A)
+qrfact!(A::StridedMatrix) = qrfact!(A, Val{false})
+qrfact{T}(A::StridedMatrix{T}, args...) = qrfact!(copy_oftype(A, typeof(zero(T)/norm(one(T)))), args...)
 qrfact(x::Number) = qrfact(fill(x,1,1))
 
 qr(A::Union{Number, AbstractMatrix}, pivot::Union{Type{Val{false}}, Type{Val{true}}}=Val{false}; thin::Bool=true) =
@@ -55,6 +108,60 @@ function _qr(A::Union{Number, AbstractMatrix}, ::Type{Val{true}}; thin::Bool=tru
     full(getq(F), thin=thin), F[:R]::Matrix{eltype(F)}, F[:p]::Vector{BlasInt}
 end
 
+"""
+    qr(v::AbstractVector)
+
+Computes the polar decomposition of a vector.
+
+Input:
+
+- `v::AbstractVector` - vector to normalize
+
+Outputs:
+
+- `w` - A unit vector in the direction of `v`
+- `r` - The norm of `v`
+
+See also:
+
+`normalize`, `normalize!`, `LinAlg.qr!`
+"""
+function qr(v::AbstractVector)
+    nrm = norm(v)
+    if !isempty(v)
+        vv = copy_oftype(v, typeof(v[1]/nrm))
+        return __normalize!(vv, nrm), nrm
+    else
+        T = typeof(zero(eltype(v))/nrm)
+        return T[], one(T)
+    end
+end
+
+"""
+    LinAlg.qr!(v::AbstractVector)
+
+Computes the polar decomposition of a vector. Instead of returning a new vector
+as `qr(v::AbstractVector)`, this function mutates the input vector `v` in place.
+
+Input:
+
+- `v::AbstractVector` - vector to normalize
+
+Outputs:
+
+- `w` - A unit vector in the direction of `v` (This is a mutation of `v`).
+- `r` - The norm of `v`
+
+See also:
+
+`normalize`, `normalize!`, `qr`
+"""
+function qr!(v::AbstractVector)
+    nrm = norm(v)
+    __normalize!(v, nrm), nrm
+end
+
+
 convert{T}(::Type{QR{T}},A::QR) = QR(convert(AbstractMatrix{T}, A.factors), convert(Vector{T}, A.τ))
 convert{T}(::Type{Factorization{T}}, A::QR) = convert(QR{T}, A)
 convert{T}(::Type{QRCompactWY{T}},A::QRCompactWY) = QRCompactWY(convert(AbstractMatrix{T}, A.factors), convert(AbstractMatrix{T}, A.T))
@@ -283,7 +390,6 @@ function A_mul_Bc!{T}(A::AbstractMatrix{T},Q::QRPackedQ{T})
     end
     A
 end
-A_mul_Bc(A::AbstractTriangular, B::Union{QRCompactWYQ,QRPackedQ}) = A_mul_Bc(full(A), B)
 function A_mul_Bc{TA,TB}(A::AbstractArray{TA}, B::Union{QRCompactWYQ{TB},QRPackedQ{TB}})
     TAB = promote_type(TA,TB)
     BB = convert(AbstractMatrix{TAB}, B)
@@ -336,7 +442,7 @@ function A_ldiv_B!{T}(A::QR{T}, B::StridedMatrix{T})
     m, n = size(A)
     minmn = min(m,n)
     mB, nB = size(B)
-    Ac_mul_B!(A[:Q], sub(B, 1:m, 1:nB))
+    Ac_mul_B!(A[:Q], sub(B, 1:m, :))
     R = A[:R]
     @inbounds begin
         if n > m # minimum norm solution
@@ -389,6 +495,7 @@ function A_ldiv_B!(A::QRPivoted, B::StridedMatrix)
     B[1:size(A.factors, 2),:] = sub(B, 1:size(A.factors, 2), :)[invperm(A.jpvt),:]
     B
 end
+
 function \{TA,Tb}(A::Union{QR{TA},QRCompactWY{TA},QRPivoted{TA}}, b::StridedVector{Tb})
     S = promote_type(TA,Tb)
     m,n = size(A)
diff --git a/base/linalg/schur.jl b/base/linalg/schur.jl
index fef129e5c4311..47eed7ceb3e03 100644
--- a/base/linalg/schur.jl
+++ b/base/linalg/schur.jl
@@ -9,7 +9,21 @@ immutable Schur{Ty<:BlasFloat, S<:AbstractMatrix} <: Factorization{Ty}
 end
 Schur{Ty}(T::AbstractMatrix{Ty}, Z::AbstractMatrix{Ty}, values::Vector) = Schur{Ty, typeof(T)}(T, Z, values)
 
+"""
+    schurfact!(A::StridedMatrix) -> F::Schur
+
+Same as `schurfact` but uses the input argument as workspace.
+"""
 schurfact!{T<:BlasFloat}(A::StridedMatrix{T}) = Schur(LinAlg.LAPACK.gees!('V', A)...)
+
+"""
+    schurfact(A::StridedMatrix) -> F::Schur
+
+Computes the Schur factorization of the matrix `A`. The (quasi) triangular Schur factor can
+be obtained from the `Schur` object `F` with either `F[:Schur]` or `F[:T]` and the
+orthogonal/unitary Schur vectors can be obtained with `F[:vectors]` or `F[:Z]` such that
+`A = F[:vectors]*F[:Schur]*F[:vectors]'`. The eigenvalues of `A` can be obtained with `F[:values]`.
+"""
 schurfact{T<:BlasFloat}(A::StridedMatrix{T}) = schurfact!(copy(A))
 function schurfact{T}(A::StridedMatrix{T})
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
@@ -28,15 +42,61 @@ function getindex(F::Schur, d::Symbol)
     end
 end
 
+"""
+    schur(A::StridedMatrix) -> T::Matrix, Z::Matrix, λ::Vector
+
+Computes the Schur factorization of the matrix `A`. The methods return the (quasi)
+triangular Schur factor `T` and the orthogonal/unitary Schur vectors `Z` such that
+`A = Z*T*Z'`. The eigenvalues of `A` are returned in the vector `λ`.
+
+See `schurfact`.
+"""
 function schur(A::StridedMatrix)
     SchurF = schurfact(A)
     SchurF[:T], SchurF[:Z], SchurF[:values]
 end
 
-ordschur!{Ty<:BlasFloat}(Q::StridedMatrix{Ty}, T::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = Schur(LinAlg.LAPACK.trsen!(convert(Vector{BlasInt}, select), T , Q)...)
-ordschur{Ty<:BlasFloat}(Q::StridedMatrix{Ty}, T::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = ordschur!(copy(Q), copy(T), select)
-ordschur!{Ty<:BlasFloat}(schur::Schur{Ty}, select::Union{Vector{Bool},BitVector}) = (res=ordschur!(schur.Z, schur.T, select); schur[:values][:]=res[:values]; res)
-ordschur{Ty<:BlasFloat}(schur::Schur{Ty}, select::Union{Vector{Bool},BitVector}) = ordschur(schur.Z, schur.T, select)
+"""
+    ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
+
+Same as `ordschur` but overwrites the factorization `F`.
+"""
+function ordschur!{Ty<:BlasFloat}(schur::Schur{Ty}, select::Union{Vector{Bool},BitVector})
+    _, _, vals = ordschur!(schur.T, schur.Z, select)
+    schur[:values][:] = vals
+    return schur
+end
+
+"""
+    ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
+
+Reorders the Schur factorization `F` of a matrix `A = Z*T*Z'` according to the logical array
+`select` returning the reordered factorization `F` object. The selected eigenvalues appear
+in the leading diagonal of `F[:Schur]` and the the corresponding leading columns of
+`F[:vectors]` form an orthogonal/unitary basis of the corresponding right invariant
+subspace. In the real case, a complex conjugate pair of eigenvalues must be either both
+included or both excluded via `select`.
+"""
+ordschur{Ty<:BlasFloat}(schur::Schur{Ty}, select::Union{Vector{Bool},BitVector}) = Schur(ordschur(schur.T, schur.Z, select)...)
+
+"""
+    ordschur!(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector
+
+Same as `ordschur` but overwrites the input arguments.
+"""
+ordschur!{Ty<:BlasFloat}(T::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = LinAlg.LAPACK.trsen!(convert(Vector{BlasInt}, select), T, Z)
+
+"""
+    ordschur(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector
+
+Reorders the Schur factorization of a real matrix `A = Z*T*Z'` according to the logical
+array `select` returning the reordered matrices `T` and `Z` as well as the vector of
+eigenvalues `λ`. The selected eigenvalues appear in the leading diagonal of `T` and the the
+corresponding leading columns of `Z` form an orthogonal/unitary basis of the corresponding
+right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be
+either both included or both excluded via `select`.
+"""
+ordschur{Ty<:BlasFloat}(T::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = ordschur!(copy(T), copy(Z), select)
 
 immutable GeneralizedSchur{Ty<:BlasFloat, M<:AbstractMatrix} <: Factorization{Ty}
     S::M
@@ -49,17 +109,72 @@ immutable GeneralizedSchur{Ty<:BlasFloat, M<:AbstractMatrix} <: Factorization{Ty
 end
 GeneralizedSchur{Ty}(S::AbstractMatrix{Ty}, T::AbstractMatrix{Ty}, alpha::Vector, beta::Vector{Ty}, Q::AbstractMatrix{Ty}, Z::AbstractMatrix{Ty}) = GeneralizedSchur{Ty, typeof(S)}(S, T, alpha, beta, Q, Z)
 
+"""
+    schurfact!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur
+
+Same as `schurfact` but uses the input matrices `A` and `B` as workspace.
+"""
 schurfact!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T}) = GeneralizedSchur(LinAlg.LAPACK.gges!('V', 'V', A, B)...)
+
+"""
+    schurfact(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur
+
+Computes the Generalized Schur (or QZ) factorization of the matrices `A` and `B`. The
+(quasi) triangular Schur factors can be obtained from the `Schur` object `F` with `F[:S]`
+and `F[:T]`, the left unitary/orthogonal Schur vectors can be obtained with `F[:left]` or
+`F[:Q]` and the right unitary/orthogonal Schur vectors can be obtained with `F[:right]` or
+`F[:Z]` such that `A=F[:left]*F[:S]*F[:right]'` and `B=F[:left]*F[:T]*F[:right]'`. The
+generalized eigenvalues of `A` and `B` can be obtained with `F[:alpha]./F[:beta]`.
+"""
 schurfact{T<:BlasFloat}(A::StridedMatrix{T},B::StridedMatrix{T}) = schurfact!(copy(A),copy(B))
 function schurfact{TA,TB}(A::StridedMatrix{TA}, B::StridedMatrix{TB})
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))), TB)
     return schurfact!(copy_oftype(A, S), copy_oftype(B, S))
 end
 
-ordschur!{Ty<:BlasFloat}(S::StridedMatrix{Ty}, T::StridedMatrix{Ty}, Q::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = GeneralizedSchur(LinAlg.LAPACK.tgsen!(convert(Vector{BlasInt}, select), S, T, Q, Z)...)
-ordschur{Ty<:BlasFloat}(S::StridedMatrix{Ty}, T::StridedMatrix{Ty}, Q::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = ordschur!(copy(S), copy(T), copy(Q), copy(Z), select)
-ordschur!{Ty<:BlasFloat}(gschur::GeneralizedSchur{Ty}, select::Union{Vector{Bool},BitVector}) = (res=ordschur!(gschur.S, gschur.T, gschur.Q, gschur.Z, select); gschur[:alpha][:]=res[:alpha]; gschur[:beta][:]=res[:beta]; res)
-ordschur{Ty<:BlasFloat}(gschur::GeneralizedSchur{Ty}, select::Union{Vector{Bool},BitVector}) = ordschur(gschur.S, gschur.T, gschur.Q, gschur.Z, select)
+"""
+    ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur
+
+Same as `ordschur` but overwrites the factorization `F`.
+"""
+function ordschur!{Ty<:BlasFloat}(gschur::GeneralizedSchur{Ty}, select::Union{Vector{Bool},BitVector})
+    _, _, α, β, _, _ = ordschur!(gschur.S, gschur.T, gschur.Q, gschur.Z, select)
+    gschur[:alpha][:] = α
+    gschur[:beta][:] = β
+    return gschur
+end
+
+"""
+    ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur
+
+Reorders the Generalized Schur factorization `F` of a matrix pair `(A, B) = (Q*S*Z', Q*T*Z')`
+according to the logical array `select` and returns a GeneralizedSchur object `F`. The
+selected eigenvalues appear in the leading diagonal of both `F[:S]` and `F[:T]`, and the
+left and right orthogonal/unitary Schur vectors are also reordered such that
+`(A, B) = F[:Q]*(F[:S], F[:T])*F[:Z]'` still holds and the generalized eigenvalues of `A`
+and `B` can still be obtained with `F[:alpha]./F[:beta]`.
+"""
+ordschur{Ty<:BlasFloat}(gschur::GeneralizedSchur{Ty}, select::Union{Vector{Bool},BitVector}) = GeneralizedSchur(ordschur(gschur.S, gschur.T, gschur.Q, gschur.Z, select)...)
+
+"""
+    ordschur!(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector
+
+Same as `ordschur` but overwrites the factorization the input arguments.
+"""
+ordschur!{Ty<:BlasFloat}(S::StridedMatrix{Ty}, T::StridedMatrix{Ty}, Q::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) = LinAlg.LAPACK.tgsen!(convert(Vector{BlasInt}, select), S, T, Q, Z)
+
+"""
+    ordschur(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector
+
+Reorders the Generalized Schur factorization of a matrix pair `(A, B) = (Q*S*Z', Q*T*Z')`
+according to the logical array `select` and returns the matrices `S`, `T`, `Q`, `Z` and
+vectors `α` and `β`.  The selected eigenvalues appear in the leading diagonal of both `S`
+and `T`, and the left and right unitary/orthogonal Schur vectors are also reordered such
+that `(A, B) = Q*(S, T)*Z'` still holds and the generalized eigenvalues of `A` and `B` can
+still be obtained with `α./β`.
+"""
+ordschur{Ty<:BlasFloat}(S::StridedMatrix{Ty}, T::StridedMatrix{Ty}, Q::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Union{Vector{Bool},BitVector}) =
+    ordschur!(copy(S), copy(T), copy(Q), copy(Z), select)
 
 function getindex(F::GeneralizedSchur, d::Symbol)
     if d == :S
@@ -81,9 +196,14 @@ function getindex(F::GeneralizedSchur, d::Symbol)
     end
 end
 
+"""
+    schur(A::StridedMatrix, B::StridedMatrix) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector
+
+See `schurfact`.
+"""
 function schur(A::StridedMatrix, B::StridedMatrix)
     SchurF = schurfact(A, B)
-    SchurF[:S], SchurF[:T], SchurF[:Q], SchurF[:Z]
+    SchurF[:S], SchurF[:T], SchurF[:Q], SchurF[:Z], SchurF[:alpha], SchurF[:beta]
 end
 
 full(F::Schur) = (F.Z * F.T) * F.Z'
diff --git a/base/linalg/svd.jl b/base/linalg/svd.jl
index 03328697ec00c..cd9e97682cb76 100644
--- a/base/linalg/svd.jl
+++ b/base/linalg/svd.jl
@@ -18,13 +18,41 @@ function svdfact!{T<:BlasFloat}(A::StridedMatrix{T}; thin::Bool=true)
     end
     SVD(u,s,vt)
 end
-function svdfact{T}(A::StridedVecOrMat{T};thin = true)
+
+"""
+    svdfact(A, [thin=true]) -> SVD
+
+Compute the singular value decomposition (SVD) of `A` and return an `SVD` object.
+
+`U`, `S`, `V` and `Vt` can be obtained from the factorization `F` with `F[:U]`,
+`F[:S]`, `F[:V]` and `F[:Vt]`, such that `A = U*diagm(S)*Vt`.
+The algorithm produces `Vt` and hence `Vt` is more efficient to extract than `V`.
+
+If `thin=true` (default), a thin SVD is returned. For a ``M \\times N`` matrix
+`A`, `U` is ``M \\times M`` for a full SVD (`thin=false`) and
+``M \\times \\min(M, N)`` for a thin SVD.
+"""
+function svdfact{T}(A::StridedVecOrMat{T}; thin::Bool = true)
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     svdfact!(copy_oftype(A, S), thin = thin)
 end
 svdfact(x::Number; thin::Bool=true) = SVD(x == 0 ? fill(one(x), 1, 1) : fill(x/abs(x), 1, 1), [abs(x)], fill(one(x), 1, 1))
 svdfact(x::Integer; thin::Bool=true) = svdfact(float(x), thin=thin)
 
+"""
+    svd(A, [thin=true]) -> U, S, V
+
+Computes the SVD of `A`, returning `U`, vector `S`, and `V` such that
+`A == U*diagm(S)*V'`.
+
+If `thin=true` (default), a thin SVD is returned. For a ``M \\times N`` matrix
+`A`, `U` is ``M \\times M`` for a full SVD (`thin=false`) and
+``M \\times \\min(M, N)`` for a thin SVD.
+
+`svd` is a wrapper around [`svdfact`](:func:`svdfact(A)`), extracting all parts
+of the `SVD` factorization to a tuple. Direct use of `svdfact` is therefore more
+efficient.
+"""
 function svd(A::Union{Number, AbstractArray}; thin::Bool=true)
     F = svdfact(A, thin=thin)
     F.U, F.S, F.Vt'
@@ -44,8 +72,19 @@ function getindex(F::SVD, d::Symbol)
     end
 end
 
+"""
+    svdvals!(A)
+
+Returns the singular values of `A`, saving space by overwriting the input.
+"""
 svdvals!{T<:BlasFloat}(A::StridedMatrix{T}) = any([size(A)...].==0) ? zeros(T, 0) : LAPACK.gesdd!('N', A)[2]
 svdvals{T<:BlasFloat}(A::AbstractMatrix{T}) = svdvals!(copy(A))
+
+"""
+    svdvals(A)
+
+Returns the singular values of `A`.
+"""
 function svdvals{T}(A::AbstractMatrix{T})
     S = promote_type(Float32, typeof(one(T)/norm(one(T))))
     svdvals!(copy_oftype(A, S))
@@ -54,12 +93,9 @@ svdvals(x::Number) = abs(x)
 svdvals{T, Tr}(S::SVD{T, Tr}) = (S[:S])::Vector{Tr}
 
 # SVD least squares
-function A_ldiv_B!{T<:BlasFloat}(A::SVD{T}, B::StridedVecOrMat{T})
-    n = length(A.S)
-    Sinv = zeros(T, n)
-    k = length(find(A.S .> eps(real(float(one(T))))*maximum(A.S)))
-    Sinv[1:k] = one(T) ./ A.S[1:k]
-    A.Vt[1:k,:]' * (Sinv[1:k] .* (A.U[:,1:k]' * B))
+function A_ldiv_B!{Ta,Tb}(A::SVD{Ta}, B::StridedVecOrMat{Tb})
+    k = searchsortedlast(A.S, eps(real(Ta))*A.S[1], rev=true)
+    sub(A.Vt,1:k,:)' * (sub(A.S,1:k) .\ (sub(A.U,:,1:k)' * B))
 end
 
 # Generalized svd
@@ -76,16 +112,65 @@ immutable GeneralizedSVD{T,S} <: Factorization{T}
 end
 GeneralizedSVD{T}(U::AbstractMatrix{T}, V::AbstractMatrix{T}, Q::AbstractMatrix{T}, a::Vector, b::Vector, k::Int, l::Int, R::AbstractMatrix{T}) = GeneralizedSVD{T,typeof(U)}(U, V, Q, a, b, k, l, R)
 
+"""
+    svdfact!(A, [thin=true]) -> SVD
+
+`svdfact!` is the same as [`svdfact`](:func:`svdfact`), but saves space by
+overwriting the input `A`, instead of creating a copy.
+
+If `thin=true` (default), a thin SVD is returned. For a ``M \\times N`` matrix
+`A`, `U` is ``M \\times M`` for a full SVD (`thin=false`) and
+``M \\times \\min(M, N)`` for a thin SVD.
+"""
 function svdfact!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T})
-    U, V, Q, a, b, k, l, R = LAPACK.ggsvd!('U', 'V', 'Q', A, B)
+    # xggsvd3 replaced xggsvd in LAPACK 3.6.0
+    if LAPACK.VERSION[] < v"3.6.0"
+        U, V, Q, a, b, k, l, R = LAPACK.ggsvd!('U', 'V', 'Q', A, B)
+    else
+        U, V, Q, a, b, k, l, R = LAPACK.ggsvd3!('U', 'V', 'Q', A, B)
+    end
     GeneralizedSVD(U, V, Q, a, b, Int(k), Int(l), R)
 end
 svdfact{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T}) = svdfact!(copy(A),copy(B))
+
+"""
+    svdfact(A, B) -> GeneralizedSVD
+
+Compute the generalized SVD of `A` and `B`, returning a `GeneralizedSVD` factorization
+object `F`, such that `A = F[:U]*F[:D1]*F[:R0]*F[:Q]'` and `B = F[:V]*F[:D2]*F[:R0]*F[:Q]'`.
+
+For an M-by-N matrix `A` and P-by-N matrix `B`,
+
+- `F[:U]` is a M-by-M orthogonal matrix,
+- `F[:V]` is a P-by-P orthogonal matrix,
+- `F[:Q]` is a N-by-N orthogonal matrix,
+- `F[:R0]` is a (K+L)-by-N matrix whose rightmost (K+L)-by-(K+L) block is
+           nonsingular upper block triangular,
+- `F[:D1]` is a M-by-(K+L) diagonal matrix with 1s in the first K entries,
+- `F[:D2]` is a P-by-(K+L) matrix whose top right L-by-L block is diagonal,
+
+`K+L` is the effective numerical rank of the matrix `[A; B]`.
+
+The entries of `F[:D1]` and `F[:D2]` are related, as explained in the LAPACK
+documentation for the
+[generalized SVD](http://www.netlib.org/lapack/lug/node36.html) and the
+[xGGSVD3](http://www.netlib.org/lapack/explore-html/d6/db3/dggsvd3_8f.html)
+routine which is called underneath (in LAPACK 3.6.0 and newer).
+"""
 function svdfact{TA,TB}(A::StridedMatrix{TA}, B::StridedMatrix{TB})
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))),TB)
     return svdfact!(copy_oftype(A, S), copy_oftype(B, S))
 end
 
+"""
+    svd(A, B) -> U, V, Q, D1, D2, R0
+
+Wrapper around [`svdfact`](:func:`svdfact(A, B)`) extracting all parts of the
+factorization to a tuple. Direct use of
+`svdfact` is therefore generally more efficient. The function returns the generalized SVD of
+`A` and `B`, returning `U`, `V`, `Q`, `D1`, `D2`, and `R0` such that `A = U*D1*R0*Q'` and `B =
+V*D2*R0*Q'`.
+"""
 function svd(A::AbstractMatrix, B::AbstractMatrix)
     F = svdfact(A, B)
     F[:U], F[:V], F[:Q], F[:D1], F[:D2], F[:R0]
@@ -130,10 +215,22 @@ function getindex{T}(obj::GeneralizedSVD{T}, d::Symbol)
 end
 
 function svdvals!{T<:BlasFloat}(A::StridedMatrix{T}, B::StridedMatrix{T})
-    _, _, _, a, b, k, l, _ = LAPACK.ggsvd!('N', 'N', 'N', A, B)
+    # xggsvd3 replaced xggsvd in LAPACK 3.6.0
+    if LAPACK.VERSION[] < v"3.6.0"
+        _, _, _, a, b, k, l, _ = LAPACK.ggsvd!('N', 'N', 'N', A, B)
+    else
+        _, _, _, a, b, k, l, _ = LAPACK.ggsvd3!('N', 'N', 'N', A, B)
+    end
     a[1:k + l] ./ b[1:k + l]
 end
 svdvals{T<:BlasFloat}(A::StridedMatrix{T},B::StridedMatrix{T}) = svdvals!(copy(A),copy(B))
+
+"""
+    svdvals(A, B)
+
+Return the generalized singular values from the generalized singular value
+decomposition of `A` and `B`.
+"""
 function svdvals{TA,TB}(A::StridedMatrix{TA}, B::StridedMatrix{TB})
     S = promote_type(Float32, typeof(one(TA)/norm(one(TA))), TB)
     return svdvals!(copy_oftype(A, S), copy_oftype(B, S))
diff --git a/base/linalg/symmetric.jl b/base/linalg/symmetric.jl
index bbd5bf3b19b1e..d7227b70932bb 100644
--- a/base/linalg/symmetric.jl
+++ b/base/linalg/symmetric.jl
@@ -5,13 +5,13 @@ immutable Symmetric{T,S<:AbstractMatrix} <: AbstractMatrix{T}
     data::S
     uplo::Char
 end
-Symmetric(A::AbstractMatrix, uplo::Symbol=:U) = (chksquare(A);Symmetric{eltype(A),typeof(A)}(A, char_uplo(uplo)))
+Symmetric(A::AbstractMatrix, uplo::Symbol=:U) = (checksquare(A);Symmetric{eltype(A),typeof(A)}(A, char_uplo(uplo)))
 immutable Hermitian{T,S<:AbstractMatrix} <: AbstractMatrix{T}
     data::S
     uplo::Char
 end
 function Hermitian(A::AbstractMatrix, uplo::Symbol=:U)
-    n = chksquare(A)
+    n = checksquare(A)
     for i=1:n
         isreal(A[i, i]) || throw(ArgumentError(
             "Cannot construct Hermitian from matrix with nonreal diagonals"))
@@ -23,12 +23,31 @@ typealias HermOrSym{T,S} Union{Hermitian{T,S}, Symmetric{T,S}}
 typealias RealHermSymComplexHerm{T<:Real,S} Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{Complex{T},S}}
 
 size(A::HermOrSym, args...) = size(A.data, args...)
-getindex(A::Symmetric, i::Integer, j::Integer) = (A.uplo == 'U') == (i < j) ? getindex(A.data, i, j) : getindex(A.data, j, i)
-getindex(A::Hermitian, i::Integer, j::Integer) = (A.uplo == 'U') == (i < j) ? getindex(A.data, i, j) : conj(getindex(A.data, j, i))
-unsafe_getindex(A::Symmetric, i::Integer, j::Integer) = (A.uplo == 'U') == (i < j) ? unsafe_getindex(A.data, i, j) : unsafe_getindex(A.data, j, i)
-unsafe_getindex(A::Hermitian, i::Integer, j::Integer) = (A.uplo == 'U') == (i < j) ? unsafe_getindex(A.data, i, j) : conj(unsafe_getindex(A.data, j, i))
+@inline function getindex(A::Symmetric, i::Integer, j::Integer)
+    @boundscheck checkbounds(A, i, j)
+    @inbounds r = (A.uplo == 'U') == (i < j) ? A.data[i, j] : A.data[j, i]
+    r
+end
+@inline function getindex(A::Hermitian, i::Integer, j::Integer)
+    @boundscheck checkbounds(A, i, j)
+    @inbounds r = (A.uplo == 'U') == (i < j) ? A.data[i, j] : conj(A.data[j, i])
+    r
+end
+
+similar{T}(A::Symmetric, ::Type{T}) = Symmetric(similar(A.data, T))
+# Hermitian version can be simplified when check for imaginary part of
+# diagonal in Hermitian has been removed
+function similar{T}(A::Hermitian, ::Type{T})
+    B = similar(A.data, T)
+    for i = 1:size(A,1)
+        B[i,i] = 0
+    end
+    return Hermitian(B)
+end
+
 full(A::Symmetric) = copytri!(copy(A.data), A.uplo)
 full(A::Hermitian) = copytri!(copy(A.data), A.uplo, true)
+parent(A::HermOrSym) = A.data
 convert{T,S<:AbstractMatrix}(::Type{Symmetric{T,S}},A::Symmetric{T,S}) = A
 convert{T,S<:AbstractMatrix}(::Type{Symmetric{T,S}},A::Symmetric) = Symmetric{T,S}(convert(S,A.data),A.uplo)
 convert{T}(::Type{AbstractMatrix{T}}, A::Symmetric) = Symmetric(convert(AbstractMatrix{T}, A.data), symbol(A.uplo))
@@ -40,9 +59,9 @@ copy{T,S}(A::Hermitian{T,S}) = Hermitian{T,S}(copy(A.data),A.uplo)
 ishermitian(A::Hermitian) = true
 ishermitian{T<:Real,S}(A::Symmetric{T,S}) = true
 ishermitian{T<:Complex,S}(A::Symmetric{T,S}) = all(imag(A.data) .== 0)
-issym{T<:Real,S}(A::Hermitian{T,S}) = true
-issym{T<:Complex,S}(A::Hermitian{T,S}) = all(imag(A.data) .== 0)
-issym(A::Symmetric) = true
+issymmetric{T<:Real,S}(A::Hermitian{T,S}) = true
+issymmetric{T<:Complex,S}(A::Hermitian{T,S}) = all(imag(A.data) .== 0)
+issymmetric(A::Symmetric) = true
 transpose(A::Symmetric) = A
 ctranspose{T<:Real}(A::Symmetric{T}) = A
 function ctranspose(A::Symmetric)
@@ -105,6 +124,8 @@ function triu(A::Symmetric, k::Integer=0)
     end
 end
 
+-{Tv,S<:AbstractMatrix}(A::Symmetric{Tv,S}) = Symmetric{Tv,S}(-A.data, A.uplo)
+
 ## Matvec
 A_mul_B!{T<:BlasFloat,S<:StridedMatrix}(y::StridedVector{T}, A::Symmetric{T,S}, x::StridedVector{T}) = BLAS.symv!(A.uplo, one(T), A.data, x, zero(T), y)
 A_mul_B!{T<:BlasComplex,S<:StridedMatrix}(y::StridedVector{T}, A::Hermitian{T,S}, x::StridedVector{T}) = BLAS.hemv!(A.uplo, one(T), A.data, x, zero(T), y)
@@ -117,8 +138,16 @@ A_mul_B!{T<:BlasComplex,S<:StridedMatrix}(C::StridedMatrix{T}, A::StridedMatrix{
 *(A::HermOrSym, B::HermOrSym) = full(A)*full(B)
 *(A::StridedMatrix, B::HermOrSym) = A*full(B)
 
-factorize(A::HermOrSym) = bkfact(A.data, symbol(A.uplo), issym(A))
-\{T,S<:StridedMatrix}(A::HermOrSym{T,S}, B::StridedVecOrMat) = \(bkfact(A.data, symbol(A.uplo), issym(A)), B)
+bkfact(A::HermOrSym) = bkfact(A.data, symbol(A.uplo), issymmetric(A))
+factorize(A::HermOrSym) = bkfact(A)
+
+# Is just RealHermSymComplexHerm, but type alias seems to be broken
+det{T<:Real,S}(A::Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{Complex{T},S}}) = real(det(bkfact(A)))
+det{T<:Real}(A::Symmetric{T}) = det(bkfact(A))
+det(A::Symmetric) = det(bkfact(A))
+
+\{T,S<:StridedMatrix}(A::HermOrSym{T,S}, B::StridedVecOrMat) = \(bkfact(A.data, symbol(A.uplo), issymmetric(A)), B)
+
 inv{T<:BlasFloat,S<:StridedMatrix}(A::Hermitian{T,S}) = Hermitian{T,S}(inv(bkfact(A.data, symbol(A.uplo))), A.uplo)
 inv{T<:BlasFloat,S<:StridedMatrix}(A::Symmetric{T,S}) = Symmetric{T,S}(inv(bkfact(A.data, symbol(A.uplo), true)), A.uplo)
 
@@ -134,11 +163,6 @@ eigfact!{T<:BlasReal,S<:StridedMatrix}(A::RealHermSymComplexHerm{T,S}, vl::Real,
 # Because of #6721 it is necessary to specify the parameters explicitly here.
 eigfact{T1<:Real,T2}(A::RealHermSymComplexHerm{T1,T2}, vl::Real, vh::Real) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigfact!(S != T ? convert(AbstractMatrix{S}, A) : copy(A), vl, vh))
 
-function eig{T<:Real,S}(A::Union{Hermitian{T,S}, Symmetric{T,S}, Hermitian{Complex{T},S}}, args...)
-    F = eigfact(A, args...)
-    return F.values, F.vectors
-end
-
 eigvals!{T<:BlasReal,S<:StridedMatrix}(A::RealHermSymComplexHerm{T,S}) = LAPACK.syevr!('N', 'A', A.uplo, A.data, 0.0, 0.0, 0, 0, -1.0)[1]
 # Because of #6721 it is necessary to specify the parameters explicitly here.
 eigvals{T1<:Real,T2}(A::RealHermSymComplexHerm{T1,T2}) = (T = eltype(A); S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(AbstractMatrix{S}, A) : copy(A)))
@@ -180,7 +204,7 @@ function expm(A::Symmetric)
     return Symmetric((F.vectors * Diagonal(exp(F.values))) * F.vectors')
 end
 function expm{T}(A::Hermitian{T})
-    n = chksquare(A)
+    n = checksquare(A)
     F = eigfact(A)
     retmat = (F.vectors * Diagonal(exp(F.values))) * F.vectors'
     if T <: Real
@@ -208,7 +232,7 @@ for (funm, func) in ([:logm,:log], [:sqrtm,:sqrt])
         end
 
         function ($funm){T}(A::Hermitian{T})
-            n = chksquare(A)
+            n = checksquare(A)
             F = eigfact(A)
             if isposdef(F)
                 retmat = (F.vectors * Diagonal(($func)(F.values))) * F.vectors'
diff --git a/base/linalg/triangular.jl b/base/linalg/triangular.jl
index 507cc0a1bffb8..09688dd10e4aa 100644
--- a/base/linalg/triangular.jl
+++ b/base/linalg/triangular.jl
@@ -5,13 +5,15 @@
 abstract AbstractTriangular{T,S<:AbstractMatrix} <: AbstractMatrix{T} # could be renamed to Triangular when than name has been fully deprecated
 
 # First loop through all methods that don't need special care for upper/lower and unit diagonal
-for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTriangular)
+for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular,
+          :UnitUpperTriangular)
     @eval begin
         immutable $t{T,S<:AbstractMatrix} <: AbstractTriangular{T,S}
             data::S
         end
+        $t(A::$t) = A
         function $t(A::AbstractMatrix)
-            Base.LinAlg.chksquare(A)
+            Base.LinAlg.checksquare(A)
             return $t{eltype(A), typeof(A)}(A)
         end
 
@@ -22,18 +24,12 @@ for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTr
         convert{Tnew,Told,S}(::Type{AbstractMatrix{Tnew}}, A::$t{Told,S}) = convert($t{Tnew}, A)
         convert{T,S}(::Type{Matrix}, A::$t{T,S}) = convert(Matrix{T}, A)
 
-        function similar{T,S,Tnew}(A::$t{T,S}, ::Type{Tnew}, dims::Dims)
-            if dims[1] != dims[2]
-                throw(ArgumentError("Triangular matrix must be square"))
-            end
-            if length(dims) != 2
-                throw(ArgumentError("Triangular matrix must have two dimensions"))
-            end
-            B = similar(A.data, Tnew, dims)
+        function similar{T,S,Tnew}(A::$t{T,S}, ::Type{Tnew})
+            B = similar(A.data, Tnew)
             return $t(B)
         end
 
-        copy{T,S}(A::$t{T,S}) = $t{T,S}(copy(A.data))
+        copy(A::$t) = $t(copy(A.data))
 
         big(A::$t) = $t(big(A.data))
 
@@ -49,6 +45,7 @@ imag(A::UnitLowerTriangular) = LowerTriangular(tril!(imag(A.data),-1))
 imag(A::UnitUpperTriangular) = UpperTriangular(triu!(imag(A.data),1))
 
 full(A::AbstractTriangular) = convert(Matrix, A)
+parent(A::AbstractTriangular) = A.data
 
 fill!(A::AbstractTriangular, x) = (fill!(A.data, x); A)
 
@@ -119,36 +116,54 @@ getindex{T,S}(A::UpperTriangular{T,S}, i::Integer, j::Integer) = i <= j ? A.data
 
 function setindex!(A::UpperTriangular, x, i::Integer, j::Integer)
     if i > j
-        throw(BoundsError(A,(i,j)))
+        x == 0 || throw(ArgumentError("cannot set index in the lower triangular part ($i, $j) of an UpperTriangular matrix to a nonzero value ($x)"))
+    else
+        A.data[i,j] = x
     end
-    A.data[i,j] = x
     return A
 end
 
 function setindex!(A::UnitUpperTriangular, x, i::Integer, j::Integer)
-    if i >= j
-        throw(BoundsError(A,(i,j)))
+    if i > j
+        x == 0 || throw(ArgumentError("cannot set index in the lower triangular part ($i, $j) of a UnitUpperTriangular matrix to a nonzero value ($x)"))
+    elseif i == j
+        x == 1 || throw(ArgumentError("cannot set index on the diagonal ($i, $j) of a UnitUpperTriangular matrix to a non-unit value ($x)"))
+    else
+        A.data[i,j] = x
     end
-    A.data[i,j] = x
     return A
 end
 
 function setindex!(A::LowerTriangular, x, i::Integer, j::Integer)
     if i < j
-        throw(BoundsError(A,(i,j)))
+        x == 0 || throw(ArgumentError("cannot set index in the upper triangular part ($i, $j) of a LowerTriangular matrix to a nonzero value ($x)"))
+    else
+        A.data[i,j] = x
     end
-    A.data[i,j] = x
     return A
 end
 
 function setindex!(A::UnitLowerTriangular, x, i::Integer, j::Integer)
-    if i <= j
-        throw(BoundsError(A,(i,j)))
+    if i < j
+        x == 0 || throw(ArgumentError("cannot set index in the upper triangular part ($i, $j) of a UnitLowerTriangular matrix to a nonzero value ($x)"))
+    elseif i == j
+        x == 1 || throw(ArgumentError("cannot set diagonal index ($i, $j) of a UnitLowerTriangular matrix to a non-unit value ($x)"))
+    else
+        A.data[i,j] = x
     end
-    A.data[i,j] = x
     return A
 end
 
+
+## structured matrix methods ##
+function Base.replace_in_print_matrix(A::UpperTriangular,i::Integer,j::Integer,s::AbstractString)
+    i<=j ? s : Base.replace_with_centered_mark(s)
+end
+function Base.replace_in_print_matrix(A::LowerTriangular,i::Integer,j::Integer,s::AbstractString)
+    i>=j ? s : Base.replace_with_centered_mark(s)
+end
+
+
 istril(A::LowerTriangular) = true
 istril(A::UnitLowerTriangular) = true
 istriu(A::UpperTriangular) = true
@@ -247,23 +262,23 @@ function tril!(A::UnitLowerTriangular,k::Integer=0)
     return tril!(LowerTriangular(A.data),k)
 end
 
-transpose{T,S}(A::LowerTriangular{T,S}) = UpperTriangular{T, S}(transpose(A.data))
-transpose{T,S}(A::UnitLowerTriangular{T,S}) = UnitUpperTriangular{T, S}(transpose(A.data))
-transpose{T,S}(A::UpperTriangular{T,S}) = LowerTriangular{T, S}(transpose(A.data))
-transpose{T,S}(A::UnitUpperTriangular{T,S}) = UnitLowerTriangular{T, S}(transpose(A.data))
-ctranspose{T,S}(A::LowerTriangular{T,S}) = UpperTriangular{T, S}(ctranspose(A.data))
-ctranspose{T,S}(A::UnitLowerTriangular{T,S}) = UnitUpperTriangular{T, S}(ctranspose(A.data))
-ctranspose{T,S}(A::UpperTriangular{T,S}) = LowerTriangular{T, S}(ctranspose(A.data))
-ctranspose{T,S}(A::UnitUpperTriangular{T,S}) = UnitLowerTriangular{T, S}(ctranspose(A.data))
-
-transpose!{T,S}(A::LowerTriangular{T,S}) = UpperTriangular{T, S}(copytri!(A.data, 'L'))
-transpose!{T,S}(A::UnitLowerTriangular{T,S}) = UnitUpperTriangular{T, S}(copytri!(A.data, 'L'))
-transpose!{T,S}(A::UpperTriangular{T,S}) = LowerTriangular{T, S}(copytri!(A.data, 'U'))
-transpose!{T,S}(A::UnitUpperTriangular{T,S}) = UnitLowerTriangular{T, S}(copytri!(A.data, 'U'))
-ctranspose!{T,S}(A::LowerTriangular{T,S}) = UpperTriangular{T, S}(copytri!(A.data, 'L' , true))
-ctranspose!{T,S}(A::UnitLowerTriangular{T,S}) = UnitUpperTriangular{T, S}(copytri!(A.data, 'L' , true))
-ctranspose!{T,S}(A::UpperTriangular{T,S}) = LowerTriangular{T, S}(copytri!(A.data, 'U' , true))
-ctranspose!{T,S}(A::UnitUpperTriangular{T,S}) = UnitLowerTriangular{T, S}(copytri!(A.data, 'U' , true))
+transpose(A::LowerTriangular) = UpperTriangular(transpose(A.data))
+transpose(A::UnitLowerTriangular) = UnitUpperTriangular(transpose(A.data))
+transpose(A::UpperTriangular) = LowerTriangular(transpose(A.data))
+transpose(A::UnitUpperTriangular) = UnitLowerTriangular(transpose(A.data))
+ctranspose(A::LowerTriangular) = UpperTriangular(ctranspose(A.data))
+ctranspose(A::UnitLowerTriangular) = UnitUpperTriangular(ctranspose(A.data))
+ctranspose(A::UpperTriangular) = LowerTriangular(ctranspose(A.data))
+ctranspose(A::UnitUpperTriangular) = UnitLowerTriangular(ctranspose(A.data))
+
+transpose!(A::LowerTriangular) = UpperTriangular(copytri!(A.data, 'L'))
+transpose!(A::UnitLowerTriangular) = UnitUpperTriangular(copytri!(A.data, 'L'))
+transpose!(A::UpperTriangular) = LowerTriangular(copytri!(A.data, 'U'))
+transpose!(A::UnitUpperTriangular) = UnitLowerTriangular(copytri!(A.data, 'U'))
+ctranspose!(A::LowerTriangular) = UpperTriangular(copytri!(A.data, 'L' , true))
+ctranspose!(A::UnitLowerTriangular) = UnitUpperTriangular(copytri!(A.data, 'L' , true))
+ctranspose!(A::UpperTriangular) = LowerTriangular(copytri!(A.data, 'U' , true))
+ctranspose!(A::UnitUpperTriangular) = UnitLowerTriangular(copytri!(A.data, 'U' , true))
 
 diag(A::LowerTriangular) = diag(A.data)
 diag(A::UnitLowerTriangular) = ones(eltype(A), size(A,1))
@@ -309,7 +324,7 @@ function copy!{T<:Union{LowerTriangular, UnitLowerTriangular}}(A::T, B::T)
 end
 
 function scale!{T<:Union{UpperTriangular, UnitUpperTriangular}}(A::UpperTriangular, B::T, c::Number)
-    n = chksquare(B)
+    n = checksquare(B)
     for j = 1:n
         if isa(B, UnitUpperTriangular)
             @inbounds A[j,j] = c
@@ -321,7 +336,7 @@ function scale!{T<:Union{UpperTriangular, UnitUpperTriangular}}(A::UpperTriangul
     return A
 end
 function scale!{T<:Union{LowerTriangular, UnitLowerTriangular}}(A::LowerTriangular, B::T, c::Number)
-    n = chksquare(B)
+    n = checksquare(B)
     for j = 1:n
         if isa(B, UnitLowerTriangular)
             @inbounds A[j,j] = c
@@ -362,7 +377,8 @@ scale!(c::Number, A::Union{UpperTriangular,LowerTriangular}) = scale!(A,c)
 
 A_mul_B!(A::Tridiagonal, B::AbstractTriangular) = A*full!(B)
 A_mul_B!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = A_mul_B!(A, copy!(C, B))
-A_mul_Bc!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = A_mul_Bc!(A, copy!(C, B))
+A_mul_Bt!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = A_mul_B!(A, transpose!(C, B))
+A_mul_Bc!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = A_mul_B!(A, ctranspose!(C, B))
 
 for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
                             (:UnitLowerTriangular, 'L', 'U'),
@@ -371,24 +387,31 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
     @eval begin
         # Vector multiplication
         A_mul_B!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}, b::StridedVector{T}) = BLAS.trmv!($uploc, 'N', $isunitc, A.data, b)
+        At_mul_B!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}, b::StridedVector{T}) = BLAS.trmv!($uploc, 'T', $isunitc, A.data, b)
+        Ac_mul_B!{T<:BlasReal,S<:StridedMatrix}(A::$t{T,S}, b::StridedVector{T}) = BLAS.trmv!($uploc, 'T', $isunitc, A.data, b)
+        Ac_mul_B!{T<:BlasComplex,S<:StridedMatrix}(A::$t{T,S}, b::StridedVector{T}) = BLAS.trmv!($uploc, 'C', $isunitc, A.data, b)
 
         # Matrix multiplication
         A_mul_B!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}, B::StridedMatrix{T}) = BLAS.trmm!('L', $uploc, 'N', $isunitc, one(T), A.data, B)
         A_mul_B!{T<:BlasFloat,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trmm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
 
+        At_mul_B!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}, B::StridedMatrix{T}) = BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), A.data, B)
         Ac_mul_B!{T<:BlasComplex,S<:StridedMatrix}(A::$t{T,S}, B::StridedMatrix{T}) = BLAS.trmm!('L', $uploc, 'C', $isunitc, one(T), A.data, B)
         Ac_mul_B!{T<:BlasReal,S<:StridedMatrix}(A::$t{T,S}, B::StridedMatrix{T}) = BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), A.data, B)
 
+        A_mul_Bt!{T<:BlasFloat,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
         A_mul_Bc!{T<:BlasComplex,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trmm!('R', $uploc, 'C', $isunitc, one(T), B.data, A)
         A_mul_Bc!{T<:BlasReal,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
 
         # Left division
         A_ldiv_B!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}, B::StridedVecOrMat{T}) = LAPACK.trtrs!($uploc, 'N', $isunitc, A.data, B)
+        At_ldiv_B!{T<:BlasFloat,S<:StridedMatrix}(A::$t{T,S}, B::StridedVecOrMat{T}) = LAPACK.trtrs!($uploc, 'T', $isunitc, A.data, B)
         Ac_ldiv_B!{T<:BlasReal,S<:StridedMatrix}(A::$t{T,S}, B::StridedVecOrMat{T}) = LAPACK.trtrs!($uploc, 'T', $isunitc, A.data, B)
         Ac_ldiv_B!{T<:BlasComplex,S<:StridedMatrix}(A::$t{T,S}, B::StridedVecOrMat{T}) = LAPACK.trtrs!($uploc, 'C', $isunitc, A.data, B)
 
         # Right division
-        A_rdiv_B!{T<:BlasFloat,S<:StridedMatrix}(A::StridedVecOrMat{T}, B::$t{T,S}) = BLAS.trsm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
+        A_rdiv_B!{T<:BlasFloat,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trsm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
+        A_rdiv_Bt!{T<:BlasFloat,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trsm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
         A_rdiv_Bc!{T<:BlasReal,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trsm!('R', $uploc, 'T', $isunitc, one(T), B.data, A)
         A_rdiv_Bc!{T<:BlasComplex,S<:StridedMatrix}(A::StridedMatrix{T}, B::$t{T,S}) = BLAS.trsm!('R', $uploc, 'C', $isunitc, one(T), B.data, A)
 
@@ -400,7 +423,7 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
 
         # Condition numbers
         function cond{T<:BlasFloat,S}(A::$t{T,S}, p::Real=2)
-            chksquare(A)
+            checksquare(A)
             if p == 1
                 return inv(LAPACK.trcon!('O', $uploc, $isunitc, A.data))
             elseif p == Inf
@@ -561,7 +584,7 @@ function Ac_mul_B!(A::UpperTriangular, B::StridedVecOrMat)
     end
     for j = 1:n
         for i = m:-1:1
-            Bij = A.data[i,i]*B[i,j]
+            Bij = A.data[i,i]'B[i,j]
             for k = 1:i - 1
                 Bij += A.data[k,i]'B[k,j]
             end
@@ -594,7 +617,7 @@ function Ac_mul_B!(A::LowerTriangular, B::StridedVecOrMat)
     end
     for j = 1:n
         for i = 1:m
-            Bij = A.data[i,i]*B[i,j]
+            Bij = A.data[i,i]'B[i,j]
             for k = i + 1:m
                 Bij += A.data[k,i]'B[k,j]
             end
@@ -620,6 +643,72 @@ function Ac_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat)
     B
 end
 
+function At_mul_B!(A::UpperTriangular, B::StridedVecOrMat)
+    m, n = size(B, 1), size(B, 2)
+    if m != size(A, 1)
+        throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m"))
+    end
+    for j = 1:n
+        for i = m:-1:1
+            Bij = A.data[i,i].'B[i,j]
+            for k = 1:i - 1
+                Bij += A.data[k,i].'B[k,j]
+            end
+            B[i,j] = Bij
+        end
+    end
+    B
+end
+function At_mul_B!(A::UnitUpperTriangular, B::StridedVecOrMat)
+    m, n = size(B, 1), size(B, 2)
+    if m != size(A, 1)
+        throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m"))
+    end
+    for j = 1:n
+        for i = m:-1:1
+            Bij = B[i,j]
+            for k = 1:i - 1
+                Bij += A.data[k,i].'B[k,j]
+            end
+            B[i,j] = Bij
+        end
+    end
+    B
+end
+
+function At_mul_B!(A::LowerTriangular, B::StridedVecOrMat)
+    m, n = size(B, 1), size(B, 2)
+    if m != size(A, 1)
+        throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m"))
+    end
+    for j = 1:n
+        for i = 1:m
+            Bij = A.data[i,i].'B[i,j]
+            for k = i + 1:m
+                Bij += A.data[k,i].'B[k,j]
+            end
+            B[i,j] = Bij
+        end
+    end
+    B
+end
+function At_mul_B!(A::UnitLowerTriangular, B::StridedVecOrMat)
+    m, n = size(B, 1), size(B, 2)
+    if m != size(A, 1)
+        throw(DimensionMismatch("right hand side B needs first dimension of size $(size(A,1)), has size $m"))
+    end
+    for j = 1:n
+        for i = 1:m
+            Bij = B[i,j]
+            for k = i + 1:m
+                Bij += A.data[k,i].'B[k,j]
+            end
+            B[i,j] = Bij
+        end
+    end
+    B
+end
+
 function A_mul_B!(A::StridedMatrix, B::UpperTriangular)
     m, n = size(A)
     if size(B, 1) != n
@@ -693,7 +782,7 @@ function A_mul_Bc!(A::StridedMatrix, B::UpperTriangular)
     end
     for i = 1:m
         for j = 1:n
-            Aij = A[i,j]*B[j,j]
+            Aij = A[i,j]*B.data[j,j]'
             for k = j + 1:n
                 Aij += A[i,k]*B.data[j,k]'
             end
@@ -726,7 +815,7 @@ function A_mul_Bc!(A::StridedMatrix, B::LowerTriangular)
     end
     for i = 1:m
         for j = n:-1:1
-            Aij = A[i,j]*B[j,j]
+            Aij = A[i,j]*B.data[j,j]'
             for k = 1:j - 1
                 Aij += A[i,k]*B.data[j,k]'
             end
@@ -752,70 +841,247 @@ function A_mul_Bc!(A::StridedMatrix, B::UnitLowerTriangular)
     A
 end
 
+function A_mul_Bt!(A::StridedMatrix, B::UpperTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = 1:n
+            Aij = A[i,j]*B.data[j,j].'
+            for k = j + 1:n
+                Aij += A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij
+        end
+    end
+    A
+end
+function A_mul_Bt!(A::StridedMatrix, B::UnitUpperTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = 1:n
+            Aij = A[i,j]
+            for k = j + 1:n
+                Aij += A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij
+        end
+    end
+    A
+end
+
+function A_mul_Bt!(A::StridedMatrix, B::LowerTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = n:-1:1
+            Aij = A[i,j]*B.data[j,j].'
+            for k = 1:j - 1
+                Aij += A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij
+        end
+    end
+    A
+end
+function A_mul_Bt!(A::StridedMatrix, B::UnitLowerTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = n:-1:1
+            Aij = A[i,j]
+            for k = 1:j - 1
+                Aij += A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij
+        end
+    end
+    A
+end
+
 #Generic solver using naive substitution
-function naivesub!(A::UpperTriangular, b::AbstractVector, x::AbstractVector=b)
+# manually hoisting x[j] significantly improves performance as of Dec 2015
+# manually eliding bounds checking significantly improves performance as of Dec 2015
+# directly indexing A.data rather than A significantly improves performance as of Dec 2015
+# replacing repeated references to A.data with [Adata = A.data and references to Adata] does not significantly impact performance as of Dec 2015
+# replacing repeated references to A.data[j,j] with [Ajj = A.data[j,j] and references to Ajj] does not significantly impact performance as of Dec 2015
+function naivesub!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b)
     n = size(A, 2)
     if !(n == length(b) == length(x))
-        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)) must be equal"))
+        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
     end
-    for j = n:-1:1
-        xj = b[j]
-        for k = j+1:1:n
-            xj -= A[j,k] * x[k]
+    @inbounds for j in n:-1:1
+        A.data[j,j] == zero(A.data[j,j]) && throw(SingularException(j))
+        xj = x[j] = A.data[j,j] \ b[j]
+        for i in j-1:-1:1 # counterintuitively 1:j-1 performs slightly better
+            b[i] -= A.data[i,j] * xj
         end
-        Ajj = A[j,j]
-        if Ajj == zero(Ajj)
-            throw(SingularException(j))
-        else
-            x[j] = Ajj\xj
+    end
+    x
+end
+function naivesub!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 2)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in n:-1:1
+        xj = x[j] = b[j]
+        for i in j-1:-1:1 # counterintuitively 1:j-1 performs slightly better
+            b[i] -= A.data[i,j] * xj
         end
     end
     x
 end
-function naivesub!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector=b)
+function naivesub!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b)
     n = size(A, 2)
     if !(n == length(b) == length(x))
-        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)) must be equal"))
+        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
     end
-    for j = n:-1:1
-        xj = b[j]
-        for k = j+1:1:n
-            xj -= A[j,k] * x[k]
+    @inbounds for j in 1:n
+        A.data[j,j] == zero(A.data[j,j]) && throw(SingularException(j))
+        xj = x[j] = A.data[j,j] \ b[j]
+        for i in j+1:n
+            b[i] -= A.data[i,j] * xj
         end
-        x[j] = xj
     end
     x
 end
-function naivesub!(A::LowerTriangular, b::AbstractVector, x::AbstractVector=b)
+function naivesub!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b)
     n = size(A, 2)
     if !(n == length(b) == length(x))
-        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)) must be equal"))
+        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
     end
-    for j = 1:n
-        xj = b[j]
-        for k = 1:j-1
-            xj -= A[j,k] * x[k]
+    @inbounds for j in 1:n
+        xj = x[j] = b[j]
+        for i in j+1:n
+            b[i] -= A.data[i,j] * xj
         end
-        Ajj = A[j,j]
-        if Ajj == zero(Ajj)
-            throw(SingularException(j))
-        else
-            x[j] = Ajj\xj
+    end
+    x
+end
+# in the following transpose and conjugate transpose naive substitution variants,
+# accumulating in z rather than b[j] significantly improves performance as of Dec 2015
+function At_ldiv_B!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in n:-1:1
+        z = b[j]
+        for i in n:-1:j+1
+            z -= A.data[i,j] * x[i]
         end
+        A.data[j,j] == zero(A.data[j,j]) && throw(SingularException(j))
+        x[j] = A.data[j,j] \ z
     end
     x
 end
-function naivesub!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector=b)
-    n = size(A, 2)
+function At_ldiv_B!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
     if !(n == length(b) == length(x))
-        throw(DimensionMismatch("second dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)) must be equal"))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
     end
-    for j = 1:n
-        xj = b[j]
-        for k = 1:j-1
-            xj -= A[j,k] * x[k]
+    @inbounds for j in n:-1:1
+        z = b[j]
+        for i in n:-1:j+1
+            z -= A.data[i,j] * x[i]
+        end
+        x[j] = z
+    end
+    x
+end
+function At_ldiv_B!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in 1:n
+        z = b[j]
+        for i in 1:j-1
+            z -= A.data[i,j] * x[i]
+        end
+        A.data[j,j] == zero(A.data[j,j]) && throw(SingularException(j))
+        x[j] = A.data[j,j] \ z
+    end
+    x
+end
+function At_ldiv_B!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in 1:n
+        z = b[j]
+        for i in 1:j-1
+            z -= A.data[i,j] * x[i]
+        end
+        x[j] = z
+    end
+    x
+end
+function Ac_ldiv_B!(A::LowerTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in n:-1:1
+        z = b[j]
+        for i in n:-1:j+1
+            z -= A.data[i,j]' * x[i]
+        end
+        A.data[j,j] == zero(A.data[j,j]) && throw(SingularException(j))
+        x[j] = A.data[j,j]' \ z
+    end
+    x
+end
+function Ac_ldiv_B!(A::UnitLowerTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in n:-1:1
+        z = b[j]
+        for i in n:-1:j+1
+            z -= A.data[i,j]' * x[i]
         end
-        x[j] = xj
+        x[j] = z
+    end
+    x
+end
+function Ac_ldiv_B!(A::UpperTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in 1:n
+        z = b[j]
+        for i in 1:j-1
+            z -= A.data[i,j]' * x[i]
+        end
+        A.data[j,j] == zero(A.data[j,j]) && throw(SingularException(j))
+        x[j] = A.data[j,j]' \ z
+    end
+    x
+end
+function Ac_ldiv_B!(A::UnitUpperTriangular, b::AbstractVector, x::AbstractVector = b)
+    n = size(A, 1)
+    if !(n == length(b) == length(x))
+        throw(DimensionMismatch("first dimension of left hand side A, $n, length of output x, $(length(x)), and length of right hand side b, $(length(b)), must be equal"))
+    end
+    @inbounds for j in 1:n
+        z = b[j]
+        for i in 1:j-1
+            z -= A.data[i,j]' * x[i]
+        end
+        x[j] = z
     end
     x
 end
@@ -897,7 +1163,7 @@ function A_rdiv_Bc!(A::StridedMatrix, B::UpperTriangular)
             for k = j + 1:n
                 Aij -= A[i,k]*B.data[j,k]'
             end
-            A[i,j] = Aij/B[j,j]
+            A[i,j] = Aij/B.data[j,j]'
         end
     end
     A
@@ -930,7 +1196,7 @@ function A_rdiv_Bc!(A::StridedMatrix, B::LowerTriangular)
             for k = 1:j - 1
                 Aij -= A[i,k]*B.data[j,k]'
             end
-            A[i,j] = Aij/B[j,j]
+            A[i,j] = Aij/B.data[j,j]'
         end
     end
     A
@@ -952,6 +1218,72 @@ function A_rdiv_Bc!(A::StridedMatrix, B::UnitLowerTriangular)
     A
 end
 
+function A_rdiv_Bt!(A::StridedMatrix, B::UpperTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = n:-1:1
+            Aij = A[i,j]
+            for k = j + 1:n
+                Aij -= A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij/B.data[j,j].'
+        end
+    end
+    A
+end
+function A_rdiv_Bt!(A::StridedMatrix, B::UnitUpperTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = n:-1:1
+            Aij = A[i,j]
+            for k = j + 1:n
+                Aij -= A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij
+        end
+    end
+    A
+end
+
+function A_rdiv_Bt!(A::StridedMatrix, B::LowerTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = 1:n
+            Aij = A[i,j]
+            for k = 1:j - 1
+                Aij -= A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij/B.data[j,j].'
+        end
+    end
+    A
+end
+function A_rdiv_Bt!(A::StridedMatrix, B::UnitLowerTriangular)
+    m, n = size(A)
+    if size(B, 1) != n
+        throw(DimensionMismatch("right hand side B needs first dimension of size $n, has size $(size(B,1))"))
+    end
+    for i = 1:m
+        for j = 1:n
+            Aij = A[i,j]
+            for k = 1:j - 1
+                Aij -= A[i,k]*B.data[j,k].'
+            end
+            A[i,j] = Aij
+        end
+    end
+    A
+end
+
 # Promotion
 ## Promotion methods in matmul don't apply to triangular multiplication since it is inplace. Hence we have to make very similar definitions, but without allocation of a result array. For multiplication and unit diagonal division the element type doesn't have to be stable under division whereas that is necessary in the general triangular solve problem.
 
@@ -962,7 +1294,7 @@ for t in (UpperTriangular, UnitUpperTriangular, LowerTriangular, UnitLowerTriang
     end
 end
 
-for f in (:*, :Ac_mul_B, :At_mul_B, :A_mul_Bc, :A_mul_Bt, :Ac_mul_Bc, :At_mul_Bt, :\, :Ac_ldiv_B, :At_ldiv_B)
+for f in (:*, :Ac_mul_B, :At_mul_B, :\, :Ac_ldiv_B, :At_ldiv_B)
     @eval begin
         ($f)(A::AbstractTriangular, B::AbstractTriangular) = ($f)(A, full(B))
     end
@@ -979,41 +1311,25 @@ for (f, g) in ((:*, :A_mul_B!), (:Ac_mul_B, :Ac_mul_B!), (:At_mul_B, :At_mul_B!)
     @eval begin
         function ($f){TA,TB}(A::AbstractTriangular{TA}, B::StridedVecOrMat{TB})
             TAB = typeof(zero(TA)*zero(TB) + zero(TA)*zero(TB))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
+            ($g)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
         end
     end
 end
 ### Left division with triangle to the left hence rhs cannot be transposed. No quotients.
 for (f, g) in ((:\, :A_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!), (:At_ldiv_B, :At_ldiv_B!))
     @eval begin
-        function ($f){TA,TB,S}(A::UnitUpperTriangular{TA,S}, B::StridedVecOrMat{TB})
+        function ($f){TA,TB,S}(A::Union{UnitUpperTriangular{TA,S},UnitLowerTriangular{TA,S}}, B::StridedVecOrMat{TB})
             TAB = typeof(zero(TA)*zero(TB) + zero(TA)*zero(TB))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
-        end
-    end
-end
-for (f, g) in ((:\, :A_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!), (:At_ldiv_B, :At_ldiv_B!))
-    @eval begin
-        function ($f){TA,TB,S}(A::UnitLowerTriangular{TA,S}, B::StridedVecOrMat{TB})
-            TAB = typeof(zero(TA)*zero(TB) + zero(TA)*zero(TB))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
+            ($g)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
         end
     end
 end
 ### Left division with triangle to the left hence rhs cannot be transposed. Quotients.
 for (f, g) in ((:\, :A_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!), (:At_ldiv_B, :At_ldiv_B!))
     @eval begin
-        function ($f){TA,TB,S}(A::UpperTriangular{TA,S}, B::StridedVecOrMat{TB})
-            TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
-        end
-    end
-end
-for (f, g) in ((:\, :A_ldiv_B!), (:Ac_ldiv_B, :Ac_ldiv_B!), (:At_ldiv_B, :At_ldiv_B!))
-    @eval begin
-        function ($f){TA,TB,S}(A::LowerTriangular{TA,S}, B::StridedVecOrMat{TB})
+        function ($f){TA,TB,S}(A::Union{UpperTriangular{TA,S},LowerTriangular{TA,S}}, B::StridedVecOrMat{TB})
             TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
+            ($g)(convert(AbstractArray{TAB}, A), copy_oftype(B, TAB))
         end
     end
 end
@@ -1022,44 +1338,33 @@ for (f, g) in ((:*, :A_mul_B!), (:A_mul_Bc, :A_mul_Bc!), (:A_mul_Bt, :A_mul_Bt!)
     @eval begin
         function ($f){TA,TB}(A::StridedVecOrMat{TA}, B::AbstractTriangular{TB})
             TAB = typeof(zero(TA)*zero(TB) + zero(TA)*zero(TB))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
+            ($g)(copy_oftype(A, TAB), convert(AbstractArray{TAB}, B))
         end
     end
 end
 ### Right division with triangle to the right hence lhs cannot be transposed. No quotients.
 for (f, g) in ((:/, :A_rdiv_B!), (:A_rdiv_Bc, :A_rdiv_Bc!), (:A_rdiv_Bt, :A_rdiv_Bt!))
     @eval begin
-        function ($f){TA,TB,S}(A::StridedVecOrMat{TA}, B::UnitUpperTriangular{TB,S})
-            TAB = typeof(zero(TA)*zero(TB) + zero(TA)*zero(TB))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
-        end
-    end
-end
-for (f, g) in ((:/, :A_rdiv_B!), (:A_rdiv_Bc, :A_rdiv_Bc!), (:A_rdiv_Bt, :A_rdiv_Bt!))
-    @eval begin
-        function ($f){TA,TB,S}(A::StridedVecOrMat{TA}, B::UnitLowerTriangular{TB,S})
+        function ($f){TA,TB,S}(A::StridedVecOrMat{TA}, B::Union{UnitUpperTriangular{TB,S},UnitLowerTriangular{TB,S}})
             TAB = typeof(zero(TA)*zero(TB) + zero(TA)*zero(TB))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
+            ($g)(copy_oftype(A, TAB), convert(AbstractArray{TAB}, B))
         end
     end
 end
 ### Right division with triangle to the right hence lhs cannot be transposed. Quotients.
 for (f, g) in ((:/, :A_rdiv_B!), (:A_rdiv_Bc, :A_rdiv_Bc!), (:A_rdiv_Bt, :A_rdiv_Bt!))
     @eval begin
-        function ($f){TA,TB,S}(A::StridedVecOrMat{TA}, B::UpperTriangular{TB,S})
-            TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
-        end
-    end
-end
-for (f, g) in ((:/, :A_rdiv_B!), (:A_rdiv_Bc, :A_rdiv_Bc!), (:A_rdiv_Bt, :A_rdiv_Bt!))
-    @eval begin
-        function ($f){TA,TB,S}(A::StridedVecOrMat{TA}, B::LowerTriangular{TB,S})
+        function ($f){TA,TB,S}(A::StridedVecOrMat{TA}, B::Union{UpperTriangular{TB,S},LowerTriangular{TB,S}})
             TAB = typeof((zero(TA)*zero(TB) + zero(TA)*zero(TB))/one(TA))
-            ($g)(TA == TAB ? copy(A) : convert(AbstractArray{TAB}, A), TB == TAB ? copy(B) : convert(AbstractArray{TAB}, B))
+            ($g)(copy_oftype(A, TAB), convert(AbstractArray{TAB}, B))
         end
     end
 end
+### Fallbacks brought in from linalg/bidiag.jl while fixing #14506.
+# Eventually the above promotion methods should be generalized as
+# was done for bidiagonal matrices in #14506.
+At_ldiv_B(A::AbstractTriangular, B::AbstractVecOrMat) = At_ldiv_B!(A, copy(B))
+Ac_ldiv_B(A::AbstractTriangular, B::AbstractVecOrMat) = Ac_ldiv_B!(A, copy(B))
 
 # Complex matrix logarithm for the upper triangular factor, see:
 #   Al-Mohy and Higham, "Improved inverse  scaling and squaring algorithms for
@@ -1253,7 +1558,7 @@ end
 logm(A::LowerTriangular) = logm(A.').'
 
 function sqrtm{T}(A::UpperTriangular{T})
-    n = chksquare(A)
+    n = checksquare(A)
     realmatrix = false
     if isreal(A)
         realmatrix = true
@@ -1283,7 +1588,7 @@ function sqrtm{T}(A::UpperTriangular{T})
     return UpperTriangular(R)
 end
 function sqrtm{T}(A::UnitUpperTriangular{T})
-    n = chksquare(A)
+    n = checksquare(A)
     TT = typeof(sqrt(zero(T)))
     R = zeros(TT, n, n)
     for j = 1:n
@@ -1311,8 +1616,8 @@ function eigvecs{T}(A::AbstractTriangular{T})
         throw(ArgumentError("eigvecs type $(typeof(A)) not supported. Please submit a pull request."))
     end
 end
-det{T}(A::UnitUpperTriangular{T}) = one(T)*one(T)
-det{T}(A::UnitLowerTriangular{T}) = one(T)*one(T)
+det{T}(A::UnitUpperTriangular{T}) = one(T)
+det{T}(A::UnitLowerTriangular{T}) = one(T)
 det{T}(A::UpperTriangular{T}) = prod(diag(A.data))
 det{T}(A::LowerTriangular{T}) = prod(diag(A.data))
 
diff --git a/base/linalg/tridiag.jl b/base/linalg/tridiag.jl
index 6417d45351214..83288d3f48262 100644
--- a/base/linalg/tridiag.jl
+++ b/base/linalg/tridiag.jl
@@ -16,7 +16,7 @@ end
 
 SymTridiagonal{T}(dv::Vector{T}, ev::Vector{T}) = SymTridiagonal{T}(dv, ev)
 
-function SymTridiagonal{Td,Te}(dv::Vector{Td}, ev::Vector{Te})
+function SymTridiagonal{Td,Te}(dv::AbstractVector{Td}, ev::AbstractVector{Te})
     T = promote_type(Td,Te)
     SymTridiagonal(convert(Vector{T}, dv), convert(Vector{T}, ev))
 end
@@ -30,8 +30,10 @@ function SymTridiagonal(A::AbstractMatrix)
 end
 
 full{T}(M::SymTridiagonal{T}) = convert(Matrix{T}, M)
-convert{T}(::Type{SymTridiagonal{T}}, S::SymTridiagonal) = SymTridiagonal(convert(Vector{T}, S.dv), convert(Vector{T}, S.ev))
-convert{T}(::Type{AbstractMatrix{T}}, S::SymTridiagonal) = SymTridiagonal(convert(Vector{T}, S.dv), convert(Vector{T}, S.ev))
+convert{T}(::Type{SymTridiagonal{T}}, S::SymTridiagonal) =
+    SymTridiagonal(convert(Vector{T}, S.dv), convert(Vector{T}, S.ev))
+convert{T}(::Type{AbstractMatrix{T}}, S::SymTridiagonal) =
+    SymTridiagonal(convert(Vector{T}, S.dv), convert(Vector{T}, S.ev))
 function convert{T}(::Type{Matrix{T}}, M::SymTridiagonal{T})
     n = size(M, 1)
     Mf = zeros(T, n, n)
@@ -58,6 +60,8 @@ function size(A::SymTridiagonal, d::Integer)
     end
 end
 
+similar{T}(S::SymTridiagonal, ::Type{T}) = SymTridiagonal{T}(similar(S.dv, T), similar(S.ev, T))
+
 #Elementary operations
 for func in (:conj, :copy, :round, :trunc, :floor, :ceil, :abs, :real, :imag)
     @eval ($func)(M::SymTridiagonal) = SymTridiagonal(($func)(M.dv), ($func)(M.ev))
@@ -77,7 +81,7 @@ function diag{T}(M::SymTridiagonal{T}, n::Integer=0)
     elseif absn<size(M,1)
         return zeros(T,size(M,1)-absn)
     else
-        throw(BoundsError("$n-th diagonal of a $(size(M)) matrix doesn't exist!"))
+        throw(ArgumentError("$n-th diagonal of a $(size(M)) matrix doesn't exist!"))
     end
 end
 
@@ -116,23 +120,47 @@ function A_mul_B!(C::StridedVecOrMat, S::SymTridiagonal, B::StridedVecOrMat)
     return C
 end
 
+(\)(T::SymTridiagonal, B::StridedVecOrMat) = ldltfact(T)\B
+
 eigfact!{T<:BlasReal}(A::SymTridiagonal{T}) = Eigen(LAPACK.stegr!('V', A.dv, A.ev)...)
-eigfact{T}(A::SymTridiagonal{T}) = (S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigfact!(S != T ? convert(SymTridiagonal{S}, A) : copy(A)))
+function eigfact{T}(A::SymTridiagonal{T})
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    eigfact!(copy_oftype(A, S))
+end
 
-eigfact!{T<:BlasReal}(A::SymTridiagonal{T}, irange::UnitRange) = Eigen(LAPACK.stegr!('V', 'I', A.dv, A.ev, 0.0, 0.0, irange.start, irange.stop)...)
-eigfact{T}(A::SymTridiagonal{T}, irange::UnitRange) = (S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigfact!(S != T ? convert(SymTridiagonal{S}, A) : copy(A), irange))
+eigfact!{T<:BlasReal}(A::SymTridiagonal{T}, irange::UnitRange) =
+    Eigen(LAPACK.stegr!('V', 'I', A.dv, A.ev, 0.0, 0.0, irange.start, irange.stop)...)
+function eigfact{T}(A::SymTridiagonal{T}, irange::UnitRange)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    return eigfact!(copy_oftype(A, S), irange)
+end
 
-eigfact!{T<:BlasReal}(A::SymTridiagonal{T}, vl::Real, vu::Real) = Eigen(LAPACK.stegr!('V', 'V', A.dv, A.ev, vl, vu, 0, 0)...)
-eigfact{T}(A::SymTridiagonal{T}, vl::Real, vu::Real) = (S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigfact!(S != T ? convert(SymTridiagonal{S}, A) : copy(A), vl, vu))
+eigfact!{T<:BlasReal}(A::SymTridiagonal{T}, vl::Real, vu::Real) =
+    Eigen(LAPACK.stegr!('V', 'V', A.dv, A.ev, vl, vu, 0, 0)...)
+function eigfact{T}(A::SymTridiagonal{T}, vl::Real, vu::Real)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    return eigfact!(copy_oftype(A, S), vl, vu)
+end
 
 eigvals!{T<:BlasReal}(A::SymTridiagonal{T}) = LAPACK.stev!('N', A.dv, A.ev)[1]
-eigvals{T}(A::SymTridiagonal{T}) = (S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(SymTridiagonal{S}, A) : copy(A)))
+function eigvals{T}(A::SymTridiagonal{T})
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    return eigvals!(copy_oftype(A, S))
+end
 
-eigvals!{T<:BlasReal}(A::SymTridiagonal{T}, irange::UnitRange) = LAPACK.stegr!('N', 'I', A.dv, A.ev, 0.0, 0.0, irange.start, irange.stop)[1]
-eigvals{T}(A::SymTridiagonal{T}, irange::UnitRange) = (S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(SymTridiagonal{S}, A) : copy(A), irange))
+eigvals!{T<:BlasReal}(A::SymTridiagonal{T}, irange::UnitRange) =
+    LAPACK.stegr!('N', 'I', A.dv, A.ev, 0.0, 0.0, irange.start, irange.stop)[1]
+function eigvals{T}(A::SymTridiagonal{T}, irange::UnitRange)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    return eigvals!(copy_oftype(A, S), irange)
+end
 
-eigvals!{T<:BlasReal}(A::SymTridiagonal{T}, vl::Real, vu::Real) = LAPACK.stegr!('N', 'V', A.dv, A.ev, vl, vu, 0, 0)[1]
-eigvals{T}(A::SymTridiagonal{T}, vl::Real, vu::Real) = (S = promote_type(Float32, typeof(zero(T)/norm(one(T)))); eigvals!(S != T ? convert(SymTridiagonal{S}, A) : copy(A), vl, vu))
+eigvals!{T<:BlasReal}(A::SymTridiagonal{T}, vl::Real, vu::Real) =
+    LAPACK.stegr!('N', 'V', A.dv, A.ev, vl, vu, 0, 0)[1]
+function eigvals{T}(A::SymTridiagonal{T}, vl::Real, vu::Real)
+    S = promote_type(Float32, typeof(zero(T)/norm(one(T))))
+    return eigvals!(copy_oftype(A, S), vl, vu)
+end
 
 #Computes largest and smallest eigenvalue
 eigmax(A::SymTridiagonal) = eigvals(A, size(A, 1):size(A, 1))[1]
@@ -194,6 +222,12 @@ end
 getindex( a::ZeroOffsetVector, i) = a.data[i+1]
 setindex!(a::ZeroOffsetVector, x, i) = a.data[i+1]=x
 
+
+## structured matrix methods ##
+function Base.replace_in_print_matrix(A::SymTridiagonal,i::Integer,j::Integer,s::AbstractString)
+    i==j-1||i==j||i==j+1 ? s : Base.replace_with_centered_mark(s)
+end
+
 #Implements the inverse using the recurrence relation between principal minors
 # a, b, c are assumed to be the subdiagonal, diagonal, and superdiagonal of
 # a tridiagonal matrix.
@@ -249,7 +283,7 @@ det(A::SymTridiagonal) = det_usmani(A.ev, A.dv, A.ev)
 
 function getindex{T}(A::SymTridiagonal{T}, i::Integer, j::Integer)
     if !(1 <= i <= size(A,2) && 1 <= j <= size(A,2))
-        throw(BoundsError("(i,j) = ($i,$j) not within matrix of size $(size(A))"))
+        throw(BoundsError(A, (i,j)))
     end
     if i == j
         return A.dv[i]
@@ -262,6 +296,16 @@ function getindex{T}(A::SymTridiagonal{T}, i::Integer, j::Integer)
     end
 end
 
+function setindex!(A::SymTridiagonal, x, i::Integer, j::Integer)
+    if i == j
+        A.dv[i] = x
+    elseif abs(i - j) == 1
+        A.ev[min(i,j)] = x
+    else
+        throw(ArgumentError("cannot set elements outside the sub, main, or super diagonals"))
+    end
+end
+
 ## Tridiagonal matrices ##
 immutable Tridiagonal{T} <: AbstractMatrix{T}
     dl::Vector{T}    # sub-diagonal
@@ -269,6 +313,8 @@ immutable Tridiagonal{T} <: AbstractMatrix{T}
     du::Vector{T}    # sup-diagonal
     du2::Vector{T}   # supsup-diagonal for pivoting
 end
+
+# Basic constructor takes in three dense vectors of same type
 function Tridiagonal{T}(dl::Vector{T}, d::Vector{T}, du::Vector{T})
     n = length(d)
     if (length(dl) != n-1 || length(du) != n-1)
@@ -276,10 +322,23 @@ function Tridiagonal{T}(dl::Vector{T}, d::Vector{T}, du::Vector{T})
     end
     Tridiagonal(dl, d, du, zeros(T,n-2))
 end
-function Tridiagonal{Tl, Td, Tu}(dl::Vector{Tl}, d::Vector{Td}, du::Vector{Tu})
+
+# Construct from diagonals of any abstract vector, any eltype
+function Tridiagonal{Tl, Td, Tu}(dl::AbstractVector{Tl}, d::AbstractVector{Td}, du::AbstractVector{Tu})
     Tridiagonal(map(v->convert(Vector{promote_type(Tl,Td,Tu)}, v), (dl, d, du))...)
 end
 
+# Provide a constructor Tridiagonal(A) similar to the triangulars, diagonal, symmetric
+"""
+    Tridiagonal(A)
+
+returns a `Tridiagonal` array based on (abstract) matrix `A`, using its lower diagonal,
+diagonal, and upper diagonal.
+"""
+function Tridiagonal(A::AbstractMatrix)
+    return Tridiagonal(diag(A,-1), diag(A), diag(A,+1))
+end
+
 size(M::Tridiagonal) = (length(M.d), length(M.d))
 function size(M::Tridiagonal, d::Integer)
     if d < 1
@@ -304,11 +363,8 @@ function convert{T}(::Type{Matrix{T}}, M::Tridiagonal{T})
     A
 end
 convert{T}(::Type{Matrix}, M::Tridiagonal{T}) = convert(Matrix{T}, M)
-function similar(M::Tridiagonal, T, dims::Dims)
-    if length(dims) != 2 || dims[1] != dims[2]
-        throw(DimensionMismatch("Tridiagonal matrices must be square"))
-    end
-    Tridiagonal{T}(similar(M.dl), similar(M.d), similar(M.du), similar(M.du2))
+function similar{T}(M::Tridiagonal, ::Type{T})
+    Tridiagonal{T}(similar(M.dl, T), similar(M.d, T), similar(M.du, T), similar(M.du2, T))
 end
 
 # Operations on Tridiagonal matrices
@@ -339,13 +395,13 @@ function diag{T}(M::Tridiagonal{T}, n::Integer=0)
     elseif abs(n) < size(M,1)
         return zeros(T,size(M,1)-abs(n))
     else
-        throw(BoundsError("$n-th diagonal of a $(size(M)) matrix doesn't exist!"))
+        throw(ArgumentError("$n-th diagonal of a $(size(M)) matrix doesn't exist!"))
     end
 end
 
 function getindex{T}(A::Tridiagonal{T}, i::Integer, j::Integer)
     if !(1 <= i <= size(A,2) && 1 <= j <= size(A,2))
-        throw(BoundsError("(i,j) = ($i,$j) not within matrix of size $(size(A))"))
+        throw(BoundsError(A, (i,j)))
     end
     if i == j
         return A.d[i]
@@ -358,6 +414,23 @@ function getindex{T}(A::Tridiagonal{T}, i::Integer, j::Integer)
     end
 end
 
+function setindex!(A::Tridiagonal, x, i::Integer, j::Integer)
+    if i == j
+        A.d[i] = x
+    elseif i - j == 1
+        A.dl[j] = x
+    elseif j - i == 1
+        A.du[i] = x
+    else
+        throw(ArgumentError("cannot set elements outside the sub, main, or super diagonals"))
+    end
+end
+
+## structured matrix methods ##
+function Base.replace_in_print_matrix(A::Tridiagonal,i::Integer,j::Integer,s::AbstractString)
+    i==j-1||i==j||i==j+1 ? s : Base.replace_with_centered_mark(s)
+end
+
 #tril and triu
 
 istriu(M::Tridiagonal) = all(M.dl .== 0)
diff --git a/base/linalg/uniformscaling.jl b/base/linalg/uniformscaling.jl
index 55899c810112a..5d7a2d84adbfb 100644
--- a/base/linalg/uniformscaling.jl
+++ b/base/linalg/uniformscaling.jl
@@ -89,7 +89,7 @@ function (-)(J::UniformScaling, UL::Union{LowerTriangular,UnitLowerTriangular})
 end
 
 function (+){TA,TJ}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
-    n = chksquare(A)
+    n = checksquare(A)
     B = similar(A, promote_type(TA,TJ))
     copy!(B,A)
     @inbounds for i = 1:n
@@ -99,7 +99,7 @@ function (+){TA,TJ}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
 end
 
 function (-){TA,TJ<:Number}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
-    n = chksquare(A)
+    n = checksquare(A)
     B = similar(A, promote_type(TA,TJ))
     copy!(B, A)
     @inbounds for i = 1:n
@@ -108,7 +108,7 @@ function (-){TA,TJ<:Number}(A::AbstractMatrix{TA}, J::UniformScaling{TJ})
     B
 end
 function (-){TA,TJ<:Number}(J::UniformScaling{TJ}, A::AbstractMatrix{TA})
-    n = chksquare(A)
+    n = checksquare(A)
     B = convert(AbstractMatrix{promote_type(TJ,TA)}, -A)
     @inbounds for j = 1:n
         B[j,j] += J.λ
@@ -128,15 +128,15 @@ inv(J::UniformScaling) = UniformScaling(inv(J.λ))
 *(J::UniformScaling, x::Number) = UniformScaling(J.λ*x)
 
 /(J1::UniformScaling, J2::UniformScaling) = J2.λ == 0 ? throw(SingularException(1)) : UniformScaling(J1.λ/J2.λ)
-/(J::UniformScaling, A::AbstractMatrix) = J.λ*inv(A)
+/(J::UniformScaling, A::AbstractMatrix) = scale!(J.λ, inv(A))
 /(A::AbstractMatrix, J::UniformScaling) = J.λ == 0 ? throw(SingularException(1)) : A/J.λ
 
 /(J::UniformScaling, x::Number) = UniformScaling(J.λ/x)
 
 \(J1::UniformScaling, J2::UniformScaling) = J1.λ == 0 ? throw(SingularException(1)) : UniformScaling(J1.λ\J2.λ)
-\{T<:Number}(A::Union{Bidiagonal{T},AbstractTriangular{T}}, J::UniformScaling) = inv(A)*J.λ
+\{T<:Number}(A::Union{Bidiagonal{T},AbstractTriangular{T}}, J::UniformScaling) = scale!(inv(A), J.λ)
 \(J::UniformScaling, A::AbstractVecOrMat) = J.λ == 0 ? throw(SingularException(1)) : J.λ\A
-\(A::AbstractMatrix, J::UniformScaling) = inv(A)*J.λ
+\(A::AbstractMatrix, J::UniformScaling) = scale!(inv(A), J.λ)
 
 \(x::Number, J::UniformScaling) = UniformScaling(x\J.λ)
 
diff --git a/base/loading.jl b/base/loading.jl
index 4071d136f17b7..8b522437c03cc 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -2,6 +2,84 @@
 
 # Base.require is the implementation for the `import` statement
 
+# Cross-platform case-sensitive path canonicalization
+
+if OS_NAME ∈ (:Linux, :FreeBSD)
+    # Case-sensitive filesystems, don't have to do anything
+    isfile_casesensitive(path) = isfile(path)
+elseif OS_NAME == :Windows
+    # GetLongPathName Win32 function returns the case-preserved filename on NTFS.
+    function isfile_casesensitive(path)
+        isfile(path) || return false  # Fail fast
+        Filesystem.longpath(path) == path
+    end
+elseif OS_NAME == :Darwin
+    # HFS+ filesystem is case-preserving. The getattrlist API returns
+    # a case-preserved filename. In the rare event that HFS+ is operating
+    # in case-sensitive mode, this will still work but will be redundant.
+
+    # Constants from <sys/attr.h>
+    const ATRATTR_BIT_MAP_COUNT = 5
+    const ATTR_CMN_NAME = 1
+    const BITMAPCOUNT = 1
+    const COMMONATTR = 5
+    const FSOPT_NOFOLLOW = 1  # Don't follow symbolic links
+
+    const attr_list = zeros(UInt8, 24)
+    attr_list[BITMAPCOUNT] = ATRATTR_BIT_MAP_COUNT
+    attr_list[COMMONATTR] = ATTR_CMN_NAME
+
+    # This essentially corresponds to the following C code:
+    # attrlist attr_list;
+    # memset(&attr_list, 0, sizeof(attr_list));
+    # attr_list.bitmapcount = ATTR_BIT_MAP_COUNT;
+    # attr_list.commonattr = ATTR_CMN_NAME;
+    # struct Buffer {
+    #    u_int32_t total_length;
+    #    u_int32_t filename_offset;
+    #    u_int32_t filename_length;
+    #    char filename[max_filename_length];
+    # };
+    # Buffer buf;
+    # getattrpath(path, &attr_list, &buf, sizeof(buf), FSOPT_NOFOLLOW);
+    function isfile_casesensitive(path)
+        isfile(path) || return false
+        path_basename = bytestring(basename(path))
+        local casepreserved_basename
+        const header_size = 12
+        buf = Array(UInt8, length(path_basename) + header_size + 1)
+        while true
+            ret = ccall(:getattrlist, Cint,
+                        (Cstring, Ptr{Void}, Ptr{Void}, Csize_t, Culong),
+                        path, attr_list, buf, sizeof(buf), FSOPT_NOFOLLOW)
+            systemerror(:getattrlist, ret ≠ 0)
+            filename_length = unsafe_load(
+              convert(Ptr{UInt32}, pointer(buf) + 8))
+            if (filename_length + header_size) > length(buf)
+                resize!(buf, filename_length + header_size)
+                continue
+            end
+            casepreserved_basename =
+              sub(buf, (header_size+1):(header_size+filename_length-1))
+            break
+        end
+        # Hack to compensate for inability to create a string from a subarray with no allocations.
+        path_basename.data == casepreserved_basename && return true
+
+        # If there is no match, it's possible that the file does exist but HFS+
+        # performed unicode normalization. See  https://developer.apple.com/library/mac/qa/qa1235/_index.html.
+        isascii(path_basename) && return false
+        normalize_string(path_basename, :NFD).data == casepreserved_basename
+    end
+else
+    # Generic fallback that performs a slow directory listing.
+    function isfile_casesensitive(path)
+        isfile(path) || return false
+        dir, filename = splitdir(path)
+        any(readdir(dir) .== filename)
+    end
+end
+
 # `wd` is a working directory to search. defaults to current working directory.
 # if `wd === nothing`, no extra path is searched.
 function find_in_path(name::AbstractString, wd = pwd())
@@ -13,15 +91,15 @@ function find_in_path(name::AbstractString, wd = pwd())
         name = string(base,".jl")
     end
     if wd !== nothing
-        isfile(joinpath(wd,name)) && return joinpath(wd,name)
+        isfile_casesensitive(joinpath(wd,name)) && return joinpath(wd,name)
     end
     for prefix in [Pkg.dir(); LOAD_PATH]
         path = joinpath(prefix, name)
-        isfile(path) && return abspath(path)
+        isfile_casesensitive(path) && return abspath(path)
         path = joinpath(prefix, base, "src", name)
-        isfile(path) && return abspath(path)
+        isfile_casesensitive(path) && return abspath(path)
         path = joinpath(prefix, name, "src", name)
-        isfile(path) && return abspath(path)
+        isfile_casesensitive(path) && return abspath(path)
     end
     return nothing
 end
@@ -30,7 +108,7 @@ function find_in_node_path(name, srcpath, node::Int=1)
     if myid() == node
         find_in_path(name, srcpath)
     else
-        remotecall_fetch(node, find_in_path, name, srcpath)
+        remotecall_fetch(find_in_path, node, name, srcpath)
     end
 end
 
@@ -47,7 +125,7 @@ function find_all_in_cache_path(mod::Symbol)
     paths = AbstractString[]
     for prefix in LOAD_CACHE_PATH
         path = joinpath(prefix, name*".ji")
-        if isfile(path)
+        if isfile_casesensitive(path)
             push!(paths, path)
         end
     end
@@ -60,14 +138,17 @@ end
 
 # returns an array of modules loaded, or nothing if failed
 function _require_from_serialized(node::Int, mod::Symbol, path_to_try::ByteString, toplevel_load::Bool)
+    if JLOptions().use_compilecache == 0
+        return nothing
+    end
     restored = nothing
     if toplevel_load && myid() == 1 && nprocs() > 1
         recompile_stale(mod, path_to_try)
         # broadcast top-level import/using from node 1 (only)
         if node == myid()
-            content = open(readbytes, path_to_try)
+            content = open(read, path_to_try)
         else
-            content = remotecall_fetch(node, open, readbytes, path_to_try)
+            content = remotecall_fetch(open, node, read, path_to_try)
         end
         restored = _include_from_serialized(content)
         if restored !== nothing
@@ -83,14 +164,14 @@ function _require_from_serialized(node::Int, mod::Symbol, path_to_try::ByteStrin
         myid() == 1 && recompile_stale(mod, path_to_try)
         restored = ccall(:jl_restore_incremental, Any, (Ptr{UInt8},), path_to_try)
     else
-        content = remotecall_fetch(node, open, readbytes, path_to_try)
+        content = remotecall_fetch(open, node, read, path_to_try)
         restored = _include_from_serialized(content)
     end
     # otherwise, continue search
 
     if restored !== nothing
         for M in restored
-            if isdefined(M, :__META__)
+            if isdefined(M, Base.Docs.META)
                 push!(Base.Docs.modules, M)
             end
         end
@@ -99,6 +180,9 @@ function _require_from_serialized(node::Int, mod::Symbol, path_to_try::ByteStrin
 end
 
 function _require_from_serialized(node::Int, mod::Symbol, toplevel_load::Bool)
+    if JLOptions().use_compilecache == 0
+        return nothing
+    end
     if node == myid()
         paths = find_all_in_cache_path(mod)
     else
@@ -155,44 +239,64 @@ precompilableerror(ex, c) = false
 # Call __precompile__ at the top of a file to force it to be precompiled (true), or
 # to be prevent it from being precompiled (false).  __precompile__(true) is
 # ignored except within "require" call.
+"""
+    __precompile__(isprecompilable::Bool=true)
+
+Specify whether the file calling this function is precompilable. If `isprecompilable` is
+`true`, then `__precompile__` throws an exception when the file is loaded by
+`using`/`import`/`require` *unless* the file is being precompiled, and in a module file it
+causes the module to be automatically precompiled when it is imported. Typically,
+`__precompile__()` should occur before the `module` declaration in the file, or better yet
+`VERSION >= v"0.4" && __precompile__()` in order to be backward-compatible with Julia 0.3.
+
+If a module or file is *not* safely precompilable, it should call `__precompile__(false)` in
+order to throw an error if Julia attempts to precompile it.
+
+`__precompile__()` should *not* be used in a module unless all of its dependencies are also
+using `__precompile__()`. Failure to do so can result in a runtime error when loading the module.
+"""
 function __precompile__(isprecompilable::Bool=true)
-    if myid() == 1 && isprecompilable != (0 != ccall(:jl_generating_output, Cint, ())) &&
-        !(isprecompilable && toplevel_load::Bool)
+    if (myid() == 1 &&
+        JLOptions().use_compilecache != 0 &&
+        isprecompilable != (0 != ccall(:jl_generating_output, Cint, ())) &&
+        !(isprecompilable && toplevel_load::Bool))
         throw(PrecompilableError(isprecompilable))
     end
 end
 
-function require_filename(name::AbstractString)
+function require_modname(name::AbstractString)
     # This function can be deleted when the deprecation for `require`
     # is deleted.
     # While we could also strip off the absolute path, the user may be
     # deliberately directing to a different file than what got
     # cached. So this takes a conservative approach.
-    if endswith(name, ".jl")
-        tmp = name[1:end-3]
-        for prefix in LOAD_CACHE_PATH
-            path = joinpath(prefix, tmp*".ji")
-            if isfile(path)
-                return tmp
+    if Bool(JLOptions().use_compilecache)
+        if endswith(name, ".jl")
+            tmp = name[1:end-3]
+            for prefix in LOAD_CACHE_PATH
+                path = joinpath(prefix, tmp*".ji")
+                if isfile(path)
+                    return tmp
+                end
             end
         end
     end
-    name
+    return name
 end
 
-doc"""
+"""
     reload(name::AbstractString)
 
 Force reloading of a package, even if it has been loaded before. This is intended for use
 during package development as code is modified.
 """
 function reload(name::AbstractString)
-    if isfile(name) || contains(name,path_separator)
+    if isfile(name) || contains(name,Filesystem.path_separator)
         # for reload("path/file.jl") just ask for include instead
         error("use `include` instead of `reload` to load source files")
     else
         # reload("Package") is ok
-        require(symbol(require_filename(name)))
+        require(symbol(require_modname(name)))
     end
 end
 
@@ -227,10 +331,11 @@ function require(mod::Symbol)
             end
             return
         end
-
         name = string(mod)
         path = find_in_node_path(name, nothing, 1)
-        path === nothing && throw(ArgumentError("$name not found in path"))
+        if path === nothing
+            throw(ArgumentError("$name not found in path.\nRun Pkg.add(\"$name\") to install the $name package"))
+        end
         try
             if last && myid() == 1 && nprocs() > 1
                 # include on node 1 first to check for PrecompilableErrors
@@ -267,9 +372,8 @@ include_string(txt::ByteString, fname::ByteString) =
     ccall(:jl_load_file_string, Any, (Ptr{UInt8},Csize_t,Ptr{UInt8},Csize_t),
           txt, sizeof(txt), fname, sizeof(fname))
 
-include_string(txt::AbstractString, fname::AbstractString) = include_string(bytestring(txt), bytestring(fname))
-
-include_string(txt::AbstractString) = include_string(txt, "string")
+include_string(txt::AbstractString, fname::AbstractString="string") =
+    include_string(bytestring(txt), bytestring(fname))
 
 function source_path(default::Union{AbstractString,Void}="")
     t = current_task()
@@ -292,6 +396,15 @@ end
 
 macro __FILE__() source_path() end
 
+"""
+    include(path::AbstractString)
+
+Evaluate the contents of a source file in the current context. During including, a
+task-local include path is set to the directory containing the file. Nested calls to
+`include` will search relative to that path. All paths refer to files on node 1 when running
+in parallel, and files will be fetched from node 1. This function is typically used to load
+source interactively, or to combine files in packages that are broken into multiple source files.
+"""
 function include_from_node1(_path::AbstractString)
     path, prev = _include_dependency(_path)
     tls = task_local_storage()
@@ -304,7 +417,7 @@ function include_from_node1(_path::AbstractString)
             result = Core.include(path)
             nprocs()>1 && sleep(0.005)
         else
-            result = include_string(remotecall_fetch(1, readall, path), path)
+            result = include_string(remotecall_fetch(readstring, 1, path), path)
         end
     finally
         if prev === nothing
@@ -327,16 +440,18 @@ end
 evalfile(path::AbstractString, args::Vector) = evalfile(path, UTF8String[args...])
 
 function create_expr_cache(input::AbstractString, output::AbstractString)
-    isfile(output) && rm(output)
+    rm(output, force=true)   # Remove file if it exists
     code_object = """
         while !eof(STDIN)
             eval(Main, deserialize(STDIN))
         end
         """
-    io, pobj = open(detach(`$(julia_cmd())
-                           --output-ji $output --output-incremental=yes
-                           --startup-file=no --history-file=no
-                           --eval $code_object`), "w", STDOUT)
+    io, pobj = open(pipeline(detach(`$(julia_cmd())
+                                    --output-ji $output --output-incremental=yes
+                                    --startup-file=no --history-file=no
+                                    --color=$(have_color ? "yes" : "no")
+                                    --eval $code_object`), stderr=STDERR),
+                    "w", STDOUT)
     try
         serialize(io, quote
                   empty!(Base.LOAD_PATH)
@@ -355,9 +470,7 @@ function create_expr_cache(input::AbstractString, output::AbstractString)
         serialize(io, :(Base._track_dependencies[1] = true))
         serialize(io, :(Base.include($(abspath(input)))))
         if source !== nothing
-            serialize(io, quote
-                      delete!(task_local_storage(), :SOURCE_PATH)
-                      end)
+            serialize(io, :(delete!(task_local_storage(), :SOURCE_PATH)))
         end
         close(io)
         wait(pobj)
@@ -396,14 +509,14 @@ function cache_dependencies(f::IO)
         n = ntoh(read(f, Int32))
         n == 0 && break
         push!(modules,
-              (symbol(readbytes(f, n)), # module symbol
+              (symbol(read(f, n)), # module symbol
                ntoh(read(f, UInt64)))) # module UUID (timestamp)
     end
     read(f, Int64) # total bytes for file dependencies
     while true
         n = ntoh(read(f, Int32))
         n == 0 && break
-        push!(files, (bytestring(readbytes(f, n)), ntoh(read(f, Float64))))
+        push!(files, (bytestring(read(f, n)), ntoh(read(f, Float64))))
     end
     return modules, files
 end
@@ -429,7 +542,8 @@ function stale_cachefile(modpath, cachefile)
             return true # cache file was compiled from a different path
         end
         for (f,ftime) in files
-            if mtime(f) != ftime
+            # Issue #13606: compensate for Docker images rounding mtimes
+            if mtime(f) ∉ (ftime, floor(ftime))
                 return true
             end
         end
@@ -451,13 +565,10 @@ end
 function recompile_stale(mod, cachefile)
     path = find_in_path(string(mod), nothing)
     if path === nothing
-        rm(cachefile)
-        error("module $mod not found in current path; removed orphaned cache file $cachefile")
+        error("module $mod not found in current path; you should rm(\"$(escape_string(cachefile))\") to remove the orphaned cache file")
     end
     if stale_cachefile(path, cachefile)
         info("Recompiling stale cache file $cachefile for module $mod.")
-        if !success(create_expr_cache(path, cachefile))
-            error("Failed to precompile $mod to $cachefile")
-        end
+        compilecache(mod)
     end
 end
diff --git a/base/lock.jl b/base/lock.jl
index 38ccc95c7530d..0c21ddecfc869 100644
--- a/base/lock.jl
+++ b/base/lock.jl
@@ -58,4 +58,3 @@ function release(s::Semaphore)
     s.curr_cnt = s.curr_cnt - 1
     notify(s.cond_wait; all=false)
 end
-
diff --git a/base/locks.jl b/base/locks.jl
new file mode 100644
index 0000000000000..82872885c8f82
--- /dev/null
+++ b/base/locks.jl
@@ -0,0 +1,158 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+export SpinLock, Mutex, init_lock!, destroy_lock!, lock!, trylock!, unlock!
+
+abstract AbstractLock
+
+# Test-and-test-and-set spin locks are quickest up to about 30ish
+# contending threads. If you have more contention than that, perhaps
+# a lock is the wrong way to synchronize.
+immutable TatasLock <: AbstractLock
+    handle::Atomic{Int}
+    TatasLock() = new(Atomic{Int}(0))
+end
+
+typealias SpinLock TatasLock
+
+function lock!(l::TatasLock)
+    while true
+        if l.handle[] == 0
+            p = atomic_xchg!(l.handle, 1)
+            if p == 0
+                return 0
+            end
+        end
+        ccall(:jl_cpu_pause, Void, ())
+        # Temporary solution before we have gc transition support in codegen.
+        # This could mess up gc state when we add codegen support.
+        # Use these as a safe point
+        gc_state = ccall(:jl_gc_safe_enter, Int8, ())
+        ccall(:jl_gc_safe_leave, Void, (Int8,), gc_state)
+    end
+end
+
+function trylock!(l::TatasLock)
+    if l.handle[] == 0
+        return atomic_xchg!(l.handle, 1)
+    end
+    return 1
+end
+
+function unlock!(l::TatasLock)
+    l.handle[] = 0
+    ccall(:jl_cpu_wake, Void, ())
+    return 0
+end
+
+
+# Recursive test-and-test-and-set lock. Slower.
+immutable RecursiveTatasLock <: AbstractLock
+    ownertid::Atomic{Int16}
+    handle::Atomic{Int}
+    RecursiveTatasLock() = new(Atomic{Int16}(0), Atomic{Int}(0))
+end
+
+typealias RecursiveSpinLock RecursiveTatasLock
+
+function lock!(l::RecursiveTatasLock)
+    if l.ownertid[] == threadid()
+        l.handle[] += 1
+        return 0
+    end
+    while true
+        if l.handle[] == 0
+            if atomic_cas!(l.handle, 0, 1)
+                l.ownertid[] = threadid()
+                return 0
+            end
+        end
+        ccall(:jl_cpu_pause, Void, ())
+        # Temporary solution before we have gc transition support in codegen.
+        # This could mess up gc state when we add codegen support.
+        # Use these as a safe point
+        gc_state = ccall(:jl_gc_safe_enter, Int8, ())
+        ccall(:jl_gc_safe_leave, Void, (Int8,), gc_state)
+    end
+end
+
+function trylock!(l::RecursiveTatasLock)
+    if l.ownertid[] == threadid()
+        l.handle[] += 1
+        return 0
+    end
+    if l.handle[] == 0
+        if atomic_cas!(l.handle, 0, 1)
+            l.ownertid[] = threadid()
+            return 0
+        end
+        return 1
+    end
+    return 1
+end
+
+function unlock!(l::RecursiveTatasLock)
+    if l.ownertid[] != threadid()
+        return 1
+    end
+    if l.handle[] == 1
+        l.ownertid[] = 0
+        l.handle[] = 0
+        ccall(:jl_cpu_wake, Void, ())
+    else
+        l.handle[] -= 1
+    end
+    return 0
+end
+
+
+# These are mutexes from libuv, which abstract pthread mutexes and
+# Windows critical sections. We're doing some error checking (and
+# paying for it in overhead), but regardless, in some situations,
+# passing a bad parameter will cause an abort.
+
+# TODO: how defensive to get, and how to turn it off?
+# TODO: how to catch an abort?
+
+const UV_MUTEX_SIZE = ccall(:jl_sizeof_uv_mutex, Cint, ())
+
+type Mutex <: AbstractLock
+    ownertid::Int16
+    handle::Array{Int8}
+    Mutex() = (m = new(zero(Int16), zeros(Int8, UV_MUTEX_SIZE));
+               ccall(:uv_mutex_init, Void, (Ptr{Void},), m.handle);
+               finalizer(m, (x -> ccall(:uv_mutex_destroy, Void, (Ptr{Void},), x.handle)));
+               m)
+end
+
+function lock!(m::Mutex)
+    if m.ownertid == threadid()
+        return 0
+    end
+    # Temporary solution before we have gc transition support in codegen.
+    # This could mess up gc state when we add codegen support.
+    gc_state = ccall(:jl_gc_safe_enter, Int8, ())
+    ccall(:uv_mutex_lock, Void, (Ptr{Void},), m.handle)
+    ccall(:jl_gc_safe_leave, Void, (Int8,), gc_state)
+    m.ownertid = threadid()
+    return 0
+end
+
+function trylock!(m::Mutex)
+    if m.ownertid == threadid()
+        return 0
+    end
+    r = ccall(:uv_mutex_trylock, Cint, (Ptr{Void},), m.handle)
+    if r == 0
+        m.ownertid = threadid()
+    end
+    return r
+end
+
+function unlock!(m::Mutex)
+    if m.ownertid != threadid()
+        return Base.UV_EPERM
+    end
+    m.ownertid = 0
+    ccall(:uv_mutex_unlock, Void, (Ptr{Void},), m.handle)
+    return 0
+end
diff --git a/base/managers.jl b/base/managers.jl
index 5102eecb70097..cbbca01a63506 100644
--- a/base/managers.jl
+++ b/base/managers.jl
@@ -58,7 +58,7 @@ function launch(manager::SSHManager, params::Dict, launched::Array, launch_ntfy:
     # Wait for all launches to complete.
     launch_tasks = cell(length(manager.machines))
 
-    for (i,(machine, cnt)) in  enumerate(manager.machines)
+    for (i,(machine, cnt)) in enumerate(manager.machines)
         let machine=machine, cnt=cnt
             launch_tasks[i] = @schedule try
                     launch_on_machine(manager, machine, cnt, params, launched, launch_ntfy)
@@ -85,30 +85,63 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched,
     exeflags = params[:exeflags]
 
     # machine could be of the format [user@]host[:port] bind_addr[:bind_port]
+    # machine format string is split on whitespace
     machine_bind = split(machine)
+    if isempty(machine_bind)
+        throw(ArgumentError("invalid machine definition format string: \"$machine\$"))
+    end
     if length(machine_bind) > 1
         exeflags = `--bind-to $(machine_bind[2]) $exeflags`
     end
     exeflags = `$exeflags --worker`
 
-    machine_def = machine_bind[1]
-    machine_def = split(machine_def, ':')
-    portopt = length(machine_def) == 2 ? ` -p $(machine_def[2]) ` : ``
-    sshflags = `$(params[:sshflags]) $portopt`
-
+    machine_def = split(machine_bind[1], ':')
+    # if this machine def has a port number, add the port information to the ssh flags
+    if length(machine_def) > 2
+        throw(ArgumentError("invalid machine defintion format string: invalid port format \"$machine_def\""))
+    end
     host = machine_def[1]
+    portopt = ``
+    if length(machine_def) == 2
+        portstr = machine_def[2]
+        if !isinteger(portstr) || (p = parse(Int,portstr); p < 1 || p > 65535)
+            msg = "invalid machine definition format string: invalid port format \"$machine_def\""
+            throw(ArgumentError(msg))
+        end
+        portopt = ` -p $(machine_def[2]) `
+    end
+    sshflags = `$(params[:sshflags]) $portopt`
 
     # Build up the ssh command
-    tval = haskey(ENV, "JULIA_WORKER_TIMEOUT") ? `export JULIA_WORKER_TIMEOUT=$(ENV["JULIA_WORKER_TIMEOUT"]);` : ``
 
-    cmd = `cd $dir && $tval $exename $exeflags` # launch julia
-    cmd = `sh -l -c $(shell_escape(cmd))` # shell to launch under
-    cmd = `ssh -T -a -x -o ClearAllForwardings=yes -n $sshflags $host $(shell_escape(cmd))` # use ssh to remote launch
+    # the default worker timeout
+    tval = haskey(ENV, "JULIA_WORKER_TIMEOUT") ?
+        `export JULIA_WORKER_TIMEOUT=$(ENV["JULIA_WORKER_TIMEOUT"]);` : ``
 
-    # launch
-    io, pobj = open(detach(cmd), "r")
-    wconfig = WorkerConfig()
+    # Julia process with passed in command line flag arguments
+    cmd = `cd $dir && $tval $exename $exeflags`
+
+    # shell login (-l) with string command (-c) to launch julia process
+    cmd = `sh -l -c $(shell_escape(cmd))`
 
+    # remote launch with ssh with given ssh flags / host / port information
+    # -T → disable pseudo-terminal allocation
+    # -a → disable forwarding of auth agent connection
+    # -x → disable X11 forwarding
+    # -o ClearAllForwardings → option if forwarding connections and
+    #                          forwarded connections are causing collisions
+    # -n → Redirects stdin from /dev/null (actually, prevents reading from stdin).
+    #      Used when running ssh in the background.
+    cmd = `ssh -T -a -x -o ClearAllForwardings=yes -n $sshflags $host $(shell_escape(cmd))`
+
+    # launch the remote Julia process
+
+    # detach launches the command in a new process group, allowing it to outlive
+    # the initial julia process (Ctrl-C and teardown methods are handled through messages)
+    # for the launched porcesses.
+    io, pobj = open(pipeline(detach(cmd), stderr=STDERR), "r")
+
+    wconfig = WorkerConfig()
     wconfig.io = io
     wconfig.host = host
     wconfig.tunnel = params[:tunnel]
@@ -130,11 +163,11 @@ function manage(manager::SSHManager, id::Integer, config::WorkerConfig, op::Symb
             host = get(config.host)
             sshflags = get(config.sshflags)
             if !success(`ssh -T -a -x -o ClearAllForwardings=yes -n $sshflags $host "kill -2 $ospid"`)
-                println("Error sending a Ctrl-C to julia worker $id on $host")
+                warn(STDERR,"error sending a Ctrl-C to julia worker $id on $host")
             end
         else
             # This state can happen immediately after an addprocs
-            println("Worker $id cannot be presently interrupted.")
+            warn(STDERR,"worker $id cannot be presently interrupted.")
         end
     end
 end
@@ -153,18 +186,33 @@ let tunnel_port = 9201
 end
 
 
-# establish an SSH tunnel to a remote worker
-# returns P such that localhost:P connects to host:port
+"""
+    ssh_tunnel(user, host, bind_addr, port, sshflags) -> localport
+
+Establish an SSH tunnel to a remote worker.
+Returns a port number `localport` such that `localhost:localport` connects to `host:port`.
+"""
 function ssh_tunnel(user, host, bind_addr, port, sshflags)
-    localp = next_tunnel_port()
-    ntries = cnt = 100
-    while !success(detach(`ssh -T -a -x -o ExitOnForwardFailure=yes -f $sshflags $(user)@$host -L $localp:$bind_addr:$(Int(port)) sleep 60`)) && cnt > 0
-        localp = next_tunnel_port()
+    port = Int(port)
+    cnt  = 100
+    localport = next_tunnel_port()
+    # if we cannot do port forwarding, bail immediately
+    # the connection is forwarded to `port` on the remote server over the local port `localport`
+    # the -f option backgrounds the ssh session
+    # `sleep 60` command specifies that an alloted time of 60 seconds is allowed to start the
+    # remote julia process and estabilish the network connections specified the the process topology.
+    # If no connections are made within 60 seconds, ssh will exit and an error will be printed on the
+    # process that launched the remote process.
+    ssh = `ssh -T -a -x -o ExitOnForwardFailure=yes`
+    while !success(detach(`$ssh -f $sshflags $user@$host -L $localport:$bind_addr:$port sleep 60`)) && cnt > 0
+        localport = next_tunnel_port()
         cnt -= 1
     end
-    (cnt == 0) && error("Unable to create SSH tunnel after $cnt tries. No free port?")
-
-    localp
+    if cnt == 0
+        throw(ErrorException(
+            "unable to create SSH tunnel after $cnt tries. No free port?"))
+    end
+    return localport
 end
 
 
@@ -188,8 +236,9 @@ function launch(manager::LocalManager, params::Dict, launched::Array, c::Conditi
     exeflags = params[:exeflags]
 
     for i in 1:manager.np
-        io, pobj = open(detach(
-            setenv(`$(julia_cmd(exename)) $exeflags --bind-to $(LPROC.bind_addr) --worker`, dir=dir)), "r")
+        io, pobj = open(pipeline(detach(
+                setenv(`$(julia_cmd(exename)) $exeflags --bind-to $(LPROC.bind_addr) --worker`, dir=dir)),
+            stderr=STDERR), "r")
         wconfig = WorkerConfig()
         wconfig.process = pobj
         wconfig.io = io
@@ -242,7 +291,8 @@ function connect(manager::ClusterManager, pid::Int, config::WorkerConfig)
         if haskey(ENV, "USER")
             user = ENV["USER"]
         elseif tunnel
-            error("USER must be specified either in the environment or as part of the hostname when tunnel option is used")
+            error("USER must be specified either in the environment ",
+                  "or as part of the hostname when tunnel option is used")
         end
     end
 
@@ -313,10 +363,7 @@ function socket_reuse_port()
             elseif rc < 0
                 throw(SystemError("setsockopt() SO_REUSEPORT : "))
             end
-
-            ccall(:jl_tcp_getsockname_v4, Int32,
-                        (Ptr{Void}, Ref{Cuint}, Ref{Cushort}),
-                        s.handle, client_host, client_port) < 0 && throw(SystemError("getsockname() : "))
+            getsockname(s)
         catch e
             # This is an issue only on systems with lots of client connections, hence delay the warning....
             nworkers() > 128 && warn_once("Error trying to reuse client port number, falling back to plain socket : ", e)
@@ -342,7 +389,7 @@ function connect_to_worker(host::AbstractString, port::Integer)
         bind_addr = "127.0.0.1"
     else
         try
-            bind_addr = string(parseip(host))
+            bind_addr = string(parse(IPAddr,host))
         catch
             bind_addr = string(getaddrinfo(host))
         end
@@ -357,7 +404,7 @@ function connect_to_worker(host::AbstractString, bind_addr::AbstractString, port
 end
 
 function kill(manager::ClusterManager, pid::Int, config::WorkerConfig)
-    remote_do(pid, exit) # For TCP based transports this will result in a close of the socket
+    remote_do(exit, pid) # For TCP based transports this will result in a close of the socket
                        # at our end, which will result in a cleanup of the worker.
     nothing
 end
diff --git a/base/markdown/Common/Common.jl b/base/markdown/Common/Common.jl
index 6b5807775f347..a6c7b54a3ed3d 100644
--- a/base/markdown/Common/Common.jl
+++ b/base/markdown/Common/Common.jl
@@ -6,5 +6,5 @@ include("inline.jl")
 @flavor common [list, indentcode, blockquote, hashheader, horizontalrule,
                 paragraph,
 
-                linebreak, escapes, inline_code,
-                asterisk_bold, asterisk_italic, image, link]
+                linebreak, escapes, inline_tex, inline_code,
+                asterisk_bold, asterisk_italic, image, footnote, link]
diff --git a/base/markdown/Common/block.jl b/base/markdown/Common/block.jl
index 3053ddbac3d32..b5d715991e23c 100644
--- a/base/markdown/Common/block.jl
+++ b/base/markdown/Common/block.jl
@@ -15,11 +15,14 @@ function paragraph(stream::IO, md::MD)
     p = Paragraph()
     push!(md, p)
     skipwhitespace(stream)
+    prev_char = '\n'
     while !eof(stream)
         char = read(stream, Char)
         if char == '\n' || char == '\r'
             char == '\r' && peek(stream) == '\n' && read(stream, Char)
-            if blankline(stream) || parse(stream, md, breaking = true)
+            if prev_char == '\\'
+                write(buffer, '\n')
+            elseif blankline(stream) || parse(stream, md, breaking = true)
                 break
             else
                 write(buffer, ' ')
@@ -27,6 +30,7 @@ function paragraph(stream::IO, md::MD)
         else
             write(buffer, char)
         end
+        prev_char = char
     end
     p.content = parseinline(seek(buffer, 0), md)
     return true
diff --git a/base/markdown/Common/inline.jl b/base/markdown/Common/inline.jl
index 9e10f7a28ac64..9838342516086 100644
--- a/base/markdown/Common/inline.jl
+++ b/base/markdown/Common/inline.jl
@@ -34,6 +34,12 @@ function inline_code(stream::IO, md::MD)
     return result === nothing ? nothing : Code(result)
 end
 
+@trigger '`' ->
+function inline_tex(stream::IO, md::MD)
+    result = parse_inline_wrapper(stream, "``"; rep=true)
+    return result === nothing ? nothing : LaTeX(result)
+end
+
 # ––––––––––––––
 # Images & Links
 # ––––––––––––––
@@ -76,6 +82,21 @@ function link(stream::IO, md::MD)
     end
 end
 
+type Footnote
+    id::UTF8String
+    text
+end
+
+@trigger '[' ->
+function footnote(stream::IO, md::MD)
+    withstream(stream) do
+        startswith(stream, "[^") || return
+        id = readuntil(stream, ']', match = '[')
+        id ≡ nothing && return
+        Footnote(id, startswith(stream, ':') ? parseinline(stream, md) : nothing)
+    end
+end
+
 # –––––––––––
 # Punctuation
 # –––––––––––
diff --git a/base/markdown/GitHub/GitHub.jl b/base/markdown/GitHub/GitHub.jl
index c0ed6b9b036f8..6944871b5a495 100644
--- a/base/markdown/GitHub/GitHub.jl
+++ b/base/markdown/GitHub/GitHub.jl
@@ -20,7 +20,11 @@ function fencedcode(stream::IO, block::MD)
             line_start = position(stream)
             if startswith(stream, string(ch) ^ n)
                 if !startswith(stream, string(ch))
-                    push!(block, Code(flavor, takebuf_string(buffer) |> chomp))
+                    if flavor == "math"
+                        push!(block, LaTeX(takebuf_string(buffer) |> chomp))
+                    else
+                        push!(block, Code(flavor, takebuf_string(buffer) |> chomp))
+                    end
                     return true
                 else
                     seek(stream, line_start)
@@ -57,5 +61,5 @@ end
 @flavor github [list, indentcode, blockquote, fencedcode, hashheader,
                 github_table, github_paragraph,
 
-                linebreak, escapes, en_dash, inline_code, asterisk_bold,
-                asterisk_italic, image, link]
+                linebreak, escapes, en_dash, inline_tex, inline_code, asterisk_bold,
+                asterisk_italic, image, footnote, link]
diff --git a/base/markdown/GitHub/table.jl b/base/markdown/GitHub/table.jl
index baedbdf987eaa..0f5a532c51782 100644
--- a/base/markdown/GitHub/table.jl
+++ b/base/markdown/GitHub/table.jl
@@ -115,6 +115,24 @@ function plain(io::IO, md::Table)
     end
 end
 
+function rst(io::IO, md::Table)
+    cells = mapmap(rstinline, md.rows)
+    padcells!(cells, md.align, len = length, min = 3)
+    single = ["-"^length(c) for c in cells[1]]
+    double = ["="^length(c) for c in cells[1]]
+    function print_row(row, row_sep, col_sep)
+        print(io, col_sep, row_sep)
+        print_joined(io, row, string(row_sep, col_sep, row_sep))
+        println(io, row_sep, col_sep)
+    end
+    print_row(single, '-', '+')
+    for i = 1:length(cells)
+        print_row(cells[i], ' ', '|')
+        i ≡ 1 ? print_row(double, '=', '+') :
+                print_row(single, '-', '+')
+    end
+end
+
 function term(io::IO, md::Table, columns)
     cells = mapmap(terminline, md.rows)
     padcells!(cells, md.align, len = ansi_length)
diff --git a/base/markdown/IPython/IPython.jl b/base/markdown/IPython/IPython.jl
index 2ad0b39c5b161..a64a350fea641 100644
--- a/base/markdown/IPython/IPython.jl
+++ b/base/markdown/IPython/IPython.jl
@@ -26,7 +26,7 @@ writemime(io::IO, ::MIME"text/plain", tex::LaTeX) =
     print(io, '$', tex.formula, '$')
 
 latex(io::IO, tex::LaTeX) =
-    print(io, "\$\$", tex.formula, "\$\$")
+    println(io, "\$\$", tex.formula, "\$\$")
 
 latexinline(io::IO, tex::LaTeX) =
     print(io, '$', tex.formula, '$')
diff --git a/base/markdown/Julia/Julia.jl b/base/markdown/Julia/Julia.jl
index feaa28db916fa..abd26ac3cd534 100644
--- a/base/markdown/Julia/Julia.jl
+++ b/base/markdown/Julia/Julia.jl
@@ -10,5 +10,5 @@ include("interp.jl")
 @flavor julia [blocktex, blockinterp, hashheader, list, indentcode, fencedcode,
                blockquote, github_table, horizontalrule, setextheader, paragraph,
 
-               linebreak, escapes, tex, interp, en_dash, inline_code,
-               asterisk_bold, asterisk_italic, image, link]
+               linebreak, escapes, tex, interp, en_dash, inline_tex, inline_code,
+               asterisk_bold, asterisk_italic, image, footnote, link]
diff --git a/base/markdown/Julia/interp.jl b/base/markdown/Julia/interp.jl
index 1147a705aeb19..eecfcb09b9487 100644
--- a/base/markdown/Julia/interp.jl
+++ b/base/markdown/Julia/interp.jl
@@ -2,7 +2,7 @@
 
 function Base.parse(stream::IO; greedy::Bool = true, raise::Bool = true)
     pos = position(stream)
-    ex, Δ = Base.parse(readall(stream), 1, greedy = greedy, raise = raise)
+    ex, Δ = Base.parse(readstring(stream), 1, greedy = greedy, raise = raise)
     seek(stream, pos + Δ - 1)
     return ex
 end
diff --git a/base/markdown/Markdown.jl b/base/markdown/Markdown.jl
index 53f1824eb4b70..1ee18b218d308 100644
--- a/base/markdown/Markdown.jl
+++ b/base/markdown/Markdown.jl
@@ -23,7 +23,7 @@ include("render/terminal/render.jl")
 export readme, license, @md_str, @doc_str
 
 parse(markdown::AbstractString; flavor = julia) = parse(IOBuffer(markdown), flavor = flavor)
-parse_file(file::AbstractString; flavor = julia) = parse(readall(file), flavor = flavor)
+parse_file(file::AbstractString; flavor = julia) = parse(readstring(file), flavor = flavor)
 
 readme(pkg::AbstractString; flavor = github) = parse_file(Pkg.dir(pkg, "README.md"), flavor = flavor)
 readme(pkg::Module; flavor = github) = readme(string(pkg), flavor = flavor)
diff --git a/base/markdown/parse/util.jl b/base/markdown/parse/util.jl
index f6e43217bdc94..3eca2c9f9f794 100644
--- a/base/markdown/parse/util.jl
+++ b/base/markdown/parse/util.jl
@@ -199,7 +199,7 @@ end
 
 function showrest(io::IO)
     start = position(io)
-    show(readall(io))
+    show(readstring(io))
     println()
     seek(io, start)
 end
diff --git a/base/markdown/render/plain.jl b/base/markdown/render/plain.jl
index 7e6b40e64ab85..4ea982e74b184 100644
--- a/base/markdown/render/plain.jl
+++ b/base/markdown/render/plain.jl
@@ -20,9 +20,12 @@ function plain{l}(io::IO, header::Header{l})
 end
 
 function plain(io::IO, code::Code)
-    println(io, "```", code.language)
+    # If the code includes a fenced block this will break parsing,
+    # so it must be enclosed by a longer ````-sequence.
+    n = mapreduce(length, max, 2, matchall(r"^`+"m, code.code)) + 1
+    println(io, "`" ^ n, code.language)
     println(io, code.code)
-    println(io, "```")
+    println(io, "`" ^ n)
 end
 
 function plain(io::IO, p::Paragraph)
@@ -47,10 +50,13 @@ function plain(io::IO, q::BlockQuote)
 end
 
 function plain(io::IO, md::HorizontalRule)
-    println(io, "–" ^ 3)
+    println(io, "-" ^ 3)
 end
 
-plain(io::IO, md) = writemime(io, "text/plain", md)
+function plain(io::IO, md)
+    writemime(io,  MIME"text/plain"(), md)
+    println(io)
+end
 
 # Inline elements
 
@@ -66,6 +72,11 @@ plaininline(io::IO, md::Vector) = !isempty(md) && plaininline(io, md...)
 
 plaininline(io::IO, link::Link) = plaininline(io, "[", link.text, "](", link.url, ")")
 
+function plaininline(io::IO, md::Footnote)
+    print(io, "[^", md.id, "]")
+    md.text ≡ nothing || (print(io, ":"); plaininline(io, md.text))
+end
+
 plaininline(io::IO, md::Image) = plaininline(io, "![", md.alt, "](", md.url, ")")
 
 plaininline(io::IO, s::AbstractString) = print(io, s)
diff --git a/base/markdown/render/rst.jl b/base/markdown/render/rst.jl
index 1651d2778a066..3845a961a2a61 100644
--- a/base/markdown/render/rst.jl
+++ b/base/markdown/render/rst.jl
@@ -38,14 +38,14 @@ end
 
 function rst(io::IO, list::List)
     for (i, item) in enumerate(list.items)
-        print(io, list.ordered ? "$i. " : "  * ")
+        print(io, list.ordered ? "$i. " : "* ")
         rstinline(io, item)
         println(io)
     end
 end
 
 function rst(io::IO, q::BlockQuote)
-    s = sprint(buf -> plain(buf, q.content))
+    s = sprint(buf -> rst(buf, q.content))
     for line in split(rstrip(s), "\n")
         println(io, "    ", line)
     end
@@ -73,7 +73,7 @@ function rstinline(io::IO, md...)
     wasCode = false
     for el in md
         wasCode && isa(el, AbstractString) && !Base.startswith(el, " ") && print(io, "\\ ")
-        wasCode = (isa(el, Code) || isa(el, LaTeX)) && (wasCode = true)
+        wasCode = (isa(el, Code) || isa(el, LaTeX) || isa(el, Link)) && (wasCode = true)
         rstinline(io, el)
     end
 end
@@ -82,7 +82,22 @@ rstinline(io::IO, md::Vector) = !isempty(md) && rstinline(io, md...)
 
 # rstinline(io::IO, md::Image) = rstinline(io, ".. image:: ", md.url)
 
-rstinline(io::IO, md::Link) = rstinline(io, "`", md.text, " <", md.url, ">`_")
+function rstinline(io::IO, md::Link)
+    if ismatch(r":(func|obj|ref|exc|class|const|data):`\.*", md.url)
+        rstinline(io, md.url)
+    else
+        rstinline(io, "`", md.text, " <", md.url, ">`_")
+    end
+end
+
+function rstinline(io::IO, md::Footnote)
+    if md.text ≡ nothing
+        print(io, "[", md.id, "]_")
+    else
+        print(io, ".. [", md.id, "]")
+        rstinline(io, md.text)
+    end
+end
 
 rstescape(s) = replace(s, "\\", "\\\\")
 
diff --git a/base/markdown/render/terminal/render.jl b/base/markdown/render/terminal/render.jl
index fd2c3b5d0e711..eeb498b6f995f 100644
--- a/base/markdown/render/terminal/render.jl
+++ b/base/markdown/render/terminal/render.jl
@@ -3,7 +3,7 @@
 include("formatting.jl")
 
 const margin = 2
-cols() = Base.tty_size()[2]
+cols(io) = displaysize(io)[2]
 
 function term(io::IO, content::Vector, cols)
     isempty(content) && return
@@ -14,7 +14,7 @@ function term(io::IO, content::Vector, cols)
     term(io, content[end], cols)
 end
 
-term(io::IO, md::MD, columns = cols()) = term(io, md.content, columns)
+term(io::IO, md::MD, columns = cols(io)) = term(io, md.content, columns)
 
 function term(io::IO, md::Paragraph, columns)
     print(io, " "^margin)
@@ -28,7 +28,6 @@ function term(io::IO, md::BlockQuote, columns)
     for line in split(rstrip(s), "\n")
         println(io, " "^margin, "|", line)
     end
-    println(io)
 end
 
 function term(io::IO, md::List, columns)
@@ -93,7 +92,7 @@ function terminline(io::IO, content::Vector)
 end
 
 function terminline(io::IO, md::AbstractString)
-    print(io, md)
+    print(io, replace(md, r"[\s\t\n]+", " "))
 end
 
 function terminline(io::IO, md::Bold)
@@ -104,14 +103,23 @@ function terminline(io::IO, md::Italic)
     with_output_format(:underline, terminline, io, md.text)
 end
 
+function terminline(io::IO, md::LineBreak)
+    println(io)
+end
+
 function terminline(io::IO, md::Image)
-    print(io, "(Image: $(md.alt))")
+    terminline(io, "(Image: $(md.alt))")
 end
 
 function terminline(io::IO, md::Link)
     terminline(io, md.text)
 end
 
+function terminline(io::IO, md::Footnote)
+    print(io, "[^", md.id, "]")
+    md.text ≡ nothing || (print(io, ":"); terminline(io, md.text))
+end
+
 function terminline(io::IO, code::Code)
     print_with_format(:cyan, io, code.code)
 end
diff --git a/base/math.jl b/base/math.jl
index 0f14e19a5c2f9..6d5754cb5ed9a 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -24,7 +24,7 @@ export sin, cos, tan, sinh, cosh, tanh, asin, acos, atan,
 
 import Base: log, exp, sin, cos, tan, sinh, cosh, tanh, asin,
              acos, atan, asinh, acosh, atanh, sqrt, log2, log10,
-             max, min, minmax, ^, exp2,
+             max, min, minmax, ^, exp2, muladd,
              exp10, expm1, log1p,
              sign_mask, exponent_mask, exponent_one, exponent_half,
              significand_mask, significand_bits, exponent_bits, exponent_bias
@@ -379,6 +379,9 @@ function mod2pi(x::Int64)
   mod2pi(fx)
 end
 
+# generic fallback; for number types, promotion.jl does promotion
+muladd(x,y,z) = x*y+z
+
 # More special functions
 include("special/trig.jl")
 include("special/bessel.jl")
diff --git a/base/meta.jl b/base/meta.jl
index 6c40d1028c6bd..84bcc86255dad 100644
--- a/base/meta.jl
+++ b/base/meta.jl
@@ -41,7 +41,7 @@ function show_sexpr(io::IO, ex::Expr, indent::Int)
         print(io, ex.head === :block ? ",\n"*" "^inner : ", ")
         show_sexpr(io, arg, inner)
     end
-    if length(ex.args) == 0; print(io, ",)")
+    if isempty(ex.args); print(io, ",)")
     else print(io, (ex.head === :block ? "\n"*" "^indent : ""), ')')
     end
 end
diff --git a/base/methodshow.jl b/base/methodshow.jl
index 815d1510cff9e..f5848e11d8ba0 100644
--- a/base/methodshow.jl
+++ b/base/methodshow.jl
@@ -2,7 +2,7 @@
 
 # Method and method-table pretty-printing
 
-function argtype_decl(n, t) # -> (argname, argtype)
+function argtype_decl(env, n, t) # -> (argname, argtype)
     if isa(n,Expr)
         n = n.args[1]  # handle n::T in arg list
     end
@@ -18,35 +18,53 @@ function argtype_decl(n, t) # -> (argname, argtype)
         if t.parameters[1] === Any
             return string(s, "..."), ""
         else
-            return s, string(t.parameters[1], "...")
+            return s, string_with_env(env, t.parameters[1]) * "..."
         end
     elseif t == ByteString
         return s, "ByteString"
     end
-    return s, string(t)
+    return s, string_with_env(env, t)
 end
 
 function arg_decl_parts(m::Method)
     tv = m.tvars
     if !isa(tv,SimpleVector)
-        tv = svec(tv)
+        tv = Any[tv]
+    else
+        tv = Any[tv...]
     end
-    li = m.func.code
+    li = m.func
     e = uncompressed_ast(li)
     argnames = e.args[1]
     s = symbol("?")
-    decls = [argtype_decl(get(argnames,i,s), m.sig.parameters[i]) for i=1:length(m.sig.parameters)]
+    decls = [argtype_decl(:tvar_env => tv, get(argnames,i,s), m.sig.parameters[i])
+                for i = 1:length(m.sig.parameters)]
     return tv, decls, li.file, li.line
 end
 
 function show(io::IO, m::Method)
-    print(io, m.func.code.name)
     tv, decls, file, line = arg_decl_parts(m)
+    ft = m.sig.parameters[1]
+    d1 = decls[1]
+    if ft <: Function &&
+            isdefined(ft.name.module, ft.name.mt.name) &&
+            ft == typeof(getfield(ft.name.module, ft.name.mt.name))
+        print(io, ft.name.mt.name)
+    elseif isa(ft, DataType) && is(ft.name, Type.name) && isleaftype(ft)
+        f = ft.parameters[1]
+        if isa(f, DataType) && isempty(f.parameters)
+            print(io, f)
+        else
+            print(io, "(", d1[1], "::", d1[2], ")")
+        end
+    else
+        print(io, "(", d1[1], "::", d1[2], ")")
+    end
     if !isempty(tv)
         show_delim_array(io, tv, '{', ',', '}', false)
     end
     print(io, "(")
-    print_joined(io, [isempty(d[2]) ? d[1] : d[1]*"::"*d[2] for d in decls],
+    print_joined(io, [isempty(d[2]) ? d[1] : d[1]*"::"*d[2] for d in decls[2:end]],
                  ", ", ", ")
     print(io, ")")
     if line > 0
@@ -56,10 +74,14 @@ end
 
 function show_method_table(io::IO, mt::MethodTable, max::Int=-1, header::Bool=true)
     name = mt.name
+    isself = isdefined(mt.module, name) &&
+             typeof(getfield(mt.module, name)) <: Function
     n = length(mt)
     if header
         m = n==1 ? "method" : "methods"
-        print(io, "# $n $m for generic function \"$name\":")
+        ns = isself ? string(name) : string("(::", name, ")")
+        what = startswith(ns, '@') ? "macro" : "generic function"
+        print(io, "# $n $m for ", what, " \"", ns, "\":")
     end
     d = mt.defs
     n = rest = 0
@@ -90,27 +112,35 @@ function inbase(m::Module)
     end
 end
 fileurl(file) = let f = find_source_file(file); f === nothing ? "" : "file://"*f; end
+
 function url(m::Method)
-    M = m.func.code.module
-    (m.func.code.file == :null || m.func.code.file == :string) && return ""
-    file = string(m.func.code.file)
-    line = m.func.code.line
+    M = m.func.module
+    (m.func.file == :null || m.func.file == :string) && return ""
+    file = string(m.func.file)
+    line = m.func.line
     line <= 0 || ismatch(r"In\[[0-9]+\]", file) && return ""
     if inbase(M)
-        return "https://github.com/JuliaLang/julia/tree/$(Base.GIT_VERSION_INFO.commit)/base/$file#L$line"
+        if isempty(Base.GIT_VERSION_INFO.commit)
+            # this url will only work if we're on a tagged release
+            return "https://github.com/JuliaLang/julia/tree/v$VERSION/base/$file#L$line"
+        else
+            return "https://github.com/JuliaLang/julia/tree/$(Base.GIT_VERSION_INFO.commit)/base/$file#L$line"
+        end
     else
         try
             d = dirname(file)
-            u = Git.readchomp(`config remote.origin.url`, dir=d)
-            u = match(Git.GITHUB_REGEX,u).captures[1]
-            root = cd(d) do # dir=d confuses --show-toplevel, apparently
-                Git.readchomp(`rev-parse --show-toplevel`)
-            end
-            if startswith(file, root)
-                commit = Git.readchomp(`rev-parse HEAD`, dir=d)
-                return "https://github.com/$u/tree/$commit/"*file[length(root)+2:end]*"#L$line"
-            else
-                return fileurl(file)
+            return LibGit2.with(LibGit2.GitRepoExt(d)) do repo
+                LibGit2.with(LibGit2.GitConfig(repo)) do cfg
+                    u = LibGit2.get(cfg, "remote.origin.url", "")
+                    u = match(LibGit2.GITHUB_REGEX,u).captures[1]
+                    commit = string(LibGit2.head_oid(repo))
+                    root = LibGit2.path(repo)
+                    if startswith(file, root)
+                        "https://github.com/$u/tree/$commit/"*file[length(root)+1:end]*"#L$line"
+                    else
+                        fileurl(file)
+                    end
+                end
             end
         catch
             return fileurl(file)
@@ -119,8 +149,23 @@ function url(m::Method)
 end
 
 function writemime(io::IO, ::MIME"text/html", m::Method)
-    print(io, m.func.code.name)
     tv, decls, file, line = arg_decl_parts(m)
+    ft = m.sig.parameters[1]
+    d1 = decls[1]
+    if ft <: Function &&
+            isdefined(ft.name.module, ft.name.mt.name) &&
+            ft == typeof(getfield(ft.name.module, ft.name.mt.name))
+        print(io, ft.name.mt.name)
+    elseif isa(ft, DataType) && is(ft.name, Type.name) && isleaftype(ft)
+        f = ft.parameters[1]
+        if isa(f, DataType) && isempty(f.parameters)
+            print(io, f)
+        else
+            print(io, "(", d1[1], "::<b>", d1[2], "</b>)")
+        end
+    else
+        print(io, "(", d1[1], "::<b>", d1[2], "</b>)")
+    end
     if !isempty(tv)
         print(io,"<i>")
         show_delim_array(io, tv, '{', ',', '}', false)
@@ -128,7 +173,7 @@ function writemime(io::IO, ::MIME"text/html", m::Method)
     end
     print(io, "(")
     print_joined(io, [isempty(d[2]) ? d[1] : d[1]*"::<b>"*d[2]*"</b>"
-                      for d in decls], ", ", ", ")
+                      for d in decls[2:end]], ", ", ", ")
     print(io, ")")
     if line > 0
         u = url(m)
@@ -145,7 +190,9 @@ function writemime(io::IO, mime::MIME"text/html", mt::MethodTable)
     name = mt.name
     n = length(mt)
     meths = n==1 ? "method" : "methods"
-    print(io, "$n $meths for generic function <b>$name</b>:<ul>")
+    ns = string(name)
+    what = startswith(ns, '@') ? "macro" : "generic function"
+    print(io, "$n $meths for ", what, " <b>$ns</b>:<ul>")
     d = mt.defs
     while d !== nothing
         print(io, "<li> ")
@@ -171,4 +218,4 @@ end
 
 # override usual show method for Vector{Method}: don't abbreviate long lists
 writemime(io::IO, mime::MIME"text/plain", mt::AbstractVector{Method}) =
-    showarray(io, mt, limit=false)
+    showarray(IOContext(io, :limit_output => false), mt)
diff --git a/base/mmap.jl b/base/mmap.jl
index 3a331d884bc0f..832fbcbff1648 100644
--- a/base/mmap.jl
+++ b/base/mmap.jl
@@ -58,7 +58,7 @@ function grow!(io::IO, offset::Integer, len::Integer)
     pos = position(io)
     filelen = filesize(io)
     if filelen < offset + len
-        failure = ccall(:ftruncate, Cint, (Cint, Coff_t), fd(io), offset+len)
+        failure = ccall(:jl_ftruncate, Cint, (Cint, Int64), fd(io), offset+len)
         Base.systemerror(:ftruncate, failure != 0)
     end
     seek(io, pos)
@@ -68,16 +68,18 @@ end # @unix_only
 
 @windows_only begin
 
-const PAGE_READONLY          = UInt32(0x02)
-const PAGE_READWRITE         = UInt32(0x04)
-const PAGE_WRITECOPY         = UInt32(0x08)
-const PAGE_EXECUTE_READ      = UInt32(0x20)
-const PAGE_EXECUTE_READWRITE = UInt32(0x40)
-const PAGE_EXECUTE_WRITECOPY = UInt32(0x80)
-const FILE_MAP_COPY          = UInt32(0x01)
-const FILE_MAP_WRITE         = UInt32(0x02)
-const FILE_MAP_READ          = UInt32(0x04)
-const FILE_MAP_EXECUTE       = UInt32(0x20)
+typealias DWORD Culong
+
+const PAGE_READONLY          = DWORD(0x02)
+const PAGE_READWRITE         = DWORD(0x04)
+const PAGE_WRITECOPY         = DWORD(0x08)
+const PAGE_EXECUTE_READ      = DWORD(0x20)
+const PAGE_EXECUTE_READWRITE = DWORD(0x40)
+const PAGE_EXECUTE_WRITECOPY = DWORD(0x80)
+const FILE_MAP_COPY          = DWORD(0x01)
+const FILE_MAP_WRITE         = DWORD(0x02)
+const FILE_MAP_READ          = DWORD(0x04)
+const FILE_MAP_EXECUTE       = DWORD(0x20)
 
 function gethandle(io::IO)
     handle = Libc._get_osfhandle(RawFD(fd(io))).handle
@@ -85,27 +87,28 @@ function gethandle(io::IO)
     return Int(handle)
 end
 
-settings(sh::Anonymous) = utf16(sh.name), sh.readonly, sh.create
-settings(io::IO) = convert(Ptr{Cwchar_t},C_NULL), isreadonly(io), true
+settings(sh::Anonymous) = sh.name, sh.readonly, sh.create
+settings(io::IO) = Ptr{Cwchar_t}(0), isreadonly(io), true
 end # @windows_only
 
 # core impelementation of mmap
 function mmap{T,N}(io::IO,
-                          ::Type{Array{T,N}}=Vector{UInt8},
-                          dims::NTuple{N,Integer}=(div(filesize(io)-position(io),sizeof(T)),),
-                          offset::Integer=position(io); grow::Bool=true, shared::Bool=true)
+                   ::Type{Array{T,N}}=Vector{UInt8},
+                   dims::NTuple{N,Integer}=(div(filesize(io)-position(io),sizeof(T)),),
+                   offset::Integer=position(io); grow::Bool=true, shared::Bool=true)
     # check inputs
     isopen(io) || throw(ArgumentError("$io must be open to mmap"))
     isbits(T)  || throw(ArgumentError("unable to mmap $T; must satisfy isbits(T) == true"))
 
     len = prod(dims) * sizeof(T)
-    len > 0 || throw(ArgumentError("requested size must be > 0, got $len"))
+    len >= 0 || throw(ArgumentError("requested size must be ≥ 0, got $len"))
+    len == 0 && return Array(T,ntuple(x->0,N))
     len < typemax(Int) - PAGESIZE || throw(ArgumentError("requested size must be < $(typemax(Int)-PAGESIZE), got $len"))
 
     offset >= 0 || throw(ArgumentError("requested offset must be ≥ 0, got $offset"))
 
     # shift `offset` to start of page boundary
-    offset_page::FileOffset = div(offset, PAGESIZE) * PAGESIZE
+    offset_page::Int64 = div(offset, PAGESIZE) * PAGESIZE
     # add (offset - offset_page) to `len` to get total length of memory-mapped region
     mmaplen = (offset - offset_page) + len
 
@@ -115,7 +118,7 @@ function mmap{T,N}(io::IO,
         prot, flags, iswrite = settings(file_desc, shared)
         iswrite && grow && grow!(io, offset, len)
         # mmap the file
-        ptr = ccall(:jl_mmap, Ptr{Void}, (Ptr{Void}, Csize_t, Cint, Cint, Cint, FileOffset), C_NULL, mmaplen, prot, flags, file_desc, offset_page)
+        ptr = ccall(:jl_mmap, Ptr{Void}, (Ptr{Void}, Csize_t, Cint, Cint, Cint, Int64), C_NULL, mmaplen, prot, flags, file_desc, offset_page)
         systemerror("memory mapping failed", reinterpret(Int,ptr) == -1)
     end # @unix_only
 
@@ -123,12 +126,12 @@ function mmap{T,N}(io::IO,
         name, readonly, create = settings(io)
         szfile = convert(Csize_t, len + offset)
         readonly && szfile > filesize(io) && throw(ArgumentError("unable to increase file size to $szfile due to read-only permissions"))
-        handle = create ? ccall(:CreateFileMappingW, stdcall, Ptr{Void}, (Cptrdiff_t, Ptr{Void}, Cint, Cint, Cint, Cwstring),
+        handle = create ? ccall(:CreateFileMappingW, stdcall, Ptr{Void}, (Cptrdiff_t, Ptr{Void}, DWORD, DWORD, DWORD, Cwstring),
                                 file_desc, C_NULL, readonly ? PAGE_READONLY : PAGE_READWRITE, szfile >> 32, szfile & typemax(UInt32), name) :
-                          ccall(:OpenFileMappingW, stdcall, Ptr{Void}, (Cint, Cint, Cwstring),
-                            readonly ? FILE_MAP_READ : FILE_MAP_WRITE, true, name)
+                          ccall(:OpenFileMappingW, stdcall, Ptr{Void}, (DWORD, Cint, Cwstring),
+                                readonly ? FILE_MAP_READ : FILE_MAP_WRITE, true, name)
         handle == C_NULL && error("could not create file mapping: $(Libc.FormatMessage())")
-        ptr = ccall(:MapViewOfFile, stdcall, Ptr{Void}, (Ptr{Void}, Cint, Cint, Cint, Csize_t),
+        ptr = ccall(:MapViewOfFile, stdcall, Ptr{Void}, (Ptr{Void}, DWORD, DWORD, DWORD, Csize_t),
                     handle, readonly ? FILE_MAP_READ : FILE_MAP_WRITE, offset_page >> 32, offset_page & typemax(UInt32), (offset - offset_page) + len)
         ptr == C_NULL && error("could not create mapping view: $(Libc.FormatMessage())")
     end # @windows_only
@@ -162,7 +165,7 @@ mmap{T<:Array}(::Type{T}, i::Integer...; shared::Bool=true) = mmap(Anonymous(),
 function mmap{T<:BitArray,N}(io::IOStream,
                              ::Type{T},
                              dims::NTuple{N,Integer},
-                             offset::FileOffset=position(io); grow::Bool=true, shared::Bool=true)
+                             offset::Int64=position(io); grow::Bool=true, shared::Bool=true)
     n = prod(dims)
     nc = Base.num_bit_chunks(n)
     chunks = mmap(io, Vector{UInt64}, (nc,), offset; grow=grow, shared=shared)
@@ -201,9 +204,11 @@ const MS_INVALIDATE = 2
 const MS_SYNC = 4
 
 function sync!{T}(m::Array{T}, flags::Integer=MS_SYNC)
-    @unix_only systemerror("msync", ccall(:msync, Cint, (Ptr{Void}, Csize_t, Cint), pointer(m), length(m)*sizeof(T), flags) != 0)
+    offset = rem(UInt(pointer(m)), PAGESIZE)
+    ptr = pointer(m) - offset
+    @unix_only systemerror("msync", ccall(:msync, Cint, (Ptr{Void}, Csize_t, Cint), ptr, length(m)*sizeof(T), flags) != 0)
     @windows_only systemerror("could not FlushViewOfFile: $(Libc.FormatMessage())",
-                    ccall(:FlushViewOfFile, stdcall, Cint, (Ptr{Void}, Csize_t), pointer(m), length(m)) == 0)
+                    ccall(:FlushViewOfFile, stdcall, Cint, (Ptr{Void}, Csize_t), ptr, length(m)) == 0)
 end
 sync!(B::BitArray, flags::Integer=MS_SYNC) = sync!(B.chunks, flags)
 
diff --git a/base/mpfr.jl b/base/mpfr.jl
index 176e714007e92..fefd138e34629 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -4,10 +4,7 @@ module MPFR
 
 export
     BigFloat,
-    get_bigfloat_precision,
-    set_bigfloat_precision,
-    with_bigfloat_precision,
-    bigfloat_str,
+    setprecision,
     big_str
 
 import
@@ -16,14 +13,14 @@ import
         exp, exp2, exponent, factorial, floor, fma, hypot, isinteger,
         isfinite, isinf, isnan, ldexp, log, log2, log10, max, min, mod, modf,
         nextfloat, prevfloat, promote_rule, rem, round, show,
-        showcompact, sum, sqrt, string, print, trunc, precision, exp10, expm1,
+        sum, sqrt, string, print, trunc, precision, exp10, expm1,
         gamma, lgamma, digamma, erf, erfc, zeta, eta, log1p, airyai,
         eps, signbit, sin, cos, tan, sec, csc, cot, acos, asin, atan,
         cosh, sinh, tanh, sech, csch, coth, acosh, asinh, atanh, atan2,
-        cbrt, typemax, typemin, unsafe_trunc, realmin, realmax, get_rounding,
-        set_rounding, maxintfloat, widen, significand, frexp, tryparse
+        cbrt, typemax, typemin, unsafe_trunc, realmin, realmax, rounding,
+        setrounding, maxintfloat, widen, significand, frexp, tryparse
 
-import Base.Rounding: get_rounding_raw, set_rounding_raw
+import Base.Rounding: rounding_raw, setrounding_raw
 
 import Base.GMP: ClongMax, CulongMax, CdoubleMax
 
@@ -51,7 +48,7 @@ type BigFloat <: AbstractFloat
     exp::Clong
     d::Ptr{Culong}
     function BigFloat()
-        N = get_bigfloat_precision()
+        N = precision(BigFloat)
         z = new(zero(Clong), zero(Cint), zero(Clong), C_NULL)
         ccall((:mpfr_init2,:libmpfr), Void, (Ptr{BigFloat}, Clong), &z, N)
         finalizer(z, Base.GMP._mpfr_clear_func)
@@ -468,6 +465,7 @@ function airyai(x::BigFloat)
     ccall((:mpfr_ai, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Int32), &z, &x, ROUNDING_MODE[end])
     return z
 end
+airy(x::BigFloat) = airyai(x)
 
 function ldexp(x::BigFloat, n::Clong)
     z = BigFloat()
@@ -681,20 +679,28 @@ cmp(x::CdoubleMax, y::BigFloat) = -cmp(y,x)
 
 signbit(x::BigFloat) = ccall((:mpfr_signbit, :libmpfr), Int32, (Ptr{BigFloat},), &x) != 0
 
-function precision(x::BigFloat)
+function precision(x::BigFloat)  # precision of an object of type BigFloat
     return ccall((:mpfr_get_prec, :libmpfr), Clong, (Ptr{BigFloat},), &x)
 end
 
-get_bigfloat_precision() = DEFAULT_PRECISION[end]
-function set_bigfloat_precision(x::Int)
-    if x < 2
+precision(::Type{BigFloat}) = DEFAULT_PRECISION[end]  # precision of the type BigFloat itself
+
+"""
+    setprecision([T=BigFloat,] precision::Int)
+
+Set the precision (in bits) to be used for `T` arithmetic.
+"""
+function setprecision(::Type{BigFloat}, precision::Int)
+    if precision < 2
         throw(DomainError())
     end
-    DEFAULT_PRECISION[end] = x
+    DEFAULT_PRECISION[end] = precision
 end
 
+setprecision(precision::Int) = setprecision(BigFloat, precision)
+
 maxintfloat(x::BigFloat) = BigFloat(2)^precision(x)
-maxintfloat(::Type{BigFloat}) = BigFloat(2)^get_bigfloat_precision()
+maxintfloat(::Type{BigFloat}) = BigFloat(2)^precision(BigFloat)
 
 to_mpfr(::RoundingMode{:Nearest}) = Cint(0)
 to_mpfr(::RoundingMode{:ToZero}) = Cint(1)
@@ -719,10 +725,11 @@ function from_mpfr(c::Integer)
     RoundingMode(c)
 end
 
-get_rounding_raw(::Type{BigFloat}) = ROUNDING_MODE[end]
-set_rounding_raw(::Type{BigFloat},i::Integer) = ROUNDING_MODE[end] = i
-get_rounding(::Type{BigFloat}) = from_mpfr(get_rounding_raw(BigFloat))
-set_rounding(::Type{BigFloat},r::RoundingMode) = set_rounding_raw(BigFloat,to_mpfr(r))
+rounding_raw(::Type{BigFloat}) = ROUNDING_MODE[end]
+setrounding_raw(::Type{BigFloat},i::Integer) = ROUNDING_MODE[end] = i
+
+rounding(::Type{BigFloat}) = from_mpfr(rounding_raw(BigFloat))
+setrounding(::Type{BigFloat},r::RoundingMode) = setrounding_raw(BigFloat,to_mpfr(r))
 
 function copysign(x::BigFloat, y::BigFloat)
     z = BigFloat()
@@ -813,22 +820,38 @@ eps(::Type{BigFloat}) = nextfloat(BigFloat(1)) - BigFloat(1)
 realmin(::Type{BigFloat}) = nextfloat(zero(BigFloat))
 realmax(::Type{BigFloat}) = prevfloat(BigFloat(Inf))
 
-function with_bigfloat_precision(f::Function, precision::Integer)
-    old_precision = get_bigfloat_precision()
-    set_bigfloat_precision(precision)
+"""
+    setprecision(f::Function, [T=BigFloat,] precision::Integer)
+
+Change the `T` arithmetic precision (in bits) for the duration of `f`.
+It is logically equivalent to:
+
+    old = precision(BigFloat)
+    setprecision(BigFloat, precision)
+    f()
+    setprecision(BigFloat, old)
+
+Often used as `setprecision(T, precision) do ... end`
+"""
+function setprecision{T}(f::Function, ::Type{T}, prec::Integer)
+    old_prec = precision(T)
+    setprecision(T, prec)
     try
         return f()
     finally
-        set_bigfloat_precision(old_precision)
+        setprecision(T, old_prec)
     end
 end
 
+setprecision(f::Function, precision::Integer) = setprecision(f, BigFloat, precision)
+
 function string(x::BigFloat)
     # In general, the number of decimal places needed to read back the number exactly
     # is, excluding the most significant, ceil(log(10, 2^precision(x)))
     k = ceil(Int32, precision(x) * 0.3010299956639812)
     lng = k + Int32(8) # Add space for the sign, the most significand digit, the dot and the exponent
     buf = Array(UInt8, lng + 1)
+    # format strings are guaranteed to contain no NUL, so we don't use Cstring
     lng = ccall((:mpfr_snprintf,:libmpfr), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Ptr{BigFloat}...), buf, lng + 1, "%.Re", &x)
     if lng < k + 5 # print at least k decimal places
         lng = ccall((:mpfr_sprintf,:libmpfr), Int32, (Ptr{UInt8}, Ptr{UInt8}, Ptr{BigFloat}...), buf, "%.$(k)Re", &x)
@@ -841,7 +864,6 @@ end
 
 print(io::IO, b::BigFloat) = print(io, string(b))
 show(io::IO, b::BigFloat) = print(io, string(b))
-showcompact(io::IO, b::BigFloat) = print(io, string(b))
 
 # get/set exponent min/max
 get_emax() = ccall((:mpfr_get_emax, :libmpfr), Clong, ())
diff --git a/base/multi.jl b/base/multi.jl
index cff41f09549aa..7b6e9b2560ae7 100644
--- a/base/multi.jl
+++ b/base/multi.jl
@@ -134,8 +134,8 @@ type Worker
     c_state::Condition      # wait for state changes
     ct_time::Float64        # creation time
 
-    r_stream::AsyncStream
-    w_stream::AsyncStream
+    r_stream::IO
+    w_stream::IO
     manager::ClusterManager
     config::WorkerConfig
 
@@ -185,14 +185,14 @@ function flush_gc_msgs(w::Worker)
     msgs = copy(w.add_msgs)
     if !isempty(msgs)
         empty!(w.add_msgs)
-        remote_do(w, add_clients, msgs)
+        remote_do(add_clients, w, msgs)
     end
 
     msgs = copy(w.del_msgs)
     if !isempty(msgs)
         empty!(w.del_msgs)
         #print("sending delete of $msgs\n")
-        remote_do(w, del_clients, msgs)
+        remote_do(del_clients, w, msgs)
     end
 end
 
@@ -293,7 +293,7 @@ get_bind_addr(w::LocalProcess) = LPROC.bind_addr
 function get_bind_addr(w::Worker)
     if isnull(w.config.bind_addr)
         if w.id != myid()
-            w.config.bind_addr = remotecall_fetch(w.id, get_bind_addr, w.id)
+            w.config.bind_addr = remotecall_fetch(get_bind_addr, w.id, w.id)
         end
     end
     get(w.config.bind_addr)
@@ -317,7 +317,7 @@ function procs(pid::Integer)
             Int[x.id for x in filter(w -> get_bind_addr(w) == ipatpid, PGRP.workers)]
         end
     else
-        remotecall_fetch(1, procs, pid)
+        remotecall_fetch(procs, 1, pid)
     end
 end
 
@@ -336,30 +336,35 @@ function rmprocs(args...; waitfor = 0.0)
         error("only process 1 can add and remove processes")
     end
 
-    rmprocset = []
-    for i in vcat(args...)
-        if i == 1
-            warn("rmprocs: process 1 not removed")
-        else
-            if haskey(map_pid_wrkr, i)
-                w = map_pid_wrkr[i]
-                set_worker_state(w, W_TERMINATING)
-                kill(w.manager, i, w.config)
-                push!(rmprocset, w)
+    lock(worker_lock)
+    try
+        rmprocset = []
+        for i in vcat(args...)
+            if i == 1
+                warn("rmprocs: process 1 not removed")
+            else
+                if haskey(map_pid_wrkr, i)
+                    w = map_pid_wrkr[i]
+                    set_worker_state(w, W_TERMINATING)
+                    kill(w.manager, i, w.config)
+                    push!(rmprocset, w)
+                end
             end
         end
-    end
 
-    start = time()
-    while (time() - start) < waitfor
-        if all(w -> w.state == W_TERMINATED, rmprocset)
-            break;
-        else
-            sleep(0.1)
+        start = time()
+        while (time() - start) < waitfor
+            if all(w -> w.state == W_TERMINATED, rmprocset)
+                break;
+            else
+                sleep(0.1)
+            end
         end
-    end
 
-    ((waitfor > 0) && any(w -> w.state != W_TERMINATED, rmprocset)) ? :timed_out : :ok
+        ((waitfor > 0) && any(w -> w.state != W_TERMINATED, rmprocset)) ? :timed_out : :ok
+    finally
+        unlock(worker_lock)
+    end
 end
 
 
@@ -425,7 +430,7 @@ function deregister_worker(pg, pid)
             if PGRP.topology != :all_to_all
                 for rpid in workers()
                     try
-                        remote_do(rpid, deregister_worker, pid)
+                        remote_do(deregister_worker, rpid, pid)
                     catch
                     end
                 end
@@ -434,7 +439,7 @@ function deregister_worker(pg, pid)
     end
     push!(map_del_wrkr, pid)
 
-    # delete this worker from our RemoteRef client sets
+    # delete this worker from our remote reference client sets
     ids = []
     tonotify = []
     for (id,rv) in pg.refs
@@ -457,25 +462,50 @@ function deregister_worker(pg, pid)
 end
 
 ## remote refs ##
-
 const client_refs = WeakKeyDict()
 
-type RemoteRef{RemoteStore}
+abstract AbstractRemoteRef
+
+type Future <: AbstractRemoteRef
+    where::Int
+    whence::Int
+    id::Int
+    v::Nullable{Any}
+
+    Future(w, wh, id) = Future(w, wh, id, Nullable{Any}())
+    Future(w, wh, id, v) = (r = new(w,wh,id,v); test_existing_ref(r))
+end
+finalize_future(f::Future) = (isnull(f.v) && send_del_client(f))
+
+type RemoteChannel{T<:AbstractChannel} <: AbstractRemoteRef
     where::Int
     whence::Int
     id::Int
-    # TODO: cache value if it's fetched, but don't serialize the cached value
 
-    function RemoteRef(w, wh, id)
-        r = new(w,wh,id)
-        found = getkey(client_refs, r, false)
-        if !is(found,false)
-            return found
+    RemoteChannel(w, wh, id) = (r = new(w,wh,id); test_existing_ref(r))
+end
+
+function test_existing_ref(r::Future)
+    found = getkey(client_refs, r, false)
+    if !is(found,false)
+        if isnull(found.v) && !isnull(r.v)
+            # we have recd the value from another source, probably a deserialized ref, send a del_client message
+            send_del_client(r)
+            found.v = r.v
         end
-        client_refs[r] = true
-        finalizer(r, send_del_client)
-        r
+        return found
     end
+    client_refs[r] = true
+    finalizer(r, finalize_future)
+    r
+end
+
+function test_existing_ref(r::RemoteChannel)
+    found = getkey(client_refs, r, false)
+    !is(found,false) && return found
+    client_refs[r] = true
+    finalizer(r, send_del_client)
+    r
 end
 
 let REF_ID::Int = 1
@@ -486,53 +516,82 @@ let REF_ID::Int = 1
     next_rrid_tuple() = (myid(),next_ref_id())
 end
 
-RemoteRef(w::LocalProcess) = RemoteRef(w.id)
-RemoteRef(w::Worker) = RemoteRef(w.id)
-function RemoteRef(pid::Integer=myid())
+Future(w::LocalProcess) = Future(w.id)
+Future(w::Worker) = Future(w.id)
+function Future(pid::Integer=myid())
     rrid = next_rrid_tuple()
-    RemoteRef{Channel{Any}}(pid, rrid[1], rrid[2])
+    Future(pid, rrid[1], rrid[2])
 end
 
-function RemoteRef(f::Function, pid::Integer=myid())
-    remotecall_fetch(pid, (f, rrid) -> begin
+function RemoteChannel(pid::Integer=myid())
+    rrid = next_rrid_tuple()
+    RemoteChannel{Channel{Any}}(pid, rrid[1], rrid[2])
+end
+function RemoteChannel(f::Function, pid::Integer=myid())
+    remotecall_fetch(pid, f, next_rrid_tuple()) do f, rrid
         rv=lookup_ref(rrid, f)
-        RemoteRef{typeof(rv.c)}(myid(), rrid[1], rrid[2])
-    end, f, next_rrid_tuple())
+        RemoteChannel{typeof(rv.c)}(myid(), rrid[1], rrid[2])
+    end
 end
 
-hash(r::RemoteRef, h::UInt) = hash(r.whence, hash(r.id, h))
-==(r::RemoteRef, s::RemoteRef) = (r.whence==s.whence && r.id==s.id)
+hash(r::AbstractRemoteRef, h::UInt) = hash(r.whence, hash(r.id, h))
+==(r::AbstractRemoteRef, s::AbstractRemoteRef) = (r.whence==s.whence && r.id==s.id)
 
-rr2id(r::RemoteRef) = (r.whence, r.id)
+remoteref_id(r::AbstractRemoteRef) = (r.whence, r.id)
+function channel_from_id(id)
+    rv = get(PGRP.refs, id, false)
+    if rv === false
+        throw(ErrorException("Local instance of remote reference not found"))
+    end
+    rv.c
+end
 
 lookup_ref(id, f=def_rv_channel) = lookup_ref(PGRP, id, f)
 function lookup_ref(pg, id, f)
     rv = get(pg.refs, id, false)
     if rv === false
         # first we've heard of this ref
-        rv = RemoteValue(f)
+        rv = RemoteValue(f())
         pg.refs[id] = rv
         push!(rv.clientset, id[1])
     end
     rv
 end
+function isready(rr::Future)
+    !isnull(rr.v) && return true
 
-function isready(rr::RemoteRef, args...)
-    rid = rr2id(rr)
+    rid = remoteref_id(rr)
+    if rr.where == myid()
+        isready(lookup_ref(rid).c)
+    else
+        remotecall_fetch(rid->isready(lookup_ref(rid).c), rr.where, rid)
+    end
+end
+
+function isready(rr::RemoteChannel, args...)
+    rid = remoteref_id(rr)
     if rr.where == myid()
         isready(lookup_ref(rid).c, args...)
     else
-        remotecall_fetch(rr.where, id->isready(lookup_ref(rid).c, args...), rid)
+        remotecall_fetch(rid->isready(lookup_ref(rid).c, args...), rr.where, rid)
     end
 end
 
 del_client(id, client) = del_client(PGRP, id, client)
 function del_client(pg, id, client)
-    rv = lookup_ref(id)
-    delete!(rv.clientset, client)
-    if isempty(rv.clientset)
-        delete!(pg.refs, id)
-        #print("$(myid()) collected $id\n")
+# As a workaround to issue https://github.com/JuliaLang/julia/issues/14445
+# the dict/set updates are executed asynchronously so that they do
+# not occur in the midst of a gc. The `@async` prefix must be removed once
+# 14445 is fixed.
+    @async begin
+        rv = get(pg.refs, id, false)
+        if rv != false
+            delete!(rv.clientset, client)
+            if isempty(rv.clientset)
+                delete!(pg.refs, id)
+                #print("$(myid()) collected $id\n")
+            end
+        end
     end
     nothing
 end
@@ -551,23 +610,18 @@ function start_gc_msgs_task()
     end
 end
 
-function send_del_client(rr::RemoteRef)
+function send_del_client(rr)
     if rr.where == myid()
-        del_client(rr2id(rr), myid())
-    else
-        if in(rr.where, map_del_wrkr)
-            # for a removed worker, don't bother
-            return
-        end
+        del_client(remoteref_id(rr), myid())
+    elseif rr.where in procs() # process only if a valid worker
         w = worker_from_id(rr.where)
-        push!(w.del_msgs, (rr2id(rr), myid()))
+        push!(w.del_msgs, (remoteref_id(rr), myid()))
         w.gcflag = true
         notify(any_gc_flag)
     end
 end
 
 function add_client(id, client)
-    #println("$(myid()) adding client $client to $id")
     rv = lookup_ref(id)
     push!(rv.clientset, client)
     nothing
@@ -575,53 +629,68 @@ end
 
 function add_clients(pairs::Vector)
     for p in pairs
-        add_client(p[1], p[2])
+        add_client(p[1], p[2]...)
     end
 end
 
-function send_add_client(rr::RemoteRef, i)
+function send_add_client(rr::AbstractRemoteRef, i)
     if rr.where == myid()
-        add_client(rr2id(rr), i)
-    elseif i != rr.where
+        add_client(remoteref_id(rr), i)
+    elseif (i != rr.where) && (rr.where in procs())
         # don't need to send add_client if the message is already going
         # to the processor that owns the remote ref. it will add_client
         # itself inside deserialize().
         w = worker_from_id(rr.where)
-        #println("$(myid()) adding $((rr2id(rr), i)) for $(rr.where)")
-        push!(w.add_msgs, (rr2id(rr), i))
+        push!(w.add_msgs, (remoteref_id(rr), i))
         w.gcflag = true
         notify(any_gc_flag)
     end
 end
 
-function serialize(s::SerializationState, rr::RemoteRef)
-    i = worker_id_from_socket(s.io)
-    #println("$(myid()) serializing $rr to $i")
-    if i != -1
-        #println("send add $rr to $i")
-        send_add_client(rr, i)
+channel_type{T}(rr::RemoteChannel{T}) = T
+
+serialize(s::SerializationState, f::Future) = serialize(s, f, isnull(f.v))
+serialize(s::SerializationState, rr::RemoteChannel) = serialize(s, rr, true)
+function serialize(s::SerializationState, rr::AbstractRemoteRef, addclient)
+    if addclient
+        p = worker_id_from_socket(s.io)
+        (p !== rr.where) && send_add_client(rr, p)
     end
     invoke(serialize, Tuple{SerializationState, Any}, s, rr)
 end
 
-function deserialize(s::SerializationState, t::Type{RemoteRef})
+function deserialize{T<:Future}(s::SerializationState, t::Type{T})
+    f = deserialize_rr(s,t)
+    Future(f.where, f.whence, f.id) # ctor adds to ref table
+end
+
+function deserialize{T<:RemoteChannel}(s::SerializationState, t::Type{T})
+    rr = deserialize_rr(s,t)
+    # call ctor to make sure this rr gets added to the client_refs table
+    RemoteChannel{channel_type(rr)}(rr.where, rr.whence, rr.id)
+end
+
+function deserialize_rr(s, t)
     rr = invoke(deserialize, Tuple{SerializationState, DataType}, s, t)
-    where = rr.where
-    if where == myid()
-        add_client(rr2id(rr), myid())
+    if rr.where == myid()
+        # send_add_client() is not executed when the ref is being
+        # serialized to where it exists
+        add_client(remoteref_id(rr), myid())
     end
-    # call ctor to make sure this rr gets added to the client_refs table
-    RemoteRef(where, rr.whence, rr.id)
+    rr
 end
 
-# data stored by the owner of a RemoteRef
+# data stored by the owner of a remote reference
 def_rv_channel() = Channel(1)
 type RemoteValue
     c::AbstractChannel
-    clientset::IntSet
+    clientset::IntSet # Set of workerids that have a reference to this channel.
+                      # Keeping ids instead of a count aids in cleaning up upon
+                      # a worker exit.
+
     waitingfor::Int   # processor we need to hear from to fill this, or 0
 
-    RemoteValue(f::Function) = new(f(), IntSet(), 0)
+    RemoteValue(c) = new(c, IntSet(), 0)
 end
 
 wait(rv::RemoteValue) = wait(rv.c)
@@ -646,7 +715,7 @@ function run_work_thunk(thunk, print_error)
     catch err
         ce = CapturedException(err, catch_backtrace())
         result = RemoteException(ce)
-        print_error && print(STDERR, ce)
+        print_error && showerror(STDERR, ce)
     end
     result
 end
@@ -656,7 +725,7 @@ function run_work_thunk(rv::RemoteValue, thunk)
 end
 
 function schedule_call(rid, thunk)
-    rv = RemoteValue(def_rv_channel)
+    rv = RemoteValue(def_rv_channel())
     (PGRP::ProcessGroup).refs[rid] = rv
     push!(rv.clientset, rid[1])
     schedule(@task(run_work_thunk(rv,thunk)))
@@ -665,7 +734,7 @@ end
 
 #localize_ref(b::Box) = Box(localize_ref(b.contents))
 
-#function localize_ref(r::RemoteRef)
+#function localize_ref(r::RemoteChannel)
 #    if r.where == myid()
 #        fetch(r)
 #    else
@@ -686,7 +755,7 @@ function local_remotecall_thunk(f, args)
     # TODO: this seems to be capable of causing deadlocks by waiting on
     # Refs buried inside the closure that we don't want to wait on yet.
     # linfo = ccall(:jl_closure_linfo, Any, (Any,), f)
-    # if isa(linfo,LambdaStaticData)
+    # if isa(linfo,LambdaInfo)
     #     env = ccall(:jl_closure_env, Any, (Any,), f)
     #     buf = memio()
     #     serialize(buf, env)
@@ -698,28 +767,28 @@ function local_remotecall_thunk(f, args)
     # f(map(localize_ref,args)...)
 end
 
-function remotecall(w::LocalProcess, f, args...)
-    rr = RemoteRef(w)
-    schedule_call(rr2id(rr), local_remotecall_thunk(f,args))
+function remotecall(f, w::LocalProcess, args...)
+    rr = Future(w)
+    schedule_call(remoteref_id(rr), local_remotecall_thunk(f,args))
     rr
 end
 
-function remotecall(w::Worker, f, args...)
-    rr = RemoteRef(w)
+function remotecall(f, w::Worker, args...)
+    rr = Future(w)
     #println("$(myid()) asking for $rr")
-    send_msg(w, CallMsg{:call}(f, args, rr2id(rr)))
+    send_msg(w, CallMsg{:call}(f, args, remoteref_id(rr)))
     rr
 end
 
-remotecall(id::Integer, f, args...) = remotecall(worker_from_id(id), f, args...)
+remotecall(f, id::Integer, args...) = remotecall(f, worker_from_id(id), args...)
 
 # faster version of fetch(remotecall(...))
-function remotecall_fetch(w::LocalProcess, f, args...)
+function remotecall_fetch(f, w::LocalProcess, args...)
     v=run_work_thunk(local_remotecall_thunk(f,args), false)
     isa(v, RemoteException) ? throw(v) : v
 end
 
-function remotecall_fetch(w::Worker, f, args...)
+function remotecall_fetch(f, w::Worker, args...)
     # can be weak, because the program will have no way to refer to the Ref
     # itself, it only gets the result.
     oid = next_rrid_tuple()
@@ -731,27 +800,28 @@ function remotecall_fetch(w::Worker, f, args...)
     isa(v, RemoteException) ? throw(v) : v
 end
 
-remotecall_fetch(id::Integer, f, args...) =
-    remotecall_fetch(worker_from_id(id), f, args...)
+remotecall_fetch(f, id::Integer, args...) =
+    remotecall_fetch(f, worker_from_id(id), args...)
 
 # faster version of wait(remotecall(...))
-remotecall_wait(w::LocalProcess, f, args...) = wait(remotecall(w,f,args...))
+remotecall_wait(f, w::LocalProcess, args...) = wait(remotecall(f, w, args...))
 
-function remotecall_wait(w::Worker, f, args...)
+function remotecall_wait(f, w::Worker, args...)
     prid = next_rrid_tuple()
     rv = lookup_ref(prid)
     rv.waitingfor = w.id
-    rr = RemoteRef(w)
-    send_msg(w, CallWaitMsg(f, args, rr2id(rr), prid))
-    wait(rv)
+    rr = Future(w)
+    send_msg(w, CallWaitMsg(f, args, remoteref_id(rr), prid))
+    v = fetch(rv.c)
     delete!(PGRP.refs, prid)
+    isa(v, RemoteException) && throw(v)
     rr
 end
 
-remotecall_wait(id::Integer, f, args...) =
-    remotecall_wait(worker_from_id(id), f, args...)
+remotecall_wait(f, id::Integer, args...) =
+    remotecall_wait(f, worker_from_id(id), args...)
 
-function remote_do(w::LocalProcess, f, args...)
+function remote_do(f, w::LocalProcess, args...)
     # the LocalProcess version just performs in local memory what a worker
     # does when it gets a :do message.
     # same for other messages on LocalProcess.
@@ -760,49 +830,97 @@ function remote_do(w::LocalProcess, f, args...)
     nothing
 end
 
-function remote_do(w::Worker, f, args...)
+function remote_do(f, w::Worker, args...)
     send_msg(w, RemoteDoMsg(f, args))
     nothing
 end
 
-remote_do(id::Integer, f, args...) = remote_do(worker_from_id(id), f, args...)
+remote_do(f, id::Integer, args...) = remote_do(f, worker_from_id(id), args...)
 
 # have the owner of rr call f on it
-function call_on_owner(f, rr::RemoteRef, args...)
-    rid = rr2id(rr)
+function call_on_owner(f, rr::AbstractRemoteRef, args...)
+    rid = remoteref_id(rr)
     if rr.where == myid()
         f(rid, args...)
     else
-        remotecall_fetch(rr.where, f, rid, args...)
+        remotecall_fetch(f, rr.where, rid, args...)
+    end
+end
+
+function wait_ref(rid, callee, args...)
+    v = fetch_ref(rid, args...)
+    if isa(v, RemoteException)
+        if myid() == callee
+            throw(v)
+        else
+            return v
+        end
     end
+    nothing
 end
+wait(r::Future) = (!isnull(r.v) && return r; call_on_owner(wait_ref, r, myid()); r)
+wait(r::RemoteChannel, args...) = (call_on_owner(wait_ref, r, myid(), args...); r)
 
-wait_ref(rid, args...) = (wait(lookup_ref(rid).c, args...); nothing)
-wait(r::RemoteRef, args...) = (call_on_owner(wait_ref, r, args...); r)
+function fetch_future(rid, callee)
+    rv = lookup_ref(rid);
+    v = fetch(rv.c)
+    del_client(rid, callee)
+    v
+end
+function fetch(r::Future)
+    !isnull(r.v) && return get(r.v)
+    v=call_on_owner(fetch_future, r, myid())
+    r.v=v
+    v
+end
 
 fetch_ref(rid, args...) = fetch(lookup_ref(rid).c, args...)
-fetch(r::RemoteRef, args...) = call_on_owner(fetch_ref, r, args...)
+fetch(r::RemoteChannel, args...) = call_on_owner(fetch_ref, r, args...)
 fetch(x::ANY) = x
 
-# storing a value to a RemoteRef
+isready(rv::RemoteValue, args...) = isready(rv.c, args...)
+function put!(rr::Future, v)
+    !isnull(rr.v) && error("Future can be set only once")
+    call_on_owner(put_future, rr, v, myid())
+    rr.v = v
+    rr
+end
+function put_future(rid, v, callee)
+    rv = lookup_ref(rid)
+    isready(rv) && error("Future can be set only once")
+    put!(rv, v)
+    # The callee has the value and hence can be removed from the remote store.
+    del_client(rid, callee)
+    nothing
+end
+
+
 put!(rv::RemoteValue, args...) = put!(rv.c, args...)
-put_ref(rid, args...) = put!(lookup_ref(rid), args...)
-put!(rr::RemoteRef, args...) = (call_on_owner(put_ref, rr, args...); rr)
+put_ref(rid, args...) = (put!(lookup_ref(rid), args...); nothing)
+put!(rr::RemoteChannel, args...) = (call_on_owner(put_ref, rr, args...); rr)
+
+# take! is not supported on Future
 
 take!(rv::RemoteValue, args...) = take!(rv.c, args...)
-take_ref(rid, args...) = take!(lookup_ref(rid), args...)
-take!(rr::RemoteRef, args...) = call_on_owner(take_ref, rr, args...)
+function take_ref(rid, callee, args...)
+    v=take!(lookup_ref(rid), args...)
+    isa(v, RemoteException) && (myid() == callee) && throw(v)
+    v
+end
+take!(rr::RemoteChannel, args...) = call_on_owner(take_ref, rr, myid(), args...)
+
+# close is not supported on Future
 
 close_ref(rid) = (close(lookup_ref(rid).c); nothing)
-close(rr::RemoteRef) = call_on_owner(close_ref, rr)
+close(rr::RemoteChannel) = call_on_owner(close_ref, rr)
 
 
 function deliver_result(sock::IO, msg, oid, value)
     #print("$(myid()) sending result $oid\n")
-    if is(msg,:call_fetch)
+    if is(msg,:call_fetch) || isa(value, RemoteException)
         val = value
     else
-        val = oid
+        val = :OK
     end
     try
         send_msg_now(sock, ResultMsg(oid, val))
@@ -818,7 +936,7 @@ function deliver_result(sock::IO, msg, oid, value)
         elseif wid == 1
             exit(1)
         else
-            remote_do(1, rmprocs, wid)
+            remote_do(rmprocs, 1, wid)
         end
     end
 end
@@ -836,9 +954,9 @@ function process_tcp_streams(r_stream::TCPSocket, w_stream::TCPSocket)
         message_handler_loop(r_stream, w_stream)
 end
 
-process_messages(r_stream::AsyncStream, w_stream::AsyncStream) = @schedule message_handler_loop(r_stream, w_stream)
+process_messages(r_stream::IO, w_stream::IO) = @schedule message_handler_loop(r_stream, w_stream)
 
-function message_handler_loop(r_stream::AsyncStream, w_stream::AsyncStream)
+function message_handler_loop(r_stream::IO, w_stream::IO)
     global PGRP
     global cluster_manager
 
@@ -897,7 +1015,7 @@ end
 function handle_msg(msg::CallWaitMsg, r_stream, w_stream)
     @schedule begin
         rv = schedule_call(msg.response_oid, ()->msg.f(msg.args...))
-        deliver_result(w_stream, :call_wait, msg.notify_oid, wait(rv))
+        deliver_result(w_stream, :call_wait, msg.notify_oid, fetch(rv.c))
     end
 end
 
@@ -1060,7 +1178,7 @@ function init_worker(manager::ClusterManager=DefaultClusterManager())
     cluster_manager = manager
     disable_threaded_libs()
 
-    # Since our pid has yet to be set, ensure no RemoteRefs have been created or addprocs() called.
+    # Since our pid has yet to be set, ensure no RemoteChannel / Future  have been created or addprocs() called.
     assert(nprocs() <= 1)
     assert(isempty(PGRP.refs))
     assert(isempty(client_refs))
@@ -1075,7 +1193,20 @@ end
 # `manager` is of type ClusterManager. The respective managers are responsible
 # for launching the workers. All keyword arguments (plus a few default values)
 # are available as a dictionary to the `launch` methods
+#
+# Only one addprocs can be in progress at any time
+#
+const worker_lock = ReentrantLock()
 function addprocs(manager::ClusterManager; kwargs...)
+    lock(worker_lock)
+    try
+        addprocs_locked(manager::ClusterManager; kwargs...)
+    finally
+        unlock(worker_lock)
+    end
+end
+
+function addprocs_locked(manager::ClusterManager; kwargs...)
 
     params = merge(default_addprocs_params(), AnyDict(kwargs))
     topology(symbol(params[:topology]))
@@ -1102,13 +1233,13 @@ function addprocs(manager::ClusterManager; kwargs...)
 
     @sync begin
         while true
-            if length(launched) == 0
+            if isempty(launched)
                 istaskdone(t_launch) && break
                 @schedule (sleep(1); notify(launch_ntfy))
                 wait(launch_ntfy)
             end
 
-            if (length(launched) > 0)
+            if !isempty(launched)
                 wconfig = shift!(launched)
                 let wconfig=wconfig
                     @async setup_launched_worker(manager, wconfig, launched_q)
@@ -1125,7 +1256,7 @@ function addprocs(manager::ClusterManager; kwargs...)
     # function returns to the caller.
     all_w = workers()
     for pid in all_w
-        remote_do(pid, set_valid_processes, all_w)
+        remote_do(set_valid_processes, pid, all_w)
     end
 
     sort!(launched_q)
@@ -1169,7 +1300,7 @@ function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launch
         exeflags = get(fromconfig.exeflags, ``)
         cmd = `$exename $exeflags`
 
-        new_addresses = remotecall_fetch(frompid, launch_additional, cnt, cmd)
+        new_addresses = remotecall_fetch(launch_additional, frompid, cnt, cmd)
         for address in new_addresses
             (bind_addr, port) = address
 
@@ -1183,7 +1314,7 @@ function launch_n_additional_processes(manager, frompid, fromconfig, cnt, launch
             let wconfig=wconfig
                 @async begin
                     pid = create_worker(manager, wconfig)
-                    remote_do(frompid, redirect_output_from_additional_worker, pid, port)
+                    remote_do(redirect_output_from_additional_worker, frompid, pid, port)
                     push!(launched_q, pid)
                 end
             end
@@ -1272,7 +1403,7 @@ function launch_additional(np::Integer, cmd::Cmd)
     addresses = cell(np)
 
     for i in 1:np
-        io, pobj = open(detach(cmd), "r")
+        io, pobj = open(pipeline(detach(cmd), stderr=STDERR), "r")
         io_objs[i] = io
     end
 
@@ -1298,17 +1429,18 @@ let nextidx = 0
     global chooseproc
     function chooseproc(thunk::Function)
         p = -1
-        env = thunk.env
-        if isa(env,Tuple)
-            for v in env
-                if isa(v,Box)
-                    v = v.contents
-                end
-                if isa(v,RemoteRef)
-                    p = v.where; break
-                end
-            end
-        end
+        # TODO jb/functions
+        #env = thunk.env
+        #if isa(env,Tuple)
+        #    for v in env
+        #        if isa(v,Box)
+        #            v = v.contents
+        #        end
+        #        if isa(v,AbstractRemoteRef)
+        #            p = v.where; break
+        #        end
+        #    end
+        #end
         if p == -1
             p = workers()[(nextidx % nworkers()) + 1]
             nextidx += 1
@@ -1317,31 +1449,31 @@ let nextidx = 0
     end
 end
 
-spawnat(p, thunk) = sync_add(remotecall(p, thunk))
+spawnat(p, thunk) = sync_add(remotecall(thunk, p))
 
 spawn_somewhere(thunk) = spawnat(chooseproc(thunk),thunk)
 
 macro spawn(expr)
-    expr = localize_vars(:(()->($expr)), false)
-    :(spawn_somewhere($(esc(expr))))
+    expr = localize_vars(esc(:(()->($expr))), false)
+    :(spawn_somewhere($expr))
 end
 
 macro spawnat(p, expr)
-    expr = localize_vars(:(()->($expr)), false)
-    :(spawnat($(esc(p)), $(esc(expr))))
+    expr = localize_vars(esc(:(()->($expr))), false)
+    :(spawnat($(esc(p)), $expr))
 end
 
 macro fetch(expr)
-    expr = localize_vars(:(()->($expr)), false)
+    expr = localize_vars(esc(:(()->($expr))), false)
     quote
-        thunk = $(esc(expr))
-        remotecall_fetch(chooseproc(thunk), thunk)
+        thunk = $expr
+        remotecall_fetch(thunk, chooseproc(thunk))
     end
 end
 
 macro fetchfrom(p, expr)
-    expr = localize_vars(:(()->($expr)), false)
-    :(remotecall_fetch($(esc(p)), $(esc(expr))))
+    expr = localize_vars(esc(:(()->($expr))), false)
+    :(remotecall_fetch($expr, $(esc(p))))
 end
 
 macro everywhere(ex)
@@ -1349,7 +1481,7 @@ macro everywhere(ex)
         sync_begin()
         thunk = ()->(eval(Main,$(Expr(:quote,ex))); nothing)
         for pid in workers()
-            async_run_thunk(()->remotecall_fetch(pid, thunk))
+            async_run_thunk(()->remotecall_fetch(thunk, pid))
             yield() # ensure that the remotecall_fetch has been started
         end
 
@@ -1365,7 +1497,7 @@ end
 function pmap_static(f, lsts...)
     np = nprocs()
     n = length(lsts[1])
-    Any[ remotecall(PGRP.workers[(i-1)%np+1].id, f, map(L->L[i], lsts)...) for i = 1:n ]
+    Any[ remotecall(f, PGRP.workers[(i-1)%np+1].id, map(L->L[i], lsts)...) for i = 1:n ]
 end
 
 pmap(f) = f()
@@ -1427,7 +1559,7 @@ function pmap(f, lsts...; err_retry=true, err_stop=false, pids = workers())
                     (idx, fvals) = tasklet
                     busy_workers[pididx] = true
                     try
-                        results[idx] = remotecall_fetch(wpid, f, fvals...)
+                        results[idx] = remotecall_fetch(f, wpid, fvals...)
                     catch ex
                         if err_retry
                             push!(retryqueue, (idx,fvals, ex))
@@ -1476,31 +1608,32 @@ function splitrange(N::Int, np::Int)
     return chunks
 end
 
-function preduce(reducer, f, N::Int)
+function preduce(reducer, f, R)
+    N = length(R)
     chunks = splitrange(N, nworkers())
     all_w = workers()[1:length(chunks)]
 
     w_exec = Task[]
     for (idx,pid) in enumerate(all_w)
-        t = Task(()->remotecall_fetch(pid, f, first(chunks[idx]), last(chunks[idx])))
+        t = Task(()->remotecall_fetch(f, pid, reducer, R, first(chunks[idx]), last(chunks[idx])))
         schedule(t)
         push!(w_exec, t)
     end
     reduce(reducer, [wait(t) for t in w_exec])
 end
 
-function pfor(f, N::Int)
-    [@spawn f(first(c), last(c)) for c in splitrange(N, nworkers())]
+function pfor(f, R)
+    [@spawn f(R, first(c), last(c)) for c in splitrange(length(R), nworkers())]
 end
 
-function make_preduce_body(reducer, var, body, R)
+function make_preduce_body(var, body)
     quote
-        function (lo::Int, hi::Int)
-            $(esc(var)) = ($R)[lo]
+        function (reducer, R, lo::Int, hi::Int)
+            $(esc(var)) = R[lo]
             ac = $(esc(body))
             if lo != hi
-                for $(esc(var)) in ($R)[(lo+1):hi]
-                    ac = ($(esc(reducer)))(ac, $(esc(body)))
+                for $(esc(var)) in R[(lo+1):hi]
+                    ac = reducer(ac, $(esc(body)))
                 end
             end
             ac
@@ -1508,10 +1641,10 @@ function make_preduce_body(reducer, var, body, R)
     end
 end
 
-function make_pfor_body(var, body, R)
+function make_pfor_body(var, body)
     quote
-        function (lo::Int, hi::Int)
-            for $(esc(var)) in ($R)[lo:hi]
+        function (R, lo::Int, hi::Int)
+            for $(esc(var)) in R[lo:hi]
                 $(esc(body))
             end
         end
@@ -1535,12 +1668,11 @@ macro parallel(args...)
     r = loop.args[1].args[2]
     body = loop.args[2]
     if na==1
-        thecall = :(pfor($(make_pfor_body(var, body, :therange)), length(therange)))
+        thecall = :(pfor($(make_pfor_body(var, body)), $(esc(r))))
     else
-        thecall = :(preduce($(esc(reducer)),
-                            $(make_preduce_body(reducer, var, body, :therange)), length(therange)))
+        thecall = :(preduce($(esc(reducer)), $(make_preduce_body(var, body)), $(esc(r))))
     end
-    localize_vars(quote therange = $(esc(r)); $thecall; end)
+    localize_vars(thecall)
 end
 
 
@@ -1568,7 +1700,7 @@ end
 function timedwait(testcb::Function, secs::Float64; pollint::Float64=0.1)
     pollint > 0 || throw(ArgumentError("cannot set pollint to $pollint seconds"))
     start = time()
-    done = RemoteRef()
+    done = Channel(1)
     timercb(aw) = begin
         try
             if testcb()
@@ -1625,7 +1757,7 @@ end
 
 function check_same_host(pids)
     if myid() != 1
-        return remotecall_fetch(1, check_same_host, pids)
+        return remotecall_fetch(check_same_host, 1, pids)
     else
         # We checkfirst if all test pids have been started using the local manager,
         # else we check for the same bind_to addr. This handles the special case
@@ -1658,10 +1790,14 @@ function terminate_all_workers()
     end
 end
 
-getindex(r::RemoteRef) = fetch(r)
-function getindex(r::RemoteRef, args...)
+getindex(r::RemoteChannel) = fetch(r)
+getindex(r::Future) = fetch(r)
+
+getindex(r::Future, args...) = getindex(fetch(r), args...)
+function getindex(r::RemoteChannel, args...)
     if r.where == myid()
         return getindex(fetch(r), args...)
     end
-    return remotecall_fetch(r.where, getindex, r, args...)
+    return remotecall_fetch(getindex, r.where, r, args...)
 end
+
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 9b127007a0772..7ba32048f70b6 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -6,7 +6,7 @@ module IteratorsMD
 import Base: eltype, length, start, done, next, last, getindex, setindex!, linearindexing, min, max, eachindex, ndims
 importall ..Base.Operators
 import Base: simd_outer_range, simd_inner_length, simd_index, @generated
-import Base: @nref, @ncall, @nif, @nexprs, LinearFast, LinearSlow, to_index
+import Base: @nref, @ncall, @nif, @nexprs, LinearFast, LinearSlow, to_index, AbstractCartesianIndex
 
 export CartesianIndex, CartesianRange
 
@@ -14,19 +14,34 @@ export CartesianIndex, CartesianRange
 linearindexing{A<:BitArray}(::Type{A}) = LinearFast()
 
 # CartesianIndex
-immutable CartesianIndex{N}
+immutable CartesianIndex{N} <: AbstractCartesianIndex{N}
     I::NTuple{N,Int}
     CartesianIndex(index::NTuple{N,Integer}) = new(index)
 end
 
 CartesianIndex{N}(index::NTuple{N,Integer}) = CartesianIndex{N}(index)
-@generated function Base.call{N}(::Type{CartesianIndex{N}},index::Integer...)
-    length(index) == N && return :(CartesianIndex(index))
-    length(index) > N && throw(DimensionMismatch("Cannot create CartesianIndex{$N} from $(length(index)) indexes"))
-    args = [i <= length(index) ? :(index[$i]) : 1 for i = 1:N]
+(::Type{CartesianIndex})(index::Integer...) = CartesianIndex(index)
+(::Type{CartesianIndex{N}}){N}(index::Integer...) = CartesianIndex{N}(index)
+# Allow passing tuples smaller than N
+@generated function (::Type{CartesianIndex{N}}){N,M}(index::NTuple{M,Integer})
+    M == N && return :(CartesianIndex(index))
+    M > N && return :(throw(DimensionMismatch("Cannot create CartesianIndex{$N} from $M indexes")))
+    args = [i <= M ? :(index[$i]) : 1 for i = 1:N]
     :(CartesianIndex(tuple($(args...))))
 end
-Base.call{M,N}(::Type{CartesianIndex{N}},index::NTuple{M,Integer}) = CartesianIndex{N}(index...)
+# Un-nest passed CartesianIndexes
+CartesianIndex(index::Union{Integer, CartesianIndex}...) = CartesianIndex(index)
+@generated function CartesianIndex{N}(index::NTuple{N, Union{Integer, CartesianIndex}})
+    ex = Expr(:tuple)
+    for (i, T) in enumerate(index.parameters)
+        if T <: Integer
+            push!(ex.args, :(index[$i]))
+        else
+            push!(ex.args, Expr(:..., :(index[$i].I)))
+        end
+    end
+    :($(Expr(:meta, :inline)); CartesianIndex($ex))
+end
 
 # length
 length{N}(::CartesianIndex{N})=N
@@ -161,10 +176,12 @@ index_lengths_dim(A, dim) = ()
 index_lengths_dim(A, dim, ::Colon) = (trailingsize(A, dim),)
 @inline index_lengths_dim(A, dim, ::Colon, i, I...) = (size(A, dim), index_lengths_dim(A, dim+1, i, I...)...)
 @inline index_lengths_dim(A, dim, ::Real, I...) = (1, index_lengths_dim(A, dim+1, I...)...)
+@inline index_lengths_dim{N}(A, dim, ::CartesianIndex{N}, I...) = (1, index_shape_dim(A, dim+N, I...)...)
 @inline index_lengths_dim(A, dim, i::AbstractArray{Bool}, I...) = (sum(i), index_lengths_dim(A, dim+1, I...)...)
 @inline index_lengths_dim(A, dim, i::AbstractArray, I...) = (length(i), index_lengths_dim(A, dim+1, I...)...)
+@inline index_lengths_dim{N}(A, dim, i::AbstractArray{CartesianIndex{N}}, I...) = (length(i), index_lengths_dim(A, dim+N, I...)...)
 
-# shape of array to create for getindex() with indexes I, dropping trailing scalars
+# shape of array to create for getindex() with indexes I, dropping scalars
 index_shape(A::AbstractArray, I::AbstractArray) = size(I) # Linear index reshape
 index_shape(A::AbstractArray, I::AbstractArray{Bool}) = (sum(I),) # Logical index
 index_shape(A::AbstractArray, I::Colon) = (length(A),)
@@ -172,27 +189,29 @@ index_shape(A::AbstractArray, I::Colon) = (length(A),)
 index_shape_dim(A, dim, I::Real...) = ()
 index_shape_dim(A, dim, ::Colon) = (trailingsize(A, dim),)
 @inline index_shape_dim(A, dim, ::Colon, i, I...) = (size(A, dim), index_shape_dim(A, dim+1, i, I...)...)
-@inline index_shape_dim(A, dim, ::Real, I...) = (1, index_shape_dim(A, dim+1, I...)...)
+@inline index_shape_dim(A, dim, ::Real, I...) = (index_shape_dim(A, dim+1, I...)...)
+@inline index_shape_dim{N}(A, dim, ::CartesianIndex{N}, I...) = (index_shape_dim(A, dim+N, I...)...)
 @inline index_shape_dim(A, dim, i::AbstractVector{Bool}, I...) = (sum(i), index_shape_dim(A, dim+1, I...)...)
 @inline index_shape_dim(A, dim, i::AbstractVector, I...) = (length(i), index_shape_dim(A, dim+1, I...)...)
+@inline index_shape_dim{N}(A, dim, i::AbstractVector{CartesianIndex{N}}, I...) = (length(i), index_shape_dim(A, dim+N, I...)...)
 
 ### From abstractarray.jl: Internal multidimensional indexing definitions ###
-# These are not defined on directly ongetindex and unsafe_getindex to avoid
+# These are not defined on directly on getindex to avoid
 # ambiguities for AbstractArray subtypes. See the note in abstractarray.jl
 
 # Note that it's most efficient to call checkbounds first, and then to_index
 @inline function _getindex(l::LinearIndexing, A::AbstractArray, I::Union{Real, AbstractArray, Colon}...)
-    checkbounds(A, I...)
+    @boundscheck checkbounds(A, I...)
     _unsafe_getindex(l, A, I...)
 end
-@generated function _unsafe_getindex(l::LinearIndexing, A::AbstractArray, I::Union{Real, AbstractArray, Colon}...)
+@generated function _unsafe_getindex(::LinearIndexing, A::AbstractArray, I::Union{Real, AbstractArray, Colon}...)
     N = length(I)
     quote
         # This is specifically *not* inlined.
         @nexprs $N d->(I_d = to_index(I[d]))
         dest = similar(A, @ncall $N index_shape A I)
         @ncall $N checksize dest I
-        @ncall $N _unsafe_getindex! dest l A I
+        @ncall $N _unsafe_getindex! dest A I
     end
 end
 
@@ -209,9 +228,10 @@ function _unsafe_getindex(::LinearIndexing, src::AbstractArray, I::AbstractArray
     s = 0
     for b in eachindex(I)
         s+=1
-        if unsafe_getindex(I, b)
+        @inbounds Ib = I[b]
+        if Ib
             d, Ds = next(D, Ds)
-            unsafe_setindex!(dest, unsafe_getindex(src, s), d)
+            @inbounds dest[d] = src[s]
         end
     end
     dest
@@ -219,66 +239,52 @@ end
 
 # Indexing with an array of indices is inherently linear in the source, but
 # might be able to be optimized with fast dividing integers
-@inline function _unsafe_getindex!(dest::AbstractArray, ::LinearIndexing, src::AbstractArray, I::AbstractArray)
+@inline function _unsafe_getindex!(dest::AbstractArray, src::AbstractArray, I::AbstractArray)
     D = eachindex(dest)
     Ds = start(D)
     for idx in I
         d, Ds = next(D, Ds)
-        unsafe_setindex!(dest, unsafe_getindex(src, idx), d)
+        @inbounds dest[d] = src[idx]
     end
     dest
 end
 
-# Fast source - compute the linear index
-@generated function _unsafe_getindex!(dest::AbstractArray, ::LinearFast, src::AbstractArray, I::Union{Real, AbstractVector, Colon}...)
+# Always index with the exactly indices provided.
+@generated function _unsafe_getindex!(dest::AbstractArray, src::AbstractArray, I::Union{Real, AbstractVector, Colon}...)
     N = length(I)
     quote
         $(Expr(:meta, :inline))
-        stride_1 = 1
-        @nexprs $N d->(stride_{d+1} = stride_d*size(src, d))
-        $(symbol(:offset_, N)) = 1
         D = eachindex(dest)
         Ds = start(D)
-        @nloops $N i dest d->(offset_{d-1} = offset_d + (unsafe_getindex(I[d], i_d)-1)*stride_d) begin
+        idxlens = index_lengths(src, I...) # TODO: unsplat?
+        @nloops $N i d->(1:idxlens[d]) d->(@inbounds j_d = getindex(I[d], i_d)) begin
             d, Ds = next(D, Ds)
-            unsafe_setindex!(dest, unsafe_getindex(src, offset_0), d)
-        end
-        dest
-    end
-end
-# Slow source - index with the indices provided.
-# TODO: this may not be the full dimensionality; that case could be optimized
-@generated function _unsafe_getindex!(dest::AbstractArray, ::LinearSlow, src::AbstractArray, I::Union{Real, AbstractVector, Colon}...)
-    N = length(I)
-    quote
-        $(Expr(:meta, :inline))
-        D = eachindex(dest)
-        Ds = start(D)
-        @nloops $N i dest d->(j_d = unsafe_getindex(I[d], i_d)) begin
-            d, Ds = next(D, Ds)
-            v = @ncall $N unsafe_getindex src j
-            unsafe_setindex!(dest, v, d)
+            @inbounds dest[d] = @ncall $N getindex src j
         end
         dest
     end
 end
 
 # checksize ensures the output array A is the correct size for the given indices
-checksize(A::AbstractArray, I::AbstractArray) = size(A) == size(I) || throw(DimensionMismatch("index 1 has size $(size(I)), but size(A) = $(size(A))"))
-checksize(A::AbstractArray, I::AbstractArray{Bool}) = length(A) == sum(I) || throw(DimensionMismatch("index 1 selects $(sum(I)) elements, but length(A) = $(length(A))"))
-@generated function checksize(A::AbstractArray, I...)
-    N = length(I)
-    quote
-        @nexprs $N d->(_checksize(A, d, I[d]) || throw(DimensionMismatch("index $d selects $(length(I[d])) elements, but size(A, $d) = $(size(A,d))")))
-    end
-end
-_checksize(A::AbstractArray, dim, I) = size(A, dim) == length(I)
-_checksize(A::AbstractArray, dim, I::AbstractVector{Bool}) = size(A, dim) == sum(I)
-_checksize(A::AbstractArray, dim, ::Colon) = true
-_checksize(A::AbstractArray, dim, ::Real) = size(A, dim) == 1
+@noinline throw_checksize_error(A, dim, idx) = throw(DimensionMismatch("index $dim selects $(length(idx)) elements, but size(A, $dim) = $(size(A,dim))"))
+@noinline throw_checksize_error(A, dim, idx::AbstractArray{Bool}) = throw(DimensionMismatch("index $dim selects $(sum(idx)) elements, but size(A, $dim) = $(size(A,dim))"))
 
-@inline unsafe_setindex!(v::BitArray, x::Bool, ind::Int) = (Base.unsafe_bitsetindex!(v.chunks, x, ind); v)
-@inline unsafe_setindex!(v::BitArray, x, ind::Real) = (Base.unsafe_bitsetindex!(v.chunks, convert(Bool, x), to_index(ind)); v)
+checksize(A::AbstractArray, I::AbstractArray) = size(A) == size(I) || throw_checksize_error(A, 1, I)
+checksize(A::AbstractArray, I::AbstractArray{Bool}) = length(A) == sum(I) || throw_checksize_error(A, 1, I)
+
+@inline checksize(A::AbstractArray, I...) = _checksize(A, 1, I...)
+_checksize(A::AbstractArray, dim) = true
+# Drop dimensions indexed by scalars, ignore colons
+@inline _checksize(A::AbstractArray, dim, ::Real, J...) = _checksize(A, dim, J...)
+@inline _checksize(A::AbstractArray, dim, ::Colon, J...) = _checksize(A, dim+1, J...)
+@inline function _checksize(A::AbstractArray, dim, I, J...)
+    size(A, dim) == length(I) || throw_checksize_error(A, dim, I)
+    _checksize(A, dim+1, J...)
+end
+@inline function _checksize(A::AbstractArray, dim, I::AbstractVector{Bool}, J...)
+    size(A, dim) == sum(I) || throw_checksize_error(A, dim, I)
+    _checksize(A, dim+1, J...)
+end
 
 ## setindex! ##
 # For multi-element setindex!, we check bounds, convert the indices (to_index),
@@ -287,11 +293,11 @@ _checksize(A::AbstractArray, dim, ::Real) = size(A, dim) == 1
 _iterable(v::AbstractArray) = v
 _iterable(v) = repeated(v)
 @inline function _setindex!(l::LinearIndexing, A::AbstractArray, x, J::Union{Real,AbstractArray,Colon}...)
-    checkbounds(A, J...)
+    @boundscheck checkbounds(A, J...)
     _unsafe_setindex!(l, A, x, J...)
 end
-@inline function _unsafe_setindex!(l::LinearIndexing, A::AbstractArray, x, J::Union{Real,AbstractArray,Colon}...)
-    _unsafe_batchsetindex!(l, A, _iterable(x), to_indexes(J...)...)
+@inline function _unsafe_setindex!(::LinearIndexing, A::AbstractArray, x, J::Union{Real,AbstractArray,Colon}...)
+    _unsafe_batchsetindex!(A, _iterable(x), to_indexes(J...)...)
 end
 
 # 1-d logical indexing: override the above to avoid calling find (in to_index)
@@ -302,10 +308,11 @@ function _unsafe_setindex!(::LinearIndexing, A::AbstractArray, x, I::AbstractArr
     c = 0
     for b in eachindex(I)
         i+=1
-        if unsafe_getindex(I, b)
+        @inbounds Ib = I[b]
+        if Ib
             done(X, Xs) && throw_setindex_mismatch(x, c+1)
             (v, Xs) = next(X, Xs)
-            unsafe_setindex!(A, v, i)
+            @inbounds A[i] = v
             c += 1
         end
     end
@@ -313,34 +320,16 @@ function _unsafe_setindex!(::LinearIndexing, A::AbstractArray, x, I::AbstractArr
     A
 end
 
-# Use iteration over X so we don't need to worry about its storage
-@generated function _unsafe_batchsetindex!(::LinearFast, A::AbstractArray, X, I::Union{Real,AbstractArray,Colon}...)
-    N = length(I)
-    quote
-        @nexprs $N d->(I_d = I[d])
-        idxlens = @ncall $N index_lengths A I
-        @ncall $N setindex_shape_check X (d->idxlens[d])
-        Xs = start(X)
-        stride_1 = 1
-        @nexprs $N d->(stride_{d+1} = stride_d*size(A,d))
-        $(symbol(:offset_, N)) = 1
-        @nloops $N i d->(1:idxlens[d]) d->(offset_{d-1} = offset_d + (unsafe_getindex(I_d, i_d)-1)*stride_d) begin
-            v, Xs = next(X, Xs)
-            unsafe_setindex!(A, v, offset_0)
-        end
-        A
-    end
-end
-@generated function _unsafe_batchsetindex!(::LinearSlow, A::AbstractArray, X, I::Union{Real,AbstractArray,Colon}...)
+@generated function _unsafe_batchsetindex!(A::AbstractArray, X, I::Union{Real,AbstractArray,Colon}...)
     N = length(I)
     quote
         @nexprs $N d->(I_d = I[d])
         idxlens = @ncall $N index_lengths A I
         @ncall $N setindex_shape_check X (d->idxlens[d])
         Xs = start(X)
-        @nloops $N i d->(1:idxlens[d]) d->(j_d = unsafe_getindex(I_d, i_d)) begin
+        @nloops $N i d->(1:idxlens[d]) d->(@inbounds j_d = I_d[i_d]) begin
             v, Xs = next(X, Xs)
-            @ncall $N unsafe_setindex! A v j
+            @inbounds @ncall $N setindex! A v j
         end
         A
     end
@@ -364,16 +353,10 @@ function cartindex_exprs(indexes, syms)
     exprs
 end
 @generated function _getindex{T,N}(l::LinearIndexing, A::AbstractArray{T,N}, I::Union{Real,AbstractArray,Colon,CartesianIndex}...)
-    :($(Expr(:meta, :inline)); getindex(A, $(cartindex_exprs(I, :I)...)))
-end
-@generated function _unsafe_getindex{T,N}(l::LinearIndexing, A::AbstractArray{T,N}, I::Union{Real,AbstractArray,Colon,CartesianIndex}...)
-    :($(Expr(:meta, :inline)); unsafe_getindex(A, $(cartindex_exprs(I, :I)...)))
+    :(@_propagate_inbounds_meta; getindex(A, $(cartindex_exprs(I, :I)...)))
 end
 @generated function _setindex!{T,N}(l::LinearIndexing, A::AbstractArray{T,N}, v, I::Union{Real,AbstractArray,Colon,CartesianIndex}...)
-    :($(Expr(:meta, :inline)); setindex!(A, v, $(cartindex_exprs(I, :I)...)))
-end
-@generated function _unsafe_setindex!{T,N}(l::LinearIndexing, A::AbstractArray{T,N}, v, I::Union{Real,AbstractArray,Colon,CartesianIndex}...)
-    :($(Expr(:meta, :inline)); unsafe_setindex!(A, v, $(cartindex_exprs(I, :I)...)))
+    :(@_propagate_inbounds_meta; setindex!(A, v, $(cartindex_exprs(I, :I)...)))
 end
 
 
@@ -400,116 +383,57 @@ end
 # In such cases we have to collapse the 2d space spanned by the ranges.
 #
 # API:
-#    merge_indexes(V, indexes::NTuple, dims::Dims, linindex)
-# where dims encodes the trailing sizes of the parent array,
+#    merge_indexes(V, indexes::NTuple, index)
 # indexes encodes the view's trailing indexes into the parent array,
-# and linindex encodes the subset of these elements that we'll select.
+# and index encodes the subset of these elements that we'll select.
 #
-# The generic algorithm makes use of div to convert elements
-# of linindex into a cartesian index into indexes, looks up
-# the corresponding cartesian index into the parent, and then uses
-# dims to convert back to a linear index into the parent array.
-#
-# However, a common case is linindex::Range.
-# Since div is slow and in(j::Int, linindex::Range) is fast,
-# it can be much faster to generate all possibilities and
-# then test whether the corresponding linear index is in linindex.
-# One exception occurs when only a small subset of the total
-# is desired, in which case we fall back to the div-based algorithm.
-#@generated function merge_indexes{T<:Integer}(V, parentindexes::NTuple, parentdims::Dims, linindex::Union{Colon,Range{T}}, lindim)
-@generated function merge_indexes_in{TT}(V, parentindexes::TT, parentdims::Dims, linindex, lindim)
-    N = length(parentindexes.parameters)   # number of parent axes we're merging
-    N > 0 || throw(ArgumentError("cannot merge empty indexes"))
-    lengthexpr = linindex == Colon ? (:(prod(size(V)[lindim:end]))) : (:(length(linindex)))
-    L = symbol(string("Istride_", N+1))  # length of V's trailing dimensions
+# It returns a CartesianIndex or array of CartesianIndexes.
+
+# Checking 'in' a range is fast -- so check all possibilities and keep the good ones
+@generated function merge_indexes{N}(V, indexes::NTuple{N}, index::Union{Colon, Range})
+    # There may be a vector of cartesian indices in the passed indexes... which
+    # makes the number of indices more than N. Since we pre-allocate the array
+    # of CartesianIndexes, we need to figure out how big to make it
+    M = 0
+    for T in indexes.parameters
+        T <: CartesianIndex ? (M += length(T)) : (M += 1)
+    end
+    index_length_expr = index <: Colon ? symbol(string("Istride_", N+1)) : :(length(index))
     quote
-        n = $lengthexpr
-        Base.Cartesian.@nexprs $N d->(I_d = parentindexes[d])
-        pdimoffset = ndims(V.parent) - length(parentdims)
-        Istride_1 = 1   # parentindexes strides
-        Base.Cartesian.@nexprs $N d->(Istride_{d+1} = Istride_d*dimsize(V.parent, d+pdimoffset, I_d))
-        Istridet = Base.Cartesian.@ntuple $(N+1) d->Istride_d
-        if n < 0.1*$L   # this has not been carefully tuned
-            return merge_indexes_div(V, parentindexes, parentdims, linindex, lindim)
+        Cartesian.@nexprs $N d->(I_d = indexes[d])
+        dimlengths = Cartesian.@ncall $N index_lengths_dim V.parent length(V.indexes)-N+1 I
+        Istride_1 = 1   # strides of the indexes to merge
+        Cartesian.@nexprs $N d->(Istride_{d+1} = Istride_d*dimlengths[d])
+        idx_len = $(index_length_expr)
+        if idx_len < 0.1*$(symbol(string("Istride_", N+1)))   # this has not been carefully tuned
+            return merge_indexes_div(V, indexes, index, dimlengths)
         end
-        Pstride_1 = 1   # parent strides
-        Base.Cartesian.@nexprs $(N-1) d->(Pstride_{d+1} = Pstride_d*parentdims[d])
-        Base.Cartesian.@nexprs $N d->(counter_d = 1) # counter_0 is a linear index into parentindexes
-        Base.Cartesian.@nexprs $N d->(offset_d = 1)  # offset_0 is a linear index into parent
+        Cartesian.@nexprs $N d->(counter_d = 1) # counter_0 is the linear index
         k = 0
-        index = Array(Int, n)
-        Base.Cartesian.@nloops $N i d->(1:dimsize(V.parent, d+pdimoffset, I_d)) d->(offset_{d-1} = offset_d + (I_d[i_d]-1)*Pstride_d; counter_{d-1} = counter_d + (i_d-1)*Istride_d) begin
-            if in(counter_0, linindex)
-                index[k+=1] = offset_0
+        merged = Array(CartesianIndex{$M}, idx_len)
+        Cartesian.@nloops $N i d->(1:dimlengths[d]) d->(counter_{d-1} = counter_d + (i_d-1)*Istride_d; @inbounds idx_d = I_d[i_d]) begin
+            if counter_0 in index # this branch is elided for ::Colon
+                @inbounds merged[k+=1] = Cartesian.@ncall $N CartesianIndex{$M} idx
             end
         end
-        index
+        merged
     end
 end
 
-# HACK: dispatch seemingly wasn't working properly
-function merge_indexes(V, parentindexes::NTuple, parentdims::Dims, linindex, lindim)
-    if isa(linindex, Colon) || isa(linindex, Range)
-        return merge_indexes_in(V, parentindexes, parentdims, linindex, lindim)
-    end
-    merge_indexes_div(V, parentindexes, parentdims, linindex, lindim)
-end
+# mapping getindex across the parent and subindices rapidly gets too big to
+# automatically inline, but it is crucial that it does so to avoid allocations
+# Unlike SubArray's reindex, merge_indexes doesn't drop any indices.
+@inline inlinemap(f, t::Tuple, s::Tuple) = (f(t[1], s[1]), inlinemap(f, tail(t), tail(s))...)
+inlinemap(f, t::Tuple{}, s::Tuple{}) = ()
+inlinemap(f, t::Tuple{}, s::Tuple) = ()
+inlinemap(f, t::Tuple, s::Tuple{}) = ()
 
-# Even simpler is the case where the linear index is ::Colon: return all indexes
-@generated function merge_indexes(V, indexes::NTuple, dims::Dims, ::Colon)
-    N = length(indexes)
-    N > 0 || throw(ArgumentError("cannot merge empty indexes"))
-    quote
-        Base.Cartesian.@nexprs $N d->(I_d = indexes[d])
-        dimoffset = ndims(V.parent) - length(dims)
-        n = prod(map(length, indexes))
-        Pstride_1 = 1   # parent strides
-        Base.Cartesian.@nexprs $(N-1) d->(Pstride_{d+1} = Pstride_d*dims[d])
-        Base.Cartesian.@nexprs $N d->(offset_d = 1)  # offset_0 is a linear index into parent
-        k = 0
-        index = Array(Int, n)
-        Base.Cartesian.@nloops $N i d->(1:dimsize(V, d+dimoffset, I_d)) d->(offset_{d-1} = offset_d + (I_d[i_d]-1)*Pstride_d) begin
-            index[k+=1] = offset_0
-        end
-        index
-    end
-end
+# Otherwise, we fall back to the slow div/rem method, using ind2sub.
+@inline merge_indexes{N}(V, indexes::NTuple{N}, index) = merge_indexes_div(V, indexes, index, index_lengths_dim(V.parent, length(V.indexes)-N+1, indexes...))
 
-# This could be written as a regular function, but performance
-# will be better using Cartesian macros to avoid the heap and
-# an extra loop.
-@generated function merge_indexes_div{TT}(V, parentindexes::TT, parentdims::Dims, linindex, lindim)
-    N = length(parentindexes.parameters)
-    N > 0 || throw(ArgumentError("cannot merge empty indexes"))
-    Istride_N = symbol("Istride_$N")
-    lengthexpr = :(length(linindex))
-    quote
-        Base.Cartesian.@nexprs $N d->(I_d = parentindexes[d])
-        Pstride_1 = 1   # parent strides
-        Base.Cartesian.@nexprs $(N-1) d->(Pstride_{d+1} = Pstride_d*parentdims[d])
-        Istride_1 = 1   # parentindexes strides
-        pdimoffset = ndims(V.parent) - length(parentdims)
-        Base.Cartesian.@nexprs $(N-1) d->(Istride_{d+1} = Istride_d*dimsize(V.parent, d+pdimoffset, I_d))
-        n = $lengthexpr
-        L = $(Istride_N) * dimsize(V.parent, $N+pdimoffset, parentindexes[end])
-        index = Array(Int, n)
-        for i = 1:n
-            k = linindex[i] # k is the parentindexes-centered linear index
-            1 <= k <= L || throw(BoundsError())
-            k -= 1
-            j = 0  # j will be the new parent-centered linear index
-            Base.Cartesian.@nexprs $N d->(d < $N ?
-                begin
-                    c, k = divrem(k, Istride_{$N-d+1})
-                    j += (Base.unsafe_getindex(I_{$N-d+1}, c+1)-1)*Pstride_{$N-d+1}
-                end : begin
-                    j += Base.unsafe_getindex(I_1, k+1)
-                end)
-            index[i] = j
-        end
-        index
-    end
-end
+@inline merge_indexes_div{N}(V, indexes::NTuple{N}, index::Real, dimlengths) = CartesianIndex(inlinemap(getindex, indexes, ind2sub(dimlengths, index)))
+merge_indexes_div{N}(V, indexes::NTuple{N}, index, dimlengths) = [CartesianIndex(inlinemap(getindex, indexes, ind2sub(dimlengths, i))) for i in index]
+merge_indexes_div{N}(V, indexes::NTuple{N}, index::Colon, dimlengths) = [CartesianIndex(inlinemap(getindex, indexes, ind2sub(dimlengths, i))) for i in 1:prod(dimlengths)]
 
 
  cumsum(A::AbstractArray, axis::Integer=1) =  cumsum!(similar(A, Base._cumsum_type(A)), A, axis)
@@ -591,13 +515,13 @@ end
 
 # contiguous multidimensional indexing: if the first dimension is a range,
 # we can get some performance from using copy_chunks!
-@inline function _unsafe_getindex!(X::BitArray, ::LinearFast, B::BitArray, I0::Union{UnitRange{Int}, Colon})
+@inline function _unsafe_getindex!(X::BitArray, B::BitArray, I0::Union{UnitRange{Int}, Colon})
     copy_chunks!(X.chunks, 1, B.chunks, first(I0), index_lengths(B, I0)[1])
     return X
 end
 
 # Optimization where the inner dimension is contiguous improves perf dramatically
-@generated function _unsafe_getindex!(X::BitArray, ::LinearFast, B::BitArray, I0::Union{Colon,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Colon}...)
+@generated function _unsafe_getindex!(X::BitArray, B::BitArray, I0::Union{Colon,UnitRange{Int}}, I::Union{Int,UnitRange{Int},Colon}...)
     N = length(I)
     quote
         $(Expr(:meta, :inline))
@@ -619,7 +543,8 @@ end
 
         storeind = 1
         Xc, Bc = X.chunks, B.chunks
-        @nloops($N, i, d->1:size(X, d+1),
+        idxlens = index_lengths(B, I0, I...) # TODO: unsplat?
+        @nloops($N, i, d->(1:idxlens[d+1]),
                 d->nothing, # PRE
                 d->(ind += stride_lst_d - gap_lst_d), # POST
                 begin # BODY
@@ -633,7 +558,7 @@ end
 # in the general multidimensional non-scalar case, can we do about 10% better
 # in most cases by manually hoisting the bitarray chunks access out of the loop
 # (This should really be handled by the compiler or with an immutable BitArray)
-@generated function _unsafe_getindex!(X::BitArray, ::LinearFast, B::BitArray, I::Union{Int,AbstractVector{Int},Colon}...)
+@generated function _unsafe_getindex!(X::BitArray, B::BitArray, I::Union{Int,AbstractVector{Int},Colon}...)
     N = length(I)
     quote
         $(Expr(:meta, :inline))
@@ -642,7 +567,8 @@ end
         $(symbol(:offset_, N)) = 1
         ind = 0
         Xc, Bc = X.chunks, B.chunks
-        @nloops $N i X d->(offset_{d-1} = offset_d + (unsafe_getindex(I[d], i_d)-1)*stride_d) begin
+        idxlens = index_lengths(B, I...) # TODO: unsplat?
+        @nloops $N i d->(1:idxlens[d]) d->(@inbounds offset_{d-1} = offset_d + (I[d][i_d]-1)*stride_d) begin
             ind += 1
             unsafe_bitsetindex!(Xc, unsafe_bitgetindex(Bc, offset_0), ind)
         end
@@ -655,15 +581,18 @@ end
 # contiguous multidimensional indexing: if the first dimension is a range,
 # we can get some performance from using copy_chunks!
 
-function unsafe_setindex!(B::BitArray, X::BitArray, I0::UnitRange{Int})
+@inline function setindex!(B::BitArray, X::BitArray, I0::UnitRange{Int})
+    @boundscheck checkbounds(B, I0)
     l0 = length(I0)
+    setindex_shape_check(X, l0)
     l0 == 0 && return B
     f0 = first(I0)
     copy_chunks!(B.chunks, f0, X.chunks, 1, l0)
     return B
 end
 
-function unsafe_setindex!(B::BitArray, x::Bool, I0::UnitRange{Int})
+@inline function setindex!(B::BitArray, x::Bool, I0::UnitRange{Int})
+    @boundscheck checkbounds(B, I0)
     l0 = length(I0)
     l0 == 0 && return B
     f0 = first(I0)
@@ -671,10 +600,15 @@ function unsafe_setindex!(B::BitArray, x::Bool, I0::UnitRange{Int})
     return B
 end
 
-@generated function unsafe_setindex!(B::BitArray, X::BitArray, I0::UnitRange{Int}, I::Union{Int,UnitRange{Int}}...)
+@inline function setindex!(B::BitArray, X::BitArray, I0::UnitRange{Int}, I::Union{Int,UnitRange{Int}}...)
+    @boundscheck checkbounds(B, I0, I...)
+    _unsafe_setindex!(B, X, I0, I...)
+end
+@generated function _unsafe_setindex!(B::BitArray, X::BitArray, I0::UnitRange{Int}, I::Union{Int,UnitRange{Int}}...)
     N = length(I)
     quote
-        length(X) == 0 && return B
+        # TODO: need to setindex_shape_check
+        isempty(X) && return B
         f0 = first(I0)
         l0 = length(I0)
 
@@ -702,13 +636,17 @@ end
     end
 end
 
-@generated function unsafe_setindex!(B::BitArray, x::Bool, I0::UnitRange{Int}, I::Union{Int,UnitRange{Int}}...)
+@inline function setindex!(B::BitArray, x::Bool, I0::UnitRange{Int}, I::Union{Int,UnitRange{Int}}...)
+    @boundscheck checkbounds(B, I0, I...)
+    _unsafe_setindex!(B, x, I0, I...)
+end
+@generated function _unsafe_setindex!(B::BitArray, x::Bool, I0::UnitRange{Int}, I::Union{Int,UnitRange{Int}}...)
     N = length(I)
     quote
         f0 = first(I0)
         l0 = length(I0)
         l0 == 0 && return B
-        @nexprs $N d->(length(I[d]) == 0 && return B)
+        @nexprs $N d->(isempty(I[d]) && return B)
 
         gap_lst_1 = 0
         @nexprs $N d->(gap_lst_{d+1} = length(I[d]))
@@ -818,6 +756,13 @@ immutable Prehashed
 end
 hash(x::Prehashed) = x.hash
 
+"""
+    unique(itr[, dim])
+
+Returns an array containing only the unique elements of the iterable `itr`, in
+the order that the first of each set of equivalent elements originally appears.
+If `dim` is specified, returns unique regions of the array `itr` along `dim`.
+"""
 @generated function unique{T,N}(A::AbstractArray{T,N}, dim::Int)
     quote
         1 <= dim <= $N || return copy(A)
diff --git a/base/nullable.jl b/base/nullable.jl
index 7f059613e407e..21da641206200 100644
--- a/base/nullable.jl
+++ b/base/nullable.jl
@@ -10,6 +10,8 @@ eltype{T}(::Type{Nullable{T}}) = T
 
 convert{T}(::Type{Nullable{T}}, x::Nullable{T}) = x
 
+convert{T}(t::Type{Nullable{T}}, x::Any) = convert(t, convert(T, x))
+
 function convert{T}(::Type{Nullable{T}}, x::Nullable)
     return isnull(x) ? Nullable{T}() : Nullable{T}(convert(T, get(x)))
 end
@@ -20,11 +22,11 @@ convert{T}(::Type{Nullable{T}}, ::Void) = Nullable{T}()
 convert(   ::Type{Nullable   }, ::Void) = Nullable{Union{}}()
 
 function show{T}(io::IO, x::Nullable{T})
-    if x.isnull
-        print(io, "Nullable{"); show(io, T); print(io, "}()")
-    else
-        print(io, "Nullable("); show(io, x.value); print(io, ")")
+    print(io, "Nullable{", T, "}(")
+    if !isnull(x)
+        show(io, x.value)
     end
+    print(io, ')')
 end
 
 get(x::Nullable) = x.isnull ? throw(NullException()) : x.value
diff --git a/base/number.jl b/base/number.jl
index ff78f6913fb60..0dfbc14447561 100644
--- a/base/number.jl
+++ b/base/number.jl
@@ -12,21 +12,29 @@ ndims{T<:Number}(::Type{T}) = 0
 length(x::Number) = 1
 endof(x::Number) = 1
 getindex(x::Number) = x
-getindex(x::Number, i::Integer) = i == 1 ? x : throw(BoundsError())
-getindex(x::Number, I::Integer...) = all([i == 1 for i in I]) ? x : throw(BoundsError())
+function getindex(x::Number, i::Integer)
+    @_inline_meta
+    @boundscheck i == 1 || throw(BoundsError())
+    x
+end
+function getindex(x::Number, I::Integer...)
+    @_inline_meta
+    @boundscheck all([i == 1 for i in I]) || throw(BoundsError())
+    x
+end
 getindex(x::Number, I::Real...) = getindex(x, to_indexes(I...)...)
-unsafe_getindex(x::Real, i::Real) = x
 first(x::Number) = x
 last(x::Number) = x
 
 divrem(x,y) = (div(x,y),rem(x,y))
 fldmod(x,y) = (fld(x,y),mod(x,y))
 signbit(x::Real) = x < 0
-sign(x::Number) = x == 0? float(zero(x)) : x/abs(x)
+sign(x::Number) = x == 0 ? x/abs(one(x)) : x/abs(x)
 sign(x::Real) = ifelse(x < 0, oftype(x,-1), ifelse(x > 0, one(x), x))
 sign(x::Unsigned) = ifelse(x > 0, one(x), x)
 abs(x::Real) = ifelse(signbit(x), -x, x)
 abs2(x::Real) = x*x
+flipsign(x::Real, y::Real) = ifelse(signbit(y), -x, x)
 copysign(x::Real, y::Real) = ifelse(signbit(x)!=signbit(y), -x, x)
 
 conj(x::Real) = x
@@ -43,7 +51,7 @@ done(x::Number, state) = state
 isempty(x::Number) = false
 in(x::Number, y::Number) = x == y
 
-map(f, x::Number) = f(x)
+map(f, x::Number, ys::Number...) = f(x, ys...)
 
 zero(x::Number) = oftype(x,0)
 zero{T<:Number}(::Type{T}) = convert(T,0)
diff --git a/base/operators.jl b/base/operators.jl
index c2eb8ae900844..7ae4e8f54ac2c 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -4,7 +4,7 @@
 
 const (<:) = issubtype
 
-super(T::DataType) = T.super
+supertype(T::DataType) = T.super
 
 ## generic comparison ##
 
@@ -88,8 +88,14 @@ function afoldl(op,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,qs...)
     y
 end
 
+immutable ElementwiseMaxFun end
+(::ElementwiseMaxFun)(x, y) = max(x,y)
+
+immutable ElementwiseMinFun end
+(::ElementwiseMinFun)(x, y) = min(x, y)
+
 for (op,F) in ((:+,:(AddFun())), (:*,:(MulFun())), (:&,:(AndFun())), (:|,:(OrFun())),
-               (:$,:$), (:min,:(MinFun())), (:max,:(MaxFun())), (:kron,:kron))
+               (:$,:(XorFun())), (:min,:(ElementwiseMinFun())), (:max,:(ElementwiseMaxFun())), (:kron,:kron))
     @eval begin
         # note: these definitions must not cause a dispatch loop when +(a,b) is
         # not defined, and must only try to call 2-argument definitions, so
@@ -121,9 +127,83 @@ const .≤ = .<=
 const .≠ = .!=
 
 # core << >> and >>> takes Int as second arg
+"""
+    <<(x, n)
+
+Left bit shift operator, `x << n`. The result is `x` shifted left by `n` bits,
+where `n >= 0`, filling with `0`s. This is equivalent to `x * 2^n`.
+
+```jldoctest
+julia> Int8(3) << 2
+12
+
+julia> bits(Int8(3))
+"00000011"
+
+julia> bits(Int8(12))
+"00001100"
+```
+See also [`>>`](:func:`>>`), [`>>>`](:func:`>>>`).
+"""
 <<(x,y::Int)  = no_op_err("<<", typeof(x))
+
+"""
+    >>(x, n)
+
+Right bit shift operator, `x >> n`. The result is `x` shifted right by `n` bits, where
+`n >= 0`, filling with `0`s if `x >= 0`, `1`s if `x < 0`, preserving the sign of `x`.
+This is equivalent to `fld(x, 2^n)`.
+
+
+```jldoctest
+julia> Int8(13) >> 2
+3
+
+julia> bits(Int8(13))
+"00001101"
+
+julia> bits(Int8(3))
+"00000011"
+
+julia> Int8(-14) >> 2
+-4
+
+julia> bits(Int8(-14))
+"11110010"
+
+julia> bits(Int8(-4))
+"11111100"
+```
+See also [`>>>`](:func:`>>>`), [`<<`](:func:`<<`).
+"""
 >>(x,y::Int)  = no_op_err(">>", typeof(x))
+
+"""
+    >>>(x, n)
+
+Unsigned right bit shift operator, `x >>> n`. The result is `x` shifted right by `n` bits,
+where `n >= 0`, filling with `0`s.
+
+For `Unsigned` integer types, this is eqivalent to [`>>`](:func:`>>`). For `Signed` integer types,
+this is equivalent to `(unsigned(x) >> n) % typeof(x)`.
+
+```jldoctest
+julia> Int8(-14) >>> 2
+60
+
+julia> bits(Int8(-14))
+"11110010"
+
+julia> bits(Int8(60))
+"00111100"
+```
+`BigInt`s are treated as if having infinite size, so no filling is required and this
+is equivalent to [`>>`](:func:`>>`).
+
+See also [`>>`](:func:`>>`), [`<<`](:func:`<<`).
+"""
 >>>(x,y::Int) = no_op_err(">>>", typeof(x))
+
 <<(x,y::Integer)  = typemax(Int) < y ? zero(x) : x <<  (y % Int)
 >>(x,y::Integer)  = typemax(Int) < y ? zero(x) : x >>  (y % Int)
 >>>(x,y::Integer) = typemax(Int) < y ? zero(x) : x >>> (y % Int)
@@ -142,11 +222,17 @@ modCeil{T<:Real}(x::T, y::T) = convert(T,x-y*ceil(x/y))
 const % = rem
 .%(x::Real, y::Real) = x%y
 const ÷ = div
+.÷(x::Real, y::Real) = x÷y
 
-# mod returns in [0,y) whereas mod1 returns in (0,y]
+# mod returns in [0,y) or (y,0] (for negative y),
+# whereas mod1 returns in (0,y] or [y,0)
 mod1{T<:Real}(x::T, y::T) = (m=mod(x,y); ifelse(m==0, y, m))
-rem1{T<:Real}(x::T, y::T) = rem(x-1,y)+1
-fld1{T<:Real}(x::T, y::T) = fld(x-1,y)+1
+fld1{T<:Real}(x::T, y::T) = (m=mod(x,y); fld(x-m,y))
+fldmod1{T<:Real}(x::T, y::T) = (fld1(x,y), mod1(x,y))
+# efficient version for integers
+mod1{T<:Integer}(x::T, y::T) = mod(x+y-T(1),y)+T(1)
+fld1{T<:Integer}(x::T, y::T) = fld(x+y-T(1),y)
+fldmod1{T<:Integer}(x::T, y::T) = (fld1(x,y), mod1(x,y))
 
 # transpose
 transpose(x) = x
@@ -181,11 +267,11 @@ widen{T<:Number}(x::T) = convert(widen(T), x)
 
 eltype(::Type) = Any
 eltype(::Type{Any}) = Any
-eltype(t::DataType) = eltype(super(t))
+eltype(t::DataType) = eltype(supertype(t))
 eltype(x) = eltype(typeof(x))
 
 # copying immutable things
-copy(x::Union{Symbol,Number,AbstractString,Function,Tuple,LambdaStaticData,
+copy(x::Union{Symbol,Number,AbstractString,Function,Tuple,LambdaInfo,
               TopNode,QuoteNode,DataType,Union}) = x
 
 # function pipelining
@@ -246,7 +332,7 @@ end
 # for permutations that leave array elements in the same linear order.
 # those are the permutations that preserve the order of the non-singleton
 # dimensions.
-function setindex_shape_check(X::AbstractArray, I::Int...)
+function setindex_shape_check(X::AbstractArray, I...)
     li = ndims(X)
     lj = length(I)
     i = j = 1
@@ -283,16 +369,16 @@ end
 setindex_shape_check(X::AbstractArray) =
     (length(X)==1 || throw_setindex_mismatch(X,()))
 
-setindex_shape_check(X::AbstractArray, i::Int) =
+setindex_shape_check(X::AbstractArray, i) =
     (length(X)==i || throw_setindex_mismatch(X, (i,)))
 
-setindex_shape_check{T}(X::AbstractArray{T,1}, i::Int) =
+setindex_shape_check{T}(X::AbstractArray{T,1}, i) =
     (length(X)==i || throw_setindex_mismatch(X, (i,)))
 
-setindex_shape_check{T}(X::AbstractArray{T,1}, i::Int, j::Int) =
+setindex_shape_check{T}(X::AbstractArray{T,1}, i, j) =
     (length(X)==i*j || throw_setindex_mismatch(X, (i,j)))
 
-function setindex_shape_check{T}(X::AbstractArray{T,2}, i::Int, j::Int)
+function setindex_shape_check{T}(X::AbstractArray{T,2}, i, j)
     if length(X) != i*j
         throw_setindex_mismatch(X, (i,j))
     end
@@ -301,7 +387,7 @@ function setindex_shape_check{T}(X::AbstractArray{T,2}, i::Int, j::Int)
         throw_setindex_mismatch(X, (i,j))
     end
 end
-setindex_shape_check(X, I::Int...) = nothing # Non-arrays broadcast to all idxs
+setindex_shape_check(X, I...) = nothing # Non-arrays broadcast to all idxs
 
 # convert to a supported index type (Array, Colon, or Int)
 to_index(i::Int) = i
@@ -439,9 +525,10 @@ isless(p::Pair, q::Pair) = ifelse(!isequal(p.first,q.first), isless(p.first,q.fi
                                                              isless(p.second,q.second))
 getindex(p::Pair,i::Int) = getfield(p,i)
 getindex(p::Pair,i::Real) = getfield(p, convert(Int, i))
-reverse(p::Pair) = Pair(p.second, p.first)
+reverse{A,B}(p::Pair{A,B}) = Pair{B,A}(p.second, p.first)
 
 endof(p::Pair) = 2
+length(p::Pair) = 2
 
 # some operators not defined yet
 global //, >:, <|, hcat, hvcat, ⋅, ×, ∈, ∉, ∋, ∌, ⊆, ⊈, ⊊, ∩, ∪, √, ∛
@@ -457,6 +544,8 @@ export
     $,
     %,
     .%,
+    ÷,
+    .÷,
     &,
     *,
     +,
@@ -499,7 +588,6 @@ export
     |>,
     <|,
     ~,
-    ÷,
     ⋅,
     ×,
     ∈,
@@ -520,13 +608,12 @@ export
     getindex,
     setindex!,
     transpose,
-    ctranspose,
-    call
+    ctranspose
 
-import ..this_module: !, !=, $, %, .%, &, *, +, -, .!=, .+, .-, .*, ./, .<, .<=, .==, .>,
+import ..this_module: !, !=, $, %, .%, ÷, .÷, &, *, +, -, .!=, .+, .-, .*, ./, .<, .<=, .==, .>,
     .>=, .\, .^, /, //, <, <:, <<, <=, ==, >, >=, >>, .>>, .<<, >>>,
     <|, |>, \, ^, |, ~, !==, ===, >:, colon, hcat, vcat, hvcat, getindex, setindex!,
-    transpose, ctranspose, call,
-    ≥, ≤, ≠, .≥, .≤, .≠, ÷, ⋅, ×, ∈, ∉, ∋, ∌, ⊆, ⊈, ⊊, ∩, ∪, √, ∛
+    transpose, ctranspose,
+    ≥, ≤, ≠, .≥, .≤, .≠, ⋅, ×, ∈, ∉, ∋, ∌, ⊆, ⊈, ⊊, ∩, ∪, √, ∛
 
 end
diff --git a/base/options.jl b/base/options.jl
index fd4f7c3211b38..f48abdb314210 100644
--- a/base/options.jl
+++ b/base/options.jl
@@ -28,6 +28,7 @@ immutable JLOptions
     worker::Int8
     handle_signals::Int8
     use_precompiled::Int8
+    use_compilecache::Int8
     bindto::Ptr{UInt8}
     outputbc::Ptr{UInt8}
     outputo::Ptr{UInt8}
@@ -36,3 +37,17 @@ immutable JLOptions
 end
 
 JLOptions() = unsafe_load(cglobal(:jl_options, JLOptions))
+
+function show(io::IO, opt::JLOptions)
+    println(io, "JLOptions(")
+    fields = fieldnames(opt)
+    nfields = length(fields)
+    for (i,f) in enumerate(fieldnames(opt))
+        v = getfield(opt,f)
+        if isa(v, Ptr{UInt8})
+            v = v != C_NULL ? bytestring(v) : ""
+        end
+        println(io, "  ", f, " = ", repr(v), i < nfields ? "," : "")
+    end
+    print(io,")")
+end
diff --git a/base/ordering.jl b/base/ordering.jl
index 95d4f18cce27b..c3015f76315f8 100644
--- a/base/ordering.jl
+++ b/base/ordering.jl
@@ -41,7 +41,6 @@ immutable Perm{O<:Ordering,V<:AbstractVector} <: Ordering
     order::O
     data::V
 end
-Perm{O<:Ordering,V<:AbstractVector}(o::O,v::V) = Perm{O,V}(o,v)
 
 lt(o::ForwardOrdering,       a, b) = isless(a,b)
 lt(o::ReverseOrdering,       a, b) = lt(o.fwd,b,a)
diff --git a/base/osutils.jl b/base/osutils.jl
index e149ca59e317e..7155e2edc8438 100644
--- a/base/osutils.jl
+++ b/base/osutils.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+const OS_NAME = ccall(:jl_get_OS_NAME, Any, ())
+
 function is_unix(os::Symbol)
     if (os==:Windows) return false;
     elseif (os==:Linux) return true;
diff --git a/base/parse.jl b/base/parse.jl
index 111c5c6125410..123b4af2dd5c4 100644
--- a/base/parse.jl
+++ b/base/parse.jl
@@ -171,6 +171,7 @@ float{S<:AbstractString}(a::AbstractArray{S}) = map!(float, similar(a,typeof(flo
 ## interface to parser ##
 
 function parse(str::AbstractString, pos::Int; greedy::Bool=true, raise::Bool=true)
+    # pos is one based byte offset.
     # returns (expr, end_pos). expr is () in case of parse error.
     bstr = bytestring(str)
     ex, pos = ccall(:jl_parse_string, Any,
@@ -187,7 +188,7 @@ function parse(str::AbstractString, pos::Int; greedy::Bool=true, raise::Bool=tru
 end
 
 function parse(str::AbstractString; raise::Bool=true)
-    ex, pos = parse(str, start(str), greedy=true, raise=raise)
+    ex, pos = parse(str, 1, greedy=true, raise=raise)
     if isa(ex,Expr) && ex.head === :error
         return ex
     end
diff --git a/base/path.jl b/base/path.jl
index 24f47a69be6e7..4cd8ebfa3c338 100644
--- a/base/path.jl
+++ b/base/path.jl
@@ -1,5 +1,21 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+export
+    abspath,
+    basename,
+    dirname,
+    expanduser,
+    homedir,
+    isabspath,
+    isdirpath,
+    joinpath,
+    normpath,
+    realpath,
+    relpath,
+    splitdir,
+    splitdrive,
+    splitext
+
 @unix_only begin
     const path_separator    = "/"
     const path_separator_re = r"/+"
@@ -108,20 +124,31 @@ normpath(a::AbstractString, b::AbstractString...) = normpath(joinpath(a,b...))
 abspath(a::AbstractString) = normpath(isabspath(a) ? a : joinpath(pwd(),a))
 abspath(a::AbstractString, b::AbstractString...) = abspath(joinpath(a,b...))
 
-@windows_only realpath(path::AbstractString) = realpath(utf16(path))
-@windows_only function realpath(path::UTF16String)
-    p = UInt32((sizeof(path)>>2) + 1)
+@windows_only function realpath(path::AbstractString)
+    path = cwstring(path)
+    buf = zeros(UInt16, length(path))
     while true
-        buflength = p
-        buf = zeros(UInt16,buflength)
-        p = ccall((:GetFullPathNameW, "Kernel32"), stdcall,
-            UInt32, (Cwstring, UInt32, Ptr{UInt16}, Ptr{Void}),
-            path, buflength, buf, C_NULL)
-        systemerror(:realpath, p == 0)
-        if (p < buflength)
-            resize!(buf, p+1)
-            return utf8(UTF16String(buf))
-        end
+        n = ccall((:GetFullPathNameW, "kernel32"), stdcall,
+            UInt32, (Ptr{UInt16}, UInt32, Ptr{UInt16}, Ptr{Void}),
+            path, length(buf), buf, C_NULL)
+        systemerror(:realpath, n == 0)
+        x = n < length(buf) # is the buffer big enough?
+        resize!(buf, n) # shrink if x, grow if !x
+        x && return UTF8String(utf16to8(buf))
+    end
+end
+
+@windows_only function longpath(path::AbstractString)
+    path = cwstring(path)
+    buf = zeros(UInt16, length(path))
+    while true
+        n = ccall((:GetLongPathNameW, "kernel32"), stdcall,
+            UInt32, (Ptr{UInt16}, Ptr{UInt16}, UInt32),
+            path, buf, length(buf))
+        systemerror(:longpath, n == 0)
+        x = n < length(buf) # is the buffer big enough?
+        resize!(buf, n) # shrink if x, grow if !x
+        x && return UTF8String(utf16to8(buf))
     end
 end
 
diff --git a/base/pcre.jl b/base/pcre.jl
index ec7a865aca94c..aa24f8690145f 100644
--- a/base/pcre.jl
+++ b/base/pcre.jl
@@ -4,7 +4,7 @@
 
 module PCRE
 
-include("pcre_h.jl")
+include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","pcre_h.jl"))  # include($BUILDROOT/base/pcre_h.jl)
 
 const PCRE_LIB = "libpcre2-8"
 
diff --git a/base/pkg.jl b/base/pkg.jl
index b7b48ad40e892..e0b185c9f95eb 100644
--- a/base/pkg.jl
+++ b/base/pkg.jl
@@ -2,74 +2,265 @@
 
 module Pkg
 
-export Git, Dir, GitHub, Types, Reqs, Cache, Read, Query, Resolve, Write, Generate, Entry
+export Dir, Types, Reqs, Cache, Read, Query, Resolve, Write, Entry, Git
 export dir, init, rm, add, available, installed, status, clone, checkout,
-       update, resolve, register, tag, publish, generate, test,
-       build, free, pin
+       update, resolve, test, build, free, pin, PkgError, setprotocol!
 
-const DEFAULT_META = "git://github.com/JuliaLang/METADATA.jl"
+const DEFAULT_META = "https://github.com/JuliaLang/METADATA.jl"
 const META_BRANCH = "metadata-v2"
 
-for file in split("git dir github types reqs cache read query resolve write generate entry")
+type PkgError <: Exception
+    msg::AbstractString
+end
+
+for file in split("dir types reqs cache read query resolve write entry git")
     include("pkg/$file.jl")
 end
 const cd = Dir.cd
 
 dir(path...) = Dir.path(path...)
+
+"""
+    dir() -> AbstractString
+
+Returns the absolute path of the package directory. This defaults to
+`joinpath(homedir(),".julia","v\$(VERSION.major).\$(VERSION.minor)")` on all platforms (i.e.
+`~/.julia/v$(VERSION.major).$(VERSION.minor)` in UNIX shell syntax). If the `JULIA_PKGDIR`
+environment variable is set, then that path is used in the returned value as
+`joinpath(ENV["JULIA_PKGDIR"],"v\$(VERSION.major).\$(VERSION.minor)")`. If `JULIA_PKGDIR` is
+a relative path, it is interpreted relative to whatever the current working directory is.
+"""
+dir()
+
+"""
+    dir(names...) -> AbstractString
+
+Equivalent to `normpath(Pkg.dir(),names...)` – i.e. it appends path components to the
+package directory and normalizes the resulting path. In particular, `Pkg.dir(pkg)` returns
+the path to the package `pkg`.
+"""
+dir(names...)
+
+"""
+    init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH)
+
+Initialize `Pkg.dir()` as a package directory. This will be done automatically when the
+`JULIA_PKGDIR` is not set and `Pkg.dir()` uses its default value. As part of this process,
+clones a local METADATA git repository from the site and branch specified by its arguments,
+which are typically not provided. Explicit (non-default) arguments can be used to support a
+custom METADATA setup.
+"""
 init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH) = Dir.init(meta,branch)
 
+function __init__()
+    vers = "v$(VERSION.major).$(VERSION.minor)"
+    unshift!(Base.LOAD_CACHE_PATH, abspath(Dir._pkgroot(), "lib", vers))
+end
+
+"""
+    edit()
+
+Opens `Pkg.dir("REQUIRE")` in the editor specified by the `VISUAL` or `EDITOR` environment
+variables; when the editor command returns, it runs `Pkg.resolve()` to determine and install
+a new optimal set of installed package versions.
+"""
 edit() = cd(Entry.edit)
+
+"""
+    rm(pkg)
+
+Remove all requirement entries for `pkg` from `Pkg.dir("REQUIRE")` and call `Pkg.resolve()`.
+"""
 rm(pkg::AbstractString) = cd(Entry.rm,pkg)
+
+"""
+    add(pkg, vers...)
+
+Add a requirement entry for `pkg` to `Pkg.dir("REQUIRE")` and call `Pkg.resolve()`. If
+`vers` are given, they must be `VersionNumber` objects and they specify acceptable version
+intervals for `pkg`.
+"""
 add(pkg::AbstractString, vers::VersionNumber...) = cd(Entry.add,pkg,vers...)
 
+"""
+    available() -> Vector{ASCIIString}
+
+Returns the names of available packages.
+"""
 available() = cd(Entry.available)
+
+"""
+    available(pkg) -> Vector{VersionNumber}
+
+Returns the version numbers available for package `pkg`.
+"""
 available(pkg::AbstractString) = cd(Entry.available,pkg)
 
+"""
+    installed() -> Dict{ASCIIString,VersionNumber}
+
+Returns a dictionary mapping installed package names to the installed version number of each
+package.
+"""
 installed() = cd(Entry.installed)
+
+"""
+    installed(pkg) -> Void | VersionNumber
+
+If `pkg` is installed, return the installed version number, otherwise return `nothing`.
+"""
 installed(pkg::AbstractString) = cd(Entry.installed,pkg)
 
+"""
+    status()
+
+Prints out a summary of what packages are installed and what version and state they're in.
+"""
 status(io::IO=STDOUT) = cd(Entry.status,io)
-status(pkg::AbstractString = "", io::IO=STDOUT) = cd(Entry.status,io,pkg)
+status(pkg::AbstractString, io::IO=STDOUT) = cd(Entry.status,io,pkg)
+
+"""
+    clone(pkg)
 
+If `pkg` has a URL registered in `Pkg.dir("METADATA")`, clone it from that URL on the
+default branch. The package does not need to have any registered versions.
+"""
 clone(url_or_pkg::AbstractString) = cd(Entry.clone,url_or_pkg)
+
+"""
+    clone(url, [pkg])
+
+Clone a package directly from the git URL `url`. The package does not need to be registered
+in `Pkg.dir("METADATA")`. The package repo is cloned by the name `pkg` if provided; if not
+provided, `pkg` is determined automatically from `url`.
+"""
 clone(url::AbstractString, pkg::AbstractString) = cd(Entry.clone,url,pkg)
 
+"""
+    checkout(pkg, [branch="master"]; merge=true, pull=true)
+
+Checkout the `Pkg.dir(pkg)` repo to the branch `branch`. Defaults to checking out the
+"master" branch. To go back to using the newest compatible released version, use
+`Pkg.free(pkg)`. Changes are merged (fast-forward only) if the keyword argument `merge ==
+true`, and the latest version is pulled from the upstream repo if `pull == true`.
+"""
 checkout(pkg::AbstractString, branch::AbstractString="master"; merge::Bool=true, pull::Bool=true) =
     cd(Entry.checkout,pkg,branch,merge,pull)
 
+"""
+    free(pkg)
+
+Free the package `pkg` to be managed by the package manager again. It calls `Pkg.resolve()`
+to determine optimal package versions after. This is an inverse for both `Pkg.checkout` and
+`Pkg.pin`.
+
+You can also supply an iterable collection of package names, e.g., `Pkg.free(("Pkg1",
+"Pkg2"))` to free multiple packages at once.
+"""
 free(pkg) = cd(Entry.free,pkg)
 
+"""
+    pin(pkg)
+
+Pin `pkg` at the current version. To go back to using the newest compatible released
+version, use `Pkg.free(pkg)`
+"""
 pin(pkg::AbstractString) = cd(Entry.pin,pkg)
+
+"""
+    pin(pkg, version)
+
+Pin `pkg` at registered version `version`.
+"""
 pin(pkg::AbstractString, ver::VersionNumber) = cd(Entry.pin,pkg,ver)
 
+"""
+    update()
+
+Update the metadata repo – kept in `Pkg.dir("METADATA")` – then update any fixed packages
+that can safely be pulled from their origin; then call `Pkg.resolve()` to determine a new
+optimal set of packages versions.
+"""
 update() = cd(Entry.update,Dir.getmetabranch())
-resolve() = cd(Entry.resolve)
 
-register(pkg::AbstractString) = cd(Entry.register,pkg)
-register(pkg::AbstractString, url::AbstractString) = cd(Entry.register,pkg,url)
+"""
+    resolve()
 
-tag(pkg::AbstractString, sym::Symbol=:patch) = cd(Entry.tag,pkg,sym)
-tag(pkg::AbstractString, sym::Symbol, commit::AbstractString) = cd(Entry.tag,pkg,sym,false,commit)
+Determines an optimal, consistent set of package versions to install or upgrade to. The
+optimal set of package versions is based on the contents of `Pkg.dir("REQUIRE")` and the
+state of installed packages in `Pkg.dir()`, Packages that are no longer required are moved
+into `Pkg.dir(".trash")`.
+"""
+resolve() = cd(Entry.resolve)
 
-tag(pkg::AbstractString, ver::VersionNumber; force::Bool=false) = cd(Entry.tag,pkg,ver,force)
-tag(pkg::AbstractString, ver::VersionNumber, commit::AbstractString; force::Bool=false) =
-    cd(Entry.tag,pkg,ver,force,commit)
+"""
+    build()
 
-submit(pkg::AbstractString) = cd(Entry.submit,pkg)
-submit(pkg::AbstractString, commit::AbstractString) = cd(Entry.submit,pkg,commit)
+Run the build scripts for all installed packages in depth-first recursive order.
+"""
+build() = cd(Entry.build)
 
-publish() = cd(Entry.publish,Dir.getmetabranch())
+"""
+    build(pkgs...)
 
-build() = cd(Entry.build)
+Run the build script in `deps/build.jl` for each package in `pkgs` and all of their
+dependencies in depth-first recursive order. This is called automatically by `Pkg.resolve()`
+on all installed or updated packages.
+"""
 build(pkgs::AbstractString...) = cd(Entry.build,[pkgs...])
 
-generate(pkg::AbstractString, license::AbstractString; force::Bool=false, authors::Union{AbstractString,Array} = [], config::Dict=Dict()) =
-    cd(Generate.package,pkg,license,force=force,authors=authors,config=config)
-
+"""
+    test()
 
+Run the tests for all installed packages ensuring that each package's test dependencies are
+installed for the duration of the test. A package is tested by running its
+`test/runtests.jl` file and test dependencies are specified in `test/REQUIRE`.
+"""
 test(;coverage::Bool=false) = cd(Entry.test; coverage=coverage)
+
+"""
+    test(pkgs...)
+
+Run the tests for each package in `pkgs` ensuring that each package's test dependencies are
+installed for the duration of the test. A package is tested by running its
+`test/runtests.jl` file and test dependencies are specified in `test/REQUIRE`.
+"""
 test(pkgs::AbstractString...; coverage::Bool=false) = cd(Entry.test,AbstractString[pkgs...]; coverage=coverage)
 
 dependents(packagename::AbstractString) = Reqs.dependents(packagename)
 
+"""
+    setprotocol!(proto)
+
+Set the protocol used to access GitHub-hosted packages. Defaults to 'https', with a blank
+`proto` delegating the choice to the package developer.
+"""
+setprotocol!(proto::AbstractString) = Cache.setprotocol!(proto)
+
+
+# point users to PkgDev
+register(args...) =
+    error("Pkg.register(pkg,[url]) has been moved to the package PkgDev.jl.\n",
+          "Run Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-")
+
+tag(pkg, ver=nothing, commit=nothing) =
+    error("Pkg.tag(pkg, [ver, [commit]]) has been moved to the package PkgDev.jl.\n",
+          "Run Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-")
+
+publish() =
+    error("Pkg.publish() has been moved to the package PkgDev.jl.\n",
+          "Run Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-")
+
+generate(pkg, license) =
+    error("Pkg.generate(pkg, license) has been moved to the package PkgDev.jl.\n",
+          "Run Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-")
+
+license(lic=nothing) =
+    error("Pkg.license([lic]) has been moved to the package PkgDev.jl.\n",
+          "Run Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-")
+
+submit(pkg, commit=nothing) =
+    error("Pkg.submit(pkg[, commit]) has been moved to the package PkgDev.jl.\n",
+          "Run Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-")
+
 end # module
diff --git a/base/pkg/cache.jl b/base/pkg/cache.jl
index 22107f430e70c..f41b2252170c1 100644
--- a/base/pkg/cache.jl
+++ b/base/pkg/cache.jl
@@ -2,9 +2,14 @@
 
 module Cache
 
-import ..Git, ..Dir
+import ...LibGit2, ..Dir, ...Pkg.PkgError
 using ..Types
 
+rewrite_url_to = "https"
+
+const GITHUB_REGEX =
+    r"^(?:git@|git://|https://(?:[\w\.\+\-]+@)?)github.com[:/](([^/].+)/(.+?))(?:\.git)?$"i
+
 path(pkg::AbstractString) = abspath(".cache", pkg)
 
 function mkcachedir()
@@ -13,11 +18,7 @@ function mkcachedir()
         return
     end
 
-    @windows_only if Base.windows_version() < Base.WINDOWS_VISTA_VER
-        mkdir(cache)
-        return
-    end
-    if Dir.isversioned(pwd())
+    @unix_only if Dir.isversioned(pwd())
         rootcache = joinpath(realpath(".."), ".cache")
         if !isdir(rootcache)
             mkdir(rootcache)
@@ -28,28 +29,57 @@ function mkcachedir()
     mkdir(cache)
 end
 
-
 function prefetch(pkg::AbstractString, url::AbstractString, sha1s::Vector)
     isdir(".cache") || mkcachedir()
+
     cache = path(pkg)
-    if !isdir(cache)
-        info("Cloning cache of $pkg from $url")
-        try Git.run(`clone -q --mirror $url $cache`)
-        catch
-            rm(cache, recursive=true)
-            rethrow()
+    normalized_url = normalize_url(url)
+
+    repo = if isdir(cache)
+        LibGit2.GitRepo(cache) # open repo, free it at the end
+    else
+        info("Cloning cache of $pkg from $normalized_url")
+        try
+            # clone repo, free it at the end
+            LibGit2.clone(normalized_url, cache, isbare = true, remote_cb = LibGit2.mirror_cb())
+        catch err
+            isdir(cache) && rm(cache, recursive=true)
+            throw(PkgError("Cannot clone $pkg from $normalized_url. $(err.msg)"))
+        end
+    end
+    try
+        LibGit2.set_remote_url(repo, normalized_url)
+        in_cache = BitArray(map(sha1->LibGit2.iscommit(sha1, repo), sha1s))
+        if !all(in_cache)
+            info("Updating cache of $pkg...")
+            LibGit2.fetch(repo)
+            in_cache = BitArray(map(sha1->LibGit2.iscommit(sha1, repo), sha1s))
         end
+        sha1s[!in_cache]
+    finally
+        finalize(repo) # closing repo opened/created above
     end
-    Git.set_remote_url(url, dir=cache)
-    in_cache = Git.iscommit(sha1s, dir=cache)
-    if !all(in_cache)
-        info("Updating cache of $pkg...")
-        Git.success(`remote update`, dir=cache) ||
-        error("couldn't update $cache using `git remote update`")
-        in_cache = Git.iscommit(sha1s, dir=cache)
+end
+prefetch(pkg::AbstractString, url::AbstractString, sha1::AbstractString...) =
+    prefetch(pkg, url, AbstractString[sha1...])
+
+function setprotocol!(proto::AbstractString)
+    global rewrite_url_to
+
+    if length(proto) == 0
+        rewrite_url_to = nothing
+    else
+        rewrite_url_to = proto
     end
-    sha1s[!in_cache]
 end
-prefetch(pkg::AbstractString, url::AbstractString, sha1::AbstractString...) = prefetch(pkg, url, AbstractString[sha1...])
+
+function normalize_url(url::AbstractString)
+    global rewrite_url_to
+
+    m = match(GITHUB_REGEX,url)
+    (m === nothing || rewrite_url_to === nothing) ?
+        url : "$rewrite_url_to://github.com/$(m.captures[1]).git"
+
+end
 
 end # module
diff --git a/base/pkg/dir.jl b/base/pkg/dir.jl
index 0e253001fe96f..ef38251c99f88 100644
--- a/base/pkg/dir.jl
+++ b/base/pkg/dir.jl
@@ -2,8 +2,8 @@
 
 module Dir
 
-import ..Pkg: DEFAULT_META, META_BRANCH
-import ..Git
+import ..Pkg: DEFAULT_META, META_BRANCH, PkgError
+import ...LibGit2, ...LibGit2.with
 
 const DIR_NAME = ".julia"
 
@@ -26,56 +26,49 @@ function cd(f::Function, args...; kws...)
     metadata_dir = joinpath(dir, "METADATA")
     if !isdir(metadata_dir)
         !haskey(ENV,"JULIA_PKGDIR") ? init() :
-            error("Package metadata directory $metadata_dir doesn't exist; run Pkg.init() to initialize it.")
+            throw(PkgError("Package metadata directory $metadata_dir doesn't exist; run Pkg.init() to initialize it."))
     end
     Base.cd(()->f(args...; kws...), dir)
 end
 
 function init(meta::AbstractString=DEFAULT_META, branch::AbstractString=META_BRANCH)
-    if Git.version() < v"1.7.3"
-        warn("Pkg only works with git versions greater than v1.7.3")
-    end
     dir = path()
     info("Initializing package repository $dir")
     metadata_dir = joinpath(dir, "METADATA")
     if isdir(metadata_dir)
         info("Package directory $dir is already initialized.")
-        Git.set_remote_url(meta, dir=metadata_dir)
+        LibGit2.set_remote_url(metadata_dir, meta)
         return
     end
-    local temp_dir
+    local temp_dir = ""
     try
         mkpath(dir)
         temp_dir = mktempdir(dir)
         Base.cd(temp_dir) do
             info("Cloning METADATA from $meta")
-            run(`git clone -q -b $branch $meta METADATA`)
-            Git.set_remote_url(meta, dir="METADATA")
+            with(LibGit2.clone(meta, "METADATA", branch = branch)) do metadata_repo
+                LibGit2.set_remote_url(metadata_repo, meta)
+            end
             touch("REQUIRE")
             touch("META_BRANCH")
-            open("META_BRANCH", "w") do io
-                write(io, branch)
-                close(io)
-            end
+            write("META_BRANCH", branch)
         end
         #Move TEMP to METADATA
         Base.mv(joinpath(temp_dir,"METADATA"), metadata_dir)
         Base.mv(joinpath(temp_dir,"REQUIRE"), joinpath(dir,"REQUIRE"))
         Base.mv(joinpath(temp_dir,"META_BRANCH"), joinpath(dir,"META_BRANCH"))
         rm(temp_dir)
-    catch e
+    catch err
         ispath(metadata_dir) && rm(metadata_dir, recursive=true)
         ispath(temp_dir) && rm(temp_dir, recursive=true)
-        rethrow(e)
+        rethrow(err)
     end
 end
 
 function getmetabranch()
     try
-        open(joinpath(path(),"META_BRANCH")) do io
-          chomp(readuntil(io, "/n"))
-        end
-    catch
+        chomp(readline(joinpath(path(),"META_BRANCH")))
+    catch err
         META_BRANCH
     end
 end
diff --git a/base/pkg/entry.jl b/base/pkg/entry.jl
index 869fec4499e4f..15c8431b2a35c 100644
--- a/base/pkg/entry.jl
+++ b/base/pkg/entry.jl
@@ -3,7 +3,10 @@
 module Entry
 
 import Base: thispatch, nextpatch, nextminor, nextmajor, check_new_version
-import ..Git, ..Reqs, ..Read, ..Query, ..Resolve, ..Cache, ..Write, ..GitHub, ..Dir
+import ..Reqs, ..Read, ..Query, ..Resolve, ..Cache, ..Write, ..Dir
+import ...LibGit2
+importall ...LibGit2
+import ...Pkg.PkgError
 using ..Types
 
 macro recover(ex)
@@ -11,6 +14,7 @@ macro recover(ex)
         try $(esc(ex))
         catch err
             show(err)
+            print('\n')
         end
     end
 end
@@ -32,7 +36,7 @@ end
 function edit()
     editor = get(ENV,"VISUAL",get(ENV,"EDITOR",nothing))
     editor !== nothing ||
-        error("set the EDITOR environment variable to an edit command")
+        throw(PkgError("set the EDITOR environment variable to an edit command"))
     editor = Base.shell_split(editor)
     reqs = Reqs.parse("REQUIRE")
     run(`$editor REQUIRE`)
@@ -46,22 +50,23 @@ function add(pkg::AbstractString, vers::VersionSet)
     outdated = :maybe
     @sync begin
         @async if !edit(Reqs.add,pkg,vers)
-            ispath(pkg) || error("unknown package $pkg")
+            ispath(pkg) || throw(PkgError("unknown package $pkg"))
             info("Nothing to be done")
         end
         branch = Dir.getmetabranch()
-        if Git.branch(dir="METADATA") == branch
-            if !Git.success(`diff --quiet origin/$branch`, dir="METADATA")
-                outdated = :yes
-            else
-                try
-                    run(pipeline(Git.cmd(`fetch -q --all`, dir="METADATA"),stdout=DevNull,stderr=DevNull))
-                    outdated = Git.success(`diff --quiet origin/$branch`, dir="METADATA") ?
-                        (:no) : (:yes)
+        outdated = with(GitRepo, "METADATA") do repo
+            if LibGit2.branch(repo) == branch
+                if LibGit2.isdiff(repo, "origin/$branch")
+                    outdated = :yes
+                else
+                    try
+                        LibGit2.fetch(repo)
+                        outdated = LibGit2.isdiff(repo, "origin/$branch") ? (:yes) : (:no)
+                    end
                 end
+            else
+                :no # user is doing something funky with METADATA
             end
-        else
-            outdated = :no # user is doing something funky with METADATA
         end
     end
     if outdated != :no
@@ -93,7 +98,7 @@ function available(pkg::AbstractString)
     if !isempty(avail) || Read.isinstalled(pkg)
         return sort!(collect(keys(avail)))
     end
-    error("$pkg is not a package (not registered or installed)")
+    throw(PkgError("$pkg is not a package (not registered or installed)"))
 end
 
 function installed()
@@ -106,8 +111,16 @@ end
 
 function installed(pkg::AbstractString)
     avail = Read.available(pkg)
-    Read.isinstalled(pkg) && return Read.installed_version(pkg,avail)
-    isempty(avail) && error("$pkg is not a package (not registered or installed)")
+    if Read.isinstalled(pkg)
+        res = typemin(VersionNumber)
+        if ispath(joinpath(pkg,".git"))
+            LibGit2.with(GitRepo, pkg) do repo
+                res = Read.installed_version(pkg, repo, avail)
+            end
+        end
+        return res
+    end
+    isempty(avail) && throw(PkgError("$pkg is not a package (not registered or installed)"))
     return nothing # registered but not installed
 end
 
@@ -119,8 +132,12 @@ function status(io::IO; pkgname::AbstractString = "")
     if !isempty(required)
         showpkg("") && println(io, "$(length(required)) required packages:")
         for pkg in required
-            ver,fix = pop!(instd,pkg)
-            showpkg(pkg) && status(io,pkg,ver,fix)
+            if !haskey(instd, pkg)
+                showpkg(pkg) && status(io,pkg,"not found")
+            else
+                ver,fix = pop!(instd,pkg)
+                showpkg(pkg) && status(io,pkg,ver,fix)
+            end
         end
     end
     additional = sort!(collect(keys(instd)))
@@ -143,26 +160,44 @@ function status(io::IO, pkg::AbstractString, ver::VersionNumber, fix::Bool)
     fix || return println(io,ver)
     @printf io "%-19s" ver
     if ispath(pkg,".git")
-        print(io, Git.attached(dir=pkg) ? Git.branch(dir=pkg) : Git.head(dir=pkg)[1:8])
-        attrs = AbstractString[]
-        isfile("METADATA",pkg,"url") || push!(attrs,"unregistered")
-        Git.dirty(dir=pkg) && push!(attrs,"dirty")
-        isempty(attrs) || print(io, " (",join(attrs,", "),")")
+        prepo = GitRepo(pkg)
+        try
+            with(LibGit2.head(prepo)) do phead
+                if LibGit2.isattached(prepo)
+                    print(io, LibGit2.shortname(phead))
+                else
+                    print(io, string(LibGit2.Oid(phead))[1:8])
+                end
+            end
+            attrs = AbstractString[]
+            isfile("METADATA",pkg,"url") || push!(attrs,"unregistered")
+            LibGit2.isdirty(prepo) && push!(attrs,"dirty")
+            isempty(attrs) || print(io, " (",join(attrs,", "),")")
+        catch err
+            print_with_color(:red, io, " broken-repo (unregistered)")
+        finally
+            finalize(prepo)
+        end
     else
-        print(io, "non-repo (unregistered)")
+        print_with_color(:yellow, io, "non-repo (unregistered)")
     end
     println(io)
 end
 
+function status(io::IO, pkg::AbstractString, msg::AbstractString)
+    @printf io " - %-29s %-19s\n" pkg msg
+end
+
 function clone(url::AbstractString, pkg::AbstractString)
     info("Cloning $pkg from $url")
-    ispath(pkg) && error("$pkg already exists")
+    ispath(pkg) && throw(PkgError("$pkg already exists"))
     try
-        Git.run(`clone -q $url $pkg`)
-        Git.set_remote_url(url, dir=pkg)
-    catch
-        Base.rm(pkg, recursive=true)
-        rethrow()
+        LibGit2.with(LibGit2.clone(url, pkg)) do repo
+            LibGit2.set_remote_url(repo, url)
+        end
+    catch err
+        isdir(pkg) && Base.rm(pkg, recursive=true)
+        rethrow(err)
     end
     info("Computing changes...")
     if !edit(Reqs.add, pkg)
@@ -173,54 +208,59 @@ end
 
 function clone(url_or_pkg::AbstractString)
     urlpath = joinpath("METADATA",url_or_pkg,"url")
-    if isfile(urlpath)
+    if !(':' in url_or_pkg) && isfile(urlpath)
         pkg = url_or_pkg
         url = readchomp(urlpath)
         # TODO: Cache.prefetch(pkg,url)
     else
         url = url_or_pkg
         m = match(r"(?:^|[/\\])(\w+?)(?:\.jl)?(?:\.git)?$", url)
-        m !== nothing || error("can't determine package name from URL: $url")
+        m !== nothing || throw(PkgError("can't determine package name from URL: $url"))
         pkg = m.captures[1]
     end
     clone(url,pkg)
 end
 
-function _checkout(pkg::AbstractString, what::AbstractString, merge::Bool=false, pull::Bool=false, branch::Bool=false)
-    Git.transact(dir=pkg) do
-        Git.dirty(dir=pkg) && error("$pkg is dirty, bailing")
-        branch ? Git.run(`checkout -q -B $what -t origin/$what`, dir=pkg) : Git.run(`checkout -q $what`, dir=pkg)
-        merge && Git.run(`merge -q --ff-only $what`, dir=pkg)
-        if pull
-            info("Pulling $pkg latest $what...")
-            Git.run(`pull -q --ff-only`, dir=pkg)
+function checkout(pkg::AbstractString, branch::AbstractString, do_merge::Bool, do_pull::Bool)
+    ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo"))
+    info("Checking out $pkg $branch...")
+    with(GitRepo, pkg) do r
+        LibGit2.transact(r) do repo
+            LibGit2.isdirty(repo) && throw(PkgError("$pkg is dirty, bailing"))
+            LibGit2.branch!(repo, branch, track=LibGit2.Consts.REMOTE_ORIGIN)
+            do_merge && LibGit2.merge!(repo, fastforward=true) # merge changes
+            if do_pull
+                info("Pulling $pkg latest $branch...")
+                LibGit2.fetch(repo)
+                LibGit2.merge!(repo, fastforward=true)
+            end
+            resolve()
         end
-        resolve()
     end
 end
 
-function checkout(pkg::AbstractString, branch::AbstractString, merge::Bool, pull::Bool)
-    ispath(pkg,".git") || error("$pkg is not a git repo")
-    info("Checking out $pkg $branch...")
-    _checkout(pkg,branch,merge,pull,true)
-end
-
 function free(pkg::AbstractString)
-    ispath(pkg,".git") || error("$pkg is not a git repo")
-    Read.isinstalled(pkg) || error("$pkg cannot be freed – not an installed package")
+    ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo"))
+    Read.isinstalled(pkg) || throw(PkgError("$pkg cannot be freed – not an installed package"))
     avail = Read.available(pkg)
-    isempty(avail) && error("$pkg cannot be freed – not a registered package")
-    Git.dirty(dir=pkg) && error("$pkg cannot be freed – repo is dirty")
-    info("Freeing $pkg")
-    vers = sort!(collect(keys(avail)), rev=true)
-    while true
-        for ver in vers
-            sha1 = avail[ver].sha1
-            Git.iscommit(sha1, dir=pkg) || continue
-            return _checkout(pkg,sha1)
+    isempty(avail) && throw(PkgError("$pkg cannot be freed – not a registered package"))
+    with(GitRepo, pkg) do repo
+        LibGit2.isdirty(repo) && throw(PkgError("$pkg cannot be freed – repo is dirty"))
+        info("Freeing $pkg")
+        vers = sort!(collect(keys(avail)), rev=true)
+        while true
+            for ver in vers
+                sha1 = avail[ver].sha1
+                LibGit2.iscommit(sha1, repo) || continue
+                return LibGit2.transact(repo) do r
+                    LibGit2.isdirty(repo) && throw(PkgError("$pkg is dirty, bailing"))
+                    LibGit2.checkout!(repo, sha1)
+                    resolve()
+                end
+            end
+            isempty(Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail])) && continue
+            throw(PkgError("can't find any registered versions of $pkg to checkout"))
         end
-        isempty(Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail])) && continue
-        error("can't find any registered versions of $pkg to checkout")
     end
 end
 
@@ -231,14 +271,16 @@ function free(pkgs)
             Read.isinstalled(pkg) || error("$pkg cannot be freed – not an installed package")
             avail = Read.available(pkg)
             isempty(avail) && error("$pkg cannot be freed – not a registered package")
-            Git.dirty(dir=pkg) && error("$pkg cannot be freed – repo is dirty")
-            info("Freeing $pkg")
-            vers = sort!(collect(keys(avail)), rev=true)
-            for ver in vers
-                sha1 = avail[ver].sha1
-                Git.iscommit(sha1, dir=pkg) || continue
-                Git.run(`checkout -q $sha1`, dir=pkg)
-                break
+            with(GitRepo, pkg) do repo
+                LibGit2.isdirty(repo) && throw(PkgError("$pkg cannot be freed – repo is dirty"))
+                info("Freeing $pkg")
+                vers = sort!(collect(keys(avail)), rev=true)
+                for ver in vers
+                    sha1 = avail[ver].sha1
+                    LibGit2.iscommit(sha1, repo) || continue
+                    LibGit2.checkout!(repo, sha1)
+                    break
+                end
             end
             isempty(Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail])) && continue
             error("can't find any registered versions of $pkg to checkout")
@@ -249,63 +291,109 @@ function free(pkgs)
 end
 
 function pin(pkg::AbstractString, head::AbstractString)
-    ispath(pkg,".git") || error("$pkg is not a git repo")
-    branch = "pinned.$(head[1:8]).tmp"
-    rslv = (head != Git.head(dir=pkg))
-    info("Creating $pkg branch $branch")
-    Git.run(`checkout -q -B $branch $head`, dir=pkg)
-    rslv ? resolve() : nothing
+    ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo"))
+    should_resolve = true
+    with(GitRepo, pkg) do repo
+        id = if isempty(head) # get HEAD commit
+            LibGit2.head_oid(repo)
+        else
+            # no need to resolve, branch will be from HEAD
+            should_resolve = false
+            LibGit2.revparseid(repo, head)
+        end
+        commit = LibGit2.get(LibGit2.GitCommit, repo, id)
+        branch = "pinned.$(string(id)[1:8]).tmp"
+        info("Creating $pkg branch $branch")
+        try
+            ref = LibGit2.create_branch(repo, branch, commit)
+            finalize(ref)
+        finally
+            finalize(commit)
+        end
+    end
+    should_resolve && resolve()
+    nothing
 end
-pin(pkg::AbstractString) = pin(pkg,Git.head(dir=pkg))
+pin(pkg::AbstractString) = pin(pkg, "")
 
 function pin(pkg::AbstractString, ver::VersionNumber)
-    ispath(pkg,".git") || error("$pkg is not a git repo")
-    Read.isinstalled(pkg) || error("$pkg cannot be pinned – not an installed package".tmp)
+    ispath(pkg,".git") || throw(PkgError("$pkg is not a git repo"))
+    Read.isinstalled(pkg) || throw(PkgError("$pkg cannot be pinned – not an installed package"))
     avail = Read.available(pkg)
-    isempty(avail) && error("$pkg cannot be pinned – not a registered package".tmp)
-    haskey(avail,ver) || error("$pkg – $ver is not a registered version")
-    pin(pkg,avail[ver].sha1)
+    isempty(avail) && throw(PkgError("$pkg cannot be pinned – not a registered package"))
+    haskey(avail,ver) || throw(PkgError("$pkg – $ver is not a registered version"))
+    pin(pkg, avail[ver].sha1)
 end
 
 function update(branch::AbstractString)
     info("Updating METADATA...")
-    cd("METADATA") do
-        if Git.branch() != branch
-            Git.dirty() && error("METADATA is dirty and not on $branch, bailing")
-            Git.attached() || error("METADATA is detached not on $branch, bailing")
-            Git.run(`fetch -q --all`)
-            Git.run(`checkout -q HEAD^0`)
-            Git.run(`branch -f $branch refs/remotes/origin/$branch`)
-            Git.run(`checkout -q $branch`)
+    with(GitRepo, "METADATA") do repo
+        with(LibGit2.head(repo)) do h
+            if LibGit2.branch(h) != branch
+                if LibGit2.isdirty(repo)
+                    throw(PkgError("METADATA is dirty and not on $branch, bailing"))
+                end
+                if !LibGit2.isattached(repo)
+                    throw(PkgError("METADATA is detached not on $branch, bailing"))
+                end
+                LibGit2.fetch(repo)
+                LibGit2.checkout_head(repo)
+                LibGit2.branch!(repo, branch, track="refs/remotes/origin/$branch")
+                LibGit2.merge!(repo)
+            end
         end
-        # TODO: handle merge conflicts
-        Base.withenv("GIT_MERGE_AUTOEDIT"=>"no") do
-            Git.run(`pull --rebase -q`, out=DevNull)
+        LibGit2.fetch(repo)
+        ff_succeeded = LibGit2.merge!(repo, fastforward=true)
+        if !ff_succeeded
+            LibGit2.rebase!(repo, "origin/$branch")
         end
     end
     avail = Read.available()
     # this has to happen before computing free/fixed
-    for pkg in filter!(Read.isinstalled,collect(keys(avail)))
-        Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]])
+    for pkg in filter(Read.isinstalled, collect(keys(avail)))
+        try
+            Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]])
+        catch err
+            warn("Package $pkg: unable to update cache\n$(err.msg)")
+        end
     end
     instd = Read.installed(avail)
-    free = Read.free(instd)
+    free  = Read.free(instd)
     for (pkg,ver) in free
-        Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]])
+        Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a) in avail[pkg]])
     end
     fixed = Read.fixed(avail,instd)
     for (pkg,ver) in fixed
         ispath(pkg,".git") || continue
-        begin
-            if Git.attached(dir=pkg) && !Git.dirty(dir=pkg)
-                info("Updating $pkg...")
-                @recover begin
-                    Git.run(`fetch -q --all`, dir=pkg)
-                    Git.success(`pull -q --ff-only`, dir=pkg) # suppress output
+        with(GitRepo, pkg) do repo
+            if LibGit2.isattached(repo)
+                if LibGit2.isdirty(repo)
+                    warn("Package $pkg: skipping update (dirty)...")
+                else
+                    prev_sha = string(LibGit2.head_oid(repo))
+                    success = true
+                    try
+                        LibGit2.fetch(repo)
+                        LibGit2.merge!(repo, fastforward=true)
+                    catch err
+                        show(err)
+                        print('\n')
+                        success = false
+                    end
+                    if success
+                        post_sha = string(LibGit2.head_oid(repo))
+                        branch = LibGit2.branch(repo)
+                        info("Updating $pkg $branch...",
+                              prev_sha != post_sha ? " $(prev_sha[1:8]) → $(post_sha[1:8])" : "")
+                    end
                 end
             end
-            if haskey(avail,pkg)
+        end
+        if haskey(avail,pkg)
+            try
                 Cache.prefetch(pkg, Read.url(pkg), [a.sha1 for (v,a)=avail[pkg]])
+            catch err
+                warn("Package $pkg: unable to update cache\n$(err.msg)")
             end
         end
     end
@@ -315,84 +403,6 @@ function update(branch::AbstractString)
     updatehook(sort!(collect(keys(installed()))))
 end
 
-function pull_request(dir::AbstractString, commit::AbstractString="", url::AbstractString="")
-    commit = isempty(commit) ? Git.head(dir=dir) :
-        Git.readchomp(`rev-parse --verify $commit`, dir=dir)
-    isempty(url) && (url = Git.readchomp(`config remote.origin.url`, dir=dir))
-    m = match(Git.GITHUB_REGEX, url)
-    m === nothing && error("not a GitHub repo URL, can't make a pull request: $url")
-    owner, repo = m.captures[2:3]
-    user = GitHub.user()
-    info("Forking $owner/$repo to $user")
-    response = GitHub.fork(owner,repo)
-    fork = response["ssh_url"]
-    branch = "pull-request/$(commit[1:8])"
-    info("Pushing changes as branch $branch")
-    Git.run(`push -q $fork $commit:refs/heads/$branch`, dir=dir)
-    pr_url = "$(response["html_url"])/compare/$branch"
-    @osx? run(`open $pr_url`) : info("To create a pull-request, open:\n\n  $pr_url\n")
-end
-
-function submit(pkg::AbstractString, commit::AbstractString="")
-    urlpath = joinpath("METADATA",pkg,"url")
-    url = ispath(urlpath) ? readchomp(urlpath) : ""
-    pull_request(pkg, commit, url)
-end
-
-function publish(branch::AbstractString)
-    Git.branch(dir="METADATA") == branch ||
-        error("METADATA must be on $branch to publish changes")
-    Git.run(`fetch -q`, dir="METADATA")
-    ahead_remote, ahead_local = map(x->parse(Int,x),split(Git.readchomp(`rev-list --count --left-right origin/$branch...$branch`, dir="METADATA"),'\t'))
-    ahead_remote > 0 && error("METADATA is behind origin/$branch – run `Pkg.update()` before publishing")
-    ahead_local == 0 && error("There are no METADATA changes to publish")
-
-    tags = Dict{ByteString,Vector{ASCIIString}}()
-    Git.run(`update-index -q --really-refresh`, dir="METADATA")
-    cmd = `diff --name-only --diff-filter=AMR origin/$branch HEAD --`
-    for line in eachline(Git.cmd(cmd, dir="METADATA"))
-        path = chomp(line)
-        m = match(r"^(.+?)/versions/([^/]+)/sha1$", path)
-        m !== nothing && ismatch(Base.VERSION_REGEX, m.captures[2]) || continue
-        pkg, ver = m.captures; ver = convert(VersionNumber,ver)
-        sha1 = readchomp(joinpath("METADATA",path))
-        if Git.success(`cat-file -e origin/$branch:$path`, dir="METADATA")
-            old = Git.readchomp(`cat-file blob origin/$branch:$path`, dir="METADATA")
-            old == sha1 || error("$pkg v$ver SHA1 changed in METADATA – refusing to publish")
-        end
-        any(split(Git.readall(`tag --contains $sha1`, dir=pkg))) do tag
-            ver == convert(VersionNumber,tag) || return false
-            haskey(tags,pkg) || (tags[pkg] = ASCIIString[])
-            push!(tags[pkg], tag)
-            return true
-        end || error("$pkg v$ver is incorrectly tagged – $sha1 expected")
-    end
-    isempty(tags) && info("No new package versions to publish")
-    info("Validating METADATA")
-    check_metadata(Set(keys(tags)))
-    @sync for pkg in sort!(collect(keys(tags)))
-        @async begin
-            forced = ASCIIString[]
-            unforced = ASCIIString[]
-            for tag in tags[pkg]
-                ver = convert(VersionNumber,tag)
-                push!(isrewritable(ver) ? forced : unforced, tag)
-            end
-            if !isempty(forced)
-                info("Pushing $pkg temporary tags: ", join(forced,", "))
-                refspecs = ["refs/tags/$tag:refs/tags/$tag" for tag in forced]
-                Git.run(`push -q --force origin $refspecs`, dir=pkg)
-            end
-            if !isempty(unforced)
-                info("Pushing $pkg permanent tags: ", join(unforced,", "))
-                refspecs = ["refs/tags/$tag:refs/tags/$tag" for tag in unforced]
-                Git.run(`push -q origin $refspecs`, dir=pkg)
-            end
-        end
-    end
-    info("Submitting METADATA changes")
-    pull_request("METADATA")
-end
 
 function resolve(
     reqs  :: Dict = Reqs.parse("REQUIRE"),
@@ -407,11 +417,11 @@ function resolve(
     for pkg in keys(reqs)
         if !haskey(deps,pkg)
             if "julia" in conflicts[pkg]
-                error("$pkg can't be installed because it has no versions that support ", VERSION, " of julia. " *
-                   "You may need to update METADATA by running `Pkg.update()`")
+                throw(PkgError("$pkg can't be installed because it has no versions that support $VERSION of julia. " *
+                   "You may need to update METADATA by running `Pkg.update()`"))
             else
-                error("$pkg's requirements can't be satisfied because of the following fixed packages: ",
-                   join(conflicts[pkg], ", ", " and "))
+                sconflicts = join(conflicts[pkg], ", ", " and ")
+                throw(PkgError("$pkg's requirements can't be satisfied because of the following fixed packages: $sconflicts"))
             end
         end
     end
@@ -429,7 +439,7 @@ function resolve(
     missing = []
     for (pkg,(ver1,ver2)) in changes
         vers = ASCIIString[]
-        ver1 !== nothing && push!(vers,Git.head(dir=pkg))
+        ver1 !== nothing && push!(vers,LibGit2.head(pkg))
         ver2 !== nothing && push!(vers,Read.sha1(pkg,ver2))
         append!(missing,
             map(sha1->(pkg,(ver1,ver2),sha1),
@@ -440,7 +450,7 @@ function resolve(
         for (pkg,ver,sha1) in missing
             msg *= "  $pkg v$ver [$sha1[1:10]]\n"
         end
-        error(msg)
+        throw(PkgError(msg))
     end
 
     # try applying changes, roll back everything if anything fails
@@ -460,7 +470,7 @@ function resolve(
             end
             push!(changed,(pkg,(ver1,ver2)))
         end
-    catch
+    catch err
         for (pkg,(ver1,ver2)) in reverse!(changed)
             if ver1 === nothing
                 info("Rolling back install of $pkg")
@@ -473,172 +483,14 @@ function resolve(
                 @recover Write.update(pkg, Read.sha1(pkg,ver1))
             end
         end
-        rethrow()
+        rethrow(err)
     end
     # re/build all updated/installed packages
     build(map(x->x[1], filter(x -> x[2][2] !== nothing, changes)))
 end
 
-function write_tag_metadata(pkg::AbstractString, ver::VersionNumber, commit::AbstractString, force::Bool=false)
-    cmd = Git.cmd(`cat-file blob $commit:REQUIRE`, dir=pkg)
-    reqs = success(cmd) ? Reqs.read(cmd) : Reqs.Line[]
-    cd("METADATA") do
-        d = joinpath(pkg,"versions",string(ver))
-        mkpath(d)
-        sha1file = joinpath(d,"sha1")
-        if !force && ispath(sha1file)
-            current = readchomp(sha1file)
-            current == commit ||
-                error("$pkg v$ver is already registered as $current, bailing")
-        end
-        open(io->println(io,commit), sha1file, "w")
-        Git.run(`add $sha1file`)
-        reqsfile = joinpath(d,"requires")
-        if isempty(reqs)
-            ispath(reqsfile) && Git.run(`rm -f -q $reqsfile`)
-        else
-            Reqs.write(reqsfile,reqs)
-            Git.run(`add $reqsfile`)
-        end
-    end
-    return nothing
-end
-
-function register(pkg::AbstractString, url::AbstractString)
-    ispath(pkg,".git") || error("$pkg is not a git repo")
-    isfile("METADATA",pkg,"url") && error("$pkg already registered")
-    tags = split(Git.readall(`tag -l v*`, dir=pkg))
-    filter!(tag->ismatch(Base.VERSION_REGEX,tag), tags)
-    versions = [
-        convert(VersionNumber,tag) =>
-        Git.readchomp(`rev-parse --verify $tag^{commit}`, dir=pkg)
-        for tag in tags
-    ]
-    Git.transact(dir="METADATA") do
-        cd("METADATA") do
-            info("Registering $pkg at $url")
-            mkdir(pkg)
-            path = joinpath(pkg,"url")
-            open(io->println(io,url), path, "w")
-            Git.run(`add $path`)
-        end
-        vers = sort!(collect(keys(versions)))
-        for ver in vers
-            info("Tagging $pkg v$ver")
-            write_tag_metadata(pkg,ver,versions[ver])
-        end
-        if Git.staged(dir="METADATA")
-            info("Committing METADATA for $pkg")
-            msg = "Register $pkg"
-            if !isempty(versions)
-                msg *= ": $(join(map(v->"v$v", vers),", "))"
-            end
-            Git.run(`commit -q -m $msg -- $pkg`, dir="METADATA")
-        else
-            info("No METADATA changes to commit")
-        end
-    end
-end
-
-function register(pkg::AbstractString)
-    Git.success(`config remote.origin.url`, dir=pkg) ||
-        error("$pkg: no URL configured")
-    url = Git.readchomp(`config remote.origin.url`, dir=pkg)
-    register(pkg,Git.normalize_url(url))
-end
-
-function isrewritable(v::VersionNumber)
-    thispatch(v)==v"0" ||
-    length(v.prerelease)==1 && isempty(v.prerelease[1]) ||
-    length(v.build)==1 && isempty(v.build[1])
-end
-
-nextbump(v::VersionNumber) = isrewritable(v) ? v : nextpatch(v)
-
-function tag(pkg::AbstractString, ver::Union{Symbol,VersionNumber}, force::Bool=false, commit::AbstractString="HEAD")
-    ispath(pkg,".git") || error("$pkg is not a git repo")
-    Git.dirty(dir=pkg) &&
-        error("$pkg is dirty – commit or stash changes to tag")
-    Git.dirty(pkg, dir="METADATA") &&
-        error("METADATA/$pkg is dirty – commit or stash changes to tag")
-    commit = Git.readchomp(`rev-parse $commit`, dir=pkg)
-    registered = isfile("METADATA",pkg,"url")
-    if !force
-        if registered
-            avail = Read.available(pkg)
-            existing = VersionNumber[keys(Read.available(pkg))...]
-            ancestors = filter(v->Git.is_ancestor_of(avail[v].sha1,commit,dir=pkg), existing)
-        else
-            tags = split(Git.readall(`tag -l v*`, dir=pkg))
-            filter!(tag->ismatch(Base.VERSION_REGEX,tag), tags)
-            existing = VersionNumber[tags...]
-            filter!(tags) do tag
-                sha1 = Git.readchomp(`rev-parse --verify $tag^{commit}`, dir=pkg)
-                Git.is_ancestor_of(sha1,commit,dir=pkg)
-            end
-            ancestors = VersionNumber[tags...]
-        end
-        sort!(existing)
-        if isa(ver,Symbol)
-            prv = isempty(existing) ? v"0" :
-                  isempty(ancestors) ? maximum(existing) : maximum(ancestors)
-            ver = (ver == :bump ) ? nextbump(prv)  :
-                  (ver == :patch) ? nextpatch(prv) :
-                  (ver == :minor) ? nextminor(prv) :
-                  (ver == :major) ? nextmajor(prv) :
-                                    error("invalid version selector: $ver")
-        end
-        isrewritable(ver) && filter!(v->v!=ver,existing)
-        check_new_version(existing,ver)
-    end
-    # TODO: check that SHA1 isn't the same as another version
-    info("Tagging $pkg v$ver")
-    opts = ``
-    if force || isrewritable(ver)
-        opts = `$opts --force`
-    end
-    if !isrewritable(ver)
-        opts = `$opts --annotate --message "$pkg v$ver [$(commit[1:10])]"`
-    end
-    Git.run(`tag $opts v$ver $commit`, dir=pkg, out=DevNull)
-    registered || return
-    try
-        Git.transact(dir="METADATA") do
-            write_tag_metadata(pkg,ver,commit,force)
-            if Git.staged(dir="METADATA")
-                info("Committing METADATA for $pkg")
-                Git.run(`commit -q -m "Tag $pkg v$ver" -- $pkg`, dir="METADATA")
-            else
-                info("No METADATA changes to commit")
-            end
-        end
-    catch
-        Git.run(`tag -d v$ver`, dir=pkg)
-        rethrow()
-    end
-end
-
-function check_metadata(pkgs::Set{ByteString} = Set{ByteString}())
-    avail = Read.available()
-    deps, conflicts = Query.dependencies(avail)
-
-    for (dp,dv) in deps, (v,a) in dv, p in keys(a.requires)
-        haskey(deps, p) || error("package $dp v$v requires a non-registered package: $p")
-    end
-
-    problematic = Resolve.sanity_check(deps, pkgs)
-    if !isempty(problematic)
-        msg = "packages with unsatisfiable requirements found:\n"
-        for (p, vn, rp) in problematic
-            msg *= "    $p v$vn – no valid versions exist for package $rp\n"
-        end
-        error(msg)
-    end
-    return
-end
-
 function warnbanner(msg...; label="[ WARNING ]", prefix="")
-    cols = Base.tty_size()[2]
+    cols = Base.displaysize(STDERR)[2]
     warn(prefix="", Base.cpad(label,cols,"="))
     println(STDERR)
     warn(prefix=prefix, msg...)
@@ -646,22 +498,73 @@ function warnbanner(msg...; label="[ WARNING ]", prefix="")
     warn(prefix="", "="^cols)
 end
 
-function build!(pkgs::Vector, errs::Dict, seen::Set=Set())
+function build!(pkgs::Vector, buildstream::IO, seen::Set)
     for pkg in pkgs
         pkg == "julia" && continue
         pkg in seen && continue
-        build!(Read.requires_list(pkg),errs,push!(seen,pkg))
-        Read.isinstalled(pkg) || error("$pkg is not an installed package")
+        build!(Read.requires_list(pkg),buildstream,push!(seen,pkg))
+        Read.isinstalled(pkg) || throw(PkgError("$pkg is not an installed package"))
         path = abspath(pkg,"deps","build.jl")
         isfile(path) || continue
-        info("Building $pkg")
-        cd(dirname(path)) do
-            try evalfile(path)
-            catch err
-                warnbanner(err, label="[ ERROR: $pkg ]")
+        println(buildstream, path) # send to build process for evalfile
+        flush(buildstream)
+    end
+end
+
+function build!(pkgs::Vector, errs::Dict, seen::Set=Set())
+    # To isolate the build from the running Julia process, we
+    # execute the build.jl files in a separate process that
+    # is sitting there waiting for paths to evaluate.   Errors
+    # are serialized to errfile for later retrieval into errs[pkg]
+    errfile = tempname()
+    close(open(errfile, "w")) # create empty file
+    code = """
+        empty!(Base.LOAD_PATH)
+        append!(Base.LOAD_PATH, $(repr(Base.LOAD_PATH)))
+        empty!(Base.LOAD_CACHE_PATH)
+        append!(Base.LOAD_CACHE_PATH, $(repr(Base.LOAD_CACHE_PATH)))
+        empty!(Base.DL_LOAD_PATH)
+        append!(Base.DL_LOAD_PATH, $(repr(Base.DL_LOAD_PATH)))
+        open("$(escape_string(errfile))", "a") do f
+            for path_ in eachline(STDIN)
+                path = chomp(path_)
+                pkg = basename(dirname(dirname(path)))
+                try
+                    info("Building \$pkg")
+                    cd(dirname(path)) do
+                        evalfile(path)
+                    end
+                catch err
+                    Base.Pkg.Entry.warnbanner(err, label="[ ERROR: \$pkg ]")
+                    serialize(f, pkg)
+                    serialize(f, err)
+                end
+            end
+        end
+    """
+    io, pobj = open(pipeline(detach(`$(Base.julia_cmd())
+                                    --compilecache=$(Bool(Base.JLOptions().use_compilecache) ? "yes" : "no")
+                                    --history-file=no
+                                    --color=$(Base.have_color ? "yes" : "no")
+                                    --eval $code`), stderr=STDERR), "w", STDOUT)
+    try
+        build!(pkgs, io, seen)
+        close(io)
+        wait(pobj)
+        success(pobj) || error("Build process failed.")
+        open(errfile, "r") do f
+            while !eof(f)
+                pkg = deserialize(f)
+                err = deserialize(f)
                 errs[pkg] = err
             end
         end
+    catch err
+        kill(pobj)
+        close(io)
+        rethrow(err)
+    finally
+        isfile(errfile) && Base.rm(errfile)
     end
 end
 
@@ -710,7 +613,10 @@ function updatehook(pkgs::Vector)
     """)
 end
 
-function test!(pkg::AbstractString, errs::Vector{AbstractString}, notests::Vector{AbstractString}; coverage::Bool=false)
+function test!(pkg::AbstractString,
+               errs::Vector{AbstractString},
+               nopkgs::Vector{AbstractString},
+               notests::Vector{AbstractString}; coverage::Bool=false)
     reqs_path = abspath(pkg,"test","REQUIRE")
     if isfile(reqs_path)
         tests_require = Reqs.parse(reqs_path)
@@ -720,13 +626,17 @@ function test!(pkg::AbstractString, errs::Vector{AbstractString}, notests::Vecto
         end
     end
     test_path = abspath(pkg,"test","runtests.jl")
-    if isfile(test_path)
+    if !isdir(pkg)
+        push!(nopkgs, pkg)
+    elseif !isfile(test_path)
+        push!(notests, pkg)
+    else
         info("Testing $pkg")
         cd(dirname(test_path)) do
             try
                 color = Base.have_color? "--color=yes" : "--color=no"
                 codecov = coverage? ["--code-coverage=user", "--inline=no"] : ["--code-coverage=none"]
-                julia_exe = joinpath(JULIA_HOME, Base.julia_exename())
+                julia_exe = Base.julia_cmd()
                 run(`$julia_exe --check-bounds=yes $codecov $color $test_path`)
                 info("$pkg tests passed")
             catch err
@@ -734,23 +644,31 @@ function test!(pkg::AbstractString, errs::Vector{AbstractString}, notests::Vecto
                 push!(errs,pkg)
             end
         end
-    else
-        push!(notests,pkg)
     end
     isfile(reqs_path) && resolve()
 end
 
 function test(pkgs::Vector{AbstractString}; coverage::Bool=false)
     errs = AbstractString[]
+    nopkgs = AbstractString[]
     notests = AbstractString[]
     for pkg in pkgs
-        test!(pkg,errs,notests; coverage=coverage)
+        test!(pkg,errs,nopkgs,notests; coverage=coverage)
     end
-    if !isempty(errs) || !isempty(notests)
+    if !all(isempty, (errs, nopkgs, notests))
         messages = AbstractString[]
-        isempty(errs) || push!(messages, "$(join(errs,", "," and ")) had test errors")
-        isempty(notests) || push!(messages, "$(join(notests,", "," and ")) did not provide a test/runtests.jl file")
-        error(join(messages, "and"))
+        if !isempty(errs)
+            push!(messages, "$(join(errs,", "," and ")) had test errors")
+        end
+        if !isempty(nopkgs)
+            msg = length(nopkgs) > 1 ? " are not installed packages" :
+                                       " is not an installed package"
+            push!(messages, string(join(nopkgs,", ", " and "), msg))
+        end
+        if !isempty(notests)
+            push!(messages, "$(join(notests,", "," and ")) did not provide a test/runtests.jl file")
+        end
+        throw(PkgError(join(messages, "and")))
     end
 end
 
diff --git a/base/pkg/generate.jl b/base/pkg/generate.jl
deleted file mode 100644
index 3076878bdf642..0000000000000
--- a/base/pkg/generate.jl
+++ /dev/null
@@ -1,518 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-module Generate
-
-import ..Git, ..Read
-
-copyright_year() = readchomp(`date +%Y`)
-copyright_name(dir::AbstractString) = readchomp(Git.cmd(`config --get user.name`, dir=dir))
-github_user() = readchomp(ignorestatus(`git config --global --get github.user`))
-
-function git_contributors(dir::AbstractString, n::Int=typemax(Int))
-    contrib = Dict()
-    tty = @windows? "CON:" : "/dev/tty"
-    for line in eachline(pipeline(tty, Git.cmd(`shortlog -nes`, dir=dir)))
-        m = match(r"\s*(\d+)\s+(.+?)\s+\<(.+?)\>\s*$", line)
-        m === nothing && continue
-        commits, name, email = m.captures
-        if haskey(contrib,email)
-            contrib[email][1] += parse(Int,commits)
-        else
-            contrib[email] = [parse(Int,commits), name]
-        end
-    end
-    names = Dict()
-    for (commits,name) in values(contrib)
-        names[name] = get(names,name,0) + commits
-    end
-    names = sort!(collect(keys(names)),by=name->names[name],rev=true)
-    length(names) <= n ? names : [names[1:n]; "et al."]
-end
-
-function package(
-    pkg::AbstractString,
-    license::AbstractString;
-    force::Bool = false,
-    authors::Union{AbstractString,Array} = "",
-    years::Union{Int,AbstractString} = copyright_year(),
-    user::AbstractString = github_user(),
-    config::Dict = Dict(),
-)
-    isnew = !ispath(pkg)
-    try
-        if isnew
-            url = isempty(user) ? "" : "git://github.com/$user/$pkg.jl.git"
-            Generate.init(pkg,url,config=config)
-        else
-            Git.dirty(dir=pkg) && error("$pkg is dirty – commit or stash your changes")
-        end
-
-        Git.transact(dir=pkg) do
-            if isempty(authors)
-                authors = isnew ? copyright_name(pkg) : git_contributors(pkg,5)
-            end
-            Generate.license(pkg,license,years,authors,force=force)
-            Generate.readme(pkg,user,force=force)
-            Generate.entrypoint(pkg,force=force)
-            Generate.tests(pkg,force=force)
-            Generate.require(pkg,force=force)
-            Generate.travis(pkg,force=force)
-            Generate.appveyor(pkg,force=force)
-            Generate.gitignore(pkg,force=force)
-
-            msg = """
-            $pkg.jl $(isnew ? "generated" : "regenerated") files.
-
-                license:  $license
-                authors:  $(join(vcat(authors),", "))
-                years:    $years
-                user:     $user
-
-            Julia Version $VERSION [$(Base.GIT_VERSION_INFO.commit_short)]
-            """
-
-            if isnew
-                info("Committing $pkg generated files")
-                Git.run(`commit -q -m $msg`, dir=pkg)
-            elseif Git.dirty(dir=pkg)
-                Git.run(`reset -q --`, dir=pkg)
-                info("Regenerated files left unstaged, use `git add -p` to select")
-                open(io->print(io,msg), joinpath(Git.dir(pkg),"MERGE_MSG"), "w")
-            else
-                info("Regenerated files are unchanged")
-            end
-        end
-    catch
-        isnew && rm(pkg, recursive=true)
-        rethrow()
-    end
-end
-
-function init(pkg::AbstractString, url::AbstractString=""; config::Dict=Dict())
-    if !ispath(pkg)
-        info("Initializing $pkg repo: $(abspath(pkg))")
-        Git.run(`init -q $pkg`)
-
-        for (key,val) in config
-            Git.run(`config $key $val`, dir=pkg)
-        end
-        Git.run(`commit -q --allow-empty -m "initial empty commit"`, dir=pkg)
-    end
-    isempty(url) && return
-    info("Origin: $url")
-    Git.run(`remote add origin $url`,dir=pkg)
-    Git.set_remote_url(url,dir=pkg)
-    Git.run(`config branch.master.remote origin`, dir=pkg)
-    Git.run(`config branch.master.merge refs/heads/master`, dir=pkg)
-end
-
-function license(pkg::AbstractString, license::AbstractString,
-                 years::Union{Int,AbstractString},
-                 authors::Union{AbstractString,Array};
-                 force::Bool=false)
-    genfile(pkg,"LICENSE.md",force) do io
-        if !haskey(LICENSES,license)
-            licenses = join(sort!(collect(keys(LICENSES)), by=lowercase), ", ")
-            error("$license is not a known license choice, choose one of: $licenses.")
-        end
-        print(io, LICENSES[license](pkg, string(years), authors))
-    end || info("License file exists, leaving unmodified; use `force=true` to overwrite")
-end
-
-function readme(pkg::AbstractString, user::AbstractString=""; force::Bool=false)
-    genfile(pkg,"README.md",force) do io
-        println(io, "# $pkg")
-        isempty(user) && return
-        url = "https://travis-ci.org/$user/$pkg.jl"
-        println(io, "\n[![Build Status]($url.svg?branch=master)]($url)")
-    end
-end
-
-function tests(pkg::AbstractString; force::Bool=false)
-    genfile(pkg,"test/runtests.jl",force) do io
-        print(io, """
-        using $pkg
-        using Base.Test
-
-        # write your own tests here
-        @test 1 == 1
-        """)
-    end
-end
-
-function versionfloor(ver::VersionNumber)
-    # return "major.minor" for the most recent release version relative to ver
-    # for prereleases with ver.minor == ver.patch == 0, return "major-" since we
-    # don't know what the most recent minor version is for the previous major
-    if isempty(ver.prerelease) || ver.patch > 0
-        return string(ver.major, '.', ver.minor)
-    elseif ver.minor > 0
-        return string(ver.major, '.', ver.minor - 1)
-    else
-        return string(ver.major, '-')
-    end
-end
-
-function require(pkg::AbstractString; force::Bool=false)
-    genfile(pkg,"REQUIRE",force) do io
-        print(io, """
-        julia $(versionfloor(VERSION))
-        """)
-    end
-end
-
-function travis(pkg::AbstractString; force::Bool=false)
-    genfile(pkg,".travis.yml",force) do io
-        print(io, """
-        # Documentation: http://docs.travis-ci.com/user/languages/julia/
-        language: julia
-        os:
-          - linux
-          - osx
-        julia:
-          - release
-          - nightly
-        notifications:
-          email: false
-        # uncomment the following lines to override the default test script
-        #script:
-        #  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-        #  - julia -e 'Pkg.clone(pwd()); Pkg.build("$pkg"); Pkg.test("$pkg"; coverage=true)'
-        """)
-    end
-end
-
-function appveyor(pkg::AbstractString; force::Bool=false)
-    vf = versionfloor(VERSION)
-    if vf[end] == '-' # don't know what previous release was
-        vf = string(VERSION.major, '.', VERSION.minor)
-        rel32 = "#  - JULIAVERSION: \"julialang/bin/winnt/x86/$vf/julia-$vf-latest-win32.exe\""
-        rel64 = "#  - JULIAVERSION: \"julialang/bin/winnt/x64/$vf/julia-$vf-latest-win64.exe\""
-    else
-        rel32 = "  - JULIAVERSION: \"julialang/bin/winnt/x86/$vf/julia-$vf-latest-win32.exe\""
-        rel64 = "  - JULIAVERSION: \"julialang/bin/winnt/x64/$vf/julia-$vf-latest-win64.exe\""
-    end
-    genfile(pkg,"appveyor.yml",force) do io
-        print(io, """
-        environment:
-          matrix:
-        $rel32
-        $rel64
-          - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
-          - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
-
-        branches:
-          only:
-            - master
-            - /release-.*/
-
-        notifications:
-          - provider: Email
-            on_build_success: false
-            on_build_failure: false
-            on_build_status_changed: false
-
-        install:
-        # Download most recent Julia Windows binary
-          - ps: (new-object net.webclient).DownloadFile(
-                \$("http://s3.amazonaws.com/"+\$env:JULIAVERSION),
-                "C:\\projects\\julia-binary.exe")
-        # Run installer silently, output to C:\\projects\\julia
-          - C:\\projects\\julia-binary.exe /S /D=C:\\projects\\julia
-
-        build_script:
-        # Need to convert from shallow to complete for Pkg.clone to work
-          - IF EXIST .git\\shallow (git fetch --unshallow)
-          - C:\\projects\\julia\\bin\\julia -e "versioninfo();
-              Pkg.clone(pwd(), \\"$pkg\\"); Pkg.build(\\"$pkg\\")"
-
-        test_script:
-          - C:\\projects\\julia\\bin\\julia --check-bounds=yes -e "Pkg.test(\\"$pkg\\")"
-        """)
-    end
-end
-
-function gitignore(pkg::AbstractString; force::Bool=false)
-    genfile(pkg,".gitignore",force) do io
-        print(io, """
-        *.jl.cov
-        *.jl.*.cov
-        *.jl.mem
-        """)
-    end
-end
-
-function entrypoint(pkg::AbstractString; force::Bool=false)
-    genfile(pkg,"src/$pkg.jl",force) do io
-        print(io, """
-        module $pkg
-
-        # package code goes here
-
-        end # module
-        """)
-    end
-end
-
-function genfile(f::Function, pkg::AbstractString, file::AbstractString, force::Bool=false)
-    path = joinpath(pkg,file)
-    if force || !ispath(path)
-        info("Generating $file")
-        mkpath(dirname(path))
-        open(f, path, "w")
-        Git.run(`add -f $file`, dir=pkg)
-        return true
-    end
-    return false
-end
-
-copyright(years::AbstractString, authors::AbstractString) = "> Copyright (c) $years: $authors."
-
-function copyright(years::AbstractString, authors::Array)
-    text = "> Copyright (c) $years:"
-    for author in authors
-        text *= "\n>  * $author"
-    end
-    return text
-end
-
-mit(pkg::AbstractString, years::AbstractString, authors::Union{AbstractString,Array}) =
-"""
-The $pkg.jl package is licensed under the MIT "Expat" License:
-
-$(copyright(years,authors))
->
-> Permission is hereby granted, free of charge, to any person obtaining
-> a copy of this software and associated documentation files (the
-> "Software"), to deal in the Software without restriction, including
-> without limitation the rights to use, copy, modify, merge, publish,
-> distribute, sublicense, and/or sell copies of the Software, and to
-> permit persons to whom the Software is furnished to do so, subject to
-> the following conditions:
->
-> The above copyright notice and this permission notice shall be
-> included in all copies or substantial portions of the Software.
->
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-"""
-
-bsd(pkg::AbstractString, years::AbstractString, authors::Union{AbstractString,Array}) =
-"""
-The $pkg.jl package is licensed under the Simplified "2-clause" BSD License:
-
-$(copyright(years,authors))
->
-> Redistribution and use in source and binary forms, with or without
-> modification, are permitted provided that the following conditions are
-> met:
->
-> 1. Redistributions of source code must retain the above copyright
->    notice, this list of conditions and the following disclaimer.
-> 2. Redistributions in binary form must reproduce the above copyright
->    notice, this list of conditions and the following disclaimer in the
->    documentation and/or other materials provided with the distribution.
->
-> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-> "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-> LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-> A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-> OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-> SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-> LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-> DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-> THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-> (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-asl(pkg::AbstractString, years::AbstractString, authors::Union{AbstractString,Array}) =
-"""
-The $pkg.jl package is licensed under version 2.0 of the Apache License:
-
-$(copyright(years,authors))
->
->                                 Apache License
->                           Version 2.0, January 2004
->                        http://www.apache.org/licenses/
->
->   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
->
->   1. Definitions.
->
->      "License" shall mean the terms and conditions for use, reproduction,
->      and distribution as defined by Sections 1 through 9 of this document.
->
->      "Licensor" shall mean the copyright owner or entity authorized by
->      the copyright owner that is granting the License.
->
->      "Legal Entity" shall mean the union of the acting entity and all
->      other entities that control, are controlled by, or are under common
->      control with that entity. For the purposes of this definition,
->      "control" means (i) the power, direct or indirect, to cause the
->      direction or management of such entity, whether by contract or
->      otherwise, or (ii) ownership of fifty percent (50%) or more of the
->      outstanding shares, or (iii) beneficial ownership of such entity.
->
->      "You" (or "Your") shall mean an individual or Legal Entity
->      exercising permissions granted by this License.
->
->      "Source" form shall mean the preferred form for making modifications,
->      including but not limited to software source code, documentation
->      source, and configuration files.
->
->      "Object" form shall mean any form resulting from mechanical
->      transformation or translation of a Source form, including but
->      not limited to compiled object code, generated documentation,
->      and conversions to other media types.
->
->      "Work" shall mean the work of authorship, whether in Source or
->      Object form, made available under the License, as indicated by a
->      copyright notice that is included in or attached to the work
->      (an example is provided in the Appendix below).
->
->      "Derivative Works" shall mean any work, whether in Source or Object
->      form, that is based on (or derived from) the Work and for which the
->      editorial revisions, annotations, elaborations, or other modifications
->      represent, as a whole, an original work of authorship. For the purposes
->      of this License, Derivative Works shall not include works that remain
->      separable from, or merely link (or bind by name) to the interfaces of,
->      the Work and Derivative Works thereof.
->
->      "Contribution" shall mean any work of authorship, including
->      the original version of the Work and any modifications or additions
->      to that Work or Derivative Works thereof, that is intentionally
->      submitted to Licensor for inclusion in the Work by the copyright owner
->      or by an individual or Legal Entity authorized to submit on behalf of
->      the copyright owner. For the purposes of this definition, "submitted"
->      means any form of electronic, verbal, or written communication sent
->      to the Licensor or its representatives, including but not limited to
->      communication on electronic mailing lists, source code control systems,
->      and issue tracking systems that are managed by, or on behalf of, the
->      Licensor for the purpose of discussing and improving the Work, but
->      excluding communication that is conspicuously marked or otherwise
->      designated in writing by the copyright owner as "Not a Contribution."
->
->      "Contributor" shall mean Licensor and any individual or Legal Entity
->      on behalf of whom a Contribution has been received by Licensor and
->      subsequently incorporated within the Work.
->
->   2. Grant of Copyright License. Subject to the terms and conditions of
->      this License, each Contributor hereby grants to You a perpetual,
->      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
->      copyright license to reproduce, prepare Derivative Works of,
->      publicly display, publicly perform, sublicense, and distribute the
->      Work and such Derivative Works in Source or Object form.
->
->   3. Grant of Patent License. Subject to the terms and conditions of
->      this License, each Contributor hereby grants to You a perpetual,
->      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
->      (except as stated in this section) patent license to make, have made,
->      use, offer to sell, sell, import, and otherwise transfer the Work,
->      where such license applies only to those patent claims licensable
->      by such Contributor that are necessarily infringed by their
->      Contribution(s) alone or by combination of their Contribution(s)
->      with the Work to which such Contribution(s) was submitted. If You
->      institute patent litigation against any entity (including a
->      cross-claim or counterclaim in a lawsuit) alleging that the Work
->      or a Contribution incorporated within the Work constitutes direct
->      or contributory patent infringement, then any patent licenses
->      granted to You under this License for that Work shall terminate
->      as of the date such litigation is filed.
->
->   4. Redistribution. You may reproduce and distribute copies of the
->      Work or Derivative Works thereof in any medium, with or without
->      modifications, and in Source or Object form, provided that You
->      meet the following conditions:
->
->      (a) You must give any other recipients of the Work or
->          Derivative Works a copy of this License; and
->
->      (b) You must cause any modified files to carry prominent notices
->          stating that You changed the files; and
->
->      (c) You must retain, in the Source form of any Derivative Works
->          that You distribute, all copyright, patent, trademark, and
->          attribution notices from the Source form of the Work,
->          excluding those notices that do not pertain to any part of
->          the Derivative Works; and
->
->      (d) If the Work includes a "NOTICE" text file as part of its
->          distribution, then any Derivative Works that You distribute must
->          include a readable copy of the attribution notices contained
->          within such NOTICE file, excluding those notices that do not
->          pertain to any part of the Derivative Works, in at least one
->          of the following places: within a NOTICE text file distributed
->          as part of the Derivative Works; within the Source form or
->          documentation, if provided along with the Derivative Works; or,
->          within a display generated by the Derivative Works, if and
->          wherever such third-party notices normally appear. The contents
->          of the NOTICE file are for informational purposes only and
->          do not modify the License. You may add Your own attribution
->          notices within Derivative Works that You distribute, alongside
->          or as an addendum to the NOTICE text from the Work, provided
->          that such additional attribution notices cannot be construed
->          as modifying the License.
->
->      You may add Your own copyright statement to Your modifications and
->      may provide additional or different license terms and conditions
->      for use, reproduction, or distribution of Your modifications, or
->      for any such Derivative Works as a whole, provided Your use,
->      reproduction, and distribution of the Work otherwise complies with
->      the conditions stated in this License.
->
->   5. Submission of Contributions. Unless You explicitly state otherwise,
->      any Contribution intentionally submitted for inclusion in the Work
->      by You to the Licensor shall be under the terms and conditions of
->      this License, without any additional terms or conditions.
->      Notwithstanding the above, nothing herein shall supersede or modify
->      the terms of any separate license agreement you may have executed
->      with Licensor regarding such Contributions.
->
->   6. Trademarks. This License does not grant permission to use the trade
->      names, trademarks, service marks, or product names of the Licensor,
->      except as required for reasonable and customary use in describing the
->      origin of the Work and reproducing the content of the NOTICE file.
->
->   7. Disclaimer of Warranty. Unless required by applicable law or
->      agreed to in writing, Licensor provides the Work (and each
->      Contributor provides its Contributions) on an "AS IS" BASIS,
->      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
->      implied, including, without limitation, any warranties or conditions
->      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
->      PARTICULAR PURPOSE. You are solely responsible for determining the
->      appropriateness of using or redistributing the Work and assume any
->      risks associated with Your exercise of permissions under this License.
->
->   8. Limitation of Liability. In no event and under no legal theory,
->      whether in tort (including negligence), contract, or otherwise,
->      unless required by applicable law (such as deliberate and grossly
->      negligent acts) or agreed to in writing, shall any Contributor be
->      liable to You for damages, including any direct, indirect, special,
->      incidental, or consequential damages of any character arising as a
->      result of this License or out of the use or inability to use the
->      Work (including but not limited to damages for loss of goodwill,
->      work stoppage, computer failure or malfunction, or any and all
->      other commercial damages or losses), even if such Contributor
->      has been advised of the possibility of such damages.
->
->   9. Accepting Warranty or Additional Liability. While redistributing
->      the Work or Derivative Works thereof, You may choose to offer,
->      and charge a fee for, acceptance of support, warranty, indemnity,
->      or other liability obligations and/or rights consistent with this
->      License. However, in accepting such obligations, You may act only
->      on Your own behalf and on Your sole responsibility, not on behalf
->      of any other Contributor, and only if You agree to indemnify,
->      defend, and hold each Contributor harmless for any liability
->      incurred by, or claims asserted against, such Contributor by reason
->      of your accepting any such warranty or additional liability.
-"""
-
-const LICENSES = Dict("MIT" => mit, "BSD" => bsd, "ASL" => asl)
-
-end # module
diff --git a/base/pkg/git.jl b/base/pkg/git.jl
index 32e492f074dc1..56252125ce7bc 100644
--- a/base/pkg/git.jl
+++ b/base/pkg/git.jl
@@ -22,7 +22,7 @@ end
 
 cmd(args::Cmd; dir="") = `$(git(dir)) $args`
 run(args::Cmd; dir="", out=STDOUT) = Base.run(pipeline(cmd(args,dir=dir), out))
-readall(args::Cmd; dir="") = Base.readall(cmd(args,dir=dir))
+readstring(args::Cmd; dir="") = Base.readstring(cmd(args,dir=dir))
 readchomp(args::Cmd; dir="") = Base.readchomp(cmd(args,dir=dir))
 
 function success(args::Cmd; dir="")
diff --git a/base/pkg/github.jl b/base/pkg/github.jl
deleted file mode 100644
index 24310b8276f50..0000000000000
--- a/base/pkg/github.jl
+++ /dev/null
@@ -1,148 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-module GitHub
-
-import Main, ..Git, ..Dir
-
-const AUTH_NOTE = "Julia Package Manager"
-const AUTH_DATA = Dict{Any,Any}(
-    "scopes" => ["repo"],
-    "note" => AUTH_NOTE,
-    "note_url" => "http://docs.julialang.org/en/latest/manual/packages/",
-)
-
-function user()
-    if !success(`git config --global github.user`)
-        error("""
-        no GitHub user name configured; please configure it with:
-
-            git config --global github.user USERNAME
-
-        where USERNAME is replaced with your GitHub user name.
-        """)
-    end
-    readchomp(`git config --global github.user`)
-end
-
-function json()
-    isdefined(:JSON) || try eval(Main, :(import JSON))
-    catch err
-        warn(err)
-        error("using the GitHub API requires having the JSON package installed ")
-    end
-    Main.JSON
-end
-
-function curl(url::AbstractString, opts::Cmd=``)
-    success(`curl --version`) || error("using the GitHub API requires having `curl` installed")
-    out, proc = open(`curl -i -s -S $opts $url`,"r")
-    head = readline(out)
-    status = parse(Int,split(head,r"\s+";limit=3)[2])
-    header = Dict{AbstractString,AbstractString}()
-    for line in eachline(out)
-        if !ismatch(r"^\s*$",line)
-            (k,v) = split(line, r":\s*"; limit=2)
-            header[k] = v
-            continue
-        end
-        wait(proc); return status, header, readall(out)
-    end
-    error("strangely formatted HTTP response")
-end
-curl(url::AbstractString, data::Void, opts::Cmd=``) = curl(url,opts)
-curl(url::AbstractString, data, opts::Cmd=``) =
-    curl(url,`--data $(sprint(io->json().print(io,data))) $opts`)
-
-function delete_token()
-    tokfile = Dir.path(".github","token")
-    Base.rm(tokfile)
-    info("Could not authenticate with existing token. Deleting token and trying again.")
-end
-
-function token(user::AbstractString=user())
-    tokfile = Dir.path(".github","token")
-    isfile(tokfile) && return strip(readchomp(tokfile))
-    status, header, content = curl("https://api.github.com/authorizations",AUTH_DATA,`-u $user`)
-    tfa = false
-
-    # Check for two-factor authentication
-    if status == 401 && get(header, "X-GitHub-OTP", "") |> x->startswith(x, "required") && isinteractive()
-        tfa = true
-        info("Two-factor authentication in use.  Enter auth code.  (You may have to re-enter your password.)")
-        print(STDERR, "Authentication code: ")
-        code = readline(STDIN) |> chomp
-        status, header, content = curl("https://api.github.com/authorizations",AUTH_DATA,`-H "X-GitHub-OTP: $code" -u $user`)
-    end
-
-    if status == 422
-        error_code = json().parse(content)["errors"][1]["code"]
-        if error_code == "already_exists"
-            if tfa
-                info("Retrieving existing GitHub token. (You may have to re-enter your password twice more.)")
-                status, header, content = curl("https://api.github.com/authorizations",AUTH_DATA,`-u $user`)
-                status != 401 && error("$status: $(json().parse(content)["message"])")
-                print(STDERR, "New authentication code: ")
-                code = readline(STDIN) |> chomp
-                status, header, content = curl("https://api.github.com/authorizations",`-H "X-GitHub-OTP: $code" -u $user`)
-            else
-                info("Retrieving existing GitHub token. (You may have to re-enter your password.)")
-                status, header, content = curl("https://api.github.com/authorizations", `-u $user`)
-            end
-            (status >= 400) && error("$status: $(json().parse(content)["message"])")
-            for entry in json().parse(content)
-                if entry["note"] == AUTH_NOTE
-                    tok = entry["token"]
-                    break
-                end
-            end
-        else
-            error("GitHub returned validation error (422): $error_code: $(json().parse(content)["message"])")
-        end
-    else
-        (status != 401 && status != 403) || error("$status: $(json().parse(content)["message"])")
-        tok = json().parse(content)["token"]
-    end
-
-    mkpath(dirname(tokfile))
-    open(io->println(io,tok),tokfile,"w")
-    return tok
-end
-
-function req(resource::AbstractString, data, opts::Cmd=``)
-    url = "https://api.github.com/$resource"
-    status, header, content = curl(url,data,`-u $(token()):x-oauth-basic $opts`)
-    response = json().parse(content)
-    status, response
-end
-
-GET(resource::AbstractString, data, opts::Cmd=``) = req(resource,data,opts)
-HEAD(resource::AbstractString, data, opts::Cmd=``) = req(resource,data,`-I $opts`)
-PUT(resource::AbstractString, data, opts::Cmd=``) = req(resource,data,`-X PUT $opts`)
-POST(resource::AbstractString, data, opts::Cmd=``) = req(resource,data,`-X POST $opts`)
-PATCH(resource::AbstractString, data, opts::Cmd=``) = req(resource,data,`-X PATCH $opts`)
-DELETE(resource::AbstractString, data, opts::Cmd=``) = req(resource,data,`-X DELETE $opts`)
-
-for m in (:GET,:HEAD,:PUT,:POST,:PATCH,:DELETE)
-    @eval $m(resource::AbstractString, opts::Cmd=``) = $m(resource,nothing,opts)
-end
-
-function pushable(owner::AbstractString, repo::AbstractString, user::AbstractString=user())
-    status, response = HEAD("repos/$owner/$repo")
-    status == 404 && error("repo $owner/$repo does not exist")
-    status, response = GET("repos/$owner/$repo/collaborators/$user")
-    status == 204 && return true
-    status == 404 && return false
-    error("unexpected API status code: $status – $(response["message"])")
-end
-
-function fork(owner::AbstractString, repo::AbstractString)
-    status, response = POST("repos/$owner/$repo/forks")
-    if status == 401
-        delete_token()
-        status, response = POST("repos/$owner/$repo/forks")
-    end
-    status == 202 || error("forking $owner/$repo failed: $(response["message"])")
-    return response
-end
-
-end # module
diff --git a/base/pkg/query.jl b/base/pkg/query.jl
index 2a7245d524b84..1cec1817c9696 100644
--- a/base/pkg/query.jl
+++ b/base/pkg/query.jl
@@ -2,13 +2,13 @@
 
 module Query
 
-import ...Pkg
+import ...Pkg.PkgError
 using ..Types
 
 function requirements(reqs::Dict, fix::Dict, avail::Dict)
     for (p1,f1) in fix
         for p2 in keys(f1.requires)
-            haskey(avail, p2) || haskey(fix, p2) || error("unknown package $p2 required by $p1")
+            haskey(avail, p2) || haskey(fix, p2) || throw(PkgError("unknown package $p2 required by $p1"))
         end
         satisfies(p1, f1.version, reqs) ||
             warn("$p1 is fixed at $(f1.version) conflicting with top-level requirement: $(reqs[p1])")
@@ -108,7 +108,7 @@ function check_requirements(reqs::Requires, deps::Dict{ByteString,Dict{VersionNu
             else
                 err_msg *= "       available versions are $(join(available_list, ", ", " and "))"
             end
-            error(err_msg)
+            throw(PkgError(err_msg))
         end
     end
 end
diff --git a/base/pkg/read.jl b/base/pkg/read.jl
index 059c1fd1eaa3e..1a6149578438c 100644
--- a/base/pkg/read.jl
+++ b/base/pkg/read.jl
@@ -2,10 +2,10 @@
 
 module Read
 
-import ..Git, ..Cache, ..Reqs
+import ...LibGit2, ..Cache, ..Reqs, ...Pkg.PkgError
 using ..Types
 
-readstrip(path...) = strip(readall(joinpath(path...)))
+readstrip(path...) = strip(readstring(joinpath(path...)))
 
 url(pkg::AbstractString) = readstrip("METADATA", pkg, "url")
 sha1(pkg::AbstractString, ver::VersionNumber) = readstrip("METADATA", pkg, "versions", string(ver), "sha1")
@@ -55,52 +55,97 @@ end
 isinstalled(pkg::AbstractString) =
     pkg != "METADATA" && pkg != "REQUIRE" && pkg[1] != '.' && isdir(pkg)
 
-function isfixed(pkg::AbstractString, avail::Dict=available(pkg))
-    isinstalled(pkg) || error("$pkg is not an installed package.")
+function isfixed(pkg::AbstractString, prepo::LibGit2.GitRepo, avail::Dict=available(pkg))
+    isinstalled(pkg) || throw(PkgError("$pkg is not an installed package."))
     isfile("METADATA", pkg, "url") || return true
     ispath(pkg, ".git") || return true
-    Git.dirty(dir=pkg) && return true
-    Git.attached(dir=pkg) && return true
-    !Git.success(`cat-file -e HEAD:REQUIRE`, dir=pkg) && isfile(pkg,"REQUIRE") && return true
-    head = Git.head(dir=pkg)
+
+    LibGit2.isdirty(prepo) && return true
+    LibGit2.isattached(prepo) && return true
+    LibGit2.need_update(prepo)
+    LibGit2.iszero(LibGit2.revparseid(prepo, "HEAD:REQUIRE")) && isfile(pkg,"REQUIRE") && return true
+
+    head = string(LibGit2.head_oid(prepo))
     for (ver,info) in avail
         head == info.sha1 && return false
     end
+
     cache = Cache.path(pkg)
-    cache_has_head = isdir(cache) && Git.iscommit(head, dir=cache)
-    for (ver,info) in avail
-        if cache_has_head && Git.iscommit(info.sha1, dir=cache)
-            Git.is_ancestor_of(head, info.sha1, dir=cache) && return false
-        elseif Git.iscommit(info.sha1, dir=pkg)
-            Git.is_ancestor_of(head, info.sha1, dir=pkg) && return false
-        else
-            Base.warn_once("unknown $pkg commit $(info.sha1[1:8]), metadata may be ahead of package cache")
+    cache_has_head = if isdir(cache)
+        crepo = LibGit2.GitRepo(cache)
+        LibGit2.iscommit(head, crepo)
+    else
+        false
+    end
+    res = true
+    try
+        for (ver,info) in avail
+            if cache_has_head && LibGit2.iscommit(info.sha1, crepo)
+                if LibGit2.is_ancestor_of(head, info.sha1, crepo)
+                    res = false
+                    break
+                end
+            elseif LibGit2.iscommit(info.sha1, prepo)
+                if LibGit2.is_ancestor_of(head, info.sha1, prepo)
+                    res = false
+                    break
+                end
+            else
+                Base.warn_once("unknown $pkg commit $(info.sha1[1:8]), metadata may be ahead of package cache")
+            end
         end
+    finally
+        cache_has_head && LibGit2.finalize(crepo)
     end
-    return true
+    return res
 end
 
-function installed_version(pkg::AbstractString, avail::Dict=available(pkg))
+function installed_version(pkg::AbstractString, prepo::LibGit2.GitRepo, avail::Dict=available(pkg))
     ispath(pkg,".git") || return typemin(VersionNumber)
-    head = Git.head(dir=pkg)
+
+    # get package repo head hash
+    local head
+    try
+        head = string(LibGit2.head_oid(prepo))
+    catch ex
+        # refs/heads/master does not exist
+        if isa(ex,LibGit2.GitError) &&
+            ex.code == LibGit2.Error.EUNBORNBRANCH
+            head = ""
+        else
+            rethrow(ex)
+        end
+    end
+    isempty(head) && return typemin(VersionNumber)
+
     vers = collect(keys(filter((ver,info)->info.sha1==head, avail)))
     !isempty(vers) && return maximum(vers)
+
     cache = Cache.path(pkg)
-    cache_has_head = isdir(cache) && Git.iscommit(head, dir=cache)
+    cache_has_head = if isdir(cache)
+        crepo = LibGit2.GitRepo(cache)
+        LibGit2.iscommit(head, crepo)
+    else
+        false
+    end
     ancestors = VersionNumber[]
     descendants = VersionNumber[]
-    for (ver,info) in avail
-        sha1 = info.sha1
-        base = if cache_has_head && Git.iscommit(sha1, dir=cache)
-            Git.readchomp(`merge-base $head $sha1`, dir=cache)
-        elseif Git.iscommit(sha1, dir=pkg)
-            Git.readchomp(`merge-base $head $sha1`, dir=pkg)
-        else
-            Base.warn_once("unknown $pkg commit $(sha1[1:8]), metadata may be ahead of package cache")
-            continue
+    try
+        for (ver,info) in avail
+            sha1 = info.sha1
+            base = if cache_has_head && LibGit2.iscommit(sha1, crepo)
+                LibGit2.merge_base(crepo, head, sha1)
+            elseif LibGit2.iscommit(sha1, prepo)
+                LibGit2.merge_base(prepo, head, sha1)
+            else
+                Base.warn_once("unknown $pkg commit $(sha1[1:8]), metadata may be ahead of package cache")
+                continue
+            end
+            string(base) == sha1 && push!(ancestors,ver)
+            string(base) == head && push!(descendants,ver)
         end
-        base == sha1 && push!(ancestors,ver)
-        base == head && push!(descendants,ver)
+    finally
+        cache_has_head && LibGit2.finalize(crepo)
     end
     both = sort!(intersect(ancestors,descendants))
     isempty(both) || warn("$pkg: some versions are both ancestors and descendants of head: $both")
@@ -118,9 +163,13 @@ end
 function requires_path(pkg::AbstractString, avail::Dict=available(pkg))
     pkgreq = joinpath(pkg,"REQUIRE")
     ispath(pkg,".git") || return pkgreq
-    Git.dirty("REQUIRE", dir=pkg) && return pkgreq
-    !Git.success(`cat-file -e HEAD:REQUIRE`, dir=pkg) && isfile(pkgreq) && return pkgreq
-    head = Git.head(dir=pkg)
+    repo = LibGit2.GitRepo(pkg)
+    head = LibGit2.with(LibGit2.GitRepo, pkg) do repo
+        LibGit2.isdirty(repo, "REQUIRE") && return pkgreq
+        LibGit2.need_update(repo)
+        LibGit2.iszero(LibGit2.revparseid(repo, "HEAD:REQUIRE")) && isfile(pkgreq) && return pkgreq
+        string(LibGit2.head_oid(repo))
+    end
     for (ver,info) in avail
         if head == info.sha1
             return joinpath("METADATA", pkg, "versions", string(ver), "requires")
@@ -140,7 +189,15 @@ function installed(avail::Dict=available())
     for pkg in readdir()
         isinstalled(pkg) || continue
         ap = get(avail,pkg,Dict{VersionNumber,Available}())
-        pkgs[pkg] = (installed_version(pkg,ap),isfixed(pkg,ap))
+        if ispath(pkg,".git")
+            LibGit2.with(LibGit2.GitRepo, pkg) do repo
+                ver = installed_version(pkg, repo, ap)
+                fixed = isfixed(pkg, repo, ap)
+                pkgs[pkg] = (ver, fixed)
+            end
+        else
+            pkgs[pkg] = (typemin(VersionNumber), true)
+        end
     end
     return pkgs
 end
@@ -168,7 +225,7 @@ end
 
 function issue_url(pkg::AbstractString)
     ispath(pkg,".git") || return ""
-    m = match(Git.GITHUB_REGEX, url(pkg))
+    m = match(LibGit2.GITHUB_REGEX, url(pkg))
     m === nothing && return ""
     return "https://github.com/" * m.captures[1] * "/issues"
 end
diff --git a/base/pkg/reqs.jl b/base/pkg/reqs.jl
index 76226aaf698f6..80f67a268031f 100644
--- a/base/pkg/reqs.jl
+++ b/base/pkg/reqs.jl
@@ -2,8 +2,8 @@
 
 module Reqs
 
-import Base: ==, hash
-
+import Base: ==
+import ...Pkg.PkgError
 using ..Types
 
 # representing lines of REQUIRE files
@@ -24,12 +24,12 @@ immutable Requirement <: Line
         while !isempty(fields) && fields[1][1] == '@'
             push!(system,shift!(fields)[2:end])
         end
-        isempty(fields) && error("invalid requires entry: $content")
+        isempty(fields) && throw(PkgError("invalid requires entry: $content"))
         package = shift!(fields)
         all(field->ismatch(Base.VERSION_REGEX, field), fields) ||
-            error("invalid requires entry for $package: $content")
+            throw(PkgError("invalid requires entry for $package: $content"))
         versions = VersionNumber[fields...]
-        issorted(versions) || error("invalid requires entry for $package: $content")
+        issorted(versions) || throw(PkgError("invalid requires entry for $package: $content"))
         new(content, package, VersionSet(versions), system)
     end
     function Requirement(package::AbstractString, versions::VersionSet, system::Vector{AbstractString}=AbstractString[])
@@ -54,6 +54,15 @@ hash(s::Line, h::UInt) = hash(s.content, h + (0x3f5a631add21cb1a % UInt))
 
 # general machinery for parsing REQUIRE files
 
+function read{T<:AbstractString}(readable::Vector{T})
+    lines = Line[]
+    for line in readable
+        line = chomp(line)
+        push!(lines, ismatch(r"^\s*(?:#|$)", line) ? Comment(line) : Requirement(line))
+    end
+    return lines
+end
+
 function read(readable::Union{IO,Base.AbstractCmd})
     lines = Line[]
     for line in eachline(readable)
diff --git a/base/pkg/resolve.jl b/base/pkg/resolve.jl
index 83a5b9822a562..0f943c59aa05d 100644
--- a/base/pkg/resolve.jl
+++ b/base/pkg/resolve.jl
@@ -7,6 +7,7 @@ include("resolve/interface.jl")
 include("resolve/maxsum.jl")
 
 using ..Types, ..Query, .PkgToMaxSumInterface, .MaxSum
+import ...Pkg.PkgError
 
 export resolve, sanity_check
 
@@ -34,7 +35,7 @@ function resolve(reqs::Requires, deps::Dict{ByteString,Dict{VersionNumber,Availa
                     msg *= "\n  (you may try increasing the value of the" *
                            "\n   JULIA_PKGRESOLVE_ACCURACY environment variable)"
                 end
-                error(msg)
+                throw(PkgError(msg))
             end
             rethrow(err)
         end
@@ -49,7 +50,8 @@ function resolve(reqs::Requires, deps::Dict{ByteString,Dict{VersionNumber,Availa
 end
 
 # Scan dependencies for (explicit or implicit) contradictions
-function sanity_check(deps::Dict{ByteString,Dict{VersionNumber,Available}}, pkgs::Set{ByteString} = Set{ByteString}())
+function sanity_check(deps::Dict{ByteString,Dict{VersionNumber,Available}},
+                      pkgs::Set{ByteString} = Set{ByteString}())
 
     isempty(pkgs) || (deps = Query.undirected_dependencies_subset(deps, pkgs))
 
diff --git a/base/pkg/resolve/maxsum.jl b/base/pkg/resolve/maxsum.jl
index 958f26d9d9be5..7e568b196ab39 100644
--- a/base/pkg/resolve/maxsum.jl
+++ b/base/pkg/resolve/maxsum.jl
@@ -25,7 +25,7 @@ type MaxSumParams
     function MaxSumParams()
         accuracy = parse(Int,get(ENV, "JULIA_PKGRESOLVE_ACCURACY", "1"))
         if accuracy <= 0
-            error("JULIA_PKGRESOLVE_ACCURACY must be >= 1")
+            error("JULIA_PKGRESOLVE_ACCURACY must be > 0")
         end
         nondec_iterations = accuracy * 20
         dec_interval = accuracy * 10
@@ -65,7 +65,7 @@ type Graph
     gdir::Vector{Vector{Int}}
 
     # adjacency dict:
-    #   allows to retrieve the indices in gadj, so that
+    #   allows one to retrieve the indices in gadj, so that
     #   gadj[p0][adjdict[p1][p0]] = p1
     adjdict::Vector{Dict{Int,Int}}
 
diff --git a/base/pkg/resolve/versionweight.jl b/base/pkg/resolve/versionweight.jl
index 4e7a22975bfef..a87e0b689846f 100644
--- a/base/pkg/resolve/versionweight.jl
+++ b/base/pkg/resolve/versionweight.jl
@@ -11,7 +11,7 @@ immutable HierarchicalValue{T}
     rest::T
 end
 
-HierarchicalValue{T}(v::Vector{T}, rest::T = zero(T)) = HierarchicalValue{T}(v, rest)
+HierarchicalValue{T}(v::Vector{T}) = HierarchicalValue{T}(v, zero(T))
 HierarchicalValue(T::Type) = HierarchicalValue(T[])
 
 Base.zero{T}(::Type{HierarchicalValue{T}}) = HierarchicalValue(T)
diff --git a/base/pkg/write.jl b/base/pkg/write.jl
index 4f9c68c7bd16a..ff9d9d9ed15e6 100644
--- a/base/pkg/write.jl
+++ b/base/pkg/write.jl
@@ -2,46 +2,57 @@
 
 module Write
 
-import ..Git, ..Cache, ..Read
+import ...LibGit2, ..Cache, ..Read, ...Pkg.PkgError
+importall ...LibGit2
 
 function prefetch(pkg::AbstractString, sha1::AbstractString)
     isempty(Cache.prefetch(pkg, Read.url(pkg), sha1)) && return
-    error("$pkg: couldn't find commit $(sha1[1:10])")
+    throw(PkgError("$pkg: couldn't find commit $(sha1[1:10])"))
 end
 
-function fetch(pkg::AbstractString, sha1::AbstractString)
-    refspec = "+refs/*:refs/remotes/cache/*"
-    Git.run(`fetch -q $(Cache.path(pkg)) $refspec`, dir=pkg)
-    Git.iscommit(sha1, dir=pkg) && return
-    f = Git.iscommit(sha1, dir=Cache.path(pkg)) ? "fetch" : "prefetch"
+function fetch(repo::GitRepo, pkg::AbstractString, sha1::AbstractString)
+    cache = Cache.path(pkg)
+    LibGit2.fetch(repo, remoteurl=cache, refspecs=["+refs/*:refs/remotes/cache/*"])
+    LibGit2.need_update(repo)
+    LibGit2.iscommit(sha1, repo) && return
+    f = with(GitRepo, cache) do repo
+         LibGit2.iscommit(sha1, repo)
+    end ? "fetch" : "prefetch"
     url = Read.issue_url(pkg)
     if isempty(url)
-        error("$pkg: $f failed to get commit $(sha1[1:10]), please file a bug report with the package author.")
+        throw(PkgError("$pkg: $f failed to get commit $(sha1[1:10]), please file a bug report with the package author."))
     else
-        error("$pkg: $f failed to get commit $(sha1[1:10]), please file an issue at $url")
+        throw(PkgError("$pkg: $f failed to get commit $(sha1[1:10]), please file an issue at $url"))
     end
 end
 
-function checkout(pkg::AbstractString, sha1::AbstractString)
-    Git.set_remote_url(Read.url(pkg), dir=pkg)
-    Git.run(`checkout -q $sha1`, dir=pkg)
+function checkout(repo::GitRepo, pkg::AbstractString, sha1::AbstractString)
+    LibGit2.set_remote_url(repo, Cache.normalize_url(Read.url(pkg)))
+    LibGit2.checkout!(repo, sha1)
 end
 
 function install(pkg::AbstractString, sha1::AbstractString)
     prefetch(pkg, sha1)
-    if isdir(".trash/$pkg")
-        mv(".trash/$pkg", "./$pkg")
+    repo = if isdir(".trash/$pkg")
+        mv(".trash/$pkg", "./$pkg") #TODO check for newer version in cache before moving
+        GitRepo(pkg)
     else
-        Git.run(`clone -q $(Cache.path(pkg)) $pkg`)
+        LibGit2.clone(Cache.path(pkg), pkg)
+    end
+    try
+        fetch(repo, pkg, sha1)
+        checkout(repo, pkg, sha1)
+    finally
+        finalize(repo)
     end
-    fetch(pkg, sha1)
-    checkout(pkg, sha1)
 end
 
 function update(pkg::AbstractString, sha1::AbstractString)
     prefetch(pkg, sha1)
-    fetch(pkg, sha1)
-    checkout(pkg, sha1)
+    with(GitRepo, pkg) do repo
+        fetch(repo, pkg, sha1)
+        checkout(repo, pkg, sha1)
+    end
 end
 
 function remove(pkg::AbstractString)
diff --git a/base/pointer.jl b/base/pointer.jl
index 1956ef2263b66..83c80f33f1376 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -5,7 +5,7 @@
 const C_NULL = box(Ptr{Void}, 0)
 
 # pointer to integer
-convert{T<:Union{Int,UInt}}(::Type{T}, x::Ptr) = box(T, unbox(Ptr,x))
+convert{T<:Union{Int,UInt}}(::Type{T}, x::Ptr) = box(T, unbox(Ptr{Void},x))
 convert{T<:Integer}(::Type{T}, x::Ptr) = convert(T,convert(UInt, x))
 
 # integer to pointer
@@ -14,7 +14,7 @@ convert{T}(::Type{Ptr{T}}, x::Int) = box(Ptr{T},unbox(Int,Int(x)))
 
 # pointer to pointer
 convert{T}(::Type{Ptr{T}}, p::Ptr{T}) = p
-convert{T}(::Type{Ptr{T}}, p::Ptr) = box(Ptr{T}, unbox(Ptr,p))
+convert{T}(::Type{Ptr{T}}, p::Ptr) = box(Ptr{T}, unbox(Ptr{Void},p))
 
 # object to pointer (when used with ccall)
 unsafe_convert(::Type{Ptr{UInt8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{UInt8}, (Any,), x)
@@ -57,7 +57,7 @@ function pointer_to_string(p::Ptr{UInt8}, len::Integer, own::Bool=false)
     ccall(:jl_array_to_string, Any, (Any,), a)::ByteString
 end
 pointer_to_string(p::Ptr{UInt8}, own::Bool=false) =
-    pointer_to_string(p, ccall(:strlen, Csize_t, (Ptr{UInt8},), p), own)
+    pointer_to_string(p, ccall(:strlen, Csize_t, (Cstring,), p), own)
 
 # convert a raw Ptr to an object reference, and vice-versa
 unsafe_pointer_to_objref(x::Ptr) = ccall(:jl_value_ptr, Any, (Ptr{Void},), x)
diff --git a/base/poll.jl b/base/poll.jl
index 01715cc42d51f..1c21bee8b2285 100644
--- a/base/poll.jl
+++ b/base/poll.jl
@@ -1,5 +1,20 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+# filesystem operations
+
+export
+    watch_file,
+    poll_fd,
+    poll_file,
+    FileMonitor,
+    PollingFileWatcher,
+    FDWatcher
+
+import Base: @handle_as, wait, close, uvfinalize, eventloop, notify_error, stream_wait,
+    _sizeof_uv_poll, _sizeof_uv_fs_poll, _sizeof_uv_fs_event, _uv_hook_close,
+    associate_julia_struct, disassociate_julia_struct
+@windows_only import Base.WindowsRawSocket
+
 # libuv file watching event flags
 const UV_RENAME = 1
 const UV_CHANGE = 2
@@ -32,7 +47,6 @@ FDEvent(flags::Integer) = FDEvent((flags & UV_READABLE) != 0,
                                   (flags & FD_TIMEDOUT) != 0)
 fdtimeout() = FDEvent(false, false, true)
 
-
 type FileMonitor
     handle::Ptr{Void}
     file::ByteString
@@ -52,9 +66,7 @@ type FileMonitor
     end
 end
 
-abstract UVPollingWatcher
-
-type PollingFileWatcher <: UVPollingWatcher
+type PollingFileWatcher
     handle::Ptr{Void}
     file::ByteString
     interval::UInt32
@@ -150,7 +162,7 @@ type _FDWatcher
         end
     end
 end
-type FDWatcher <: UVPollingWatcher
+type FDWatcher
     watcher::_FDWatcher
     readable::Bool
     writable::Bool
@@ -197,6 +209,12 @@ function _uv_hook_close(uv::FileMonitor)
     nothing
 end
 
+function __init__()
+    global uv_jl_pollcb        = cfunction(uv_pollcb, Void, (Ptr{Void}, Cint, Cint))
+    global uv_jl_fspollcb      = cfunction(uv_fspollcb, Void, (Ptr{Void}, Cint, Ptr{Void}, Ptr{Void}))
+    global uv_jl_fseventscb    = cfunction(uv_fseventscb, Void, (Ptr{Void}, Ptr{Int8}, Int32, Int32))
+end
+
 function uv_fseventscb(handle::Ptr{Void}, filename::Ptr, events::Int32, status::Int32)
     t = @handle_as handle FileMonitor
     fname = filename == C_NULL ? "" : bytestring(convert(Ptr{UInt8}, filename))
diff --git a/base/precompile.jl b/base/precompile.jl
index bf3aed56cf6a7..6fa7a99d8f1f9 100644
--- a/base/precompile.jl
+++ b/base/precompile.jl
@@ -75,8 +75,9 @@ precompile(Base.LineEdit.init_state, (Base.Terminals.TTYTerminal, Base.LineEdit.
 precompile(Base.LineEdit.input_string, (Base.LineEdit.PromptState,))
 precompile(Base.LineEdit.keymap, (Base.LineEdit.PromptState, Base.LineEdit.Prompt))
 precompile(Base.LineEdit.keymap_data, (Base.LineEdit.PromptState, Base.LineEdit.Prompt))
-precompile(Base.LineEdit.keymap_fcn, (Function, Base.LineEdit.MIState, ByteString))
-precompile(Base.LineEdit.keymap_fcn, (Function, Base.LineEdit.MIState, ByteString))
+precompile(Base.LineEdit.keymap_fcn, (Function, ByteString))
+precompile(Base.LineEdit.keymap_fcn, (Function, ByteString))
+precompile(Base.LineEdit.keymap_fcn, (Function, ASCIIString))
 precompile(Base.LineEdit.match_input, (Dict{Char,Any},Base.LineEdit.MIState))
 precompile(Base.LineEdit.match_input, (Dict{Char, Any}, Base.LineEdit.MIState, Base.Terminals.TTYTerminal))
 precompile(Base.LineEdit.match_input, (Function, Base.LineEdit.MIState, Base.Terminals.TTYTerminal, Array{Char,1}))
@@ -144,7 +145,7 @@ precompile(Base.REPLCompletions.completions, (ASCIIString, Int))
 precompile(Base.Random.srand, ())
 precompile(Base.Random.srand, (ASCIIString, Int))
 precompile(Base.Random.srand, (UInt,))
-precompile(Base.RemoteRef, (Int, Int, Int))
+precompile(Base.RemoteChannel, (Int, Int, Int))
 precompile(Base.RemoteValue, ())
 precompile(Base.Set, ())
 precompile(Base.SystemError, (ASCIIString,))
@@ -172,7 +173,7 @@ precompile(Base.abspath, (UTF8String, UTF8String))
 precompile(Base.abspath, (UTF8String,))
 precompile(Base.abspath, (ASCIIString, ASCIIString))
 precompile(Base.abspath, (ASCIIString,))
-precompile(Base.alignment, (Float64,))
+precompile(Base.alignment, (Base.IOContext, Float64,))
 precompile(Base.any, (Function, Array{Any,1}))
 precompile(Base.arg_gen, (ASCIIString,))
 precompile(Base.associate_julia_struct, (Ptr{Void}, Base.TTY))
@@ -181,9 +182,6 @@ precompile(Base.atexit, (Function,))
 precompile(Base.banner, (Base.Terminals.TTYTerminal,))
 precompile(Base.startswith, (ASCIIString, ASCIIString))
 precompile(Base.bytestring, (ASCIIString,))
-precompile(Base.call, (Type{Base.Dict{Symbol, Any}}, Base.Pair{Symbol, Base.LineEdit.Prompt}, Base.Pair{Symbol, Base.LineEdit.Prompt}, Base.Pair{Symbol, Base.LineEdit.Prompt}))
-precompile(Base.call, (Array{Any, 1}, Type{Base.LineEdit.Prompt}, ASCIIString))
-precompile(Base.call, (Type{Base.Pair}, Symbol, Base.LineEdit.Prompt))
 precompile(Base.chop, (ASCIIString,))
 precompile(Base.close, (Base.TTY,))
 precompile(Base.close, (IOStream,))
@@ -235,8 +233,8 @@ precompile(Base.getindex, (Type{ByteString}, ASCIIString, ASCIIString))
 precompile(Base.getindex, (Type{Dict{Any, Any}}, Dict{Any, Any}, Dict{Any, Any}, Dict{Any, Any}, Dict{Any, Any}, Dict{Any, Any}))
 precompile(Base.getpid, ())
 precompile(Base.hash, (Int,))
-precompile(Base.hash, (RemoteRef, UInt))
-precompile(Base.hash, (RemoteRef,))
+precompile(Base.hash, (RemoteChannel, UInt))
+precompile(Base.hash, (RemoteChannel,))
 precompile(Base.haskey, (Base.EnvHash, ASCIIString))
 precompile(Base.haskey, (Dict{Symbol,Any}, Symbol))
 precompile(Base.haskey, (ObjectIdDict, Symbol))
@@ -267,8 +265,8 @@ precompile(Base.isequal, (Base.LineEdit.Prompt, Base.LineEdit.Prompt))
 precompile(Base.isequal, (Bool, Bool))
 precompile(Base.isequal, (Char, ASCIIString))
 precompile(Base.isequal, (Int,Int))
-precompile(Base.isequal, (RemoteRef, RemoteRef))
-precompile(Base.isequal, (RemoteRef, WeakRef))
+precompile(Base.isequal, (RemoteChannel, RemoteChannel))
+precompile(Base.isequal, (RemoteChannel, WeakRef))
 precompile(Base.isequal, (Symbol, Symbol))
 precompile(Base.isequal, (VersionNumber, VersionNumber))
 precompile(Base.isequal, (Void, Void))
@@ -294,7 +292,6 @@ precompile(Base.next, (Dict{Symbol,Any},Int))
 precompile(Base.next, (IntSet, Int))
 precompile(Base.next, (UnitRange{Int},Int))
 precompile(Base.nextind, (ASCIIString, Int))
-precompile(Base.nnz, (BitArray{1},))
 precompile(Base.normpath, (ASCIIString, ASCIIString))
 precompile(Base.normpath, (ASCIIString,))
 precompile(Base.normpath, (UTF8String, UTF8String))
@@ -348,9 +345,9 @@ precompile(Base.rehash!, (Dict{Any,Any}, Int))
 precompile(Base.rehash!, (Dict{UInt8, Any}, Int))
 precompile(Base.reinit_stdio, ())
 precompile(Base.repeat, (ASCIIString, Int))
-precompile(Base.repl_cmd, (Cmd,))
+precompile(Base.repl_cmd, (Cmd, Base.Terminals.TTYTerminal))
 precompile(Base.require, (Symbol,))
-precompile(Base.rr2id, (RemoteRef,))
+precompile(Base.remoteref_id, (RemoteChannel,))
 precompile(Base.rsearch, (ASCIIString, Char))
 precompile(Base.rstrip, (ASCIIString,))
 precompile(Base.run, (Cmd,))
@@ -380,7 +377,7 @@ precompile(Base.setindex!, (Vector{Any}, Vector{Any}, Int))
 precompile(Base.show, (Base.Terminals.TTYTerminal, Int))
 precompile(Base.show, (Float64,))
 precompile(Base.show, (IOStream, Int32))
-precompile(Base.showlimited, (Base.Terminals.TTYTerminal, Int))
+precompile(Base.showcompact, (Base.Terminals.TTYTerminal, Int))
 precompile(Base.similar, (Array{Base.LineEdit.Prompt, 1}, Type{Base.LineEdit.TextInterface}, Tuple{Int}))
 precompile(Base.size, (Base.Terminals.TTYTerminal,))
 precompile(Base.sizehint!, (Base.Dict{Symbol, Any}, Int))
@@ -406,7 +403,7 @@ precompile(Base.sync_begin, ())
 precompile(Base.sync_end, ())
 precompile(Base.systemerror, (Symbol, Bool))
 precompile(Base.take!, (Base.RemoteValue,))
-precompile(Base.take!, (RemoteRef,))
+precompile(Base.take!, (RemoteChannel,))
 precompile(Base.take_ref, (Tuple{Int,Int},))
 precompile(Base.takebuf_string, (IOBuffer,))
 precompile(Base.task_local_storage, ())
@@ -422,7 +419,7 @@ precompile(Base.uv_error, (ASCIIString, Bool))
 precompile(Base.uvfinalize, (Base.TTY,))
 precompile(Base.vcat, (Base.LineEdit.Prompt,))
 precompile(Base.wait, ())
-precompile(Base.wait, (RemoteRef,))
+precompile(Base.wait, (RemoteChannel,))
 precompile(Base.write, (Base.Terminals.TTYTerminal, ASCIIString))
 precompile(Base.write, (Base.Terminals.TerminalBuffer, ASCIIString))
 precompile(Base.write, (IOBuffer, Vector{UInt8}))
@@ -445,7 +442,6 @@ precompile(Base.spawn, (Cmd, Tuple{Base.TTY, Base.TTY, Base.TTY}, Bool, Bool))
 precompile(Base.spawn, (Cmd,))
 
 # For repl startup
-precompile(Base.call, (Type{Task}, Function))
 precompile(Base.yieldto, (Task, Int))
 precompile(Base.open, (UTF8String, Bool, Bool, Bool, Bool, Bool))
 precompile(Base.setindex!, (Base.Dict{Any, Any}, Char, Char))
@@ -467,14 +463,12 @@ precompile(Base.LineEdit.refresh_multi_line, (Array{Any, 1}, Base.Terminals.Term
 precompile(Base.schedule, (Array{Any, 1}, Task, Void))
 precompile(Base.LineEdit.match_input, (Function, Base.LineEdit.MIState, Base.Terminals.TTYTerminal, Array{Char, 1}, Base.Dict{Char, Any}))
 precompile(Base.convert, (Type{Union{ASCIIString, UTF8String}}, ASCIIString))
-precompile(Base.LineEdit.keymap_fcn, (Function, Base.LineEdit.MIState, ASCIIString))
-precompile(Base.weak_key_delete!, (Base.Dict{Any, Any}, Base.RemoteRef))
-precompile(==, (Base.RemoteRef, WeakRef))
-precompile(==, (Base.RemoteRef, Base.RemoteRef))
-precompile(Base.send_del_client, (Base.RemoteRef,))
+precompile(Base.weak_key_delete!, (Base.Dict{Any, Any}, Base.RemoteChannel))
+precompile(==, (Base.RemoteChannel, WeakRef))
+precompile(==, (Base.RemoteChannel, Base.RemoteChannel))
+precompile(Base.send_del_client, (Base.RemoteChannel,))
 precompile(!=, (Base.SubString{UTF8String}, ASCIIString))
 precompile(Base.print_joined, (Base.IOBuffer, Array{Base.SubString{UTF8String}, 1}, ASCIIString))
-precompile(Base.call, (Array{Any, 1}, Type{Base.LineEdit.Prompt}, ASCIIString))
 precompile(Base.joinpath, (UTF8String, ASCIIString, ASCIIString, ASCIIString))
 precompile(Base.string, (ASCIIString, UTF8String, Char))
 precompile(Base.string, (ASCIIString, ASCIIString, Int))
@@ -501,8 +495,6 @@ precompile(Base.set_valid_processes, (Array{Int, 1}, ))
 
 
 # Speed up repl help
-if Base.USE_GPL_LIBS
-    sprint(Markdown.term, @doc fft)
-    sprint(Docs.repl_search, "fft")
-    sprint(Docs.repl_corrections, "fft")
-end
+sprint(Markdown.term, @doc mean)
+sprint(Docs.repl_search, "mean")
+sprint(Docs.repl_corrections, "meen")
diff --git a/base/primes.jl b/base/primes.jl
index edd55dea7d772..bcfc3fa86226c 100644
--- a/base/primes.jl
+++ b/base/primes.jl
@@ -7,9 +7,9 @@
 #     Jonathan Sorenson, "An analysis of two prime number sieves", Computer Science Technical Report Vol. 1028, 1991
 const wheel         = [4,  2,  4,  2,  4,  6,  2,  6]
 const wheel_primes  = [7, 11, 13, 17, 19, 23, 29, 31]
-const wheel_indices = [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7 ]
+const wheel_indices = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7]
 
-@inline wheel_index(n) = ( (d, r) = divrem(n - 1, 30); return 8d + wheel_indices[r+1] )
+@inline wheel_index(n) = ( (d, r) = divrem(n - 1, 30); return 8d + wheel_indices[r+2] )
 @inline wheel_prime(n) = ( (d, r) = ((n - 1) >>> 3, (n - 1) & 7); return 30d + wheel_primes[r+1] )
 
 function _primesmask(limit::Int)
@@ -37,37 +37,23 @@ function _primesmask(lo::Int, hi::Int)
     wlo, whi = wheel_index(lo - 1), wheel_index(hi)
     m = wheel_prime(whi)
     sieve = ones(Bool, whi - wlo)
-    small_primes = primes(isqrt(hi))
-    @inbounds for i in 4:length(small_primes)
-        p = small_primes[i]
-        j = wheel_index(2 * div(lo - p - 1, 2p) + 1)
-        q = p * wheel_prime(j + 1); j = j & 7 + 1
-        while q ≤ m
-            sieve[wheel_index(q)-wlo] = false
-            q = q + wheel[j] * p
-            j = j & 7 + 1
+    hi < 49 && return sieve
+    small_sieve = _primesmask(isqrt(hi))
+    @inbounds for i in eachindex(small_sieve)
+        if small_sieve[i]; p = wheel_prime(i)
+            j = wheel_index(2 * div(lo - p - 1, 2p) + 1)
+            q = p * wheel_prime(j + 1); j = j & 7 + 1
+            while q ≤ m
+                sieve[wheel_index(q)-wlo] = false
+                q = q + wheel[j] * p
+                j = j & 7 + 1
+            end
         end
     end
     return sieve
 end
 
-# Sieve of the primes up to limit represented as an array of booleans
-function primesmask(limit::Int)
-    limit < 1 && throw(ArgumentError("limit must be at least 1, got $limit"))
-    sieve = falses(limit)
-    limit < 2 && return sieve; sieve[2] = true
-    limit < 3 && return sieve; sieve[3] = true
-    limit < 5 && return sieve; sieve[5] = true
-    limit < 7 && return sieve
-    wheel_sieve = _primesmask(limit)
-    @inbounds for i in eachindex(wheel_sieve)
-        Base.unsafe_setindex!(sieve, wheel_sieve[i], wheel_prime(i))
-    end
-    return sieve
-end
-primesmask(n::Integer) = n <= typemax(Int) ? primesmask(Int(n)) :
-    throw(ArgumentError("requested number of primes must be ≤ $(typemax(Int)), got $n"))
-
+# Sieve of the primes from lo up to hi represented as an array of booleans
 function primesmask(lo::Int, hi::Int)
     0 < lo ≤ hi || throw(ArgumentError("the condition 0 < lo ≤ hi must be met"))
     sieve = falses(hi - lo + 1)
@@ -79,26 +65,16 @@ function primesmask(lo::Int, hi::Int)
     lsi = lo - 1
     lwi = wheel_index(lsi)
     @inbounds for i in eachindex(wheel_sieve)
-        Base.unsafe_setindex!(sieve, wheel_sieve[i], wheel_prime(i + lwi) - lsi)
+        sieve[wheel_prime(i + lwi) - lsi] = wheel_sieve[i]
     end
     return sieve
 end
 primesmask{T<:Integer}(lo::T, hi::T) = lo <= hi <= typemax(Int) ? primesmask(Int(lo), Int(hi)) :
     throw(ArgumentError("both endpoints of the interval to sieve must be ≤ $(typemax(Int)), got $lo and $hi"))
 
-function primes(n::Int)
-    list = Int[]
-    n < 2 && return list; push!(list, 2)
-    n < 3 && return list; push!(list, 3)
-    n < 5 && return list; push!(list, 5)
-    n < 7 && return list
-    sizehint!(list, floor(Int, n / log(n)))
-    sieve = _primesmask(n)
-    @inbounds for i in eachindex(sieve)
-        sieve[i] && push!(list, wheel_prime(i))
-    end
-    return list
-end
+primesmask(limit::Int) = primesmask(1, limit)
+primesmask(n::Integer) = n <= typemax(Int) ? primesmask(Int(n)) :
+    throw(ArgumentError("requested number of primes must be ≤ $(typemax(Int)), got $n"))
 
 function primes(lo::Int, hi::Int)
     lo ≤ hi || throw(ArgumentError("the condition lo ≤ hi must be met"))
@@ -107,6 +83,7 @@ function primes(lo::Int, hi::Int)
     lo ≤ 3 ≤ hi && push!(list, 3)
     lo ≤ 5 ≤ hi && push!(list, 5)
     hi < 7 && return list
+    sizehint!(list, floor(Int, hi / log(hi)))
     sieve = _primesmask(max(7, lo), hi)
     lwi = wheel_index(lo - 1)
     @inbounds for i in eachindex(sieve)
@@ -114,6 +91,7 @@ function primes(lo::Int, hi::Int)
     end
     return list
 end
+primes(n::Int) = primes(1, n)
 
 const PRIMES = primes(2^16)
 
diff --git a/base/printf.jl b/base/printf.jl
index ba16147b98c09..8a2994bc45464 100644
--- a/base/printf.jl
+++ b/base/printf.jl
@@ -6,7 +6,7 @@ export @printf, @sprintf
 
 ### printf formatter generation ###
 const SmallFloatingPoint = Union{Float64,Float32,Float16}
-const SmallNumber = Union{SmallFloatingPoint,Base.Integer64,UInt128,Int128}
+const SmallNumber = Union{SmallFloatingPoint,Base.BitInteger}
 
 function gen(s::AbstractString)
     args = []
@@ -191,22 +191,24 @@ function print_fixed(out, precision, pt, ndigits, trailingzeros=true)
             write(out, '0')
             pt += 1
         end
-        write(out, pdigits, ndigits)
+        unsafe_write(out, pdigits, ndigits)
         precision -= ndigits
     elseif ndigits <= pt
         # dddd000.000000
-        write(out, pdigits, ndigits)
+        unsafe_write(out, pdigits, ndigits)
         while ndigits < pt
             write(out, '0')
             ndigits += 1
         end
-        write(out, trailingzeros ? '.' : ' ')
+        if trailingzeros
+            write(out, '.')
+        end
     else # 0 < pt < ndigits
         # dd.dd0000
         ndigits -= pt
-        write(out, pdigits, pt)
+        unsafe_write(out, pdigits, pt)
         write(out, '.')
-        write(out, pdigits+pt, ndigits)
+        unsafe_write(out, pdigits+pt, ndigits)
         precision -= ndigits
     end
     if trailingzeros
@@ -312,7 +314,7 @@ function gen_d(flags::ASCIIString, width::Int, precision::Int, c::Char)
         push!(blk.args, pad(width-1, zeros, '0'))
     end
     # print integer
-    push!(blk.args, :(write(out, pointer(DIGITS), pt)))
+    push!(blk.args, :(unsafe_write(out, pointer(DIGITS), pt)))
     # print padding
     if padding !== nothing && '-' in flags
         push!(blk.args, pad(width-precision, padding, ' '))
@@ -371,7 +373,7 @@ function gen_f(flags::ASCIIString, width::Int, precision::Int, c::Char)
     if precision > 0
         push!(blk.args, :(print_fixed(out,$precision,pt,len)))
     else
-        push!(blk.args, :(write(out, pointer(DIGITS), len)))
+        push!(blk.args, :(unsafe_write(out, pointer(DIGITS), len)))
         push!(blk.args, :(while pt >= (len+=1) write(out,'0') end))
         '#' in flags && push!(blk.args, :(write(out, '.')))
     end
@@ -411,7 +413,7 @@ function gen_e(flags::ASCIIString, width::Int, precision::Int, c::Char, inside_g
     blk = ifblk.args[2]
     push!(blk.args, :((len, pt, neg) = args))
     push!(blk.args, :(exp = pt-1))
-    expmark = c=='E' ? "E" : "e"
+    expmark = isupper(c) ? "E" : "e"
     if precision==0 && '#' in flags
         expmark = string(".",expmark)
     end
@@ -471,12 +473,12 @@ function gen_e(flags::ASCIIString, width::Int, precision::Int, c::Char, inside_g
                               end;
                               if endidx > 1
                                   write(out, '.')
-                                  write(out, pointer(DIGITS)+1, endidx-1)
+                                  unsafe_write(out, pointer(DIGITS)+1, endidx-1)
                               end
                               ))
         else
             push!(blk.args, :(write(out, '.')))
-            push!(blk.args, :(write(out, pointer(DIGITS)+1, $(ndigits-1))))
+            push!(blk.args, :(unsafe_write(out, pointer(DIGITS)+1, $(ndigits-1))))
             if ndigits < precision+1
                 n = precision+1-ndigits
                 push!(blk.args, pad(n, n, '0'))
@@ -575,7 +577,7 @@ function gen_a(flags::ASCIIString, width::Int, precision::Int, c::Char)
     push!(blk.args, :(write(out, DIGITS[1])))
     if precision > 0
         push!(blk.args, :(write(out, '.')))
-        push!(blk.args, :(write(out, pointer(DIGITS)+1, $(ndigits-1))))
+        push!(blk.args, :(unsafe_write(out, pointer(DIGITS)+1, $(ndigits-1))))
         if ndigits < precision+1
             n = precision+1-ndigits
             push!(blk.args, pad(n, n, '0'))
@@ -588,7 +590,7 @@ function gen_a(flags::ASCIIString, width::Int, precision::Int, c::Char)
         else
             push!(vpblk.args, :(write(out, '.')))
         end
-        push!(vpblk.args, :(write(out, pointer(DIGITS)+1, len-1)))
+        push!(vpblk.args, :(unsafe_write(out, pointer(DIGITS)+1, len-1)))
         push!(blk.args, ifvpblk)
     end
     for ch in expmark
@@ -680,6 +682,17 @@ function gen_p(flags::ASCIIString, width::Int, precision::Int, c::Char)
 end
 
 function gen_g(flags::ASCIIString, width::Int, precision::Int, c::Char)
+    # print to fixed trailing precision
+    #  [g]: lower case e on scientific
+    #  [G]: Upper case e on scientific
+    #
+    # flags
+    #  (#): always print a decimal point
+    #  (0): pad left with zeros
+    #  (-): left justify
+    #  ( ): precede non-negative values with " "
+    #  (+): precede non-negative values with "+"
+    #
     x, ex, blk = special_handler(flags,width)
     if precision < 0; precision = 6; end
     ndigits = min(precision+1,length(DIGITS)-1)
@@ -709,14 +722,9 @@ function gen_g(flags::ASCIIString, width::Int, precision::Int, c::Char)
     push!(blk.args, :(width = $width))
     # need to compute value before left-padding since trailing zeros are elided
     push!(blk.args, :(tmpout = IOBuffer()))
-    push!(blk.args, :(if fprec > 0
-                          print_fixed(tmpout,fprec,pt,len,$('#' in flags))
-                      else
-                          write(tmpout, pointer(DIGITS), len)
-                          while pt >= (len+=1) write(tmpout,'0') end
-                      end))
+    push!(blk.args, :(print_fixed(tmpout,fprec,pt,len,$('#' in flags))))
     push!(blk.args, :(tmpstr = takebuf_string(tmpout)))
-    push!(blk.args, :(if fprec > 0 width -= length(tmpstr); end ))
+    push!(blk.args, :(width -= length(tmpstr)))
     if '+' in flags || ' ' in flags
         push!(blk.args, :(width -= 1))
     else
@@ -856,7 +864,7 @@ function decode(b::Int, x::BigInt)
     pt = Base.ndigits(x, abs(b))
     length(DIGITS) < pt+1 && resize!(DIGITS, pt+1)
     neg && (x.size = -x.size)
-    ccall((:__gmpz_get_str, :libgmp), Ptr{UInt8},
+    ccall((:__gmpz_get_str, :libgmp), Cstring,
           (Ptr{UInt8}, Cint, Ptr{BigInt}), DIGITS, b, &x)
     neg && (x.size = -x.size)
     return Int32(pt), Int32(pt), neg
@@ -876,7 +884,7 @@ function decode_0ct(x::BigInt)
     length(DIGITS) < pt+1 && resize!(DIGITS, pt+1)
     neg && (x.size = -x.size)
     p = convert(Ptr{UInt8}, DIGITS) + 1
-    ccall((:__gmpz_get_str, :libgmp), Ptr{UInt8},
+    ccall((:__gmpz_get_str, :libgmp), Cstring,
           (Ptr{UInt8}, Cint, Ptr{BigInt}), p, 8, &x)
     neg && (x.size = -x.size)
     return neg, Int32(pt), Int32(pt)
@@ -901,7 +909,7 @@ function decode_dec(x::SmallFloatingPoint)
         DIGITS[1] = '0'
         return (Int32(1), Int32(1), false)
     end
-    len,pt,neg,buffer = grisu(x,Grisu.FIXED,0)
+    len,pt,neg = grisu(x,Grisu.FIXED,0)
     if len == 0
         DIGITS[1] = '0'
         return (Int32(1), Int32(1), false)
@@ -927,7 +935,7 @@ fix_dec(x::Integer, n::Int) = decode_dec(x)
 
 function fix_dec(x::SmallFloatingPoint, n::Int)
     if n > length(DIGITS)-1; n = length(DIGITS)-1; end
-    len,pt,neg,buffer = grisu(x,Grisu.FIXED,n)
+    len,pt,neg = grisu(x,Grisu.FIXED,n)
     if len == 0
         DIGITS[1] = '0'
         return (Int32(1), Int32(1), neg)
@@ -981,7 +989,7 @@ function ini_dec(x::SmallFloatingPoint, n::Int)
         ccall(:memset, Ptr{Void}, (Ptr{Void}, Cint, Csize_t), DIGITS, '0', n)
         return Int32(1), Int32(1), signbit(x)
     else
-        len,pt,neg,buffer = grisu(x,Grisu.PRECISION,n)
+        len,pt,neg = grisu(x,Grisu.PRECISION,n)
     end
     return Int32(len), Int32(pt), neg
 end
@@ -1058,6 +1066,19 @@ function ini_hex(x::SmallFloatingPoint, symbols::Array{UInt8,1})
     end
 end
 
+function ini_hex(x::Integer)
+    len,pt,neg = decode_hex(x)
+    pt = (len-1)<<2
+    len,pt,neg
+end
+function ini_HEX(x::Integer)
+    len,pt,neg = decode_HEX(x)
+    pt = (len-1)<<2
+    len,pt,neg
+end
+
+# not implemented
+ini_hex(x::Integer,ndigits::Int) = throw(MethodError(ini_hex,(x,ndigits)))
 
 #BigFloat
 fix_dec(out, d::BigFloat, flags::ASCIIString, width::Int, precision::Int, c::Char) = bigfloat_printf(out, d, flags, width, precision, c)
@@ -1095,7 +1116,7 @@ function bigfloat_printf(out, d, flags::ASCIIString, width::Int, precision::Int,
     bufsiz = length(DIGITS) - 1
     lng = ccall((:mpfr_snprintf,:libmpfr), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Ptr{BigFloat}...), DIGITS, bufsiz, printf_fmt, &d)
     lng > 0 || error("invalid printf formatting for BigFloat")
-    write(out, pointer(DIGITS), min(lng,bufsiz))
+    unsafe_write(out, pointer(DIGITS), min(lng,bufsiz))
     return (false, ())
 end
 
@@ -1154,7 +1175,7 @@ function _printf(macroname, io, fmt, args)
 end
 
 macro printf(args...)
-    !isempty(args) || throw(ArgumentError("@printf: called with no arguments"))
+    isempty(args) && throw(ArgumentError("@printf: called with no arguments"))
     if isa(args[1], AbstractString) || is_str_expr(args[1])
         _printf("@printf", :STDOUT, args[1], args[2:end])
     else
@@ -1165,7 +1186,7 @@ macro printf(args...)
 end
 
 macro sprintf(args...)
-    !isempty(args) || throw(ArgumentError("@sprintf: called with zero arguments"))
+    isempty(args) && throw(ArgumentError("@sprintf: called with zero arguments"))
     isa(args[1], AbstractString) || is_str_expr(args[1]) ||
         throw(ArgumentError("@sprintf: first argument must be a format string"))
     letexpr = _printf("@sprintf", :(IOBuffer()), args[1], args[2:end])
diff --git a/base/process.jl b/base/process.jl
index 879e4288bf356..7d673f746db4b 100644
--- a/base/process.jl
+++ b/base/process.jl
@@ -2,22 +2,80 @@
 
 abstract AbstractCmd
 
+# libuv process option flags
+const UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = UInt8(1 << 2)
+const UV_PROCESS_DETACHED = UInt8(1 << 3)
+const UV_PROCESS_WINDOWS_HIDE = UInt8(1 << 4)
+
 immutable Cmd <: AbstractCmd
     exec::Vector{ByteString}
     ignorestatus::Bool
-    detach::Bool
+    flags::UInt32 # libuv process flags
     env::Union{Array{ByteString},Void}
     dir::UTF8String
     Cmd(exec::Vector{ByteString}) =
-        new(exec, false, false, nothing, "")
-    Cmd(cmd::Cmd, ignorestatus, detach, env, dir) =
-        new(cmd.exec, ignorestatus, detach, env,
+        new(exec, false, 0x00, nothing, "")
+    Cmd(cmd::Cmd, ignorestatus, flags, env, dir) =
+        new(cmd.exec, ignorestatus, flags, env,
             dir === cmd.dir ? dir : cstr(dir))
-    Cmd(cmd::Cmd; ignorestatus=cmd.ignorestatus, detach=cmd.detach, env=cmd.env, dir=cmd.dir) =
-        new(cmd.exec, ignorestatus, detach, env,
+    function Cmd(cmd::Cmd; ignorestatus::Bool=cmd.ignorestatus, env=cmd.env, dir::AbstractString=cmd.dir,
+                 detach::Bool = 0 != cmd.flags & UV_PROCESS_DETACHED,
+                 windows_verbatim::Bool = 0 != cmd.flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
+                 windows_hide::Bool = 0 != cmd.flags & UV_PROCESS_WINDOWS_HIDE)
+        flags = detach*UV_PROCESS_DETACHED |
+                windows_verbatim*UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS |
+                windows_hide*UV_PROCESS_WINDOWS_HIDE
+        new(cmd.exec, ignorestatus, flags, byteenv(env),
             dir === cmd.dir ? dir : cstr(dir))
+    end
 end
 
+"""
+    Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide,
+                  env, dir)
+
+Construct a new `Cmd` object, representing an external program and
+arguments, from `cmd`, while changing the settings of the optional
+keyword arguments:
+
+* `ignorestatus::Bool`: If `true` (defaults to `false`), then the `Cmd`
+  will not throw an error if the return code is nonzero.
+* `detach::Bool`: If `true` (defaults to `false`), then the `Cmd` will be
+  run in a new process group, allowing it to outlive the `julia` process
+  and not have Ctrl-C passed to it.
+* `windows_verbatim::Bool`: If `true` (defaults to `false`), then on Windows
+  the `Cmd` will send a command-line string to the process with no quoting
+  or escaping of arguments, even arguments containing spaces.  (On Windows,
+  arguments are sent to a program as a single "command-line" string, and
+  programs are responsible for parsing it into arguments.  By default,
+  empty arguments and arguments with spaces or tabs are quoted with double
+  quotes `"` in the command line, and `\\` or `"` are preceded by backslashes.
+  `windows_verbatim=true` is useful for launching programs that parse their
+  command line in nonstandard ways.)  Has no effect on non-Windows systems.
+* `windows_hide::Bool`: If `true` (defaults to `false`), then on Windows no
+  new console window is displayed when the `Cmd` is executed.  This has
+  no effect if a console is already open or on non-Windows systems.
+* `env`: Set environment variables to use when running the `Cmd`.  `env`
+  is either a dictionary mapping strings to strings, an array
+  of strings of the form `"var=val"`, an array or tuple of `"var"=>val`
+  pairs, or `nothing`.  In order to modify (rather than replace)
+  the existing environment, create `env` by `copy(ENV)` and then
+  set `env["var"]=val` as desired.
+* `dir::AbstractString`: Specify a working directory for the command (instead
+  of the current directory).
+
+For any keywords that are not specified, the current settings from `cmd` are
+used.   Normally, to create a `Cmd` object in the first place, one uses
+backticks, e.g.
+
+    Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)
+"""
+Cmd
+
+hash(x::Cmd, h::UInt) = hash(x.exec, hash(x.env, hash(x.ignorestatus, hash(x.dir, hash(x.flags, h)))))
+==(x::Cmd, y::Cmd) = x.exec == y.exec && x.env == y.env && x.ignorestatus == y.ignorestatus &&
+                     x.dir == y.dir && isequal(x.flags, y.flags)
+
 immutable OrCmds <: AbstractCmd
     a::AbstractCmd
     b::AbstractCmd
@@ -86,27 +144,34 @@ immutable FileRedirect
     end
 end
 
-immutable DevNullStream <: AsyncStream end
+immutable DevNullStream <: IO end
 const DevNull = DevNullStream()
 isreadable(::DevNullStream) = false
 iswritable(::DevNullStream) = true
 isopen(::DevNullStream) = true
-read{T<:DevNullStream}(::T, args...) = throw(EOFErorr())
-write{T<:DevNullStream}(::T, args...) = 0
+read(::DevNullStream, ::Type{UInt8}) = throw(EOFError())
+write(::DevNullStream, ::UInt8) = 1
 close(::DevNullStream) = nothing
 flush(::DevNullStream) = nothing
 copy(::DevNullStream) = DevNull
+wait_connected(::DevNullStream) = nothing
+wait_readnb(::DevNullStream) = wait()
+wait_readbyte(::DevNullStream) = wait()
+wait_close(::DevNullStream) = wait()
+eof(::DevNullStream) = true
 
 uvhandle(::DevNullStream) = C_NULL
+uvtype(::DevNullStream) = UV_STREAM
+
 uvhandle(x::Ptr) = x
 uvtype(::Ptr) = UV_STREAM
-uvtype(::DevNullStream) = UV_STREAM
 
 # Not actually a pointer, but that's how we pass it through the C API so it's fine
 uvhandle(x::RawFD) = convert(Ptr{Void}, x.fd % UInt)
 uvtype(x::RawFD) = UV_RAW_FD
 
-typealias Redirectable Union{AsyncStream, FS.File, FileRedirect, DevNullStream, IOStream, RawFD}
+typealias Redirectable Union{IO, FileRedirect, RawFD}
+typealias StdIOSet NTuple{3, Union{Redirectable, Ptr{Void}}} # XXX: remove Ptr{Void} once libuv is refactored to use upstream release
 
 immutable CmdRedirect <: AbstractCmd
     cmd::AbstractCmd
@@ -129,11 +194,21 @@ function show(io::IO, cr::CmdRedirect)
     print(io, ")")
 end
 
+"""
+    ignorestatus(command)
 
+Mark a command object so that running it will not throw an error if the result code is non-zero.
+"""
 ignorestatus(cmd::Cmd) = Cmd(cmd, ignorestatus=true)
 ignorestatus(cmd::Union{OrCmds,AndCmds}) =
     typeof(cmd)(ignorestatus(cmd.a), ignorestatus(cmd.b))
-detach(cmd::Cmd) = Cmd(cmd, detach=true)
+
+"""
+    detach(command)
+
+Mark a command object so that it will be run in a new process group, allowing it to outlive the julia process, and not have Ctrl-C interrupts passed to it.
+"""
+detach(cmd::Cmd) = Cmd(cmd; detach=true)
 
 # like bytestring(s), but throw an error if s contains NUL, since
 # libuv requires NUL-terminated strings
@@ -144,21 +219,19 @@ function cstr(s)
     return bytestring(s)
 end
 
-function setenv{S<:ByteString}(cmd::Cmd, env::Array{S}; dir="")
-    byteenv = ByteString[cstr(x) for x in env]
-    return Cmd(cmd; env = byteenv, dir = dir)
-end
-function setenv(cmd::Cmd, env::Associative; dir="")
-    byteenv = ByteString[cstr(string(k)*"="*string(v)) for (k,v) in env]
-    return Cmd(cmd; env = byteenv, dir = dir)
-end
-function setenv{T<:AbstractString}(cmd::Cmd, env::Pair{T}...; dir="")
-    byteenv = ByteString[cstr(k*"="*string(v)) for (k,v) in env]
-    return Cmd(cmd; env = byteenv, dir = dir)
-end
-function setenv(cmd::Cmd; dir="")
-    return Cmd(cmd; dir = dir)
-end
+# convert various env representations into an array of "key=val" strings
+byteenv{S<:AbstractString}(env::AbstractArray{S}) =
+    ByteString[cstr(x) for x in env]
+byteenv(env::Associative) =
+    ByteString[cstr(string(k)*"="*string(v)) for (k,v) in env]
+byteenv(env::Void) = nothing
+byteenv{T<:AbstractString}(env::Union{AbstractVector{Pair{T}}, Tuple{Vararg{Pair{T}}}}) =
+    ByteString[cstr(k*"="*string(v)) for (k,v) in env]
+
+setenv(cmd::Cmd, env; dir="") = Cmd(cmd; env=byteenv(env), dir=dir)
+setenv{T<:AbstractString}(cmd::Cmd, env::Pair{T}...; dir="") =
+    setenv(cmd, env; dir=dir)
+setenv(cmd::Cmd; dir="") = Cmd(cmd; dir=dir)
 
 (&)(left::AbstractCmd, right::AbstractCmd) = AndCmds(left, right)
 redir_out(src::AbstractCmd, dest::AbstractCmd) = OrCmds(src, dest)
@@ -197,30 +270,30 @@ pipeline(src::Union{Redirectable,AbstractString}, cmd::AbstractCmd) = pipeline(c
 
 pipeline(a, b, c, d...) = pipeline(pipeline(a,b), c, d...)
 
-typealias RawOrBoxedHandle Union{UVHandle,AsyncStream,Redirectable,IOStream}
-typealias StdIOSet NTuple{3,RawOrBoxedHandle}
-
 type Process <: AbstractPipe
     cmd::Cmd
     handle::Ptr{Void}
-    in::AsyncStream
-    out::AsyncStream
-    err::AsyncStream
+    in::IO
+    out::IO
+    err::IO
     exitcode::Int64
     termsignal::Int32
     exitcb::Callback
     exitnotify::Condition
     closecb::Callback
     closenotify::Condition
-    function Process(cmd::Cmd, handle::Ptr{Void}, in::RawOrBoxedHandle, out::RawOrBoxedHandle, err::RawOrBoxedHandle)
-        if !isa(in, AsyncStream) || in === DevNull
-            in=DevNull
+    function Process(cmd::Cmd, handle::Ptr{Void},
+                     in::Union{Redirectable, Ptr{Void}},
+                     out::Union{Redirectable, Ptr{Void}},
+                     err::Union{Redirectable, Ptr{Void}})
+        if !isa(in, IO)
+            in = DevNull
         end
-        if !isa(out, AsyncStream) || out === DevNull
-            out=DevNull
+        if !isa(out, IO)
+            out = DevNull
         end
-        if !isa(err, AsyncStream) || err === DevNull
-            err=DevNull
+        if !isa(err, IO)
+            err = DevNull
         end
         this = new(cmd, handle, in, out, err,
                    typemin(fieldtype(Process, :exitcode)),
@@ -230,6 +303,8 @@ type Process <: AbstractPipe
         this
     end
 end
+pipe_reader(p::Process) = p.out
+pipe_writer(p::Process) = p.in
 
 immutable ProcessChain <: AbstractPipe
     processes::Vector{Process}
@@ -238,6 +313,8 @@ immutable ProcessChain <: AbstractPipe
     err::Redirectable
     ProcessChain(stdios::StdIOSet) = new(Process[], stdios[1], stdios[2], stdios[3])
 end
+pipe_reader(p::ProcessChain) = p.out
+pipe_writer(p::ProcessChain) = p.in
 
 function _jl_spawn(cmd, argv, loop::Ptr{Void}, pp::Process,
                    in, out, err)
@@ -248,7 +325,7 @@ function _jl_spawn(cmd, argv, loop::Ptr{Void}, pp::Process,
          Ptr{Void}, Int32, Ptr{Void}, Int32, Ptr{Void}, Int32, Ptr{Ptr{UInt8}}, Ptr{UInt8}, Ptr{Void}),
         cmd, argv, loop, proc, pp, uvtype(in),
         uvhandle(in), uvtype(out), uvhandle(out), uvtype(err), uvhandle(err),
-        pp.cmd.detach, pp.cmd.env === nothing ? C_NULL : pp.cmd.env, isempty(pp.cmd.dir) ? C_NULL : pp.cmd.dir,
+        pp.cmd.flags, pp.cmd.env === nothing ? C_NULL : pp.cmd.env, isempty(pp.cmd.dir) ? C_NULL : pp.cmd.dir,
         uv_jl_return_spawn::Ptr{Void})
     if error != 0
         ccall(:jl_forceclose_uv, Void, (Ptr{Void},), proc)
@@ -353,7 +430,7 @@ function setup_stdio(stdio::Pipe, readable::Bool)
 end
 
 function setup_stdio(stdio::IOStream, readable::Bool)
-    io = FS.File(RawFD(fd(stdio)))
+    io = Filesystem.File(RawFD(fd(stdio)))
     return (io, false)
 end
 
@@ -366,7 +443,7 @@ function setup_stdio(stdio::FileRedirect, readable::Bool)
         attr |= stdio.append ? JL_O_APPEND : JL_O_TRUNC
         perm = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH
     end
-    io = FS.open(stdio.filename, attr, perm)
+    io = Filesystem.open(stdio.filename, attr, perm)
     return (io, true)
 end
 
@@ -431,9 +508,9 @@ end
 # |       |        \ The function to be called once the uv handle is closed
 # |       \ The function to be called once the process exits
 # \ A set of up to 256 stdio instructions, where each entry can be either:
-#   | - An AsyncStream to be passed to the child
+#   | - An IO to be passed to the child
 #   | - DevNull to pass /dev/null
-#   | - An FS.File object to redirect the output to
+#   | - An Filesystem.File object to redirect the output to
 #   \ - An ASCIIString specifying a filename to be opened
 
 spawn_opts_swallow(stdios::StdIOSet, exitcb::Callback=false, closecb::Callback=false) =
@@ -448,8 +525,6 @@ spawn_opts_inherit(stdios::StdIOSet, exitcb::Callback=false, closecb::Callback=f
 spawn_opts_inherit(in::Redirectable=RawFD(0), out::Redirectable=RawFD(1), err::Redirectable=RawFD(2), args...) =
     (tuple(in,out,err,args...),false,false)
 
-spawn(cmds::AbstractCmd, args...; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) =
-    spawn(cmds, spawn_opts_swallow(args...)...; chain=chain)
 spawn(cmds::AbstractCmd, args...; chain::Nullable{ProcessChain}=Nullable{ProcessChain}()) =
     spawn(cmds, spawn_opts_swallow(args...)...; chain=chain)
 
@@ -459,12 +534,12 @@ function eachline(cmd::AbstractCmd, stdin)
     close(stdout.in)
     out = stdout.out
     # implicitly close after reading lines, since we opened
-    return EachLine(out, ()->close(out))
+    return EachLine(out, ()->(close(out); success(processes) || pipeline_error(processes)))
 end
 eachline(cmd::AbstractCmd) = eachline(cmd, DevNull)
 
 # return a Process object to read-to/write-from the pipeline
-function open(cmds::AbstractCmd, mode::AbstractString="r", other::AsyncStream=DevNull)
+function open(cmds::AbstractCmd, mode::AbstractString="r", other::Redirectable=DevNull)
     if mode == "r"
         in = other
         out = io = Pipe()
@@ -502,18 +577,18 @@ function readandwrite(cmds::AbstractCmd)
     (out, in, processes)
 end
 
-function readbytes(cmd::AbstractCmd, stdin::AsyncStream=DevNull)
+function read(cmd::AbstractCmd, stdin::Redirectable=DevNull)
     out, procs = open(cmd, "r", stdin)
-    bytes = readbytes(out)
+    bytes = read(out)
     !success(procs) && pipeline_error(procs)
     return bytes
 end
 
-function readall(cmd::AbstractCmd, stdin::AsyncStream=DevNull)
-    return bytestring(readbytes(cmd, stdin))
+function readstring(cmd::AbstractCmd, stdin::Redirectable=DevNull)
+    return bytestring(read(cmd, stdin))
 end
 
-function writeall(cmd::AbstractCmd, stdin::AbstractString, stdout::AsyncStream=DevNull)
+function writeall(cmd::AbstractCmd, stdin::AbstractString, stdout::Redirectable=DevNull)
     open(cmd, "w", stdout) do io
         write(io, stdin)
     end
@@ -557,7 +632,7 @@ function pipeline_error(procs::ProcessChain)
             push!(failed, p)
         end
     end
-    length(failed) == 0 && return nothing
+    isempty(failed) && return nothing
     length(failed) == 1 && pipeline_error(failed[1])
     msg = "failed processes:"
     for proc in failed
diff --git a/base/profile.jl b/base/profile.jl
index caaf8be021617..63fe98497b89d 100644
--- a/base/profile.jl
+++ b/base/profile.jl
@@ -2,7 +2,7 @@
 
 module Profile
 
-import Base: hash, ==
+import Base.StackTraces: lookup, UNKNOWN, show_spec_linfo
 
 export @profile
 
@@ -23,6 +23,16 @@ end
 ####
 #### User-level functions
 ####
+
+"""
+    init(; n::Integer, delay::Float64)
+
+Configure the `delay` between backtraces (measured in seconds), and the number `n` of
+instruction pointers that may be stored. Each instruction pointer corresponds to a single
+line of code; backtraces generally consist of a long list of instruction pointers. Default
+settings can be obtained by calling this function with no arguments, and each can be set
+independently using keywords or in the order `(n, delay)`.
+"""
 function init(; n::Union{Void,Integer} = nothing, delay::Union{Void,Float64} = nothing)
     n_cur = ccall(:jl_profile_maxlen_data, Csize_t, ())
     delay_cur = ccall(:jl_profile_delay_nsec, UInt64, ())/10^9
@@ -45,9 +55,33 @@ end
 # Use a max size of 1M profile samples, and fire timer every 1ms
 @windows? (__init__() = init(1_000_000, 0.01)) : (__init__() = init(1_000_000, 0.001))
 
+"""
+    clear()
+
+Clear any existing backtraces from the internal buffer.
+"""
 clear() = ccall(:jl_profile_clear_data, Void, ())
 
-function print{T<:Unsigned}(io::IO, data::Vector{T} = fetch(), lidict::Dict = getdict(data); format = :tree, C = false, combine = true, cols = Base.tty_size()[2], maxdepth::Int = typemax(Int), sortedby::Symbol = :filefuncline)
+"""
+    print([io::IO = STDOUT,] [data::Vector]; format = :tree, C = false, combine = true, maxdepth = typemax(Int), sortedby = :filefuncline)
+
+Prints profiling results to `io` (by default, `STDOUT`). If you do not
+supply a `data` vector, the internal buffer of accumulated backtraces
+will be used. `format` can be `:tree` or `:flat`. If `C==true`,
+backtraces from C and Fortran code are shown. `combine==true` merges
+instruction pointers that correspond to the same line of
+code. `maxdepth` can be used to limit the depth of printing in `:tree`
+format, while `sortedby` can be used to control the order in `:flat`
+format (`:filefuncline` sorts by the source line, whereas `:count`
+sorts in order of number of collected samples).
+"""
+function print{T<:Unsigned}(io::IO, data::Vector{T} = fetch(), lidict::Dict = getdict(data);
+        format = :tree,
+        C = false,
+        combine = true,
+        maxdepth::Int = typemax(Int),
+        sortedby::Symbol = :filefuncline)
+    cols = Base.displaysize(io)[2]
     if format == :tree
         tree(io, data, lidict, C, combine, cols, maxdepth)
     elseif format == :flat
@@ -56,8 +90,26 @@ function print{T<:Unsigned}(io::IO, data::Vector{T} = fetch(), lidict::Dict = ge
         throw(ArgumentError("output format $(repr(format)) not recognized"))
     end
 end
+
+"""
+    print([io::IO = STDOUT,] data::Vector, lidict::Dict; kwargs)
+
+Prints profiling results to `io`. This variant is used to examine results exported by a
+previous call to [`retrieve`](:func:`retrieve`). Supply the vector `data` of backtraces and
+a dictionary `lidict` of line information.
+
+See `Profile.print([io], data)` for an explanation of the valid keyword arguments.
+"""
 print{T<:Unsigned}(data::Vector{T} = fetch(), lidict::Dict = getdict(data); kwargs...) = print(STDOUT, data, lidict; kwargs...)
 
+"""
+    retrieve() -> data, lidict
+
+"Exports" profiling results in a portable format, returning the set of all backtraces
+(`data`) and a dictionary that maps the (session-specific) instruction pointers in `data` to
+`LineInfo` values that store the file name, function name, and line number. This function
+allows you to save profiling results for future analysis.
+"""
 function retrieve()
     data = fetch()
     copy(data), getdict(data)
@@ -65,9 +117,21 @@ end
 
 function getdict(data::Vector{UInt})
     uip = unique(data)
-    Dict{UInt, LineInfo}([ip=>lookup(ip) for ip in uip])
+    Dict{UInt, StackFrame}([ip=>lookup(ip) for ip in uip])
 end
 
+"""
+    callers(funcname, [data, lidict], [filename=<filename>], [linerange=<start:stop>]) -> Vector{Tuple{count, lineinfo}}
+
+Given a previous profiling run, determine who called a particular function. Supplying the
+filename (and optionally, range of line numbers over which the function is defined) allows
+you to disambiguate an overloaded method. The returned value is a vector containing a count
+of the number of calls and line information about the caller. One can optionally supply
+backtrace `data` obtained from [`retrieve`](:func:`retrieve`); otherwise, the current internal
+profile buffer is used.
+"""
+function callers end
+
 function callers(funcname::ByteString, bt::Vector{UInt}, lidict; filename = nothing, linerange = nothing)
     if filename === nothing && linerange === nothing
         return callersf(li -> li.func == funcname, bt, lidict)
@@ -89,37 +153,16 @@ callers(func::Function; kwargs...) = callers(string(func), retrieve()...; kwargs
 ##
 # Reset the malloc log. Used to avoid counting memory allocated during
 # compilation.
-clear_malloc_data() = ccall(:jl_clear_malloc_data, Void, ())
-
 
-####
-#### Internal interface
-####
-immutable LineInfo
-    func::ByteString
-    file::ByteString
-    line::Int
-    inlined_file::ByteString
-    inlined_line::Int
-    fromC::Bool
-    ip::Int64 # large enough that this struct can be losslessly read on any machine (32 or 64 bit)
-end
+"""
+    clear_malloc_data()
 
-const UNKNOWN = LineInfo("?", "?", -1, "?", -1, true, 0)
-
-#
-# If the LineInfo has function and line information, we consider two of them the same
-# if they share the same function/line information. For unknown functions, line==ip
-# so we never actually need to consider the .ip field.
-#
-==(a::LineInfo, b::LineInfo) = a.line == b.line && a.fromC == b.fromC && a.func == b.func && a.file == b.file
-
-function hash(li::LineInfo, h::UInt)
-    h += 0xf4fbda67fe20ce88 % UInt
-    h = hash(li.line, h)
-    h = hash(li.file, h)
-    h = hash(li.func, h)
-end
+Clears any stored memory allocation data when running julia with `--track-allocation`.
+Execute the command(s) you want to test (to force JIT-compilation), then call
+[`clear_malloc_data`](:func:`clear_malloc_data`). Then execute your command(s) again, quit
+Julia, and examine the resulting `*.mem` files.
+"""
+clear_malloc_data() = ccall(:jl_clear_malloc_data, Void, ())
 
 # C wrappers
 start_timer() = ccall(:jl_profile_start_timer, Cint, ())
@@ -134,22 +177,22 @@ len_data() = convert(Int, ccall(:jl_profile_len_data, Csize_t, ()))
 
 maxlen_data() = convert(Int, ccall(:jl_profile_maxlen_data, Csize_t, ()))
 
-function lookup(ip::Ptr{Void})
-    info = ccall(:jl_lookup_code_address, Any, (Ptr{Void},Cint), ip, false)
-    if length(info) == 7
-        return LineInfo(string(info[1]), string(info[2]), Int(info[3]), string(info[4]), Int(info[5]), info[6], Int64(info[7]))
-    else
-        return UNKNOWN
-    end
-end
-lookup(ip::UInt) = lookup(convert(Ptr{Void},ip))
-
 error_codes = Dict{Int,ASCIIString}(
     -1=>"cannot specify signal action for profiling",
     -2=>"cannot create the timer for profiling",
     -3=>"cannot start the timer for profiling",
     -4=>"cannot unblock SIGUSR1")
 
+
+"""
+    fetch() -> data
+
+Returns a reference to the internal buffer of backtraces. Note that subsequent operations,
+like [`clear`](:func:`clear`), can affect `data` unless you first make a copy. Note that the
+values in `data` have meaning only on this machine in the current session, because it
+depends on the exact memory addresses used in JIT-compiling. This function is primarily for
+internal use; [`retrieve`](:func:`retrieve`) may be a better choice for most users.
+"""
 function fetch()
     len = len_data()
     maxlen = maxlen_data()
@@ -198,7 +241,7 @@ function parse_flat(iplist, n, lidict, C::Bool)
     # The ones with no line number might appear multiple times in a single
     # backtrace, giving the wrong impression about the total number of backtraces.
     # Delete them too.
-    keep = !Bool[x == UNKNOWN || x.line == 0 || (x.fromC && !C) for x in lilist]
+    keep = !Bool[x == UNKNOWN || x.line == 0 || (x.from_c && !C) for x in lilist]
     n = n[keep]
     lilist = lilist[keep]
     lilist, n
@@ -217,7 +260,7 @@ function flat{T<:Unsigned}(io::IO, data::Vector{T}, lidict::Dict, C::Bool, combi
     print_flat(io, lilist, n, combine, cols, sortedby)
 end
 
-function print_flat(io::IO, lilist::Vector{LineInfo}, n::Vector{Int}, combine::Bool, cols::Integer, sortedby)
+function print_flat(io::IO, lilist::Vector{StackFrame}, n::Vector{Int}, combine::Bool, cols::Integer, sortedby)
     p = liperm(lilist)
     lilist = lilist[p]
     n = n[p]
@@ -242,26 +285,35 @@ function print_flat(io::IO, lilist::Vector{LineInfo}, n::Vector{Int}, combine::B
     end
     wcounts = max(6, ndigits(maximum(n)))
     maxline = 0
-    maxfile = 0
-    maxfunc = 0
+    maxfile = 6
+    maxfunc = 10
     for li in lilist
         maxline = max(maxline, li.line)
-        maxfile = max(maxfile, length(li.file))
-        maxfunc = max(maxfunc, length(li.func))
+        maxfile = max(maxfile, length(string(li.file)))
+        maxfunc = max(maxfunc, length(string(li.func)))
     end
     wline = max(5, ndigits(maxline))
     ntext = cols - wcounts - wline - 3
-    if maxfile+maxfunc <= ntext
+    maxfunc += 25
+    if maxfile + maxfunc <= ntext
         wfile = maxfile
         wfunc = maxfunc
     else
         wfile = floor(Integer,2*ntext/5)
         wfunc = floor(Integer,3*ntext/5)
     end
-    println(io, lpad("Count", wcounts, " "), " ", rpad("File", wfile, " "), " ", rpad("Function", wfunc, " "), " ", lpad("Line", wline, " "))
+    println(io, lpad("Count", wcounts, " "), " ", rpad("File", wfile, " "), " ", lpad("Line", wline, " "), " ", rpad("Function", wfunc, " "))
     for i = 1:length(n)
         li = lilist[i]
-        println(io, lpad(string(n[i]), wcounts, " "), " ", rpad(truncto(li.file, wfile), wfile, " "), " ", rpad(truncto(li.func, wfunc), wfunc, " "), " ", lpad(string(li.line), wline, " "))
+        Base.print(io, lpad(string(n[i]), wcounts, " "), " ")
+        Base.print(io, rpad(rtruncto(string(li.file), wfile), wfile, " "), " ")
+        Base.print(io, lpad(string(li.line), wline, " "), " ")
+        fname = string(li.func)
+        if !li.from_c && !isnull(li.outer_linfo)
+            fname = sprint(show_spec_linfo, li)
+        end
+        Base.print(io, rpad(ltruncto(fname, wfunc), wfunc, " "))
+        println(io)
     end
 end
 
@@ -287,9 +339,9 @@ function tree_aggregate{T<:Unsigned}(data::Vector{T})
     bt, counts
 end
 
-tree_format_linewidth(x::LineInfo) = ndigits(x.line)+6
+tree_format_linewidth(x::StackFrame) = ndigits(x.line)+6
 
-function tree_format(lilist::Vector{LineInfo}, counts::Vector{Int}, level::Int, cols::Integer)
+function tree_format(lilist::Vector{StackFrame}, counts::Vector{Int}, level::Int, cols::Integer)
     nindent = min(cols>>1, level)
     ndigcounts = ndigits(maximum(counts))
     ndigline = maximum([tree_format_linewidth(x) for x in lilist])
@@ -310,24 +362,26 @@ function tree_format(lilist::Vector{LineInfo}, counts::Vector{Int}, level::Int,
             if showextra
                 base = string(base, "+", nextra, " ")
             end
-            if li.line == li.ip
+            if li.line == li.pointer
                 strs[i] = string(base,
                           rpad(string(counts[i]), ndigcounts, " "),
-                          " ","unknown function (ip: 0x",hex(li.ip,2*sizeof(Ptr{Void})),
+                          " ",
+                          "unknown function (pointer: 0x",
+                          hex(li.pointer,2*sizeof(Ptr{Void})),
                           ")")
             else
-                base = string(base,
+                fname = string(li.func)
+                if !li.from_c && !isnull(li.outer_linfo)
+                    fname = sprint(show_spec_linfo, li)
+                end
+                strs[i] = string(base,
                               rpad(string(counts[i]), ndigcounts, " "),
                               " ",
-                              truncto(string(li.file), widthfile),
+                              rtruncto(string(li.file), widthfile),
+                              ":",
+                              li.line == -1 ? "?" : string(li.line),
                               "; ",
-                              truncto(string(li.func), widthfunc),
-                              "; ")
-                if li.line == -1
-                    strs[i] = string(base, "(unknown line)")
-                else
-                    strs[i] = string(base, "line: ", li.line)
-                end
+                              ltruncto(fname, widthfunc))
             end
         else
             strs[i] = ""
@@ -344,7 +398,7 @@ function tree{T<:Unsigned}(io::IO, bt::Vector{Vector{T}}, counts::Vector{Int}, l
     # Organize backtraces into groups that are identical up to this level
     if combine
         # Combine based on the line information
-        d = Dict{LineInfo,Vector{Int}}()
+        d = Dict{StackFrame,Vector{Int}}()
         for i = 1:length(bt)
             ip = bt[i][level+1]
             key = lidict[ip]
@@ -357,7 +411,7 @@ function tree{T<:Unsigned}(io::IO, bt::Vector{Vector{T}}, counts::Vector{Int}, l
         end
         # Generate counts
         dlen = length(d)
-        lilist = Array(LineInfo, dlen)
+        lilist = Array(StackFrame, dlen)
         group = Array(Vector{Int}, dlen)
         n = Array(Int, dlen)
         i = 1
@@ -381,7 +435,7 @@ function tree{T<:Unsigned}(io::IO, bt::Vector{Vector{T}}, counts::Vector{Int}, l
         end
         # Generate counts, and do the code lookup
         dlen = length(d)
-        lilist = Array(LineInfo, dlen)
+        lilist = Array(StackFrame, dlen)
         group = Array(Vector{Int}, dlen)
         n = Array(Int, dlen)
         i = 1
@@ -432,7 +486,7 @@ function tree{T<:Unsigned}(io::IO, data::Vector{T}, lidict::Dict, C::Bool, combi
 end
 
 function callersf(matchfunc::Function, bt::Vector{UInt}, lidict)
-    counts = Dict{LineInfo, Int}()
+    counts = Dict{StackFrame, Int}()
     lastmatched = false
     for id in bt
         if id == 0
@@ -456,16 +510,26 @@ function callersf(matchfunc::Function, bt::Vector{UInt}, lidict)
 end
 
 # Utilities
-function truncto(str::ByteString, w::Int)
+function rtruncto(str::ByteString, w::Int)
     ret = str;
     if length(str) > w
         ret = string("...", str[end-w+4:end])
     end
     ret
 end
+function ltruncto(str::ByteString, w::Int)
+    ret = str;
+    if length(str) > w
+        ret = string(str[1:w-4], "...")
+    end
+    ret
+end
+
+
+truncto(str::Symbol, w::Int) = truncto(string(str), w)
 
 # Order alphabetically (file, function) and then by line number
-function liperm(lilist::Vector{LineInfo})
+function liperm(lilist::Vector{StackFrame})
     comb = Array(ByteString, length(lilist))
     for i = 1:length(lilist)
         li = lilist[i]
@@ -484,7 +548,7 @@ warning_empty() = warn("""
             Profile.init().""")
 
 function purgeC(data, lidict)
-    keep = Bool[d == 0 || lidict[d].fromC == false for d in data]
+    keep = Bool[d == 0 || lidict[d].from_c == false for d in data]
     data[keep]
 end
 
diff --git a/base/promotion.jl b/base/promotion.jl
index 63e3b9a3d7606..b71ed7c4d5191 100644
--- a/base/promotion.jl
+++ b/base/promotion.jl
@@ -2,10 +2,11 @@
 
 ## type join (closest common ancestor, or least upper bound) ##
 
-typejoin() = Bottom
-typejoin(t::ANY) = t
-typejoin(t::ANY, ts...) = typejoin(t, typejoin(ts...))
+typejoin() = (@_pure_meta; Bottom)
+typejoin(t::ANY) = (@_pure_meta; t)
+typejoin(t::ANY, ts...) = (@_pure_meta; typejoin(t, typejoin(ts...)))
 function typejoin(a::ANY, b::ANY)
+    @_pure_meta
     if isa(a,TypeConstructor); a = a.body; end
     if isa(b,TypeConstructor); b = b.body; end
     if a <: b
@@ -71,7 +72,7 @@ function typejoin(a::ANY, b::ANY)
     while !is(b,Any)
         if a <: b.name.primary
             while a.name !== b.name
-                a = super(a)
+                a = supertype(a)
             end
             # join on parameters
             n = length(a.parameters)
@@ -86,7 +87,7 @@ function typejoin(a::ANY, b::ANY)
             end
             return a.name.primary{p...}
         end
-        b = super(b)
+        b = supertype(b)
     end
     return Any
 end
@@ -102,37 +103,39 @@ end
 
 ## promotion mechanism ##
 
-promote_type()  = Bottom
-promote_type(T) = T
-promote_type(T, S, U, V...) = promote_type(T, promote_type(S, U, V...))
+promote_type()  = (@_pure_meta; Bottom)
+promote_type(T) = (@_pure_meta; T)
+promote_type(T, S, U, V...) = (@_pure_meta; promote_type(T, promote_type(S, U, V...)))
 
-promote_type(::Type{Bottom}, ::Type{Bottom}) = Bottom
-promote_type{T}(::Type{T}, ::Type{T}) = T
-promote_type{T}(::Type{T}, ::Type{Bottom}) = T
-promote_type{T}(::Type{Bottom}, ::Type{T}) = T
+promote_type(::Type{Bottom}, ::Type{Bottom}) = (@_pure_meta; Bottom)
+promote_type{T}(::Type{T}, ::Type{T}) = (@_pure_meta; T)
+promote_type{T}(::Type{T}, ::Type{Bottom}) = (@_pure_meta; T)
+promote_type{T}(::Type{Bottom}, ::Type{T}) = (@_pure_meta; T)
 
 # Try promote_rule in both orders. Typically only one is defined,
 # and there is a fallback returning Bottom below, so the common case is
 #   promote_type(T, S) =>
 #   promote_result(T, S, result, Bottom) =>
 #   typejoin(result, Bottom) => result
-promote_type{T,S}(::Type{T}, ::Type{S}) =
+function promote_type{T,S}(::Type{T}, ::Type{S})
+    @_pure_meta
     promote_result(T, S, promote_rule(T,S), promote_rule(S,T))
+end
 
-promote_rule(T, S) = Bottom
+promote_rule(T, S) = (@_pure_meta; Bottom)
 
-promote_result(t,s,T,S) = promote_type(T,S)
+promote_result(t,s,T,S) = (@_pure_meta; promote_type(T,S))
 # If no promote_rule is defined, both directions give Bottom. In that
 # case use typejoin on the original types instead.
-promote_result{T,S}(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom}) = typejoin(T, S)
+promote_result{T,S}(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom}) = (@_pure_meta; typejoin(T, S))
 
 promote() = ()
 promote(x) = (x,)
 function promote{T,S}(x::T, y::S)
     (convert(promote_type(T,S),x), convert(promote_type(T,S),y))
 end
-promote_typeof(x) = typeof(x)
-promote_typeof(x, xs...) = promote_type(typeof(x), promote_typeof(xs...))
+promote_typeof(x) = (@_pure_meta; typeof(x))
+promote_typeof(x, xs...) = (@_pure_meta; promote_type(typeof(x), promote_typeof(xs...)))
 function promote(x, y, z)
     (convert(promote_typeof(x,y,z), x),
      convert(promote_typeof(x,y,z), y),
@@ -152,16 +155,18 @@ end
 # Otherwise, typejoin(T,S) is called (returning Number) so no conversion
 # happens, and +(promote(x,y)...) is called again, causing a stack
 # overflow.
-promote_result{T<:Number,S<:Number}(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom}) =
-    promote_to_super(T, S, typejoin(T,S))
+function promote_result{T<:Number,S<:Number}(::Type{T},::Type{S},::Type{Bottom},::Type{Bottom})
+    @_pure_meta
+    promote_to_supertype(T, S, typejoin(T,S))
+end
 
 # promote numeric types T and S to typejoin(T,S) if T<:S or S<:T
 # for example this makes promote_type(Integer,Real) == Real without
 # promoting arbitrary pairs of numeric types to Number.
-promote_to_super{T<:Number          }(::Type{T}, ::Type{T}, ::Type{T}) = T
-promote_to_super{T<:Number,S<:Number}(::Type{T}, ::Type{S}, ::Type{T}) = T
-promote_to_super{T<:Number,S<:Number}(::Type{T}, ::Type{S}, ::Type{S}) = S
-promote_to_super{T<:Number,S<:Number}(::Type{T}, ::Type{S}, ::Type) =
+promote_to_supertype{T<:Number          }(::Type{T}, ::Type{T}, ::Type{T}) = (@_pure_meta; T)
+promote_to_supertype{T<:Number,S<:Number}(::Type{T}, ::Type{S}, ::Type{T}) = (@_pure_meta; T)
+promote_to_supertype{T<:Number,S<:Number}(::Type{T}, ::Type{S}, ::Type{S}) = (@_pure_meta; S)
+promote_to_supertype{T<:Number,S<:Number}(::Type{T}, ::Type{S}, ::Type) =
     error("no promotion exists for ", T, " and ", S)
 
 +(x::Number, y::Number) = +(promote(x,y)...)
@@ -195,15 +200,14 @@ max(x::Real, y::Real) = max(promote(x,y)...)
 min(x::Real, y::Real) = min(promote(x,y)...)
 minmax(x::Real, y::Real) = minmax(promote(x, y)...)
 
-checked_add(x::Integer, y::Integer) = checked_add(promote(x,y)...)
-checked_sub(x::Integer, y::Integer) = checked_sub(promote(x,y)...)
-checked_mul(x::Integer, y::Integer) = checked_mul(promote(x,y)...)
-
 # "Promotion" that takes a Functor into account. You can override this
 # as needed. For example, if you need to provide a custom result type
 # for the multiplication of two types,
 #   promote_op{R<:MyType,S<:MyType}(::MulFun, ::Type{R}, ::Type{S}) = MyType{multype(R,S)}
-promote_op{R,S}(::Any, ::Type{R}, ::Type{S}) = promote_type(R, S)
+promote_op(::Any)    = (@_pure_meta; Bottom)
+promote_op(::Any, T) = (@_pure_meta; T)
+promote_op{R,S}(::Any, ::Type{R}, ::Type{S}) = (@_pure_meta; promote_type(R, S))
+promote_op(op, T, S, U, V...) = (@_pure_meta; promote_op(op, T, promote_op(op, S, U, V...)))
 
 ## catch-alls to prevent infinite recursion when definitions are missing ##
 
@@ -226,20 +230,13 @@ muladd{T<:Number}(x::T, y::T, z::T) = x*y+z
  <{T<:Real}(x::T, y::T) = no_op_err("<" , T)
 <={T<:Real}(x::T, y::T) = no_op_err("<=", T)
 
-div{T<:Real}(x::T, y::T) = no_op_err("div", T)
-fld{T<:Real}(x::T, y::T) = no_op_err("fld", T)
-cld{T<:Real}(x::T, y::T) = no_op_err("cld", T)
 rem{T<:Real}(x::T, y::T) = no_op_err("rem", T)
 mod{T<:Real}(x::T, y::T) = no_op_err("mod", T)
 
-mod1{T<:Real}(x::T, y::T) = no_op_err("mod1", T)
-rem1{T<:Real}(x::T, y::T) = no_op_err("rem1", T)
-fld1{T<:Real}(x::T, y::T) = no_op_err("fld1", T)
+min(x::Real) = x
+max(x::Real) = x
+minmax(x::Real) = (x, x)
 
 max{T<:Real}(x::T, y::T) = ifelse(y < x, x, y)
 min{T<:Real}(x::T, y::T) = ifelse(y < x, y, x)
 minmax{T<:Real}(x::T, y::T) = y < x ? (y, x) : (x, y)
-
-checked_add{T<:Integer}(x::T, y::T) = no_op_err("checked_add", T)
-checked_sub{T<:Integer}(x::T, y::T) = no_op_err("checked_sub", T)
-checked_mul{T<:Integer}(x::T, y::T) = no_op_err("checked_mul", T)
diff --git a/base/quadgk.jl b/base/quadgk.jl
index 95696f125896a..280a1555f4b75 100644
--- a/base/quadgk.jl
+++ b/base/quadgk.jl
@@ -79,7 +79,7 @@ function evalrule(f, a,b, x,w,gw, nrm)
     return Segment(a, b, Ik, E)
 end
 
-rulekey(::Type{BigFloat}, n) = (BigFloat, get_bigfloat_precision(), n)
+rulekey(::Type{BigFloat}, n) = (BigFloat, precision(BigFloat), n)
 rulekey(T,n) = (T,n)
 
 # Internal routine: integrate f over the union of the open intervals
diff --git a/base/random.jl b/base/random.jl
index b100aa6101138..4fdeb95c9bd06 100644
--- a/base/random.jl
+++ b/base/random.jl
@@ -35,8 +35,8 @@ type Close1Open2 <: FloatInterval end
         RandomDevice(unlimited::Bool=true) = new(open(unlimited ? "/dev/urandom" : "/dev/random"))
     end
 
-    rand{ T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice,  ::Type{T})  = read( rd.file, T)
-    rand!{T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice, A::Array{T}) = read!(rd.file, A)
+    rand{ T<:Union{Bool, Base.BitInteger}}(rd::RandomDevice,  ::Type{T})  = read( rd.file, T)
+    rand!{T<:Union{Bool, Base.BitInteger}}(rd::RandomDevice, A::Array{T}) = read!(rd.file, A)
 end
 
 @windows_only begin
@@ -47,12 +47,12 @@ end
         RandomDevice() = new(Array(UInt128, 1))
     end
 
-    function rand{T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice, ::Type{T})
+    function rand{T<:Union{Bool, Base.BitInteger}}(rd::RandomDevice, ::Type{T})
         win32_SystemFunction036!(rd.buffer)
         @inbounds return rd.buffer[1] % T
     end
 
-    rand!{T<:Union{Bool, Base.IntTypes...}}(rd::RandomDevice, A::Array{T}) = (win32_SystemFunction036!(A); A)
+    rand!{T<:Union{Bool, Base.BitInteger}}(rd::RandomDevice, A::Array{T}) = (win32_SystemFunction036!(A); A)
 end
 
 rand(rng::RandomDevice, ::Type{Close1Open2}) =
@@ -90,7 +90,7 @@ function gen_rand(r::MersenneTwister)
 end
 
 @inline reserve_1(r::MersenneTwister) = mt_empty(r) && gen_rand(r)
-# `reserve` allows to call `rand_inbounds` n times
+# `reserve` allows one to call `rand_inbounds` n times
 # precondition: n <= MTCacheLength
 @inline reserve(r::MersenneTwister, n::Int) = mt_avail(r) < n && gen_rand(r)
 
@@ -104,7 +104,6 @@ end
 
 @inline rand_ui52_raw_inbounds(r::MersenneTwister) = reinterpret(UInt64, rand_inbounds(r, Close1Open2))
 @inline rand_ui52_raw(r::MersenneTwister) = (reserve_1(r); rand_ui52_raw_inbounds(r))
-@inline rand_ui52(r::MersenneTwister) = rand_ui52_raw(r) & 0x000fffffffffffff
 @inline rand_ui2x52_raw(r::MersenneTwister) = rand_ui52_raw(r) % UInt128 << 64 | rand_ui52_raw(r)
 
 function srand(r::MersenneTwister, seed::Vector{UInt32})
@@ -149,7 +148,7 @@ function make_seed()
         seed = reinterpret(UInt64, time())
         seed = hash(seed, UInt64(getpid()))
         try
-        seed = hash(seed, parse(UInt64, readall(pipeline(`ifconfig`, `sha1sum`))[1:40], 16))
+        seed = hash(seed, parse(UInt64, readstring(pipeline(`ifconfig`, `sha1sum`))[1:40], 16))
         end
         return make_seed(seed)
     end
@@ -168,11 +167,7 @@ function make_seed(n::Integer)
 end
 
 function make_seed(filename::AbstractString, n::Integer)
-    open(filename) do io
-        a = Array(UInt32, Int(n))
-        read!(io, a)
-        a
-    end
+    read!(filename, Array(UInt32, Int(n)))
 end
 
 ## srand()
@@ -245,7 +240,8 @@ rand(r::Union{RandomDevice,MersenneTwister}, ::Type{Float32}) =
 
 ## random integers
 
-@inline rand_ui52(r::AbstractRNG) = reinterpret(UInt64, rand(r, Close1Open2)) & 0x000fffffffffffff
+@inline rand_ui52_raw(r::AbstractRNG) = reinterpret(UInt64, rand(r, Close1Open2))
+@inline rand_ui52(r::AbstractRNG) = rand_ui52_raw(r) & 0x000fffffffffffff
 
 # MersenneTwister
 
@@ -566,7 +562,7 @@ else
     end
 end
 
-rand{T<:Union{Signed,Unsigned,BigInt,Bool,Char}}(rng::AbstractRNG, r::UnitRange{T}) = rand(rng, RangeGenerator(r))
+rand{T<:Union{Signed,Unsigned,BigInt,Bool}}(rng::AbstractRNG, r::UnitRange{T}) = rand(rng, RangeGenerator(r))
 
 
 # Randomly draw a sample from an AbstractArray r
@@ -596,7 +592,7 @@ rand(rng::AbstractRNG, r::AbstractArray, dims::Int...) = rand(rng, r, dims)
 ## random BitArrays (AbstractRNG)
 
 function rand!(rng::AbstractRNG, B::BitArray)
-    length(B) == 0 && return B
+    isempty(B) && return B
     Bc = B.chunks
     rand!(rng, Bc)
     Bc[end] &= Base._msk_end(B)
@@ -1324,14 +1320,28 @@ randsubseq!(S::AbstractArray, A::AbstractArray, p::Real) = randsubseq!(GLOBAL_RN
 randsubseq{T}(r::AbstractRNG, A::AbstractArray{T}, p::Real) = randsubseq!(r, T[], A, p)
 randsubseq(A::AbstractArray, p::Real) = randsubseq(GLOBAL_RNG, A, p)
 
+"Return a random `Int` (masked with `mask`) in ``[0, n)``, when `n <= 2^52`."
+@inline function rand_lt(r::AbstractRNG, n::Int, mask::Int=nextpow2(n)-1)
+    # this duplicates the functionality of RangeGenerator objects,
+    # to optimize this special case
+    while true
+        x = (rand_ui52_raw(r) % Int) & mask
+        x < n && return x
+    end
+end
 
 function shuffle!(r::AbstractRNG, a::AbstractVector)
-    for i = length(a):-1:2
-        j = rand(r, 1:i)
+    n = length(a)
+    @assert n <= Int64(2)^52
+    mask = nextpow2(n) - 1
+    for i = n:-1:2
+        (mask >> 1) == i && (mask >>= 1)
+        j = 1 + rand_lt(r, i, mask)
         a[i], a[j] = a[j], a[i]
     end
     return a
 end
+
 shuffle!(a::AbstractVector) = shuffle!(GLOBAL_RNG, a)
 
 shuffle(r::AbstractRNG, a::AbstractVector) = shuffle!(r, copy(a))
@@ -1339,14 +1349,17 @@ shuffle(a::AbstractVector) = shuffle(GLOBAL_RNG, a)
 
 function randperm(r::AbstractRNG, n::Integer)
     a = Array(typeof(n), n)
+    @assert n <= Int64(2)^52
     if n == 0
        return a
     end
     a[1] = 1
-    @inbounds for i = 2:n
-        j = rand(r, 1:i)
+    mask = 3
+    @inbounds for i = 2:Int(n)
+        j = 1 + rand_lt(r, i, mask)
         a[i] = a[j]
         a[j] = i
+        i == 1+mask && (mask = 2mask + 1)
     end
     return a
 end
@@ -1354,11 +1367,15 @@ randperm(n::Integer) = randperm(GLOBAL_RNG, n)
 
 function randcycle(r::AbstractRNG, n::Integer)
     a = Array(typeof(n), n)
+    n == 0 && return a
+    @assert n <= Int64(2)^52
     a[1] = 1
-    @inbounds for i = 2:n
-        j = rand(r, 1:i-1)
+    mask = 3
+    @inbounds for i = 2:Int(n)
+        j = 1 + rand_lt(r, i-1, mask)
         a[i] = a[j]
         a[j] = i
+        i == 1+mask && (mask = 2mask + 1)
     end
     return a
 end
diff --git a/base/range.jl b/base/range.jl
index 52db2504d032b..9b997d2a1ca8b 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -3,6 +3,7 @@
 ## 1-dimensional ranges ##
 
 typealias Dims Tuple{Vararg{Int}}
+typealias DimsInteger Tuple{Vararg{Integer}}
 
 abstract Range{T} <: AbstractArray{T,1}
 
@@ -244,13 +245,64 @@ function show(io::IO, r::LinSpace)
     print(io, ')')
 end
 
+"""
+`print_range(io, r)` prints out a nice looking range r in terms of its elements
+as if it were `collect(r)`, dependent on the size of the
+terminal, and taking into account whether compact numbers should be shown.
+It figures out the width in characters of each element, and if they
+end up too wide, it shows the first and last elements separated by a
+horizontal elipsis. Typical output will look like `1.0,2.0,3.0,…,4.0,5.0,6.0`.
+
+`print_range(io, r, pre, sep, post, hdots)` uses optional
+parameters `pre` and `post` characters for each printed row,
+`sep` separator string between printed elements,
+`hdots` string for the horizontal ellipsis.
+"""
+function print_range(io::IO, r::Range,
+                     pre::AbstractString = " ",
+                     sep::AbstractString = ",",
+                     post::AbstractString = "",
+                     hdots::AbstractString = ",\u2026,") # horiz ellipsis
+    # This function borrows from print_matrix() in show.jl
+    # and should be called by writemime (replutil.jl) and by display()
+    limit = limit_output(io)
+    sz = displaysize(io)
+    screenheight, screenwidth = sz[1] - 4, sz[2]
+    screenwidth -= length(pre) + length(post)
+    postsp = ""
+    sepsize = length(sep)
+    m = 1 # treat the range as a one-row matrix
+    n = length(r)
+    # Figure out spacing alignments for r, but only need to examine the
+    # left and right edge columns, as many as could conceivably fit on the
+    # screen, with the middle columns summarized by horz, vert, or diag ellipsis
+    maxpossiblecols = div(screenwidth, 1+sepsize) # assume each element is at least 1 char + 1 separator
+    colsr = n <= maxpossiblecols ? (1:n) : [1:div(maxpossiblecols,2)+1; (n-div(maxpossiblecols,2)):n]
+    rowmatrix = r[colsr]' # treat the range as a one-row matrix for print_matrix_row
+    A = alignment(io, rowmatrix, 1:m, 1:length(rowmatrix), screenwidth, screenwidth, sepsize) # how much space range takes
+    if n <= length(A) # cols fit screen, so print out all elements
+        print(io, pre) # put in pre chars
+        print_matrix_row(io,rowmatrix,A,1,1:n,sep) # the entire range
+        print(io, post) # add the post characters
+    else # cols don't fit so put horiz ellipsis in the middle
+        # how many chars left after dividing width of screen in half
+        # and accounting for the horiz ellipsis
+        c = div(screenwidth-length(hdots)+1,2)+1 # chars remaining for each side of rowmatrix
+        alignR = reverse(alignment(io, rowmatrix, 1:m, length(rowmatrix):-1:1, c, c, sepsize)) # which cols of rowmatrix to put on the right
+        c = screenwidth - sum(map(sum,alignR)) - (length(alignR)-1)*sepsize - length(hdots)
+        alignL = alignment(io, rowmatrix, 1:m, 1:length(rowmatrix), c, c, sepsize) # which cols of rowmatrix to put on the left
+        print(io, pre)   # put in pre chars
+        print_matrix_row(io, rowmatrix,alignL,1,1:length(alignL),sep) # left part of range
+        print(io, hdots) # horizontal ellipsis
+        print_matrix_row(io, rowmatrix,alignR,1,length(rowmatrix)-length(alignR)+1:length(rowmatrix),sep) # right part of range
+        print(io, post)  # post chars
+    end
+end
+
 logspace(start::Real, stop::Real, n::Integer=50) = 10.^linspace(start, stop, n)
 
 ## interface implementations
 
-similar(r::Range, T::Type, dims::Tuple{Vararg{Integer}}) = Array(T, dims...)
-similar(r::Range, T::Type, dims::Dims) = Array(T, dims)
-
 size(r::Range) = (length(r),)
 
 isempty(r::StepRange) =
@@ -336,57 +388,86 @@ done(r::LinSpace, i::Int) = length(r) < i
 next{T}(r::LinSpace{T}, i::Int) =
     (convert(T, ((r.len-i)*r.start + (i-1)*r.stop)/r.divisor), i+1)
 
-# NOTE: For ordinal ranges, we assume start+step might be from a
-# lifted domain (e.g. Int8+Int8 => Int); use that for iterating.
-start(r::StepRange) = convert(typeof(r.start+r.step), r.start)
+start(r::StepRange) = oftype(r.start + r.step, r.start)
 next{T}(r::StepRange{T}, i) = (convert(T,i), i+r.step)
 done{T,S}(r::StepRange{T,S}, i) = isempty(r) | (i < min(r.start, r.stop)) | (i > max(r.start, r.stop))
-done{T,S}(r::StepRange{T,S}, i::Integer) = isempty(r) | (i == r.stop+r.step)
+done{T,S}(r::StepRange{T,S}, i::Integer) =
+    isempty(r) | (i == oftype(i, r.stop) + r.step)
 
-start(r::UnitRange) = oftype(r.start+1, r.start)
-next{T}(r::UnitRange{T}, i) = (convert(T,i), i+1)
-done(r::UnitRange, i) = i==oftype(i,r.stop)+1
+start{T}(r::UnitRange{T}) = oftype(r.start + one(T), r.start)
+next{T}(r::UnitRange{T}, i) = (convert(T, i), i + one(T))
+done{T}(r::UnitRange{T}, i) = i == oftype(i, r.stop) + one(T)
 
 
+# some special cases to favor default Int type to avoid overflow
+let smallint = (Int === Int64 ?
+                Union{Int8,UInt8,Int16,UInt16,Int32,UInt32} :
+                Union{Int8,UInt8,Int16,UInt16})
+    global start
+    global next
+    start{T<:smallint}(r::StepRange{T}) = convert(Int, r.start)
+    next{T<:smallint}(r::StepRange{T}, i) = (i % T, i + r.step)
+    start{T<:smallint}(r::UnitRange{T}) = convert(Int, r.start)
+    next{T<:smallint}(r::UnitRange{T}, i) = (i % T, i + 1)
+end
+
 ## indexing
 
-getindex(r::Range, i::Integer) = (checkbounds(r, i); unsafe_getindex(r, i))
-unsafe_getindex{T}(v::Range{T}, i::Integer) = convert(T, first(v) + (i-1)*step(v))
+function getindex{T}(v::Range{T}, i::Integer)
+    @_inline_meta
+    @boundscheck checkbounds(v, i)
+    convert(T, first(v) + (i-1)*step(v))
+end
+function getindex{T<:Union{Int8,UInt8,Int16,UInt16,Int32,UInt32}}(v::Range{T},i::Integer)
+    @_inline_meta
+    @boundscheck checkbounds(v, i)
+    (first(v) + (i - 1) * step(v)) % T
+end
 
-getindex{T}(r::FloatRange{T}, i::Integer) = (checkbounds(r, i); unsafe_getindex(r, i))
-unsafe_getindex{T}(r::FloatRange{T}, i::Integer) = convert(T, (r.start + (i-1)*r.step)/r.divisor)
+function getindex{T}(r::FloatRange{T}, i::Integer)
+    @_inline_meta
+    @boundscheck checkbounds(r, i);
+    convert(T, (r.start + (i-1)*r.step)/r.divisor)
+end
 
-getindex{T}(r::LinSpace{T}, i::Integer) = (checkbounds(r, i); unsafe_getindex(r, i))
-unsafe_getindex{T}(r::LinSpace{T}, i::Integer) = convert(T, ((r.len-i)*r.start + (i-1)*r.stop)/r.divisor)
+function getindex{T}(r::LinSpace{T}, i::Integer)
+    @_inline_meta
+    @boundscheck checkbounds(r, i);
+    convert(T, ((r.len-i)*r.start + (i-1)*r.stop)/r.divisor)
+end
 
 getindex(r::Range, ::Colon) = copy(r)
-unsafe_getindex(r::Range, ::Colon) = copy(r)
 
-getindex(r::UnitRange, s::UnitRange{Int}) = (checkbounds(r, s); unsafe_getindex(r, s))
-function unsafe_getindex(r::UnitRange, s::UnitRange{Int})
+function getindex{T<:Integer}(r::UnitRange, s::UnitRange{T})
+    @_inline_meta
+    @boundscheck checkbounds(r, s)
     st = oftype(r.start, r.start + s.start-1)
     range(st, length(s))
 end
 
-getindex(r::UnitRange, s::StepRange{Int}) = (checkbounds(r, s); unsafe_getindex(r, s))
-function unsafe_getindex(r::UnitRange, s::StepRange{Int})
+function getindex{T<:Integer}(r::UnitRange, s::StepRange{T})
+    @_inline_meta
+    @boundscheck checkbounds(r, s)
     st = oftype(r.start, r.start + s.start-1)
     range(st, step(s), length(s))
 end
 
-getindex(r::StepRange, s::Range{Int}) = (checkbounds(r, s); unsafe_getindex(r, s))
-function unsafe_getindex(r::StepRange, s::Range{Int})
+function getindex{T<:Integer}(r::StepRange, s::Range{T})
+    @_inline_meta
+    @boundscheck checkbounds(r, s)
     st = oftype(r.start, r.start + (first(s)-1)*step(r))
     range(st, step(r)*step(s), length(s))
 end
 
-getindex(r::FloatRange, s::OrdinalRange) = (checkbounds(r, s); unsafe_getindex(r, s))
-function unsafe_getindex(r::FloatRange, s::OrdinalRange)
+function getindex(r::FloatRange, s::OrdinalRange)
+    @_inline_meta
+    @boundscheck checkbounds(r, s)
     FloatRange(r.start + (first(s)-1)*r.step, step(s)*r.step, length(s), r.divisor)
 end
 
-getindex(r::LinSpace, s::OrdinalRange) = (checkbounds(r, s); unsafe_getindex(r, s))
-function unsafe_getindex{T}(r::LinSpace{T}, s::OrdinalRange)
+function getindex{T}(r::LinSpace{T}, s::OrdinalRange)
+    @_inline_meta
+    @boundscheck checkbounds(r, s)
     sl::T = length(s)
     ifirst = first(s)
     ilast = last(s)
diff --git a/base/rational.jl b/base/rational.jl
index f52906b6d84f8..e900d8e696c68 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -57,6 +57,15 @@ function show(io::IO, x::Rational)
     show(io, den(x))
 end
 
+function read{T<:Integer}(s::IO, ::Type{Rational{T}})
+    r = read(s,T)
+    i = read(s,T)
+    r//i
+end
+function write(s::IO, z::Rational)
+    write(s,num(z),den(z))
+end
+
 convert{T<:Integer}(::Type{Rational{T}}, x::Rational) = Rational{T}(convert(T,x.num),convert(T,x.den))
 convert{T<:Integer}(::Type{Rational{T}}, x::Integer) = Rational{T}(convert(T,x), convert(T,1))
 
@@ -279,23 +288,60 @@ trunc{T}(::Type{T}, x::Rational) = convert(T,div(x.num,x.den))
 floor{T}(::Type{T}, x::Rational) = convert(T,fld(x.num,x.den))
 ceil{ T}(::Type{T}, x::Rational) = convert(T,cld(x.num,x.den))
 
-function round{T}(::Type{T}, x::Rational, ::RoundingMode{:Nearest})
-    q,r = divrem(x.num,x.den)
-    s = abs(r) < (x.den+one(x.den)+iseven(q))>>1 ? q : q+copysign(one(q),x.num)
-    convert(T,s)
+
+function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:Nearest})
+    if den(x) == zero(Tr) && T <: Integer
+        throw(DivideError())
+    elseif den(x) == zero(Tr)
+        return convert(T, copysign(one(Tr)//zero(Tr), num(x)))
+    end
+    q,r = divrem(num(x), den(x))
+    s = q
+    if abs(r) >= abs((den(x)-copysign(Tr(4), num(x))+one(Tr)+iseven(q))>>1 + copysign(Tr(2), num(x)))
+        s += copysign(one(Tr),num(x))
+    end
+    convert(T, s)
 end
-round{T}(::Type{T}, x::Rational) = round(T,x,RoundNearest)
-function round{T}(::Type{T}, x::Rational, ::RoundingMode{:NearestTiesAway})
-    q,r = divrem(x.num,x.den)
-    s = abs(r) < (x.den+one(x.den))>>1 ? q : q+copysign(one(q),x.num)
-    convert(T,s)
+
+round{T}(::Type{T}, x::Rational) = round(T, x, RoundNearest)
+
+function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesAway})
+    if den(x) == zero(Tr) && T <: Integer
+        throw(DivideError())
+    elseif den(x) == zero(Tr)
+        return convert(T, copysign(one(Tr)//zero(Tr), num(x)))
+    end
+    q,r = divrem(num(x), den(x))
+    s = q
+    if abs(r) >= abs((den(x)-copysign(Tr(4), num(x))+one(Tr))>>1 + copysign(Tr(2), num(x)))
+        s += copysign(one(Tr),num(x))
+    end
+    convert(T, s)
+end
+
+function round{T, Tr}(::Type{T}, x::Rational{Tr}, ::RoundingMode{:NearestTiesUp})
+    if den(x) == zero(Tr) && T <: Integer
+        throw(DivideError())
+    elseif den(x) == zero(Tr)
+        return convert(T, copysign(one(Tr)//zero(Tr), num(x)))
+    end
+    q,r = divrem(num(x), den(x))
+    s = q
+    if abs(r) >= abs((den(x)-copysign(Tr(4), num(x))+one(Tr)+(num(x)<0))>>1 + copysign(Tr(2), num(x)))
+        s += copysign(one(Tr),num(x))
+    end
+    convert(T, s)
 end
-function round{T}(::Type{T}, x::Rational, ::RoundingMode{:NearestTiesUp})
-    q,r = divrem(x.num,x.den)
-    s = abs(r) < (x.den+one(x.den)+(x.num<0))>>1 ? q : q+copysign(one(q),x.num)
-    convert(T,s)
+
+function round{T}(::Type{T}, x::Rational{Bool})
+    if den(x) == false && issubtype(T, Union{Integer, Bool})
+        throw(DivideError())
+    end
+    convert(T, x)
 end
 
+round{T}(::Type{T}, x::Rational{Bool}, ::RoundingMode) = round(T, x)
+
 trunc{T}(x::Rational{T}) = Rational(trunc(T,x))
 floor{T}(x::Rational{T}) = Rational(floor(T,x))
 ceil{ T}(x::Rational{T}) = Rational(ceil(T,x))
diff --git a/base/reduce.jl b/base/reduce.jl
index ce34985e74d46..d10691aab30de 100644
--- a/base/reduce.jl
+++ b/base/reduce.jl
@@ -36,10 +36,10 @@ function mapfoldl_impl(f, op, v0, itr, i)
     # Unroll the while loop once; if v0 is known, the call to op may
     # be evaluated at compile time
     if done(itr, i)
-        return v0
+        return r_promote(op, v0)
     else
         (x, i) = next(itr, i)
-        v = op(v0, f(x))
+        v = op(r_promote(op, v0), f(x))
         while !done(itr, i)
             (x, i) = next(itr, i)
             v = op(v, f(x))
@@ -71,10 +71,10 @@ function mapfoldr_impl(f, op, v0, itr, i::Integer)
     # Unroll the while loop once; if v0 is known, the call to op may
     # be evaluated at compile time
     if i == 0
-        return v0
+        return r_promote(op, v0)
     else
         x = itr[i]
-        v  = op(f(x), v0)
+        v  = op(f(x), r_promote(op, v0))
         while i > 1
             x = itr[i -= 1]
             v = op(f(x), v)
@@ -93,12 +93,12 @@ foldr(op, itr) = mapfoldr(IdFun(), op, itr)
 
 # mapreduce_***_impl require ifirst < ilast
 function mapreduce_seq_impl(f, op, A::AbstractArray, ifirst::Int, ilast::Int)
-    @inbounds fx1 = r_promote(op, f(A[ifirst]))
-    @inbounds fx2 = f(A[ifirst+=1])
-    @inbounds v = op(fx1, fx2)
+    fx1 = r_promote(op, f(A[ifirst]))
+    fx2 = f(A[ifirst+=1])
+    v = op(fx1, fx2)
     while ifirst < ilast
-        @inbounds fx = f(A[ifirst+=1])
-        v = op(v, fx)
+        @inbounds Ai = A[ifirst+=1]
+        v = op(v, f(Ai))
     end
     return v
 end
@@ -131,20 +131,22 @@ mr_empty(::Abs2Fun, op::MaxFun, T) = abs2(zero(T)::T)
 mr_empty(f, op::AndFun, T) = true
 mr_empty(f, op::OrFun, T) = false
 
-function _mapreduce{T}(f, op, A::AbstractArray{T})
+_mapreduce(f, op, A::AbstractArray) = _mapreduce(f, op, linearindexing(A), A)
+
+function _mapreduce{T}(f, op, ::LinearFast, A::AbstractArray{T})
     n = Int(length(A))
     if n == 0
         return mr_empty(f, op, T)
     elseif n == 1
         return r_promote(op, f(A[1]))
     elseif n < 16
-        @inbounds fx1 = r_promote(op, f(A[1]))
-        @inbounds fx2 = r_promote(op, f(A[2]))
+        fx1 = r_promote(op, f(A[1]))
+        fx2 = r_promote(op, f(A[2]))
         s = op(fx1, fx2)
         i = 2
         while i < n
-            @inbounds fx = f(A[i+=1])
-            s = op(s, fx)
+            @inbounds Ai = A[i+=1]
+            s = op(s, f(Ai))
         end
         return s
     else
@@ -152,7 +154,9 @@ function _mapreduce{T}(f, op, A::AbstractArray{T})
     end
 end
 
-mapreduce(f, op, A::AbstractArray) = _mapreduce(f, op, A)
+_mapreduce{T}(f, op, ::LinearSlow, A::AbstractArray{T}) = mapfoldl(f, op, A)
+
+mapreduce(f, op, A::AbstractArray) = _mapreduce(f, op, linearindexing(A), A)
 mapreduce(f, op, a::Number) = f(a)
 
 mapreduce(f, op::Function, A::AbstractArray) = mapreduce(f, specialized_binary(op), A)
@@ -180,7 +184,7 @@ sc_finish(::OrFun)  = false
 ## short-circuiting (sc) mapreduce definitions
 
 function mapreduce_sc_impl(f, op, itr::AbstractArray)
-    @inbounds for x in itr
+    for x in itr
         shortcircuits(op, f(x)) && return shorted(op)
     end
     return sc_finish(op)
@@ -220,11 +224,10 @@ mapreduce(f, op::ShortCircuiting, itr::Any)           = mapreduce_sc(f,op,itr)
 ## sum
 
 function mapreduce_seq_impl(f, op::AddFun, a::AbstractArray, ifirst::Int, ilast::Int)
-    @inbounds begin
-        s = r_promote(op, f(a[ifirst])) + f(a[ifirst+1])
-        @simd for i = ifirst+2:ilast
-            s += f(a[i])
-        end
+    s = r_promote(op, f(a[ifirst])) + f(a[ifirst+1])
+    @simd for i = ifirst+2:ilast
+        @inbounds ai = a[i]
+        s += f(ai)
     end
     s
 end
@@ -273,9 +276,6 @@ end
 prod(f::Union{Callable,Func{1}}, a) = mapreduce(f, MulFun(), a)
 prod(a) = mapreduce(IdFun(), MulFun(), a)
 
-prod(A::AbstractArray{Bool}) =
-    error("use all() instead of prod() for boolean arrays")
-
 ## maximum & minimum
 
 function mapreduce_impl(f, op::MaxFun, A::AbstractArray, first::Int, last::Int)
@@ -283,11 +283,13 @@ function mapreduce_impl(f, op::MaxFun, A::AbstractArray, first::Int, last::Int)
     v = f(A[first])
     i = first + 1
     while v != v && i <= last
-        @inbounds v = f(A[i])
+        @inbounds Ai = A[i]
+        v = f(Ai)
         i += 1
     end
     while i <= last
-        @inbounds x = f(A[i])
+        @inbounds Ai = A[i]
+        x = f(Ai)
         if x > v
             v = x
         end
@@ -301,11 +303,13 @@ function mapreduce_impl(f, op::MinFun, A::AbstractArray, first::Int, last::Int)
     v = f(A[first])
     i = first + 1
     while v != v && i <= last
-        @inbounds v = f(A[i])
+        @inbounds Ai = A[i]
+        v = f(Ai)
         i += 1
     end
     while i <= last
-        @inbounds x = f(A[i])
+        @inbounds Ai = A[i]
+        x = f(Ai)
         if x < v
             v = x
         end
@@ -390,22 +394,18 @@ end
 function count(pred, itr)
     n = 0
     for x in itr
-        pred(x) && (n += 1)
-    end
-    return n
-end
-
-function count(pred, a::AbstractArray)
-    n = 0
-    for i = 1:length(a)
-        @inbounds if pred(a[i])
-            n += 1
-        end
+        n += pred(x)
     end
     return n
 end
 
 immutable NotEqZero <: Func{1} end
-call(::NotEqZero, x) = x != 0
+(::NotEqZero)(x) = x != 0
+
+"""
+    countnz(A)
 
+Counts the number of nonzero values in array `A` (dense or sparse). Note that this is not a constant-time operation.
+For sparse matrices, one should usually use `nnz`, which returns the number of stored values.
+"""
 countnz(a) = count(NotEqZero(), a)
diff --git a/base/reducedim.jl b/base/reducedim.jl
index 77d1d0af5e1cb..e98151bfefda4 100644
--- a/base/reducedim.jl
+++ b/base/reducedim.jl
@@ -222,8 +222,6 @@ function _mapreducedim!{T,N}(f, op, R::AbstractArray, A::AbstractArray{T,N})
     return R
 end
 
-mapreducedim!(f, op, R::AbstractArray, A::AbstractArray) = (_mapreducedim!(f, op, R, A); R)
-
 to_op(op) = op
 function to_op(op::Function)
     is(op, +) ? AddFun() :
@@ -325,12 +323,18 @@ function findminmax!{T,N}(f, Rval, Rind, A::AbstractArray{T,N})
     Rval, Rind
 end
 
-# findmin
+
+"""
+    findmin!(rval, rind, A, [init=true]) -> (minval, index)
+
+Find the minimum of `A` and the corresponding linear index along singleton
+dimensions of `rval` and `rind`, and store the results in `rval` and `rind`.
+"""
 function findmin!{R}(rval::AbstractArray{R},
                      rind::AbstractArray,
                      A::AbstractArray;
                      init::Bool=true)
-    findminmax!(LessFun(), initarray!(rval, typemax(R), init), rind, A)
+    findminmax!(LessFun(), initarray!(rval, MinFun(), init), rind, A)
 end
 
 function findmin{T}(A::AbstractArray{T}, region)
@@ -342,12 +346,17 @@ function findmin{T}(A::AbstractArray{T}, region)
             zeros(Int, reduced_dims0(A, region)), A)
 end
 
-# findmax
+"""
+    findmax!(rval, rind, A, [init=true]) -> (maxval, index)
+
+Find the maximum of `A` and the corresponding linear index along singleton
+dimensions of `rval` and `rind`, and store the results in `rval` and `rind`.
+"""
 function findmax!{R}(rval::AbstractArray{R},
                      rind::AbstractArray,
                      A::AbstractArray;
                      init::Bool=true)
-    findminmax!(MoreFun(), initarray!(rval, typemin(R), init), rind, A)
+    findminmax!(MoreFun(), initarray!(rval, MaxFun(), init), rind, A)
 end
 
 function findmax{T}(A::AbstractArray{T}, region)
diff --git a/base/reflection.jl b/base/reflection.jl
index 26a0deb1a6239..b24a2c7acbca1 100644
--- a/base/reflection.jl
+++ b/base/reflection.jl
@@ -51,7 +51,18 @@ function resolve(g::GlobalRef; force::Bool=false)
     return g
 end
 
-fieldnames(t::DataType) = Symbol[n for n in t.name.names ]
+"""
+    fieldname(x::DataType, i)
+
+Get the name of field `i` of a `DataType`.
+"""
+fieldname(t::DataType, i::Integer) = t.name.names[i]::Symbol
+
+"""
+    fieldnames(x::DataType)
+
+Get an array of the fields of a `DataType`.
+"""
 function fieldnames(v)
     t = typeof(v)
     if !isa(t,DataType)
@@ -59,8 +70,7 @@ function fieldnames(v)
     end
     return fieldnames(t)
 end
-
-fieldname(t::DataType, i::Integer) = t.name.names[i]::Symbol
+fieldnames(t::DataType) = Symbol[fieldname(t, n) for n in 1:nfields(t)]
 
 isconst(s::Symbol) = ccall(:jl_is_const, Int32, (Ptr{Void}, Any), C_NULL, s) != 0
 
@@ -71,25 +81,52 @@ isconst(m::Module, s::Symbol) =
 object_id(x::ANY) = ccall(:jl_object_id, UInt, (Any,), x)
 
 # type predicates
-isimmutable(x::ANY) = (isa(x,Tuple) || !typeof(x).mutable)
-isstructtype(t::DataType) = nfields(t) != 0 || (t.size==0 && !t.abstract)
-isstructtype(x) = false
-isbits(t::DataType) = !t.mutable & t.pointerfree & isleaftype(t)
-isbits(t::Type) = false
-isbits(x) = isbits(typeof(x))
-isleaftype(t::ANY) = ccall(:jl_is_leaf_type, Int32, (Any,), t) != 0
-
-typeintersect(a::ANY,b::ANY) = ccall(:jl_type_intersection, Any, (Any,Any), a, b)
-typeseq(a::ANY,b::ANY) = a<:b && b<:a
-
-function fieldoffsets(x::DataType)
-    offsets = Array(Int, nfields(x))
-    ccall(:jl_field_offsets, Void, (Any, Ptr{Int}), x, offsets)
-    offsets
-end
-
-type_alignment(x::DataType) = ccall(:jl_get_alignment,Csize_t,(Any,),x)
-field_offset(x::DataType,idx) = ccall(:jl_get_field_offset,Csize_t,(Any,Int32),x,idx)
+isimmutable(x::ANY) = (@_pure_meta; (isa(x,Tuple) || !typeof(x).mutable))
+isstructtype(t::DataType) = (@_pure_meta; nfields(t) != 0 || (t.size==0 && !t.abstract))
+isstructtype(x) = (@_pure_meta; false)
+isbits(t::DataType) = (@_pure_meta; !t.mutable & t.pointerfree & isleaftype(t))
+isbits(t::Type) = (@_pure_meta; false)
+isbits(x) = (@_pure_meta; isbits(typeof(x)))
+isleaftype(t::ANY) = (@_pure_meta; ccall(:jl_is_leaf_type, Int32, (Any,), t) != 0)
+
+typeintersect(a::ANY,b::ANY) = (@_pure_meta; ccall(:jl_type_intersection, Any, (Any,Any), a, b))
+typeseq(a::ANY,b::ANY) = (@_pure_meta; a<:b && b<:a)
+
+"""
+    fieldoffset(type, i)
+
+The byte offset of field `i` of a type relative to the data start. For example, we could
+use it in the following manner to summarize information about a struct type:
+
+```jldoctest
+julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:nfields(T)];
+
+julia> structinfo(Base.Filesystem.StatStruct)
+12-element Array{Tuple{UInt64,Symbol,Type{_}},1}:
+ (0x0000000000000000,:device,UInt64)
+ (0x0000000000000008,:inode,UInt64)
+ (0x0000000000000010,:mode,UInt64)
+ (0x0000000000000018,:nlink,Int64)
+ (0x0000000000000020,:uid,UInt64)
+ (0x0000000000000028,:gid,UInt64)
+ (0x0000000000000030,:rdev,UInt64)
+ (0x0000000000000038,:size,Int64)
+ (0x0000000000000040,:blksize,Int64)
+ (0x0000000000000048,:blocks,Int64)
+ (0x0000000000000050,:mtime,Float64)
+ (0x0000000000000058,:ctime,Float64)
+```
+"""
+fieldoffset(x::DataType, idx::Integer) = (@_pure_meta; ccall(:jl_get_field_offset, Csize_t, (Any, Cint), x, idx))
+
+"""
+    fieldtype(T, name::Symbol | index::Int)
+
+Determine the declared type of a field (specified by name or index) in a composite DataType `T`.
+"""
+fieldtype
+
+type_alignment(x::DataType) = (@_pure_meta; ccall(:jl_get_alignment, Csize_t, (Any,), x))
 
 # return all instances, for types that can be enumerated
 function instances end
@@ -100,7 +137,7 @@ function _subtypes(m::Module, x::DataType, sts=Set(), visited=Set())
     for s in names(m,true)
         if isdefined(m,s)
             t = eval(m,s)
-            if isa(t, DataType) && t.name.name == s && super(t).name == x.name
+            if isa(t, DataType) && t.name.name == s && supertype(t).name == x.name
                 ti = typeintersect(t, x)
                 ti != Bottom && push!(sts, ti)
             elseif isa(t, Module) && !in(t, visited)
@@ -114,11 +151,10 @@ subtypes(m::Module, x::DataType) = sort(collect(_subtypes(m, x)), by=string)
 subtypes(x::DataType) = subtypes(Main, x)
 
 # function reflection
-isgeneric(f::ANY) = (isa(f,Function) && isa(f.env,MethodTable))
-
-function_name(f::Function) = isgeneric(f) ? f.env.name : (:anonymous)
+function_name(f::Function) = typeof(f).name.mt.name
 
 function to_tuple_type(t::ANY)
+    @_pure_meta
     if isa(t,Tuple) || isa(t,AbstractArray) || isa(t,SimpleVector)
         t = Tuple{t...}
     end
@@ -132,58 +168,71 @@ function to_tuple_type(t::ANY)
     t
 end
 
-tt_cons(t::ANY, tup::ANY) = Tuple{t, (isa(tup, Type) ? tup.parameters : tup)...}
+tt_cons(t::ANY, tup::ANY) = (@_pure_meta; Tuple{t, (isa(tup, Type) ? tup.parameters : tup)...})
 
-code_lowered(f, t::ANY) = map(m->uncompressed_ast(m.func.code), methods(f, t))
-function methods(f::Function,t::ANY)
-    if !isgeneric(f)
+code_lowered(f, t::ANY=Tuple) = map(m->uncompressed_ast(m.func), methods(f, t))
+function methods(f::ANY,t::ANY)
+    if isa(f,Builtin)
         throw(ArgumentError("argument is not a generic function"))
     end
     t = to_tuple_type(t)
     Any[m[3] for m in _methods(f,t,-1)]
 end
-methods(f::ANY,t::ANY) = methods(call, tt_cons(isa(f,Type) ? Type{f} : typeof(f), t))
 function _methods(f::ANY,t::ANY,lim)
+    ft = isa(f,Type) ? Type{f} : typeof(f)
     if isa(t,Type)
-        _methods(f, Any[t.parameters...], length(t.parameters), lim, [])
+        _methods_by_ftype(Tuple{ft, t.parameters...}, lim)
     else
-        _methods(f, Any[t...], length(t), lim, [])
+        _methods_by_ftype(Tuple{ft, t...}, lim)
     end
 end
-function _methods(f::ANY,t::Array,i,lim::Integer,matching::Array{Any,1})
-    if i == 0
-        new = ccall(:jl_matching_methods, Any, (Any,Any,Int32), f, Tuple{t...}, lim)
-        if new === false
-            return false
+function _methods_by_ftype(t::ANY, lim)
+    tp = t.parameters
+    nu = 1
+    for ti in tp
+        if isa(ti, Union)
+            nu *= length(ti.types)
         end
+    end
+    if 1 < nu <= 64
+        return _methods(Any[tp...], length(tp), lim, [])
+    end
+    return ccall(:jl_matching_methods, Any, (Any,Int32), t, lim)
+end
+function _methods(t::Array,i,lim::Integer,matching::Array{Any,1})
+    if i == 0
+        new = ccall(:jl_matching_methods, Any, (Any,Int32), Tuple{t...}, lim)
+        new === false && return false
         append!(matching, new::Array{Any,1})
     else
         ti = t[i]
         if isa(ti, Union)
             for ty in (ti::Union).types
                 t[i] = ty
-                if _methods(f,t,i-1,lim,matching) === false
+                if _methods(t,i-1,lim,matching) === false
                     t[i] = ty
                     return false
                 end
             end
             t[i] = ti
         else
-            return _methods(f,t,i-1,lim,matching)
+            return _methods(t,i-1,lim,matching)
         end
     end
     matching
 end
 
-function methods(f::Function)
-    if !isgeneric(f)
-        throw(ArgumentError("argument is not a generic function"))
+function methods(f::ANY)
+    ft = typeof(f)
+    if ft <: Type || !isempty(ft.parameters)
+        # for these types of `f`, not every method in the table will necessarily
+        # match, so we need to filter based on its type.
+        methods(f, Tuple{Vararg{Any}})
+    else
+        ft.name.mt
     end
-    f.env
 end
 
-methods(x::ANY) = methods(call, Tuple{isa(x,Type) ? Type{x} : typeof(x), Vararg{Any}})
-
 function length(mt::MethodTable)
     n = 0
     d = mt.defs
@@ -199,13 +248,13 @@ next(mt::MethodTable, m::Method) = (m,m.next)
 done(mt::MethodTable, m::Method) = false
 done(mt::MethodTable, i::Void) = true
 
-uncompressed_ast(l::LambdaStaticData) =
+uncompressed_ast(l::LambdaInfo) =
     isa(l.ast,Expr) ? l.ast : ccall(:jl_uncompress_ast, Any, (Any,Any), l, l.ast)
 
 # Printing code representations in IR and assembly
 function _dump_function(f, t::ANY, native, wrapper, strip_ir_metadata, dump_module)
-    t = to_tuple_type(t)
-    llvmf = ccall(:jl_get_llvmf, Ptr{Void}, (Any, Any, Bool), f, t, wrapper)
+    t = tt_cons(Core.Typeof(f), to_tuple_type(t))
+    llvmf = ccall(:jl_get_llvmf, Ptr{Void}, (Any, Any, Bool, Bool), f, t, wrapper, native)
 
     if llvmf == C_NULL
         error("no method found for the specified argument types")
@@ -221,31 +270,26 @@ function _dump_function(f, t::ANY, native, wrapper, strip_ir_metadata, dump_modu
     return str
 end
 
-code_llvm(io::IO, f::Function, types::ANY, strip_ir_metadata=true, dump_module=false) =
+code_llvm(io::IO, f::ANY, types::ANY=Tuple, strip_ir_metadata=true, dump_module=false) =
     print(io, _dump_function(f, types, false, false, strip_ir_metadata, dump_module))
-code_llvm(f::ANY, types::ANY) = code_llvm(STDOUT, f, types)
-code_llvm_raw(f::ANY, types::ANY) = code_llvm(STDOUT, f, types, false)
-code_llvm(io::IO, f::ANY, t::ANY, args...) =
-    code_llvm(io, call,
-              tt_cons(isa(f, Type) ? Type{f} : typeof(f), t), args...)
+code_llvm(f::ANY, types::ANY=Tuple) = code_llvm(STDOUT, f, types)
+code_llvm_raw(f::ANY, types::ANY=Tuple) = code_llvm(STDOUT, f, types, false)
 
-code_native(io::IO, f::Function, types::ANY) =
+code_native(io::IO, f::ANY, types::ANY=Tuple) =
     print(io, _dump_function(f, types, true, false, false, false))
-code_native(f::ANY, types::ANY) = code_native(STDOUT, f, types)
-code_native(io::IO, f::ANY, t::ANY) =
-    code_native(io, call, tt_cons(isa(f, Type) ? Type{f} : typeof(f), t))
+code_native(f::ANY, types::ANY=Tuple) = code_native(STDOUT, f, types)
 
 # give a decent error message if we try to instantiate a staged function on non-leaf types
 function func_for_method_checked(m, types)
-    linfo = Core.Inference.func_for_method(m[3],types,m[2])
+    linfo = Core.Inference.func_for_method(m[3],m[1],m[2])
     if linfo === Core.Inference.NF
         error("cannot call @generated function `", m[3], "` ",
               "with abstract argument types: ", types)
     end
-    linfo::LambdaStaticData
+    linfo::LambdaInfo
 end
 
-function code_typed(f::Function, types::ANY; optimize=true)
+function code_typed(f::ANY, types::ANY=Tuple; optimize=true)
     types = to_tuple_type(types)
     asts = []
     for x in _methods(f,types,-1)
@@ -258,20 +302,14 @@ function code_typed(f::Function, types::ANY; optimize=true)
                                                          optimize=false)
         end
         if !isa(tree, Expr)
-            push!(asts, ccall(:jl_uncompress_ast, Any, (Any,Any), linfo, tree))
-        else
-            push!(asts, tree)
+            tree = ccall(:jl_uncompress_ast, Any, (Any,Any), linfo, tree)
         end
+        push!(asts, tree)
     end
     asts
 end
 
-function code_typed(f, t::ANY; optimize=true)
-    code_typed(call, tt_cons(isa(f, Type) ? Type{f} : typeof(f), t),
-               optimize=optimize)
-end
-
-function return_types(f::Function, types::ANY)
+function return_types(f::ANY, types::ANY=Tuple)
     types = to_tuple_type(types)
     rt = []
     for x in _methods(f,types,-1)
@@ -282,11 +320,10 @@ function return_types(f::Function, types::ANY)
     rt
 end
 
-function return_types(f, t::ANY)
-    return_types(call, tt_cons(isa(f, Type) ? Type{f} : typeof(f), t))
-end
-
 function which(f::ANY, t::ANY)
+    if isa(f,Builtin)
+        throw(ArgumentError("argument is not a generic function"))
+    end
     t = to_tuple_type(t)
     if isleaftype(t)
         ms = methods(f, t)
@@ -294,13 +331,8 @@ function which(f::ANY, t::ANY)
         length(ms)!=1 && error("no unique matching method for the specified argument types")
         ms[1]
     else
-        if !isa(f,Function)
-            t = Tuple{isa(f,Type) ? Type{f} : typeof(f), t.parameters...}
-            f = call
-        elseif !isgeneric(f)
-            throw(ArgumentError("argument is not a generic function"))
-        end
-        m = ccall(:jl_gf_invoke_lookup, Any, (Any, Any), f, t)
+        ft = isa(f,Type) ? Type{f} : typeof(f)
+        m = ccall(:jl_gf_invoke_lookup, Any, (Any,), Tuple{ft, t.parameters...})
         if m === nothing
             error("no method found for the specified argument types")
         end
@@ -318,7 +350,7 @@ function which_module(m::Module, s::Symbol)
 end
 
 function functionloc(m::Method)
-    lsd = m.func.code::LambdaStaticData
+    lsd = m.func::LambdaInfo
     ln = lsd.line
     if ln <= 0
         error("could not determine location of method definition")
@@ -332,8 +364,14 @@ function functionloc(f)
     m = methods(f)
     if length(m) > 1
         error("function has multiple methods; please specify a type signature")
+    elseif isempty(m)
+        if isa(f,Function)
+            error("function has no definitions")
+        else
+            error("object is not callable")
+        end
     end
-    functionloc(m.defs)
+    functionloc(first(m))
 end
 
 function function_module(f, types::ANY)
@@ -341,5 +379,11 @@ function function_module(f, types::ANY)
     if isempty(m)
         error("no matching methods")
     end
-    m[1].func.code.module
+    m[1].func.module
+end
+
+function method_exists(f::ANY, t::ANY)
+    t = to_tuple_type(t)
+    t = Tuple{isa(f,Type) ? Type{f} : typeof(f), t.parameters...}
+    return ccall(:jl_method_exists, Cint, (Any, Any), typeof(f).name.mt, t) != 0
 end
diff --git a/base/refpointer.jl b/base/refpointer.jl
index 67a3b5e052061..ca87c63cf05f0 100644
--- a/base/refpointer.jl
+++ b/base/refpointer.jl
@@ -21,8 +21,8 @@ Ref(x::Ref) = x
 Ref(x::Any) = RefValue(x)
 Ref{T}(x::Ptr{T}, i::Integer=1) = x + (i-1)*Core.sizeof(T)
 Ref(x, i::Integer) = (i != 1 && error("Object only has one element"); Ref(x))
-call{T}(::Type{Ref{T}}) = RefValue{T}() # Ref{T}()
-call{T}(::Type{Ref{T}}, x) = RefValue{T}(x) # Ref{T}(x)
+(::Type{Ref{T}}){T}() = RefValue{T}() # Ref{T}()
+(::Type{Ref{T}}){T}(x) = RefValue{T}(x) # Ref{T}(x)
 convert{T}(::Type{Ref{T}}, x) = RefValue{T}(x)
 
 function unsafe_convert{T}(P::Type{Ptr{T}}, b::RefValue{T})
@@ -61,6 +61,29 @@ function unsafe_convert(P::Type{Ptr{Any}}, b::RefArray{Any})
 end
 unsafe_convert{T}(::Type{Ptr{Void}}, b::RefArray{T}) = convert(Ptr{Void}, unsafe_convert(Ptr{T}, b))
 
+# convert Arrays to pointer arrays for ccall
+function (::Type{Ref{P}}){P<:Ptr,T<:Ptr}(a::Array{T}) # Ref{P<:Ptr}(a::Array{T<:Ptr})
+    return RefArray(a) # effectively a no-op
+end
+function (::Type{Ref{P}}){P<:Ptr,T}(a::Array{T}) # Ref{P<:Ptr}(a::Array)
+    if (!isbits(T) && T <: eltype(P))
+        # this Array already has the right memory layout for the requested Ref
+        return RefArray(a,1,false) # root something, so that this function is type-stable
+    else
+        ptrs = Array(P, length(a)+1)
+        roots = Array(Any, length(a))
+        for i = 1:length(a)
+            root = cconvert(P, a[i])
+            ptrs[i] = unsafe_convert(P, root)::P
+            roots[i] = root
+        end
+        ptrs[length(a)+1] = C_NULL
+        return RefArray(ptrs,1,roots)
+    end
+end
+cconvert{P<:Ptr,T<:Ptr}(::Union{Type{Ptr{P}},Type{Ref{P}}}, a::Array{T}) = a
+cconvert{P<:Ptr}(::Union{Type{Ptr{P}},Type{Ref{P}}}, a::Array) = Ref{P}(a)
+
 ###
 
 getindex(b::RefValue) = b.x
diff --git a/base/regex.jl b/base/regex.jl
index ce9e3d958b58c..5898349717c85 100644
--- a/base/regex.jl
+++ b/base/regex.jl
@@ -60,6 +60,26 @@ function compile(regex::Regex)
     regex
 end
 
+"""
+    @r_str -> Regex
+
+Construct a regex, such as `r"^[a-z]*\$"`. The regex also accepts one or more flags, listed
+after the ending quote, to change its behaviour:
+
+- `i` enables case-insensitive matching
+- `m` treats the `^` and `\$` tokens as matching the start and end of individual lines, as
+  opposed to the whole string.
+- `s` allows the `.` modifier to match newlines.
+- `x` enables "comment mode": whitespace is enabled except when escaped with `\\`, and `#`
+  is treated as starting a comment.
+
+For example, this regex has all three flags enabled:
+
+```julia
+julia> match(r"a+.*b+.*?d\$"ism, "Goodbye,\\nOh, angry,\\nBad world\\n")
+RegexMatch("angry,\\nBad world")
+```
+"""
 macro r_str(pattern, flags...) Regex(pattern, flags...) end
 
 copy(r::Regex) = r
@@ -135,7 +155,7 @@ function ismatch(r::Regex, s::SubString, offset::Integer=0)
                      r.match_data)
 end
 
-call(r::Regex, s) = ismatch(r, s)
+(r::Regex)(s) = ismatch(r, s)
 
 function match(re::Regex, str::Union{SubString{UTF8String}, UTF8String}, idx::Integer, add_opts::UInt32=UInt32(0))
     compile(re)
@@ -342,7 +362,7 @@ function next(itr::RegexMatchIterator, prev_match)
     (prev_match, nothing)
 end
 
-function eachmatch(re::Regex, str::AbstractString, ovr::Bool=false)
+function eachmatch(re::Regex, str::AbstractString, ovr::Bool)
     RegexMatchIterator(re,str,ovr)
 end
 
diff --git a/base/replutil.jl b/base/replutil.jl
index fa9eacda8d615..e0df155bb6483 100644
--- a/base/replutil.jl
+++ b/base/replutil.jl
@@ -1,42 +1,62 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 # fallback text/plain representation of any type:
-writemime(io::IO, ::MIME"text/plain", x) = showlimited(io, x)
+writemime(io::IO, ::MIME"text/plain", x) = showcompact(io, x)
+writemime(io::IO, ::MIME"text/plain", x::Number) = show(io, x)
 
 function writemime(io::IO, ::MIME"text/plain", f::Function)
-    if isgeneric(f)
-        n = length(f.env)
-        m = n==1 ? "method" : "methods"
-        print(io, "$(f.env.name) (generic function with $n $m)")
-    else
-        show(io, f)
+    ft = typeof(f)
+    mt = ft.name.mt
+    name = mt.name
+    isself = isdefined(ft.name.module, name) &&
+             ft == typeof(getfield(ft.name.module, name))
+    n = length(mt)
+    m = n==1 ? "method" : "methods"
+    ns = isself ? string(name) : string("(::", name, ")")
+    what = startswith(ns, '@') ? "macro" : "generic function"
+    print(io, ns, " (", what, " with $n $m)")
+end
+
+function writemime(io::IO, ::MIME"text/plain", f::Builtin)
+    print(io, typeof(f).name.mt.name, " (built-in function)")
+end
+
+# writemime for ranges, e.g.
+#  3-element UnitRange{Int64,Int}
+#   1,2,3
+# or for more elements than fit on screen:
+#   1.0,2.0,3.0,…,6.0,7.0,8.0
+function writemime(io::IO, ::MIME"text/plain", r::Range)
+    print(io, summary(r))
+    if !isempty(r)
+        println(io, ":")
+        print_range(IOContext(io, :limit_output => true), r)
     end
 end
 
 function writemime(io::IO, ::MIME"text/plain", v::AbstractVector)
-    if isa(v, Range)
-        show(io, v)
-    else
-        print(io, summary(v))
-        if !isempty(v)
-            println(io, ":")
-            with_output_limit(()->print_matrix(io, v))
-        end
+    print(io, summary(v))
+    if !isempty(v)
+        println(io, ":")
+        print_matrix(IOContext(io, :limit_output => true), v)
     end
 end
 
 writemime(io::IO, ::MIME"text/plain", v::AbstractArray) =
-    with_output_limit(()->showarray(io, v, header=true, repr=false))
+    showarray(IOContext(io, :limit_output => true), v, header=true, repr=false)
 
 function writemime(io::IO, ::MIME"text/plain", v::DataType)
     show(io, v)
     # TODO: maybe show constructor info?
 end
 
-writemime(io::IO, ::MIME"text/plain", t::Associative) =
-    showdict(io, t, limit=true)
-writemime(io::IO, ::MIME"text/plain", t::Union{KeyIterator, ValueIterator}) =
-    showkv(io, t, limit=true)
+function writemime(io::IO, ::MIME"text/plain", t::Task)
+    show(io, t)
+    if t.state == :failed
+        println(io)
+        showerror(io, CapturedException(t.result, t.backtrace))
+    end
+end
 
 
 # showing exception objects as descriptive error messages
@@ -72,9 +92,6 @@ function showerror(io::IO, ex::TypeError)
             tstr = string(typeof(ex.got))
         end
         print(io, "$(ex.func): $(ctx)expected $(ex.expected), got $tstr")
-        if ex.func === :apply && ex.expected <: Function && isa(ex.got, AbstractArray)
-            print(io, "\nUse square brackets [] for indexing.")
-        end
     end
 end
 
@@ -103,13 +120,15 @@ showerror(io::IO, ex::InitError) = showerror(io, ex, [])
 function showerror(io::IO, ex::DomainError, bt; backtrace=true)
     print(io, "DomainError:")
     for b in bt
-        code = ccall(:jl_lookup_code_address, Any, (Ptr{Void}, Cint), b-1, true)
-        if length(code) == 7 && !code[6]  # code[6] == fromC
-            if code[1] in (:log, :log2, :log10, :sqrt) # TODO add :besselj, :besseli, :bessely, :besselk
-                print(io,"\n$(code[1]) will only return a complex result if called with a complex argument. Try $(code[1])(complex(x)).")
-            elseif (code[1] == :^ && code[2] == symbol("intfuncs.jl")) || code[1] == :power_by_squaring #3024
+        code = StackTraces.lookup(b)
+        if !code.from_c
+            if code.func in (:log, :log2, :log10, :sqrt) # TODO add :besselj, :besseli, :bessely, :besselk
+                print(io,"\n$(code.func) will only return a complex result if called with a complex argument. Try $(string(code.func))(complex(x)).")
+            elseif (code.func == :^ && code.file == symbol("intfuncs.jl")) || code.func == :power_by_squaring #3024
                 print(io, "\nCannot raise an integer x to a negative power -n. \nMake x a float by adding a zero decimal (e.g. 2.0^-n instead of 2^-n), or write 1/x^n, float(x)^-n, or (x//1)^-n.")
-            elseif code[1] == :^ && (code[2] == symbol("promotion.jl") || code[2] == symbol("math.jl"))
+            elseif code.func == :^ &&
+                    (code.file == symbol("promotion.jl") || code.file == symbol("math.jl") ||
+                    code.file == symbol(joinpath(".","promotion.jl")) || code.file == symbol(joinpath(".","math.jl")))
                 print(io, "\nExponentiation yielding a complex result requires a complex argument.\nReplace x^y with (x+0im)^y, Complex(x)^y, or similar.")
             end
             break
@@ -119,7 +138,13 @@ function showerror(io::IO, ex::DomainError, bt; backtrace=true)
     nothing
 end
 
-showerror(io::IO, ex::SystemError) = print(io, "SystemError: $(ex.prefix): $(Libc.strerror(ex.errnum))")
+function showerror(io::IO, ex::SystemError)
+    if ex.extrainfo == nothing
+        print(io, "SystemError: $(ex.prefix): $(Libc.strerror(ex.errnum))")
+    else
+        print(io, "SystemError (with $(ex.extrainfo)): $(ex.prefix): $(Libc.strerror(ex.errnum))")
+    end
+end
 showerror(io::IO, ::DivideError) = print(io, "DivideError: integer division error")
 showerror(io::IO, ::StackOverflowError) = print(io, "StackOverflowError:")
 showerror(io::IO, ::UndefRefError) = print(io, "UndefRefError: access to undefined reference")
@@ -138,29 +163,48 @@ function showerror(io::IO, ex::MethodError)
     arg_types = is_arg_types ? ex.args : typesof(ex.args...)
     arg_types_param::SimpleVector = arg_types.parameters
     print(io, "MethodError: ")
-    if isa(ex.f, Tuple)
-        f = ex.f[1]
-        print(io, "<inline> ")
-    else
-        f = ex.f
-    end
-    name = isgeneric(f) ? f.env.name : :anonymous
-    if isa(f, DataType)
-        print(io, "`$(f)` has no method matching $(f)(")
+    f = ex.f
+    ft = typeof(f)
+    name = ft.name.mt.name
+    f_is_function = false
+    if f == Base.convert && length(arg_types_param) == 2 && !is_arg_types
+        f_is_function = true
+        # See #13033
+        T = striptype(ex.args[1])
+        if T == nothing
+            print(io, "First argument to `convert` must be a Type, got ", ex.args[1])
+        else
+            print(io, "Cannot `convert` an object of type ", arg_types_param[2], " to an object of type ", T)
+        end
+    elseif isempty(methods(f)) && !isa(f, Function)
+        print(io, "objects of type $ft are not callable")
     else
-        print(io, "`$(name)` has no method matching $(name)(")
+        if ft <: Function && isempty(ft.parameters) &&
+                isdefined(ft.name.module, name) &&
+                ft == typeof(getfield(ft.name.module, name))
+            f_is_function = true
+            print(io, "no method matching ", name)
+        elseif isa(f, Type)
+            print(io, "no method matching ", f)
+        else
+            print(io, "no method matching (::", ft, ")")
+        end
+        print(io, "(")
+        for (i, typ) in enumerate(arg_types_param)
+            print(io, "::$typ")
+            i == length(arg_types_param) || print(io, ", ")
+        end
+        print(io, ")")
     end
-    for (i, typ) in enumerate(arg_types_param)
-        print(io, "::$typ")
-        i == length(arg_types_param) || print(io, ", ")
+    if ft <: AbstractArray
+        print(io, "\nUse square brackets [] for indexing an Array.")
     end
-    print(io, ")")
     # Check for local functions that shadow methods in Base
-    if isdefined(Base, name)
-        basef = eval(Base, name)
-        if basef !== ex.f && isgeneric(basef) && method_exists(basef, arg_types)
+    if f_is_function && isdefined(Base, name)
+        basef = getfield(Base, name)
+        if basef !== ex.f && method_exists(basef, arg_types)
             println(io)
-            print(io, "you may have intended to import Base.$(name)")
+            print(io, "you may have intended to import Base.", name)
         end
     end
     if !is_arg_types
@@ -180,7 +224,7 @@ function showerror(io::IO, ex::MethodError)
     end
     # Give a helpful error message if the user likely called a type constructor
     # and sees a no method error for convert
-    if (f == Base.convert && !isempty(arg_types_param) && !is_arg_types &&
+    if (f === Base.convert && !isempty(arg_types_param) && !is_arg_types &&
         isa(arg_types_param[1], DataType) &&
         arg_types_param[1].name === Type.name)
         construct_type = arg_types_param[1].parameters[1]
@@ -188,27 +232,30 @@ function showerror(io::IO, ex::MethodError)
         print(io, "This may have arisen from a call to the constructor $construct_type(...),",
                   "\nsince type constructors fall back to convert methods.")
     end
-    show_method_candidates(io, ex)
+    try
+        show_method_candidates(io, ex)
+    catch
+        warn(io, "Error showing method candidates, aborted")
+    end
 end
 
+striptype{T}(::Type{T}) = T
+striptype(::Any) = nothing
+
 #Show an error by directly calling jl_printf.
 #Useful in Base submodule __init__ functions where STDERR isn't defined yet.
 function showerror_nostdio(err, msg::AbstractString)
     stderr_stream = ccall(:jl_stderr_stream, Ptr{Void}, ())
-    ccall(:jl_printf, UInt, (Ptr{Void},Cstring), stderr_stream, msg)
-    ccall(:jl_printf, UInt, (Ptr{Void},Cstring), stderr_stream, ":\n")
-    ccall(:jl_static_show, UInt, (Ptr{Void},Ptr{Void}), stderr_stream,
-          pointer_from_objref(err))
-    ccall(:jl_printf, UInt, (Ptr{Void},Cstring), stderr_stream, "\n")
+    ccall(:jl_printf, Cint, (Ptr{Void},Cstring), stderr_stream, msg)
+    ccall(:jl_printf, Cint, (Ptr{Void},Cstring), stderr_stream, ":\n")
+    ccall(:jl_static_show, Csize_t, (Ptr{Void},Any), stderr_stream, err)
+    ccall(:jl_printf, Cint, (Ptr{Void},Cstring), stderr_stream, "\n")
 end
 
-const UNSHOWN_METHODS = ObjectIdDict(
-    which(call, Tuple{Type, Vararg{Any}}) => true
-)
 function show_method_candidates(io::IO, ex::MethodError)
     is_arg_types = isa(ex.args, DataType)
     arg_types = is_arg_types ? ex.args : typesof(ex.args...)
-    arg_types_param::SimpleVector = arg_types.parameters
+    arg_types_param = Any[arg_types.parameters...]
     # Displays the closest candidates of the given function by looping over the
     # functions methods and counting the number of matching arguments.
     if isa(ex.f, Tuple)
@@ -220,36 +267,50 @@ function show_method_candidates(io::IO, ex::MethodError)
     lines = []
     # These functions are special cased to only show if first argument is matched.
     special = f in [convert, getindex, setindex!]
-    funcs = [f]
+    funcs = Any[(Core.Typeof(f),arg_types_param)]
 
     # An incorrect call method produces a MethodError for convert.
     # It also happens that users type convert when they mean call. So
     # pool MethodErrors for these two functions.
-    f === convert && push!(funcs, call)
+    if f === convert && !isempty(arg_types_param)
+        push!(funcs, (arg_types_param[1],arg_types_param[2:end]))
+    end
 
-    for func in funcs
-        name = isgeneric(func) ? func.env.name : :anonymous
-        for method in methods(func)
-            haskey(UNSHOWN_METHODS, method) && continue
+    for (func,arg_types_param) in funcs
+        for method in func.name.mt
             buf = IOBuffer()
-            sig = method.sig.parameters
-            use_constructor_syntax = func == call && !isempty(sig) && isa(sig[1], DataType) &&
-                                     !isempty(sig[1].parameters) && isa(sig[1].parameters[1], DataType)
-            print(buf, "  ", use_constructor_syntax ? sig[1].parameters[1].name : name)
+            s1 = method.sig.parameters[1]
+            sig = method.sig.parameters[2:end]
+            print(buf, "  ")
+            if !(func <: s1)
+                # function itself doesn't match
+                print(buf, "(")
+                if Base.have_color
+                    Base.with_output_color(:red, buf) do buf
+                        print(buf, "::", s1)
+                    end
+                else
+                    print(buf, "!Matched::", s1)
+                end
+                print(buf, ")")
+            else
+                use_constructor_syntax = func.name === Type.name && !isa(func.parameters[1],TypeVar)
+                print(buf, use_constructor_syntax ? func.parameters[1] : func.name.mt.name)
+            end
             right_matches = 0
             tv = method.tvars
             if !isa(tv,SimpleVector)
-                tv = svec(tv)
+                tv = Any[tv]
             end
             if !isempty(tv)
                 show_delim_array(buf, tv, '{', ',', '}', false)
             end
             print(buf, "(")
-            t_i = Any[arg_types_param...]
+            t_i = copy(arg_types_param)
             right_matches = 0
             for i = 1 : min(length(t_i), length(sig))
-                i > (use_constructor_syntax ? 2 : 1) && print(buf, ", ")
-                # If isvarargtype then it checks wether the rest of the input arguements matches
+                i > 1 && print(buf, ", ")
+                # If isvarargtype then it checks whether the rest of the input arguments matches
                 # the varargtype
                 if Base.isvarargtype(sig[i])
                     sigstr = string(sig[i].parameters[1], "...")
@@ -263,9 +324,7 @@ function show_method_candidates(io::IO, ex::MethodError)
                 # If the function is one of the special cased then it should break the loop if
                 # the type of the first argument is not matched.
                 t_in === Union{} && special && i == 1 && break
-                if use_constructor_syntax && i == 1
-                    right_matches += i
-                elseif t_in === Union{}
+                if t_in === Union{}
                     if Base.have_color
                         Base.with_output_color(:red, buf) do buf
                             print(buf, "::$sigstr")
@@ -320,7 +379,7 @@ function show_method_candidates(io::IO, ex::MethodError)
         end
     end
 
-    if length(lines) != 0 # Display up to three closest candidates
+    if !isempty(lines) # Display up to three closest candidates
         Base.with_output_color(:normal, io) do io
             println(io)
             print(io, "Closest candidates are:")
@@ -339,53 +398,27 @@ function show_method_candidates(io::IO, ex::MethodError)
     end
 end
 
-function show_trace_entry(io, fname, file, line, inlinedat_file, inlinedat_line, n)
+function show_trace_entry(io, frame, n)
     print(io, "\n")
-    # if we have inlining information, we print the `file`:`line` first,
-    # then show the inlining info, because the inlining location
-    # corresponds to `fname`.
-    if (inlinedat_file != symbol(""))
-        # align the location text
-        print(io, " [inlined code] from ")
-    else
-        print(io, " in ", fname, " at ")
-    end
-
-    print(io, file)
-
-    if line >= 1
-        try
-            print(io, ":", line)
-        catch
-            print(io, '?') #for when dec is not yet defined
-        end
-    end
-
-    if n > 1
-        print(io, " (repeats ", n, " times)")
-    end
-
-    if (inlinedat_file != symbol(""))
-        print(io, "\n in ", fname, " at ")
-        print(io, inlinedat_file, ":", inlinedat_line)
-    end
+    show(io, frame, full_path=true)
+    n > 1 && print(io, " (repeats ", n, " times)")
 end
 
-function show_backtrace(io::IO, t, set=1:typemax(Int))
+function show_backtrace(io::IO, t::Vector, set=1:typemax(Int))
     # we may not declare :eval_user_input
     # directly so that we get a compile error
     # in case its name changes in the future
     show_backtrace(io,
                     try
-                        eval_user_input.env.name
+                        typeof(eval_user_input).name.mt.name
                     catch
                         :(:) #for when client.jl is not yet defined
                     end, t, set)
 end
 
-function show_backtrace(io::IO, top_function::Symbol, t, set)
-    process_entry(lastname, lastfile, lastline, last_inlinedat_file, last_inlinedat_line, n) =
-        show_trace_entry(io, lastname, lastfile, lastline, last_inlinedat_file, last_inlinedat_line, n)
+function show_backtrace(io::IO, top_function::Symbol, t::Vector, set)
+    process_entry(last_frame, n) =
+        show_trace_entry(io, last_frame, n)
     process_backtrace(process_entry, top_function, t, set)
 end
 
@@ -396,37 +429,33 @@ function show_backtrace(io::IO, top_function::Symbol, t::Vector{Any}, set)
 end
 
 # process the backtrace, up to (but not including) top_function
-function process_backtrace(process_func::Function, top_function::Symbol, t, set)
-    n = 1
-    lastfile = ""; lastline = -11; lastname = symbol("#");
-    last_inlinedat_file = ""; last_inlinedat_line = -1
-    local fname, file, line
+function process_backtrace(process_func::Function, top_function::Symbol, t::Vector, set; skipC = true)
+    n = 0
+    last_frame = StackTraces.UNKNOWN
     count = 0
     for i = 1:length(t)
-        lkup = ccall(:jl_lookup_code_address, Any, (Ptr{Void}, Cint), t[i]-1, true)
-        if lkup === nothing
+        lkup = StackTraces.lookup(t[i])
+        if lkup === StackTraces.UNKNOWN
             continue
         end
-        fname, file, line, inlinedat_file, inlinedat_line, fromC = lkup
 
-        if fromC; continue; end
-        if i == 1 && fname == :error; continue; end
-        if fname == top_function; break; end
+        if lkup.from_c && skipC; continue; end
+        if i == 1 && lkup.func == :error; continue; end
+        if lkup.func == top_function; break; end
         count += 1
         if !in(count, set); continue; end
 
-        if file != lastfile || line != lastline || fname != lastname
-            if lastline != -11
-                process_func(lastname, lastfile, lastline, last_inlinedat_file, last_inlinedat_line, n)
+        if lkup.file != last_frame.file || lkup.line != last_frame.line || lkup.func != last_frame.func
+            if n > 0
+                process_func(last_frame, n)
             end
             n = 1
-            lastfile = file; lastline = line; lastname = fname;
-            last_inlinedat_file = inlinedat_file; last_inlinedat_line = inlinedat_line;
+            last_frame = lkup
         else
             n += 1
         end
     end
-    if n > 1 || lastline != -11
-        process_func(lastname, lastfile, lastline, last_inlinedat_file, last_inlinedat_line, n)
+    if n > 0
+        process_func(last_frame, n)
     end
 end
diff --git a/base/require.jl b/base/require.jl
index a1787ece7996e..edff3d41cf71c 100644
--- a/base/require.jl
+++ b/base/require.jl
@@ -1,3 +1,5 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
 # deprecated require
 module OldRequire
 
@@ -11,7 +13,7 @@ function find_in_path(name::AbstractString)
         name = string(base,".jl")
         isfile(name) && return abspath(name)
     end
-    for prefix in [Pkg.dir(), LOAD_PATH]
+    for prefix in [Pkg.dir(); LOAD_PATH]
         path = joinpath(prefix, name)
         isfile(path) && return abspath(path)
         path = joinpath(prefix, base, "src", name)
@@ -23,12 +25,12 @@ function find_in_path(name::AbstractString)
 end
 
 find_in_node1_path(name) = myid()==1 ?
-    find_in_path(name) : remotecall_fetch(1, find_in_path, name)
+    find_in_path(name) : remotecall_fetch(find_in_path, 1, name)
 
 # Store list of files and their load time
-package_list = (ByteString=>Float64)[]
+package_list = Dict{ByteString,Float64}()
 # to synchronize multiple tasks trying to require something
-package_locks = (ByteString=>Any)[]
+package_locks = Dict{ByteString,Any}()
 
 # only broadcast top-level (not nested) requires and reloads
 toplevel_load = true
@@ -41,7 +43,7 @@ function require(name::ByteString)
     path == nothing && error("$name not found")
 
     if myid() == 1 && toplevel_load
-        refs = { @spawnat p _require(path) for p in filter(x->x!=1, procs()) }
+        refs = Any[ @spawnat p _require(path) for p in filter(x->x!=1, procs()) ]
         _require(path)
         for r in refs; wait(r); end
     else
@@ -67,7 +69,7 @@ end
 
 # remote/parallel load
 
-function source_path(default::Union(AbstractString,Nothing)="")
+function source_path(default::Union{AbstractString,Void}="")
     t = current_task()
     while true
         s = t.storage
@@ -94,7 +96,7 @@ function include_from_node1(path::AbstractString)
             result = Core.include(path)
             nprocs()>1 && sleep(0.005)
         else
-            result = include_string(remotecall_fetch(1, readall, path), path)
+            result = include_string(remotecall_fetch(readstring, 1, path), path)
         end
     finally
         if prev == nothing
@@ -109,7 +111,7 @@ end
 function reload_path(path::AbstractString)
     had = haskey(package_list, path)
     if !had
-        package_locks[path] = RemoteRef()
+        package_locks[path] = RemoteChannel()
     end
     package_list[path] = time()
     tls = task_local_storage()
diff --git a/base/rounding.jl b/base/rounding.jl
index 96490407452c2..692e1d81ba881 100644
--- a/base/rounding.jl
+++ b/base/rounding.jl
@@ -1,12 +1,12 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 module Rounding
-include("fenv_constants.jl")
+include(UTF8String(vcat(length(Core.ARGS)>=2?Core.ARGS[2].data:"".data, "fenv_constants.jl".data))) # include($BUILDROOT/base/fenv_constants.jl)
 
 export
     RoundingMode, RoundNearest, RoundToZero, RoundUp, RoundDown, RoundFromZero,
     RoundNearestTiesAway, RoundNearestTiesUp,
-    get_rounding, set_rounding, with_rounding,
+    rounding, setrounding,
     get_zero_subnormals, set_zero_subnormals
 
 ## rounding modes ##
@@ -41,25 +41,26 @@ function from_fenv(r::Integer)
     end
 end
 
-set_rounding_raw{T<:Union{Float32,Float64}}(::Type{T},i::Integer) = ccall(:fesetround, Cint, (Cint,), i)
-get_rounding_raw{T<:Union{Float32,Float64}}(::Type{T}) = ccall(:fegetround, Cint, ())
+setrounding_raw{T<:Union{Float32,Float64}}(::Type{T},i::Integer) = ccall(:fesetround, Int32, (Int32,), i)
+rounding_raw{T<:Union{Float32,Float64}}(::Type{T}) = ccall(:fegetround, Int32, ())
 
-set_rounding{T<:Union{Float32,Float64}}(::Type{T},r::RoundingMode) = set_rounding_raw(T,to_fenv(r))
-get_rounding{T<:Union{Float32,Float64}}(::Type{T}) = from_fenv(get_rounding_raw(T))
+setrounding{T<:Union{Float32,Float64}}(::Type{T},r::RoundingMode) = setrounding_raw(T,to_fenv(r))
+rounding{T<:Union{Float32,Float64}}(::Type{T}) = from_fenv(rounding_raw(T))
 
-function with_rounding{T}(f::Function, ::Type{T}, rounding::RoundingMode)
-    old_rounding_raw = get_rounding_raw(T)
-    set_rounding(T,rounding)
+
+function setrounding{T}(f::Function, ::Type{T}, rounding::RoundingMode)
+    old_rounding_raw = rounding_raw(T)
+    setrounding(T,rounding)
     try
         return f()
     finally
-        set_rounding_raw(T,old_rounding_raw)
+        setrounding_raw(T,old_rounding_raw)
     end
 end
 
 
 # Should be equivalent to:
-#   with_rounding(Float64,r) do
+#   setrounding(Float64,r) do
 #       convert(T,x)
 #   end
 # but explicit checks are currently quicker (~20x).
diff --git a/base/serialize.jl b/base/serialize.jl
index afd57c6fd6bec..54ed178f8ab7c 100644
--- a/base/serialize.jl
+++ b/base/serialize.jl
@@ -3,6 +3,7 @@
 module Serializer
 
 import Base: GMP, Bottom, svec, unsafe_convert, uncompressed_ast
+using Base: ViewIndex, index_lengths
 
 export serialize, deserialize
 
@@ -13,12 +14,12 @@ export serialize, deserialize
 const TAGS = Any[
     Symbol, Int8, UInt8, Int16, UInt16, Int32, UInt32,
     Int64, UInt64, Int128, UInt128, Float32, Float64, Char, Ptr,
-    DataType, Union, Function,
+    DataType, Union, TypeName,
     Tuple, Array, Expr,
     #LongSymbol, LongTuple, LongExpr,
     Symbol, Tuple, Expr,  # dummy entries, intentionally shadowed by earlier ones
     LineNumberNode, SymbolNode, LabelNode, GotoNode,
-    QuoteNode, TopNode, TypeVar, Box, LambdaStaticData,
+    QuoteNode, TopNode, TypeVar, Box, LambdaInfo,
     Module, #=UndefRefTag=#Symbol, Task, ASCIIString, UTF8String,
     UTF16String, UTF32String, Float16,
     SimpleVector, #=BackrefTag=#Symbol, :reserved11, :reserved12,
@@ -40,7 +41,7 @@ const TAGS = Any[
     28, 29, 30, 31, 32
 ]
 
-const ser_version = 2 # do not make changes without bumping the version #!
+const ser_version = 3 # do not make changes without bumping the version #!
 
 const NTAGS = length(TAGS)
 
@@ -71,10 +72,10 @@ const BACKREF_TAG = Int32(sertag(SimpleVector)+1)
 const EXPR_TAG = sertag(Expr)
 const LONGEXPR_TAG = Int32(sertag(Expr)+3)
 const MODULE_TAG = sertag(Module)
-const FUNCTION_TAG = sertag(Function)
-const LAMBDASTATICDATA_TAG = sertag(LambdaStaticData)
+const LAMBDASTATICDATA_TAG = sertag(LambdaInfo)
 const TASK_TAG = sertag(Task)
 const DATATYPE_TAG = sertag(DataType)
+const TYPENAME_TAG = sertag(TypeName)
 const INT_TAG = sertag(Int)
 
 writetag(s::IO, tag) = write(s, UInt8(tag))
@@ -102,7 +103,7 @@ end
 serialize(s::SerializationState, x::Bool) = x ? writetag(s.io, TRUE_TAG) :
                                                 writetag(s.io, FALSE_TAG)
 
-serialize(s::SerializationState, ::Ptr) = error("cannot serialize a pointer")
+serialize(s::SerializationState, p::Ptr) = serialize_any(s, oftype(p, C_NULL))
 
 serialize(s::SerializationState, ::Tuple{}) = writetag(s.io, EMPTYTUPLE_TAG)
 
@@ -124,7 +125,7 @@ function serialize(s::SerializationState, v::SimpleVector)
     writetag(s.io, SIMPLEVECTOR_TAG)
     write(s.io, Int32(length(v)))
     for i = 1:length(v)
-        serialize(s.io, v[i])
+        serialize(s, v[i])
     end
 end
 
@@ -134,7 +135,7 @@ function serialize(s::SerializationState, x::Symbol)
         return write_as_tag(s.io, tag)
     end
     pname = unsafe_convert(Ptr{UInt8}, x)
-    ln = Int(ccall(:strlen, Csize_t, (Ptr{UInt8},), pname))
+    ln = Int(ccall(:strlen, Csize_t, (Cstring,), pname))
     if ln <= 255
         writetag(s.io, SYMBOL_TAG)
         write(s.io, UInt8(ln))
@@ -142,12 +143,12 @@ function serialize(s::SerializationState, x::Symbol)
         writetag(s.io, LONGSYMBOL_TAG)
         write(s.io, Int32(ln))
     end
-    write(s.io, pname, ln)
+    unsafe_write(s.io, pname, ln)
 end
 
 function serialize_array_data(s::IO, a)
     elty = eltype(a)
-    if elty === Bool && length(a)>0
+    if elty === Bool && !isempty(a)
         last = a[1]
         count = 1
         for i = 2:length(a)
@@ -167,11 +168,25 @@ end
 
 function serialize(s::SerializationState, a::Array)
     elty = eltype(a)
-    !isbits(elty) && serialize_cycle(s, a) && return
+    if !isbits(elty)
+        # This is subtle: whether Arrays are put in the table depends on
+        # the eltype, so we need to be able to deserialize the eltype first.
+        # However deserializing the eltype might also use the table.
+        offs = get(s.table, a, -1)
+        if offs != -1
+            writetag(s.io, BACKREF_TAG)
+            write(s.io, Int(offs))
+            return
+        end
+    end
     writetag(s.io, ARRAY_TAG)
     if elty !== UInt8
         serialize(s, elty)
     end
+    if !isbits(elty)
+        s.table[a] = s.counter
+        s.counter += 1
+    end
     if ndims(a) != 1
         serialize(s, size(a))
     else
@@ -191,18 +206,28 @@ function serialize(s::SerializationState, a::Array)
 end
 
 function serialize{T,N,A<:Array}(s::SerializationState, a::SubArray{T,N,A})
-    if !isbits(T) || stride(a,1)!=1
-        return serialize(s, copy(a))
-    end
-    writetag(s.io, ARRAY_TAG)
-    serialize(s, T)
-    serialize(s, size(a))
-    serialize_array_data(s.io, a)
+    b = trimmedsubarray(a)
+    serialize_any(s, b)
 end
 
+function trimmedsubarray{T,N,A<:Array}(V::SubArray{T,N,A})
+    dest = Array(eltype(V), trimmedsize(V))
+    copy!(dest, V)
+    _trimmedsubarray(dest, V, (), V.indexes...)
+end
+
+trimmedsize(V) = index_lengths(V.parent, V.indexes...)
+
+_trimmedsubarray{T,N,P,I,LD}(A, V::SubArray{T,N,P,I,LD}, newindexes) = SubArray{T,N,P,I,LD}(A, newindexes, size(V), 1, 1)
+_trimmedsubarray(A, V, newindexes, index::ViewIndex, indexes...) = _trimmedsubarray(A, V, (newindexes..., trimmedindex(V.parent, length(newindexes)+1, index)), indexes...)
+
+trimmedindex(P, d, i::Real) = oftype(i, 1)
+trimmedindex(P, d, i::Colon) = i
+trimmedindex(P, d, i::AbstractVector) = oftype(i, 1:length(i))
+
 function serialize{T<:AbstractString}(s::SerializationState, ss::SubString{T})
     # avoid saving a copy of the parent string, keeping the type of ss
-    invoke(serialize, Tuple{SerializationState,Any}, s, convert(SubString{T}, convert(T,ss)))
+    serialize_any(s, convert(SubString{T}, convert(T,ss)))
 end
 
 # Don't serialize the pointers
@@ -224,7 +249,7 @@ function serialize(s::SerializationState, n::BigFloat)
 end
 
 function serialize(s::SerializationState, ex::Expr)
-    serialize_cycle(s, e) && return
+    serialize_cycle(s, ex) && return
     l = length(ex.args)
     if l <= 255
         writetag(s.io, EXPR_TAG)
@@ -264,80 +289,40 @@ function serialize(s::SerializationState, m::Module)
     writetag(s.io, EMPTYTUPLE_TAG)
 end
 
-function serialize(s::SerializationState, f::Function)
-    serialize_cycle(s, f) && return
-    writetag(s.io, FUNCTION_TAG)
-    name = false
-    if isgeneric(f)
-        name = f.env.name
-    elseif isa(f.env,Symbol)
-        name = f.env
-    end
-    if isa(name,Symbol)
-        if isdefined(Base,name) && is(f,getfield(Base,name))
-            write(s.io, UInt8(0))
-            serialize(s, name)
-            return
-        end
-        mod = ()
-        if isa(f.env,Symbol)
-            mod = Core
-        elseif !is(f.env.defs, ())
-            mod = f.env.defs.func.code.module
-        end
-        if mod !== ()
-            if isdefined(mod,name) && is(f,getfield(mod,name))
-                # toplevel named func
-                write(s.io, UInt8(2))
-                serialize(s, mod)
-                serialize(s, name)
-                return
-            end
-        end
-        write(s.io, UInt8(3))
-        serialize(s, f.env)
-    else
-        linfo = f.code
-        @assert isa(linfo,LambdaStaticData)
-        write(s.io, UInt8(1))
-        serialize(s, linfo)
-        serialize(s, f.env)
-    end
-end
-
-const lambda_numbers = WeakKeyDict()
-lnumber_salt = 0
-function lambda_number(l::LambdaStaticData)
-    global lnumber_salt, lambda_numbers
-    if haskey(lambda_numbers, l)
-        return lambda_numbers[l]
+# TODO: make this bidirectional, so objects can be sent back via the same key
+const object_numbers = WeakKeyDict()
+obj_number_salt = 0
+function object_number(l::ANY)
+    global obj_number_salt, object_numbers
+    if haskey(object_numbers, l)
+        return object_numbers[l]
     end
     # a hash function that always gives the same number to the same
     # object on the same machine, and is unique over all machines.
-    ln = lnumber_salt+(UInt64(myid())<<44)
-    lnumber_salt += 1
-    lambda_numbers[l] = ln
+    ln = obj_number_salt+(UInt64(myid())<<44)
+    obj_number_salt += 1
+    object_numbers[l] = ln
     return ln
 end
 
-function serialize(s::SerializationState, linfo::LambdaStaticData)
+function serialize(s::SerializationState, linfo::LambdaInfo)
     serialize_cycle(s, linfo) && return
     writetag(s.io, LAMBDASTATICDATA_TAG)
-    serialize(s, lambda_number(linfo))
+    serialize(s, object_number(linfo))
     serialize(s, uncompressed_ast(linfo))
     if isdefined(linfo.def, :roots)
-        serialize(s, linfo.def.roots)
+        serialize(s, linfo.def.roots::Vector{Any})
     else
-        serialize(s, [])
+        serialize(s, Any[])
     end
-    serialize(s, linfo.sparams)
+    serialize(s, linfo.sparam_syms)
+    serialize(s, linfo.sparam_vals)
     serialize(s, linfo.inferred)
     serialize(s, linfo.module)
-    if isdefined(linfo, :capt)
-        serialize(s, linfo.capt)
-    else
-        serialize(s, nothing)
-    end
+    serialize(s, linfo.name)
+    serialize(s, linfo.file)
+    serialize(s, linfo.line)
+    serialize(s, linfo.pure)
 end
 
 function serialize(s::SerializationState, t::Task)
@@ -345,21 +330,81 @@ function serialize(s::SerializationState, t::Task)
     if istaskstarted(t) && !istaskdone(t)
         error("cannot serialize a running Task")
     end
+    state = [t.code,
+        t.storage,
+        t.state == :queued || t.state == :runnable ? (:runnable) : t.state,
+        t.result,
+        t.exception]
     writetag(s.io, TASK_TAG)
-    serialize(s, t.code)
-    serialize(s, t.storage)
-    serialize(s, t.state == :queued || t.state == :waiting ? (:runnable) : t.state)
-    serialize(s, t.result)
-    serialize(s, t.exception)
-end
-
-function serialize_type_data(s, t)
-    tname = t.name.name
-    serialize(s, tname)
-    mod = t.name.module
-    serialize(s, mod)
-    if length(t.parameters) > 0
-        if isdefined(mod,tname) && is(t,getfield(mod,tname))
+    for fld in state
+        serialize(s, fld)
+    end
+end
+
+function serialize(s::SerializationState, t::TypeName)
+    serialize_cycle(s, t) && return
+    writetag(s.io, TYPENAME_TAG)
+    serialize(s, object_number(t))
+    serialize(s, t.name)
+    serialize(s, t.module)
+    serialize(s, t.names)
+    serialize(s, t.primary.super)
+    serialize(s, t.primary.parameters)
+    serialize(s, t.primary.types)
+    serialize(s, t.primary.size)
+    serialize(s, t.primary.abstract)
+    serialize(s, t.primary.mutable)
+    serialize(s, t.primary.ninitialized)
+    if isdefined(t, :mt)
+        serialize(s, t.mt.name)
+        serialize(s, t.mt.defs)
+        serialize(s, t.mt.max_args)
+        if isdefined(t.mt, :kwsorter)
+            serialize(s, t.mt.kwsorter)
+        else
+            writetag(s.io, UNDEFREF_TAG)
+        end
+    else
+        writetag(s.io, UNDEFREF_TAG)
+    end
+end
+
+# decide whether to send all data for a type (instead of just its name)
+function should_send_whole_type(s, t::ANY)
+    tn = t.name
+    if isdefined(tn, :mt)
+        # TODO improve somehow
+        # send whole type for anonymous functions in Main
+        fname = tn.mt.name
+        mod = tn.module
+        toplevel = isdefined(mod, fname) && isdefined(t, :instance) &&
+            getfield(mod, fname) === t.instance
+        ishidden = unsafe_load(unsafe_convert(Ptr{UInt8}, fname))==UInt8('#')
+        return mod === __deserialized_types__ || (mod === Main && (ishidden || !toplevel))
+    end
+    return false
+end
+
+# `type_itself` means we are serializing a type object. when it's false, we are
+# sending the type tag part of some other object's representation.
+function serialize_type_data(s, t::ANY, type_itself::Bool)
+    whole = should_send_whole_type(s, t)
+    form = type_itself ? UInt8(0) : UInt8(1)
+    if whole
+        form |= UInt8(2)
+    end
+    writetag(s.io, DATATYPE_TAG)
+    write(s.io, form)
+    if whole
+        serialize(s, t.name)
+    else
+        tname = t.name.name
+        serialize(s, tname)
+        mod = t.name.module
+        serialize(s, mod)
+    end
+    if !isempty(t.parameters)
+        if (whole ? (t === t.name.primary) : (isdefined(mod,tname) && t === getfield(mod,tname)))
             serialize(s, svec())
         else
             serialize(s, t.parameters)
@@ -369,22 +414,14 @@ end
 
 function serialize(s::SerializationState, t::DataType)
     tag = sertag(t)
-    if tag > 0
-        return write_as_tag(s.io, tag)
-    end
-    writetag(s.io, DATATYPE_TAG)
-    write(s.io, UInt8(0))
-    serialize_type_data(s, t)
+    tag > 0 && return write_as_tag(s.io, tag)
+    serialize_type_data(s, t, true)
 end
 
 function serialize_type(s::SerializationState, t::DataType)
     tag = sertag(t)
-    if tag > 0
-        return writetag(s.io, tag)
-    end
-    writetag(s.io, DATATYPE_TAG)
-    write(s.io, UInt8(1))
-    serialize_type_data(s, t)
+    tag > 0 && return writetag(s.io, tag)
+    serialize_type_data(s, t, false)
 end
 
 function serialize(s::SerializationState, n::Int)
@@ -396,7 +433,9 @@ function serialize(s::SerializationState, n::Int)
     write(s.io, n)
 end
 
-function serialize(s::SerializationState, x)
+serialize(s::SerializationState, x::ANY) = serialize_any(s, x)
+
+function serialize_any(s::SerializationState, x::ANY)
     tag = sertag(x)
     if tag > 0
         return write_as_tag(s.io, tag)
@@ -407,8 +446,9 @@ function serialize(s::SerializationState, x)
         serialize_type(s, t)
         write(s.io, x)
     else
-        t.mutable && serialize_cycle(s, x) && return
+        t.mutable && haskey(s.table, x) && serialize_cycle(s, x) && return
         serialize_type(s, t)
+        t.mutable && serialize_cycle(s, x)
         for i in 1:nf
             if isdefined(x, i)
                 serialize(s, getfield(x, i))
@@ -429,7 +469,7 @@ function deserialize(s::SerializationState)
     handle_deserialize(s, Int32(read(s.io, UInt8)::UInt8))
 end
 
-function deserialize_cycle(s::SerializationState, x)
+function deserialize_cycle(s::SerializationState, x::ANY)
     if !isimmutable(x) && !typeof(x).pointerfree
         s.table[s.counter] = x
         s.counter += 1
@@ -500,60 +540,40 @@ function deserialize(s::SerializationState, ::Type{Module})
     m
 end
 
-const known_lambda_data = Dict()
+const known_object_data = Dict()
 
-function deserialize(s::SerializationState, ::Type{Function})
-    b = read(s.io, UInt8)::UInt8
-    if b==0
-        name = deserialize(s)::Symbol
-        if !isdefined(Base,name)
-            return (args...)->error("function $name not defined on process $(myid())")
-        end
-        return getfield(Base,name)::Function
-    elseif b==2
-        mod = deserialize(s)::Module
-        name = deserialize(s)::Symbol
-        if !isdefined(mod,name)
-            return (args...)->error("function $name not defined on process $(myid())")
-        end
-        return getfield(mod,name)::Function
-    elseif b==3
-        env = deserialize(s)
-        return ccall(:jl_new_gf_internal, Any, (Any,), env)::Function
-    end
-    linfo = deserialize(s)
-    f = ccall(:jl_new_closure, Any, (Ptr{Void}, Ptr{Void}, Any), C_NULL, C_NULL, linfo)::Function
-    deserialize_cycle(s, f)
-    f.env = deserialize(s)
-    return f
-end
-
-function deserialize(s::SerializationState, ::Type{LambdaStaticData})
+function deserialize(s::SerializationState, ::Type{LambdaInfo})
     lnumber = deserialize(s)
-    if haskey(known_lambda_data, lnumber)
-        linfo = known_lambda_data[lnumber]::LambdaStaticData
+    if haskey(known_object_data, lnumber)
+        linfo = known_object_data[lnumber]::LambdaInfo
         makenew = false
     else
-        linfo = ccall(:jl_new_lambda_info, Any, (Ptr{Void}, Ptr{Void}, Ptr{Void}), C_NULL, C_NULL, C_NULL)::LambdaStaticData
+        linfo = ccall(:jl_new_lambda_info, Any, (Ptr{Void}, Ptr{Void}, Ptr{Void}, Ptr{Void}), C_NULL, C_NULL, C_NULL, C_NULL)::LambdaInfo
         makenew = true
     end
     deserialize_cycle(s, linfo)
-    ast = deserialize(s)
-    roots = deserialize(s)
-    sparams = deserialize(s)
-    infr = deserialize(s)
-    mod = deserialize(s)
-    capt = deserialize(s)
+    ast = deserialize(s)::Expr
+    roots = deserialize(s)::Vector{Any}
+    sparam_syms = deserialize(s)::SimpleVector
+    sparam_vals = deserialize(s)::SimpleVector
+    infr = deserialize(s)::Bool
+    mod = deserialize(s)::Module
+    name = deserialize(s)
+    file = deserialize(s)
+    line = deserialize(s)
+    pure = deserialize(s)
     if makenew
         linfo.ast = ast
-        linfo.sparams = sparams
+        linfo.sparam_syms = sparam_syms
+        linfo.sparam_vals = sparam_vals
         linfo.inferred = infr
         linfo.module = mod
         linfo.roots = roots
-        if !is(capt,nothing)
-            linfo.capt = capt
-        end
-        known_lambda_data[lnumber] = linfo
+        linfo.name = name
+        linfo.file = file
+        linfo.line = line
+        linfo.pure = pure
+        known_object_data[lnumber] = linfo
     end
     return linfo
 end
@@ -606,9 +626,9 @@ end
 
 function deserialize_expr(s::SerializationState, len)
     hd = deserialize(s)::Symbol
-    ty = deserialize(s)
     e = Expr(hd)
     deserialize_cycle(s, e)
+    ty = deserialize(s)
     e.args = Any[ deserialize(s) for i=1:len ]
     e.typ = ty
     e
@@ -619,25 +639,101 @@ function deserialize(s::SerializationState, ::Type{Union})
     Union{types...}
 end
 
+module __deserialized_types__
+end
+
+function deserialize(s::SerializationState, ::Type{TypeName})
+    number = deserialize(s)
+    name = deserialize(s)
+    mod = deserialize(s)
+    if haskey(known_object_data, number)
+        tn = known_object_data[number]::TypeName
+        name = tn.name
+        mod = tn.module
+        makenew = false
+    elseif isdefined(mod, name)
+        tn = getfield(mod, name).name
+        # TODO: confirm somehow that the types match
+        name = tn.name
+        mod = tn.module
+        makenew = false
+    else
+        name = gensym()
+        mod = __deserialized_types__
+        tn = ccall(:jl_new_typename_in, Any, (Any, Any), name, mod)
+        makenew = true
+    end
+    deserialize_cycle(s, tn)
+
+    names = deserialize(s)
+    super = deserialize(s)
+    parameters = deserialize(s)
+    types = deserialize(s)
+    size = deserialize(s)
+    abstr = deserialize(s)
+    mutable = deserialize(s)
+    ninitialized = deserialize(s)
+
+    if makenew
+        tn.names = names
+        tn.primary = ccall(:jl_new_datatype, Any, (Any, Any, Any, Any, Any, Cint, Cint, Cint),
+                           tn, super, parameters, names, types,
+                           abstr, mutable, ninitialized)
+        known_object_data[number] = tn
+        ty = tn.primary
+        ccall(:jl_set_const, Void, (Any, Any, Any), mod, name, ty)
+        if !isdefined(ty,:instance)
+            if isempty(parameters) && !abstr && size == 0 && (!mutable || isempty(names))
+                setfield!(ty, :instance, ccall(:jl_new_struct, Any, (Any,Any...), ty))
+            end
+        end
+    end
+    tag = Int32(read(s.io, UInt8)::UInt8)
+    if tag != UNDEFREF_TAG
+        mtname = handle_deserialize(s, tag)
+        defs = deserialize(s)
+        maxa = deserialize(s)
+        if makenew
+            tn.mt = ccall(:jl_new_method_table, Any, (Any, Any), name, mod)
+            tn.mt.name = mtname
+            tn.mt.defs = defs
+            tn.mt.max_args = maxa
+        end
+        tag = Int32(read(s.io, UInt8)::UInt8)
+        if tag != UNDEFREF_TAG
+            kws = handle_deserialize(s, tag)
+            if makenew
+                tn.mt.kwsorter = kws
+            end
+        end
+    end
+
+    return tn
+end
+
 function deserialize_datatype(s::SerializationState)
     form = read(s.io, UInt8)::UInt8
-    name = deserialize(s)::Symbol
-    mod = deserialize(s)::Module
-    ty = getfield(mod,name)
-    if length(ty.parameters) == 0
+    if (form&2) != 0
+        tname = deserialize(s)::TypeName
+        ty = tname.primary
+    else
+        name = deserialize(s)::Symbol
+        mod = deserialize(s)::Module
+        ty = getfield(mod,name)
+    end
+    assert(isa(ty,DataType))
+    if isempty(ty.parameters)
         t = ty
     else
         params = deserialize(s)
         t = ty{params...}
     end
-    if form == 0
+    if (form&1) == 0
         return t
     end
     deserialize(s, t)
 end
 
-deserialize{T}(s::SerializationState, ::Type{Ptr{T}}) = convert(Ptr{T}, 0)
-
 function deserialize(s::SerializationState, ::Type{Task})
     t = Task(()->nothing)
     deserialize_cycle(s, t)
@@ -703,8 +799,6 @@ deserialize(s::SerializationState, ::Type{BigFloat}) = parse(BigFloat, deseriali
 
 deserialize(s::SerializationState, ::Type{BigInt}) = get(GMP.tryparse_internal(BigInt, deserialize(s), 62, true))
 
-deserialize(s::SerializationState, ::Type{BigInt}) = get(GMP.tryparse_internal(BigInt, deserialize(s), 62, true))
-
 function deserialize(s::SerializationState, t::Type{Regex})
     pattern = deserialize(s)
     compile_options = deserialize(s)
diff --git a/base/set.jl b/base/set.jl
index 857a36d9ea192..46a14aa73e279 100644
--- a/base/set.jl
+++ b/base/set.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-type Set{T}
+type Set{T} <: AbstractSet{T}
     dict::Dict{T,Void}
 
     Set() = new(Dict{T,Void}())
@@ -28,7 +28,7 @@ length(s::Set)  = length(s.dict)
 in(x, s::Set) = haskey(s.dict, x)
 push!(s::Set, x) = (s.dict[x] = nothing; s)
 pop!(s::Set, x) = (pop!(s.dict, x); x)
-pop!(s::Set, x, deflt) = pop!(s.dict, x, deflt) == deflt ? deflt : x
+pop!(s::Set, x, deflt) = x in s ? pop!(s, x) : deflt
 pop!(s::Set) = (idx = start(s.dict); val = s.dict.keys[idx]; _delete!(s.dict, idx); val)
 delete!(s::Set, x) = (delete!(s.dict, x); s)
 
@@ -104,7 +104,7 @@ const ⊆ = issubset
 ⊈(l::Set, r::Set) = !⊆(l, r)
 
 function unique(C)
-    out = Array(eltype(C),0)
+    out = Vector{eltype(C)}()
     seen = Set{eltype(C)}()
     for x in C
         if !in(x, seen)
@@ -115,6 +115,25 @@ function unique(C)
     out
 end
 
+"""
+    unique(f, itr)
+
+Returns an array containing one value from `itr` for each unique value produced by `f`
+applied to elements of `itr`.
+"""
+function unique(f::Callable, C)
+    out = Vector{eltype(C)}()
+    seen = Set()
+    for x in C
+        y = f(x)
+        if !in(y, seen)
+            push!(seen, y)
+            push!(out, x)
+        end
+    end
+    out
+end
+
 function filter(f, s::Set)
     u = similar(s)
     for x in s
@@ -135,7 +154,7 @@ end
 
 const hashs_seed = UInt === UInt64 ? 0x852ada37cfe8e0ce : 0xcfe8e0ce
 function hash(s::Set, h::UInt)
-    h += hashs_seed
+    h = hash(hashs_seed, h)
     for x in s
         h $= hash(x)
     end
diff --git a/base/sharedarray.jl b/base/sharedarray.jl
index ab29e05e8b47b..90636d1c21c1c 100644
--- a/base/sharedarray.jl
+++ b/base/sharedarray.jl
@@ -3,7 +3,7 @@
 type SharedArray{T,N} <: DenseArray{T,N}
     dims::NTuple{N,Int}
     pids::Vector{Int}
-    refs::Vector{RemoteRef}
+    refs::Vector
 
     # The segname is currently used only in the test scripts to ensure that
     # the shmem segment has been unlinked.
@@ -19,11 +19,36 @@ type SharedArray{T,N} <: DenseArray{T,N}
     # the local partition into the array when viewed as a single dimensional array.
     # this can be removed when @parallel or its equivalent supports looping on
     # a subset of workers.
-    loc_subarr_1d::SubArray{T,1,Array{T,N},Tuple{UnitRange{Int}},1}
+    loc_subarr_1d::SubArray{T,1,Array{T,N},Tuple{UnitRange{Int}},true}
 
     SharedArray(d,p,r,sn) = new(d,p,r,sn)
 end
 
+(::Type{SharedArray{T}}){T,N}(d::NTuple{N,Int}; kwargs...) =
+    SharedArray(T, d; kwargs...)
+(::Type{SharedArray{T}}){T}(d::Integer...; kwargs...) =
+    SharedArray(T, d; kwargs...)
+(::Type{SharedArray{T}}){T}(m::Integer; kwargs...) =
+    SharedArray(T, m; kwargs...)
+(::Type{SharedArray{T}}){T}(m::Integer, n::Integer; kwargs...) =
+    SharedArray(T, m, n; kwargs...)
+(::Type{SharedArray{T}}){T}(m::Integer, n::Integer, o::Integer; kwargs...) =
+    SharedArray(T, m, n, o; kwargs...)
+
+"""
+    SharedArray(T::Type, dims::NTuple; init=false, pids=Int[])
+
+Construct a `SharedArray` of a bitstype `T` and size `dims` across the processes specified
+by `pids` - all of which have to be on the same host.
+
+If `pids` is left unspecified, the shared array will be mapped across all processes on the
+current host, including the master. But, `localindexes` and `indexpids` will only refer to
+worker processes. This facilitates work distribution code to use workers for actual
+computation with the master process acting as a driver.
+
+If an `init` function of the type `initfn(S::SharedArray)` is specified, it is called on all
+the participating workers.
+"""
 function SharedArray(T::Type, dims::NTuple; init=false, pids=Int[])
     N = length(dims)
 
@@ -44,14 +69,17 @@ function SharedArray(T::Type, dims::NTuple; init=false, pids=Int[])
         else
             # The shared array is created on a remote machine....
             shmmem_create_pid = pids[1]
-            remotecall_fetch(pids[1], () -> begin shm_mmap_array(T, dims, shm_seg_name, JL_O_CREAT | JL_O_RDWR); nothing end)
+            remotecall_fetch(pids[1]) do
+                shm_mmap_array(T, dims, shm_seg_name, JL_O_CREAT | JL_O_RDWR)
+                nothing
+            end
         end
 
         func_mapshmem = () -> shm_mmap_array(T, dims, shm_seg_name, JL_O_RDWR)
 
-        refs = Array(RemoteRef, length(pids))
+        refs = Array(Future, length(pids))
         for (i, p) in enumerate(pids)
-            refs[i] = remotecall(p, func_mapshmem)
+            refs[i] = remotecall(func_mapshmem, p)
         end
 
         # Wait till all the workers have mapped the segment
@@ -64,35 +92,17 @@ function SharedArray(T::Type, dims::NTuple; init=false, pids=Int[])
             if onlocalhost
                 rc = shm_unlink(shm_seg_name)
             else
-                rc = remotecall_fetch(shmmem_create_pid, shm_unlink, shm_seg_name)
+                rc = remotecall_fetch(shm_unlink, shmmem_create_pid, shm_seg_name)
             end
             systemerror("Error unlinking shmem segment " * shm_seg_name, rc != 0)
         end
         S = SharedArray{T,N}(dims, pids, refs, shm_seg_name)
+        initialize_shared_array(S, s, onlocalhost, init, pids)
         shm_seg_name = ""
 
-        if onlocalhost
-            init_loc_flds(S)
-
-            # In the event that myid() is not part of pids, s will not be set
-            # in the init function above, hence setting it here if available.
-            S.s = s
-        else
-            S.pidx = 0
-        end
-
-        # if present init function is called on each of the parts
-        if isa(init, Function)
-            @sync begin
-                for p in pids
-                    @async remotecall_wait(p, init, S)
-                end
-            end
-        end
-
     finally
         if shm_seg_name != ""
-            remotecall_fetch(shmmem_create_pid, shm_unlink, shm_seg_name)
+            remotecall_fetch(shm_unlink, shmmem_create_pid, shm_seg_name)
         end
     end
     S
@@ -100,7 +110,36 @@ end
 
 SharedArray(T, I::Int...; kwargs...) = SharedArray(T, I; kwargs...)
 
-# Create a SharedArray from a disk file
+"""
+    SharedArray(filename::AbstractString, T::Type, dims::NTuple, [offset=0]; mode=nothing, init=false, pids=Int[])
+
+Construct a `SharedArray` backed by the file `filename`, with element
+type `T` (must be a `bitstype`) and size `dims`, across the processes
+specified by `pids` - all of which have to be on the same host. This
+file is mmapped into the host memory, with the following consequences:
+
+- The array data must be represented in binary format (e.g., an ASCII
+  format like CSV cannot be supported)
+
+- Any changes you make to the array values (e.g., `A[3] = 0`) will
+  also change the values on disk
+
+If `pids` is left unspecified, the shared array will be mapped across
+all processes on the current host, including the master. But,
+`localindexes` and `indexpids` will only refer to worker
+processes. This facilitates work distribution code to use workers for
+actual computation with the master process acting as a driver.
+
+`mode` must be one of `"r"`, `"r+"`, `"w+"`, or `"a+"`, and defaults
+to `"r+"` if the file specified by `filename` already exists, or
+`"w+"` if not. If an `init` function of the type
+`initfn(S::SharedArray)` is specified, it is called on all the
+participating workers. You cannot specify an `init` function if the
+file is not writable.
+
+`offset` allows you to skip the specified number of bytes at the
+beginning of the file.
+"""
 function SharedArray{T,N}(filename::AbstractString, ::Type{T}, dims::NTuple{N,Int}, offset::Integer=0; mode=nothing, init=false, pids::Vector{Int}=Int[])
     isabspath(filename) || throw(ArgumentError("$filename is not an absolute path; try abspath(filename)?"))
     isbits(T) || throw(ArgumentError("type of SharedArray elements must be bits types, got $(T)"))
@@ -108,7 +147,7 @@ function SharedArray{T,N}(filename::AbstractString, ::Type{T}, dims::NTuple{N,In
     pids, onlocalhost = shared_pids(pids)
 
     # If not supplied, determine the appropriate mode
-    have_file = onlocalhost ? isfile(filename) : remotecall_fetch(pids[1], isfile, filename)
+    have_file = onlocalhost ? isfile(filename) : remotecall_fetch(isfile, pids[1], filename)
     if mode == nothing
         mode = have_file ? "r+" : "w+"
     end
@@ -120,21 +159,27 @@ function SharedArray{T,N}(filename::AbstractString, ::Type{T}, dims::NTuple{N,In
     mode == "r" && !isfile(filename) && throw(ArgumentError("file $filename does not exist, but mode $mode cannot create it"))
 
     # Create the file if it doesn't exist, map it if it does
-    refs = Array(RemoteRef, length(pids))
+    refs = Array(Future, length(pids))
     func_mmap = mode -> open(filename, mode) do io
         Mmap.mmap(io, Array{T,N}, dims, offset; shared=true)
     end
     local s
     if onlocalhost
         s = func_mmap(mode)
-        refs[1] = remotecall(pids[1], () -> func_mmap(workermode))
+        refs[1] = remotecall(pids[1]) do
+            func_mmap(workermode)
+        end
     else
-        refs[1] = remotecall_wait(pids[1], () -> func_mmap(mode))
+        refs[1] = remotecall_wait(pids[1]) do
+            func_mmap(mode)
+        end
     end
 
     # Populate the rest of the workers
     for i = 2:length(pids)
-        refs[i] = remotecall(pids[i], () -> func_mmap(workermode))
+        refs[i] = remotecall(pids[i]) do
+            func_mmap(workermode)
+        end
     end
 
     # Wait till all the workers have mapped the segment
@@ -143,7 +188,11 @@ function SharedArray{T,N}(filename::AbstractString, ::Type{T}, dims::NTuple{N,In
     end
 
     S = SharedArray{T,N}(dims, pids, refs, filename)
+    initialize_shared_array(S, s, onlocalhost, init, pids)
+    S
+end
 
+function initialize_shared_array(S, s, onlocalhost, init, pids)
     if onlocalhost
         init_loc_flds(S)
         # In the event that myid() is not part of pids, s will not be set
@@ -157,10 +206,23 @@ function SharedArray{T,N}(filename::AbstractString, ::Type{T}, dims::NTuple{N,In
     if isa(init, Function)
         @sync begin
             for p in pids
-                @async remotecall_wait(p, init, S)
+                @async remotecall_wait(init, p, S)
             end
         end
     end
+
+    finalizer(S, finalize_refs)
+    S
+end
+
+function finalize_refs{T,N}(S::SharedArray{T,N})
+    for r in S.refs
+        finalize(r)
+    end
+    empty!(S.pids)
+    empty!(S.refs)
+    init_loc_flds(S)
+    S.s = Array(T, ntuple(d->0,N))
     S
 end
 
@@ -173,9 +235,11 @@ linearindexing{S<:SharedArray}(::Type{S}) = LinearFast()
 
 function reshape{T,N}(a::SharedArray{T}, dims::NTuple{N,Int})
     (length(a) != prod(dims)) && throw(DimensionMismatch("dimensions must be consistent with array size"))
-    refs = Array(RemoteRef, length(a.pids))
+    refs = Array(Future, length(a.pids))
     for (i, p) in enumerate(a.pids)
-        refs[i] = remotecall(p, (r,d)->reshape(fetch(r),d), a.refs[i], dims)
+        refs[i] = remotecall(p, a.refs[i], dims) do r,d
+            reshape(fetch(r),d)
+        end
     end
 
     A = SharedArray{T,N}(dims, a.pids, refs, a.segname)
@@ -190,6 +254,20 @@ indexpids(S::SharedArray) = S.pidx
 sdata(S::SharedArray) = S.s
 sdata(A::AbstractArray) = A
 
+"""
+    localindexes(S::SharedArray)
+
+Returns a range describing the "default" indexes to be handled by the
+current process.  This range should be interpreted in the sense of
+linear indexing, i.e., as a sub-range of `1:length(S)`.  In
+multi-process contexts, returns an empty range in the parent process
+(or any process for which `indexpids` returns 0).
+
+It's worth emphasizing that `localindexes` exists purely as a
+convenience, and you can partition work on the array among workers any
+way you wish.  For a SharedArray, all indexes should be equally fast
+for each worker process.
+"""
 localindexes(S::SharedArray) = S.pidx > 0 ? range_1dim(S, S.pidx) : 1:0
 
 unsafe_convert{T}(::Type{Ptr{T}}, S::SharedArray) = unsafe_convert(Ptr{T}, sdata(S))
@@ -248,7 +326,13 @@ sub_1dim(S::SharedArray, pidx) = sub(S.s, range_1dim(S, pidx))
 function init_loc_flds{T,N}(S::SharedArray{T,N})
     if myid() in S.pids
         S.pidx = findfirst(S.pids, myid())
-        S.s = fetch(S.refs[S.pidx])
+        if isa(S.refs[1], Future)
+            refid = remoteref_id(S.refs[S.pidx])
+        else
+            refid = S.refs[S.pidx]
+        end
+        c = channel_from_id(refid)
+        S.s = fetch(c)
         S.loc_subarr_1d = sub_1dim(S, S.pidx)
     else
         S.pidx = 0
@@ -265,6 +349,15 @@ function serialize(s::SerializationState, S::SharedArray)
     for n in SharedArray.name.names
         if n in [:s, :pidx, :loc_subarr_1d]
             Serializer.writetag(s.io, Serializer.UNDEFREF_TAG)
+        elseif n == :refs
+            v = getfield(S, n)
+            if isa(v[1], Future)
+                # convert to ids to avoid distributed GC overhead
+                ids = [remoteref_id(x) for x in v]
+                serialize(s, ids)
+            else
+                serialize(s, v)
+            end
         else
             serialize(s, getfield(S, n))
         end
@@ -288,7 +381,7 @@ function fill!(S::SharedArray, v)
     vT = convert(eltype(S), v)
     f = S->fill!(S.loc_subarr_1d, vT)
     @sync for p in procs(S)
-        @async remotecall_wait(p, f, S)
+        @async remotecall_wait(f, p, S)
     end
     return S
 end
@@ -296,7 +389,7 @@ end
 function rand!{T}(S::SharedArray{T})
     f = S->map!(x->rand(T), S.loc_subarr_1d)
     @sync for p in procs(S)
-        @async remotecall_wait(p, f, S)
+        @async remotecall_wait(f, p, S)
     end
     return S
 end
@@ -304,7 +397,7 @@ end
 function randn!(S::SharedArray)
     f = S->map!(x->randn(), S.loc_subarr_1d)
     @sync for p in procs(S)
-        @async remotecall_wait(p, f, S)
+        @async remotecall_wait(f, p, S)
     end
     return S
 end
@@ -386,9 +479,9 @@ function print_shmem_limits(slen)
         @linux_only pfx = "kernel"
         @osx_only pfx = "kern.sysv"
 
-        shmmax_MB = div(parse(Int, split(readall(`sysctl $(pfx).shmmax`))[end]), 1024*1024)
-        page_size = parse(Int, split(readall(`getconf PAGE_SIZE`))[end])
-        shmall_MB = div(parse(Int, split(readall(`sysctl $(pfx).shmall`))[end]) * page_size, 1024*1024)
+        shmmax_MB = div(parse(Int, split(readstring(`sysctl $(pfx).shmmax`))[end]), 1024*1024)
+        page_size = parse(Int, split(readstring(`getconf PAGE_SIZE`))[end])
+        shmall_MB = div(parse(Int, split(readstring(`sysctl $(pfx).shmall`))[end]) * page_size, 1024*1024)
 
         println("System max size of single shmem segment(MB) : ", shmmax_MB,
             "\nSystem max size of all shmem segments(MB) : ", shmall_MB,
@@ -431,22 +524,22 @@ end
 
 function _shm_mmap_array(T, dims, shm_seg_name, mode)
     fd_mem = shm_open(shm_seg_name, mode, S_IRUSR | S_IWUSR)
-    systemerror("shm_open() failed for " * shm_seg_name, fd_mem <= 0)
+    systemerror("shm_open() failed for " * shm_seg_name, fd_mem < 0)
 
     s = fdio(fd_mem, true)
 
     # On OSX, ftruncate must to used to set size of segment, just lseek does not work.
     # and only at creation time
     if (mode & JL_O_CREAT) == JL_O_CREAT
-        rc = ccall(:ftruncate, Int, (Int, Int), fd_mem, prod(dims)*sizeof(T))
+        rc = ccall(:jl_ftruncate, Cint, (Cint, Int64), fd_mem, prod(dims)*sizeof(T))
         systemerror("ftruncate() failed for shm segment " * shm_seg_name, rc != 0)
     end
 
-    Mmap.mmap(s, Array{T,length(dims)}, dims, zero(FileOffset); grow=false)
+    Mmap.mmap(s, Array{T,length(dims)}, dims, zero(Int64); grow=false)
 end
 
 shm_unlink(shm_seg_name) = ccall(:shm_unlink, Cint, (Cstring,), shm_seg_name)
-shm_open(shm_seg_name, oflags, permissions) = ccall(:shm_open, Int, (Cstring, Int, Int), shm_seg_name, oflags, permissions)
+shm_open(shm_seg_name, oflags, permissions) = ccall(:shm_open, Cint, (Cstring, Cint, Cmode_t), shm_seg_name, oflags, permissions)
 
 end # @unix_only
 
@@ -456,7 +549,7 @@ function _shm_mmap_array(T, dims, shm_seg_name, mode)
     readonly = !((mode & JL_O_RDWR) == JL_O_RDWR)
     create = (mode & JL_O_CREAT) == JL_O_CREAT
     s = Mmap.Anonymous(shm_seg_name, readonly, create)
-    Mmap.mmap(s, Array{T,length(dims)}, dims, zero(FileOffset))
+    Mmap.mmap(s, Array{T,length(dims)}, dims, zero(Int64))
 end
 
 # no-op in windows
diff --git a/base/shell.jl b/base/shell.jl
index cfd7eb26ee690..eb091b7922de7 100644
--- a/base/shell.jl
+++ b/base/shell.jl
@@ -81,7 +81,7 @@ function shell_parse(raw::AbstractString, interp::Bool)
                     if done(s,k)
                         error("unterminated double quote")
                     end
-                    if s[k] == '"' || s[k] == '$'
+                    if s[k] == '"' || s[k] == '$' || s[k] == '\\'
                         update_arg(s[i:j-1]); i = k
                         c, k = next(s,k)
                     end
diff --git a/base/show.jl b/base/show.jl
index 994bcf94b05ec..d1783e07037b4 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -1,8 +1,74 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 show(x) = show(STDOUT::IO, x)
+print(io::IO, s::Symbol) = (write(io,s); nothing)
+
+immutable IOContext{IO_t <: IO} <: AbstractPipe
+    io::IO_t
+    dict::ImmutableDict{Symbol, Any}
+    function IOContext(io::IO_t, dict::ImmutableDict{Symbol, Any})
+        assert(!(IO_t <: IOContext))
+        return new(io, dict)
+    end
+end
+
+"""
+    IOContext{<:IO} <: IO
+
+IOContext provides a mechanism for passing output-configuration keyword arguments through arbitrary show methods.
+
+In short, it is an immutable Dictionary that is a subclass of IO.
+
+    IOContext(io::IO, KV::Pair)
+
+Create a new entry in the IO Dictionary for the key => value pair
+
+ - use `(key => value) in dict` to see if this particular combination is in the properties set
+ - use `get(dict, key, default)` to retrieve the most recent value for a particular key
+
+    IOContext(io::IO, context::IOContext)
+
+Create a IOContext that wraps an alternate IO but inherits the keyword arguments from the context
+"""
+IOContext
+
+IOContext(io::IOContext) = io
+IOContext(io::IO) = IOContext(io, ImmutableDict{Symbol,Any}())
+
+IOContext(io::IOContext, dict::ImmutableDict) = typeof(io)(io.io, dict)
+IOContext(io::IO, dict::ImmutableDict) = IOContext{typeof(io)}(io, dict)
+
+IOContext(io::IO, key, value) = IOContext(io, ImmutableDict{Symbol, Any}(key, value))
+IOContext(io::IOContext, key, value) = IOContext(io, ImmutableDict{Symbol, Any}(io.dict, key, value))
+
+IOContext(io::IO, context::IO) = IOContext(io)
+IOContext(io::IO, context::IOContext) = IOContext(io, context.dict)
+IOContext(io::IO, KV::Pair) = IOContext(io, KV[1], KV[2])
+
+show(io::IO, ctx::IOContext) = (print(io, "IOContext("); show(io, ctx.io); print(io, ")"))
+
+pipe_reader(io::IOContext) = io.io
+pipe_writer(io::IOContext) = io.io
+lock(io::IOContext) = lock(io.io)
+unlock(io::IOContext) = unlock(io.io)
+
+in(key_value::Pair, io::IOContext) = in(key_value, io.dict, is)
+in(key_value::Pair, io::IO) = false
+haskey(io::IOContext, key) = haskey(io.dict, key)
+haskey(io::IO, key) = false
+getindex(io::IOContext, key) = getindex(io.dict, key)
+getindex(io::IO, key) = throw(KeyError(key))
+get(io::IOContext, key, default) = get(io.dict, key, default)
+get(io::IO, key, default) = default
+
+"    limit_output(io) -> Bool
+Output hinting for identifying contexts where the user requested a compact output"
+limit_output(::ANY) = _limit_output::Bool
+limit_output(io::IOContext) = get(io, :limit_output, _limit_output::Bool) === true
+_limit_output = false # delete with with_output_limit deprecation
+
+displaysize(io::IOContext) = haskey(io, :displaysize) ? io[:displaysize] : displaysize(io.io)
 
-print(io::IO, s::Symbol) = (write(io,s);nothing)
 
 show(io::IO, x::ANY) = show_default(io, x)
 function show_default(io::IO, x::ANY)
@@ -11,37 +77,21 @@ function show_default(io::IO, x::ANY)
     print(io, '(')
     nf = nfields(t)
     if nf != 0 || t.size==0
-        recorded = false
-        shown_set = get(task_local_storage(), :SHOWNSET, nothing)
-        if shown_set === nothing
-            shown_set = ObjectIdDict()
-            task_local_storage(:SHOWNSET, shown_set)
-        end
-
-        try
-            if x in keys(shown_set)
-                print(io, "#= circular reference =#")
-            else
-                shown_set[x] = true
-                recorded = true
-
-                for i=1:nf
-                    f = fieldname(t, i)
-                    if !isdefined(x, f)
-                        print(io, undef_ref_str)
-                    else
-                        show(io, x.(f))
-                    end
-                    if i < nf
-                        print(io, ',')
-                    end
+        if (:SHOWN_SET => x) in io
+            print(io, "#= circular reference =#")
+        else
+            recur_io = IOContext(io, :SHOWN_SET => x)
+            for i=1:nf
+                f = fieldname(t, i)
+                if !isdefined(x, f)
+                    print(io, undef_ref_str)
+                else
+                    show(recur_io, x.(f))
+                end
+                if i < nf
+                    print(io, ',')
                 end
             end
-        catch e
-            rethrow(e)
-
-        finally
-            if recorded; delete!(shown_set, x); end
         end
     else
         nb = t.size
@@ -68,16 +118,11 @@ function is_exported_from_stdlib(name::Symbol, mod::Module)
 end
 
 function show(io::IO, f::Function)
-    if isgeneric(f)
-        if is_exported_from_stdlib(f.env.name, f.env.module) || f.env.module === Main
-            print(io, f.env.name)
-        else
-            print(io, f.env.module, ".", f.env.name)
-        end
-    elseif isdefined(f, :env) && isa(f.env,Symbol)
-        print(io, f.env)
+    mt = typeof(f).name.mt
+    if !isdefined(mt, :module) || is_exported_from_stdlib(mt.name, mt.module) || mt.module === Main
+        print(io, mt.name)
     else
-        print(io, "(anonymous function)")
+        print(io, mt.module, ".", mt.name)
     end
 end
 
@@ -103,7 +148,7 @@ end
 
 function show(io::IO, x::DataType)
     show(io, x.name)
-    if (length(x.parameters) > 0 || x.name === Tuple.name) && x !== Tuple
+    if (!isempty(x.parameters) || x.name === Tuple.name) && x !== Tuple
         print(io, '{')
         n = length(x.parameters)
         for i = 1:n
@@ -114,12 +159,6 @@ function show(io::IO, x::DataType)
     end
 end
 
-showcompact(io::IO, x) = show(io, x)
-showcompact(x) = showcompact(STDOUT::IO, x)
-
-showcompact_lim(io, x) = _limit_output ? showcompact(io, x) : show(io, x)
-showcompact_lim(io, x::Number) = _limit_output ? showcompact(io, x) : print(io, x)
-
 macro show(exs...)
     blk = Expr(:block)
     for ex in exs
@@ -169,13 +208,14 @@ function show(io::IO, m::Module)
     end
 end
 
-function show(io::IO, l::LambdaStaticData)
+function show(io::IO, l::LambdaInfo)
     print(io, "AST(")
     show(io, uncompressed_ast(l))
     print(io, ")")
 end
 
-function show_delim_array(io::IO, itr::AbstractArray, op, delim, cl, delim_one, compact=false, i1=1, l=length(itr))
+function show_delim_array(io::IO, itr::Union{AbstractArray,SimpleVector}, op, delim, cl, delim_one,
+                          i1=1, l=length(itr))
     print(io, op)
     newline = true
     first = true
@@ -187,14 +227,12 @@ function show_delim_array(io::IO, itr::AbstractArray, op, delim, cl, delim_one,
                 multiline = false
             else
                 x = itr[i]
-                multiline = isa(x,AbstractArray) && ndims(x)>1 && length(x)>0
+                multiline = isa(x,AbstractArray) && ndims(x)>1 && !isempty(x)
                 newline && multiline && println(io)
                 if !isbits(x) && is(x, itr)
                     print(io, "#= circular reference =#")
-                elseif compact
-                    showcompact_lim(io, x)
                 else
-                    show(io, x)
+                    showcompact_lim(io, x)
                 end
             end
             i += 1
@@ -215,7 +253,7 @@ function show_delim_array(io::IO, itr::AbstractArray, op, delim, cl, delim_one,
     print(io, cl)
 end
 
-function show_delim_array(io::IO, itr, op, delim, cl, delim_one, compact=false, i1=1, n=typemax(Int))
+function show_delim_array(io::IO, itr, op, delim, cl, delim_one, i1=1, n=typemax(Int))
     print(io, op)
     state = start(itr)
     newline = true
@@ -227,7 +265,7 @@ function show_delim_array(io::IO, itr, op, delim, cl, delim_one, compact=false,
     if !done(itr,state)
         while true
             x, state = next(itr,state)
-            multiline = isa(x,AbstractArray) && ndims(x)>1 && length(x)>0
+            multiline = isa(x,AbstractArray) && ndims(x)>1 && !isempty(x)
             newline && multiline && println(io)
             if !isbits(x) && is(x, itr)
                 print(io, "#= circular reference =#")
@@ -328,6 +366,7 @@ isoperator(s::Symbol) = ccall(:jl_is_operator, Cint, (Cstring,), s) != 0
 operator_precedence(s::Symbol) = Int(ccall(:jl_operator_precedence, Cint, (Cstring,), s))
 operator_precedence(x::Any) = 0 # fallback for generic expression nodes
 const prec_power = operator_precedence(:(^))
+const prec_decl = operator_precedence(:(::))
 
 is_expr(ex, head::Symbol)         = (isa(ex, Expr) && (ex.head == head))
 is_expr(ex, head::Symbol, n::Int) = is_expr(ex, head) && length(ex.args) == n
@@ -342,23 +381,36 @@ is_quoted(ex::Expr)      = is_expr(ex, :quote, 1) || is_expr(ex, :inert, 1)
 unquoted(ex::QuoteNode)  = ex.value
 unquoted(ex::Expr)       = ex.args[1]
 
+function is_intrinsic_expr(x::ANY)
+    isa(x, IntrinsicFunction) && return true
+    if isa(x, GlobalRef)
+        x = x::GlobalRef
+        return (x.mod == Base && isdefined(Base, x.name) &&
+                isa(getfield(Base, x.name), IntrinsicFunction))
+    elseif isa(x, TopNode)
+        x = x::TopNode
+        return (isdefined(Base, x.name) &&
+                isa(getfield(Base, x.name), IntrinsicFunction))
+    end
+    return false
+end
+
 ## AST printing helpers ##
 
+typeemphasize(io::IO) = get(io, :TYPEEMPHASIZE, false) === true
+
 const indent_width = 4
 
-function show_expr_type(io::IO, ty)
+function show_expr_type(io::IO, ty, emph)
     if is(ty, Function)
         print(io, "::F")
     elseif is(ty, IntrinsicFunction)
         print(io, "::I")
     else
-        emph = get(task_local_storage(), :TYPEEMPHASIZE, false)::Bool
         if emph && !isleaftype(ty)
             emphasize(io, "::$ty")
         else
-            if !is(ty, Any)
-                print(io, "::$ty")
-            end
+            print(io, "::$ty")
         end
     end
 end
@@ -442,7 +494,10 @@ show_unquoted(io::IO, ex::GlobalRef, ::Int, ::Int)      = print(io, ex.mod, '.',
 
 function show_unquoted(io::IO, ex::SymbolNode, ::Int, ::Int)
     print(io, ex.name)
-    show_expr_type(io, ex.typ)
+    emphstate = typeemphasize(io)
+    if emphstate || ex.typ !== Any
+        show_expr_type(io, ex.typ, emphstate)
+    end
 end
 
 function show_unquoted(io::IO, ex::QuoteNode, indent::Int, prec::Int)
@@ -479,8 +534,17 @@ end
 # TODO: implement interpolated strings
 function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
     head, args, nargs = ex.head, ex.args, length(ex.args)
+    emphstate = typeemphasize(io)
     show_type = true
-    emphstate = get(task_local_storage(), :TYPEEMPHASIZE, false)
+    if (ex.head == :(=) ||
+        ex.head == :boundscheck ||
+        ex.head == :gotoifnot ||
+        ex.head == :return)
+        show_type = false
+    end
+    if !emphstate && ex.typ === Any
+        show_type = false
+    end
     # dot (i.e. "x.y")
     if is(head, :(.))
         show_unquoted(io, args[1], indent + indent_width)
@@ -519,7 +583,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         head !== :row && print(io, cl)
 
     # function call
-    elseif head == :call && nargs >= 1
+    elseif head === :call && nargs >= 1
         func = args[1]
         fname = isa(func,GlobalRef) ? func.name : func
         func_prec = operator_precedence(fname)
@@ -528,8 +592,13 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         end
         func_args = args[2:end]
 
-        if in(ex.args[1], (:box, TopNode(:box), :throw)) || ismodulecall(ex)
-            show_type = task_local_storage(:TYPEEMPHASIZE, false)
+        if (in(ex.args[1], (GlobalRef(Base, :box), TopNode(:box), :throw)) ||
+            ismodulecall(ex) ||
+            (ex.typ === Any && is_intrinsic_expr(ex.args[1])))
+            show_type = false
+        end
+        if show_type
+            prec = prec_decl
         end
 
         # scalar multiplication (i.e. "100x")
@@ -552,20 +621,23 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
 
         # binary operator (i.e. "x + y")
         elseif func_prec > 0 # is a binary operator
-            if length(func_args) > 1
+            na = length(func_args)
+            if na == 2 || (na > 2 && func in (:+, :++, :*))
                 sep = " $func "
                 if func_prec <= prec
                     show_enclosed_list(io, '(', func_args, sep, ')', indent, func_prec, true)
                 else
                     show_list(io, func_args, sep, indent, func_prec, true)
                 end
-            else
+            elseif na == 1
                 # 1-argument call to normally-binary operator
                 op, cl = expr_calls[head]
                 print(io, "(")
                 show_unquoted(io, func, indent)
                 print(io, ")")
                 show_enclosed_list(io, op, func_args, ",", cl, indent)
+            else
+                show_call(io, head, func, func_args, indent)
             end
 
         # normal function (i.e. "f(x,y)")
@@ -705,18 +777,21 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         show_unquoted(io, args[2], indent+indent_width)
 
     elseif is(head, :string)
-        a = map(args) do x
+        print(io, '"')
+        for x in args
             if !isa(x,AbstractString)
+                print(io, "\$(")
                 if isa(x,Symbol) && !(x in quoted_syms)
-                    string("\$(", x, ")")
+                    print(io, x)
                 else
-                    string("\$(", sprint(show_unquoted,x), ")")
+                    show_unquoted(io, x)
                 end
+                print(io, ")")
             else
-                sprint(print_escaped, x, "\"\$")
+                print_escaped(io, x, "\"\$")
             end
         end
-        print(io, '"', a..., '"')
+        print(io, '"')
 
     elseif (is(head, :&)#= || is(head, :$)=#) && length(args) == 1
         print(io, head)
@@ -728,7 +803,13 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
 
     # transpose
     elseif (head === symbol('\'') || head === symbol(".'")) && length(args) == 1
-        show_unquoted(io, args[1])
+        if isa(args[1], Symbol)
+            show_unquoted(io, args[1])
+        else
+            print(io, "(")
+            show_unquoted(io, args[1])
+            print(io, ")")
+        end
         print(io, head)
 
     elseif is(head, :import) || is(head, :importall) || is(head, :using)
@@ -749,9 +830,10 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
     # print anything else as "Expr(head, args...)"
     else
         show_type = false
-        emph = get(task_local_storage(), :TYPEEMPHASIZE, false)::Bool &&
-               (ex.head === :lambda || ex.head == :method)
-        task_local_storage(:TYPEEMPHASIZE, emph)
+        if emphstate && ex.head !== :lambda && ex.head !== :method
+            io = IOContext(io, :TYPEEMPHASIZE => false)
+            emphstate = false
+        end
         print(io, "\$(Expr(")
         show(io, ex.head)
         for arg in args
@@ -760,14 +842,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         end
         print(io, "))")
     end
-    if (ex.head == :(=) ||
-        ex.head == :boundscheck ||
-        ex.head == :gotoifnot ||
-        ex.head == :return)
-        show_type = false
-    end
-    show_type && show_expr_type(io, ex.typ)
-    task_local_storage(:TYPEEMPHASIZE, emphstate)
+    show_type && show_expr_type(io, ex.typ, emphstate)
 end
 
 function ismodulecall(ex::Expr)
@@ -777,6 +852,26 @@ function ismodulecall(ex::Expr)
         isa(getfield(current_module(), ex.args[2]), Module)
 end
 
+function show(io::IO, tv::TypeVar)
+    tvar_env = isa(io, IOContext) && get(io, :tvar_env, false)
+    if isa(tvar_env, Vector{Any})
+        have_env = true
+        in_env = (tv in tvar_env::Vector{Any})
+    else
+        have_env = false
+        in_env = true
+    end
+    if !in_env && !is(tv.lb, Bottom)
+        show(io, tv.lb)
+        print(io, "<:")
+    end
+    write(io, tv.name)
+    if have_env ? !in_env : !is(tv.ub, Any)
+        print(io, "<:")
+        show(io, tv.ub)
+    end
+end
+
 # dump & xdump - structured tree representation like R's str()
 # - dump is for the user-facing structure
 # - xdump is for the internal structure
@@ -847,7 +942,7 @@ xdump(fn::Function, io::IO, x::Array, n::Int, indent) =
 # Types
 xdump(fn::Function, io::IO, x::Union, n::Int, indent) = println(io, x)
 function xdump(fn::Function, io::IO, x::DataType, n::Int, indent)
-    println(io, x, "::", typeof(x), " ", " <: ", super(x))
+    println(io, x, "::", typeof(x), " ", " <: ", supertype(x))
     fields = fieldnames(x)
     if n > 0
         for idx in 1:min(10, length(fields))
@@ -887,14 +982,14 @@ function dumptype(io::IO, x, n::Int, indent)
                          any(map(tt -> string(x.name) == typargs(tt), t.body.types)))
                         targs = join(t.parameters, ",")
                         println(io, indent, "  ", s,
-                                length(t.parameters) > 0 ? "{$targs}" : "",
+                                !isempty(t.parameters) ? "{$targs}" : "",
                                 " = ", t)
                     end
                 elseif isa(t, Union)
                     if any(tt -> string(x.name) == typargs(tt), t.types)
                         println(io, indent, "  ", s, " = ", t)
                     end
-                elseif isa(t, DataType) && super(t).name == x.name
+                elseif isa(t, DataType) && supertype(t).name == x.name
                     # type aliases
                     if string(s) != string(t.name)
                         println(io, indent, "  ", s, " = ", t.name)
@@ -919,7 +1014,7 @@ xdump(fn::Function, io::IO, x, n::Int) = xdump(xdump, io, x, n, "")
 xdump(fn::Function, io::IO, args...) = throw(ArgumentError("invalid arguments to xdump"))
 xdump(fn::Function, args...) = xdump(fn, STDOUT::IO, args...)
 xdump(io::IO, args...) = xdump(xdump, io, args...)
-xdump(args...) = with_output_limit(()->xdump(xdump, STDOUT::IO, args...), true)
+xdump(args...) = xdump(xdump, IOContext(STDOUT::IO, :limit_output => true), args...)
 xdump(arg::IO) = xdump(xdump, STDOUT::IO, arg)
 
 # Here are methods specifically for dump:
@@ -931,7 +1026,7 @@ dump(io::IO, x::AbstractString, n::Int, indent) =
 dump(io::IO, x, n::Int, indent) = xdump(dump, io, x, n, indent)
 dump(io::IO, args...) = throw(ArgumentError("invalid arguments to dump"))
 dump(arg::IO) = xdump(dump, STDOUT::IO, arg)
-dump(args...) = with_output_limit(()->dump(STDOUT::IO, args...), true)
+dump(args...) = dump(IOContext(STDOUT::IO, :limit_output => true), args...)
 
 function dump(io::IO, x::Dict, n::Int, indent)
     println(io, typeof(x), " len ", length(x))
@@ -956,48 +1051,66 @@ dump(io::IO, x::DataType) = dump(io, x, 5, "")
 dump(io::IO, x::TypeVar, n::Int, indent) = println(io, x.name)
 
 
-alignment(x::Any) = (0, length(sprint(showcompact_lim, x)))
-alignment(x::Number) = (length(sprint(showcompact_lim, x)), 0)
-alignment(x::Integer) = (length(sprint(showcompact_lim, x)), 0)
-function alignment(x::Real)
-    m = match(r"^(.*?)((?:[\.eE].*)?)$", sprint(showcompact_lim, x))
-    m === nothing ? (length(sprint(showcompact_lim, x)), 0) :
+"""
+`alignment(X)` returns a tuple (left,right) showing how many characters are
+needed on either side of an alignment feature such as a decimal point.
+"""
+alignment(io::IO, x::Any) = (0, length(sprint(0, showcompact_lim, x, env=io)))
+alignment(io::IO, x::Number) = (length(sprint(0, showcompact_lim, x, env=io)), 0)
+"`alignment(42)` yields (2,0)"
+alignment(io::IO, x::Integer) = (length(sprint(0, showcompact_lim, x, env=io)), 0)
+"`alignment(4.23)` yields (1,3) for `4` and `.23`"
+function alignment(io::IO, x::Real)
+    m = match(r"^(.*?)((?:[\.eE].*)?)$", sprint(0, showcompact_lim, x, env=io))
+    m === nothing ? (length(sprint(0, showcompact_lim, x, env=io)), 0) :
                    (length(m.captures[1]), length(m.captures[2]))
 end
-function alignment(x::Complex)
-    m = match(r"^(.*[\+\-])(.*)$", sprint(showcompact_lim, x))
-    m === nothing ? (length(sprint(showcompact_lim, x)), 0) :
+"`alignment(1 + 10im)` yields (3,5) for `1 +` and `_10im` (plus sign on left, space on right)"
+function alignment(io::IO, x::Complex)
+    m = match(r"^(.*[\+\-])(.*)$", sprint(0, showcompact_lim, x, env=io))
+    m === nothing ? (length(sprint(0, showcompact_lim, x, env=io)), 0) :
                    (length(m.captures[1]), length(m.captures[2]))
 end
-function alignment(x::Rational)
-    m = match(r"^(.*?/)(/.*)$", sprint(showcompact_lim, x))
-    m === nothing ? (length(sprint(showcompact_lim, x)), 0) :
+function alignment(io::IO, x::Rational)
+    m = match(r"^(.*?/)(/.*)$", sprint(0, showcompact_lim, x, env=io))
+    m === nothing ? (length(sprint(0, showcompact_lim, x, env=io)), 0) :
                    (length(m.captures[1]), length(m.captures[2]))
 end
 
 const undef_ref_str = "#undef"
 const undef_ref_alignment = (3,3)
 
+"""
+`alignment(X, rows, cols, cols_if_complete, cols_otherwise, sep)` returns the
+alignment for specified parts of array `X`, returning the (left,right) info.
+It will look in X's `rows`, `cols` (both lists of indices)
+and figure out what's needed to be fully aligned, for example looking all
+the way down a column and finding out the maximum size of each element.
+Parameter `sep::Integer` is number of spaces to put between elements.
+`cols_if_complete` and `cols_otherwise` indicate screen width to use.
+Alignment is reported as a vector of (left,right) tuples, one for each
+column going across the screen.
+"""
 function alignment(
-    X::AbstractVecOrMat,
+    io::IO, X::AbstractVecOrMat,
     rows::AbstractVector, cols::AbstractVector,
     cols_if_complete::Integer, cols_otherwise::Integer, sep::Integer
 )
-    a = []
-    for j in cols
+    a = Tuple{Int, Int}[]
+    for j in cols # need to go down each column one at a time
         l = r = 0
-        for i in rows
+        for i in rows # plumb down and see what largest element sizes are
             if isassigned(X,i,j)
-                aij = alignment(X[i,j])
+                aij = alignment(io, X[i,j])
             else
                 aij = undef_ref_alignment
             end
-            l = max(l, aij[1])
-            r = max(r, aij[2])
+            l = max(l, aij[1]) # left characters
+            r = max(r, aij[2]) # right characters
         end
-        push!(a, (l, r))
+        push!(a, (l, r)) # one tuple per column of X, pruned to screen width
         if length(a) > 1 && sum(map(sum,a)) + sep*length(a) >= cols_if_complete
-            pop!(a)
+            pop!(a) # remove this latest tuple if we're already beyond screen width
             break
         end
     end
@@ -1009,27 +1122,50 @@ function alignment(
     return a
 end
 
+"""
+Unexported convenience function used in body of `replace_in_print_matrix`
+methods. By default returns a string of the same width as original with a
+centered cdot, used in printing of structural zeros of structured matrices.
+Accept keyword args `c` for alternate single character marker.
+"""
+function replace_with_centered_mark(s::AbstractString;c::Char = '⋅')
+    N = length(s)
+    return join(setindex!([utf8(" ") for i=1:N],string(c),ceil(Int,N/2)))
+end
+
+"""
+`print_matrix_row(io, X, A, i, cols, sep)` produces the aligned output for
+a single matrix row X[i, cols] where the desired list of columns is given.
+The corresponding alignment A is used, and the separation between elements
+is specified as string sep.
+`print_matrix_row` will also respect compact output for elements.
+"""
 function print_matrix_row(io::IO,
     X::AbstractVecOrMat, A::Vector,
-    i::Integer, cols::AbstractVector, sep::AbstractString
-)
+    i::Integer, cols::AbstractVector, sep::AbstractString)
     for k = 1:length(A)
         j = cols[k]
-        if isassigned(X,i,j)
+        if isassigned(X,Int(i),Int(j)) # isassigned accepts only `Int` indices
             x = X[i,j]
-            a = alignment(x)
-            sx = sprint(showcompact_lim, x)
+            a = alignment(io, x)
+            sx = sprint(0, showcompact_lim, x, env=io)
         else
             a = undef_ref_alignment
             sx = undef_ref_str
         end
-        l = repeat(" ", A[k][1]-a[1])
+        l = repeat(" ", A[k][1]-a[1]) # pad on left and right as needed
         r = repeat(" ", A[k][2]-a[2])
-        print(io, l, sx, r)
+        prettysx = replace_in_print_matrix(X,i,j,sx)
+        print(io, l, prettysx, r)
         if k < length(A); print(io, sep); end
     end
 end
 
+"""
+`print_matrix_vdots` is used to show a series of vertical ellipsis instead
+of a bunch of rows for long matrices. Not only is the string vdots shown
+but it also repeated every M elements if desired.
+"""
 function print_matrix_vdots(io::IO,
     vdots::AbstractString, A::Vector, sep::AbstractString, M::Integer, m::Integer
 )
@@ -1046,79 +1182,102 @@ function print_matrix_vdots(io::IO,
     end
 end
 
+"""
+`print_matrix(io, X)` composes an entire matrix, taking into account the screen size.
+If X is too big, it will be nine-sliced with vertical, horizontal, or diagonal
+ellipsis inserted as appropriate.
+Optional parameters are screen size tuple sz such as (24,80),
+string pre prior to the matrix (e.g. opening bracket), which will cause
+a corresponding same-size indent on following rows,
+string post on the end of the last row of the matrix.
+Also options to use different ellipsis characters hdots,
+vdots, ddots. These are repeated every hmod or vmod elements.
+"""
 function print_matrix(io::IO, X::AbstractVecOrMat,
-                      sz::Tuple{Integer, Integer} = (s = tty_size(); (s[1]-4, s[2])),
-                      pre::AbstractString = " ",
-                      sep::AbstractString = "  ",
-                      post::AbstractString = "",
+                      pre::AbstractString = " ",  # pre-matrix string
+                      sep::AbstractString = "  ", # separator between elements
+                      post::AbstractString = "",  # post-matrix string
                       hdots::AbstractString = "  \u2026  ",
                       vdots::AbstractString = "\u22ee",
                       ddots::AbstractString = "  \u22f1  ",
                       hmod::Integer = 5, vmod::Integer = 5)
-    rows, cols = sz
-    cols -= length(pre) + length(post)
-    presp = repeat(" ", length(pre))
+    if !limit_output(io)
+        screenheight = screenwidth = typemax(Int)
+    else
+        sz = displaysize(io)
+        screenheight, screenwidth = sz[1] - 4, sz[2]
+    end
+    screenwidth -= length(pre) + length(post)
+    presp = repeat(" ", length(pre))  # indent each row to match pre string
     postsp = ""
     @assert strwidth(hdots) == strwidth(ddots)
-    ss = length(sep)
+    sepsize = length(sep)
     m, n = size(X,1), size(X,2)
-    if m <= rows # rows fit
-        A = alignment(X,1:m,1:n,cols,cols,ss)
-        if n <= length(A) # rows and cols fit
-            for i = 1:m
+    # To figure out alignments, only need to look at as many rows as could
+    # fit down screen. If screen has at least as many rows as A, look at A.
+    # If not, then we only need to look at the first and last chunks of A,
+    # each half a screen height in size.
+    halfheight = div(screenheight,2)
+    rowsA = m <= screenheight ? (1:m) : [1:halfheight; m-div(screenheight-1,2)+1:m]
+    # Similarly for columns, only necessary to get alignments for as many
+    # columns as could conceivably fit across the screen
+    maxpossiblecols = div(screenwidth, 1+sepsize)
+    colsA = n <= maxpossiblecols ? (1:n) : [1:maxpossiblecols; (n-maxpossiblecols+1):n]
+    A = alignment(io, X, rowsA, colsA, screenwidth, screenwidth, sepsize)
+    # Nine-slicing is accomplished using print_matrix_row repeatedly
+    if m <= screenheight # rows fit vertically on screen
+        if n <= length(A) # rows and cols fit so just print whole matrix in one piece
+            for i in rowsA
                 print(io, i == 1 ? pre : presp)
-                print_matrix_row(io, X,A,i,1:n,sep)
+                print_matrix_row(io, X,A,i,colsA,sep)
                 print(io, i == m ? post : postsp)
                 if i != m; println(io, ); end
             end
-        else # rows fit, cols don't
-            c = div(cols-length(hdots)+1,2)+1
-            R = reverse(alignment(X,1:m,n:-1:1,c,c,ss))
-            c = cols - sum(map(sum,R)) - (length(R)-1)*ss - length(hdots)
-            L = alignment(X,1:m,1:n,c,c,ss)
-            for i = 1:m
+        else # rows fit down screen but cols don't, so need horizontal ellipsis
+            c = div(screenwidth-length(hdots)+1,2)+1  # what goes to right of ellipsis
+            Ralign = reverse(alignment(io, X, rowsA, reverse(colsA), c, c, sepsize)) # alignments for right
+            c = screenwidth - sum(map(sum,Ralign)) - (length(Ralign)-1)*sepsize - length(hdots)
+            Lalign = alignment(io, X, rowsA, colsA, c, c, sepsize) # alignments for left of ellipsis
+            for i in rowsA
                 print(io, i == 1 ? pre : presp)
-                print_matrix_row(io, X,L,i,1:length(L),sep)
+                print_matrix_row(io, X,Lalign,i,1:length(Lalign),sep)
                 print(io, i % hmod == 1 ? hdots : repeat(" ", length(hdots)))
-                print_matrix_row(io, X,R,i,n-length(R)+1:n,sep)
+                print_matrix_row(io, X,Ralign,i,n-length(Ralign)+colsA,sep)
                 print(io, i == m ? post : postsp)
                 if i != m; println(io, ); end
             end
         end
-    else # rows don't fit
-        t = div(rows,2)
-        I = [1:t; m-div(rows-1,2)+1:m]
-        A = alignment(X,I,1:n,cols,cols,ss)
-        if n <= length(A) # rows don't fit, cols do
-            for i in I
+    else # rows don't fit so will need vertical ellipsis
+        if n <= length(A) # rows don't fit, cols do, so only vertical ellipsis
+            for i in rowsA
                 print(io, i == 1 ? pre : presp)
-                print_matrix_row(io, X,A,i,1:n,sep)
+                print_matrix_row(io, X,A,i,colsA,sep)
                 print(io, i == m ? post : postsp)
-                if i != I[end]; println(io, ); end
-                if i == t
+                if i != rowsA[end]; println(io, ); end
+                if i == halfheight
                     print(io, i == 1 ? pre : presp)
                     print_matrix_vdots(io, vdots,A,sep,vmod,1)
                     println(io, i == m ? post : postsp)
                 end
             end
-        else # neither rows nor cols fit
-            c = div(cols-length(hdots)+1,2)+1
-            R = reverse(alignment(X,I,n:-1:1,c,c,ss))
-            c = cols - sum(map(sum,R)) - (length(R)-1)*ss - length(hdots)
-            L = alignment(X,I,1:n,c,c,ss)
-            r = mod((length(R)-n+1),vmod)
-            for i in I
+        else # neither rows nor cols fit, so use all 3 kinds of dots
+            c = div(screenwidth-length(hdots)+1,2)+1
+            Ralign = reverse(alignment(io, X, rowsA, reverse(colsA), c, c, sepsize))
+            c = screenwidth - sum(map(sum,Ralign)) - (length(Ralign)-1)*sepsize - length(hdots)
+            Lalign = alignment(io, X, rowsA, colsA, c, c, sepsize)
+            r = mod((length(Ralign)-n+1),vmod) # where to put dots on right half
+            for i in rowsA
                 print(io, i == 1 ? pre : presp)
-                print_matrix_row(io, X,L,i,1:length(L),sep)
+                print_matrix_row(io, X,Lalign,i,1:length(Lalign),sep)
                 print(io, i % hmod == 1 ? hdots : repeat(" ", length(hdots)))
-                print_matrix_row(io, X,R,i,n-length(R)+1:n,sep)
+                print_matrix_row(io, X,Ralign,i,n-length(Ralign)+colsA,sep)
                 print(io, i == m ? post : postsp)
-                if i != I[end]; println(io, ); end
-                if i == t
+                if i != rowsA[end]; println(io, ); end
+                if i == halfheight
                     print(io, i == 1 ? pre : presp)
-                    print_matrix_vdots(io, vdots,L,sep,vmod,1)
+                    print_matrix_vdots(io, vdots,Lalign,sep,vmod,1)
                     print(io, ddots)
-                    print_matrix_vdots(io, vdots,R,sep,vmod,r)
+                    print_matrix_vdots(io, vdots,Ralign,sep,vmod,r)
                     println(io, i == m ? post : postsp)
                 end
             end
@@ -1126,16 +1285,29 @@ function print_matrix(io::IO, X::AbstractVecOrMat,
     end
 end
 
-summary(x) = string(typeof(x))
+"""
+    summary(x)
 
-dims2string(d) = length(d) == 0 ? "0-dimensional" :
+Return a string giving a brief description of a value. By default returns
+`string(typeof(x))`, e.g. `Int64`.
+
+For arrays, returns a string of size and type info,
+e.g. `10-element Array{Int64,1}`.
+"""
+summary(x) = string(typeof(x)) # e.g. Int64
+
+# sizes such as 0-dimensional, 4-dimensional, 2x3
+dims2string(d) = isempty(d) ? "0-dimensional" :
                  length(d) == 1 ? "$(d[1])-element" :
                  join(map(string,d), 'x')
 
+# anything array-like gets summarized e.g. 10-element Array{Int64,1}
 summary(a::AbstractArray) =
     string(dims2string(size(a)), " ", typeof(a))
 
-function show_nd(io::IO, a::AbstractArray, limit, print_matrix, label_slices)
+# n-dimensional arrays
+function show_nd(io::IO, a::AbstractArray, print_matrix, label_slices)
+    limit::Bool = limit_output(io)
     if isempty(a)
         return
     end
@@ -1176,11 +1348,9 @@ function show_nd(io::IO, a::AbstractArray, limit, print_matrix, label_slices)
     end
 end
 
-# global flag for limiting output
-# TODO: this should be replaced with a better mechanism. currently it is only
-# for internal use in showing arrays.
-_limit_output = false
-
+"""
+`print_matrix_repr(io, X)` prints matrix X with opening and closing square brackets.
+"""
 function print_matrix_repr(io, X::AbstractArray)
     compact, prefix = array_eltype_show_how(X)
     prefix *= "["
@@ -1209,9 +1379,7 @@ end
 # array output. Not sure I want to do it this way.
 showarray(X::AbstractArray; kw...) = showarray(STDOUT, X; kw...)
 function showarray(io::IO, X::AbstractArray;
-                   header::Bool=true, limit::Bool=_limit_output,
-                   sz = (s = tty_size(); (s[1]-4, s[2])), repr=false)
-    rows, cols = sz
+                   header::Bool=true, repr=false)
     header && print(io, summary(X))
     if !isempty(X)
         header && println(io, ":")
@@ -1222,61 +1390,46 @@ function showarray(io::IO, X::AbstractArray;
                 return print(io, undef_ref_str)
             end
         end
-        if !limit
-            rows = cols = typemax(Int)
-            sz = (rows, cols)
-        end
         if repr
-            if ndims(X)<=2
+            if ndims(X) <= 2
                 print_matrix_repr(io, X)
             else
-                show_nd(io, X, limit, print_matrix_repr, false)
+                show_nd(io, X, print_matrix_repr, false)
             end
         else
             punct = (" ", "  ", "")
-            if ndims(X)<=2
-                print_matrix(io, X, sz, punct...)
+            if ndims(X) <= 2
+                print_matrix(io, X, punct...)
             else
-                show_nd(io, X, limit,
-                        (io,slice)->print_matrix(io,slice,sz,punct...),
+                show_nd(io, X,
+                        (io, slice) -> print_matrix(io, slice, punct...),
                         !repr)
             end
         end
     end
 end
 
-show(io::IO, X::AbstractArray) = showarray(io, X, header=_limit_output, repr=!_limit_output)
-
-function with_output_limit(thk, lim=true)
-    global _limit_output
-    last = _limit_output
-    _limit_output = lim
-    try
-        thk()
-    finally
-        _limit_output = last
-    end
-end
+show(io::IO, X::AbstractArray) = showarray(io, X, header=limit_output(io), repr=!limit_output(io))
 
 showall(x) = showall(STDOUT, x)
 function showall(io::IO, x)
-    if _limit_output==false
+    if !limit_output(io)
         show(io, x)
     else
-        with_output_limit(false) do
-            show(io, x)
-        end
+        show(IOContext(io, :limit_output => false), x)
     end
 end
 
-showlimited(x) = showlimited(STDOUT, x)
-function showlimited(io::IO, x)
-    if _limit_output==true
+# TODO: deprecated. remove this once methods for showcompact are gone
+showcompact_lim(io, x) = limit_output(io) ? showcompact(io, x) : show(io, x)
+showcompact_lim(io, x::Number) = limit_output(io) ? showcompact(io, x) : print(io, x)
+
+showcompact(x) = showcompact(STDOUT, x)
+function showcompact(io::IO, x)
+    if limit_output(io)
         show(io, x)
     else
-        with_output_limit(true) do
-            show(io, x)
-        end
+        show(IOContext(io, :limit_output => true), x)
     end
 end
 
@@ -1295,12 +1448,16 @@ end
 
 function show_vector(io::IO, v, opn, cls)
     compact, prefix = array_eltype_show_how(v)
+    limited = limit_output(io)
+    if limited && !compact
+        io = IOContext(io, :limit_output => false)
+    end
     print(io, prefix)
-    if _limit_output && length(v) > 20
-        show_delim_array(io, v, opn, ",", "", false, compact, 1, 10)
+    if limited && length(v) > 20
+        show_delim_array(io, v, opn, ",", "", false, 1, 10)
         print(io, "  \u2026  ")
         n = length(v)
-        show_delim_array(io, v, "", ",", cls, false, compact, n-9, 10)
+        show_delim_array(io, v, "", ",", cls, false, n-9, 10)
     else
         show_delim_array(io, v, opn, ",", cls, false)
     end
@@ -1326,7 +1483,7 @@ print_bit_chunk(c::UInt64, l::Integer) = print_bit_chunk(STDOUT, c, l)
 print_bit_chunk(c::UInt64) = print_bit_chunk(STDOUT, c)
 
 function bitshow(io::IO, B::BitArray)
-    length(B) == 0 && return
+    isempty(B) && return
     Bc = B.chunks
     for i = 1:length(Bc)-1
         print_bit_chunk(io, Bc[i])
diff --git a/base/simdloop.jl b/base/simdloop.jl
index e7742704e81ed..d8fdc5b54792f 100644
--- a/base/simdloop.jl
+++ b/base/simdloop.jl
@@ -46,8 +46,8 @@ simd_outer_range(r) = 0:0
 # Get trip count for inner loop.
 simd_inner_length(r,j::Int) = length(r)
 
-# Construct user-level index from original range, outer loop index j, and inner loop index i.
-simd_index(r,j::Int,i) = first(r)+i*step(r)
+# Construct user-level element from original range, outer loop index j, and inner loop index i.
+@inline simd_index(r,j::Int,i) = (@inbounds ret = r[i+1]; ret)
 
 # Compile Expr x in context of @simd.
 function compile(x)
diff --git a/base/socket.jl b/base/socket.jl
index 01cfa0756d31d..367a5e149c321 100644
--- a/base/socket.jl
+++ b/base/socket.jl
@@ -32,7 +32,7 @@ function IPv4(host::Integer)
 end
 
 # constructor: ("1.2.3.4")
-IPv4(ipstr::AbstractString) = parseipv4(ipstr)
+IPv4(str::AbstractString) = parse(IPv4, str)
 
 show(io::IO,ip::IPv4) = print(io,"ip\"",ip,"\"")
 print(io::IO,ip::IPv4) = print(io,dec((ip.host&(0xFF000000))>>24),".",
@@ -75,7 +75,7 @@ function IPv6(host::Integer)
     end
 end
 
-IPv6(ipstr::AbstractString) = parseipv6(ipstr)
+IPv6(str::AbstractString) = parse(IPv6, str)
 
 # Suppress leading '0's and "0x"
 print_ipv6_field(io,field::UInt16) = print(io,hex(field))
@@ -138,12 +138,12 @@ end
 
 # Parsing
 
-function parseipv4(str)
+function parse(::Type{IPv4}, str::AbstractString)
     fields = split(str,'.')
     i = 1
     ret = 0
     for f in fields
-        if length(f) == 0
+        if isempty(f)
             throw(ArgumentError("empty field in IPv4 address"))
         end
         if f[1] == '0'
@@ -199,7 +199,7 @@ function parseipv6fields(fields,num_fields)
 end
 parseipv6fields(fields) = parseipv6fields(fields,8)
 
-function parseipv6(str)
+function parse(::Type{IPv6}, str::AbstractString)
     fields = split(str,':')
     if length(fields) > 8
         throw(ArgumentError("too many fields in IPv6 address"))
@@ -207,7 +207,7 @@ function parseipv6(str)
         return IPv6(parseipv6fields(fields))
     elseif in('.',fields[end])
         return IPv6((parseipv6fields(fields[1:(end-1)],6))
-            | parseipv4(fields[end]).host )
+            | parse(IPv4, fields[end]).host )
     else
         return IPv6(parseipv6fields(fields))
     end
@@ -219,38 +219,28 @@ end
 # of the appropriate size and should use the appropriate constructor
 #
 
-function parseip(str)
-    if in(':',str)
-        # IPv6 Address
-        return parseipv6(str)
+function parse(::Type{IPAddr}, str::AbstractString)
+    if ':' in str
+        return parse(IPv6, str)
     else
-        # IPv4 Address
-        return parseipv4(str)
+        return parse(IPv4, str)
     end
 end
 
 macro ip_str(str)
-    return parseip(str)
+    return parse(IPAddr, str)
 end
 
-type InetAddr
-    host::IPAddr
+immutable InetAddr{T<:IPAddr}
+    host::T
     port::UInt16
-
-    function InetAddr(host, port::Integer)
-        if !(0 <= port <= typemax(UInt16))
-            throw(ArgumentError("port out of range, must be 0 ≤ port ≤ 65535, got $port"))
-        end
-        new(host,UInt16(port))
-    end
 end
 
+InetAddr(ip::IPAddr, port) = InetAddr{typeof(ip)}(ip, port)
 
 ## SOCKETS ##
 
-abstract Socket <: AsyncStream
-
-type TCPSocket <: Socket
+type TCPSocket <: LibuvStream
     handle::Ptr{Void}
     status::Int
     line_buffered::Bool
@@ -294,10 +284,7 @@ function TCPSocket()
     this
 end
 
-lock(s::TCPSocket) = lock(s.lock)
-unlock(s::TCPSocket) = unlock(s.lock)
-
-type TCPServer <: UVServer
+type TCPServer <: LibuvServer
     handle::Ptr{Void}
     status::Int
     ccb::Callback
@@ -328,13 +315,8 @@ function TCPServer()
     this
 end
 
-isreadable(io::TCPSocket) = true
-iswritable(io::TCPSocket) = true
-
-show(io::IO,sock::TCPSocket) = print(io,"TCPSocket(",uv_status_string(sock),", ",
-    nb_available(sock.buffer)," bytes waiting)")
-
-show(io::IO,sock::TCPServer) = print(io,"TCPServer(",uv_status_string(sock),")")
+isreadable(io::TCPSocket) = isopen(io) || nb_available(io) > 0
+iswritable(io::TCPSocket) = isopen(io) && io.status != StatusClosing
 
 ## VARIOUS METHODS TO BE MOVED TO BETTER LOCATION
 
@@ -353,19 +335,9 @@ accept(server::TCPServer) = accept(server, TCPSocket())
 accept(server::PipeServer) = accept(server, init_pipe!(PipeEndpoint();
     readable=false, writable=false, julia_only=true))
 
-##
-
-bind(sock::TCPServer, addr::InetAddr) = bind(sock,addr.host,addr.port)
-
-_bind(sock::TCPServer, host::IPv4, port::UInt16) = ccall(:jl_tcp_bind, Int32, (Ptr{Void}, UInt16, UInt32, Cuint),
-            sock.handle, hton(port), hton(host.host), 0)
-
-_bind(sock::TCPServer, host::IPv6, port::UInt16) = ccall(:jl_tcp_bind6, Int32, (Ptr{Void}, UInt16, Ptr{UInt128}, Cuint),
-            sock.handle, hton(port), &hton(host.host), 0)
-
 # UDP
 
-type UDPSocket <: Socket
+type UDPSocket <: LibuvStream
     handle::Ptr{Void}
     status::Int
     recvnotify::Condition
@@ -396,6 +368,8 @@ function UDPSocket()
     this
 end
 
+show(io::IO, stream::UDPSocket) = print(io, typeof(stream), "(", uv_status_string(stream), ")")
+
 function uvfinalize(uv::Union{TTY,PipeEndpoint,PipeServer,TCPServer,TCPSocket,UDPSocket})
     if (uv.status != StatusUninit && uv.status != StatusInit)
         close(uv)
@@ -412,6 +386,9 @@ function _uv_hook_close(sock::UDPSocket)
     notify_error(sock.recvnotify,EOFError())
 end
 
+# Disables dual stack mode.
+const UV_TCP_IPV6ONLY = 1
+
 # Disables dual stack mode. Only available when using ipv6 binf
 const UV_UDP_IPV6ONLY = 1
 
@@ -419,36 +396,41 @@ const UV_UDP_IPV6ONLY = 1
 # remainder was discarded by the OS.
 const UV_UDP_PARTIAL = 2
 
-function bind(sock::Union{TCPServer,UDPSocket}, host::IPv4, port::Integer)
-    if sock.status != StatusInit
-        error("$(typeof(sock)) is not initialized")
-    end
-    err = _bind(sock,host,UInt16(port))
-    if err < 0
-        if err != UV_EADDRINUSE && err != UV_EACCES
-            #TODO: this codepath is not currently tested
-            throw(UVError("bind",err))
-        else
-            return false
-        end
-    end
-    sock.status = StatusOpen
-    true
-end
+# Indicates if SO_REUSEADDR will be set when binding the handle in uv_udp_bind. This sets
+# the SO_REUSEPORT socket flag on the BSDs and OS X. On other Unix platforms, it sets the
+# SO_REUSEADDR flag. What that means is that multiple threads or processes can bind to the
+# same address without error (provided they all set the flag) but only the last one to bind
+# will receive any traffic, in effect "stealing" the port from the previous listener.
+const UV_UDP_REUSEADDR = 4
 
-_bind(sock::UDPSocket, host::IPv4, port::UInt16) = ccall(:jl_udp_bind, Int32, (Ptr{Void}, UInt16, UInt32, UInt32),
-            sock.handle, hton(port), hton(host.host), 0)
+##
+
+_bind(sock::TCPServer, host::IPv4, port::UInt16, flags::UInt32 = UInt32(0)) = ccall(:jl_tcp_bind, Int32, (Ptr{Void}, UInt16, UInt32, Cuint),
+            sock.handle, hton(port), hton(host.host), flags)
+
+_bind(sock::TCPServer, host::IPv6, port::UInt16, flags::UInt32 = UInt32(0)) = ccall(:jl_tcp_bind6, Int32, (Ptr{Void}, UInt16, Ptr{UInt128}, Cuint),
+            sock.handle, hton(port), Ref(hton(host.host)), flags)
+
+_bind(sock::UDPSocket, host::IPv4, port::UInt16, flags::UInt32 = UInt32(0)) = ccall(:jl_udp_bind, Int32, (Ptr{Void}, UInt16, UInt32, UInt32),
+            sock.handle, hton(port), hton(host.host), flags)
 
 _bind(sock::UDPSocket, host::IPv6, port::UInt16, flags::UInt32 = UInt32(0)) = ccall(:jl_udp_bind6, Int32, (Ptr{Void}, UInt16, Ptr{UInt128}, UInt32),
-            sock.handle, hton(port), &hton(host.host), flags)
+            sock.handle, hton(port), Ref(hton(host.host)), flags)
 
-function bind(sock::UDPSocket, host::IPv6, port::UInt16; ipv6only = false)
+function bind(sock::Union{TCPServer, UDPSocket}, host::IPAddr, port::Integer; ipv6only = false, reuseaddr = false, kws...)
     if sock.status != StatusInit
-        error("UDPSocket is not initialized")
+        error("$(typeof(sock)) is not initialized")
     end
-    err = _bind(sock,host,port, UInt32(ipv6only ? UV_UDP_IPV6ONLY : 0))
+    flags = 0
+    if isa(host,IPv6) && ipv6only
+        flags |= isa(sock, UDPSocket) ? UV_UDP_IPV6ONLY : UV_TCP_IPV6ONLY
+    end
+    if isa(sock, UDPSocket) && reuseaddr
+        flags |= UV_UDP_REUSEADDR
+    end
+    err = _bind(sock,host,UInt16(port),UInt32(flags))
     if err < 0
-        if err != UV_EADDRINUSE && err != UV_EACCES
+        if err != UV_EADDRINUSE && err != UV_EACCES && err != UV_EADDRNOTAVAIL
             #TODO: this codepath is not currently tested
             throw(UVError("bind",err))
         else
@@ -456,13 +438,15 @@ function bind(sock::UDPSocket, host::IPv6, port::UInt16; ipv6only = false)
         end
     end
     sock.status = StatusOpen
+    isa(sock, UDPSocket) && setopt(sock; kws...)
     true
 end
 
+bind(sock::TCPServer, addr::InetAddr) = bind(sock,addr.host,addr.port)
 
 function setopt(sock::UDPSocket; multicast_loop = nothing, multicast_ttl=nothing, enable_broadcast=nothing, ttl=nothing)
     if sock.status == StatusUninit
-        error("Cannot set options on unitialized socket")
+        error("Cannot set options on uninitialized socket")
     end
     if multicast_loop !== nothing
         uv_error("multicast_loop",ccall(:uv_udp_set_multicast_loop,Cint,(Ptr{Void},Cint),sock.handle,multicast_loop) < 0)
@@ -670,6 +654,8 @@ function connect!(sock::TCPSocket, host::IPv6, port::Integer)
     sock.status = StatusConnecting
 end
 
+connect!(sock::TCPSocket, addr::InetAddr) = connect!(sock, addr.host, addr.port)
+
 # Default Host to localhost
 connect(sock::TCPSocket, port::Integer) = connect(sock,IPv4(127,0,0,1),port)
 connect(port::Integer) = connect(IPv4(127,0,0,1),port)
@@ -694,7 +680,7 @@ end
 
 ##
 
-listen(sock::UVServer; backlog::Integer=BACKLOG_DEFAULT) = (uv_error("listen",_listen(sock;backlog=backlog)); sock)
+listen(sock::LibuvServer; backlog::Integer=BACKLOG_DEFAULT) = (uv_error("listen",_listen(sock;backlog=backlog)); sock)
 
 function listen(addr; backlog::Integer=BACKLOG_DEFAULT)
     sock = TCPServer()
@@ -706,7 +692,7 @@ listen(port::Integer; backlog::Integer=BACKLOG_DEFAULT) = listen(IPv4(UInt32(0))
 listen(host::IPAddr, port::Integer; backlog::Integer=BACKLOG_DEFAULT) = listen(InetAddr(host,port);backlog=backlog)
 
 listen(cb::Callback,args...; backlog::Integer=BACKLOG_DEFAULT) = (sock=listen(args...;backlog=backlog);sock.ccb=cb;sock)
-listen(cb::Callback,sock::Socket; backlog::Integer=BACKLOG_DEFAULT) = (sock.ccb=cb;listen(sock;backlog=backlog))
+listen(cb::Callback,sock::Union{TCPSocket,UDPSocket}; backlog::Integer=BACKLOG_DEFAULT) = (sock.ccb=cb;listen(sock;backlog=backlog))
 
 ##
 
@@ -736,9 +722,41 @@ function listenany(default_port)
             return (addr.port,sock)
         end
         close(sock)
-        addr.port += 1
+        addr = InetAddr(addr.host, addr.port + 1)
         if addr.port==default_port
             error("no ports available")
         end
     end
 end
+
+function getsockname(sock::Union{TCPServer,TCPSocket})
+    rport = Ref{Cushort}(0)
+    raddress = zeros(UInt8, 16)
+    rfamily = Ref{Cuint}(0)
+    r = if isa(sock, TCPServer)
+        ccall(:jl_tcp_getsockname, Int32,
+                (Ptr{Void}, Ref{Cushort}, Ptr{Void}, Ref{Cuint}),
+                sock.handle, rport, raddress, rfamily)
+    else
+        ccall(:jl_tcp_getpeername, Int32,
+                (Ptr{Void}, Ref{Cushort}, Ptr{Void}, Ref{Cuint}),
+                sock.handle, rport, raddress, rfamily)
+    end
+    uv_error("cannot obtain socket name", r);
+    if r == 0
+        port = ntoh(rport[])
+        if rfamily[] == 2 # AF_INET
+            addrv4 = raddress[1:4]
+            naddr = ntoh(unsafe_load(Ptr{Cuint}(pointer(addrv4)), 1))
+            addr = IPv4(naddr)
+        elseif rfamily[] == @windows? 23 : (@osx? 30 : 10) # AF_INET6
+            naddr = ntoh(unsafe_load(Ptr{UInt128}(pointer(raddress)), 1))
+            addr = IPv6(naddr)
+        else
+            error("unsupported address family: $(getindex(rfamily))")
+        end
+    else
+        error("cannot obtain socket name")
+    end
+    return addr, port
+end
diff --git a/base/sparse.jl b/base/sparse.jl
index b9e751abbe20b..8ea18173d8187 100644
--- a/base/sparse.jl
+++ b/base/sparse.jl
@@ -1,25 +1,39 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-module SparseMatrix
+module SparseArrays
 
 using Base: Func, AddFun, OrFun, ConjFun, IdFun
 using Base.Sort: Forward
-using Base.LinAlg: AbstractTriangular
+using Base.LinAlg: AbstractTriangular, PosDefException
 
-importall Base
-importall ..Base.Operators
-importall Base.LinAlg
-import Base.promote_eltype
-import Base.@get!
-import Base.Broadcast.eltype_plus, Base.Broadcast.broadcast_shape
+import Base: +, -, *, \, &, |, $, .+, .-, .*, ./, .\, .^, .<, .!=, ==
+import Base: A_mul_B!, Ac_mul_B, Ac_mul_B!, At_mul_B, At_mul_B!, At_ldiv_B, Ac_ldiv_B, A_ldiv_B!
+import Base.LinAlg: At_ldiv_B!, Ac_ldiv_B!
 
-export AbstractSparseArray, AbstractSparseMatrix, AbstractSparseVector, SparseMatrixCSC,
-       blkdiag, dense, droptol!, dropzeros!, etree, issparse, nnz, nonzeros, nzrange,
-       rowvals, sparse, sparsevec, spdiagm, speye, spones, sprand, sprandbool, sprandn,
-       spzeros, symperm
+import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh,
+    atan, atand, atanh, broadcast!, chol, conj!, cos, cosc, cosd, cosh, cospi, cot,
+    cotd, coth, countnz, csc, cscd, csch, ctranspose!, diag, diff, done, dot, eig,
+    exp10, exp2, eye, findn, floor, hash, indmin, inv, issymmetric, istril, istriu,
+    log10, log2, lu, maxabs, minabs, next, sec, secd, sech, show, showarray, sin,
+    sinc, sind, sinh, sinpi, squeeze, start, sum, sumabs, sumabs2, summary, tan,
+    tand, tanh, trace, transpose!, tril!, triu!, trunc, vecnorm, writemime, abs, abs2,
+    broadcast, ceil, complex, cond, conj, convert, copy, copy!, ctranspose, diagm,
+    exp, expm1, factorize, find, findmax, findmin, findnz, float, full, getindex,
+    hcat, hvcat, imag, indmax, ishermitian, kron, length, log, log1p, max, min,
+    maximum, minimum, norm, one, promote_eltype, real, reinterpret, reshape, rot180,
+    rotl90, rotr90, round, scale!, setindex!, similar, size, transpose, tril,
+    triu, vcat, vec
+
+import Base.Broadcast: eltype_plus, broadcast_shape
+
+export AbstractSparseArray, AbstractSparseMatrix, AbstractSparseVector,
+    SparseMatrixCSC, SparseVector, blkdiag, dense, droptol!, dropzeros!, etree,
+    issparse, nonzeros, nzrange, rowvals, sparse, sparsevec, spdiagm, speye, spones,
+    sprand, sprandbool, sprandn, spzeros, symperm, nnz
 
 include("sparse/abstractsparse.jl")
 include("sparse/sparsematrix.jl")
+include("sparse/sparsevector.jl")
 include("sparse/csparse.jl")
 
 include("sparse/linalg.jl")
@@ -29,4 +43,4 @@ if Base.USE_GPL_LIBS
     include("sparse/spqr.jl")
 end
 
-end # module SparseMatrix
+end
diff --git a/base/sparse/abstractsparse.jl b/base/sparse/abstractsparse.jl
index 41255cfaef42b..5b5cd0dfc0a2f 100644
--- a/base/sparse/abstractsparse.jl
+++ b/base/sparse/abstractsparse.jl
@@ -5,7 +5,19 @@ abstract AbstractSparseArray{Tv,Ti,N} <: AbstractArray{Tv,N}
 typealias AbstractSparseVector{Tv,Ti} AbstractSparseArray{Tv,Ti,1}
 typealias AbstractSparseMatrix{Tv,Ti} AbstractSparseArray{Tv,Ti,2}
 
+"""
+    issparse(S)
+
+Returns `true` if `S` is sparse, and `false` otherwise.
+"""
 issparse(A::AbstractArray) = false
 issparse(S::AbstractSparseArray) = true
 
+issparse{T, A<:AbstractSparseMatrix}(S::Symmetric{T, A}) = true
+issparse{T, A<:AbstractSparseMatrix}(S::Hermitian{T, A}) = true
+issparse{T, A<:AbstractSparseMatrix}(S::LowerTriangular{T, A}) = true
+issparse{T, A<:AbstractSparseMatrix}(S::LinAlg.UnitLowerTriangular{T, A}) = true
+issparse{T, A<:AbstractSparseMatrix}(S::UpperTriangular{T, A}) = true
+issparse{T, A<:AbstractSparseMatrix}(S::LinAlg.UnitUpperTriangular{T, A}) = true
+
 indtype{Tv,Ti}(S::AbstractSparseArray{Tv,Ti}) = Ti
diff --git a/base/sparse/cholmod.jl b/base/sparse/cholmod.jl
index ec7e980a7ed49..dbf65105356fb 100644
--- a/base/sparse/cholmod.jl
+++ b/base/sparse/cholmod.jl
@@ -2,21 +2,21 @@
 
 module CHOLMOD
 
-import Base: (*), convert, copy, eltype, getindex, show, showarray, size,
+import Base: (*), convert, copy, eltype, get, getindex, show, showarray, size,
              linearindexing, LinearFast, LinearSlow, ctranspose
 
 import Base.LinAlg: (\), A_mul_Bc, A_mul_Bt, Ac_ldiv_B, Ac_mul_B, At_ldiv_B, At_mul_B,
-                 cholfact, det, diag, ishermitian, isposdef,
-                 issym, ldltfact, logdet
+                 cholfact, cholfact!, det, diag, ishermitian, isposdef,
+                 issymmetric, ldltfact, ldltfact!, logdet
 
-import Base.SparseMatrix: sparse, nnz
+importall ..SparseArrays
 
 export
     Dense,
     Factor,
     Sparse
 
-using Base.SparseMatrix: AbstractSparseMatrix, SparseMatrixCSC, increment, indtype
+import ..SparseArrays: AbstractSparseMatrix, SparseMatrixCSC, increment, indtype
 
 #########
 # Setup #
@@ -173,13 +173,15 @@ end
 # Type definitions #
 ####################
 
+abstract SuiteSparseStruct
+
 # The three core data types for CHOLMOD: Dense, Sparse and Factor.
 # CHOLMOD manages the memory, so the Julia versions only wrap a
 # pointer to a struct.  Therefore finalizers should be registered each
 # time a pointer is returned from CHOLMOD.
 
 # Dense
-immutable C_Dense{T<:VTypes}
+immutable C_Dense{T<:VTypes} <: SuiteSparseStruct
     nrow::Csize_t
     ncol::Csize_t
     nzmax::Csize_t
@@ -195,7 +197,7 @@ type Dense{T<:VTypes} <: DenseMatrix{T}
 end
 
 # Sparse
-immutable C_Sparse{Tv<:VTypes}
+immutable C_Sparse{Tv<:VTypes} <: SuiteSparseStruct
     nrow::Csize_t
     ncol::Csize_t
     nzmax::Csize_t
@@ -215,7 +217,7 @@ end
 # Corresponds to the exact definition of cholmod_sparse_struct in the library.
 # Useful when reading matrices of unknown type from files as in
 # cholmod_read_sparse
-immutable C_SparseVoid
+immutable C_SparseVoid <: SuiteSparseStruct
     nrow::Csize_t
     ncol::Csize_t
     nzmax::Csize_t
@@ -246,7 +248,7 @@ Sparse{Tv<:VTypes}(p::Ptr{C_Sparse{Tv}}) = Sparse{Tv}(p)
 # Factor
 
 if build_version >= v"2.1.0" # CHOLMOD version 2.1.0 or later
-    immutable C_Factor{Tv<:VTypes}
+    immutable C_Factor{Tv<:VTypes} <: SuiteSparseStruct
         n::Csize_t
         minor::Csize_t
         Perm::Ptr{SuiteSparse_long}
@@ -278,7 +280,7 @@ if build_version >= v"2.1.0" # CHOLMOD version 2.1.0 or later
         dtype::Cint
     end
 else
-    immutable C_Factor{Tv<:VTypes}
+    immutable C_Factor{Tv<:VTypes} <: SuiteSparseStruct
         n::Csize_t
         minor::Csize_t
         Perm::Ptr{SuiteSparse_long}
@@ -321,12 +323,23 @@ type Factor{Tv} <: Factorization{Tv}
 end
 Factor{Tv<:VTypes}(p::Ptr{C_Factor{Tv}}) = Factor{Tv}(p)
 
+# Define get similar to get(Nullable) to check pointers. All pointer loads should be wrapped in get to make sure
+# that SuiteSparse is not called with a C_NULL pointer which could cause a segfault. Pointers are set to null
+# when serialized so this can happen when mutiple processes are in use.
+function get{T<:SuiteSparseStruct}(p::Ptr{T})
+    if p == C_NULL
+        throw(ArgumentError("pointer to the $T object is null. This can happen if the object has been serialized."))
+    else
+        return p
+    end
+end
+
 # FactorComponent, for encoding particular factors from a factorization
 type FactorComponent{Tv,S} <: AbstractMatrix{Tv}
     F::Factor{Tv}
 
     function FactorComponent(F::Factor{Tv})
-        s = unsafe_load(F.p)
+        s = unsafe_load(get(F.p))
         if s.is_ll != 0
             S == :L || S == :U || S == :PtL || S == :UP || throw(CHOLMODException(string(S, " not supported for sparse LLt matrices; try :L, :U, :PtL, or :UP")))
         else
@@ -400,14 +413,14 @@ eye(n::Integer) = eye(n, n, Float64)
 function copy_dense{Tv<:VTypes}(A::Dense{Tv})
     d = Dense(ccall((:cholmod_l_copy_dense, :libcholmod), Ptr{C_Dense{Tv}},
         (Ptr{C_Dense{Tv}}, Ptr{UInt8}),
-         A.p, common()))
+         get(A.p), common()))
     finalizer(d, free!)
     d
 end
 
 ### cholmod_matrixops.h ###
 function norm_dense{Tv<:VTypes}(D::Dense{Tv}, p::Integer)
-    s = unsafe_load(D.p)
+    s = unsafe_load(get(D.p))
     if p == 2
         if s.ncol > 1
             throw(ArgumentError("2 norm only supported when matrix has one column"))
@@ -417,7 +430,7 @@ function norm_dense{Tv<:VTypes}(D::Dense{Tv}, p::Integer)
     end
     ccall((:cholmod_l_norm_dense, :libcholmod), Cdouble,
         (Ptr{C_Dense{Tv}}, Cint, Ptr{UInt8}),
-          D.p, p, common())
+          get(D.p), p, common())
 end
 
 ### cholmod_check.h ###
@@ -471,7 +484,7 @@ function aat{Tv<:VRealTypes}(A::Sparse{Tv}, fset::Vector{SuiteSparse_long}, mode
     s = Sparse(ccall((@cholmod_name("aat", SuiteSparse_long), :libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{SuiteSparse_long}, Csize_t, Cint, Ptr{UInt8}),
-                A.p, fset, length(fset), mode, common()))
+                get(A.p), fset, length(fset), mode, common()))
     finalizer(s, free!)
     s
 end
@@ -480,7 +493,7 @@ function sparse_to_dense{Tv<:VTypes}(A::Sparse{Tv})
     d = Dense(ccall((@cholmod_name("sparse_to_dense", SuiteSparse_long),:libcholmod),
         Ptr{C_Dense{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                A.p, common()))
+                get(A.p), common()))
     finalizer(d, free!)
     d
 end
@@ -488,7 +501,7 @@ function dense_to_sparse{Tv<:VTypes}(D::Dense{Tv}, ::Type{SuiteSparse_long})
     s = Sparse(ccall((@cholmod_name("dense_to_sparse", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Dense{Tv}}, Cint, Ptr{UInt8}),
-                D.p, true, common()))
+                get(D.p), true, common()))
     finalizer(s, free!)
     s
 end
@@ -499,7 +512,7 @@ function factor_to_sparse!{Tv<:VTypes}(F::Factor{Tv})
     s = Sparse(ccall((@cholmod_name("factor_to_sparse", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-                F.p, common()))
+                get(F.p), common()))
     finalizer(s, free!)
     s
 end
@@ -507,33 +520,33 @@ end
 function change_factor!{Tv<:VTypes}(::Type{Float64}, to_ll::Bool, to_super::Bool, to_packed::Bool, to_monotonic::Bool, F::Factor{Tv})
     @isok ccall((@cholmod_name("change_factor", SuiteSparse_long),:libcholmod), Cint,
             (Cint, Cint, Cint, Cint, Cint, Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-                REAL, to_ll, to_super, to_packed, to_monotonic, F.p, common())
+                REAL, to_ll, to_super, to_packed, to_monotonic, get(F.p), common())
     Factor{Float64}(F.p)
 end
 
 function change_factor!{Tv<:VTypes}(::Type{Complex{Float64}}, to_ll::Bool, to_super::Bool, to_packed::Bool, to_monotonic::Bool, F::Factor{Tv})
     @isok ccall((@cholmod_name("change_factor", SuiteSparse_long),:libcholmod), Cint,
             (Cint, Cint, Cint, Cint, Cint, Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-                COMPLEX, to_ll, to_super, to_packed, to_monotonic, F.p, common())
+                COMPLEX, to_ll, to_super, to_packed, to_monotonic, get(F.p), common())
     Factor{Complex{Float64}}(F.p)
 end
 
 function check_sparse{Tv<:VTypes}(A::Sparse{Tv})
     ccall((@cholmod_name("check_sparse", SuiteSparse_long),:libcholmod), Cint,
           (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-          A.p, common())!=0
+          get(A.p), common())!=0
 end
 
 function check_factor{Tv<:VTypes}(F::Factor{Tv})
     ccall((@cholmod_name("check_factor", SuiteSparse_long),:libcholmod), Cint,
           (Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-          F.p, common())!=0
+          get(F.p), common())!=0
 end
 
 function nnz{Tv<:VTypes}(A::Sparse{Tv})
     ccall((@cholmod_name("nnz", SuiteSparse_long),:libcholmod), Int,
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                A.p, common())
+                get(A.p), common())
 end
 
 function speye{Tv<:VTypes}(m::Integer, n::Integer, ::Type{Tv})
@@ -558,7 +571,7 @@ function transpose_{Tv<:VTypes}(A::Sparse{Tv}, values::Integer)
     s = Sparse(ccall((@cholmod_name("transpose", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-                A.p, values, common()))
+                get(A.p), values, common()))
     finalizer(s, free!)
     s
 end
@@ -567,7 +580,7 @@ function copy_factor{Tv<:VTypes}(F::Factor{Tv})
     f = Factor(ccall((@cholmod_name("copy_factor", SuiteSparse_long),:libcholmod),
         Ptr{C_Factor{Tv}},
             (Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-                F.p, common()))
+                get(F.p), common()))
     finalizer(f, free!)
     f
 end
@@ -575,7 +588,7 @@ function copy_sparse{Tv<:VTypes}(A::Sparse{Tv})
     s = Sparse(ccall((@cholmod_name("copy_sparse", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                A.p, common()))
+                get(A.p), common()))
     finalizer(s, free!)
     s
 end
@@ -583,7 +596,7 @@ function copy{Tv<:VRealTypes}(A::Sparse{Tv}, stype::Integer, mode::Integer)
     s = Sparse(ccall((@cholmod_name("copy", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Cint, Cint, Ptr{UInt8}),
-                A.p, stype, mode, common()))
+                get(A.p), stype, mode, common()))
     finalizer(s, free!)
     s
 end
@@ -594,7 +607,7 @@ function print_sparse{Tv<:VTypes}(A::Sparse{Tv}, name::ASCIIString)
     set_print_level(cm, 3)
     @isok ccall((@cholmod_name("print_sparse", SuiteSparse_long),:libcholmod), Cint,
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}, Ptr{UInt8}),
-                 A.p, name, cm)
+                 get(A.p), name, cm)
     nothing
 end
 function print_factor{Tv<:VTypes}(F::Factor{Tv}, name::ASCIIString)
@@ -602,14 +615,14 @@ function print_factor{Tv<:VTypes}(F::Factor{Tv}, name::ASCIIString)
     set_print_level(cm, 3)
     @isok ccall((@cholmod_name("print_factor", SuiteSparse_long),:libcholmod), Cint,
             (Ptr{C_Factor{Tv}}, Ptr{UInt8}, Ptr{UInt8}),
-                F.p, name, cm)
+                get(F.p), name, cm)
     nothing
 end
 
 ### cholmod_matrixops.h ###
 function ssmult{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv}, stype::Integer, values::Bool, sorted::Bool)
-    lA = unsafe_load(A.p)
-    lB = unsafe_load(B.p)
+    lA = unsafe_load(get(A.p))
+    lB = unsafe_load(get(B.p))
     if lA.ncol != lB.nrow
         throw(DimensionMismatch("inner matrix dimensions do not fit"))
     end
@@ -617,7 +630,7 @@ function ssmult{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv}, stype::Integer, va
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{C_Sparse{Tv}}, Cint, Cint,
                 Cint, Ptr{UInt8}),
-             A.p, B.p, stype, values,
+             get(A.p), get(B.p), stype, values,
                 sorted, common()))
     finalizer(s, free!)
     s
@@ -629,21 +642,21 @@ function norm_sparse{Tv<:VTypes}(A::Sparse{Tv}, norm::Integer)
     end
     ccall((@cholmod_name("norm_sparse", SuiteSparse_long), :libcholmod), Cdouble,
             (Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-                A.p, norm, common())
+                get(A.p), norm, common())
 end
 
 function horzcat{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool)
     s = Sparse(ccall((@cholmod_name("horzcat", SuiteSparse_long), :libcholmod),
         Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-             A.p, B.p, values, common()))
+             get(A.p), get(B.p), values, common()))
     finalizer(s, free!)
     s
 end
 
 function scale!{Tv<:VRealTypes}(S::Dense{Tv}, scale::Integer, A::Sparse{Tv})
-    sS = unsafe_load(S.p)
-    sA = unsafe_load(A.p)
+    sS = unsafe_load(get(S.p))
+    sA = unsafe_load(get(A.p))
     sS.ncol == 1 || sS.nrow == 1 || throw(DimensionMismatch("first argument must be a vector"))
     if scale == SCALAR && sS.nrow != 1
         throw(DimensionMismatch("scaling argument must have length one"))
@@ -659,10 +672,10 @@ function scale!{Tv<:VRealTypes}(S::Dense{Tv}, scale::Integer, A::Sparse{Tv})
         end
     end
 
-    sA = unsafe_load(A.p)
+    sA = unsafe_load(get(A.p))
     @isok ccall((@cholmod_name("scale",SuiteSparse_long),:libcholmod), Cint,
             (Ptr{C_Dense{Tv}}, Cint, Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                S.p, scale, A.p, common())
+                get(S.p), scale, get(A.p), common())
     A
 end
 
@@ -677,14 +690,14 @@ function sdmult!{Tv<:VTypes}(A::Sparse{Tv}, transpose::Bool, α::Number, β::Num
             (Ptr{C_Sparse{Tv}}, Cint,
              Ref{Complex128}, Ref{Complex128},
              Ptr{C_Dense{Tv}}, Ptr{C_Dense{Tv}}, Ptr{UInt8}),
-                A.p, transpose, α, β, X.p, Y.p, common())
+                get(A.p), transpose, α, β, get(X.p), get(Y.p), common())
     Y
 end
 
 function vertcat{Tv<:VRealTypes}(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool)
     s = Sparse(ccall((@cholmod_name("vertcat", SuiteSparse_long), :libcholmod), Ptr{C_Sparse{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{C_Sparse{Tv}}, Cint, Ptr{UInt8}),
-                A.p, B.p, values, common()))
+                get(A.p), get(B.p), values, common()))
     finalizer(s, free!)
     s
 end
@@ -697,7 +710,7 @@ function symmetry{Tv<:VTypes}(A::Sparse{Tv}, option::Integer)
     rv = ccall((@cholmod_name("symmetry", SuiteSparse_long), :libcholmod), Cint,
             (Ptr{C_Sparse{Tv}}, Cint, Ptr{SuiteSparse_long}, Ptr{SuiteSparse_long},
                 Ptr{SuiteSparse_long}, Ptr{SuiteSparse_long}, Ptr{UInt8}),
-                    A.p, option, xmatched, pmatched,
+                    get(A.p), option, xmatched, pmatched,
                         nzoffdiag, nzdiag, common())
     rv, xmatched[1], pmatched[1], nzoffdiag[1], nzdiag[1]
 end
@@ -709,7 +722,7 @@ function analyze{Tv<:VTypes}(A::Sparse{Tv}, cmmn::Vector{UInt8})
     f = Factor(ccall((@cholmod_name("analyze", SuiteSparse_long),:libcholmod),
         Ptr{C_Factor{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                A.p, cmmn))
+                get(A.p), cmmn))
     finalizer(f, free!)
     f
 end
@@ -719,14 +732,14 @@ function analyze_p{Tv<:VTypes}(A::Sparse{Tv}, perm::Vector{SuiteSparse_long},
     f = Factor(ccall((@cholmod_name("analyze_p", SuiteSparse_long),:libcholmod),
         Ptr{C_Factor{Tv}},
             (Ptr{C_Sparse{Tv}}, Ptr{SuiteSparse_long}, Ptr{SuiteSparse_long}, Csize_t, Ptr{UInt8}),
-                A.p, perm, C_NULL, 0, cmmn))
+                get(A.p), perm, C_NULL, 0, cmmn))
     finalizer(f, free!)
     f
 end
 function factorize!{Tv<:VTypes}(A::Sparse{Tv}, F::Factor{Tv}, cmmn::Vector{UInt8})
     @isok ccall((@cholmod_name("factorize", SuiteSparse_long),:libcholmod), Cint,
         (Ptr{C_Sparse{Tv}}, Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-            A.p, F.p, cmmn)
+            get(A.p), get(F.p), cmmn)
     F
 end
 function factorize_p!{Tv<:VTypes}(A::Sparse{Tv}, β::Real, F::Factor{Tv}, cmmn::Vector{UInt8})
@@ -735,7 +748,7 @@ function factorize_p!{Tv<:VTypes}(A::Sparse{Tv}, β::Real, F::Factor{Tv}, cmmn::
     @isok ccall((@cholmod_name("factorize_p", SuiteSparse_long),:libcholmod), Cint,
         (Ptr{C_Sparse{Tv}}, Ref{Complex128}, Ptr{SuiteSparse_long}, Csize_t,
          Ptr{C_Factor{Tv}}, Ptr{UInt8}),
-            A.p, β, C_NULL, 0, F.p, cmmn)
+            get(A.p), β, C_NULL, 0, get(F.p), cmmn)
     F
 end
 
@@ -745,7 +758,7 @@ function solve{Tv<:VTypes}(sys::Integer, F::Factor{Tv}, B::Dense{Tv})
     end
     d = Dense(ccall((@cholmod_name("solve", SuiteSparse_long),:libcholmod), Ptr{C_Dense{Tv}},
             (Cint, Ptr{C_Factor{Tv}}, Ptr{C_Dense{Tv}}, Ptr{UInt8}),
-                sys, F.p, B.p, common()))
+                sys, get(F.p), get(B.p), common()))
     finalizer(d, free!)
     d
 end
@@ -757,7 +770,7 @@ function spsolve{Tv<:VTypes}(sys::Integer, F::Factor{Tv}, B::Sparse{Tv})
     s = Sparse(ccall((@cholmod_name("spsolve", SuiteSparse_long),:libcholmod),
         Ptr{C_Sparse{Tv}},
             (Cint, Ptr{C_Factor{Tv}}, Ptr{C_Sparse{Tv}}, Ptr{UInt8}),
-                sys, F.p, B.p, common()))
+                sys, get(F.p), get(B.p), common()))
     finalizer(s, free!)
     s
 end
@@ -784,7 +797,7 @@ function read_sparse(file::IO, T)
 end
 
 function get_perm(F::Factor)
-    s = unsafe_load(F.p)
+    s = unsafe_load(get(F.p))
     p = pointer_to_array(s.Perm, s.n, false)
     p+1
 end
@@ -795,17 +808,22 @@ get_perm(FC::FactorComponent) = get_perm(Factor(FC))
 #########################
 
 # Convertion/construction
-function convert{T<:VTypes}(::Type{Dense}, A::VecOrMat{T})
+function convert{T<:VTypes}(::Type{Dense{T}}, A::VecOrMat)
     d = allocate_dense(size(A, 1), size(A, 2), stride(A, 2), T)
     s = unsafe_load(d.p)
-    unsafe_copy!(s.x, pointer(A), length(A))
+    for i in eachindex(A)
+        unsafe_store!(s.x, A[i], i)
+    end
     d
 end
-convert(::Type{Dense}, A::VecOrMat) = Dense(float(A))
+function convert(::Type{Dense}, A::VecOrMat)
+    T = promote_type(eltype(A), Float64)
+    return convert(Dense{T}, A)
+end
 convert(::Type{Dense}, A::Sparse) = sparse_to_dense(A)
 
 # This constructior assumes zero based colptr and rowval
-function convert{Tv<:VTypes}(::Type{Sparse}, m::Integer, n::Integer, colptr::Vector{SuiteSparse_long}, rowval::Vector{SuiteSparse_long}, nzval::Vector{Tv}, stype)
+function (::Type{Sparse}){Tv<:VTypes}(m::Integer, n::Integer, colptr::Vector{SuiteSparse_long}, rowval::Vector{SuiteSparse_long}, nzval::Vector{Tv}, stype)
 
     # check if columns are sorted
     iss = true
@@ -828,7 +846,7 @@ function convert{Tv<:VTypes}(::Type{Sparse}, m::Integer, n::Integer, colptr::Vec
     return o
 
 end
-function convert{Tv<:VTypes}(::Type{Sparse}, m::Integer, n::Integer, colptr::Vector{SuiteSparse_long}, rowval::Vector{SuiteSparse_long}, nzval::Vector{Tv})
+function (::Type{Sparse}){Tv<:VTypes}(m::Integer, n::Integer, colptr::Vector{SuiteSparse_long}, rowval::Vector{SuiteSparse_long}, nzval::Vector{Tv})
     o = Sparse(m, n, colptr, rowval, nzval, 0)
 
     # check if array is symmetric and change stype if it is
@@ -838,7 +856,7 @@ function convert{Tv<:VTypes}(::Type{Sparse}, m::Integer, n::Integer, colptr::Vec
     o
 end
 
-function convert{Tv<:VTypes}(::Type{Sparse}, A::SparseMatrixCSC{Tv,SuiteSparse_long}, stype::Integer)
+function (::Type{Sparse}){Tv<:VTypes}(A::SparseMatrixCSC{Tv,SuiteSparse_long}, stype::Integer)
     o = allocate_sparse(A.m, A.n, length(A.nzval), true, true, stype, Tv)
     s = unsafe_load(o.p)
     for i = 1:length(A.colptr)
@@ -853,7 +871,10 @@ function convert{Tv<:VTypes}(::Type{Sparse}, A::SparseMatrixCSC{Tv,SuiteSparse_l
 
     return o
 end
-function convert{Tv<:VTypes}(::Type{Sparse}, A::SparseMatrixCSC{Tv,SuiteSparse_long})
+
+# convert SparseVectors into CHOLMOD Sparse types through a mx1 CSC matrix
+convert{Tv<:VTypes}(::Type{Sparse}, A::SparseVector{Tv,SuiteSparse_long}) = convert(Sparse, convert(SparseMatrixCSC, A))
+function convert{Tv<:VTypes,Ti<:ITypes}(::Type{Sparse}, A::SparseMatrixCSC{Tv,Ti})
     o = Sparse(A, 0)
     # check if array is symmetric and change stype if it is
     if ishermitian(o)
@@ -861,15 +882,22 @@ function convert{Tv<:VTypes}(::Type{Sparse}, A::SparseMatrixCSC{Tv,SuiteSparse_l
     end
     o
 end
-
+convert{Ti<:ITypes}(::Type{Sparse}, A::SparseMatrixCSC{Complex{Float32},Ti}) = convert(Sparse, convert(SparseMatrixCSC{Complex{Float64},SuiteSparse_long}, A))
 convert(::Type{Sparse}, A::Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}) = Sparse(A.data, A.uplo == 'L' ? -1 : 1)
 convert{Tv<:VTypes}(::Type{Sparse}, A::Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}) = Sparse(A.data, A.uplo == 'L' ? -1 : 1)
-function convert{T}(::Type{Sparse},
-    A::Union{SparseMatrixCSC{T,SuiteSparse_long},
-             Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
-             Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}},
+function convert{Ti<:ITypes}(::Type{Sparse},
+    A::Union{SparseMatrixCSC{BigFloat,Ti},
+             Symmetric{BigFloat,SparseMatrixCSC{BigFloat,Ti}},
+             Hermitian{Complex{BigFloat},SparseMatrixCSC{Complex{BigFloat},Ti}}},
+    args...)
+    throw(MethodError(convert, (Sparse, A)))
+end
+function convert{T,Ti<:ITypes}(::Type{Sparse},
+    A::Union{SparseMatrixCSC{T,Ti},
+             Symmetric{T,SparseMatrixCSC{T,Ti}},
+             Hermitian{T,SparseMatrixCSC{T,Ti}}},
     args...)
-    return Sparse(float(A), args...)
+    return Sparse(convert(AbstractMatrix{promote_type(Float64, T)}, A), args...)
 end
 
 # Useful when reading in files, but not type stable
@@ -919,7 +947,7 @@ end
 
 convert(::Type{Sparse}, A::Dense) = dense_to_sparse(A, SuiteSparse_long)
 convert(::Type{Sparse}, L::Factor) = factor_to_sparse!(copy(L))
-function convert(::Type{Sparse}, filename::ByteString)
+function (::Type{Sparse})(filename::ByteString)
     open(filename) do f
         return read_sparse(f, SuiteSparse_long)
     end
@@ -958,7 +986,7 @@ function convert{Tv}(::Type{SparseMatrixCSC{Tv,SuiteSparse_long}}, A::Sparse{Tv}
 end
 function convert(::Type{Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}}, A::Sparse{Float64})
     s = unsafe_load(A.p)
-    if !issym(A)
+    if !issymmetric(A)
         throw(ArgumentError("matrix is not symmetric"))
     end
     return Symmetric(SparseMatrixCSC(s.nrow, s.ncol, increment(pointer_to_array(s.p, (s.ncol + 1,), false)), increment(pointer_to_array(s.i, (s.nzmax,), false)), copy(pointer_to_array(s.x, (s.nzmax,), false))), s.stype > 0 ? :U : :L)
@@ -992,9 +1020,9 @@ function sparse(F::Factor)
     else
         LD = sparse(F[:LD])
         L, d = getLd!(LD)
-        A = scale(L, d)*L'
+        A = (L * Diagonal(d)) * L'
     end
-    SparseMatrix.sortSparseMatrixCSC!(A)
+    SparseArrays.sortSparseMatrixCSC!(A)
     p = get_perm(F)
     if p != [1:s.n;]
         pinv = Array(Int, length(p))
@@ -1006,7 +1034,7 @@ function sparse(F::Factor)
     A
 end
 
-sparse(D::Dense)    = sparse(Sparse(D))
+sparse(D::Dense) = sparse(Sparse(D))
 
 function sparse{Tv}(FC::FactorComponent{Tv,:L})
     F = Factor(FC)
@@ -1018,11 +1046,9 @@ sparse{Tv}(FC::FactorComponent{Tv,:LD}) = sparse(Sparse(Factor(FC)))
 
 # Calculate the offset into the stype field of the cholmod_sparse_struct and
 # change the value
-let offidx=findfirst(fieldnames(C_Sparse) .== :stype)
-
+let offset = fieldoffset(C_Sparse{Float64}, findfirst(fieldnames(C_Sparse) .== :stype))
     global change_stype!
     function change_stype!(A::Sparse, i::Integer)
-        offset = fieldoffsets(C_Sparse)[offidx]
         unsafe_store!(convert(Ptr{Cint}, A.p), i, div(offset, 4) + 1)
         return A
     end
@@ -1050,15 +1076,13 @@ function showarray(io::IO, FC::FactorComponent; kargs...)
 end
 
 function showfactor(io::IO, F::Factor)
-    s = unsafe_load(F.p)
+    s = unsafe_load(get(F.p))
     @printf(io, "type: %12s\n", s.is_ll!=0 ? "LLt" : "LDLt")
     @printf(io, "method: %10s\n", s.is_super!=0 ? "supernodal" : "simplicial")
     @printf(io, "maxnnz: %10d\n", Int(s.nzmax))
     @printf(io, "nnz: %13d\n", nnz(F))
 end
 
-
-
 isvalid(A::Dense) = check_dense(A)
 isvalid(A::Sparse) = check_sparse(A)
 isvalid(A::Factor) = check_factor(A)
@@ -1068,14 +1092,14 @@ copy(A::Sparse) = copy_sparse(A)
 copy(A::Factor) = copy_factor(A)
 
 function size(A::Union{Dense,Sparse})
-    s = unsafe_load(A.p)
+    s = unsafe_load(get(A.p))
     return (Int(s.nrow), Int(s.ncol))
 end
 function size(F::Factor, i::Integer)
     if i < 1
         throw(ArgumentError("dimension must be positive"))
     end
-    s = unsafe_load(F.p)
+    s = unsafe_load(get(F.p))
     if i <= 2
         return Int(s.n)
     end
@@ -1098,14 +1122,14 @@ ctranspose{Tv}(FC::FactorComponent{Tv,:PtLD}) = FactorComponent{Tv,:DUP}(FC.F)
 ctranspose{Tv}(FC::FactorComponent{Tv,:DUP}) = FactorComponent{Tv,:PtLD}(FC.F)
 
 function getindex(A::Dense, i::Integer)
-    s = unsafe_load(A.p)
+    s = unsafe_load(get(A.p))
     0 < i <= s.nrow*s.ncol || throw(BoundsError())
     unsafe_load(s.x, i)
 end
 
 linearindexing(::Sparse) = LinearSlow()
 function getindex{T}(A::Sparse{T}, i0::Integer, i1::Integer)
-    s = unsafe_load(A.p)
+    s = unsafe_load(get(A.p))
     !(1 <= i0 <= s.nrow && 1 <= i1 <= s.ncol) && throw(BoundsError())
     s.stype < 0 && i0 < i1 && return conj(A[i1,i0])
     s.stype > 0 && i0 > i1 && return conj(A[i1,i0])
@@ -1179,11 +1203,12 @@ Ac_mul_B(A::Sparse, B::VecOrMat) =  Ac_mul_B(A, Dense(B))
 
 ## Factorization methods
 
+## Compute that symbolic factorization only
 function fact_{Tv<:VTypes}(A::Sparse{Tv}, cm::Array{UInt8};
-    shift::Real=0.0, perm::AbstractVector{SuiteSparse_long}=SuiteSparse_long[],
+    perm::AbstractVector{SuiteSparse_long}=SuiteSparse_long[],
     postorder::Bool=true, userperm_only::Bool=true)
 
-    sA = unsafe_load(A.p)
+    sA = unsafe_load(get(A.p))
     sA.stype == 0 && throw(ArgumentError("sparse matrix is not symmetric/Hermitian"))
 
     if !postorder
@@ -1199,59 +1224,195 @@ function fact_{Tv<:VTypes}(A::Sparse{Tv}, cm::Array{UInt8};
         F = analyze_p(A, SuiteSparse_long[p-1 for p in perm], cm)
     end
 
-    factorize_p!(A, shift, F, cm)
     return F
 end
 
-function cholfact(A::Sparse; kws...)
-    cm = defaults(common()) # setting the common struct to default values. Should only be done when creating new factorization.
-    set_print_level(cm, 0) # no printing from CHOLMOD by default
+function cholfact!{Tv}(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0)
+    cm = common()
 
     # Makes it an LLt
     unsafe_store!(common_final_ll, 1)
 
-    F = fact_(A, cm; kws...)
-    s = unsafe_load(F.p)
+    # Compute the numerical factorization
+    factorize_p!(A, shift, F, cm)
+
+    s = unsafe_load(get(F.p))
     s.minor < size(A, 1) && throw(Base.LinAlg.PosDefException(s.minor))
     return F
 end
 
-function ldltfact(A::Sparse; kws...)
-    cm = defaults(common()) # setting the common struct to default values. Should only be done when creating new factorization.
-    set_print_level(cm, 0) # no printing from CHOLMOD by default
+"""
+    cholfact!(F::Factor, A::Union{SparseMatrixCSC{<:Real},
+        SparseMatrixCSC{Complex{<:Real}},
+        Symmetric{<:Real,SparseMatrixCSC{<:Real,SuiteSparse_long}},
+        Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},SuiteSparse_long}}};
+        shift = 0.0) -> CHOLMOD.Factor
+
+Compute the Cholesky (``LL'``) factorization of `A`, reusing the symbolic factorization `F`.
+
+** Note **
+
+This method uses the CHOLMOD library from SuiteSparse, which only supports
+doubles or complex doubles. Input matrices not of those element types will be
+converted to `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}` as
+appropriate.
+"""
+cholfact!{T<:Real}(F::Factor, A::Union{SparseMatrixCSC{T},
+        SparseMatrixCSC{Complex{T}},
+        Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
+        Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}}};
+    shift = 0.0) =
+    cholfact!(F, Sparse(A); shift = shift)
+
+function cholfact(A::Sparse; shift::Real=0.0,
+    perm::AbstractVector{SuiteSparse_long}=SuiteSparse_long[])
+
+    cm = defaults(common())
+    set_print_level(cm, 0)
+
+    # Compute the symbolic factorization
+    F = fact_(A, cm; perm = perm)
+
+    # Compute the numerical factorization
+    cholfact!(F, A; shift = shift)
+
+    s = unsafe_load(get(F.p))
+    s.minor < size(A, 1) && throw(Base.LinAlg.PosDefException(s.minor))
+    return F
+end
+
+"""
+    cholfact(::Union{SparseMatrixCSC{<:Real},SparseMatrixCSC{Complex{<:Real}},
+        Symmetric{<:Real,SparseMatrixCSC{<:Real,
+        SuiteSparse_long}},Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},
+        SuiteSparse_long}}}; shift = 0.0, perm=Int[]) -> CHOLMOD.Factor
+
+Compute the Cholesky factorization of a sparse positive definite matrix `A`.
+A fill-reducing permutation is used.
+`F = cholfact(A)` is most frequently used to solve systems of equations with `F\b`,
+but also the methods `diag`, `det`, `logdet` are defined for `F`.
+You can also extract individual factors from `F`, using `F[:L]`.
+However, since pivoting is on by default,
+the factorization is internally represented as `A == P'*L*L'*P` with a permutation matrix `P`;
+using just `L` without accounting for `P` will give incorrect answers.
+To include the effects of permutation,
+it's typically preferable to extact "combined" factors like `PtL = F[:PtL]` (the equivalent of `P'*L`)
+and `LtP = F[:UP]` (the equivalent of `L'*P`).
+
+Setting optional `shift` keyword argument computes the factorization of `A+shift*I` instead of `A`.
+If the `perm` argument is nonempty,
+it should be a permutation of `1:size(A,1)` giving the ordering to use (instead of CHOLMOD's default AMD ordering).
+
+** Note **
+
+This method uses the CHOLMOD library from SuiteSparse, which only supports
+doubles or complex doubles. Input matrices not of those element types will be
+converted to `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}` as
+appropriate.
+
+Many other functions from CHOLMOD are wrapped but not exported from the
+`Base.SparseArrays.CHOLMOD` module.
+"""
+cholfact{T<:Real}(A::Union{SparseMatrixCSC{T}, SparseMatrixCSC{Complex{T}},
+    Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
+    Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}}};
+    kws...) = cholfact(Sparse(A); kws...)
+
+
+function ldltfact!{Tv}(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0)
+    cm = common()
 
     # Makes it an LDLt
     unsafe_store!(common_final_ll, 0)
 
+    # Compute the numerical factorization
+    factorize_p!(A, shift, F, cm)
+
     # Really make sure it's an LDLt by avoiding supernodal factorisation
     unsafe_store!(common_supernodal, 0)
 
-    F = fact_(A, cm; kws...)
-    s = unsafe_load(F.p)
+    s = unsafe_load(get(F.p))
     s.minor < size(A, 1) && throw(Base.LinAlg.ArgumentError("matrix has one or more zero pivots"))
     return F
 end
 
+"""
+    ldltfact!(F::Factor, A::Union{SparseMatrixCSC{<:Real},
+        SparseMatrixCSC{Complex{<:Real}},
+        Symmetric{<:Real,SparseMatrixCSC{<:Real,SuiteSparse_long}},
+        Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},SuiteSparse_long}}};
+        shift = 0.0) -> CHOLMOD.Factor
 
-for f in (:cholfact, :ldltfact)
-    @eval begin
-        $f(A::SparseMatrixCSC; kws...) = $f(Sparse(A); kws...)
-        $f(A::Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}; kws...) = $f(Sparse(A); kws...)
-        $f(A::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},SuiteSparse_long}}; kws...) = $f(Sparse(A); kws...)
-    end
-end
+Compute the ``LDL'`` factorization of `A`, reusing the symbolic factorization `F`.
 
-function update!{Tv<:VTypes}(F::Factor{Tv}, A::Sparse{Tv}; shift::Real=0.0)
-    cm = defaults(common()) # setting the common struct to default values. Should only be done when creating new factorization.
-    set_print_level(cm, 0) # no printing from CHOLMOD by default
+** Note **
 
-    s = unsafe_load(F.p)
-    if s.is_ll!=0
-        unsafe_store!(common_final_ll, 1) # Makes it an LLt
-    end
-    factorize_p!(A, shift, F, cm)
+This method uses the CHOLMOD library from SuiteSparse, which only supports
+doubles or complex doubles. Input matrices not of those element types will be
+converted to `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}` as
+appropriate.
+"""
+ldltfact!{T<:Real}(F::Factor, A::Union{SparseMatrixCSC{T},
+    SparseMatrixCSC{Complex{T}},
+    Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
+    Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}}};
+    shift = 0.0) =
+    ldltfact!(F, Sparse(A), shift = shift)
+
+function ldltfact(A::Sparse; shift::Real=0.0,
+    perm::AbstractVector{SuiteSparse_long}=SuiteSparse_long[])
+
+    cm = defaults(common())
+    set_print_level(cm, 0)
+
+    # Compute the symbolic factorization
+    F = fact_(A, cm; perm = perm)
+
+    # Compute the numerical factorization
+    ldltfact!(F, A; shift = shift)
+
+    s = unsafe_load(get(F.p))
+    s.minor < size(A, 1) && throw(Base.LinAlg.ArgumentError("matrix has one or more zero pivots"))
+    return F
 end
-update!{T<:VTypes}(F::Factor{T}, A::SparseMatrixCSC{T}; kws...) = update!(F, Sparse(A); kws...)
+
+"""
+    ldltfact(::Union{SparseMatrixCSC{<:Real},SparseMatrixCSC{Complex{<:Real}},
+        Symmetric{<:Real,SparseMatrixCSC{<:Real,SuiteSparse_long}},
+        Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},SuiteSparse_long}}};
+        shift = 0.0, perm=Int[]) -> CHOLMOD.Factor
+
+Compute the ``LDL'`` factorization of a sparse symmetric or Hermitian matrix.
+A fill-reducing permutation is used.
+`F = ldltfact(A)` is most frequently used to solve systems of equations `A*x = b` with `F\b`.
+The returned factorization object `F` also supports the methods `diag`,
+`det`, and `logdet`. You can extract individual factors from `F` using `F[:L]`.
+However, since pivoting is on by default,
+the factorization is internally represented as `A == P'*L*D*L'*P` with a permutation matrix `P`;
+using just `L` without accounting for `P` will give incorrect answers.
+To include the effects of permutation,
+it's typically preferable to extact "combined" factors like `PtL = F[:PtL]` (the equivalent of
+`P'*L`) and `LtP = F[:UP]` (the equivalent of `L'*P`).
+The complete list of supported factors is `:L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP`.
+
+Setting optional `shift` keyword argument computes the factorization of `A+shift*I` instead of `A`.
+If the `perm` argument is nonempty,
+it should be a permutation of `1:size(A,1)` giving the ordering to use (instead of CHOLMOD's default AMD ordering).
+
+** Note **
+
+This method uses the CHOLMOD library from SuiteSparse, which only supports
+doubles or complex doubles. Input matrices not of those element types will be
+converted to `SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}` as
+appropriate.
+
+Many other functions from CHOLMOD are wrapped but not exported from the
+`Base.SparseArrays.CHOLMOD` module.
+"""
+ldltfact{T<:Real}(A::Union{SparseMatrixCSC{T},SparseMatrixCSC{Complex{T}},
+    Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
+    Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}}};
+    kws...) = ldltfact(Sparse(A); kws...)
 
 ## Solvers
 
@@ -1294,33 +1455,38 @@ for (T, f) in ((:Dense, :solve), (:Sparse, :spsolve))
     end
 end
 
+typealias SparseVecOrMat{Tv,Ti} Union{SparseVector{Tv,Ti}, SparseMatrixCSC{Tv,Ti}}
+
 function (\)(L::FactorComponent, b::Vector)
     reshape(convert(Matrix, L\Dense(b)), length(b))
 end
 function (\)(L::FactorComponent, B::Matrix)
     convert(Matrix, L\Dense(B))
 end
-function (\)(L::FactorComponent, B::SparseMatrixCSC)
+function (\)(L::FactorComponent, B::SparseVecOrMat)
     sparse(L\Sparse(B,0))
 end
 
 Ac_ldiv_B(L::FactorComponent, B) = ctranspose(L)\B
 
-(\)(L::Factor, B::Dense) = solve(CHOLMOD_A, L, B)
-(\)(L::Factor, b::Vector) = reshape(convert(Matrix, solve(CHOLMOD_A, L, Dense(b))), length(b))
-(\)(L::Factor, B::Matrix) = convert(Matrix, solve(CHOLMOD_A, L, Dense(B)))
+(\){T}(L::Factor{T}, B::Dense{T}) = solve(CHOLMOD_A, L, B)
+(\)(L::Factor{Float64}, B::VecOrMat{Complex{Float64}}) = L\real(B) + L\imag(B)
+(\)(L::Factor, b::Vector) = Vector(L\convert(Dense{eltype(L)}, b))
+(\)(L::Factor, B::Matrix) = Matrix(L\convert(Dense{eltype(L)}, B))
 (\)(L::Factor, B::Sparse) = spsolve(CHOLMOD_A, L, B)
 # When right hand side is sparse, we have to ensure that the rhs is not marked as symmetric.
-(\)(L::Factor, B::SparseMatrixCSC) = sparse(spsolve(CHOLMOD_A, L, Sparse(B, 0)))
+(\)(L::Factor, B::SparseVecOrMat) = sparse(spsolve(CHOLMOD_A, L, Sparse(B, 0)))
 
 Ac_ldiv_B(L::Factor, B::Dense) = solve(CHOLMOD_A, L, B)
 Ac_ldiv_B(L::Factor, B::VecOrMat) = convert(Matrix, solve(CHOLMOD_A, L, Dense(B)))
 Ac_ldiv_B(L::Factor, B::Sparse) = spsolve(CHOLMOD_A, L, B)
-Ac_ldiv_B(L::Factor, B::SparseMatrixCSC) = Ac_ldiv_B(L, Sparse(B))
+Ac_ldiv_B(L::Factor, B::SparseVecOrMat) = Ac_ldiv_B(L, Sparse(B))
 
 ## Other convenience methods
 function diag{Tv}(F::Factor{Tv})
-    f = unsafe_load(F.p)
+    f = unsafe_load(get(F.p))
+    fsuper = f.super
+    fpi = f.pi
     res = Base.zeros(Tv, Int(f.n))
     xv  = f.x
     if f.is_super!=0
@@ -1330,8 +1496,8 @@ function diag{Tv}(F::Factor{Tv})
             base = unsafe_load(px, i) + 1
             res[pos] = unsafe_load(xv, base)
             pos += 1
-            for j in 1:unsafe_load(f.super, i + 1) - unsafe_load(f.super, i) - 1
-                res[pos] = unsafe_load(xv, base + j*(unsafe_load(f.pi, i + 1) - unsafe_load(f.pi, i) + 1))
+            for j in 1:unsafe_load(fsuper, i + 1) - unsafe_load(fsuper, i) - 1
+                res[pos] = unsafe_load(xv, base + j*(unsafe_load(fpi, i + 1) - unsafe_load(fpi, i) + 1))
                 pos += 1
             end
         end
@@ -1349,7 +1515,7 @@ function diag{Tv}(F::Factor{Tv})
 end
 
 function logdet{Tv<:VTypes}(F::Factor{Tv})
-    f = unsafe_load(F.p)
+    f = unsafe_load(get(F.p))
     res = zero(Tv)
     for d in diag(F) res += log(abs(d)) end
     f.is_ll!=0 ? 2res : res
@@ -1370,7 +1536,7 @@ function isposdef{Tv<:VTypes}(A::SparseMatrixCSC{Tv,SuiteSparse_long})
     true
 end
 
-function issym(A::Sparse)
+function issymmetric(A::Sparse)
     s = unsafe_load(A.p)
     if s.stype != 0
         return isreal(A)
@@ -1398,7 +1564,7 @@ function ishermitian(A::Sparse{Complex{Float64}})
     end
 end
 
-(*){Ti}(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}, B::SparseMatrixCSC{Float64,Ti}) = sparse(Sparse(A)*Sparse(B))
-(*){Ti}(A::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}, B::SparseMatrixCSC{Complex{Float64},Ti}) = sparse(Sparse(A)*Sparse(B))
+(*){Ti}(A::Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}, B::SparseVecOrMat{Float64,Ti}) = sparse(Sparse(A)*Sparse(B))
+(*){Ti}(A::Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},Ti}}, B::SparseVecOrMat{Complex{Float64},Ti}) = sparse(Sparse(A)*Sparse(B))
 
 end #module
diff --git a/base/sparse/csparse.jl b/base/sparse/csparse.jl
index 4b8afc0f48aaa..53a153c8aa77b 100644
--- a/base/sparse/csparse.jl
+++ b/base/sparse/csparse.jl
@@ -12,189 +12,19 @@
 # Based on Direct Methods for Sparse Linear Systems, T. A. Davis, SIAM, Philadelphia, Sept. 2006.
 # Section 2.4: Triplet form
 # http://www.cise.ufl.edu/research/sparse/CSparse/
-function sparse{Tv,Ti<:Integer}(I::AbstractVector{Ti},
-                                J::AbstractVector{Ti},
-                                V::AbstractVector{Tv},
-                                nrow::Integer, ncol::Integer,
-                                combine::Union{Function,Base.Func})
 
-    N = length(I)
-    if N != length(J) || N != length(V)
-        throw(ArgumentError("triplet I,J,V vectors must be the same length"))
-    end
-    if N == 0
-        return spzeros(eltype(V), Ti, nrow, ncol)
-    end
-
-    # Work array
-    Wj = Array(Ti, max(nrow,ncol)+1)
-
-    # Allocate sparse matrix data structure
-    # Count entries in each row
-    Rnz = zeros(Ti, nrow+1)
-    Rnz[1] = 1
-    nz = 0
-    for k=1:N
-        iind = I[k]
-        iind > 0 || throw(ArgumentError("all I index values must be > 0"))
-        iind <= nrow || throw(ArgumentError("all I index values must be ≤ the number of rows"))
-        if V[k] != 0
-            Rnz[iind+1] += 1
-            nz += 1
-        end
-    end
-    Rp = cumsum(Rnz)
-    Ri = Array(Ti, nz)
-    Rx = Array(Tv, nz)
-
-    # Construct row form
-    # place triplet (i,j,x) in column i of R
-    # Use work array for temporary row pointers
-    @simd for i=1:nrow; @inbounds Wj[i] = Rp[i]; end
-
-    @inbounds for k=1:N
-        iind = I[k]
-        jind = J[k]
-        jind > 0 || throw(ArgumentError("all J index values must be > 0"))
-        jind <= ncol || throw(ArgumentError("all J index values must be ≤ the number of columns"))
-        p = Wj[iind]
-        Vk = V[k]
-        if Vk != 0
-            Wj[iind] += 1
-            Rx[p] = Vk
-            Ri[p] = jind
-        end
-    end
-
-    # Reset work array for use in counting duplicates
-    @simd for j=1:ncol; @inbounds Wj[j] = 0; end
-
-    # Sum up duplicates and squeeze
-    anz = 0
-    @inbounds for i=1:nrow
-        p1 = Rp[i]
-        p2 = Rp[i+1] - 1
-        pdest = p1
-
-        for p = p1:p2
-            j = Ri[p]
-            pj = Wj[j]
-            if pj >= p1
-                Rx[pj] = combine(Rx[pj], Rx[p])
-            else
-                Wj[j] = pdest
-                if pdest != p
-                    Ri[pdest] = j
-                    Rx[pdest] = Rx[p]
-                end
-                pdest += one(Ti)
-            end
-        end
-
-        Rnz[i] = pdest - p1
-        anz += (pdest - p1)
-    end
-
-    # Transpose from row format to get the CSC format
-    RiT = Array(Ti, anz)
-    RxT = Array(Tv, anz)
-
-    # Reset work array to build the final colptr
-    Wj[1] = 1
-    @simd for i=2:(ncol+1); @inbounds Wj[i] = 0; end
-    @inbounds for j = 1:nrow
-        p1 = Rp[j]
-        p2 = p1 + Rnz[j] - 1
-        for p = p1:p2
-            Wj[Ri[p]+1] += 1
-        end
-    end
-    RpT = cumsum(Wj[1:(ncol+1)])
-
-    # Transpose
-    @simd for i=1:length(RpT); @inbounds Wj[i] = RpT[i]; end
-    @inbounds for j = 1:nrow
-        p1 = Rp[j]
-        p2 = p1 + Rnz[j] - 1
-        for p = p1:p2
-            ind = Ri[p]
-            q = Wj[ind]
-            Wj[ind] += 1
-            RiT[q] = j
-            RxT[q] = Rx[p]
-        end
-    end
-
-    return SparseMatrixCSC(nrow, ncol, RpT, RiT, RxT)
-end
-
-## Transpose and apply f
-
-# Based on Direct Methods for Sparse Linear Systems, T. A. Davis, SIAM, Philadelphia, Sept. 2006.
-# Section 2.5: Transpose
-# http://www.cise.ufl.edu/research/sparse/CSparse/
-function ftranspose!{Tv,Ti}(T::SparseMatrixCSC{Tv,Ti}, S::SparseMatrixCSC{Tv,Ti}, f)
-    (mS, nS) = size(S)
-    nnzS = nnz(S)
-    colptr_S = S.colptr
-    rowval_S = S.rowval
-    nzval_S = S.nzval
-
-    (mT, nT) = size(T)
-    colptr_T = T.colptr
-    rowval_T = T.rowval
-    nzval_T = T.nzval
-
-    fill!(colptr_T, 0)
-    colptr_T[1] = 1
-    for i=1:nnzS
-        @inbounds colptr_T[rowval_S[i]+1] += 1
-    end
-    cumsum!(colptr_T, colptr_T)
-
-    w = copy(colptr_T)
-    @inbounds for j = 1:nS, p = colptr_S[j]:(colptr_S[j+1]-1)
-        ind = rowval_S[p]
-        q = w[ind]
-        w[ind] += 1
-        rowval_T[q] = j
-        nzval_T[q] = f(nzval_S[p])
-    end
-
-    return T
-end
-
-function ftranspose{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, f)
-    (nT, mT) = size(S)
-    nnzS = nnz(S)
-    colptr_T = Array(Ti, nT+1)
-    rowval_T = Array(Ti, nnzS)
-    nzval_T = Array(Tv, nnzS)
-
-    T = SparseMatrixCSC(mT, nT, colptr_T, rowval_T, nzval_T)
-    return ftranspose!(T, S, f)
-end
-
-function transpose!{Tv,Ti}(T::SparseMatrixCSC{Tv,Ti}, S::SparseMatrixCSC{Tv,Ti})
-    ftranspose!(T, S, IdFun())
-end
-
-function transpose{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
-    ftranspose(S, IdFun())
-end
-
-function ctranspose!{Tv,Ti}(T::SparseMatrixCSC{Tv,Ti}, S::SparseMatrixCSC{Tv,Ti})
-    ftranspose!(T, S, ConjFun())
-end
-
-function ctranspose{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
-    ftranspose(S, ConjFun())
-end
 
 # Compute the elimination tree of A using triu(A) returning the parent vector.
 # A root node is indicated by 0. This tree may actually be a forest in that
 # there may be more than one root, indicating complete separability.
 # A trivial example is speye(n, n) in which every node is a root.
+
+"""
+    etree(A[, post])
+
+Compute the elimination tree of a symmetric sparse matrix `A` from `triu(A)`
+and, optionally, its post-ordering permutation.
+"""
 function etree{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, postorder::Bool)
     m,n = size(A)
     Ap = A.colptr
@@ -225,7 +55,7 @@ function etree{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, postorder::Bool)
     for j in 1:n
         if (parent[j] != 0) continue end # skip j if it is not a root
         push!(stack, j)                  # place j on the stack
-        while (length(stack) > 0)        # while (stack is not empty)
+        while (!isempty(stack))        # while (stack is not empty)
             p = stack[end]               # p = top of stack
             i = head[p]                  # i = youngest child of p
             if (i == 0)
@@ -296,8 +126,17 @@ function csc_permute{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, pinv::Vector{Ti}, q::Vect
     (C.').' # double transpose to order the columns
 end
 
+
 # based on cs_symperm p. 21, "Direct Methods for Sparse Linear Systems"
 # form A[p,p] for a symmetric A stored in the upper triangle
+"""
+    symperm(A, p)
+
+Return the symmetric permutation of `A`, which is `A[p,p]`. `A` should be
+symmetric, sparse, and only contain nonzeros in the upper triangular part of the
+matrix is stored. This algorithm ignores the lower triangular part of the
+matrix. Only the upper triangular part of the result is returned.
+"""
 function symperm{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, pinv::Vector{Ti})
     m, n = size(A)
     if m != n
@@ -336,64 +175,4 @@ function symperm{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, pinv::Vector{Ti})
         end
     end
     (C.').' # double transpose to order the columns
-end
-
-# Based on Direct Methods for Sparse Linear Systems, T. A. Davis, SIAM, Philadelphia, Sept. 2006.
-# Section 2.7: Removing entries from a matrix
-# http://www.cise.ufl.edu/research/sparse/CSparse/
-function fkeep!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, f, other)
-    nzorig = nnz(A)
-    nz = 1
-    colptr = A.colptr
-    rowval = A.rowval
-    nzval = A.nzval
-    @inbounds for j = 1:A.n
-        p = colptr[j]                 # record current position
-        colptr[j] = nz                # set new position
-        while p < colptr[j+1]
-            if f(rowval[p], j, nzval[p], other)
-                nzval[nz] = nzval[p]
-                rowval[nz] = rowval[p]
-                nz += 1
-            end
-            p += 1
-        end
-    end
-    colptr[A.n + 1] = nz
-    nz -= 1
-    if nz < nzorig
-        resize!(nzval, nz)
-        resize!(rowval, nz)
-    end
-    A
-end
-
-
-immutable DropTolFun <: Func{4} end
-call(::DropTolFun, i,j,x,other) = abs(x)>other
-immutable DropZerosFun <: Func{4} end
-call(::DropZerosFun, i,j,x,other) = x!=0
-immutable TriuFun <: Func{4} end
-call(::TriuFun, i,j,x,other) = j>=i + other
-immutable TrilFun <: Func{4} end
-call(::TrilFun, i,j,x,other) = i>=j - other
-
-droptol!(A::SparseMatrixCSC, tol) = fkeep!(A, DropTolFun(), tol)
-dropzeros!(A::SparseMatrixCSC) = fkeep!(A, DropZerosFun(), nothing)
-dropzeros(A::SparseMatrixCSC) = dropzeros!(copy(A))
-
-function triu!(A::SparseMatrixCSC, k::Integer=0)
-    m,n = size(A)
-    if (k > 0 && k > n) || (k < 0 && -k > m)
-        throw(BoundsError())
-    end
-    fkeep!(A, TriuFun(), k)
-end
-
-function tril!(A::SparseMatrixCSC, k::Integer=0)
-    m,n = size(A)
-    if (k > 0 && k > n) || (k < 0 && -k > m)
-        throw(BoundsError())
-    end
-    fkeep!(A, TrilFun(), k)
-end
+end
\ No newline at end of file
diff --git a/base/sparse/linalg.jl b/base/sparse/linalg.jl
index ffad8c5f4b51a..ba38612573135 100644
--- a/base/sparse/linalg.jl
+++ b/base/sparse/linalg.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-import Base.LinAlg: chksquare
+import Base.LinAlg: checksquare
 
 ## Functions to switch to 0-based indexing to call external sparse solvers
 
@@ -102,8 +102,11 @@ function (*){TX,TvA,TiA}(X::StridedMatrix{TX}, A::SparseMatrixCSC{TvA,TiA})
     Y
 end
 
+(*)(X::Diagonal, A::SparseMatrixCSC) = scale!(copy(A), X.diag, A)
+(*)(A::SparseMatrixCSC, X::Diagonal) = scale!(copy(A), A, X.diag)
+
 # Sparse matrix multiplication as described in [Gustavson, 1978]:
-# http://www.cse.iitb.ac.in/graphics/~anand/website/include/papers/matrix/fast_matrix_mul.pdf
+# http://dl.acm.org/citation.cfm?id=355796
 
 (*){Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti}) = spmatmul(A,B)
 
@@ -160,37 +163,17 @@ function spmatmul{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, B::SparseMatrixCSC{Tv,Ti};
 
     # The Gustavson algorithm does not guarantee the product to have sorted row indices.
     Cunsorted = SparseMatrixCSC(mA, nB, colptrC, rowvalC, nzvalC)
-    C = Base.SparseMatrix.sortSparseMatrixCSC!(Cunsorted, sortindices=sortindices)
+    C = SparseArrays.sortSparseMatrixCSC!(Cunsorted, sortindices=sortindices)
     return C
 end
 
 ## solvers
-function A_ldiv_B!(A::SparseMatrixCSC, b::AbstractVecOrMat)
-    if eltype(b)<:Complex; A = complex(A); end
-
-    if istril(A)
-        # TODO: Fix diagonal case. Diagonal(A.nzval) needs to handle
-        # the case where there are zeros on the diagonal and error out.
-        # It also does not work in the complex case. VBS.
-        #if istriu(A); return A_ldiv_B!(Diagonal(A.nzval), b); end
-        return fwdTriSolve!(A, b)
-    end
-    if istriu(A); return bwdTriSolve!(A, b); end
-    return A_ldiv_B!(lufact(A),b)
-end
-
 function fwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
 # forward substitution for CSC matrices
-    n = length(B)
-    if isa(B, Vector)
-        nrowB = n
-        ncolB = 1
-    else
-        nrowB, ncolB = size(B)
-    end
-    ncol = chksquare(A)
+    nrowB, ncolB  = size(B, 1), size(B, 2)
+    ncol = LinAlg.checksquare(A)
     if nrowB != ncol
-        throw(DimensionMismatch("A is $(ncol)X$(ncol) and B has length $(n)"))
+        throw(DimensionMismatch("A is $(ncol) columns and B has $(nrowB) rows"))
     end
 
     aa = A.nzval
@@ -199,33 +182,44 @@ function fwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
 
     joff = 0
     for k = 1:ncolB
-        for j = 1:(nrowB-1)
-            jb = joff + j
+        for j = 1:nrowB
             i1 = ia[j]
-            i2 = ia[j+1]-1
-            B[jb] /= aa[i1]
-            bj = B[jb]
-            for i = i1+1:i2
-                B[joff+ja[i]] -= bj*aa[i]
+            i2 = ia[j + 1] - 1
+
+            # loop through the structural zeros
+            ii = i1
+            jai = ja[ii]
+            while ii <= i2 && jai < j
+                ii += 1
+                jai = ja[ii]
+            end
+
+            # check for zero pivot and divide with pivot
+            if jai == j
+                bj = B[joff + jai]/aa[ii]
+                B[joff + jai] = bj
+                ii += 1
+            else
+                throw(LinAlg.SingularException(j))
+            end
+
+            # update remaining part
+            for i = ii:i2
+                B[joff + ja[i]] -= bj*aa[i]
             end
         end
         joff += nrowB
-        B[joff] /= aa[end]
     end
-    return B
+    B
 end
 
 function bwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
 # backward substitution for CSC matrices
-    n = length(B)
-    if isa(B, Vector)
-        nrowB = n
-        ncolB = 1
-    else
-        nrowB, ncolB = size(B)
+    nrowB, ncolB = size(B, 1), size(B, 2)
+    ncol = LinAlg.checksquare(A)
+    if nrowB != ncol
+        throw(DimensionMismatch("A is $(ncol) columns and B has $(nrowB) rows"))
     end
-    ncol = chksquare(A)
-    if nrowB != ncol throw(DimensionMismatch("A is $(ncol)X$(ncol) and B has length $(n)")) end
 
     aa = A.nzval
     ja = A.rowval
@@ -233,22 +227,43 @@ function bwdTriSolve!(A::SparseMatrixCSC, B::AbstractVecOrMat)
 
     joff = 0
     for k = 1:ncolB
-        for j = nrowB:-1:2
-            jb = joff + j
+        for j = nrowB:-1:1
             i1 = ia[j]
-            i2 = ia[j+1]-1
-            B[jb] /= aa[i2]
-            bj = B[jb]
-            for i = i2-1:-1:i1
-                B[joff+ja[i]] -= bj*aa[i]
+            i2 = ia[j + 1] - 1
+
+            # loop through the structural zeros
+            ii = i2
+            jai = ja[ii]
+            while ii >= i1 && jai > j
+                ii -= 1
+                jai = ja[ii]
+            end
+
+            # check for zero pivot and divide with pivot
+            if jai == j
+                bj = B[joff + jai]/aa[ii]
+                B[joff + jai] = bj
+                ii -= 1
+            else
+                throw(LinAlg.SingularException(j))
+            end
+
+            # update remaining part
+            for i = ii:-1:i1
+                B[joff + ja[i]] -= bj*aa[i]
             end
         end
-        B[joff+1] /= aa[1]
         joff += nrowB
     end
-   return B
+    B
 end
 
+A_ldiv_B!{T,Ti}(L::LowerTriangular{T,SparseMatrixCSC{T,Ti}}, B::StridedVecOrMat) = fwdTriSolve!(L.data, B)
+A_ldiv_B!{T,Ti}(U::UpperTriangular{T,SparseMatrixCSC{T,Ti}}, B::StridedVecOrMat) = bwdTriSolve!(U.data, B)
+
+(\){T,Ti}(L::LowerTriangular{T,SparseMatrixCSC{T,Ti}}, B::SparseMatrixCSC) = A_ldiv_B!(L, full(B))
+(\){T,Ti}(U::UpperTriangular{T,SparseMatrixCSC{T,Ti}}, B::SparseMatrixCSC) = A_ldiv_B!(U, full(B))
+
 ## triu, tril
 
 function triu{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti}, k::Integer=0)
@@ -501,14 +516,14 @@ function cond(A::SparseMatrixCSC, p::Real=2)
     elseif p == 2
         throw(ArgumentError("2-norm condition number is not implemented for sparse matrices, try cond(full(A), 2) instead"))
     else
-        throw(ArgumentError("second argment must be either 1 or Inf, got $p"))
+        throw(ArgumentError("second argument must be either 1 or Inf, got $p"))
     end
 end
 
 function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A))))
     maxiter = 5
     # Check the input
-    n = chksquare(A)
+    n = checksquare(A)
     F = factorize(A)
     if t <= 0
         throw(ArgumentError("number of blocks must be a positive integer"))
@@ -587,7 +602,7 @@ function normestinv{T}(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A)
         end
 
         if T <: Real
-            # Check wether cols of S are parallel to cols of S or S_old
+            # Check whether cols of S are parallel to cols of S or S_old
             for j = 1:t
                 while true
                     repeated = false
@@ -752,7 +767,7 @@ inv(A::SparseMatrixCSC) = error("The inverse of a sparse matrix can often be den
 
 ## scale methods
 
-# Copy colptr and rowval from one SparseMatrix to another
+# Copy colptr and rowval from one sparse matrix to another
 function copyinds!(C::SparseMatrixCSC, A::SparseMatrixCSC)
     if C.colptr !== A.colptr
         resize!(C.colptr, length(A.colptr))
@@ -800,20 +815,29 @@ function scale!(C::SparseMatrixCSC, A::SparseMatrixCSC, b::Number)
     C
 end
 
-scale!(C::SparseMatrixCSC, b::Number, A::SparseMatrixCSC) = scale!(C, A, b)
+function scale!(C::SparseMatrixCSC, b::Number, A::SparseMatrixCSC)
+    size(A)==size(C) || throw(DimensionMismatch())
+    copyinds!(C, A)
+    resize!(C.nzval, length(A.nzval))
+    scale!(C.nzval, b, A.nzval)
+    C
+end
 
 scale!(A::SparseMatrixCSC, b::Number) = (scale!(A.nzval, b); A)
 scale!(b::Number, A::SparseMatrixCSC) = (scale!(b, A.nzval); A)
 
-scale{Tv,Ti,T}(A::SparseMatrixCSC{Tv,Ti}, b::Vector{T}) =
-    scale!(similar(A, promote_type(Tv,T)), A, b)
-
-scale{T,Tv,Ti}(b::Vector{T}, A::SparseMatrixCSC{Tv,Ti}) =
-    scale!(similar(A, promote_type(Tv,T)), b, A)
-
 function factorize(A::SparseMatrixCSC)
     m, n = size(A)
     if m == n
+        if istril(A)
+            if istriu(A)
+                return Diagonal(A)
+            else
+                return LowerTriangular(A)
+            end
+        elseif istriu(A)
+            return UpperTriangular(A)
+        end
         AC = CHOLMOD.Sparse(A)
         if ishermitian(AC)
             try
diff --git a/base/sparse/sparsematrix.jl b/base/sparse/sparsematrix.jl
index 592e00d7aaea9..1286a584cc7df 100644
--- a/base/sparse/sparsematrix.jl
+++ b/base/sparse/sparsematrix.jl
@@ -25,23 +25,67 @@ function SparseMatrixCSC(m::Integer, n::Integer, colptr::Vector, rowval::Vector,
 end
 
 size(S::SparseMatrixCSC) = (S.m, S.n)
+
+"""
+    nnz(A)
+
+Returns the number of stored (filled) elements in a sparse array.
+"""
 nnz(S::SparseMatrixCSC) = Int(S.colptr[end]-1)
 countnz(S::SparseMatrixCSC) = countnz(S.nzval)
 
+"""
+    nonzeros(A)
+
+Return a vector of the structural nonzero values in sparse array `A`. This
+includes zeros that are explicitly stored in the sparse array. The returned
+vector points directly to the internal nonzero storage of `A`, and any
+modifications to the returned vector will mutate `A` as well. See `rowvals(A)`
+and `nzrange(A, col)`.
+"""
 nonzeros(S::SparseMatrixCSC) = S.nzval
+
+"""
+    rowvals(A::SparseMatrixCSC)
+
+Return a vector of the row indices of `A`. Any modifications to the returned
+vector will mutate `A` as well. Providing access to how the row indices are
+stored internally can be useful in conjunction with iterating over structural
+nonzero values. See also `nonzeros(A)` and `nzrange(A, col)`.
+"""
 rowvals(S::SparseMatrixCSC) = S.rowval
+
+"""
+    nzrange(A::SparseMatrixCSC, col)
+
+Return the range of indices to the structural nonzero values of a sparse matrix
+column. In conjunction with `nonzeros(A)` and `rowvals(A)`, this allows for
+convenient iterating over a sparse matrix :
+
+    A = sparse(I,J,V)
+    rows = rowvals(A)
+    vals = nonzeros(A)
+    m, n = size(A)
+    for i = 1:n
+       for j in nzrange(A, i)
+          row = rows[j]
+          val = vals[j]
+          # perform sparse wizardry...
+       end
+    end
+"""
 nzrange(S::SparseMatrixCSC, col::Integer) = S.colptr[col]:(S.colptr[col+1]-1)
 
 function Base.showarray(io::IO, S::SparseMatrixCSC;
-                   header::Bool=true, limit::Bool=Base._limit_output,
-                   rows = Base.tty_size()[1], repr=false)
+                   header::Bool=true, repr=false)
     # TODO: repr?
-
     if header
         print(io, S.m, "x", S.n, " sparse matrix with ", nnz(S), " ", eltype(S), " entries:")
     end
 
+    limit::Bool = Base.limit_output(io)
     if limit
+        rows = displaysize(io)[1]
         half_screen_rows = div(rows - 8, 2)
     else
         half_screen_rows = typemax(Int)
@@ -53,7 +97,7 @@ function Base.showarray(io::IO, S::SparseMatrixCSC;
         if k < half_screen_rows || k > nnz(S)-half_screen_rows
             print(io, sep, '[', rpad(S.rowval[k], pad), ", ", lpad(col, pad), "]  =  ")
             if isassigned(S.nzval, k)
-                showcompact(io, S.nzval[k])
+                Base.showcompact_lim(io, S.nzval[k])
             else
                 print(io, Base.undef_ref_str)
             end
@@ -149,6 +193,23 @@ end
 copy(S::SparseMatrixCSC) =
     SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), copy(S.nzval))
 
+function copy!{TvA, TiA, TvB, TiB}(A::SparseMatrixCSC{TvA,TiA},
+                                   B::SparseMatrixCSC{TvB,TiB})
+    # If the two matrices have the same size then all the
+    # elements in A will be overwritten and we can simply copy the
+    # internal fields of B to A.
+    if size(A) == size(B)
+        copy!(A.colptr, B.colptr)
+        resize!(A.nzval, length(B.nzval))
+        resize!(A.rowval, length(B.rowval))
+        copy!(A.rowval, B.rowval)
+        copy!(A.nzval, B.nzval)
+    else
+        invoke(Base.copy!, Tuple{AbstractMatrix{TvA}, AbstractMatrix{TvB}}, A, B)
+    end
+    return A
+end
+
 similar(S::SparseMatrixCSC, Tv::Type=eltype(S))   = SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), Array(Tv, length(S.nzval)))
 similar{Tv,Ti,TvNew,TiNew}(S::SparseMatrixCSC{Tv,Ti}, ::Type{TvNew}, ::Type{TiNew}) = SparseMatrixCSC(S.m, S.n, convert(Array{TiNew},S.colptr), convert(Array{TiNew}, S.rowval), Array(TvNew, length(S.nzval)))
 similar{Tv, N}(S::SparseMatrixCSC, ::Type{Tv}, d::NTuple{N, Integer}) = spzeros(Tv, d...)
@@ -186,6 +247,14 @@ end
 convert{T}(::Type{AbstractMatrix{T}}, A::SparseMatrixCSC) = convert(SparseMatrixCSC{T}, A)
 convert(::Type{Matrix}, S::SparseMatrixCSC) = full(S)
 
+
+"""
+    full(S)
+
+Convert a sparse matrix or vector `S` into a dense matrix or vector.
+"""
+full
+
 function full{Tv}(S::SparseMatrixCSC{Tv})
     # Handle cases where zero(Tv) is not defined but the array is dense.
     # (Should we really worry about this?)
@@ -204,59 +273,14 @@ complex(A::SparseMatrixCSC, B::SparseMatrixCSC) = A + im*B
 
 # Construct a sparse vector
 
-function vec{Tv,Ti}(S::SparseMatrixCSC{Tv,Ti})
-    colptr = Array(Ti,2)
-    rowval = similar(S.rowval)
-    lS = length(S)
-    sparse_compute_reshaped_colptr_and_rowval(colptr, rowval, lS, 1, S.colptr, S.rowval, S.m, S.n)
-    SparseMatrixCSC(lS, 1, colptr, rowval, copy(S.nzval))
-end
-
-sparsevec(A::AbstractMatrix) = reshape(sparse(A), (length(A),1))
-sparsevec(S::SparseMatrixCSC) = vec(S)
-
-sparsevec{K<:Integer,V}(d::Dict{K,V}, len::Int) = sparsevec(collect(keys(d)), collect(values(d)), len)
-
-sparsevec{K<:Integer,V}(d::Dict{K,V}) = sparsevec(collect(keys(d)), collect(values(d)))
-
-sparsevec(I::AbstractVector, V, m::Integer) = sparsevec(I, V, m, AddFun())
-
-sparsevec(I::AbstractVector, V) = sparsevec(I, V, maximum(I), AddFun())
-
-function sparsevec(I::AbstractVector, V, m::Integer, combine::Union{Function,Base.Func})
-    nI = length(I)
-    if isa(V, Number)
-        V = fill(V, nI)
-    end
-    if nI != length(V)
-        throw(ArgumentError("index and value vectors must be the same length"))
-    end
-    p = sortperm(I)
-    @inbounds I = I[p]
-    if nI > 0
-        if I[1] <= 0
-            throw(ArgumentError("I index values must be ≥ 0"))
-        end
-        if I[end] > m
-            throw(ArgumentError("all I index values must be ≤ length(sparsevec)"))
-        end
-    end
-    V = V[p]
-    sparse_IJ_sorted!(I, ones(eltype(I), nI), V, m, 1, combine)
-end
-
-function sparsevec(a::Vector)
-    n = length(a)
-    I = find(a)
-    J = ones(Int, n)
-    V = a[I]
-    return sparse_IJ_sorted!(I,J,V,n,1,AddFun())
-end
-
-sparse(a::Vector) = sparsevec(a)
+# Note that unlike `vec` for arrays, this does not share data
+vec(S::SparseMatrixCSC) = S[:]
 
-## Construct a sparse matrix
+"""
+    sparse(A)
 
+Convert an AbstractMatrix `A` into a sparse matrix.
+"""
 sparse{Tv}(A::AbstractMatrix{Tv}) = convert(SparseMatrixCSC{Tv,Int}, A)
 
 sparse(S::SparseMatrixCSC) = copy(S)
@@ -271,7 +295,7 @@ function sparse_IJ_sorted!{Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector
 
     m = m < 0 ? 0 : m
     n = n < 0 ? 0 : n
-    if length(V) == 0; return spzeros(eltype(V),Ti,m,n); end
+    if isempty(V); return spzeros(eltype(V),Ti,m,n); end
 
     cols = zeros(Ti, n+1)
     cols[1] = 1  # For cumsum purposes
@@ -311,15 +335,233 @@ function sparse_IJ_sorted!{Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector
     return SparseMatrixCSC(m, n, colptr, I, V)
 end
 
-## sparse() can take its inputs in unsorted order (the parent method is now in csparse.jl)
+"""
+    sparse(I, J, V,[ m, n, combine])
+
+Create a sparse matrix `S` of dimensions `m x n` such that `S[I[k], J[k]] = V[k]`. The
+`combine` function is used to combine duplicates. If `m` and `n` are not specified, they
+are set to `maximum(I)` and `maximum(J)` respectively. If the `combine` function is not
+supplied, `combine` defaults to `+` unless the elements of `V` are Booleans in which case
+`combine` defaults to `|`. All elements of `I` must satisfy `1 <= I[k] <= m`, and all
+elements of `J` must satisfy `1 <= J[k] <= n`. Numerical zeros in (`I`, `J`, `V`) are
+retained as structural nonzeros; to drop numerical zeros, use `dropzeros!`.
+
+For additional documentation and an expert driver, see `Base.SparseArrays.sparse!`.
+"""
+function sparse{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti}, V::AbstractVector{Tv}, m::Integer, n::Integer, combine)
+    coolen = length(I)
+    if length(J) != coolen || length(V) != coolen
+        throw(ArgumentError(string("the first three arguments' lengths must match, ",
+              "length(I) (=$(length(I))) == length(J) (= $(length(J))) == length(V) (= ",
+              "$(length(V)))")))
+    end
+
+    if m == 0 || n == 0 || coolen == 0
+        if coolen != 0
+            if n == 0
+                throw(ArgumentError("column indices J[k] must satisfy 1 <= J[k] <= n"))
+            elseif m == 0
+                throw(ArgumentError("row indices I[k] must satisfy 1 <= I[k] <= m"))
+            end
+        end
+        SparseMatrixCSC(m, n, ones(Ti, n+1), Vector{Ti}(), Vector{Tv}())
+    else
+        # Allocate storage for CSR form
+        csrrowptr = Vector{Ti}(m+1)
+        csrcolval = Vector{Ti}(coolen)
+        csrnzval = Vector{Tv}(coolen)
+
+        # Allocate storage for the CSC form's column pointers and a necessary workspace
+        csccolptr = Vector{Ti}(n+1)
+        klasttouch = Vector{Ti}(n)
+
+        # Allocate empty arrays for the CSC form's row and nonzero value arrays
+        # The parent method called below automagically resizes these arrays
+        cscrowval = Vector{Ti}()
+        cscnzval = Vector{Tv}()
+
+        sparse!(I, J, V, m, n, combine, klasttouch,
+                csrrowptr, csrcolval, csrnzval,
+                csccolptr, cscrowval, cscnzval )
+    end
+end
+
+"""
+    sparse!{Tv,Ti<:Integer}(
+        I::AbstractVector{Ti}, J::AbstractVector{Ti}, V::AbstractVector{Tv},
+        m::Integer, n::Integer, combine, klasttouch::Vector{Ti},
+        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv},
+        [csccolptr::Vector{Ti}], [cscrowval::Vector{Ti}, cscnzval::Vector{Tv}] )
+
+Parent of and expert driver for `sparse`; see `sparse` for basic usage. This method
+allows the user to provide preallocated storage for `sparse`'s intermediate objects and
+result as described below. This capability enables more efficient successive construction
+of `SparseMatrixCSC`s from coordinate representations, and also enables extraction of an
+unsorted-column representation of the result's transpose at no additional cost.
+
+This method consists of three major steps: (1) Counting-sort the provided coordinate
+representation into an unsorted-row CSR form including repeated entries. (2) Sweep through
+the CSR form, simultaneously calculating the desired CSC form's column-pointer array,
+detecting repeated entries, and repacking the CSR form with repeated entries combined;
+this stage yields an unsorted-row CSR form with no repeated entries. (3) Counting-sort the
+preceding CSR form into a fully-sorted CSC form with no repeated entries.
+
+Input arrays `csrrowptr`, `csrcolval`, and `csrnzval` constitute storage for the
+intermediate CSR forms and require `length(csrrowptr) >= m + 1`,
+`length(csrcolval) >= length(I)`, and `length(csrnzval >= length(I))`. Input
+array `klasttouch`, workspace for the second stage, requires `length(klasttouch) >= n`.
+Optional input arrays `csccolptr`, `cscrowval`, and `cscnzval` constitute storage for the
+returned CSC form `S`. `csccolptr` requires `length(csccolptr) >= n + 1`. If necessary,
+`cscrowval` and `cscnzval` are automatically resized to satisfy
+`length(cscrowval) >= nnz(S)` and `length(cscnzval) >= nnz(S)`; hence, if `nnz(S)` is
+unknown at the outset, passing in empty vectors of the appropriate type (`Vector{Ti}()`
+and `Vector{Tv}()` respectively) suffices, or calling the `sparse!` method
+neglecting `cscrowval` and `cscnzval`.
+
+On return, `csrrowptr`, `csrcolval`, and `csrnzval` contain an unsorted-column
+representation of the result's transpose.
+
+You may reuse the input arrays' storage (`I`, `J`, `V`) for the output arrays
+(`csccolptr`, `cscrowval`, `cscnzval`). For example, you may call
+`sparse!(I, J, V, csrrowptr, csrcolval, csrnzval, I, J, V)`.
+
+For the sake of efficiency, this method performs no argument checking beyond
+`1 <= I[k] <= m` and `1 <= J[k] <= n`. Use with care. Testing with `--check-bounds=yes`
+is wise.
+
+This method runs in `O(m, n, length(I))` time. The HALFPERM algorithm described in
+F. Gustavson, "Two fast algorithms for sparse matrices: multiplication and permuted
+transposition," ACM TOMS 4(3), 250-269 (1978) inspired this method's use of a pair of
+counting sorts.
+
+Performance note: As of January 2016, `combine` should be a functor for this method to
+perform well. This caveat may disappear when the work in `jb/functions` lands.
+"""
+function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+        V::AbstractVector{Tv}, m::Integer, n::Integer, combine, klasttouch::Vector{Ti},
+        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv},
+        csccolptr::Vector{Ti}, cscrowval::Vector{Ti}, cscnzval::Vector{Tv} )
+
+    # Compute the CSR form's row counts and store them shifted forward by one in csrrowptr
+    fill!(csrrowptr, 0)
+    coolen = length(I)
+    @inbounds for k in 1:coolen
+        Ik = I[k]
+        if 1 > Ik || m < Ik
+            throw(ArgumentError("row indices I[k] must satisfy 1 <= I[k] <= m"))
+        end
+        csrrowptr[Ik+1] += 1
+    end
+
+    # Compute the CSR form's rowptrs and store them shifted forward by one in csrrowptr
+    countsum = 1
+    csrrowptr[1] = 1
+    @inbounds for i in 2:(m+1)
+        overwritten = csrrowptr[i]
+        csrrowptr[i] = countsum
+        countsum += overwritten
+    end
+
+    # Counting-sort the column and nonzero values from J and V into csrcolval and csrnzval
+    # Tracking write positions in csrrowptr corrects the row pointers
+    @inbounds for k in 1:coolen
+        Ik, Jk = I[k], J[k]
+        if 1 > Jk || n < Jk
+            throw(ArgumentError("column indices J[k] must satisfy 1 <= J[k] <= n"))
+        end
+        csrk = csrrowptr[Ik+1]
+        csrrowptr[Ik+1] = csrk+1
+        csrcolval[csrk] = Jk
+        csrnzval[csrk] = V[k]
+    end
+    # This completes the unsorted-row, has-repeats CSR form's construction
+
+    # Sweep through the CSR form, simultaneously (1) caculating the CSC form's column
+    # counts and storing them shifted forward by one in csccolptr; (2) detecting repeated
+    # entries; and (3) repacking the CSR form with the repeated entries combined.
+    #
+    # Minimizing extraneous communication and nonlocality of reference, primarily by using
+    # only a single auxiliary array in this step, is the key to this method's performance.
+    fill!(csccolptr, 0)
+    fill!(klasttouch, 0)
+    writek = 1
+    newcsrrowptri = 1
+    origcsrrowptri = 1
+    origcsrrowptrip1 = csrrowptr[2]
+    @inbounds for i in 1:m
+        for readk in origcsrrowptri:(origcsrrowptrip1-1)
+            j = csrcolval[readk]
+            if klasttouch[j] < newcsrrowptri
+                klasttouch[j] = writek
+                if writek != readk
+                    csrcolval[writek] = j
+                    csrnzval[writek] = csrnzval[readk]
+                end
+                writek += 1
+                csccolptr[j+1] += 1
+            else
+                klt = klasttouch[j]
+                csrnzval[klt] = combine(csrnzval[klt], csrnzval[readk])
+            end
+        end
+        newcsrrowptri = writek
+        origcsrrowptri = origcsrrowptrip1
+        origcsrrowptrip1 != writek && (csrrowptr[i+1] = writek)
+        i < m && (origcsrrowptrip1 = csrrowptr[i+2])
+    end
+
+    # Compute the CSC form's colptrs and store them shifted forward by one in csccolptr
+    countsum = 1
+    csccolptr[1] = 1
+    @inbounds for j in 2:(n+1)
+        overwritten = csccolptr[j]
+        csccolptr[j] = countsum
+        countsum += overwritten
+    end
+
+    # Now knowing the CSC form's entry count, resize cscrowval and cscnzval if necessary
+    cscnnz = countsum - 1
+    length(cscrowval) < cscnnz && resize!(cscrowval, cscnnz)
+    length(cscnzval) < cscnnz && resize!(cscnzval, cscnnz)
+
+    # Finally counting-sort the row and nonzero values from the CSR form into cscrowval and
+    # cscnzval. Tracking write positions in csccolptr corrects the column pointers.
+    @inbounds for i in 1:m
+        for csrk in csrrowptr[i]:(csrrowptr[i+1]-1)
+            j = csrcolval[csrk]
+            x = csrnzval[csrk]
+            csck = csccolptr[j+1]
+            csccolptr[j+1] = csck+1
+            cscrowval[csck] = i
+            cscnzval[csck] = x
+        end
+    end
+
+    SparseMatrixCSC(m, n, csccolptr, cscrowval, cscnzval)
+end
+function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+        V::AbstractVector{Tv}, m::Integer, n::Integer, combine, klasttouch::Vector{Ti},
+        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv},
+        csccolptr::Vector{Ti} )
+    sparse!(I, J, V, m, n, combine, klasttouch,
+            csrrowptr, csrcolval, csrnzval,
+            csccolptr, Vector{Ti}(), Vector{Tv}() )
+end
+function sparse!{Tv,Ti<:Integer}(I::AbstractVector{Ti}, J::AbstractVector{Ti},
+        V::AbstractVector{Tv}, m::Integer, n::Integer, combine, klasttouch::Vector{Ti},
+        csrrowptr::Vector{Ti}, csrcolval::Vector{Ti}, csrnzval::Vector{Tv} )
+    sparse!(I, J, V, m, n, combine, klasttouch,
+            csrrowptr, csrcolval, csrnzval,
+            Vector{Ti}(n+1), Vector{Ti}(), Vector{Tv}() )
+end
 
-dimlub(I) = length(I)==0 ? 0 : Int(maximum(I)) #least upper bound on required sparse matrix dimension
+dimlub(I) = isempty(I) ? 0 : Int(maximum(I)) #least upper bound on required sparse matrix dimension
 
-sparse(I,J,v::Number) = sparse(I, J, fill(v,length(I)), dimlub(I), dimlub(J), AddFun())
+sparse(I,J,v::Number) = sparse(I, J, fill(v,length(I)))
 
-sparse(I,J,V::AbstractVector) = sparse(I, J, V, dimlub(I), dimlub(J), AddFun())
+sparse(I,J,V::AbstractVector) = sparse(I, J, V, dimlub(I), dimlub(J))
 
-sparse(I,J,v::Number,m,n) = sparse(I, J, fill(v,length(I)), Int(m), Int(n), AddFun())
+sparse(I,J,v::Number,m,n) = sparse(I, J, fill(v,length(I)), Int(m), Int(n))
 
 sparse(I,J,V::AbstractVector,m,n) = sparse(I, J, V, Int(m), Int(n), AddFun())
 
@@ -343,6 +585,207 @@ function sparse(B::Bidiagonal)
     return sparse([1:m;1:m-1],[1:m;2:m],[B.dv;B.ev], Int(m), Int(m)) # upper bidiagonal
 end
 
+## Transposition methods
+
+# qftranspose! is the parent method on which the others are built.
+"""
+    qftranspose!{Tv,Ti}(C::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector, f)
+
+Column-permute and transpose `A` (`(AQ)^T`), applying `f` to each element of `A` in the
+  process, and store the result in preallocated `C`. Permutation vector `q` defines the
+  column-permutation `Q`. The number of columns of `C` (`C.n`) must match the number of
+  rows of `A` (`A.m`). The number of rows of `C` (`C.m`) must match the number of columns
+  of `A` (`A.n`). The length of `C`'s internal row-index (`length(C.rowval)`) and
+  entry-value (`length(C.nzval)`) arrays must be at least the number of allocated entries
+  in `A` (`nnz(A)`). The length of the permutation vector `q` (`length(q)`) must match the
+  number of columns of `A` (`A.n`).
+
+This method implements the HALFPERM algorithm described in F. Gustavson, "Two fast
+  algorithms for sparse matrices: multiplication and permuted transposition," ACM TOMS
+  4(3), 250-269 (1978). The algorithm runs in `O(A.m, A.n, nnz(A))` time and requires no
+  space beyond that passed in.
+
+Performance note: As of January 2016, `f` should be a functor for this method to perform
+  well. This caveat may disappear when the work in `jb/functions` lands.
+"""
+function qftranspose!{Tv,Ti}(C::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector, f)
+    # Attach source matrix
+    Am, An = A.m, A.n
+    Acolptr = A.colptr
+    Arowval = A.rowval
+    Anzval = A.nzval
+    Annz = Acolptr[end]-1
+
+    # Attach destination matrix
+    Cm, Cn = C.m, C.n
+    Ccolptr = C.colptr
+    Crowval = C.rowval
+    Cnzval = C.nzval
+
+    # Check compatibility of source and destination
+    if !(Cm == An)
+        throw(DimensionMismatch("the number of rows of the first argument, C.m = $(Cm),"
+            * "must match the number of columns of the second argument, A.n = $(An)") )
+    elseif !(Cn == Am)
+        throw(DimensionMismatch("the number of columns of the first argument, C.n = $(Cn),"
+            * "must match the number of rows of the second argument, A.m = $(Am)") )
+    elseif !(length(q) == A.n)
+        throw(DimensionMismatch("the length of the permtuation vector, length(q) = "
+            * "$(length(q)), must match the number of columns of the second argument,"
+            * "A.n = $(An)") )
+    elseif !(length(Crowval) >= Annz)
+        throw(ArgumentError("the first argument's row-index array's length,"
+            * "length(C.rowval) = $(length(Crowval)), must be at least the number of"
+            * "allocated entries in the second argument, nnz(A) = $(Annz)") )
+    elseif !(length(Cnzval) >= Annz)
+        throw(ArgumentError("the first argument's entry-value array's length,"
+            * "length(C.nzval) = $(length(Cnzval)), must be at least the number of"
+            * "allocated entries in the second argument, nnz(A) = $(Annz)") )
+    end
+
+    # Compute the column counts of C and store them shifted forward by one in Ccolptr
+    Ccolptr[1:end] = 0
+    @inbounds for k in 1:Annz
+        Ccolptr[Arowval[k]+1] += 1
+    end
+
+    # From these column counts, compute C's column pointers
+    # and store them shifted forward by one in Ccolptr
+    countsum = 1
+    @inbounds for k in 2:(Cn+1)
+        overwritten = Ccolptr[k]
+        Ccolptr[k] = countsum
+        countsum += overwritten
+    end
+
+    # Distribution-sort the row indices and nonzero values into Crowval and Cnzval,
+    # tracking write positions in Ccolptr
+    @inbounds for Aj in 1:An
+        qAj = q[Aj]
+        for Ak in Acolptr[qAj]:(Acolptr[qAj+1]-1)
+            Ai = Arowval[Ak]
+            Ck = Ccolptr[Ai+1]
+            Crowval[Ck] = qAj
+            Cnzval[Ck] = f(Anzval[Ak])
+            Ccolptr[Ai+1] += 1
+        end
+    end
+
+    # Tracking write positions in Ccolptr as in the last block fixes the colptr shift,
+    # but the first colptr remains incorrect
+    Ccolptr[1] = 1
+
+    C
+end
+transpose!{Tv,Ti}(C::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) = qftranspose!(C, A, 1:A.n, Base.IdFun())
+ctranspose!{Tv,Ti}(C::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}) = qftranspose!(C, A, 1:A.n, Base.ConjFun())
+"See `qftranspose!`" ftranspose!{Tv,Ti}(C::SparseMatrixCSC{Tv,Ti}, A::SparseMatrixCSC{Tv,Ti}, f) = qftranspose!(C, A, 1:A.n, f)
+
+"""
+    qftranspose{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector, f)
+
+Return-allocating version of `qftranspose!`. See `qftranspose!` for documentation.
+"""
+function qftranspose{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, q::AbstractVector, f)
+    Cm, Cn, Cnnz = A.n, A.m, nnz(A)
+    Ccolptr = zeros(Ti, Cn+1)
+    Crowval = Array{Ti}(Cnnz)
+    Cnzval = Array{Tv}(Cnnz)
+    qftranspose!(SparseMatrixCSC(Cm, Cn, Ccolptr, Crowval, Cnzval), A, q, f)
+end
+transpose{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}) = qftranspose(A, 1:A.n, Base.IdFun())
+ctranspose{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}) = qftranspose(A, 1:A.n, Base.ConjFun())
+"See `qftranspose`" ftranspose{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, f) = qftranspose(A, 1:A.n, f)
+
+
+## fkeep! and children tril!, triu!, droptol!, dropzeros[!]
+
+"""
+    fkeep!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, f, other, trim::Bool = true)
+
+Keep elements of `A` for which test `f` returns `true`. `f`'s signature should be
+
+    f{Tv,Ti}(i::Ti, j::Ti, x::Tv, other::Any) -> Bool
+
+where `i` and `j` are an element's row and column indices, `x` is the element's value,
+and `other` is passed in from the call to `fkeep!`. This method makes a single sweep
+through `A`, requiring `O(A.n, nnz(A))`-time and no space beyond that passed in. If `trim`
+is `true`, this method trims `A.rowval` and `A.nzval` to length `nnz(A)` after dropping
+elements.
+
+Performance note: As of January 2016, `f` should be a functor for this method to perform
+well. This caveat may disappear when the work in `jb/functions` lands.
+"""
+function fkeep!{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, f, other, trim::Bool = true)
+    An = A.n
+    Acolptr = A.colptr
+    Arowval = A.rowval
+    Anzval = A.nzval
+
+    # Sweep through columns, rewriting kept elements in their new positions
+    # and updating the column pointers accordingly as we go.
+    Awritepos = 1
+    oldAcolptrAj = 1
+    @inbounds for Aj in 1:An
+        for Ak in oldAcolptrAj:(Acolptr[Aj+1]-1)
+            Ai = Arowval[Ak]
+            Ax = Anzval[Ak]
+            # If this element should be kept, rewrite in new position
+            if f(Ai, Aj, Ax, other)
+                if Awritepos != Ak
+                    Arowval[Awritepos] = Ai
+                    Anzval[Awritepos] = Ax
+                end
+                Awritepos += 1
+            end
+        end
+        oldAcolptrAj = Acolptr[Aj+1]
+        Acolptr[Aj+1] = Awritepos
+    end
+
+    # Trim A's storage if necessary and desired
+    if trim
+        Annz = Acolptr[end] - 1
+        if length(Arowval) != Annz
+            resize!(Arowval, Annz)
+        end
+        if length(Anzval) != Annz
+            resize!(Anzval, Annz)
+        end
+    end
+
+    A
+end
+
+immutable TrilFunc <: Base.Func{4} end
+immutable TriuFunc <: Base.Func{4} end
+(::TrilFunc){Tv,Ti}(i::Ti, j::Ti, x::Tv, k::Integer) = i + k >= j
+(::TriuFunc){Tv,Ti}(i::Ti, j::Ti, x::Tv, k::Integer) = j >= i + k
+function tril!(A::SparseMatrixCSC, k::Integer = 0, trim::Bool = true)
+    if k > A.n-1 || k < 1-A.m
+        throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($(A.m),$(A.n))"))
+    end
+    fkeep!(A, TrilFunc(), k, trim)
+end
+function triu!(A::SparseMatrixCSC, k::Integer = 0, trim::Bool = true)
+    if k > A.n-1 || k < 1-A.m
+        throw(ArgumentError("requested diagonal, $k, out of bounds in matrix of size ($(A.m),$(A.n))"))
+    end
+    fkeep!(A, TriuFunc(), k, trim)
+end
+
+immutable DroptolFunc <: Base.Func{4} end
+(::DroptolFunc){Tv,Ti}(i::Ti, j::Ti, x::Tv, tol::Real) = abs(x) > tol
+droptol!(A::SparseMatrixCSC, tol, trim::Bool = true) = fkeep!(A, DroptolFunc(), tol, trim)
+
+immutable DropzerosFunc <: Base.Func{4} end
+(::DropzerosFunc){Tv,Ti}(i::Ti, j::Ti, x::Tv, other) = x != 0
+dropzeros!(A::SparseMatrixCSC, trim::Bool = true) = fkeep!(A, DropzerosFunc(), Void, trim)
+dropzeros(A::SparseMatrixCSC, trim::Bool = true) = dropzeros!(copy(A), trim)
+
+
+## Find methods
+
 function find(S::SparseMatrixCSC)
     sz = size(S)
     I, J = findn(S)
@@ -438,6 +881,16 @@ function sprand_IJ(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloa
     I, J
 end
 
+"""
+    sprand([rng],m,[n],p::AbstractFloat,[rfn])
+
+Create a random length `m` sparse vector or `m` by `n` sparse matrix, in
+which the probability of any element being nonzero is independently given by
+`p` (and hence the mean density of nonzeros is also exactly `p`). Nonzero
+values are sampled from the distribution specified by `rfn`. The uniform
+distribution is used in case `rfn` is not specified. The optional `rng`
+argument specifies a random number generator, see [Random Numbers](:ref:`Random Numbers <random-numbers>`).
+"""
 function sprand{T}(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat,
                 rfn::Function, ::Type{T}=eltype(rfn(r,1)))
     N = m*n
@@ -461,15 +914,45 @@ end
 sprand(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density,rand,Float64)
 sprand(m::Integer, n::Integer, density::AbstractFloat) = sprand(GLOBAL_RNG,m,n,density)
 sprandn(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density,randn,Float64)
+
+"""
+    sprandn(m[,n],p::AbstractFloat)
+
+Create a random sparse vector of length `m` or sparse matrix of size `m` by `n`
+with the specified (independent) probability `p` of any entry being nonzero,
+where nonzero values are sampled from the normal distribution.
+"""
 sprandn( m::Integer, n::Integer, density::AbstractFloat) = sprandn(GLOBAL_RNG,m,n,density)
 
 truebools(r::AbstractRNG, n::Integer) = ones(Bool, n)
 sprandbool(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density,truebools,Bool)
+
+"""
+    sprandbool(m[,n],p)
+
+Create a random `m` by `n` sparse boolean matrix or length `m` sparse boolean
+vector with the specified (independent) probability `p` of any entry being
+`true`.
+"""
 sprandbool(m::Integer, n::Integer, density::AbstractFloat) = sprandbool(GLOBAL_RNG,m,n,density)
 
+"""
+    spones(S)
+
+Create a sparse array with the same structure as that of `S`, but with every nonzero
+element having the value `1.0`.
+"""
 spones{T}(S::SparseMatrixCSC{T}) =
      SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), ones(T, S.colptr[end]-1))
 
+"""
+    spzeros([type,]m[,n])
+
+Create a sparse vector of length `m` or sparse matrix of size `m x n`. This
+sparse array will not contain any nonzero values. No storage will be allocated
+for nonzero values during construction. The type defaults to `Float64` if not
+specified.
+"""
 spzeros(m::Integer, n::Integer) = spzeros(Float64, m, n)
 spzeros(Tv::Type, m::Integer, n::Integer) = spzeros(Tv, Int, m, n)
 function spzeros(Tv::Type, Ti::Type, m::Integer, n::Integer)
@@ -477,12 +960,26 @@ function spzeros(Tv::Type, Ti::Type, m::Integer, n::Integer)
     SparseMatrixCSC(m, n, ones(Ti, n+1), Array(Ti, 0), Array(Tv, 0))
 end
 
+
 speye(n::Integer) = speye(Float64, n)
 speye(T::Type, n::Integer) = speye(T, n, n)
 speye(m::Integer, n::Integer) = speye(Float64, m, n)
+
+"""
+    speye(S)
+
+Create a sparse identity matrix with the same structure as that of  `S`.
+"""
 speye{T}(S::SparseMatrixCSC{T}) = speye(T, size(S, 1), size(S, 2))
 eye(S::SparseMatrixCSC) = speye(S)
 
+"""
+    speye([type,]m[,n])
+
+Create a sparse identity matrix of size `m x m`. When `n` is supplied,
+create a sparse identity matrix of size `m x n`. The type defaults to `Float64`
+if not specified.
+"""
 function speye(T::Type, m::Integer, n::Integer)
     ((m < 0) || (n < 0)) && throw(ArgumentError("invalid Array dimensions"))
     x = min(m,n)
@@ -644,8 +1141,8 @@ function gen_broadcast_body_sparse(f::Function, is_first_sparse::Bool)
         colptr1 = A_1.colptr; rowval1 = A_1.rowval; nzval1 = A_1.nzval
         colptr2 = A_2.colptr; rowval2 = A_2.rowval; nzval2 = A_2.nzval
 
-        nnzB = nnz(A_1) * div(B.n, A_1.n) * div(B.m, A_1.m)  +
-               nnz(A_2) * div(B.n, A_2.n) * div(B.m, A_2.m)
+        nnzB = isempty(B) ? 0 : (nnz(A_1) * div(B.n, A_1.n) * div(B.m, A_1.m)  +
+                                 nnz(A_2) * div(B.n, A_2.n) * div(B.m, A_2.m))
         if length(rowvalB) < nnzB
             resize!(rowvalB, nnzB)
         end
@@ -804,7 +1301,8 @@ function gen_broadcast_body_zpreserving(f::Function, is_first_sparse::Bool)
         Base.Broadcast.check_broadcast_shape(size(B), $A1)
         Base.Broadcast.check_broadcast_shape(size(B), $A2)
 
-        nnzB = nnz($A1) * div(B.n, ($A1).n) * div(B.m, ($A1).m)
+        nnzB = isempty(B) ? 0 :
+               nnz($A1) * div(B.n, ($A1).n) * div(B.m, ($A1).m)
         if length(B.rowval) < nnzB
             resize!(B.rowval, nnzB)
         end
@@ -916,7 +1414,7 @@ end # macro
 (.-)(A::Number, B::SparseMatrixCSC) = A .- full(B)
 ( -)(A::Array , B::SparseMatrixCSC) = A  - full(B)
 
-(.*)(A::AbstractArray, B::AbstractArray) = broadcast_zpreserving(*, A, B)
+(.*)(A::AbstractArray, B::AbstractArray) = broadcast_zpreserving(MulFun(), A, B)
 (.*)(A::SparseMatrixCSC, B::Number) = SparseMatrixCSC(A.m, A.n, copy(A.colptr), copy(A.rowval), A.nzval .* B)
 (.*)(A::Number, B::SparseMatrixCSC) = SparseMatrixCSC(B.m, B.n, copy(B.colptr), copy(B.rowval), A .* B.nzval)
 
@@ -935,6 +1433,7 @@ end # macro
 (.^)(A::SparseMatrixCSC, B::Number) =
     B==0 ? sparse(ones(typeof(one(eltype(A)).^B), A.m, A.n)) :
            SparseMatrixCSC(A.m, A.n, copy(A.colptr), copy(A.rowval), A.nzval .^ B)
+(.^)(::Irrational{:e}, B::SparseMatrixCSC) = exp(B)
 (.^)(A::Number, B::SparseMatrixCSC) = (.^)(A, full(B))
 (.^)(A::SparseMatrixCSC, B::Array) = (.^)(full(A), B)
 (.^)(A::Array, B::SparseMatrixCSC) = (.^)(A, full(B))
@@ -1017,7 +1516,7 @@ function _mapreducezeros(f, op, T::Type, nzeros::Int, v0)
     v
 end
 
-function Base._mapreduce{T}(f, op, A::SparseMatrixCSC{T})
+function Base._mapreduce{T}(f, op, ::Base.LinearSlow, A::SparseMatrixCSC{T})
     z = nnz(A)
     n = length(A)
     if z == 0
@@ -1294,14 +1793,10 @@ function getindex{T}(A::SparseMatrixCSC{T}, i0::Integer, i1::Integer)
     ((r1 > r2) || (A.rowval[r1] != i0)) ? zero(T) : A.nzval[r1]
 end
 
-getindex{T<:Integer}(A::SparseMatrixCSC, I::AbstractVector{T}, j::Integer) = getindex(A,I,[j])
-getindex{T<:Integer}(A::SparseMatrixCSC, i::Integer, J::AbstractVector{T}) = getindex(A,[i],J)
-
-# Colon translation (this could be done more efficiently)
-getindex(A::SparseMatrixCSC, ::Colon)          = getindex(A, 1:length(A))
-getindex(A::SparseMatrixCSC, ::Colon, ::Colon) = getindex(A, 1:size(A, 1), 1:size(A, 2))
-getindex(A::SparseMatrixCSC, ::Colon, j)       = getindex(A, 1:size(A, 1), j)
+# Colon translation
+getindex(A::SparseMatrixCSC, ::Colon, ::Colon) = copy(A)
 getindex(A::SparseMatrixCSC, i, ::Colon)       = getindex(A, i, 1:size(A, 2))
+getindex(A::SparseMatrixCSC, ::Colon, i)       = getindex(A, 1:size(A, 1), i)
 
 function getindex_cols{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, J::AbstractVector)
     # for indexing whole columns
@@ -1388,10 +1883,14 @@ function getindex_I_sorted{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector,
     # Similar to getindex_general but without the transpose trick.
     (m, n) = size(A)
 
-    nI = length(I)
-    avgM = div(nnz(A),n)
-    # heuristics based on experiments
-    alg = ((nI - avgM) > 2^8) ? 1 :
+    nI   = length(I)
+    nzA  = nnz(A)
+    avgM = div(nzA,n)
+    # Heuristics based on experiments discussed in:
+    # https://github.com/JuliaLang/julia/issues/12860
+    # https://github.com/JuliaLang/julia/pull/12934
+    alg = ((m > nzA) && (m > nI)) ? 0 :
+          ((nI - avgM) > 2^8) ? 1 :
           ((avgM - nI) > 2^10) ? 0 : 2
 
     (alg == 0) ? getindex_I_sorted_bsearch_A(A, I, J) :
@@ -1620,8 +2119,8 @@ end
 
 function getindex_general{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::AbstractVector)
     pI = sortperm(I)
-    @inbounds I = I[pI]
-    permute_rows!(getindex_I_sorted(A, I, J), pI)
+    @inbounds Is = I[pI]
+    permute_rows!(getindex_I_sorted(A, Is, J), pI)
 end
 
 # the general case:
@@ -1649,57 +2148,6 @@ function getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::Abstra
     end
 end
 
-# logical getindex
-getindex{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range{Bool}, J::AbstractVector{Bool}) = error("Cannot index with Range{Bool}")
-getindex{Tv,Ti<:Integer,T<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range{Bool}, J::AbstractVector{T}) = error("Cannot index with Range{Bool}")
-
-getindex{T<:Integer}(A::SparseMatrixCSC, I::Range{T}, J::AbstractVector{Bool}) = A[I,find(J)]
-getindex(A::SparseMatrixCSC, I::Integer, J::AbstractVector{Bool}) = A[I,find(J)]
-getindex(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::Integer) = A[find(I),J]
-getindex(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{Bool}) = A[find(I),find(J)]
-getindex{T<:Integer}(A::SparseMatrixCSC, I::AbstractVector{T}, J::AbstractVector{Bool}) = A[I,find(J)]
-getindex{T<:Integer}(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{T}) = A[find(I),J]
-
-function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray{Bool})
-    checkbounds(A, I)
-    n = sum(I)
-
-    colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
-    colptrB = Int[1,n+1]
-    rowvalB = Array(Int, n)
-    nzvalB = Array(Tv, n)
-    c = 1
-    rowB = 1
-
-    @inbounds for col in 1:A.n
-        r1 = colptrA[col]
-        r2 = colptrA[col+1]-1
-
-        for row in 1:A.m
-            if I[row, col]
-                while (r1 <= r2) && (rowvalA[r1] < row)
-                    r1 += 1
-                end
-                if (r1 <= r2) && (rowvalA[r1] == row)
-                    nzvalB[c] = nzvalA[r1]
-                    rowvalB[c] = rowB
-                    c += 1
-                end
-                rowB += 1
-                (rowB > n) && break
-            end
-        end
-        (rowB > n) && break
-    end
-    colptrB[end] = c
-    n = length(nzvalB)
-    if n > (c-1)
-        deleteat!(nzvalB, c:n)
-        deleteat!(rowvalB, c:n)
-    end
-    SparseMatrixCSC(n, 1, colptrB, rowvalB, nzvalB)
-end
-
 function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray)
     szA = size(A)
     nA = szA[1]*szA[2]
@@ -1742,6 +2190,16 @@ function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray)
     SparseMatrixCSC(outm, outn, colptrB, rowvalB, nzvalB)
 end
 
+# logical getindex
+getindex{Tv,Ti<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range{Bool}, J::AbstractVector{Bool}) = error("Cannot index with Range{Bool}")
+getindex{Tv,Ti<:Integer,T<:Integer}(A::SparseMatrixCSC{Tv,Ti}, I::Range{Bool}, J::AbstractVector{T}) = error("Cannot index with Range{Bool}")
+
+getindex{T<:Integer}(A::SparseMatrixCSC, I::Range{T}, J::AbstractVector{Bool}) = A[I,find(J)]
+getindex(A::SparseMatrixCSC, I::Integer, J::AbstractVector{Bool}) = A[I,find(J)]
+getindex(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::Integer) = A[find(I),J]
+getindex(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{Bool}) = A[find(I),find(J)]
+getindex{T<:Integer}(A::SparseMatrixCSC, I::AbstractVector{T}, J::AbstractVector{Bool}) = A[I,find(J)]
+getindex{T<:Integer}(A::SparseMatrixCSC, I::AbstractVector{Bool}, J::AbstractVector{T}) = A[find(I),J]
 
 ## setindex!
 function setindex!{T,Ti}(A::SparseMatrixCSC{T,Ti}, v, i0::Integer, i1::Integer)
@@ -2416,6 +2874,11 @@ function hvcat(rows::Tuple{Vararg{Int}}, X::SparseMatrixCSC...)
     vcat(tmp_rows...)
 end
 
+"""
+    blkdiag(A...)
+
+Concatenate matrices block-diagonally. Currently only implemented for sparse matrices.
+"""
 function blkdiag(X::SparseMatrixCSC...)
     num = length(X)
     mX = [ size(x, 1) for x in X ]
@@ -2447,10 +2910,8 @@ function blkdiag(X::SparseMatrixCSC...)
     SparseMatrixCSC(m, n, colptr, rowval, nzval)
 end
 
-squeeze(S::SparseMatrixCSC, dims::Dims) = throw(ArgumentError("squeeze is not available for sparse matrices"))
-
 ## Structure query functions
-issym(A::SparseMatrixCSC) = is_hermsym(A, IdFun())
+issymmetric(A::SparseMatrixCSC) = is_hermsym(A, IdFun())
 
 ishermitian(A::SparseMatrixCSC) = is_hermsym(A, ConjFun())
 
@@ -2565,6 +3026,15 @@ function spdiagm_internal(B, d)
     return (I,J,V)
 end
 
+"""
+    spdiagm(B, d[, m, n])
+
+Construct a sparse diagonal matrix. `B` is a tuple of vectors containing the diagonals and
+`d` is a tuple containing the positions of the diagonals. In the case the input contains only
+one diagonal, `B` can be a vector (instead of a tuple) and `d` can be the diagonal position
+(instead of a tuple), defaulting to 0 (diagonal). Optionally, `m` and `n` specify the size
+of the resulting sparse matrix.
+"""
 function spdiagm(B, d, m::Integer, n::Integer)
     (I,J,V) = spdiagm_internal(B, d)
     return sparse(I,J,V,m,n)
diff --git a/base/sparse/sparsevector.jl b/base/sparse/sparsevector.jl
new file mode 100644
index 0000000000000..da54b2861980e
--- /dev/null
+++ b/base/sparse/sparsevector.jl
@@ -0,0 +1,1627 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+### Common definitions
+
+import Base: Func, AddFun, MulFun, MaxFun, MinFun, SubFun, sort
+
+immutable ComplexFun <: Func{2} end
+(::ComplexFun)(x::Real, y::Real) = complex(x, y)
+
+immutable DotFun <: Func{2} end
+(::DotFun)(x::Number, y::Number) = conj(x) * y
+
+typealias UnaryOp Union{Function, Func{1}}
+typealias BinaryOp Union{Function, Func{2}}
+
+### The SparseVector
+
+### Types
+
+immutable SparseVector{Tv,Ti<:Integer} <: AbstractSparseVector{Tv,Ti}
+    n::Int              # the number of elements
+    nzind::Vector{Ti}   # the indices of nonzeros
+    nzval::Vector{Tv}   # the values of nonzeros
+
+    function SparseVector(n::Integer, nzind::Vector{Ti}, nzval::Vector{Tv})
+        n >= 0 || throw(ArgumentError("The number of elements must be non-negative."))
+        length(nzind) == length(nzval) ||
+            throw(ArgumentError("index and value vectors must be the same length"))
+        new(convert(Int, n), nzind, nzval)
+    end
+end
+
+SparseVector{Tv,Ti}(n::Integer, nzind::Vector{Ti}, nzval::Vector{Tv}) =
+    SparseVector{Tv,Ti}(n, nzind, nzval)
+
+### Basic properties
+
+length(x::SparseVector) = x.n
+size(x::SparseVector) = (x.n,)
+nnz(x::SparseVector) = length(x.nzval)
+countnz(x::SparseVector) = countnz(x.nzval)
+nonzeros(x::SparseVector) = x.nzval
+nonzeroinds(x::SparseVector) = x.nzind
+
+similar{T}(x::SparseVector, ::Type{T}, D::Dims) = spzeros(T, D...)
+
+### Construct empty sparse vector
+
+spzeros(len::Integer) = spzeros(Float64, len)
+spzeros{T}(::Type{T}, len::Integer) = SparseVector(len, Int[], T[])
+
+# Construction of same structure, but with all ones
+spones{T}(x::SparseVector{T}) = SparseVector(x.n, copy(x.nzind), ones(T, length(x.nzval)))
+
+### Construction from lists of indices and values
+
+function _sparsevector!{Ti<:Integer}(I::Vector{Ti}, V::Vector, len::Integer)
+    # pre-condition: no duplicate indexes in I
+    if !isempty(I)
+        p = sortperm(I)
+        permute!(I, p)
+        permute!(V, p)
+    end
+    SparseVector(len, I, V)
+end
+
+function _sparsevector!{Tv,Ti<:Integer}(I::Vector{Ti}, V::Vector{Tv}, len::Integer, combine::BinaryOp)
+    if !isempty(I)
+        p = sortperm(I)
+        permute!(I, p)
+        permute!(V, p)
+        m = length(I)
+
+        # advances to the first non-zero element
+        r = 1     # index of last processed entry
+        while r <= m
+            if V[r] == 0
+                r += 1
+            else
+                break
+            end
+        end
+        r > m && return SparseVector(len, Ti[], Tv[])
+
+        # move r-th to l-th
+        l = 1       # length of processed part
+        i = I[r]    # row-index of current element
+        if r > 1
+            I[l] = i; V[l] = V[r]
+        end
+
+        # main loop
+        while r < m
+            r += 1
+            i2 = I[r]
+            if i2 == i  # accumulate r-th to the l-th entry
+                V[l] = combine(V[l], V[r])
+            else  # advance l, and move r-th to l-th
+                pv = V[l]
+                if pv != 0
+                    l += 1
+                end
+                i = i2
+                if l < r
+                    I[l] = i; V[l] = V[r]
+                end
+            end
+        end
+        if V[l] == 0
+            l -= 1
+        end
+        if l < m
+            resize!(I, l)
+            resize!(V, l)
+        end
+    end
+    SparseVector(len, I, V)
+end
+
+"""
+    sparsevec(I, V, [m, combine])
+
+Create a sparse vector `S` of length `m` such that `S[I[k]] = V[k]`.
+Duplicates are combined using the `combine` function, which defaults to
+`+` if no `combine` argument is provided, unless the elements of `V` are Booleans
+in which case `combine` defaults to `|`.
+"""
+function sparsevec{Tv,Ti<:Integer}(I::AbstractVector{Ti}, V::AbstractVector{Tv}, combine::BinaryOp)
+    length(I) == length(V) ||
+        throw(ArgumentError("index and value vectors must be the same length"))
+    len = 0
+    for i in I
+        i >= 1 || error("Index must be positive.")
+        if i > len
+            len = i
+        end
+    end
+    _sparsevector!(collect(Ti, I), collect(Tv, V), len, combine)
+end
+
+function sparsevec{Tv,Ti<:Integer}(I::AbstractVector{Ti}, V::AbstractVector{Tv}, len::Integer, combine::BinaryOp)
+    length(I) == length(V) ||
+        throw(ArgumentError("index and value vectors must be the same length"))
+    maxi = convert(Ti, len)
+    for i in I
+        1 <= i <= maxi || throw(ArgumentError("An index is out of bound."))
+    end
+    _sparsevector!(collect(Ti, I), collect(Tv, V), len, combine)
+end
+
+sparsevec{Ti<:Integer}(I::AbstractVector{Ti}, V::Union{Number, AbstractVector}) =
+    sparsevec(I, V, AddFun())
+
+sparsevec{Ti<:Integer}(I::AbstractVector{Ti}, V::Union{Number, AbstractVector},
+    len::Integer) =
+    sparsevec(I, V, len, AddFun())
+
+sparsevec{Ti<:Integer}(I::AbstractVector{Ti}, V::Union{Bool, AbstractVector{Bool}}) =
+    sparsevec(I, V, OrFun())
+
+sparsevec{Ti<:Integer}(I::AbstractVector{Ti}, V::Union{Bool, AbstractVector{Bool}},
+    len::Integer) =
+    sparsevec(I, V, len, OrFun())
+
+sparsevec{Ti<:Integer}(I::AbstractVector{Ti}, v::Number, combine::BinaryOp) =
+    sparsevec(I, fill(v, length(I)), combine)
+
+sparsevec{Ti<:Integer}(I::AbstractVector{Ti}, v::Number, len::Integer, combine::BinaryOp) =
+    sparsevec(I, fill(v, length(I)), len, combine)
+
+
+### Construction from dictionary
+"""
+    sparsevec(D::Dict, [m])
+
+Create a sparse vector of length `m` where the nonzero indices are keys from
+the dictionary, and the nonzero values are the values from the dictionary.
+"""
+function sparsevec{Tv,Ti<:Integer}(dict::Associative{Ti,Tv})
+    m = length(dict)
+    nzind = Array(Ti, m)
+    nzval = Array(Tv, m)
+
+    cnt = 0
+    len = zero(Ti)
+    for (k, v) in dict
+        k >= 1 || throw(ArgumentError("index must be positive."))
+        if k > len
+            len = k
+        end
+        if v != 0
+            cnt += 1
+            @inbounds nzind[cnt] = k
+            @inbounds nzval[cnt] = v
+        end
+    end
+    resize!(nzind, cnt)
+    resize!(nzval, cnt)
+    _sparsevector!(nzind, nzval, len)
+end
+
+function sparsevec{Tv,Ti<:Integer}(dict::Associative{Ti,Tv}, len::Integer)
+    m = length(dict)
+    nzind = Array(Ti, m)
+    nzval = Array(Tv, m)
+
+    cnt = 0
+    maxk = convert(Ti, len)
+    for (k, v) in dict
+        1 <= k <= maxk || throw(ArgumentError("an index (key) is out of bound."))
+        if v != 0
+            cnt += 1
+            @inbounds nzind[cnt] = k
+            @inbounds nzval[cnt] = v
+        end
+    end
+    resize!(nzind, cnt)
+    resize!(nzval, cnt)
+    _sparsevector!(nzind, nzval, len)
+end
+
+
+### Element access
+
+function setindex!{Tv,Ti<:Integer}(x::SparseVector{Tv,Ti}, v::Tv, i::Ti)
+    checkbounds(x, i)
+    nzind = nonzeroinds(x)
+    nzval = nonzeros(x)
+
+    m = length(nzind)
+    k = searchsortedfirst(nzind, i)
+    if 1 <= k <= m && nzind[k] == i  # i found
+        if v == 0
+            deleteat!(nzind, k)
+            deleteat!(nzval, k)
+        else
+            nzval[k] = v
+        end
+    else  # i not found
+        if v != 0
+            insert!(nzind, k, i)
+            insert!(nzval, k, v)
+        end
+    end
+    x
+end
+
+setindex!{Tv, Ti<:Integer}(x::SparseVector{Tv,Ti}, v, i::Integer) =
+    setindex!(x, convert(Tv, v), convert(Ti, i))
+
+
+### Conversion
+
+# convert SparseMatrixCSC to SparseVector
+function convert{Tv,Ti<:Integer}(::Type{SparseVector{Tv,Ti}}, s::SparseMatrixCSC{Tv,Ti})
+    size(s, 2) == 1 || throw(ArgumentError("The input argument must have a single-column."))
+    SparseVector(s.m, s.rowval, s.nzval)
+end
+
+convert{Tv,Ti}(::Type{SparseVector{Tv}}, s::SparseMatrixCSC{Tv,Ti}) =
+    convert(SparseVector{Tv,Ti}, s)
+
+convert{Tv,Ti}(::Type{SparseVector}, s::SparseMatrixCSC{Tv,Ti}) =
+    convert(SparseVector{Tv,Ti}, s)
+
+# convert Vector to SparseVector
+
+"""
+    sparsevec(A)
+
+Convert a vector `A` into a sparse vector of length `m`.
+"""
+sparsevec{T}(a::AbstractVector{T}) = convert(SparseVector{T, Int}, a)
+sparsevec(a::AbstractArray) = sparsevec(vec(a))
+sparsevec(a::AbstractSparseArray) = vec(a)
+sparse(a::AbstractVector) = sparsevec(a)
+
+function _dense2sparsevec{Tv,Ti}(s::AbstractArray{Tv}, initcap::Ti)
+    # pre-condition: initcap > 0; the initcap determines the index type
+    n = length(s)
+    cap = initcap
+    nzind = Array(Ti, cap)
+    nzval = Array(Tv, cap)
+    c = 0
+    @inbounds for i = 1:n
+        v = s[i]
+        if v != 0
+            if c >= cap
+                cap *= 2
+                resize!(nzind, cap)
+                resize!(nzval, cap)
+            end
+            c += 1
+            nzind[c] = i
+            nzval[c] = v
+        end
+    end
+    if c < cap
+        resize!(nzind, c)
+        resize!(nzval, c)
+    end
+    SparseVector(n, nzind, nzval)
+end
+
+convert{Tv,Ti}(::Type{SparseVector{Tv,Ti}}, s::AbstractVector{Tv}) =
+    _dense2sparsevec(s, convert(Ti, max(8, div(length(s), 8))))
+
+convert{Tv}(::Type{SparseVector{Tv}}, s::AbstractVector{Tv}) =
+    convert(SparseVector{Tv,Int}, s)
+
+convert{Tv}(::Type{SparseVector}, s::AbstractVector{Tv}) =
+    convert(SparseVector{Tv,Int}, s)
+
+
+# convert between different types of SparseVector
+convert{Tv,Ti,TvS,TiS}(::Type{SparseVector{Tv,Ti}}, s::SparseVector{TvS,TiS}) =
+    SparseVector{Tv,Ti}(s.n, convert(Vector{Ti}, s.nzind), convert(Vector{Tv}, s.nzval))
+
+convert{Tv,TvS,TiS}(::Type{SparseVector{Tv}}, s::SparseVector{TvS,TiS}) =
+    SparseVector{Tv,TiS}(s.n, s.nzind, convert(Vector{Tv}, s.nzval))
+
+
+### Rand Construction
+sprand{T}(n::Integer, p::AbstractFloat, rfn::Function, ::Type{T}) = sprand(GLOBAL_RNG, n, p, rfn, T)
+function sprand{T}(r::AbstractRNG, n::Integer, p::AbstractFloat, rfn::Function, ::Type{T})
+    I = randsubseq(r, 1:convert(Int, n), p)
+    V = rfn(r, T, length(I))
+    SparseVector(n, I, V)
+end
+
+sprand(n::Integer, p::AbstractFloat, rfn::Function) = sprand(GLOBAL_RNG, n, p, rfn)
+function sprand(r::AbstractRNG, n::Integer, p::AbstractFloat, rfn::Function)
+    I = randsubseq(r, 1:convert(Int, n), p)
+    V = rfn(r, length(I))
+    SparseVector(n, I, V)
+end
+
+sprand{T}(n::Integer, p::AbstractFloat, ::Type{T}) = sprand(GLOBAL_RNG, n, p, rand, T)
+sprand(n::Integer, p::AbstractFloat) = sprand(GLOBAL_RNG, n, p, rand)
+sprand{T}(r::AbstractRNG, n::Integer, p::AbstractFloat, ::Type{T}) = sprand(r, n, p, rand, T)
+sprand(r::AbstractRNG, n::Integer, p::AbstractFloat) = sprand(r, n, p, rand)
+
+sprandn(n::Integer, p::AbstractFloat) = sprand(GLOBAL_RNG, n, p, randn)
+sprandn(r::AbstractRNG, n::Integer, p::AbstractFloat) = sprand(r, n, p, randn)
+
+sprandbool(n::Integer, p::AbstractFloat) = sprand(GLOBAL_RNG, n, p, truebools)
+sprandbool(r::AbstractRNG, n::Integer, p::AbstractFloat) = sprand(r, n, p, truebools)
+
+## Indexing into Matrices can return SparseVectors
+
+# Column slices
+function getindex(x::SparseMatrixCSC, ::Colon, j::Integer)
+    checkbounds(x, :, j)
+    r1 = convert(Int, x.colptr[j])
+    r2 = convert(Int, x.colptr[j+1]) - 1
+    SparseVector(x.m, x.rowval[r1:r2], x.nzval[r1:r2])
+end
+
+function getindex(x::SparseMatrixCSC, I::UnitRange, j::Integer)
+    checkbounds(x, I, j)
+    # Get the selected column
+    c1 = convert(Int, x.colptr[j])
+    c2 = convert(Int, x.colptr[j+1]) - 1
+    # Restrict to the selected rows
+    r1 = searchsortedfirst(x.rowval, first(I), c1, c2, Forward)
+    r2 = searchsortedlast(x.rowval, last(I), c1, c2, Forward)
+    SparseVector(length(I), x.rowval[r1:r2] - first(I) + 1, x.nzval[r1:r2])
+end
+
+# In the general case, we piggy back upon SparseMatrixCSC's optimized solution
+@inline function getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector, J::Integer)
+    M = A[I, [J]]
+    SparseVector(M.m, M.rowval, M.nzval)
+end
+
+# Row slices
+getindex(A::SparseMatrixCSC, i::Integer, ::Colon) = A[i, 1:end]
+getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, i::Integer, J::AbstractVector{Bool}) = A[i, find(J)]
+function Base.getindex{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, i::Integer, J::AbstractVector)
+    checkbounds(A, i, J)
+    nJ = length(J)
+    colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
+
+    nzinds = Array(Ti, 0)
+    nzvals = Array(Tv, 0)
+
+    # adapted from SparseMatrixCSC's sorted_bsearch_A
+    ptrI = 1
+    @inbounds for j = 1:nJ
+        col = J[j]
+        rowI = i
+        ptrA = colptrA[col]
+        stopA = colptrA[col+1]-1
+        if ptrA <= stopA
+            if rowvalA[ptrA] <= rowI
+                ptrA = searchsortedfirst(rowvalA, rowI, ptrA, stopA, Base.Order.Forward)
+                if ptrA <= stopA && rowvalA[ptrA] == rowI
+                    push!(nzinds, j)
+                    push!(nzvals, nzvalA[ptrA])
+                end
+            end
+            ptrI += 1
+        end
+    end
+    return SparseVector(nJ, nzinds, nzvals)
+end
+
+
+# Logical and linear indexing into SparseMatrices
+getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractVector{Bool}) = _logical_index(A, I) # Ambiguities
+getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray{Bool}) = _logical_index(A, I)
+function _logical_index{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractArray{Bool})
+    checkbounds(A, I)
+    n = sum(I)
+    nnzB = min(n, nnz(A))
+
+    colptrA = A.colptr; rowvalA = A.rowval; nzvalA = A.nzval
+    rowvalB = Array(Int, nnzB)
+    nzvalB = Array(Tv, nnzB)
+    c = 1
+    rowB = 1
+
+    @inbounds for col in 1:A.n
+        r1 = colptrA[col]
+        r2 = colptrA[col+1]-1
+
+        for row in 1:A.m
+            if I[row, col]
+                while (r1 <= r2) && (rowvalA[r1] < row)
+                    r1 += 1
+                end
+                if (r1 <= r2) && (rowvalA[r1] == row)
+                    nzvalB[c] = nzvalA[r1]
+                    rowvalB[c] = rowB
+                    c += 1
+                end
+                rowB += 1
+                (rowB > n) && break
+            end
+        end
+        (rowB > n) && break
+    end
+    if nnzB > (c-1)
+        deleteat!(nzvalB, c:nnzB)
+        deleteat!(rowvalB, c:nnzB)
+    end
+    SparseVector(n, rowvalB, nzvalB)
+end
+
+# TODO: further optimizations are available for ::Colon and other types of Range
+getindex(A::SparseMatrixCSC, ::Colon) = A[1:end]
+
+function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::UnitRange)
+    checkbounds(A, I)
+    szA = size(A)
+    nA = szA[1]*szA[2]
+    colptrA = A.colptr
+    rowvalA = A.rowval
+    nzvalA = A.nzval
+
+    n = length(I)
+    nnzB = min(n, nnz(A))
+    rowvalB = Array(Int, nnzB)
+    nzvalB = Array(Tv, nnzB)
+
+    rowstart,colstart = ind2sub(szA, first(I))
+    rowend,colend = ind2sub(szA, last(I))
+
+    idxB = 1
+    @inbounds for col in colstart:colend
+        minrow = (col == colstart ? rowstart : 1)
+        maxrow = (col == colend ? rowend : szA[1])
+        for r in colptrA[col]:(colptrA[col+1]-1)
+            rowA = rowvalA[r]
+            if minrow <= rowA <= maxrow
+                rowvalB[idxB] = sub2ind(szA, rowA, col) - first(I) + 1
+                nzvalB[idxB] = nzvalA[r]
+                idxB += 1
+            end
+        end
+    end
+    if nnzB > (idxB-1)
+        deleteat!(nzvalB, idxB:nnzB)
+        deleteat!(rowvalB, idxB:nnzB)
+    end
+    SparseVector(n, rowvalB, nzvalB)
+end
+
+function getindex{Tv}(A::SparseMatrixCSC{Tv}, I::AbstractVector)
+    szA = size(A)
+    nA = szA[1]*szA[2]
+    colptrA = A.colptr
+    rowvalA = A.rowval
+    nzvalA = A.nzval
+
+    n = length(I)
+    nnzB = min(n, nnz(A))
+    rowvalB = Array(Int, nnzB)
+    nzvalB = Array(Tv, nnzB)
+
+    idxB = 1
+    for i in 1:n
+        ((I[i] < 1) | (I[i] > nA)) && throw(BoundsError(A, I))
+        row,col = ind2sub(szA, I[i])
+        for r in colptrA[col]:(colptrA[col+1]-1)
+            @inbounds if rowvalA[r] == row
+                if idxB <= nnzB
+                    rowvalB[idxB] = i
+                    nzvalB[idxB] = nzvalA[r]
+                    idxB += 1
+                else # this can happen if there are repeated indices in I
+                    push!(rowvalB, i)
+                    push!(nzvalB, nzvalA[r])
+                end
+                break
+            end
+        end
+    end
+    if nnzB > (idxB-1)
+        deleteat!(nzvalB, idxB:nnzB)
+        deleteat!(rowvalB, idxB:nnzB)
+    end
+    SparseVector(n, rowvalB, nzvalB)
+end
+
+
+### Generic functions operating on AbstractSparseVector
+
+### getindex
+
+function _spgetindex{Tv,Ti}(m::Int, nzind::AbstractVector{Ti}, nzval::AbstractVector{Tv}, i::Integer)
+    ii = searchsortedfirst(nzind, convert(Ti, i))
+    (ii <= m && nzind[ii] == i) ? nzval[ii] : zero(Tv)
+end
+
+function getindex{Tv}(x::AbstractSparseVector{Tv}, i::Integer)
+    checkbounds(x, i)
+    _spgetindex(nnz(x), nonzeroinds(x), nonzeros(x), i)
+end
+
+function getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::UnitRange)
+    checkbounds(x, I)
+    xlen = length(x)
+    i0 = first(I)
+    i1 = last(I)
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    m = length(xnzind)
+
+    # locate the first j0, s.t. xnzind[j0] >= i0
+    j0 = searchsortedfirst(xnzind, i0)
+    # locate the last j1, s.t. xnzind[j1] <= i1
+    j1 = searchsortedlast(xnzind, i1, j0, m, Forward)
+
+    # compute the number of non-zeros
+    jrgn = j0:j1
+    mr = length(jrgn)
+    rind = Array(Ti, mr)
+    rval = Array(Tv, mr)
+    if mr > 0
+        c = 0
+        for j in jrgn
+            c += 1
+            rind[c] = convert(Ti, xnzind[j] - i0 + 1)
+            rval[c] = xnzval[j]
+        end
+    end
+    SparseVector(length(I), rind, rval)
+end
+
+getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::AbstractVector{Bool}) = x[find(I)]
+getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::AbstractArray{Bool}) = x[find(I)]
+@inline function getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::AbstractVector)
+    # SparseMatrixCSC has a nicely optimized routine for this; punt
+    S = SparseMatrixCSC(x.n, 1, [1,length(x.nzind)+1], x.nzind, x.nzval)
+    S[I, 1]
+end
+
+function getindex{Tv,Ti}(x::AbstractSparseVector{Tv,Ti}, I::AbstractArray)
+    # punt to SparseMatrixCSC
+    S = SparseMatrixCSC(x.n, 1, [1,length(x.nzind)+1], x.nzind, x.nzval)
+    S[I]
+end
+
+getindex(x::AbstractSparseVector, ::Colon) = copy(x)
+
+### show and friends
+
+function showarray(io::IO, x::AbstractSparseVector;
+                   header::Bool=true, repr=false)
+
+    n = length(x)
+    nzind = nonzeroinds(x)
+    nzval = nonzeros(x)
+    xnnz = length(nzind)
+
+    if header
+        println(io, summary(x))
+    end
+
+    limit::Bool = Base.limit_output(io)
+    half_screen_rows = limit ? div(displaysize(io)[1] - 8, 2) : typemax(Int)
+    pad = ndigits(n)
+    sep = "\n\t"
+    for k = 1:length(nzind)
+        if k < half_screen_rows || k > xnnz - half_screen_rows
+            print(io, "  ", '[', rpad(nzind[k], pad), "]  =  ")
+            Base.showcompact_lim(io, nzval[k])
+            println(io)
+        elseif k == half_screen_rows
+            println(io, "   ", " "^pad, "   \u22ee")
+        end
+    end
+end
+
+function summary(x::AbstractSparseVector)
+    string("Sparse vector of length ", length(x), ", with ", length(nonzeros(x)),
+           " ",  eltype(x), " nonzero entries:")
+end
+
+show(io::IO, x::AbstractSparseVector) = showarray(io, x)
+writemime(io::IO, ::MIME"text/plain", x::AbstractSparseVector) = show(IOContext(io, :limit_output => true), x)
+
+### Conversion to matrix
+
+function convert{TvD,TiD,Tv,Ti}(::Type{SparseMatrixCSC{TvD,TiD}}, x::AbstractSparseVector{Tv,Ti})
+    n = length(x)
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    m = length(xnzind)
+    colptr = TiD[1, m+1]
+    # Note that this *cannot* share data like normal array conversions, since
+    # modifying one would put the other in an inconsistent state
+    rowval = collect(TiD, xnzind)
+    nzval = collect(TvD, xnzval)
+    SparseMatrixCSC(n, 1, colptr, rowval, nzval)
+end
+
+convert{TvD,Tv,Ti}(::Type{SparseMatrixCSC{TvD}}, x::AbstractSparseVector{Tv,Ti}) =
+    convert(SparseMatrixCSC{TvD,Ti}, x)
+
+convert{Tv,Ti}(::Type{SparseMatrixCSC}, x::AbstractSparseVector{Tv,Ti}) =
+    convert(SparseMatrixCSC{Tv,Ti}, x)
+
+
+### Array manipulation
+
+function full{Tv}(x::AbstractSparseVector{Tv})
+    n = length(x)
+    n == 0 && return Array(Tv, 0)
+    nzind = nonzeroinds(x)
+    nzval = nonzeros(x)
+    r = zeros(Tv, n)
+    for i = 1:length(nzind)
+        r[nzind[i]] = nzval[i]
+    end
+    return r
+end
+
+vec(x::AbstractSparseVector) = x
+copy(x::AbstractSparseVector) =
+    SparseVector(length(x), copy(nonzeroinds(x)), copy(nonzeros(x)))
+
+function reinterpret{T,Tv}(::Type{T}, x::AbstractSparseVector{Tv})
+    sizeof(T) == sizeof(Tv) ||
+        throw(ArgumentError("reinterpret of sparse vectors only supports element types of the same size."))
+    SparseVector(length(x), copy(nonzeroinds(x)), reinterpret(T, nonzeros(x)))
+end
+
+float{Tv<:AbstractFloat}(x::AbstractSparseVector{Tv}) = x
+float(x::AbstractSparseVector) =
+    SparseVector(length(x), copy(nonzeroinds(x)), float(nonzeros(x)))
+
+complex{Tv<:Complex}(x::AbstractSparseVector{Tv}) = x
+complex(x::AbstractSparseVector) =
+    SparseVector(length(x), copy(nonzeroinds(x)), complex(nonzeros(x)))
+
+
+### Concatenation
+
+function hcat{Tv,Ti}(X::AbstractSparseVector{Tv,Ti}...)
+    # check sizes
+    n = length(X)
+    m = length(X[1])
+    tnnz = nnz(X[1])
+    for j = 2:n
+        length(X[j]) == m ||
+            throw(DimensionMismatch("Inconsistent column lengths."))
+        tnnz += nnz(X[j])
+    end
+
+    # construction
+    colptr = Array(Ti, n+1)
+    nzrow = Array(Ti, tnnz)
+    nzval = Array(Tv, tnnz)
+    roff = 1
+    @inbounds for j = 1:n
+        xj = X[j]
+        xnzind = nonzeroinds(xj)
+        xnzval = nonzeros(xj)
+        colptr[j] = roff
+        copy!(nzrow, roff, xnzind)
+        copy!(nzval, roff, xnzval)
+        roff += length(xnzind)
+    end
+    colptr[n+1] = roff
+    SparseMatrixCSC{Tv,Ti}(m, n, colptr, nzrow, nzval)
+end
+
+function vcat{Tv,Ti}(X::AbstractSparseVector{Tv,Ti}...)
+    # check sizes
+    n = length(X)
+    tnnz = 0
+    for j = 1:n
+        tnnz += nnz(X[j])
+    end
+
+    # construction
+    rnzind = Array(Ti, tnnz)
+    rnzval = Array(Tv, tnnz)
+    ir = 0
+    len = 0
+    @inbounds for j = 1:n
+        xj = X[j]
+        xnzind = nonzeroinds(xj)
+        xnzval = nonzeros(xj)
+        xnnz = length(xnzind)
+        for i = 1:xnnz
+            rnzind[ir + i] = xnzind[i] + len
+        end
+        copy!(rnzval, ir+1, xnzval)
+        ir += xnnz
+        len += length(xj)
+    end
+    SparseVector(len, rnzind, rnzval)
+end
+
+### math functions
+
+### Unary Map
+
+# zero-preserving functions (z->z, nz->nz)
+for op in [:-, :abs, :abs2, :conj]
+    @eval begin
+        $(op)(x::AbstractSparseVector) =
+            SparseVector(length(x), copy(nonzeroinds(x)), $(op)(nonzeros(x)))
+    end
+end
+
+# functions f, such that
+#   f(x) can be zero or non-zero when x != 0
+#   f(x) = 0 when x == 0
+#
+macro unarymap_nz2z_z2z(op, TF)
+    esc(quote
+        function $(op){Tv<:$(TF),Ti<:Integer}(x::AbstractSparseVector{Tv,Ti})
+            R = typeof($(op)(zero(Tv)))
+            xnzind = nonzeroinds(x)
+            xnzval = nonzeros(x)
+            m = length(xnzind)
+
+            ynzind = Array(Ti, m)
+            ynzval = Array(R, m)
+            ir = 0
+            @inbounds for j = 1:m
+                i = xnzind[j]
+                v = $(op)(xnzval[j])
+                if v != zero(v)
+                    ir += 1
+                    ynzind[ir] = i
+                    ynzval[ir] = v
+                end
+            end
+            resize!(ynzind, ir)
+            resize!(ynzval, ir)
+            SparseVector(length(x), ynzind, ynzval)
+        end
+    end)
+end
+
+real{T<:Real}(x::AbstractSparseVector{T}) = x
+@unarymap_nz2z_z2z real Complex
+
+imag{Tv<:Real,Ti<:Integer}(x::AbstractSparseVector{Tv,Ti}) = SparseVector(length(x), Ti[], Tv[])
+@unarymap_nz2z_z2z imag Complex
+
+for op in [:floor, :ceil, :trunc, :round]
+    @eval @unarymap_nz2z_z2z $(op) Real
+end
+
+for op in [:log1p, :expm1,
+           :sin, :tan, :sinpi, :sind, :tand,
+           :asin, :atan, :asind, :atand,
+           :sinh, :tanh, :asinh, :atanh]
+    @eval @unarymap_nz2z_z2z $(op) Number
+end
+
+# function that does not preserve zeros
+
+macro unarymap_z2nz(op, TF)
+    esc(quote
+        function $(op){Tv<:$(TF),Ti<:Integer}(x::AbstractSparseVector{Tv,Ti})
+            v0 = $(op)(zero(Tv))
+            R = typeof(v0)
+            xnzind = nonzeroinds(x)
+            xnzval = nonzeros(x)
+            n = length(x)
+            m = length(xnzind)
+            y = fill(v0, n)
+            @inbounds for j = 1:m
+                y[xnzind[j]] = $(op)(xnzval[j])
+            end
+            y
+        end
+    end)
+end
+
+for op in [:exp, :exp2, :exp10, :log, :log2, :log10,
+           :cos, :csc, :cot, :sec, :cospi,
+           :cosd, :cscd, :cotd, :secd,
+           :acos, :acot, :acosd, :acotd,
+           :cosh, :csch, :coth, :sech,
+           :acsch, :asech]
+    @eval @unarymap_z2nz $(op) Number
+end
+
+
+### Binary Map
+
+# mode:
+# 0: f(nz, nz) -> nz, f(z, nz) -> z, f(nz, z) ->  z
+# 1: f(nz, nz) -> z/nz, f(z, nz) -> nz, f(nz, z) -> nz
+# 2: f(nz, nz) -> z/nz, f(z, nz) -> z/nz, f(nz, z) -> z/nz
+
+function _binarymap{Tx,Ty}(f::BinaryOp,
+                           x::AbstractSparseVector{Tx},
+                           y::AbstractSparseVector{Ty},
+                           mode::Int)
+
+    0 <= mode <= 2 || throw(ArgumentError("Incorrect mode $mode."))
+    R = typeof(f(zero(Tx), zero(Ty)))
+    n = length(x)
+    length(y) == n || throw(DimensionMismatch())
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    ynzind = nonzeroinds(y)
+    ynzval = nonzeros(y)
+    mx = length(xnzind)
+    my = length(ynzind)
+    cap = (mode == 0 ? min(mx, my) : mx + my)::Int
+
+    rind = Array(Int, cap)
+    rval = Array(R, cap)
+    ir = 0
+    ix = 1
+    iy = 1
+
+    ir = (
+        mode == 0 ? _binarymap_mode_0!(f, mx, my,
+            xnzind, xnzval, ynzind, ynzval, rind, rval) :
+        mode == 1 ? _binarymap_mode_1!(f, mx, my,
+            xnzind, xnzval, ynzind, ynzval, rind, rval) :
+        _binarymap_mode_2!(f, mx, my,
+            xnzind, xnzval, ynzind, ynzval, rind, rval)
+    )::Int
+
+    resize!(rind, ir)
+    resize!(rval, ir)
+    return SparseVector(n, rind, rval)
+end
+
+function _binarymap_mode_0!(f::BinaryOp, mx::Int, my::Int,
+                            xnzind, xnzval, ynzind, ynzval, rind, rval)
+    # f(nz, nz) -> nz, f(z, nz) -> z, f(nz, z) ->  z
+    ir = 0; ix = 1; iy = 1
+    @inbounds while ix <= mx && iy <= my
+        jx = xnzind[ix]
+        jy = ynzind[iy]
+        if jx == jy
+            v = f(xnzval[ix], ynzval[iy])
+            ir += 1; rind[ir] = jx; rval[ir] = v
+            ix += 1; iy += 1
+        elseif jx < jy
+            ix += 1
+        else
+            iy += 1
+        end
+    end
+    return ir
+end
+
+function _binarymap_mode_1!{Tx,Ty}(f::BinaryOp, mx::Int, my::Int,
+                                   xnzind, xnzval::AbstractVector{Tx},
+                                   ynzind, ynzval::AbstractVector{Ty},
+                                   rind, rval)
+    # f(nz, nz) -> z/nz, f(z, nz) -> nz, f(nz, z) -> nz
+    ir = 0; ix = 1; iy = 1
+    @inbounds while ix <= mx && iy <= my
+        jx = xnzind[ix]
+        jy = ynzind[iy]
+        if jx == jy
+            v = f(xnzval[ix], ynzval[iy])
+            if v != zero(v)
+                ir += 1; rind[ir] = jx; rval[ir] = v
+            end
+            ix += 1; iy += 1
+        elseif jx < jy
+            v = f(xnzval[ix], zero(Ty))
+            ir += 1; rind[ir] = jx; rval[ir] = v
+            ix += 1
+        else
+            v = f(zero(Tx), ynzval[iy])
+            ir += 1; rind[ir] = jy; rval[ir] = v
+            iy += 1
+        end
+    end
+    @inbounds while ix <= mx
+        v = f(xnzval[ix], zero(Ty))
+        ir += 1; rind[ir] = xnzind[ix]; rval[ir] = v
+        ix += 1
+    end
+    @inbounds while iy <= my
+        v = f(zero(Tx), ynzval[iy])
+        ir += 1; rind[ir] = ynzind[iy]; rval[ir] = v
+        iy += 1
+    end
+    return ir
+end
+
+function _binarymap_mode_2!{Tx,Ty}(f::BinaryOp, mx::Int, my::Int,
+                                   xnzind, xnzval::AbstractVector{Tx},
+                                   ynzind, ynzval::AbstractVector{Ty},
+                                   rind, rval)
+    # f(nz, nz) -> z/nz, f(z, nz) -> z/nz, f(nz, z) -> z/nz
+    ir = 0; ix = 1; iy = 1
+    @inbounds while ix <= mx && iy <= my
+        jx = xnzind[ix]
+        jy = ynzind[iy]
+        if jx == jy
+            v = f(xnzval[ix], ynzval[iy])
+            if v != zero(v)
+                ir += 1; rind[ir] = jx; rval[ir] = v
+            end
+            ix += 1; iy += 1
+        elseif jx < jy
+            v = f(xnzval[ix], zero(Ty))
+            if v != zero(v)
+                ir += 1; rind[ir] = jx; rval[ir] = v
+            end
+            ix += 1
+        else
+            v = f(zero(Tx), ynzval[iy])
+            if v != zero(v)
+                ir += 1; rind[ir] = jy; rval[ir] = v
+            end
+            iy += 1
+        end
+    end
+    @inbounds while ix <= mx
+        v = f(xnzval[ix], zero(Ty))
+        if v != zero(v)
+            ir += 1; rind[ir] = xnzind[ix]; rval[ir] = v
+        end
+        ix += 1
+    end
+    @inbounds while iy <= my
+        v = f(zero(Tx), ynzval[iy])
+        if v != zero(v)
+            ir += 1; rind[ir] = ynzind[iy]; rval[ir] = v
+        end
+        iy += 1
+    end
+    return ir
+end
+
+function _binarymap{Tx,Ty}(f::BinaryOp,
+                           x::AbstractVector{Tx},
+                           y::AbstractSparseVector{Ty},
+                           mode::Int)
+
+    0 <= mode <= 2 || throw(ArgumentError("Incorrect mode $mode."))
+    R = typeof(f(zero(Tx), zero(Ty)))
+    n = length(x)
+    length(y) == n || throw(DimensionMismatch())
+
+    ynzind = nonzeroinds(y)
+    ynzval = nonzeros(y)
+    m = length(ynzind)
+
+    dst = Array(R, n)
+    if mode == 0
+        ii = 1
+        @inbounds for i = 1:m
+            j = ynzind[i]
+            while ii < j
+                dst[ii] = zero(R); ii += 1
+            end
+            dst[j] = f(x[j], ynzval[i]); ii += 1
+        end
+        @inbounds while ii <= n
+            dst[ii] = zero(R); ii += 1
+        end
+    else # mode >= 1
+        ii = 1
+        @inbounds for i = 1:m
+            j = ynzind[i]
+            while ii < j
+                dst[ii] = f(x[ii], zero(Ty)); ii += 1
+            end
+            dst[j] = f(x[j], ynzval[i]); ii += 1
+        end
+        @inbounds while ii <= n
+            dst[ii] = f(x[ii], zero(Ty)); ii += 1
+        end
+    end
+    return dst
+end
+
+function _binarymap{Tx,Ty}(f::BinaryOp,
+                           x::AbstractSparseVector{Tx},
+                           y::AbstractVector{Ty},
+                           mode::Int)
+
+    0 <= mode <= 2 || throw(ArgumentError("Incorrect mode $mode."))
+    R = typeof(f(zero(Tx), zero(Ty)))
+    n = length(x)
+    length(y) == n || throw(DimensionMismatch())
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    m = length(xnzind)
+
+    dst = Array(R, n)
+    if mode == 0
+        ii = 1
+        @inbounds for i = 1:m
+            j = xnzind[i]
+            while ii < j
+                dst[ii] = zero(R); ii += 1
+            end
+            dst[j] = f(xnzval[i], y[j]); ii += 1
+        end
+        @inbounds while ii <= n
+            dst[ii] = zero(R); ii += 1
+        end
+    else # mode >= 1
+        ii = 1
+        @inbounds for i = 1:m
+            j = xnzind[i]
+            while ii < j
+                dst[ii] = f(zero(Tx), y[ii]); ii += 1
+            end
+            dst[j] = f(xnzval[i], y[j]); ii += 1
+        end
+        @inbounds while ii <= n
+            dst[ii] = f(zero(Tx), y[ii]); ii += 1
+        end
+    end
+    return dst
+end
+
+
+### Binary arithmetics: +, -, *
+
+for (vop, fun, mode) in [(:_vadd, :AddFun, 1),
+                         (:_vsub, :SubFun, 1),
+                         (:_vmul, :MulFun, 0)]
+    @eval begin
+        $(vop)(x::AbstractSparseVector, y::AbstractSparseVector) = _binarymap($(fun)(), x, y, $mode)
+        $(vop)(x::StridedVector, y::AbstractSparseVector) = _binarymap($(fun)(), x, y, $mode)
+        $(vop)(x::AbstractSparseVector, y::StridedVector) = _binarymap($(fun)(), x, y, $mode)
+    end
+end
+
+# to workaround the ambiguities with BitVector
+.*(x::BitVector, y::AbstractSparseVector{Bool}) = _vmul(x, y)
+.*(x::AbstractSparseVector{Bool}, y::BitVector) = _vmul(x, y)
+
+# definition of operators
+
+for (op, vop) in [(:+, :_vadd), (:(.+), :_vadd),
+                  (:-, :_vsub), (:(.-), :_vsub),
+                  (:.*, :_vmul)]
+    @eval begin
+        $(op)(x::AbstractSparseVector, y::AbstractSparseVector) = $(vop)(x, y)
+        $(op)(x::StridedVector, y::AbstractSparseVector) = $(vop)(x, y)
+        $(op)(x::AbstractSparseVector, y::StridedVector) = $(vop)(x, y)
+    end
+end
+
+# definition of other binary functions
+
+for (op, fun, TF, mode) in [(:max, :MaxFun, :Real, 2),
+                            (:min, :MinFun, :Real, 2),
+                            (:complex, :ComplexFun, :Real, 1)]
+    @eval begin
+        $(op){Tx<:$(TF),Ty<:$(TF)}(x::AbstractSparseVector{Tx}, y::AbstractSparseVector{Ty}) =
+            _binarymap($(fun)(), x, y, $mode)
+        $(op){Tx<:$(TF),Ty<:$(TF)}(x::StridedVector{Tx}, y::AbstractSparseVector{Ty}) =
+            _binarymap($(fun)(), x, y, $mode)
+        $(op){Tx<:$(TF),Ty<:$(TF)}(x::AbstractSparseVector{Tx}, y::StridedVector{Ty}) =
+            _binarymap($(fun)(), x, y, $mode)
+    end
+end
+
+### Reduction
+
+sum(x::AbstractSparseVector) = sum(nonzeros(x))
+sumabs(x::AbstractSparseVector) = sumabs(nonzeros(x))
+sumabs2(x::AbstractSparseVector) = sumabs2(nonzeros(x))
+
+function maximum{T<:Real}(x::AbstractSparseVector{T})
+    n = length(x)
+    n > 0 || throw(ArgumentError("maximum over empty array is not allowed."))
+    m = nnz(x)
+    (m == 0 ? zero(T) :
+     m == n ? maximum(nonzeros(x)) :
+     max(zero(T), maximum(nonzeros(x))))::T
+end
+
+function minimum{T<:Real}(x::AbstractSparseVector{T})
+    n = length(x)
+    n > 0 || throw(ArgumentError("minimum over empty array is not allowed."))
+    m = nnz(x)
+    (m == 0 ? zero(T) :
+     m == n ? minimum(nonzeros(x)) :
+     min(zero(T), minimum(nonzeros(x))))::T
+end
+
+maxabs{T<:Number}(x::AbstractSparseVector{T}) = maxabs(nonzeros(x))
+minabs{T<:Number}(x::AbstractSparseVector{T}) = nnz(x) < length(x) ? abs(zero(T)) : minabs(nonzeros(x))
+
+vecnorm(x::AbstractSparseVector, p::Real=2) = vecnorm(nonzeros(x), p)
+
+### linalg.jl
+
+# Transpose
+# (The only sparse matrix structure in base is CSC, so a one-row sparse matrix is worse than dense)
+transpose(x::SparseVector) = _ct(IdFun(), x)
+ctranspose(x::SparseVector) = _ct(ConjFun(), x)
+function _ct{T}(f, x::SparseVector{T})
+    isempty(x) && return Array(T, 1, 0)
+    A = zeros(T, 1, length(x))
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    for (i,v) in zip(xnzind, xnzval)
+        @inbounds A[i] = f(v)
+    end
+    A
+end
+
+### BLAS Level-1
+
+# axpy
+
+function LinAlg.axpy!(a::Number, x::AbstractSparseVector, y::StridedVector)
+    length(x) == length(y) || throw(DimensionMismatch())
+    nzind = nonzeroinds(x)
+    nzval = nonzeros(x)
+    m = length(nzind)
+
+    if a == one(a)
+        for i = 1:m
+            @inbounds ii = nzind[i]
+            @inbounds v = nzval[i]
+            y[ii] += v
+        end
+    elseif a == -one(a)
+        for i = 1:m
+            @inbounds ii = nzind[i]
+            @inbounds v = nzval[i]
+            y[ii] -= v
+        end
+    else
+        for i = 1:m
+            @inbounds ii = nzind[i]
+            @inbounds v = nzval[i]
+            y[ii] += a * v
+        end
+    end
+    return y
+end
+
+
+# scale
+
+scale!(x::AbstractSparseVector, a::Real) = (scale!(nonzeros(x), a); x)
+scale!(x::AbstractSparseVector, a::Complex) = (scale!(nonzeros(x), a); x)
+scale!(a::Real, x::AbstractSparseVector) = scale!(nonzeros(x), a)
+scale!(a::Complex, x::AbstractSparseVector) = scale!(nonzeros(x), a)
+
+# *(x::AbstractSparseVector, a::Real) = SparseVector(length(x), copy(nonzeroinds(x)), scale(nonzeros(x), a))
+# *(x::AbstractSparseVector, a::Complex) = SparseVector(length(x), copy(nonzeroinds(x)), scale(nonzeros(x), a))
+# *(a::Number, x::AbstractSparseVector) = xa)
+# .*(x::AbstractSparseVector, a::Number) = scale(x, a)
+# .*(a::Number, x::AbstractSparseVector) = scale(x, a)
+
+
+# dot
+
+function dot{Tx<:Number,Ty<:Number}(x::StridedVector{Tx}, y::AbstractSparseVector{Ty})
+    n = length(x)
+    length(y) == n || throw(DimensionMismatch())
+    nzind = nonzeroinds(y)
+    nzval = nonzeros(y)
+    s = zero(Tx) * zero(Ty)
+    for i = 1:length(nzind)
+        s += conj(x[nzind[i]]) * nzval[i]
+    end
+    return s
+end
+
+function dot{Tx<:Number,Ty<:Number}(x::AbstractSparseVector{Tx}, y::AbstractVector{Ty})
+    n = length(y)
+    length(x) == n || throw(DimensionMismatch())
+    nzind = nonzeroinds(x)
+    nzval = nonzeros(x)
+    s = zero(Tx) * zero(Ty)
+    for i = 1:length(nzind)
+        s += conj(nzval[i]) * y[nzind[i]]
+    end
+    return s
+end
+
+function _spdot(f::BinaryOp,
+                xj::Int, xj_last::Int, xnzind, xnzval,
+                yj::Int, yj_last::Int, ynzind, ynzval)
+    # dot product between ranges of non-zeros,
+    s = zero(eltype(xnzval)) * zero(eltype(ynzval))
+    @inbounds while xj <= xj_last && yj <= yj_last
+        ix = xnzind[xj]
+        iy = ynzind[yj]
+        if ix == iy
+            s += f(xnzval[xj], ynzval[yj])
+            xj += 1
+            yj += 1
+        elseif ix < iy
+            xj += 1
+        else
+            yj += 1
+        end
+    end
+    s
+end
+
+function dot{Tx<:Number,Ty<:Number}(x::AbstractSparseVector{Tx}, y::AbstractSparseVector{Ty})
+    is(x, y) && return sumabs2(x)
+    n = length(x)
+    length(y) == n || throw(DimensionMismatch())
+
+    xnzind = nonzeroinds(x)
+    ynzind = nonzeroinds(y)
+    xnzval = nonzeros(x)
+    ynzval = nonzeros(y)
+
+    _spdot(DotFun(),
+           1, length(xnzind), xnzind, xnzval,
+           1, length(ynzind), ynzind, ynzval)
+end
+
+
+### BLAS-2 / dense A * sparse x -> dense y
+
+# A_mul_B
+
+function *{Ta,Tx}(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx})
+    m, n = size(A)
+    length(x) == n || throw(DimensionMismatch())
+    Ty = promote_type(Ta, Tx)
+    y = Array(Ty, m)
+    A_mul_B!(y, A, x)
+end
+
+A_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) =
+    A_mul_B!(one(Tx), A, x, zero(Ty), y)
+
+function A_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector)
+    m, n = size(A)
+    length(x) == n && length(y) == m || throw(DimensionMismatch())
+    m == 0 && return y
+    if β != one(β)
+        β == zero(β) ? fill!(y, zero(eltype(y))) : scale!(y, β)
+    end
+    α == zero(α) && return y
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    @inbounds for i = 1:length(xnzind)
+        v = xnzval[i]
+        if v != zero(v)
+            j = xnzind[i]
+            αv = v * α
+            for r = 1:m
+                y[r] += A[r,j] * αv
+            end
+        end
+    end
+    return y
+end
+
+# At_mul_B
+
+function At_mul_B{Ta,Tx}(A::StridedMatrix{Ta}, x::AbstractSparseVector{Tx})
+    m, n = size(A)
+    length(x) == m || throw(DimensionMismatch())
+    Ty = promote_type(Ta, Tx)
+    y = Array(Ty, n)
+    At_mul_B!(y, A, x)
+end
+
+At_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::StridedMatrix, x::AbstractSparseVector{Tx}) =
+    At_mul_B!(one(Tx), A, x, zero(Ty), y)
+
+function At_mul_B!(α::Number, A::StridedMatrix, x::AbstractSparseVector, β::Number, y::StridedVector)
+    m, n = size(A)
+    length(x) == m && length(y) == n || throw(DimensionMismatch())
+    n == 0 && return y
+    if β != one(β)
+        β == zero(β) ? fill!(y, zero(eltype(y))) : scale!(y, β)
+    end
+    α == zero(α) && return y
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    _nnz = length(xnzind)
+    _nnz == 0 && return y
+
+    s0 = zero(eltype(A)) * zero(eltype(x))
+    @inbounds for j = 1:n
+        s = zero(s0)
+        for i = 1:_nnz
+            s += A[xnzind[i], j] * xnzval[i]
+        end
+        y[j] += s * α
+    end
+    return y
+end
+
+
+### BLAS-2 / sparse A * sparse x -> dense y
+
+function densemv(A::SparseMatrixCSC, x::AbstractSparseVector; trans::Char='N')
+    xlen::Int
+    ylen::Int
+    m, n = size(A)
+    if trans == 'N' || trans == 'n'
+        xlen = n; ylen = m
+    elseif trans == 'T' || trans == 't' || trans == 'C' || trans == 'c'
+        xlen = m; ylen = n
+    else
+        throw(ArgumentError("Invalid trans character $trans"))
+    end
+    xlen == length(x) || throw(DimensionMismatch())
+    T = promote_type(eltype(A), eltype(x))
+    y = Array(T, ylen)
+    if trans == 'N' || trans == 'N'
+        A_mul_B!(y, A, x)
+    elseif trans == 'T' || trans == 't'
+        At_mul_B!(y, A, x)
+    elseif trans == 'C' || trans == 'c'
+        Ac_mul_B!(y, A, x)
+    else
+        throw(ArgumentError("Invalid trans character $trans"))
+    end
+    y
+end
+
+# A_mul_B
+
+A_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) =
+    A_mul_B!(one(Tx), A, x, zero(Ty), y)
+
+function A_mul_B!(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector, β::Number, y::StridedVector)
+    m, n = size(A)
+    length(x) == n && length(y) == m || throw(DimensionMismatch())
+    m == 0 && return y
+    if β != one(β)
+        β == zero(β) ? fill!(y, zero(eltype(y))) : scale!(y, β)
+    end
+    α == zero(α) && return y
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    Acolptr = A.colptr
+    Arowval = A.rowval
+    Anzval = A.nzval
+
+    @inbounds for i = 1:length(xnzind)
+        v = xnzval[i]
+        if v != zero(v)
+            αv = v * α
+            j = xnzind[i]
+            for r = A.colptr[j]:(Acolptr[j+1]-1)
+                y[Arowval[r]] += Anzval[r] * αv
+            end
+        end
+    end
+    return y
+end
+
+# At_mul_B
+
+At_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) =
+    At_mul_B!(one(Tx), A, x, zero(Ty), y)
+
+At_mul_B!{Tx,Ty}(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}, β::Number, y::StridedVector{Ty}) =
+    _At_or_Ac_mul_B!(MulFun(), α, A, x, β, y)
+
+Ac_mul_B!{Tx,Ty}(y::StridedVector{Ty}, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}) =
+    Ac_mul_B!(one(Tx), A, x, zero(Ty), y)
+
+Ac_mul_B!{Tx,Ty}(α::Number, A::SparseMatrixCSC, x::AbstractSparseVector{Tx}, β::Number, y::StridedVector{Ty}) =
+    _At_or_Ac_mul_B!(DotFun(), α, A, x, β, y)
+
+function _At_or_Ac_mul_B!{Tx,Ty}(tfun::BinaryOp,
+                                 α::Number, A::SparseMatrixCSC, x::AbstractSparseVector{Tx},
+                                 β::Number, y::StridedVector{Ty})
+    m, n = size(A)
+    length(x) == m && length(y) == n || throw(DimensionMismatch())
+    n == 0 && return y
+    if β != one(β)
+        β == zero(β) ? fill!(y, zero(eltype(y))) : scale!(y, β)
+    end
+    α == zero(α) && return y
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    Acolptr = A.colptr
+    Arowval = A.rowval
+    Anzval = A.nzval
+    mx = length(xnzind)
+
+    for j = 1:n
+        # s <- dot(A[:,j], x)
+        s = _spdot(tfun, Acolptr[j], Acolptr[j+1]-1, Arowval, Anzval,
+                   1, mx, xnzind, xnzval)
+        @inbounds y[j] += s * α
+    end
+    return y
+end
+
+
+### BLAS-2 / sparse A * sparse x -> dense y
+
+function *(A::SparseMatrixCSC, x::AbstractSparseVector)
+    y = densemv(A, x)
+    initcap = min(nnz(A), size(A,1))
+    _dense2sparsevec(y, initcap)
+end
+
+At_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) =
+    _At_or_Ac_mul_B(MulFun(), A, x)
+
+Ac_mul_B(A::SparseMatrixCSC, x::AbstractSparseVector) =
+    _At_or_Ac_mul_B(DotFun(), A, x)
+
+function _At_or_Ac_mul_B{TvA,TiA,TvX,TiX}(tfun::BinaryOp, A::SparseMatrixCSC{TvA,TiA}, x::AbstractSparseVector{TvX,TiX})
+    m, n = size(A)
+    length(x) == m || throw(DimensionMismatch())
+    Tv = promote_type(TvA, TvX)
+    Ti = promote_type(TiA, TiX)
+
+    xnzind = nonzeroinds(x)
+    xnzval = nonzeros(x)
+    Acolptr = A.colptr
+    Arowval = A.rowval
+    Anzval = A.nzval
+    mx = length(xnzind)
+
+    ynzind = Array(Ti, n)
+    ynzval = Array(Tv, n)
+
+    jr = 0
+    for j = 1:n
+        s = _spdot(tfun, Acolptr[j], Acolptr[j+1]-1, Arowval, Anzval,
+                   1, mx, xnzind, xnzval)
+        if s != zero(s)
+            jr += 1
+            ynzind[jr] = j
+            ynzval[jr] = s
+        end
+    end
+    if jr < n
+        resize!(ynzind, jr)
+        resize!(ynzval, jr)
+    end
+    SparseVector(n, ynzind, ynzval)
+end
+
+
+# define matrix division operations involving triangular matrices and sparse vectors
+# the valid left-division operations are A[t|c]_ldiv_B[!] and \
+# the valid right-division operations are A(t|c)_rdiv_B[t|c][!]
+# see issue #14005 for discussion of these methods
+for isunittri in (true, false), islowertri in (true, false)
+    unitstr = isunittri ? "Unit" : ""
+    halfstr = islowertri ? "Lower" : "Upper"
+    tritype = :(Base.LinAlg.$(symbol(string(unitstr, halfstr, "Triangular"))))
+
+    # build out-of-place left-division operations
+    for (istrans, func, ipfunc) in (
+        (false, :(\),         :(A_ldiv_B!)),
+        (true,  :(At_ldiv_B), :(At_ldiv_B!)),
+        (true,  :(Ac_ldiv_B), :(Ac_ldiv_B!)) )
+
+        # broad method where elements are Numbers
+        @eval function ($func){TA<:Number,Tb<:Number,S}(A::$tritype{TA,S}, b::SparseVector{Tb})
+            TAb = $(isunittri ?
+                :(typeof(zero(TA)*zero(Tb) + zero(TA)*zero(Tb))) :
+                :(typeof((zero(TA)*zero(Tb) + zero(TA)*zero(Tb))/one(TA))) )
+            ($ipfunc)(convert(AbstractArray{TAb}, A), convert(Array{TAb}, b))
+        end
+
+        # faster method requiring good view support of the
+        # triangular matrix type. hence the StridedMatrix restriction.
+        @eval function ($func){TA<:Number,Tb<:Number,S<:StridedMatrix}(A::$tritype{TA,S}, b::SparseVector{Tb})
+            TAb = $(isunittri ?
+                :(typeof(zero(TA)*zero(Tb) + zero(TA)*zero(Tb))) :
+                :(typeof((zero(TA)*zero(Tb) + zero(TA)*zero(Tb))/one(TA))) )
+            r = convert(Array{TAb}, b)
+            # this operation involves only b[nzrange], so we extract
+            # and operate on solely that section for efficiency
+            nzrange = $( (islowertri && !istrans) || (!islowertri && istrans) ?
+                :(b.nzind[1]:b.n) :
+                :(1:b.nzind[end]) )
+            nzrangeviewr = sub(r, nzrange)
+            nzrangeviewA = $tritype(sub(A.data, nzrange, nzrange))
+            ($ipfunc)(convert(AbstractArray{TAb}, nzrangeviewA), nzrangeviewr)
+            r
+        end
+
+        # fallback where elements are not Numbers
+        @eval ($func){TA,Tb,S}(A::$tritype{TA,S}, b::SparseVector{Tb}) = ($ipfunc)(A, copy(b))
+    end
+
+    # build in-place left-division operations
+    for (istrans, func) in (
+        (false, :(A_ldiv_B!)),
+        (true,  :(At_ldiv_B!)),
+        (true,  :(Ac_ldiv_B!)) )
+
+        # the generic in-place left-division methods handle these cases, but
+        # we can achieve greater efficiency where the triangular matrix provides
+        # good view support. hence the StridedMatrix restriction.
+        @eval function ($func){TA,Tb,S<:StridedMatrix}(A::$tritype{TA,S}, b::SparseVector{Tb})
+            # densify the relevant part of b in one shot rather
+            # than potentially repeatedly reallocating during the solve
+            $( (islowertri && !istrans) || (!islowertri && istrans) ?
+                :(_densifyfirstnztoend!(b)) :
+                :(_densifystarttolastnz!(b)) )
+            # this operation involves only the densified section, so
+            # for efficiency we extract and operate on solely that section
+            # furthermore we operate on that section as a dense vector
+            # such that dispatch has a chance to exploit, e.g., tuned BLAS
+            nzrange = $( (islowertri && !istrans) || (!islowertri && istrans) ?
+                :(b.nzind[1]:b.n) :
+                :(1:b.nzind[end]) )
+            nzrangeviewbnz = sub(b.nzval, nzrange - b.nzind[1] + 1)
+            nzrangeviewA = $tritype(sub(A.data, nzrange, nzrange))
+            ($func)(nzrangeviewA, nzrangeviewbnz)
+            # could strip any miraculous zeros here perhaps
+            b
+        end
+    end
+end
+
+# helper functions for in-place matrix division operations defined above
+"Densifies `x::SparseVector` from its first nonzero (`x[x.nzind[1]]`) through its end (`x[x.n]`)."
+function _densifyfirstnztoend!(x::SparseVector)
+    # lengthen containers
+    oldnnz = nnz(x)
+    newnnz = x.n - x.nzind[1] + 1
+    resize!(x.nzval, newnnz)
+    resize!(x.nzind, newnnz)
+    # redistribute nonzero values over lengthened container
+    # initialize now-allocated zero values simultaneously
+    nextpos = newnnz
+    @inbounds for oldpos in oldnnz:-1:1
+        nzi = x.nzind[oldpos]
+        nzv = x.nzval[oldpos]
+        newpos = nzi - x.nzind[1] + 1
+        newpos < nextpos && (x.nzval[newpos+1:nextpos] = 0)
+        newpos == oldpos && break
+        x.nzval[newpos] = nzv
+        nextpos = newpos - 1
+    end
+    # finally update lengthened nzinds
+    x.nzind[2:end] = (x.nzind[1]+1):x.n
+    x
+end
+"Densifies `x::SparseVector` from its beginning (`x[1]`) through its last nonzero (`x[x.nzind[end]]`)."
+function _densifystarttolastnz!(x::SparseVector)
+    # lengthen containers
+    oldnnz = nnz(x)
+    newnnz = x.nzind[end]
+    resize!(x.nzval, newnnz)
+    resize!(x.nzind, newnnz)
+    # redistribute nonzero values over lengthened container
+    # initialize now-allocated zero values simultaneously
+    nextpos = newnnz
+    @inbounds for oldpos in oldnnz:-1:1
+        nzi = x.nzind[oldpos]
+        nzv = x.nzval[oldpos]
+        nzi < nextpos && (x.nzval[nzi+1:nextpos] = 0)
+        nzi == oldpos && (nextpos = 0; break)
+        x.nzval[nzi] = nzv
+        nextpos = nzi - 1
+    end
+    nextpos > 0 && (x.nzval[1:nextpos] = 0)
+    # finally update lengthened nzinds
+    x.nzind[1:newnnz] = 1:newnnz
+    x
+end
+
+#sorting
+function sort{Tv,Ti}(x::SparseVector{Tv,Ti}; kws...)
+    allvals = push!(copy(nonzeros(x)),zero(Tv))
+    sinds = sortperm(allvals;kws...)
+    n,k = length(x),length(allvals)
+    z = findfirst(sinds,k)
+    newnzind = collect(Ti,1:k-1)
+    newnzind[z:end]+= n-k+1
+    newnzvals = allvals[deleteat!(sinds[1:k],z)]
+    SparseVector(n,newnzind,newnzvals)
+end
diff --git a/base/sparse/spqr.jl b/base/sparse/spqr.jl
index aa32492695213..970f85bd427b4 100644
--- a/base/sparse/spqr.jl
+++ b/base/sparse/spqr.jl
@@ -38,16 +38,14 @@ const RTX_EQUALS_B   = Int32(2) # solve R'*X=B     or X = R'\B
 const RTX_EQUALS_ETB = Int32(3) # solve R'*X=E'*B  or X = R'\(E'*B)
 
 
-using Base.SparseMatrix: SparseMatrixCSC
-using Base.SparseMatrix.CHOLMOD: C_Dense, C_Sparse, Dense, ITypes, Sparse, VTypes, common
+using ..SparseArrays: SparseMatrixCSC
+using ..SparseArrays.CHOLMOD: C_Dense, C_Sparse, Dense, ITypes, Sparse, SuiteSparseStruct, VTypes, common
 
 import Base: size
 import Base.LinAlg: qrfact
-import Base.SparseMatrix.CHOLMOD: convert, free!
+import ..SparseArrays.CHOLMOD: convert, free!
 
-
-
-immutable C_Factorization{Tv<:VTypes}
+immutable C_Factorization{Tv<:VTypes} <: SuiteSparseStruct
     xtype::Cint
     factors::Ptr{Tv}
 end
@@ -91,7 +89,7 @@ function backslash{Tv<:VTypes}(ordering::Integer, tol::Real, A::Sparse{Tv}, B::D
     end
     d = Dense(ccall((:SuiteSparseQR_C_backslash, :libspqr), Ptr{C_Dense{Tv}},
         (Cint, Cdouble, Ptr{C_Sparse{Tv}}, Ptr{C_Dense{Tv}}, Ptr{Void}),
-            ordering, tol, A.p, B.p, common()))
+            ordering, tol, get(A.p), get(B.p), common()))
     finalizer(d, free!)
     d
 end
@@ -103,7 +101,7 @@ function factorize{Tv<:VTypes}(ordering::Integer, tol::Real, A::Sparse{Tv})
     end
     f = Factorization(size(A)..., ccall((:SuiteSparseQR_C_factorize, :libspqr), Ptr{C_Factorization{Tv}},
         (Cint, Cdouble, Ptr{Sparse{Tv}}, Ptr{Void}),
-            ordering, tol, A.p, common()))
+            ordering, tol, get(A.p), common()))
     finalizer(f, free!)
     f
 end
@@ -118,7 +116,7 @@ function solve{Tv<:VTypes}(system::Integer, QR::Factorization{Tv}, B::Dense{Tv})
     end
     d = Dense(ccall((:SuiteSparseQR_C_solve, :libspqr), Ptr{C_Dense{Tv}},
         (Cint, Ptr{C_Factorization{Tv}}, Ptr{C_Dense{Tv}}, Ptr{Void}),
-            system, QR.p, B.p, common()))
+            system, get(QR.p), get(B.p), common()))
     finalizer(d, free!)
     d
 end
@@ -133,17 +131,33 @@ function qmult{Tv<:VTypes}(method::Integer, QR::Factorization{Tv}, X::Dense{Tv})
     end
     d = Dense(ccall((:SuiteSparseQR_C_qmult, :libspqr), Ptr{C_Dense{Tv}},
             (Cint, Ptr{C_Factorization{Tv}}, Ptr{C_Dense{Tv}}, Ptr{Void}),
-                method, QR.p, X.p, common()))
+                method, get(QR.p), get(X.p), common()))
     finalizer(d, free!)
     d
 end
 
-qrfact(A::SparseMatrixCSC) = factorize(ORDERING_DEFAULT, DEFAULT_TOL, Sparse(A, 0))
-
-function (\){T}(F::Factorization{T}, B::StridedVecOrMat{T})
+qrfact(A::SparseMatrixCSC, ::Type{Val{true}}) = factorize(ORDERING_DEFAULT, DEFAULT_TOL, Sparse(A, 0))
+qrfact(A::SparseMatrixCSC) = qrfact(A, Val{true})
+
+# With a real lhs and complex rhs with the same precision, we can reinterpret
+# the complex rhs as a real rhs with twice the number of columns
+#
+# This definition is similar to the definition in factorization.jl except the we here have to use
+# \ instead of A_ldiv_B! because of limitations in SPQR
+function (\)(F::Factorization{Float64}, B::StridedVector{Complex{Float64}})
+    c2r = reshape(transpose(reinterpret(Float64, B, (2, length(B)))), size(B, 1), 2*size(B, 2))
+    x = F\c2r
+    return reinterpret(Complex{Float64}, transpose(reshape(x, div(length(x), 2), 2)), (size(F,2),))
+end
+function (\)(F::Factorization{Float64}, B::StridedMatrix{Complex{Float64}})
+    c2r = reshape(transpose(reinterpret(Float64, B, (2, length(B)))), size(B, 1), 2*size(B, 2))
+    x = F\c2r
+    return reinterpret(Complex{Float64}, transpose(reshape(x, div(length(x), 2), 2)), (size(F,2), size(B,2)))
+end
+function (\){T<:VTypes}(F::Factorization{T}, B::StridedVecOrMat{T})
     QtB = qmult(QTX, F, Dense(B))
     convert(typeof(B), solve(RETX_EQUALS_B, F, QtB))
 end
-(\){T,S}(F::Factorization{T}, B::StridedVecOrMat{S}) = F\convert(AbstractArray{T}, B)
+(\)(F::Factorization, B::StridedVecOrMat) = F\convert(AbstractArray{eltype(F)}, B)
 
 end # module
diff --git a/base/sparse/umfpack.jl b/base/sparse/umfpack.jl
index b36cfced934e1..1b21a512d298c 100644
--- a/base/sparse/umfpack.jl
+++ b/base/sparse/umfpack.jl
@@ -7,50 +7,50 @@ export UmfpackLU
 import Base: (\), Ac_ldiv_B, At_ldiv_B, findnz, getindex, show, size
 import Base.LinAlg: A_ldiv_B!, Ac_ldiv_B!, At_ldiv_B!, Factorization, det, lufact
 
-importall Base.SparseMatrix
-import Base.SparseMatrix: increment, increment!, decrement, decrement!, nnz
+importall ..SparseArrays
+import ..SparseArrays: increment, increment!, decrement, decrement!, nnz
 
 include("umfpack_h.jl")
 type MatrixIllConditionedException <: Exception
-    message :: AbstractString
+    message::AbstractString
 end
 
 function umferror(status::Integer)
-     if status==UMFPACK_OK
-         return
-     elseif status==UMFPACK_WARNING_singular_matrix
-         throw(MatrixIllConditionedException("singular matrix"))
-     elseif status==UMFPACK_WARNING_determinant_underflow
-         throw(MatrixIllConditionedException("the determinant is nonzero but underflowed"))
-     elseif status==UMFPACK_WARNING_determinant_overflow
-         throw(MatrixIllConditionedException("the determinant overflowed"))
-     elseif status==UMFPACK_ERROR_out_of_memory
-         throw(OutOfMemoryError())
-     elseif status==UMFPACK_ERROR_invalid_Numeric_object
-         throw(ArgumentError("invalid UMFPack numeric object"))
-     elseif status==UMFPACK_ERROR_invalid_Symbolic_object
-         throw(ArgumentError("invalid UMFPack symbolic object"))
-     elseif status==UMFPACK_ERROR_argument_missing
-         throw(ArgumentError("a required argument to UMFPack is missing"))
-     elseif status==UMFPACK_ERROR_n_nonpositive
-         throw(BoundsError("the number of rows or columns of the matrix must be greater than zero"))
-     elseif status==UMFPACK_ERROR_invalid_matrix
-         throw(ArgumentError("invalid matrix"))
-     elseif status==UMFPACK_ERROR_different_pattern
-         throw(ArgumentError("pattern of the matrix changed"))
-     elseif status==UMFPACK_ERROR_invalid_system
-         throw(ArgumentError("invalid sys argument provided to UMFPack solver"))
-     elseif status==UMFPACK_ERROR_invalid_permutation
-         throw(ArgumentError("invalid permutation"))
-     elseif status==UMFPACK_ERROR_file_IO
-         throw(ErrorException("error saving / loading UMFPack decomposition"))
-     elseif status==UMFPACK_ERROR_ordering_failed
-         throw(ErrorException("the ordering method failed"))
-     elseif status==UMFPACK_ERROR_internal_error
-         throw(ErrorException("an internal error has occurred, of unknown cause"))
-     else
-         throw(ErrorException("unknown UMFPack error code: $status"))
-     end
+    if status==UMFPACK_OK
+        return
+    elseif status==UMFPACK_WARNING_singular_matrix
+        throw(LinAlg.SingularException(0))
+    elseif status==UMFPACK_WARNING_determinant_underflow
+        throw(MatrixIllConditionedException("the determinant is nonzero but underflowed"))
+    elseif status==UMFPACK_WARNING_determinant_overflow
+        throw(MatrixIllConditionedException("the determinant overflowed"))
+    elseif status==UMFPACK_ERROR_out_of_memory
+        throw(OutOfMemoryError())
+    elseif status==UMFPACK_ERROR_invalid_Numeric_object
+        throw(ArgumentError("invalid UMFPack numeric object"))
+    elseif status==UMFPACK_ERROR_invalid_Symbolic_object
+        throw(ArgumentError("invalid UMFPack symbolic object"))
+    elseif status==UMFPACK_ERROR_argument_missing
+        throw(ArgumentError("a required argument to UMFPack is missing"))
+    elseif status==UMFPACK_ERROR_n_nonpositive
+        throw(ArgumentError("the number of rows or columns of the matrix must be greater than zero"))
+    elseif status==UMFPACK_ERROR_invalid_matrix
+        throw(ArgumentError("invalid matrix"))
+    elseif status==UMFPACK_ERROR_different_pattern
+        throw(ArgumentError("pattern of the matrix changed"))
+    elseif status==UMFPACK_ERROR_invalid_system
+        throw(ArgumentError("invalid sys argument provided to UMFPack solver"))
+    elseif status==UMFPACK_ERROR_invalid_permutation
+        throw(ArgumentError("invalid permutation"))
+    elseif status==UMFPACK_ERROR_file_IO
+        throw(ErrorException("error saving / loading UMFPack decomposition"))
+    elseif status==UMFPACK_ERROR_ordering_failed
+        throw(ErrorException("the ordering method failed"))
+    elseif status==UMFPACK_ERROR_internal_error
+        throw(ErrorException("an internal error has occurred, of unknown cause"))
+    else
+        throw(ErrorException("unknown UMFPack error code: $status"))
+    end
 end
 
 macro isok(A)
@@ -59,8 +59,8 @@ end
 
 # check the size of SuiteSparse_long
 if Int(ccall((:jl_cholmod_sizeof_long,:libsuitesparse_wrapper),Csize_t,())) == 4
-    const UmfpackIndexTypes = (:Int32, )
-    typealias UMFITypes Union{Int32}
+    const UmfpackIndexTypes = (:Int32,)
+    typealias UMFITypes Int32
 else
     const UmfpackIndexTypes = (:Int32, :Int64)
     typealias UMFITypes Union{Int32, Int64}
@@ -75,22 +75,20 @@ const umf_ctrl = Array(Float64, UMFPACK_CONTROL)
 ccall((:umfpack_dl_defaults,:libumfpack), Void, (Ptr{Float64},), umf_ctrl)
 const umf_info = Array(Float64, UMFPACK_INFO)
 
-function show_umf_ctrl(level::Real)
+function show_umf_ctrl(level::Real = 2.0)
     old_prt::Float64 = umf_ctrl[1]
     umf_ctrl[1] = Float64(level)
     ccall((:umfpack_dl_report_control, :libumfpack), Void, (Ptr{Float64},), umf_ctrl)
     umf_ctrl[1] = old_prt
 end
-show_umf_ctrl() = show_umf_ctrl(2.)
 
-function show_umf_info(level::Real)
+function show_umf_info(level::Real = 2.0)
     old_prt::Float64 = umf_ctrl[1]
     umf_ctrl[1] = Float64(level)
     ccall((:umfpack_dl_report_info, :libumfpack), Void,
           (Ptr{Float64}, Ptr{Float64}), umf_ctrl, umf_info)
     umf_ctrl[1] = old_prt
 end
-show_umf_info() = show_umf_info(2.)
 
 ## Should this type be immutable?
 type UmfpackLU{Tv<:UMFVTypes,Ti<:UMFITypes} <: Factorization{Tv}
@@ -103,6 +101,43 @@ type UmfpackLU{Tv<:UMFVTypes,Ti<:UMFITypes} <: Factorization{Tv}
     nzval::Vector{Tv}
 end
 
+"""
+    lufact(A::SparseMatrixCSC) -> F::UmfpackLU
+
+Compute the LU factorization of a sparse matrix `A`.
+
+For sparse `A` with real or complex element type, the return type of `F` is
+`UmfpackLU{Tv, Ti}`, with `Tv` = `Float64` or `Complex128` respectively and
+`Ti` is an integer type (`Int32` or `Int64`).
+
+The individual components of the factorization `F` can be accessed by indexing:
+
+| Component | Description                         |
+|:----------|:------------------------------------|
+| `F[:L]`   | `L` (lower triangular) part of `LU` |
+| `F[:U]`   | `U` (upper triangular) part of `LU` |
+| `F[:p]`   | right permutation `Vector`          |
+| `F[:q]`   | left permutation `Vector`           |
+| `F[:Rs]`  | `Vector` of scaling factors         |
+| `F[:(:)]` | `(L,U,p,q,Rs)` components           |
+
+The relation between `F` and `A` is
+
+`F[:L]*F[:U] == (F[:Rs] .* A)[F[:p], F[:q]]`
+
+`F` further supports the following functions:
+
+- [`\\`](:func:`\\`)
+- [`cond`](:func:`cond`)
+- [`det`](:func:`det`)
+
+** Implementation note **
+
+`lufact(A::SparseMatrixCSC)` uses the UMFPACK library that is part of
+SuiteSparse. As this library only supports sparse matrices with `Float64` or
+`Complex128` elements, `lufact` converts `A` into a copy that is of type
+`SparseMatrixCSC{Float64}` or `SparseMatrixCSC{Complex128}` as appropriate.
+"""
 function lufact{Tv<:UMFVTypes,Ti<:UMFITypes}(S::SparseMatrixCSC{Tv,Ti})
 
     zerobased = S.colptr[1] == 0
@@ -113,11 +148,35 @@ function lufact{Tv<:UMFVTypes,Ti<:UMFITypes}(S::SparseMatrixCSC{Tv,Ti})
     finalizer(res, umfpack_free_symbolic)
     umfpack_numeric!(res)
 end
+lufact{Tv<:Union{Float16,Float32}, Ti<:UMFITypes}(A::SparseMatrixCSC{Tv,Ti}) =
+    lufact(convert(SparseMatrixCSC{Float64,Ti}, A))
+lufact{Tv<:Union{Complex32,Complex64}, Ti<:UMFITypes}(A::SparseMatrixCSC{Tv,Ti}) =
+    lufact(convert(SparseMatrixCSC{Complex128,Ti}, A))
+lufact{T<:AbstractFloat}(A::Union{SparseMatrixCSC{T},SparseMatrixCSC{Complex{T}}}) =
+    throw(ArgumentError(string("matrix type ", typeof(A), "not supported. ",
+    "Try lufact(convert(SparseMatrixCSC{Float64/Complex128,Int}, A)) for ",
+    "sparse floating point LU using UMFPACK or lufact(full(A)) for generic ",
+    "dense LU.")))
 lufact(A::SparseMatrixCSC) = lufact(float(A))
+lufact(A::SparseMatrixCSC, pivot::Type{Val{false}}) = lufact(A)
+
+
+size(F::UmfpackLU) = (F.m, F.n)
+function size(F::UmfpackLU, dim::Integer)
+    if dim < 1
+        throw(ArgumentError("size: dimension $dim out of range"))
+    elseif dim == 1
+        return Int(F.m)
+    elseif dim == 2
+        return Int(F.n)
+    else
+        return 1
+    end
+end
 
-function show(io::IO, f::UmfpackLU)
-    println(io, "UMFPACK LU Factorization of a $(f.m)-by-$(f.n) sparse matrix")
-    f.numeric != C_NULL && println(f.numeric)
+function show(io::IO, F::UmfpackLU)
+    println(io, "UMFPACK LU Factorization of a $(size(F)) sparse matrix")
+    F.numeric != C_NULL && println(io, F.numeric)
 end
 
 ## Wrappers for UMFPACK functions
@@ -170,8 +229,9 @@ for itype in UmfpackIndexTypes
                             Ptr{Float64}, Ptr{Float64}),
                            U.colptr, U.rowval, U.nzval, U.symbolic, tmp,
                            umf_ctrl, umf_info)
-            status > 0 && throw(MatrixIllConditionedException(""))
-            umferror(status)
+            if status != UMFPACK_WARNING_singular_matrix
+                umferror(status)
+            end
             U.numeric = tmp[1]
             return U
         end
@@ -184,8 +244,9 @@ for itype in UmfpackIndexTypes
                             Ptr{Float64}, Ptr{Float64}),
                            U.colptr, U.rowval, real(U.nzval), imag(U.nzval), U.symbolic, tmp,
                            umf_ctrl, umf_info)
-            status > 0 && throw(MatrixIllConditionedException(""))
-            umferror(status)
+            if status != UMFPACK_WARNING_singular_matrix
+                umferror(status)
+            end
             U.numeric = tmp[1]
             return U
         end
@@ -395,7 +456,6 @@ for Tv in (:Float64, :Complex128), Ti in UmfpackIndexTypes
         end
     end
 end
-show_umf_info() = show_umf_info(2.)
 
 function umfpack_report_symbolic(symb::Ptr{Void}, level::Real)
     old_prl::Float64 = umf_ctrl[UMFPACK_PRL]
diff --git a/base/special/bessel.jl b/base/special/bessel.jl
index f4248b70f93ae..dc77627492e94 100644
--- a/base/special/bessel.jl
+++ b/base/special/bessel.jl
@@ -1,32 +1,11 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-for jy in ("j","y"), nu in (0,1)
-    jynu = Expr(:quote, symbol(jy,nu))
-    jynuf = Expr(:quote, symbol(jy,nu,"f"))
-    bjynu = symbol("bessel",jy,nu)
-    if jy == "y"
-        @eval begin
-            $bjynu(x::Float64) = nan_dom_err(ccall(($jynu,libm),  Float64, (Float64,), x), x)
-            $bjynu(x::Float32) = nan_dom_err(ccall(($jynuf,libm), Float32, (Float32,), x), x)
-        end
-    else
-        @eval begin
-            $bjynu(x::Float64) = ccall(($jynu,libm),  Float64, (Float64,), x)
-            $bjynu(x::Float32) = ccall(($jynuf,libm), Float32, (Float32,), x)
-        end
-    end
-    @eval begin
-        $bjynu(x::Real) = $bjynu(float(x))
-        $bjynu(x::Complex) = $(symbol("bessel",jy))($nu,x)
-        @vectorize_1arg Number $bjynu
-    end
-end
-
-
 type AmosException <: Exception
     info::Int32
 end
 
+## Airy functions
+
 let
     const ai::Array{Float64,1} = Array(Float64,2)
     const ae::Array{Int32,1} = Array(Int32,2)
@@ -61,7 +40,7 @@ let
     end
 end
 
-function airy(k::Int, z::Complex128)
+function airy(k::Integer, z::Complex128)
     id = Int32(k==1 || k==3)
     if k == 0 || k == 1
         return _airy(z, id, Int32(1))
@@ -72,8 +51,6 @@ function airy(k::Int, z::Complex128)
     end
 end
 
-airy(z) = airy(0,z)
-@vectorize_1arg Number airy
 airyprime(z) = airy(1,z)
 @vectorize_1arg Number airyprime
 airyai(z) = airy(0,z)
@@ -85,13 +62,7 @@ airybi(z) = airy(2,z)
 airybiprime(z) = airy(3,z)
 @vectorize_1arg Number airybiprime
 
-airy(k::Number, x::AbstractFloat) = oftype(x, real(airy(k, complex(x))))
-airy(k::Number, x::Real) = airy(k, float(x))
-airy(k::Number, z::Complex64) = Complex64(airy(k, Complex128(z)))
-airy(k::Number, z::Complex) = airy(convert(Int,k), Complex128(z))
-@vectorize_2arg Number airy
-
-function airyx(k::Int, z::Complex128)
+function airyx(k::Integer, z::Complex128)
     id = Int32(k==1 || k==3)
     if k == 0 || k == 1
         return _airy(z, id, Int32(2))
@@ -102,14 +73,48 @@ function airyx(k::Int, z::Complex128)
     end
 end
 
-airyx(z) = airyx(0,z)
-@vectorize_1arg Number airyx
+for afn in (:airy,:airyx)
+    @eval begin
+        $afn(k::Integer, z::Complex) = $afn(k, float(z))
+        $afn{T<:AbstractFloat}(k::Integer, z::Complex{T}) = throw(MethodError($afn,(k,z)))
+        $afn(k::Integer, z::Complex64) = Complex64($afn(k, Complex128(z)))
+
+        $afn(k::Integer, x::Real) = $afn(k, float(x))
+        $afn(k::Integer, x::AbstractFloat) = real($afn(k, complex(x)))
+
+        $afn(z) = $afn(0,z)
+        @vectorize_1arg Number $afn
+        @vectorize_2arg Number $afn
+    end
+end
+
+## Bessel functions
+
+# besselj0, besselj1, bessely0, bessely1
+for jy in ("j","y"), nu in (0,1)
+    jynu = Expr(:quote, symbol(jy,nu))
+    jynuf = Expr(:quote, symbol(jy,nu,"f"))
+    bjynu = symbol("bessel",jy,nu)
+    if jy == "y"
+        @eval begin
+            $bjynu(x::Float64) = nan_dom_err(ccall(($jynu,libm),  Float64, (Float64,), x), x)
+            $bjynu(x::Float32) = nan_dom_err(ccall(($jynuf,libm), Float32, (Float32,), x), x)
+        end
+    else
+        @eval begin
+            $bjynu(x::Float64) = ccall(($jynu,libm),  Float64, (Float64,), x)
+            $bjynu(x::Float32) = ccall(($jynuf,libm), Float32, (Float32,), x)
+        end
+    end
+    @eval begin
+        $bjynu(x::Real) = $bjynu(float(x))
+        $bjynu(x::Complex) = $(symbol("bessel",jy))($nu,x)
+        @vectorize_1arg Number $bjynu
+    end
+end
+
+
 
-airyx(k::Number, x::AbstractFloat) = oftype(x, real(airyx(k, complex(x))))
-airyx(k::Number, x::Real) = airyx(k, float(x))
-airyx(k::Number, z::Complex64) = Complex64(airyx(k, Complex128(z)))
-airyx(k::Number, z::Complex) = airyx(convert(Int,k), Complex128(z))
-@vectorize_2arg Number airyx
 
 const cy = Array(Float64,2)
 const ae = Array(Int32,2)
@@ -227,13 +232,9 @@ function besselj(nu::Float64, z::Complex128)
     end
 end
 
-besselj(nu::Integer, x::AbstractFloat) = typemin(Int32) <= nu <= typemax(Int32) ?
-    oftype(x, ccall((:jn, libm), Float64, (Cint, Float64), nu, x)) :
-    besselj(Float64(nu), x)
+besselj(nu::Cint, x::Float64) = ccall((:jn, libm), Float64, (Cint, Float64), nu, x)
+besselj(nu::Cint, x::Float32) = ccall((:jnf, libm), Float32, (Cint, Float32), nu, x)
 
-besselj(nu::Integer, x::Float32) = typemin(Int32) <= nu <= typemax(Int32) ?
-    ccall((:jnf, libm), Float32, (Cint, Float32), nu, x) :
-    besselj(Float64(nu), x)
 
 function besseljx(nu::Float64, z::Complex128)
     if nu < 0
@@ -247,6 +248,19 @@ besselk(nu::Float64, z::Complex128) = _besselk(abs(nu), z, Int32(1))
 
 besselkx(nu::Float64, z::Complex128) = _besselk(abs(nu), z, Int32(2))
 
+function bessely(nu::Cint, x::Float64)
+    if x < 0
+        throw(DomainError())
+    end
+    ccall((:yn, libm), Float64, (Cint, Float64), nu, x)
+end
+function bessely(nu::Cint, x::Float32)
+    if x < 0
+        throw(DomainError())
+    end
+    ccall((:ynf, libm), Float32, (Cint, Float32), nu, x)
+end
+
 function bessely(nu::Float64, z::Complex128)
     if nu < 0
         return _bessely(-nu,z,Int32(1))*cospi(nu) - _besselj(-nu,z,Int32(1))*sinpi(nu)
@@ -263,115 +277,114 @@ function besselyx(nu::Float64, z::Complex128)
     end
 end
 
-besselh(nu, z) = besselh(nu, 1, z)
-besselh(nu::Real, k::Integer, z::Complex64) = Complex64(besselh(Float64(nu), k, Complex128(z)))
-besselh(nu::Real, k::Integer, z::Complex) = besselh(Float64(nu), k, Complex128(z))
-besselh(nu::Real, k::Integer, x::Real) = besselh(Float64(nu), k, Complex128(x))
-@vectorize_2arg Number besselh
-
-hankelh1(nu, z) = besselh(nu, 1, z)
-@vectorize_2arg Number hankelh1
-
-hankelh2(nu, z) = besselh(nu, 2, z)
-@vectorize_2arg Number hankelh2
-
-besselhx(nu::Real, k::Integer, z::Complex64) = Complex64(besselhx(Float64(nu), k, Complex128(z)))
-besselhx(nu::Real, k::Integer, z::Complex) = besselhx(Float64(nu), k, Complex128(z))
-besselhx(nu::Real, k::Integer, x::Real) = besselhx(Float64(nu), k, Complex128(x))
-
-hankelh1x(nu, z) = besselhx(nu, 1, z)
-@vectorize_2arg Number hankelh1x
-
-hankelh2x(nu, z) = besselhx(nu, 2, z)
-@vectorize_2arg Number hankelh2x
 
 function besseli(nu::Real, x::AbstractFloat)
     if x < 0 && !isinteger(nu)
         throw(DomainError())
     end
-    oftype(x, real(besseli(Float64(nu), Complex128(x))))
+    real(besseli(float(nu), complex(x)))
 end
 
 function besselix(nu::Real, x::AbstractFloat)
     if x < 0 && !isinteger(nu)
         throw(DomainError())
     end
-    oftype(x, real(besselix(Float64(nu), Complex128(x))))
+    real(besselix(float(nu), complex(x)))
 end
 
-function besselj(nu::AbstractFloat, x::AbstractFloat)
+function besselj(nu::Real, x::AbstractFloat)
     if isinteger(nu)
-        if typemin(Int32) <= nu <= typemax(Int32)
-            return besselj(Int(nu), x)
+        if typemin(Cint) <= nu <= typemax(Cint)
+            return besselj(Cint(nu), x)
         end
     elseif x < 0
         throw(DomainError())
     end
-    oftype(x, real(besselj(Float64(nu), Complex128(x))))
+    real(besselj(float(nu), complex(x)))
 end
 
 function besseljx(nu::Real, x::AbstractFloat)
     if x < 0 && !isinteger(nu)
         throw(DomainError())
     end
-    oftype(x, real(besseljx(Float64(nu), Complex128(x))))
+    real(besseljx(float(nu), complex(x)))
 end
 
 function besselk(nu::Real, x::AbstractFloat)
     if x < 0
         throw(DomainError())
-    end
-    if x == 0
+    elseif x == 0
         return oftype(x, Inf)
     end
-    oftype(x, real(besselk(Float64(nu), Complex128(x))))
+    real(besselk(float(nu), complex(x)))
 end
 
 function besselkx(nu::Real, x::AbstractFloat)
     if x < 0
         throw(DomainError())
-    end
-    if x == 0
+    elseif x == 0
         return oftype(x, Inf)
     end
-    oftype(x, real(besselkx(Float64(nu), Complex128(x))))
+    real(besselkx(float(nu), complex(x)))
 end
 
 function bessely(nu::Real, x::AbstractFloat)
     if x < 0
         throw(DomainError())
+    elseif isinteger(nu) && typemin(Cint) <= nu <= typemax(Cint)
+        return bessely(Cint(nu), x)
     end
-    if isinteger(nu) && typemin(Int32) <= nu <= typemax(Int32)
-        return bessely(Int(nu), x)
-    end
-    oftype(x, real(bessely(Float64(nu), Complex128(x))))
-end
-function bessely(nu::Integer, x::AbstractFloat)
-    if x < 0
-        throw(DomainError())
-    end
-    return oftype(x, ccall((:yn, libm), Float64, (Cint, Float64), nu, x))
-end
-function bessely(nu::Integer, x::Float32)
-    if x < 0
-        throw(DomainError())
-    end
-    return ccall((:ynf, libm), Float32, (Cint, Float32), nu, x)
+    real(bessely(float(nu), complex(x)))
 end
 
 function besselyx(nu::Real, x::AbstractFloat)
     if x < 0
         throw(DomainError())
     end
-    oftype(x, real(besselyx(Float64(nu), Complex128(x))))
+    real(besselyx(float(nu), complex(x)))
 end
 
 for f in ("i", "ix", "j", "jx", "k", "kx", "y", "yx")
     bfn = symbol("bessel", f)
     @eval begin
-        $bfn(nu::Real, z::Complex64) = Complex64($bfn(Float64(nu), Complex128(z)))
-        $bfn(nu::Real, z::Complex) = $bfn(Float64(nu), Complex128(z))
-        $bfn(nu::Real, x::Integer) = $bfn(nu, Float64(x))
+        $bfn(nu::Real, x::Real) = $bfn(nu, float(x))
+        function $bfn(nu::Real, z::Complex)
+            Tf = promote_type(float(typeof(nu)),float(typeof(real(z))))
+            $bfn(Tf(nu), Complex{Tf}(z))
+        end
+        $bfn{T<:AbstractFloat}(k::T, z::Complex{T}) = throw(MethodError($bfn,(k,z)))
+        $bfn(nu::Float32, x::Complex64) = Complex64($bfn(Float64(nu), Complex128(x)))
+        @vectorize_2arg Number $bfn
+    end
+end
+
+
+for bfn in (:besselh, :besselhx)
+    @eval begin
+        $bfn(nu, z) = $bfn(nu, 1, z)
+        $bfn(nu::Real, k::Integer, x::Real) = $bfn(nu, k, float(x))
+        $bfn(nu::Real, k::Integer, x::AbstractFloat) = $bfn(float(nu), k, complex(x))
+
+        function $bfn(nu::Real, k::Integer, z::Complex)
+            Tf = promote_type(float(typeof(nu)),float(typeof(real(z))))
+            $bfn(Tf(nu), k, Complex{Tf}(z))
+        end
+
+        $bfn{T<:AbstractFloat}(nu::T, k::Integer, z::Complex{T}) = throw(MethodError($bfn,(nu,k,z)))
+        $bfn(nu::Float32, k::Integer, x::Complex64) = Complex64($bfn(Float64(nu), k, Complex128(x)))
         @vectorize_2arg Number $bfn
     end
 end
+
+
+hankelh1(nu, z) = besselh(nu, 1, z)
+@vectorize_2arg Number hankelh1
+
+hankelh2(nu, z) = besselh(nu, 2, z)
+@vectorize_2arg Number hankelh2
+
+hankelh1x(nu, z) = besselhx(nu, 1, z)
+@vectorize_2arg Number hankelh1x
+
+hankelh2x(nu, z) = besselhx(nu, 2, z)
+@vectorize_2arg Number hankelh2x
diff --git a/base/special/gamma.jl b/base/special/gamma.jl
index 0678287e1b064..99c77b7a2e6b3 100644
--- a/base/special/gamma.jl
+++ b/base/special/gamma.jl
@@ -16,6 +16,8 @@ function lgamma_r(x::Float32)
     return y, signp[1]
 end
 lgamma_r(x::Real) = lgamma_r(float(x))
+lgamma_r(x::Number) = lgamma(x), 1 # lgamma does not take abs for non-real x
+"`lgamma_r(x)`: return L,s such that `gamma(x) = s * exp(L)`" lgamma_r
 
 lfact(x::Real) = (x<=1 ? zero(float(x)) : lgamma(x+one(x)))
 @vectorize_1arg Number lfact
@@ -406,7 +408,7 @@ function beta(x::Number, w::Number)
     yx, sx = lgamma_r(x)
     yw, sw = lgamma_r(w)
     yxw, sxw = lgamma_r(x+w)
-    return copysign(exp(yx + yw - yxw), sx*sw*sxw)
+    return exp(yx + yw - yxw) * (sx*sw*sxw)
 end
 lbeta(x::Number, w::Number) = lgamma(x)+lgamma(w)-lgamma(x+w)
 @vectorize_2arg Number beta
diff --git a/base/special/trig.jl b/base/special/trig.jl
index f3da9d068fc0e..ab1ac1b4efafe 100644
--- a/base/special/trig.jl
+++ b/base/special/trig.jl
@@ -209,32 +209,71 @@ end
 sinpi(x::Integer) = x >= 0 ? zero(float(x)) : -zero(float(x))
 cospi(x::Integer) = isodd(x) ? -one(float(x)) : one(float(x))
 
-function sinpi(z::Complex)
+function sinpi{T}(z::Complex{T})
+    F = float(T)
     zr, zi = reim(z)
-    if !isfinite(zi) && zr == 0 return complex(zr, zi) end
-    if isnan(zr) && !isfinite(zi) return complex(zr, zi) end
-    if !isfinite(zr) && zi == 0 return complex(oftype(zr, NaN), zi) end
-    if !isfinite(zr) && isfinite(zi) return complex(oftype(zr, NaN), oftype(zi, NaN)) end
-    if !isfinite(zr) && !isfinite(zi) return complex(zr, oftype(zi, NaN)) end
-    pizi = pi*zi
-    complex(sinpi(zr)*cosh(pizi), cospi(zr)*sinh(pizi))
+    if isinteger(zr)
+        # zr = ...,-2,-1,0,1,2,...
+        # sin(pi*zr) == ±0
+        # cos(pi*zr) == ±1
+        # cosh(pi*zi) > 0
+        s = copysign(zero(F),zr)
+        c_pos = isa(zr,Integer) ? iseven(zr) : isinteger(zr/2)
+        sh = sinh(pi*zi)
+        Complex(s, c_pos ? sh : -sh)
+    elseif isinteger(2*zr)
+        # zr = ...,-1.5,-0.5,0.5,1.5,2.5,...
+        # sin(pi*zr) == ±1
+        # cos(pi*zr) == +0
+        # sign(sinh(pi*zi)) == sign(zi)
+        s_pos = isinteger((2*zr-1)/4)
+        ch = cosh(pi*zi)
+        Complex(s_pos ? ch : -ch, isnan(zi) ? zero(F) : copysign(zero(F),zi))
+    elseif !isfinite(zr)
+        if zi == 0 || isinf(zi)
+            Complex(F(NaN), F(zi))
+        else
+            Complex(F(NaN), F(NaN))
+        end
+    else
+        pizi = pi*zi
+        Complex(sinpi(zr)*cosh(pizi), cospi(zr)*sinh(pizi))
+    end
 end
 
-function cospi(z::Complex)
+function cospi{T}(z::Complex{T})
+    F = float(T)
     zr, zi = reim(z)
-    if !isfinite(zi) && zr == 0
-        return complex(isnan(zi) ? zi : oftype(zi, Inf),
-                       isnan(zi) ? zr : zr*-sign(zi))
-    end
-    if !isfinite(zr) && isinf(zi)
-        return complex(oftype(zr, Inf), oftype(zi, NaN))
-    end
-    if isinf(zr)
-        return complex(oftype(zr, NaN), zi==0 ? -copysign(zi, zr) : oftype(zi, NaN))
+    if isinteger(zr)
+        # zr = ...,-2,-1,0,1,2,...
+        # sin(pi*zr) == ±0
+        # cos(pi*zr) == ±1
+        # sign(sinh(pi*zi)) == sign(zi)
+        # cosh(pi*zi) > 0
+        s = copysign(zero(F),zr)
+        c_pos = isa(zr,Integer) ? iseven(zr) : isinteger(zr/2)
+        ch = cosh(pi*zi)
+        Complex(c_pos ? ch : -ch, isnan(zi) ? s : -flipsign(s,zi))
+    elseif isinteger(2*zr)
+        # zr = ...,-1.5,-0.5,0.5,1.5,2.5,...
+        # sin(pi*zr) == ±1
+        # cos(pi*zr) == +0
+        # sign(sinh(pi*zi)) == sign(zi)
+        s_pos = isinteger((2*zr-1)/4)
+        sh = sinh(pi*zi)
+        Complex(zero(F), s_pos ? -sh : sh)
+    elseif !isfinite(zr)
+        if zi == 0
+            Complex(F(NaN), isnan(zr) ? zero(F) : -flipsign(F(zi),zr))
+        elseif isinf(zi)
+            Complex(F(Inf), F(NaN))
+        else
+            Complex(F(NaN), F(NaN))
+        end
+    else
+        pizi = pi*zi
+        Complex(cospi(zr)*cosh(pizi), -sinpi(zr)*sinh(pizi))
     end
-    if isnan(zr) && zi==0 return complex(zr, abs(zi)) end
-    pizi = pi*zi
-    complex(cospi(zr)*cosh(pizi), -sinpi(zr)*sinh(pizi))
 end
 @vectorize_1arg Number sinpi
 @vectorize_1arg Number cospi
@@ -243,10 +282,13 @@ end
 sinc(x::Number) = x==0 ? one(x)  : oftype(x,sinpi(x)/(pi*x))
 sinc(x::Integer) = x==0 ? one(x) : zero(x)
 sinc{T<:Integer}(x::Complex{T}) = sinc(float(x))
+sinc(x::Real) = x==0 ? one(x) : isinf(x) ? zero(x) : sinpi(x)/(pi*x)
 @vectorize_1arg Number sinc
+
 cosc(x::Number) = x==0 ? zero(x) : oftype(x,(cospi(x)-sinpi(x)/(pi*x))/x)
 cosc(x::Integer) = cosc(float(x))
 cosc{T<:Integer}(x::Complex{T}) = cosc(float(x))
+cosc(x::Real) = x==0 || isinf(x) ? zero(x) : (cospi(x)-sinpi(x)/(pi*x))/x
 @vectorize_1arg Number cosc
 
 for (finv, f) in ((:sec, :cos), (:csc, :sin), (:cot, :tan),
diff --git a/base/stacktraces.jl b/base/stacktraces.jl
new file mode 100644
index 0000000000000..55afd06ce13ea
--- /dev/null
+++ b/base/stacktraces.jl
@@ -0,0 +1,212 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+module StackTraces
+
+
+import Base: hash, ==, show
+import Base.Serializer: serialize, deserialize
+
+export StackTrace, StackFrame, stacktrace, catch_stacktrace
+
+"""
+    StackFrame
+
+Stack information representing execution context.
+"""
+immutable StackFrame # this type should be kept platform-agnostic so that profiles can be dumped on one machine and read on another
+    "the name of the function containing the execution context"
+    func::Symbol
+    "the LambdaInfo containing the execution context (if it could be found)"
+    outer_linfo::Nullable{LambdaInfo}
+    "the path to the file containing the execution context"
+    file::Symbol
+    "the line number in the file containing the execution context"
+    line::Int64
+    "the path to the file containing the context for code inlined into the execution context"
+    inlined_file::Symbol
+    "the line number in the file containing the context for code inlined into the execution context"
+    inlined_line::Int64
+    "true if the code is from C"
+    from_c::Bool
+    "representation of the pointer to the execution context as returned by `backtrace`"
+    pointer::Int64  # Large enough to be read losslessly on 32- and 64-bit machines.
+end
+
+StackFrame(func, file, line) = StackFrame(func, Nullable{LambdaInfo}(), file, line, empty_sym, -1, false, 0)
+
+"""
+    StackTrace
+
+An alias for `Vector{StackFrame}` provided for convenience; returned by calls to
+`stacktrace` and `catch_stacktrace`.
+"""
+typealias StackTrace Vector{StackFrame}
+
+const empty_sym = symbol("")
+const unk_sym = symbol("???")
+const UNKNOWN = StackFrame(unk_sym, Nullable{LambdaInfo}(), unk_sym, -1, empty_sym, -1, true, 0) # === lookup(C_NULL)
+
+
+#=
+If the StackFrame has function and line information, we consider two of them the same if
+they share the same function/line information. For unknown functions, line == pointer, so we
+never actually need to consider the pointer field.
+=#
+function ==(a::StackFrame, b::StackFrame)
+    a.line == b.line && a.from_c == b.from_c && a.func == b.func && a.file == b.file
+end
+
+function hash(frame::StackFrame, h::UInt)
+    h += 0xf4fbda67fe20ce88 % UInt
+    h = hash(frame.line, h)
+    h = hash(frame.file, h)
+    h = hash(frame.func, h)
+end
+
+# provide a custom serializer that skips attempting to serialize the `outer_linfo`
+# which is likely to contain complex references, types, and module references
+# that may not exist on the receiver end
+function serialize(s::SerializationState, frame::StackFrame)
+    Serializer.serialize_type(s, typeof(frame))
+    serialize(s, frame.func)
+    serialize(s, frame.file)
+    serialize(s, frame.inlined_file)
+    write(s.io, frame.line)
+    write(s.io, frame.inlined_line)
+    write(s.io, frame.from_c)
+    write(s.io, frame.pointer)
+end
+
+function deserialize(s::SerializationState, ::Type{StackFrame})
+    func = deserialize(s)
+    file = deserialize(s)
+    inlined_file = deserialize(s)
+    line = read(s.io, Int64)
+    inlined_line = read(s.io, Int64)
+    from_c = read(s.io, Bool)
+    pointer = read(s.io, Int64)
+    return StackFrame(func, Nullable{LambdaInfo}(), file, line, inlined_file, inlined_line, from_c, pointer)
+end
+
+
+"""
+    lookup(pointer::Union{Ptr{Void}, UInt}) -> StackFrame
+
+Given a pointer to an execution context (usually generated by a call to `backtrace`), looks
+up stack frame context information.
+"""
+function lookup(pointer::Ptr{Void})
+    info = ccall(:jl_lookup_code_address, Any, (Ptr{Void}, Cint), pointer - 1, false)
+    if length(info) == 8
+        is_inlined = (info[4] !== empty_sym)
+        return StackFrame(string(info[1]),
+            info[6] === nothing ? Nullable{LambdaInfo}() : Nullable{LambdaInfo}(info[6]),
+            is_inlined ? info[4] : info[2],
+            Int(is_inlined ? info[5] : info[3]),
+            is_inlined ? info[2] : "",
+            is_inlined ? Int(info[3]) : -1,
+            info[7], Int64(info[8]))
+    else
+        return UNKNOWN
+    end
+end
+
+lookup(pointer::UInt) = lookup(convert(Ptr{Void}, pointer))
+
+"""
+    stacktrace([trace::Vector{Ptr{Void}},] [c_funcs::Bool=false]) -> StackTrace
+
+Returns a stack trace in the form of a vector of `StackFrame`s. (By default stacktrace
+doesn't return C functions, but this can be enabled.) When called without specifying a
+trace, `stacktrace` first calls `backtrace`.
+"""
+function stacktrace(trace::Vector{Ptr{Void}}, c_funcs::Bool=false)
+    stack = map(lookup, trace)::StackTrace
+
+    # Remove frames that come from C calls.
+    if !c_funcs
+        filter!(frame -> !frame.from_c, stack)
+    end
+
+    # Remove frame for this function (and any functions called by this function).
+    remove_frames!(stack, :stacktrace)
+end
+
+stacktrace(c_funcs::Bool=false) = stacktrace(backtrace(), c_funcs)
+
+"""
+    catch_stacktrace([c_funcs::Bool=false]) -> StackTrace
+
+Returns the stack trace for the most recent error thrown, rather than the current execution
+context.
+"""
+catch_stacktrace(c_funcs::Bool=false) = stacktrace(catch_backtrace(), c_funcs)
+
+"""
+    remove_frames!(stack::StackTrace, name::Symbol)
+
+Takes a `StackTrace` (a vector of `StackFrames`) and a function name (a `Symbol`) and
+removes the `StackFrame` specified by the function name from the `StackTrace` (also removing
+all frames above the specified function). Primarily used to remove `StackTraces` functions
+from the `StackTrace` prior to returning it.
+"""
+function remove_frames!(stack::StackTrace, name::Symbol)
+    splice!(stack, 1:findlast(frame -> frame.func == name, stack))
+    return stack
+end
+
+function remove_frames!(stack::StackTrace, names::Vector{Symbol})
+    splice!(stack, 1:findlast(frame -> frame.func in names, stack))
+    return stack
+end
+
+function show_spec_linfo(io::IO, frame::StackFrame)
+    if isnull(frame.outer_linfo)
+        print(io, frame.func !== empty_sym ? frame.func : "?")
+    else
+        linfo = get(frame.outer_linfo)
+        if isdefined(linfo, 8)
+            params = linfo.(#=specTypes=#8).parameters
+            ft = params[1]
+            if ft <: Function && isempty(ft.parameters) &&
+                    isdefined(ft.name.module, ft.name.mt.name) &&
+                    ft == typeof(getfield(ft.name.module, ft.name.mt.name))
+                print(io, ft.name.mt.name)
+            elseif isa(ft, DataType) && is(ft.name, Type.name) && isleaftype(ft)
+                f = ft.parameters[1]
+                print(io, f)
+            else
+                print(io, "(::", ft, ")")
+            end
+            first = true
+            print(io, '(')
+            for i = 2:length(params)
+                first || print(io, ", ")
+                first = false
+                print(io, "::", params[i])
+            end
+            print(io, ')')
+        else
+            print(io, linfo.name)
+        end
+    end
+end
+
+function show(io::IO, frame::StackFrame; full_path::Bool=false)
+    if frame.inlined_file !== empty_sym
+        # if we have inlining information, print it first
+        inline_info = full_path ? string(frame.inlined_file) : basename(string(frame.inlined_file))
+        print(io, " [inlined code] from ", inline_info)
+        if frame.inlined_line > 0
+            print(io, ":", frame.inlined_line)
+        end
+        println(io)
+    end
+
+    print(io, " in ")
+    show_spec_linfo(io, frame)
+    file_info = full_path ? string(frame.file) : basename(string(frame.file))
+    print(io, " at ", file_info, ":", frame.line)
+end
+
+end
diff --git a/base/stat.jl b/base/stat.jl
index 9455e5b7b2858..ee2a286c25737 100644
--- a/base/stat.jl
+++ b/base/stat.jl
@@ -1,5 +1,30 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+# filesystem operations
+
+export
+    ctime,
+    filemode,
+    filesize,
+    gperm,
+    isblockdev,
+    ischardev,
+    isdir,
+    isfifo,
+    isfile,
+    islink,
+    ismount,
+    ispath,
+    issetgid,
+    issetuid,
+    issocket,
+    issticky,
+    lstat,
+    mtime,
+    operm,
+    stat,
+    uperm
+
 immutable StatStruct
     device  :: UInt
     inode   :: UInt
@@ -32,7 +57,7 @@ StatStruct(buf::Union{Vector{UInt8},Ptr{UInt8}}) = StatStruct(
     ccall(:jl_stat_ctime,   Float64, (Ptr{UInt8},), buf),
 )
 
-show(io::IO, st::StatStruct) = print(io, "StatStruct(mode=$(oct(st.mode,6)), size=$(st.size))")
+show(io::IO, st::StatStruct) = print(io, "StatStruct(mode=$(oct(filemode(st),6)), size=$(filesize(st)))")
 
 # stat & lstat functions
 
@@ -41,7 +66,7 @@ macro stat_call(sym, arg1type, arg)
     quote
         fill!(stat_buf,0)
         r = ccall($(Expr(:quote,sym)), Int32, ($arg1type, Ptr{UInt8}), $(esc(arg)), stat_buf)
-        r==0 || r==UV_ENOENT || r==UV_ENOTDIR || throw(UVError("stat",r))
+        r==0 || r==Base.UV_ENOENT || r==Base.UV_ENOTDIR || throw(UVError("stat",r))
         st = StatStruct(stat_buf)
         if ispath(st) != (r==0)
             error("stat returned zero type for a valid path")
@@ -58,30 +83,33 @@ lstat(path::AbstractString) = @stat_call jl_lstat Cstring path
 stat(path...) = stat(joinpath(path...))
 lstat(path...) = lstat(joinpath(path...))
 
+# some convenience functions
+
+filemode(st::StatStruct) = st.mode
+filesize(st::StatStruct) = st.size
+   mtime(st::StatStruct) = st.mtime
+   ctime(st::StatStruct) = st.ctime
+
 # mode type predicates
 
-    ispath(st::StatStruct) = st.mode & 0xf000 != 0x0000
-    isfifo(st::StatStruct) = st.mode & 0xf000 == 0x1000
- ischardev(st::StatStruct) = st.mode & 0xf000 == 0x2000
-     isdir(st::StatStruct) = st.mode & 0xf000 == 0x4000
-isblockdev(st::StatStruct) = st.mode & 0xf000 == 0x6000
-    isfile(st::StatStruct) = st.mode & 0xf000 == 0x8000
-    islink(st::StatStruct) = st.mode & 0xf000 == 0xa000
-  issocket(st::StatStruct) = st.mode & 0xf000 == 0xc000
+    ispath(st::StatStruct) = filemode(st) & 0xf000 != 0x0000
+    isfifo(st::StatStruct) = filemode(st) & 0xf000 == 0x1000
+ ischardev(st::StatStruct) = filemode(st) & 0xf000 == 0x2000
+     isdir(st::StatStruct) = filemode(st) & 0xf000 == 0x4000
+isblockdev(st::StatStruct) = filemode(st) & 0xf000 == 0x6000
+    isfile(st::StatStruct) = filemode(st) & 0xf000 == 0x8000
+    islink(st::StatStruct) = filemode(st) & 0xf000 == 0xa000
+  issocket(st::StatStruct) = filemode(st) & 0xf000 == 0xc000
 
 # mode permission predicates
 
-issetuid(st::StatStruct) = (st.mode & 0o4000) > 0
-issetgid(st::StatStruct) = (st.mode & 0o2000) > 0
-issticky(st::StatStruct) = (st.mode & 0o1000) > 0
-
-  isreadable(st::StatStruct) = (st.mode & 0o444) > 0
-  iswritable(st::StatStruct) = (st.mode & 0o222) > 0
-isexecutable(st::StatStruct) = (st.mode & 0o111) > 0
+issetuid(st::StatStruct) = (filemode(st) & 0o4000) > 0
+issetgid(st::StatStruct) = (filemode(st) & 0o2000) > 0
+issticky(st::StatStruct) = (filemode(st) & 0o1000) > 0
 
-uperm(st::StatStruct) = UInt8((st.mode >> 6) & 0x7)
-gperm(st::StatStruct) = UInt8((st.mode >> 3) & 0x7)
-operm(st::StatStruct) = UInt8((st.mode     ) & 0x7)
+uperm(st::StatStruct) = UInt8((filemode(st) >> 6) & 0x7)
+gperm(st::StatStruct) = UInt8((filemode(st) >> 3) & 0x7)
+operm(st::StatStruct) = UInt8((filemode(st)     ) & 0x7)
 
 # mode predicate methods for file names
 
@@ -92,36 +120,30 @@ for f in Symbol[
     :isdir
     :isblockdev
     :isfile
-    :islink
     :issocket
     :issetuid
     :issetgid
     :issticky
-    :isreadable
-    :iswritable
-    :isexecutable
     :uperm
     :gperm
     :operm
+    :filemode
+    :filesize
+    :mtime
+    :ctime
 ]
     @eval ($f)(path...)  = ($f)(stat(path...))
 end
 
 islink(path...) = islink(lstat(path...))
 
-
-# some convenience functions
-
-filemode(path...) = stat(path...).mode
-filesize(path...) = stat(path...).size
-   mtime(path...) = stat(path...).mtime
-   ctime(path...) = stat(path...).ctime
-
 # samefile can be used for files and directories: #11145#issuecomment-99511194
 samefile(a::StatStruct, b::StatStruct) = a.device==b.device && a.inode==b.inode
 function samefile(a::AbstractString, b::AbstractString)
-    if ispath(a) && ispath(b)
-        samefile(stat(a),stat(b))
+    infoa = stat(a)
+    infob = stat(b)
+    if ispath(infoa) && ispath(infob)
+        samefile(infoa, infob)
     else
         return false
     end
diff --git a/base/statistics.jl b/base/statistics.jl
index dc77fca791d5e..174d2f4b8fb31 100644
--- a/base/statistics.jl
+++ b/base/statistics.jl
@@ -34,6 +34,10 @@ mean{T}(A::AbstractArray{T}, region) =
 
 ##### variances #####
 
+# faster computation of real(conj(x)*y)
+realXcY(x::Real, y::Real) = x*y
+realXcY(x::Complex, y::Complex) = real(x)*real(y) + imag(x)*imag(y)
+
 function var(iterable; corrected::Bool=true, mean=nothing)
     state = start(iterable)
     if done(iterable, state)
@@ -45,12 +49,12 @@ function var(iterable; corrected::Bool=true, mean=nothing)
         # Use Welford algorithm as seen in (among other places)
         # Knuth's TAOCP, Vol 2, page 232, 3rd edition.
         M = value / 1
-        S = zero(M)
+        S = real(zero(M))
         while !done(iterable, state)
             value, state = next(iterable, state)
             count += 1
             new_M = M + (value - M) / count
-            S = S + (value - M) * (value - new_M)
+            S = S + realXcY(value - M, value - new_M)
             M = new_M
         end
         return S / (count - Int(corrected))
@@ -60,11 +64,11 @@ function var(iterable; corrected::Bool=true, mean=nothing)
         # by Chan, Golub, and LeVeque, Technical Report STAN-CS-79-773,
         # Department of Computer Science, Stanford University,
         # because user can provide mean value that is different to mean(iterable)
-        sum2 = (value - mean::Number)^2
+        sum2 = abs2(value - mean::Number)
         while !done(iterable, state)
             value, state = next(iterable, state)
             count += 1
-            sum2 += (value - mean)^2
+            sum2 += abs2(value - mean)
         end
         return sum2 / (count - Int(corrected))
     else
@@ -74,7 +78,7 @@ end
 
 function varzm{T}(A::AbstractArray{T}; corrected::Bool=true)
     n = length(A)
-    n == 0 && return convert(momenttype(T), NaN)
+    n == 0 && return convert(real(momenttype(T)), NaN)
     return sumabs2(A) / (n - Int(corrected))
 end
 
@@ -89,12 +93,12 @@ function varzm!{S}(R::AbstractArray{S}, A::AbstractArray; corrected::Bool=true)
 end
 
 varzm{T}(A::AbstractArray{T}, region; corrected::Bool=true) =
-    varzm!(reducedim_initarray(A, region, 0, momenttype(T)), A; corrected=corrected)
+    varzm!(reducedim_initarray(A, region, 0, real(momenttype(T))), A; corrected=corrected)
 
 immutable CentralizedAbs2Fun{T<:Number} <: Func{1}
     m::T
 end
-call(f::CentralizedAbs2Fun, x) = abs2(x - f.m)
+(f::CentralizedAbs2Fun)(x) = abs2(x - f.m)
 centralize_sumabs2(A::AbstractArray, m::Number) =
     mapreduce(CentralizedAbs2Fun(m), AddFun(), A)
 centralize_sumabs2(A::AbstractArray, m::Number, ifirst::Int, ilast::Int) =
@@ -139,8 +143,8 @@ end
 
 function varm{T}(A::AbstractArray{T}, m::Number; corrected::Bool=true)
     n = length(A)
-    n == 0 && return convert(momenttype(T), NaN)
-    n == 1 && return convert(momenttype(T), abs2(A[1] - m)/(1 - Int(corrected)))
+    n == 0 && return convert(real(momenttype(T)), NaN)
+    n == 1 && return convert(real(momenttype(T)), abs2(A[1] - m)/(1 - Int(corrected)))
     return centralize_sumabs2(A, m) / (n - Int(corrected))
 end
 
@@ -155,14 +159,15 @@ function varm!{S}(R::AbstractArray{S}, A::AbstractArray, m::AbstractArray; corre
 end
 
 varm{T}(A::AbstractArray{T}, m::AbstractArray, region; corrected::Bool=true) =
-    varm!(reducedim_initarray(A, region, 0, momenttype(T)), A, m; corrected=corrected)
+    varm!(reducedim_initarray(A, region, 0, real(momenttype(T))), A, m; corrected=corrected)
 
 
 function var{T}(A::AbstractArray{T}; corrected::Bool=true, mean=nothing)
-    convert(momenttype(T), mean == 0 ? varzm(A; corrected=corrected) :
-                           mean === nothing ? varm(A, Base.mean(A); corrected=corrected) :
-                           isa(mean, Number) ? varm(A, mean::Number; corrected=corrected) :
-                           throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))")))::momenttype(T)
+    convert(real(momenttype(T)),
+            mean == 0 ? varzm(A; corrected=corrected) :
+            mean === nothing ? varm(A, Base.mean(A); corrected=corrected) :
+            isa(mean, Number) ? varm(A, mean::Number; corrected=corrected) :
+            throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))")))::real(momenttype(T))
 end
 
 function var(A::AbstractArray, region; corrected::Bool=true, mean=nothing)
@@ -243,7 +248,7 @@ _vmean(x::AbstractMatrix, vardim::Int) = mean(x, vardim)
 
 # core functions
 
-unscaled_covzm(x::AbstractVector) = dot(x, x)
+unscaled_covzm(x::AbstractVector) = sumabs2(x)
 unscaled_covzm(x::AbstractMatrix, vardim::Int) = (vardim == 1 ? _conj(x'x) : x * x')
 
 unscaled_covzm(x::AbstractVector, y::AbstractVector) = dot(x, y)
@@ -256,66 +261,74 @@ unscaled_covzm(x::AbstractMatrix, y::AbstractMatrix, vardim::Int) =
 
 # covzm (with centered data)
 
-covzm(x::AbstractVector; corrected::Bool=true) = unscaled_covzm(x, x) / (length(x) - Int(corrected))
-
-covzm(x::AbstractMatrix; vardim::Int=1, corrected::Bool=true) =
+covzm(x::AbstractVector, corrected::Bool=true) = unscaled_covzm(x) / (length(x) - Int(corrected))
+covzm(x::AbstractMatrix, vardim::Int=1, corrected::Bool=true) =
     scale!(unscaled_covzm(x, vardim), inv(size(x,vardim) - Int(corrected)))
-
-covzm(x::AbstractVector, y::AbstractVector; corrected::Bool=true) =
+covzm(x::AbstractVector, y::AbstractVector, corrected::Bool=true) =
     unscaled_covzm(x, y) / (length(x) - Int(corrected))
-
-covzm(x::AbstractVecOrMat, y::AbstractVecOrMat; vardim::Int=1, corrected::Bool=true) =
+covzm(x::AbstractVecOrMat, y::AbstractVecOrMat, vardim::Int=1, corrected::Bool=true) =
     scale!(unscaled_covzm(x, y, vardim), inv(_getnobs(x, y, vardim) - Int(corrected)))
 
 # covm (with provided mean)
 
-covm(x::AbstractVector, xmean; corrected::Bool=true) =
-    covzm(x .- xmean; corrected=corrected)
-
-covm(x::AbstractMatrix, xmean; vardim::Int=1, corrected::Bool=true) =
-    covzm(x .- xmean; vardim=vardim, corrected=corrected)
+covm(x::AbstractVector, xmean, corrected::Bool=true) =
+    covzm(x .- xmean, corrected)
+covm(x::AbstractMatrix, xmean, vardim::Int=1, corrected::Bool=true) =
+    covzm(x .- xmean, vardim, corrected)
+covm(x::AbstractVector, xmean, y::AbstractVector, ymean, corrected::Bool=true) =
+    covzm(x .- xmean, y .- ymean, corrected)
+covm(x::AbstractVecOrMat, xmean, y::AbstractVecOrMat, ymean, vardim::Int=1, corrected::Bool=true) =
+    covzm(x .- xmean, y .- ymean, vardim, corrected)
 
-covm(x::AbstractVector, xmean, y::AbstractVector, ymean; corrected::Bool=true) =
-    covzm(x .- xmean, y .- ymean; corrected=corrected)
+# cov (API)
+"""
+    cov(x[, corrected=true])
 
-covm(x::AbstractVecOrMat, xmean, y::AbstractVecOrMat, ymean; vardim::Int=1, corrected::Bool=true) =
-    covzm(x .- xmean, y .- ymean; vardim=vardim, corrected=corrected)
+Compute the variance of the vector `x`. If `corrected` is `true` (the default) then the sum
+is scaled with `n-1` wheares the sum is scaled with `n` if `corrected` is `false` where `n = length(x)`.
+"""
+cov(x::AbstractVector, corrected::Bool) = covm(x, Base.mean(x), corrected)
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these two methods can be merged
+cov{T<:AbstractVector}(x::T) = covm(x, Base.mean(x), true)
 
-# cov (API)
+"""
+    cov(X[, vardim=1, corrected=true])
 
-function cov(x::AbstractVector; corrected::Bool=true, mean=nothing)
-    mean == 0 ? covzm(x; corrected=corrected) :
-    mean === nothing ? covm(x, Base.mean(x); corrected=corrected) :
-    isa(mean, Number) ? covm(x, mean; corrected=corrected) :
-    throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-end
+Compute the covariance matrix of the matrix `X` along the dimension `vardim`. If `corrected`
+is `true` (the default) then the sum is scaled with `n-1` wheares the sum is scaled with `n`
+if `corrected` is `false` where `n = size(X, vardim)`.
+"""
+cov(X::AbstractMatrix, vardim::Int, corrected::Bool=true) =
+    covm(X, _vmean(X, vardim), vardim, corrected)
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these two methods can be merged
+cov{T<:AbstractMatrix}(X::T) = cov(X, 1, true)
 
-function cov(x::AbstractMatrix; vardim::Int=1, corrected::Bool=true, mean=nothing)
-    mean == 0 ? covzm(x; vardim=vardim, corrected=corrected) :
-    mean === nothing ? covm(x, _vmean(x, vardim); vardim=vardim, corrected=corrected) :
-    isa(mean, AbstractArray) ? covm(x, mean; vardim=vardim, corrected=corrected) :
-    throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-end
+"""
+    cov(x, y[, corrected=true])
 
-function cov(x::AbstractVector, y::AbstractVector; corrected::Bool=true, mean=nothing)
-    mean == 0 ? covzm(x, y; corrected=corrected) :
-    mean === nothing ? covm(x, Base.mean(x), y, Base.mean(y); corrected=corrected) :
-    isa(mean, (Number,Number)) ? covm(x, mean[1], y, mean[2]; corrected=corrected) :
-    throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-end
+Compute the covariance between the vectors `x` and `y`. If `corrected` is `true` (the default)
+then the sum is scaled with `n-1` wheares the sum is scaled with `n` if `corrected` is `false`
+where `n = length(x) = length(y)`.
+"""
+cov(x::AbstractVector, y::AbstractVector, corrected::Bool) =
+    covm(x, Base.mean(x), y, Base.mean(y), corrected)
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these two methods can be merged
+cov{T<:AbstractVector,S<:AbstractVector}(x::T, y::S) =
+    covm(x, Base.mean(x), y, Base.mean(y), true)
 
-function cov(x::AbstractVecOrMat, y::AbstractVecOrMat; vardim::Int=1, corrected::Bool=true, mean=nothing)
-    if mean == 0
-        covzm(x, y; vardim=vardim, corrected=corrected)
-    elseif mean === nothing
-        covm(x, _vmean(x, vardim), y, _vmean(y, vardim); vardim=vardim, corrected=corrected)
-    elseif isa(mean, (Any,Any))
-        covm(x, mean[1], y, mean[2]; vardim=vardim, corrected=corrected)
-    else
-        throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-    end
-end
+"""
+    cov(X, Y[, vardim=1, corrected=true])
 
+Compute the covariance between the vectors or matrices `X` and `Y` along the dimension
+`vardim`. If `corrected` is `true` (the default) then the sum is scaled with `n-1` wheares
+the sum is scaled with `n` if `corrected` is `false` where `n = size(X, vardim) = size(Y, vardim)`.
+"""
+cov(X::AbstractVecOrMat, Y::AbstractVecOrMat, vardim::Int, corrected::Bool=true) =
+    covm(X, _vmean(X, vardim), Y, _vmean(Y, vardim), vardim, corrected)
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these methods can be merged
+cov(x::AbstractVector, Y::AbstractMatrix) = cov(x, Y, 1, true)
+cov(X::AbstractMatrix, y::AbstractVector) = cov(X, y, 1, true)
+cov(X::AbstractMatrix, Y::AbstractMatrix) = cov(X, Y, 1, true)
 
 ##### correlation #####
 
@@ -335,7 +348,6 @@ function cov2cor!{T}(C::AbstractMatrix{T}, xsd::AbstractArray)
     end
     return C
 end
-
 function cov2cor!(C::AbstractMatrix, xsd::Number, ysd::AbstractArray)
     nx, ny = size(C)
     length(ysd) == ny || throw(DimensionMismatch("inconsistent dimensions"))
@@ -346,7 +358,6 @@ function cov2cor!(C::AbstractMatrix, xsd::Number, ysd::AbstractArray)
     end
     return C
 end
-
 function cov2cor!(C::AbstractMatrix, xsd::AbstractArray, ysd::Number)
     nx, ny = size(C)
     length(xsd) == nx || throw(DimensionMismatch("inconsistent dimensions"))
@@ -357,7 +368,6 @@ function cov2cor!(C::AbstractMatrix, xsd::AbstractArray, ysd::Number)
     end
     return C
 end
-
 function cov2cor!(C::AbstractMatrix, xsd::AbstractArray, ysd::AbstractArray)
     nx, ny = size(C)
     (length(xsd) == nx && length(ysd) == ny) ||
@@ -372,11 +382,11 @@ end
 
 # corzm (non-exported, with centered data)
 
-corzm{T}(x::AbstractVector{T}) = float(one(T) * one(T))
-
-corzm(x::AbstractMatrix; vardim::Int=1) =
-    (c = unscaled_covzm(x, vardim); cov2cor!(c, sqrt!(diag(c))))
-
+corzm{T}(x::AbstractVector{T}) = one(real(T))
+function corzm(x::AbstractMatrix, vardim::Int=1)
+    c = unscaled_covzm(x, vardim)
+    return cov2cor!(c, sqrt!(diag(c)))
+end
 function corzm(x::AbstractVector, y::AbstractVector)
     n = length(x)
     length(y) == n || throw(DimensionMismatch("inconsistent lengths"))
@@ -396,62 +406,58 @@ function corzm(x::AbstractVector, y::AbstractVector)
     end
     return xy / (sqrt(xx) * sqrt(yy))
 end
-
-corzm(x::AbstractVector, y::AbstractMatrix; vardim::Int=1) =
+corzm(x::AbstractVector, y::AbstractMatrix, vardim::Int=1) =
     cov2cor!(unscaled_covzm(x, y, vardim), sqrt(sumabs2(x)), sqrt!(sumabs2(y, vardim)))
-
-corzm(x::AbstractMatrix, y::AbstractVector; vardim::Int=1) =
+corzm(x::AbstractMatrix, y::AbstractVector, vardim::Int=1) =
     cov2cor!(unscaled_covzm(x, y, vardim), sqrt!(sumabs2(x, vardim)), sqrt(sumabs2(y)))
-
-corzm(x::AbstractMatrix, y::AbstractMatrix; vardim::Int=1) =
+corzm(x::AbstractMatrix, y::AbstractMatrix, vardim::Int=1) =
     cov2cor!(unscaled_covzm(x, y, vardim), sqrt!(sumabs2(x, vardim)), sqrt!(sumabs2(y, vardim)))
 
 # corm
 
-corm(x::AbstractVector, xmean) = corzm(x .- xmean)
-
-corm(x::AbstractMatrix, xmean; vardim::Int=1) = corzm(x .- xmean; vardim=vardim)
-
+corm{T}(x::AbstractVector{T}, xmean) = one(real(T))
+corm(x::AbstractMatrix, xmean, vardim::Int=1) = corzm(x .- xmean, vardim)
 corm(x::AbstractVector, xmean, y::AbstractVector, ymean) = corzm(x .- xmean, y .- ymean)
-
-corm(x::AbstractVecOrMat, xmean, y::AbstractVecOrMat, ymean; vardim::Int=1) =
-    corzm(x .- xmean, y .- ymean; vardim=vardim)
+corm(x::AbstractVecOrMat, xmean, y::AbstractVecOrMat, ymean, vardim::Int=1) =
+    corzm(x .- xmean, y .- ymean, vardim)
 
 # cor
+"""
+    cor(x)
 
-function cor(x::AbstractVector; mean=nothing)
-    mean == 0 ? corzm(x) :
-    mean === nothing ? corm(x, Base.mean(x)) :
-    isa(mean, Number) ? corm(x, mean) :
-    throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-end
+Return the number one.
+"""
+cor{T<:AbstractVector}(x::T) = one(real(eltype(x)))
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these two methods can be merged
 
-function cor(x::AbstractMatrix; vardim::Int=1, mean=nothing)
-    mean == 0 ? corzm(x; vardim=vardim) :
-    mean === nothing ? corm(x, _vmean(x, vardim); vardim=vardim) :
-    isa(mean, AbstractArray) ? corm(x, mean; vardim=vardim) :
-    throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-end
+"""
+    cor(X[, vardim=1])
 
-function cor(x::AbstractVector, y::AbstractVector; mean=nothing)
-    mean == 0 ? corzm(x, y) :
-    mean === nothing ? corm(x, Base.mean(x), y, Base.mean(y)) :
-    isa(mean, (Number,Number)) ? corm(x, mean[1], y, mean[2]) :
-    throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-end
+Compute the Pearson correlation matrix of the matrix `X` along the dimension `vardim`.
+"""
+cor(X::AbstractMatrix, vardim::Int) = corm(X, _vmean(X, vardim), vardim)
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these two methods can be merged
+cor{T<:AbstractMatrix}(X::T) = cor(X, 1)
 
-function cor(x::AbstractVecOrMat, y::AbstractVecOrMat; vardim::Int=1, mean=nothing)
-    if mean == 0
-        corzm(x, y; vardim=vardim)
-    elseif mean === nothing
-        corm(x, _vmean(x, vardim), y, _vmean(y, vardim); vardim=vardim)
-    elseif isa(mean, (Any,Any))
-        corm(x, mean[1], y, mean[2]; vardim=vardim)
-    else
-        throw(ArgumentError("invalid value of mean, $(mean)::$(typeof(mean))"))
-    end
-end
+"""
+    cor(x, y)
+
+Compute the Pearson correlation between the vectors `x` and `y`.
+"""
+cor{T<:AbstractVector,S<:AbstractVector}(x::T, y::S) = corm(x, Base.mean(x), y, Base.mean(y))
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these two methods can be merged
+
+"""
+    cor(X, Y[, vardim=1])
 
+Compute the Pearson correlation between the vectors or matrices `X` and `Y` along the dimension `vardim`.
+"""
+cor(x::AbstractVecOrMat, y::AbstractVecOrMat, vardim::Int) =
+    corm(x, _vmean(x, vardim), y, _vmean(y, vardim), vardim)
+# This ugly hack is necessary to make the method below considered more specific than the deprecated method. When the old keyword version has been completely deprecated, these methods can be merged
+cor(x::AbstractVector, Y::AbstractMatrix) = cor(x, Y, 1)
+cor(X::AbstractMatrix, y::AbstractVector) = cor(X, y, 1)
+cor(X::AbstractMatrix, Y::AbstractMatrix) = cor(X, Y, 1)
 
 ##### median & quantiles #####
 
@@ -509,52 +515,106 @@ median{T}(v::AbstractArray{T}, region) = mapslices(median!, v, region)
 
 # for now, use the R/S definition of quantile; may want variants later
 # see ?quantile in R -- this is type 7
-# TODO: need faster implementation (use select!?)
-#
-function quantile!(v::AbstractVector, q::AbstractVector)
-    isempty(v) && throw(ArgumentError("empty data array"))
-    isempty(q) && throw(ArgumentError("empty quantile array"))
+"""
+    quantile!([q, ] v, p; sorted=false)
+
+Compute the quantile(s) of a vector `v` at the probabilities `p`, with optional output into
+array `q` (if not provided, a new output array is created). The keyword argument `sorted`
+indicates whether `v` can be assumed to be sorted; if `false` (the default), then the
+elements of `v` may be partially sorted.
 
-    # make sure the quantiles are in [0,1]
-    q = bound_quantiles(q)
+The elements of `p` should be on the interval [0,1], and `v` should not have any `NaN`
+values.
+
+Quantiles are computed via linear interpolation between the points `((k-1)/(n-1), v[k])`,
+for `k = 1:n` where `n = length(v)`. This corresponds to Definition 7 of Hyndman and Fan
+(1996), and is the same as the R default.
+
+* Hyndman, R.J and Fan, Y. (1996) "Sample Quantiles in Statistical Packages",
+  *The American Statistician*, Vol. 50, No. 4, pp. 361-365
+"""
+function quantile!(q::AbstractArray, v::AbstractVector, p::AbstractArray;
+                   sorted::Bool=false)
+    size(p) == size(q) || throw(DimensionMismatch())
+
+    isempty(v) && throw(ArgumentError("empty data vector"))
 
     lv = length(v)
-    lq = length(q)
+    if !sorted
+        minp, maxp = extrema(p)
+        lo = floor(Int,1+minp*(lv-1))
+        hi = ceil(Int,1+maxp*(lv-1))
 
-    index = 1 .+ (lv-1)*q
-    lo = floor(Int,index)
-    hi = ceil(Int,index)
-    sort!(v)
+        # only need to perform partial sort
+        sort!(v, 1, lv, PartialQuickSort(lo:hi), Base.Sort.Forward)
+    end
     isnan(v[end]) && throw(ArgumentError("quantiles are undefined in presence of NaNs"))
-    i = find(index .> lo)
-    r = float(v[lo])
-    h = (index.-lo)[i]
-    r[i] = (1.-h).*r[i] + h.*v[hi[i]]
-    return r
+
+    for i = 1:length(p)
+        @inbounds q[i] = _quantile(v,p[i])
+    end
+    return q
 end
 
-"""
-    quantile(v, ps)
+quantile!(v::AbstractVector, p::AbstractArray; sorted::Bool=false) =
+    quantile!(similar(p,float(eltype(v))), v, p; sorted=sorted)
 
-Compute the quantiles of a vector `v` at a specified set of probability values `ps`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-quantile(v::AbstractVector, q::AbstractVector) = quantile!(copy(v),q)
-"""
-    quantile(v, p)
+function quantile!(v::AbstractVector, p::Real;
+                   sorted::Bool=false)
+    isempty(v) && throw(ArgumentError("empty data vector"))
 
-Compute the quantile of a vector `v` at the probability `p`. Note: Julia does not ignore `NaN` values in the computation.
-"""
-quantile(v::AbstractVector, q::Number) = quantile(v,[q])[1]
+    lv = length(v)
+    if !sorted
+        lo = floor(Int,1+p*(lv-1))
+        hi = ceil(Int,1+p*(lv-1))
+
+        # only need to perform partial sort
+        sort!(v, 1, lv, PartialQuickSort(lo:hi), Base.Sort.Forward)
+    end
+    isnan(v[end]) && throw(ArgumentError("quantiles are undefined in presence of NaNs"))
+
+    return _quantile(v,p)
+end
+
+# Core quantile lookup function: assumes `v` sorted
+@inline function _quantile(v::AbstractVector, p::Real)
+    T = float(eltype(v))
+    isnan(p) && return T(NaN)
+
+    lv = length(v)
+    index = 1 + (lv-1)*p
+    1 <= index <= lv || error("input probability out of [0,1] range")
+
+    indlo = floor(index)
+    i = trunc(Int,indlo)
 
-function bound_quantiles(qs::AbstractVector)
-    epsilon = 100*eps()
-    if (any(qs .< -epsilon) || any(qs .> 1+epsilon))
-        throw(ArgumentError("quantiles out of [0,1] range"))
+    if index == indlo
+        return T(v[i])
+    else
+        h = T(index - indlo)
+        return (1-h)*T(v[i]) + h*T(v[i+1])
     end
-    [min(1,max(0,q)) for q = qs]
 end
 
 
+"""
+    quantile(v, p; sorted=false)
+
+Compute the quantile(s) of a vector `v` at a specified probability or vector `p`. The
+keyword argument `sorted` indicates whether `v` can be assumed to be sorted.
+
+The `p` should be on the interval [0,1], and `v` should not have any `NaN` values.
+
+Quantiles are computed via linear interpolation between the points `((k-1)/(n-1), v[k])`,
+for `k = 1:n` where `n = length(v)`. This corresponds to Definition 7 of Hyndman and Fan
+(1996), and is the same as the R default.
+
+* Hyndman, R.J and Fan, Y. (1996) "Sample Quantiles in Statistical Packages",
+  *The American Statistician*, Vol. 50, No. 4, pp. 361-365
+"""
+quantile(v::AbstractVector, p; sorted::Bool=false) =
+    quantile!(sorted ? v : copy!(similar(v),v), p; sorted=sorted)
+
 
 ##### histogram #####
 
@@ -607,8 +667,8 @@ function histrange{T<:Integer,N}(v::AbstractArray{T,N}, n::Integer)
     if hi == lo
         step = 1
     else
-        bw = (hi - lo) / n
-        e = 10^max(0,floor(Int,log10(bw)))
+        bw = (Float64(hi) - Float64(lo)) / n
+        e = 10.0^max(0,floor(log10(bw)))
         r = bw / e
         if r <= 1
             step = e
diff --git a/base/stream.jl b/base/stream.jl
index b254a1f5e8e76..0fb32137f503d 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -1,7 +1,6 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-#TODO: Move stdio detection from C to Julia (might require some Clang magic)
-include("uv_constants.jl")
+include(string(length(Core.ARGS)>=2?Core.ARGS[2]:"","uv_constants.jl"))  # include($BUILDROOT/base/uv_constants.jl)
 
 import .Libc: RawFD, dup
 @windows_only import .Libc: WindowsRawSocket
@@ -9,10 +8,35 @@ import .Libc: RawFD, dup
 ## types ##
 typealias Callback Union{Function,Bool}
 
-abstract AsyncStream <: IO
-abstract UVServer
-
-typealias UVHandle Ptr{Void}
+abstract IOServer
+abstract LibuvServer <: IOServer
+abstract LibuvStream <: IO
+
+# IO
+# +- AbstractIOBuffer{T<:AbstractArray{UInt8,1}} (not exported)
+# +- AbstractPipe (not exported)
+# .  +- Pipe
+# .  +- Process (not exported)
+# .  +- ProcessChain (not exported)
+# +- Base64DecodePipe
+# +- Base64EncodePipe
+# +- BufferStream
+# +- DevNullStream (not exported)
+# +- Filesystem.File
+# +- LibuvStream (not exported)
+# .  +- PipeEndpoint (not exported)
+# .  +- TCPSocket
+# .  +- TTY (not exported)
+# .  +- UDPSocket
+# +- IOBuffer = Base.AbstractIOBuffer{Array{UInt8,1}}
+# +- IOStream
+
+# IOServer
+# +- LibuvServer
+# .  +- PipeServer
+# .  +- TCPServer
+
+# Redirectable = Union{IO, FileRedirect, Libc.RawFD} (not exported)
 
 # convert UV handle data to julia object, checking for null
 macro handle_as(hand, typ)
@@ -26,9 +50,18 @@ end
 # A dict of all libuv handles that are being waited on somewhere in the system
 # and should thus not be garbage collected
 const uvhandles = ObjectIdDict()
+preserve_handle(x) = uvhandles[x] = get(uvhandles,x,0)::Int+1
+unpreserve_handle(x) = (v = uvhandles[x]::Int; v == 1 ? pop!(uvhandles,x) : (uvhandles[x] = v-1); nothing)
+
+function stream_wait(x, c...) # for x::LibuvObject
+    preserve_handle(x)
+    try
+        return wait(c...)
+    finally
+        unpreserve_handle(x)
+    end
+end
 
-preserve_handle(x) = uvhandles[x] = get(uvhandles,x,0)+1
-unpreserve_handle(x) = (v = uvhandles[x]; v == 1 ? pop!(uvhandles,x) : (uvhandles[x] = v-1); nothing)
 
 function uv_sizeof_handle(handle)
     if !(UV_UNKNOWN_HANDLE < handle < UV_HANDLE_TYPE_MAX)
@@ -51,11 +84,16 @@ for r in uv_req_types
 @eval const $(symbol("_sizeof_"*lowercase(string(r)))) = uv_sizeof_req($r)
 end
 
-nb_available(s::AsyncStream) = nb_available(s.buffer)
+nb_available(s::LibuvStream) = nb_available(s.buffer)
 
-function eof(s::AsyncStream)
+function eof(s::LibuvStream)
+    if isopen(s) # fast path
+        nb_available(s) > 0 && return false
+    else
+        return nb_available(s) <= 0
+    end
     wait_readnb(s,1)
-    !isopen(s) && nb_available(s)<=0
+    !isopen(s) && nb_available(s) <= 0
 end
 
 const DEFAULT_READ_BUFFER_SZ = 10485760           # 10 MB
@@ -102,7 +140,7 @@ uv_req_data(handle) = ccall(:jl_uv_req_data,Ptr{Void},(Ptr{Void},),handle)
 uv_req_set_data(req,data) = ccall(:jl_uv_req_set_data,Void,(Ptr{Void},Any),req,data)
 uv_req_set_data(req,data::Ptr{Void}) = ccall(:jl_uv_req_set_data,Void,(Ptr{Void},Ptr{Void}),req,data)
 
-type PipeEndpoint <: AsyncStream
+type PipeEndpoint <: LibuvStream
     handle::Ptr{Void}
     status::Int
     buffer::IOBuffer
@@ -129,10 +167,7 @@ type PipeEndpoint <: AsyncStream
         DEFAULT_READ_BUFFER_SZ)
 end
 
-lock(p::PipeEndpoint) = lock(p.lock)
-unlock(p::PipeEndpoint) = unlock(p.lock)
-
-type PipeServer <: UVServer
+type PipeServer <: LibuvServer
     handle::Ptr{Void}
     status::Int
     ccb::Callback
@@ -146,20 +181,7 @@ type PipeServer <: UVServer
         false,Condition())
 end
 
-function init_pipe!(pipe::Union{PipeEndpoint,PipeServer};
-                    readable::Bool = false,
-                    writable::Bool = false,
-                    julia_only::Bool = true)
-    if pipe.status != StatusUninit
-        error("pipe is already initialized")
-    end
-    if pipe.handle == C_NULL
-        malloc_julia_pipe!(pipe)
-    end
-    uv_error("init_pipe",ccall(:jl_init_pipe, Cint, (Ptr{Void},Int32,Int32,Int32), pipe.handle, writable,readable,julia_only))
-    pipe.status = StatusInit
-    pipe
-end
+typealias LibuvPipe Union{PipeEndpoint, PipeServer}
 
 function PipeServer()
     handle = Libc.malloc(_sizeof_uv_named_pipe)
@@ -174,11 +196,7 @@ function PipeServer()
     end
 end
 
-show(io::IO,stream::PipeEndpoint) = print(io,"PipeEndpoint(",uv_status_string(stream),", ",
-    nb_available(stream.buffer)," bytes waiting)")
-show(io::IO,stream::PipeServer) = print(io,"PipeServer(",uv_status_string(stream),")")
-
-type TTY <: AsyncStream
+type TTY <: LibuvStream
     handle::Ptr{Void}
     status::Int
     line_buffered::Bool
@@ -219,55 +237,42 @@ function TTY(fd::RawFD; readable::Bool = false)
     ret
 end
 
-lock(t::TTY) = lock(t.lock)
-unlock(t::TTY) = unlock(t.lock)
+show(io::IO,stream::LibuvServer) = print(io, typeof(stream), "(", uv_status_string(stream), ")")
+show(io::IO, stream::LibuvStream) = print(io, typeof(stream), "(", uv_status_string(stream), ", ",
+    nb_available(stream.buffer)," bytes waiting)")
+
+# Shared LibuvStream object interface
 
-# note that uv_is_readable/writable work for any subtype of
-# uv_stream_t, including uv_tty_t and uv_pipe_t
-function isreadable(io::Union{PipeEndpoint,TTY})
+function isreadable(io::LibuvStream)
     nb_available(io) > 0 && return true
     isopen(io) || return false
     return ccall(:uv_is_readable, Cint, (Ptr{Void},), io.handle) != 0
 end
-function iswritable(io::Union{PipeEndpoint,TTY})
+
+function iswritable(io::LibuvStream)
     isopen(io) || return false
     io.status == StatusClosing && return false
     return ccall(:uv_is_writable, Cint, (Ptr{Void},), io.handle) != 0
 end
 
-nb_available(stream::AsyncStream) = nb_available(stream.buffer)
+lock(s::LibuvStream) = lock(s.lock)
+unlock(s::LibuvStream) = unlock(s.lock)
 
-show(io::IO,stream::TTY) = print(io,"TTY(",uv_status_string(stream),", ",
-    nb_available(stream.buffer)," bytes waiting)")
+uvtype(::LibuvStream) = UV_STREAM
+uvhandle(stream::LibuvStream) = stream.handle
+unsafe_convert(::Type{Ptr{Void}}, s::Union{LibuvStream, LibuvServer}) = s.handle
 
-function println(io::AsyncStream, xs...)
-    lock(io)
-    try
-        invoke(println, Tuple{IO, map(typeof,xs)...}, io, xs...)
-    finally
-        unlock(io)
-    end
-end
-
-
-uvtype(::AsyncStream) = UV_STREAM
-uvhandle(stream::AsyncStream) = stream.handle
-
-convert(T::Type{Ptr{Void}}, s::AsyncStream) = convert(T, s.handle)
-handle(s::AsyncStream) = s.handle
-handle(s::Ptr{Void}) = s
-
-associate_julia_struct(handle::Ptr{Void},jlobj::ANY) =
-    ccall(:jl_uv_associate_julia_struct,Void,(Ptr{Void},Any),handle,jlobj)
+associate_julia_struct(handle::Ptr{Void}, jlobj::ANY) =
+    ccall(:jl_uv_associate_julia_struct, Void, (Ptr{Void}, Any), handle, jlobj)
 disassociate_julia_struct(uv) = disassociate_julia_struct(uv.handle)
 disassociate_julia_struct(handle::Ptr{Void}) =
-    handle != C_NULL && ccall(:jl_uv_disassociate_julia_struct,Void,(Ptr{Void},),handle)
+    handle != C_NULL && ccall(:jl_uv_disassociate_julia_struct, Void, (Ptr{Void},), handle)
 
-function init_stdio(handle)
-    t = ccall(:jl_uv_handle_type,Int32,(Ptr{Void},),handle)
+function init_stdio(handle::Ptr{Void})
+    t = ccall(:jl_uv_handle_type, Int32, (Ptr{Void},), handle)
     if t == UV_FILE
-        return fdio(ccall(:jl_uv_file_handle,Int32,(Ptr{Void},),handle))
-#       Replace ios.c filw with libuv file?
+        return fdio(ccall(:jl_uv_file_handle, Int32, (Ptr{Void},), handle))
+#       Replace ios.c file with libuv file?
 #       return File(RawFD(ccall(:jl_uv_file_handle,Int32,(Ptr{Void},),handle)))
     else
         if t == UV_TTY
@@ -281,21 +286,12 @@ function init_stdio(handle)
         end
         ret.status = StatusOpen
         ret.line_buffered = false
-        associate_julia_struct(ret.handle,ret)
-        finalizer(ret,uvfinalize)
+        associate_julia_struct(ret.handle, ret)
+        finalizer(ret, uvfinalize)
         return ret
     end
 end
 
-function stream_wait(x, c...) # for x::LibuvObject
-    preserve_handle(x)
-    try
-        return wait(c...)
-    finally
-        unpreserve_handle(x)
-    end
-end
-
 function reinit_stdio()
     global uv_jl_asynccb       = cfunction(uv_asynccb, Void, (Ptr{Void},))
     global uv_jl_timercb       = cfunction(uv_timercb, Void, (Ptr{Void},))
@@ -308,9 +304,6 @@ function reinit_stdio()
     global uv_jl_recvcb        = cfunction(uv_recvcb, Void, (Ptr{Void}, Cssize_t, Ptr{Void}, Ptr{Void}, Cuint))
     global uv_jl_sendcb        = cfunction(uv_sendcb, Void, (Ptr{Void}, Cint))
     global uv_jl_return_spawn  = cfunction(uv_return_spawn, Void, (Ptr{Void}, Int64, Int32))
-    global uv_jl_pollcb        = cfunction(uv_pollcb, Void, (Ptr{Void}, Cint, Cint))
-    global uv_jl_fspollcb      = cfunction(uv_fspollcb, Void, (Ptr{Void}, Cint, Ptr{Void}, Ptr{Void}))
-    global uv_jl_fseventscb    = cfunction(uv_fseventscb, Void, (Ptr{Void}, Ptr{Int8}, Int32, Int32))
 
     global uv_eventloop = ccall(:jl_global_event_loop, Ptr{Void}, ())
     global STDIN = init_stdio(ccall(:jl_stdin_stream ,Ptr{Void},()))
@@ -318,20 +311,20 @@ function reinit_stdio()
     global STDERR = init_stdio(ccall(:jl_stderr_stream,Ptr{Void},()))
 end
 
-function isopen(x::Union{AsyncStream,UVServer})
+function isopen(x::Union{LibuvStream, LibuvServer})
     if x.status == StatusUninit || x.status == StatusInit
         throw(ArgumentError("$x is not initialized"))
     end
     x.status != StatusClosed && x.status != StatusEOF
 end
 
-function check_open(x::Union{AsyncStream,UVServer})
+function check_open(x::Union{LibuvStream, LibuvServer})
     if !isopen(x) || x.status == StatusClosing
         throw(ArgumentError("stream is closed or unusable"))
     end
 end
 
-function wait_connected(x)
+function wait_connected(x::Union{LibuvStream, LibuvServer})
     check_open(x)
     while x.status == StatusConnecting
         stream_wait(x, x.connectnotify)
@@ -339,10 +332,15 @@ function wait_connected(x)
     end
 end
 
-function wait_readbyte(x::AsyncStream, c::UInt8)
+function wait_readbyte(x::LibuvStream, c::UInt8)
+    if isopen(x) # fast path
+        search(x.buffer, c) > 0 && return
+    else
+        return
+    end
     preserve_handle(x)
     try
-        while isopen(x) && search(x.buffer,c) <= 0
+        while isopen(x) && search(x.buffer, c) <= 0
             start_reading(x) # ensure we are reading
             wait(x.readnotify)
         end
@@ -352,9 +350,15 @@ function wait_readbyte(x::AsyncStream, c::UInt8)
         end
         unpreserve_handle(x)
     end
+    nothing
 end
 
-function wait_readnb(x::AsyncStream, nb::Int)
+function wait_readnb(x::LibuvStream, nb::Int)
+    if isopen(x) # fast path
+        nb_available(x.buffer) >= nb && return
+    else
+        return
+    end
     oldthrottle = x.throttle
     preserve_handle(x)
     try
@@ -372,18 +376,69 @@ function wait_readnb(x::AsyncStream, nb::Int)
         end
         unpreserve_handle(x)
     end
+    nothing
 end
 
-function wait_close(x::AsyncStream)
+function wait_close(x::Union{LibuvStream, LibuvServer})
     if isopen(x)
         stream_wait(x, x.closenotify)
     end
+    nothing
+end
+
+function close(stream::Union{LibuvStream, LibuvServer})
+    if isopen(stream) && stream.status != StatusClosing
+        ccall(:jl_close_uv,Void, (Ptr{Void},), stream.handle)
+        stream.status = StatusClosing
+    end
+    nothing
+end
+
+@windows_only begin
+    ispty(s::TTY) = s.ispty
+    ispty(s::IO) = false
+end
+
+"    displaysize(io) -> (lines, columns)
+Return the nominal size of the screen that may be used for rendering output to this io object"
+displaysize(io::IO) = displaysize()
+displaysize() = (parse(Int, get(ENV, "LINES",   "24")),
+                 parse(Int, get(ENV, "COLUMNS", "80")))::Tuple{Int, Int}
+
+function displaysize(io::TTY)
+    local h::Int, w::Int
+    default_size = displaysize()
+
+    @windows_only if ispty(io)
+        # io is actually a libuv pipe but a cygwin/msys2 pty
+        try
+            h, w = map(x -> parse(Int, x), split(readstring(open(Base.Cmd(ByteString["stty", "size"]), "r", io)[1])))
+            h > 0 || (h = default_size[1])
+            w > 0 || (w = default_size[2])
+            return h, w
+        catch
+            return default_size
+        end
+    end
+
+    s1 = Ref{Int32}(0)
+    s2 = Ref{Int32}(0)
+    Base.uv_error("size (TTY)", ccall(:uv_tty_get_winsize,
+                                      Int32, (Ptr{Void}, Ptr{Int32}, Ptr{Int32}),
+                                      io, s1, s2) != 0)
+    w, h = s1[], s2[]
+    h > 0 || (h = default_size[1])
+    w > 0 || (w = default_size[2])
+    return h, w
 end
 
+
+### Libuv callbacks ###
+
 #from `connect`
 function uv_connectcb(conn::Ptr{Void}, status::Cint)
     hand = ccall(:jl_uv_connect_handle, Ptr{Void}, (Ptr{Void},), conn)
-    sock = @handle_as hand AsyncStream
+    sock = @handle_as hand LibuvStream
     @assert sock.status == StatusConnecting
     if status >= 0
         sock.status = StatusOpen
@@ -402,16 +457,17 @@ end
 
 # from `listen`
 function uv_connectioncb(stream::Ptr{Void}, status::Cint)
-    sock = @handle_as stream UVServer
+    sock = @handle_as stream LibuvServer
     if status >= 0
         err = nothing
     else
         err = UVError("connection",status)
     end
-    if isa(sock.ccb,Function)
-        sock.ccb(sock,status)
+    if isa(sock.ccb, Function)
+        sock.ccb(sock, status)
     end
-    err===nothing ? notify(sock.connectnotify) : notify_error(sock.connectnotify, err)
+    err === nothing ? notify(sock.connectnotify) : notify_error(sock.connectnotify, err)
+    nothing
 end
 
 ## BUFFER ##
@@ -419,7 +475,7 @@ end
 function alloc_request(buffer::IOBuffer, recommended_size::UInt)
     ensureroom(buffer, Int(recommended_size))
     ptr = buffer.append ? buffer.size + 1 : buffer.ptr
-    return (pointer(buffer.data, ptr), length(buffer.data)-ptr+1)
+    return (pointer(buffer.data, ptr), length(buffer.data) - ptr + 1)
 end
 
 function uv_alloc_buf(handle::Ptr{Void}, size::Csize_t, buf::Ptr{Void})
@@ -428,9 +484,9 @@ function uv_alloc_buf(handle::Ptr{Void}, size::Csize_t, buf::Ptr{Void})
         ccall(:jl_uv_buf_set_len, Void, (Ptr{Void}, Csize_t), buf, 0)
         return nothing
     end
-    stream = unsafe_pointer_to_objref(hd)::AsyncStream
+    stream = unsafe_pointer_to_objref(hd)::LibuvStream
 
-    (data,newsize) = alloc_buf_hook(stream, UInt(size))
+    (data, newsize) = alloc_buf_hook(stream, UInt(size))
 
     ccall(:jl_uv_buf_set_base, Void, (Ptr{Void}, Ptr{Void}), buf, data)
     ccall(:jl_uv_buf_set_len, Void, (Ptr{Void}, Csize_t), buf, newsize)
@@ -438,7 +494,7 @@ function uv_alloc_buf(handle::Ptr{Void}, size::Csize_t, buf::Ptr{Void})
     nothing
 end
 
-alloc_buf_hook(stream::AsyncStream, size::UInt) = alloc_request(stream.buffer, UInt(size))
+alloc_buf_hook(stream::LibuvStream, size::UInt) = alloc_request(stream.buffer, UInt(size))
 
 function notify_filled(buffer::IOBuffer, nread::Int, base::Ptr{Void}, len::UInt)
     if buffer.append
@@ -447,7 +503,8 @@ function notify_filled(buffer::IOBuffer, nread::Int, base::Ptr{Void}, len::UInt)
         buffer.ptr += nread
     end
 end
-function notify_filled(stream::AsyncStream, nread::Int)
+
+function notify_filled(stream::LibuvStream, nread::Int)
     more = true
     while more
         if isa(stream.readcb,Function)
@@ -464,7 +521,7 @@ function notify_filled(stream::AsyncStream, nread::Int)
 end
 
 function uv_readcb(handle::Ptr{Void}, nread::Cssize_t, buf::Ptr{Void})
-    stream = @handle_as handle AsyncStream
+    stream = @handle_as handle LibuvStream
     nread = Int(nread)
     base = ccall(:jl_uv_buf_base, Ptr{Void}, (Ptr{Void},), buf)
     len = UInt(ccall(:jl_uv_buf_len, Csize_t, (Ptr{Void},), buf))
@@ -474,7 +531,7 @@ function uv_readcb(handle::Ptr{Void}, nread::Cssize_t, buf::Ptr{Void})
             # remind the client that stream.buffer is full
             notify(stream.readnotify)
         elseif nread == UV_EOF
-            if isa(stream,TTY)
+            if isa(stream, TTY)
                 stream.status = StatusEOF # libuv called stop_reading already
                 notify(stream.readnotify)
                 notify(stream.closenotify)
@@ -484,7 +541,7 @@ function uv_readcb(handle::Ptr{Void}, nread::Cssize_t, buf::Ptr{Void})
         else
             # This is a fatal connection error. Shutdown requests as per the usual
             # close function won't work and libuv will fail with an assertion failure
-            ccall(:jl_forceclose_uv,Void,(Ptr{Void},),stream.handle)
+            ccall(:jl_forceclose_uv, Void, (Ptr{Void},), stream)
             notify_error(stream.readnotify, UVError("readcb",nread))
         end
     else
@@ -503,7 +560,6 @@ function uv_readcb(handle::Ptr{Void}, nread::Cssize_t, buf::Ptr{Void})
     nothing
 end
 
-reseteof(x::IO) = nothing
 function reseteof(x::TTY)
     if x.status == StatusEOF
         x.status = StatusOpen
@@ -511,7 +567,7 @@ function reseteof(x::TTY)
     nothing
 end
 
-function _uv_hook_close(uv::Union{AsyncStream,UVServer})
+function _uv_hook_close(uv::Union{LibuvStream, LibuvServer})
     uv.handle = C_NULL
     uv.status = StatusClosed
     if isa(uv.closecb, Function)
@@ -526,17 +582,16 @@ end
 
 ##########################################
 # Pipe Abstraction
-#  (composed of two half-pipes)
+#  (composed of two half-pipes: .in and .out)
 ##########################################
 
-abstract AbstractPipe <: AsyncStream
-# allows sharing implementation with Process and ProcessChain
-
 type Pipe <: AbstractPipe
     in::PipeEndpoint # writable
     out::PipeEndpoint # readable
 end
 Pipe() = Pipe(PipeEndpoint(), PipeEndpoint())
+pipe_reader(p::Pipe) = p.out
+pipe_writer(p::Pipe) = p.in
 
 function link_pipe(pipe::Pipe;
                julia_only_read = false,
@@ -544,36 +599,11 @@ function link_pipe(pipe::Pipe;
      link_pipe(pipe.out, julia_only_read, pipe.in, julia_only_write);
 end
 
-show(io::IO,stream::Pipe) = print(io,
+show(io::IO, stream::Pipe) = print(io,
     "Pipe(",
     uv_status_string(stream.in), " => ",
     uv_status_string(stream.out), ", ",
     nb_available(stream), " bytes waiting)")
-write(io::AbstractPipe, byte::UInt8) = write(io.in, byte)
-write(io::AbstractPipe, bytes::Vector{UInt8}) = write(io.in, bytes)
-write{T<:AbstractPipe}(io::T, args...) = write(io.in, args...)
-write{S<:AbstractPipe}(io::S, a::Array) = write(io.in, a)
-buffer_or_write(io::AbstractPipe, p::Ptr, n::Integer) = buffer_or_write(io.in, p, n)
-buffer_writes(io::AbstractPipe, args...) = buffer_writes(io.in, args...)
-flush(io::AbstractPipe) = flush(io.in)
-
-read(io::AbstractPipe, byte::Type{UInt8}) = read(io.out, byte)
-read!(io::AbstractPipe, bytes::Vector{UInt8}) = read!(io.out, bytes)
-read{T<:AbstractPipe}(io::T, args...) = read(io.out, args...)
-read!{T<:AbstractPipe}(io::T, args...) = read!(io.out, args...)
-readuntil{T<:AbstractPipe}(io::T, args...) = readuntil(io.out, args...)
-readbytes(io::AbstractPipe) = readbytes(io.out)
-readavailable(io::AbstractPipe) = readavailable(io.out)
-
-isreadable(io::AbstractPipe) = isreadable(io.out)
-iswritable(io::AbstractPipe) = iswritable(io.in)
-isopen(io::AbstractPipe) = isopen(io.in) || isopen(io.out)
-close(io::AbstractPipe) = (close(io.in); close(io.out))
-wait_readnb(io::AbstractPipe, nb::Int) = wait_readnb(io.out, nb)
-wait_readbyte(io::AbstractPipe, byte::UInt8) = wait_readbyte(io.out, byte)
-wait_close(io::AbstractPipe) = (wait_close(io.in); wait_close(io.out))
-nb_available(io::AbstractPipe) = nb_available(io.out)
-eof(io::AbstractPipe) = eof(io.out)
 
 ##########################################
 # Async Worker
@@ -633,7 +663,7 @@ type Timer
         ccall(:uv_timer_start, Cint, (Ptr{Void},Ptr{Void},UInt64,UInt64),
               this.handle, uv_jl_timercb::Ptr{Void},
               UInt64(round(timeout*1000))+1, UInt64(round(repeat*1000)))
-        this
+        return this
     end
 end
 
@@ -647,6 +677,7 @@ function close(t::Timer)
         ccall(:uv_timer_stop, Cint, (Ptr{Void},), t.handle)
         ccall(:jl_close_uv, Void, (Ptr{Void},), t.handle)
     end
+    nothing
 end
 
 function _uv_hook_close(t::Timer)
@@ -692,7 +723,7 @@ function Timer(cb::Function, timeout::Real, repeat::Real=0.0)
     # we re-enter the event loop. this avoids a race condition. see issue #12719
     enq_work(current_task())
     yieldto(waiter)
-    t
+    return t
 end
 
 ## event loop ##
@@ -705,28 +736,48 @@ end
 function process_events(block::Bool)
     loop = eventloop()
     if block
-        ccall(:jl_run_once,Int32,(Ptr{Void},),loop)
+        return ccall(:jl_run_once,Int32,(Ptr{Void},),loop)
     else
-        ccall(:jl_process_events,Int32,(Ptr{Void},),loop)
+        return ccall(:jl_process_events,Int32,(Ptr{Void},),loop)
     end
 end
 
-## pipe functions ##
-function malloc_julia_pipe!(x)
+## Functions for PipeEndpoint and PipeServer ##
+
+function init_pipe!(pipe::LibuvPipe;
+                    readable::Bool = false,
+                    writable::Bool = false,
+                    julia_only::Bool = true)
+    if pipe.status != StatusUninit
+        error("pipe is already initialized")
+    end
+    if pipe.handle == C_NULL
+        malloc_julia_pipe!(pipe)
+    end
+    uv_error("init_pipe",ccall(:jl_init_pipe, Cint,
+        (Ptr{Void}, Int32, Int32, Int32),
+        pipe.handle, writable, readable, julia_only))
+    pipe.status = StatusInit
+    return pipe
+end
+
+function malloc_julia_pipe!(x::LibuvPipe)
     assert(x.handle == C_NULL)
     x.handle = Libc.malloc(_sizeof_uv_named_pipe)
     associate_julia_struct(x.handle, x)
     finalizer(x, uvfinalize)
+    nothing
 end
 
 function _link_pipe(read_end::Ptr{Void}, write_end::Ptr{Void})
     uv_error("pipe_link",
         ccall(:uv_pipe_link, Int32, (Ptr{Void}, Ptr{Void}), read_end, write_end))
+    nothing
 end
 
 function link_pipe(read_end::Ptr{Void}, readable_julia_only::Bool,
                    write_end::Ptr{Void}, writable_julia_only::Bool,
-                   readpipe::AsyncStream, writepipe::AsyncStream)
+                   readpipe::PipeEndpoint, writepipe::PipeEndpoint)
     #make the pipe an unbuffered stream for now
     #TODO: this is probably not freeing memory properly after errors
     uv_error("init_pipe(read)",
@@ -734,6 +785,7 @@ function link_pipe(read_end::Ptr{Void}, readable_julia_only::Bool,
     uv_error("init_pipe(write)",
         ccall(:jl_init_pipe, Cint, (Ptr{Void},Int32,Int32,Int32), write_end, 1, 0, writable_julia_only))
     _link_pipe(read_end, write_end)
+    nothing
 end
 
 function link_pipe(read_end::Ptr{Void}, readable_julia_only::Bool,
@@ -743,6 +795,7 @@ function link_pipe(read_end::Ptr{Void}, readable_julia_only::Bool,
     uv_error("init_pipe(write)",
         ccall(:jl_init_pipe, Cint, (Ptr{Void},Int32,Int32,Int32), write_end, 1, 0, writable_julia_only))
     _link_pipe(read_end,write_end)
+    nothing
 end
 
 function link_pipe(read_end::PipeEndpoint, readable_julia_only::Bool,
@@ -756,6 +809,7 @@ function link_pipe(read_end::PipeEndpoint, readable_julia_only::Bool,
         ccall(:jl_init_pipe, Cint, (Ptr{Void},Int32,Int32,Int32), write_end, 1, 0, writable_julia_only))
     _link_pipe(read_end.handle, write_end)
     read_end.status = StatusOpen
+    nothing
 end
 
 function link_pipe(read_end::Ptr{Void}, readable_julia_only::Bool,
@@ -769,6 +823,7 @@ function link_pipe(read_end::Ptr{Void}, readable_julia_only::Bool,
         readable = false, writable = true, julia_only = writable_julia_only)
     _link_pipe(read_end, write_end.handle)
     write_end.status = StatusOpen
+    nothing
 end
 
 function link_pipe(read_end::PipeEndpoint, readable_julia_only::Bool,
@@ -794,35 +849,30 @@ function close_pipe_sync(p::PipeEndpoint)
     p.status = StatusClosed
     nothing
 end
-function close_pipe_sync(handle::UVHandle)
-    ccall(:uv_pipe_close_sync, Void, (UVHandle,), handle)
-end
 
-function close(stream::Union{AsyncStream, UVServer})
-    if isopen(stream) && stream.status != StatusClosing
-        ccall(:jl_close_uv,Void, (Ptr{Void},), stream.handle)
-        stream.status = StatusClosing
-    end
-    nothing
+function close_pipe_sync(handle::Ptr{Void})
+    return ccall(:uv_pipe_close_sync, Void, (Ptr{Void},), handle)
 end
 
-## stream functions ##
-function start_reading(stream::AsyncStream)
+## Functions for any LibuvStream ##
+
+function start_reading(stream::LibuvStream)
     if stream.status == StatusOpen
         if !isreadable(stream)
             error("tried to read a stream that is not readable")
         end
-        ret = ccall(:uv_read_start,Cint,(Ptr{Void},Ptr{Void},Ptr{Void}),
-                    handle(stream),uv_jl_alloc_buf::Ptr{Void},uv_jl_readcb::Ptr{Void})
+        ret = ccall(:uv_read_start, Cint, (Ptr{Void}, Ptr{Void}, Ptr{Void}),
+                    stream, uv_jl_alloc_buf::Ptr{Void}, uv_jl_readcb::Ptr{Void})
         stream.status = StatusActive
-        ret
+        return ret
     elseif stream.status == StatusActive
-        Int32(0)
+        return Int32(0)
     else
-        Int32(-1)
+        return Int32(-1)
     end
 end
-function start_reading(stream::AsyncStream, cb::Function)
+
+function start_reading(stream::LibuvStream, cb::Function)
     failure = start_reading(stream)
     stream.readcb = cb
     nread = nb_available(stream.buffer)
@@ -831,50 +881,38 @@ function start_reading(stream::AsyncStream, cb::Function)
     end
     return failure_code
 end
-function start_reading(stream::AsyncStream, cb::Bool)
+
+function start_reading(stream::LibuvStream, cb::Bool)
     failure_code = start_reading(stream)
     stream.readcb = cb
     return failure_code
 end
 
-function stop_reading(stream::AsyncStream)
+function stop_reading(stream::LibuvStream)
     if stream.status == StatusActive
-        ret = ccall(:uv_read_stop,Cint,(Ptr{Void},),stream.handle)
+        ret = ccall(:uv_read_stop, Cint, (Ptr{Void},), stream)
         stream.status = StatusOpen
-        ret
+        return ret
     elseif stream.status == StatusOpen
-        Int32(0)
+        return Int32(0)
     else
-        Int32(-1)
+        return Int32(-1)
     end
 end
 
-function readbytes(stream::AsyncStream)
-    wait_readnb(stream, typemax(Int))
-    return takebuf_array(stream.buffer)
-end
-
-function read!{T}(s::AsyncStream, a::Array{T})
-    isbits(T) || throw(ArgumentError("read from AsyncStream only supports bits types or arrays of bits types"))
-    nb = length(a) * sizeof(T)
-    read!(s, reshape(reinterpret(UInt8, a), nb))
-    return a
-end
-
-const SZ_UNBUFFERED_IO=65536
-function read!(s::AsyncStream, a::Vector{UInt8})
-    nb = length(a)
+readbytes!(s::LibuvStream, a::Vector{UInt8}, nb = length(a)) = readbytes!(s, a, Int(nb))
+function readbytes!(s::LibuvStream, a::Vector{UInt8}, nb::Int)
     sbuf = s.buffer
     @assert sbuf.seekable == false
     @assert sbuf.maxsize >= nb
 
     if nb_available(sbuf) >= nb
-        return read!(sbuf, a)
+        return readbytes!(sbuf, a, nb)
     end
 
     if nb <= SZ_UNBUFFERED_IO # Under this limit we are OK with copying the array from the stream's buffer
         wait_readnb(s, nb)
-        read!(sbuf, a)
+        return readbytes!(sbuf, a, nb)
     else
         try
             stop_reading(s) # Just playing it safe, since we are going to switch buffers.
@@ -882,77 +920,93 @@ function read!(s::AsyncStream, a::Vector{UInt8})
             newbuf.size = 0 # reset the write pointer to the beginning
             s.buffer = newbuf
             write(newbuf, sbuf)
-            wait_readnb(s, nb)
+            wait_readnb(s, Int(nb))
+            compact(newbuf)
+            return nb_available(newbuf)
         finally
             s.buffer = sbuf
             if !isempty(s.readnotify.waitq)
-                start_reading(x) # resume reading iff there are currently other read clients of the stream
+                start_reading(s) # resume reading iff there are currently other read clients of the stream
             end
         end
     end
-    return a
+    @assert false # unreachable
 end
 
-function read{T}(s::AsyncStream, ::Type{T}, dims::Dims)
-    isbits(T) || throw(ArgumentError("read from AsyncStream only supports bits types or arrays of bits types"))
-    nb = prod(dims)*sizeof(T)
-    a = read!(s, Array(UInt8, nb))
-    reshape(reinterpret(T, a), dims)
+function read(stream::LibuvStream)
+    wait_readnb(stream, typemax(Int))
+    return takebuf_array(stream.buffer)
 end
 
-function read(this::AsyncStream,::Type{UInt8})
-    buf = this.buffer
-    @assert buf.seekable == false
-    wait_readnb(this, 1)
-    read(buf, UInt8)
-end
+function unsafe_read(s::LibuvStream, p::Ptr{UInt8}, nb::UInt)
+    sbuf = s.buffer
+    @assert sbuf.seekable == false
+    @assert sbuf.maxsize >= nb
 
-readline(this::AsyncStream) = readuntil(this, '\n')
+    if nb_available(sbuf) >= nb
+        return unsafe_read(sbuf, p, nb)
+    end
 
-readline() = readline(STDIN)
+    if nb <= SZ_UNBUFFERED_IO # Under this limit we are OK with copying the array from the stream's buffer
+        wait_readnb(s, Int(nb))
+        unsafe_read(sbuf, p, nb)
+    else
+        try
+            stop_reading(s) # Just playing it safe, since we are going to switch buffers.
+            newbuf = PipeBuffer(pointer_to_array(p, nb), #=maxsize=# Int(nb))
+            newbuf.size = 0 # reset the write pointer to the beginning
+            s.buffer = newbuf
+            write(newbuf, sbuf)
+            wait_readnb(s, Int(nb))
+            nb == nb_available(newbuf) || throw(EOFError())
+        finally
+            s.buffer = sbuf
+            if !isempty(s.readnotify.waitq)
+                start_reading(s) # resume reading iff there are currently other read clients of the stream
+            end
+        end
+    end
+    nothing
+end
 
-function readavailable(this::AsyncStream)
+function read(this::LibuvStream, ::Type{UInt8})
+    wait_readnb(this, 1)
     buf = this.buffer
     @assert buf.seekable == false
-    wait_readnb(this, 1)
-    takebuf_array(buf)
+    return read(buf, UInt8)
 end
 
-function readuntil(this::AsyncStream, c::UInt8)
+function readavailable(this::LibuvStream)
+    wait_readnb(this, 1)
     buf = this.buffer
     @assert buf.seekable == false
-    wait_readbyte(this, c)
-    readuntil(buf, c)
+    return takebuf_array(buf)
 end
 
-#function finish_read(pipe::PipeEndpoint)
-#    close(pipe) #handles to UV and ios will be invalid after this point
-#end
-#
-#function finish_read(state::(PipeEndpoint,ByteString))
-#    finish_read(state...)
-#end
+function readuntil(this::LibuvStream, c::UInt8)
+    wait_readbyte(this, c)
+    buf = this.buffer
+    @assert buf.seekable == false
+    return readuntil(buf, c)
+end
 
-function uv_write(s::AsyncStream, p, n::Integer)
+uv_write(s::LibuvStream, p::Vector{UInt8}) = uv_write(s, pointer(p), UInt(sizeof(p)))
+function uv_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt)
     check_open(s)
     uvw = Libc.malloc(_sizeof_uv_write)
-    try
-        uv_req_set_data(uvw,C_NULL)
-        err = ccall(:jl_uv_write,
-                    Int32,
-                    (Ptr{Void}, Ptr{Void}, UInt, Ptr{Void}, Ptr{Void}),
-                    handle(s), p, n, uvw,
-                    uv_jl_writecb_task::Ptr{Void})
-        if err < 0
-            uv_error("write", err)
-        end
-        ct = current_task()
-        uv_req_set_data(uvw,ct)
-        ct.state = :waiting
-        stream_wait(ct)
-    finally
+    uv_req_set_data(uvw,C_NULL)
+    err = ccall(:jl_uv_write,
+                Int32,
+                (Ptr{Void}, Ptr{Void}, UInt, Ptr{Void}, Ptr{Void}),
+                s, p, n, uvw,
+                uv_jl_writecb_task::Ptr{Void})
+    if err < 0
         Libc.free(uvw)
+        uv_error("write", err)
     end
+    ct = current_task()
+    uv_req_set_data(uvw,ct)
+    stream_wait(ct)
     return Int(n)
 end
 
@@ -960,80 +1014,68 @@ end
 # - smaller writes are buffered, final uv write on flush or when buffer full
 # - large isbits arrays are unbuffered and written directly
 
-function buffer_or_write(s::AsyncStream, p::Ptr, n::Integer)
+function unsafe_write(s::LibuvStream, p::Ptr{UInt8}, n::UInt)
     if isnull(s.sendbuf)
-        return uv_write(s, p, n)
-    else
-        buf = get(s.sendbuf)
+        return uv_write(s, p, UInt(n))
     end
 
+    buf = get(s.sendbuf)
     totb = nb_available(buf) + n
     if totb < buf.maxsize
-        nb = write(buf, p, n)
+        nb = unsafe_write(buf, p, n)
     else
         flush(s)
         if n > buf.maxsize
             nb = uv_write(s, p, n)
         else
-            nb = write(buf, p, n)
+            nb = unsafe_write(buf, p, n)
         end
     end
     return nb
 end
 
-function flush(s::AsyncStream)
+function flush(s::LibuvStream)
     if isnull(s.sendbuf)
         return s
     end
     buf = get(s.sendbuf)
     if nb_available(buf) > 0
         arr = takebuf_array(buf)        # Array of UInt8s
-        uv_write(s, arr, length(arr))
+        uv_write(s, arr)
     end
-    s
+    return s
 end
 
-buffer_writes(s::AsyncStream, bufsize=SZ_UNBUFFERED_IO) = (s.sendbuf=PipeBuffer(bufsize); s)
+buffer_writes(s::LibuvStream, bufsize) = (s.sendbuf=PipeBuffer(bufsize); s)
 
-## low-level calls ##
+## low-level calls to libuv ##
 
-write(s::AsyncStream, b::UInt8) = write(s, [b])
-write(s::AsyncStream, c::Char) = write(s, string(c))
-function write{T}(s::AsyncStream, a::Array{T})
-    if isbits(T)
-        n = UInt(length(a)*sizeof(T))
-        return buffer_or_write(s, pointer(a), n);
-    else
-        check_open(s)
-        invoke(write, Tuple{IO, Array},s,a)
-    end
-end
-
-write(s::AsyncStream, p::Ptr, n::Integer) = buffer_or_write(s, p, n)
+write(s::LibuvStream, b::UInt8) = write(s, Ref{UInt8}(b))
 
 function uv_writecb_task(req::Ptr{Void}, status::Cint)
-    #handle = ccall(:jl_uv_write_handle, Ptr{Void}, (Ptr{Void},), req)
-    #s = @handle_as handle AsyncStream
     d = uv_req_data(req)
-    @assert d != C_NULL
-    if status < 0
-        err = UVError("write",status)
-        schedule(unsafe_pointer_to_objref(d)::Task,err,error=true)
-    else
-        schedule(unsafe_pointer_to_objref(d)::Task)
+    if d != C_NULL
+        if status < 0
+            err = UVError("write",status)
+            schedule(unsafe_pointer_to_objref(d)::Task,err,error=true)
+        else
+            schedule(unsafe_pointer_to_objref(d)::Task)
+        end
     end
+    Libc.free(req)
     nothing
 end
 
 ## Libuv error handling ##
+
 type UVError <: Exception
     prefix::AbstractString
     code::Int32
     UVError(p::AbstractString,code::Integer)=new(p,code)
 end
 
-struverror(err::UVError) = bytestring(ccall(:uv_strerror,Ptr{UInt8},(Int32,),err.code))
-uverrorname(err::UVError) = bytestring(ccall(:uv_err_name,Ptr{UInt8},(Int32,),err.code))
+struverror(err::UVError) = bytestring(ccall(:uv_strerror,Cstring,(Int32,),err.code))
+uverrorname(err::UVError) = bytestring(ccall(:uv_err_name,Cstring,(Int32,),err.code))
 
 uv_error(prefix::Symbol, c::Integer) = uv_error(string(prefix),c)
 uv_error(prefix::AbstractString, c::Integer) = c < 0 ? throw(UVError(prefix,c)) : nothing
@@ -1059,7 +1101,7 @@ function accept_nonblock(server::PipeServer)
     client
 end
 
-function accept(server::UVServer, client::AsyncStream)
+function accept(server::LibuvServer, client::LibuvStream)
     if server.status != StatusActive
         throw(ArgumentError("server not connected, make sure \"listen\" has been called"))
     end
@@ -1077,10 +1119,10 @@ end
 
 const BACKLOG_DEFAULT = 511
 
-function _listen(sock::UVServer; backlog::Integer=BACKLOG_DEFAULT)
+function _listen(sock::LibuvServer; backlog::Integer=BACKLOG_DEFAULT)
     check_open(sock)
     err = ccall(:uv_listen, Cint, (Ptr{Void}, Cint, Ptr{Void}),
-                sock.handle, backlog, uv_jl_connectioncb::Ptr{Void})
+                sock, backlog, uv_jl_connectioncb::Ptr{Void})
     sock.status = StatusActive
     err
 end
@@ -1088,7 +1130,7 @@ end
 function bind(server::PipeServer, name::AbstractString)
     @assert server.status == StatusInit
     err = ccall(:uv_pipe_bind, Int32, (Ptr{Void}, Cstring),
-                server.handle, name)
+                server, name)
     if err != 0
         if err != UV_EADDRINUSE && err != UV_EACCES
             #TODO: this codepath is currently not tested
@@ -1118,8 +1160,8 @@ function connect!(sock::PipeEndpoint, path::AbstractString)
     sock
 end
 
-function connect(sock::AsyncStream, args...)
-    connect!(sock,args...)
+function connect(sock::LibuvStream, args...)
+    connect!(sock, args...)
     wait_connected(sock)
     sock
 end
@@ -1129,8 +1171,8 @@ end
 connect(path::AbstractString) = connect(init_pipe!(PipeEndpoint(); readable=false, writable=false, julia_only=true),path)
 
 _fd(x::IOStream) = RawFD(fd(x))
-@unix_only _fd(x::AsyncStream) = RawFD(ccall(:jl_uv_handle,Int32,(Ptr{Void},),x.handle))
-@windows_only _fd(x::AsyncStream) = WindowsRawSocket(
+@unix_only _fd(x::LibuvStream) = RawFD(ccall(:jl_uv_handle,Int32,(Ptr{Void},),x.handle))
+@windows_only _fd(x::LibuvStream) = WindowsRawSocket(
     ccall(:jl_uv_handle,Ptr{Void},(Ptr{Void},),x.handle))
 
 for (x,writable,unix_fd,c_symbol) in ((:STDIN,false,0,:jl_uv_stdin),(:STDOUT,true,1,:jl_uv_stdout),(:STDERR,true,2,:jl_uv_stderr))
@@ -1141,11 +1183,11 @@ for (x,writable,unix_fd,c_symbol) in ((:STDIN,false,0,:jl_uv_stdin),(:STDOUT,tru
             global $x
             @windows? (
                 ccall(:SetStdHandle,stdcall,Int32,(Int32,Ptr{Void}),
-                    $(-10-unix_fd), Libc._get_osfhandle(_fd(stream)).handle) :
+                    $(-10-unix_fd), Libc._get_osfhandle(_fd(stream)).handle) ) : (
                 dup(_fd(stream),  RawFD($unix_fd)) )
             $x = stream
         end
-        function ($f)(handle::Union{AsyncStream,IOStream})
+        function ($f)(handle::Union{LibuvStream,IOStream})
             $(_f)(handle)
             unsafe_store!(cglobal($(Expr(:quote,c_symbol)),Ptr{Void}),
                 handle.handle)
@@ -1160,13 +1202,13 @@ for (x,writable,unix_fd,c_symbol) in ((:STDIN,false,0,:jl_uv_stdin),(:STDOUT,tru
     end
 end
 
-mark(x::AsyncStream)     = mark(x.buffer)
-unmark(x::AsyncStream)   = unmark(x.buffer)
-reset(x::AsyncStream)    = reset(x.buffer)
-ismarked(x::AsyncStream) = ismarked(x.buffer)
+mark(x::LibuvStream)     = mark(x.buffer)
+unmark(x::LibuvStream)   = unmark(x.buffer)
+reset(x::LibuvStream)    = reset(x.buffer)
+ismarked(x::LibuvStream) = ismarked(x.buffer)
 
 # BufferStream's are non-OS streams, backed by a regular IOBuffer
-type BufferStream <: AsyncStream
+type BufferStream <: LibuvStream
     buffer::IOBuffer
     r_c::Condition
     close_c::Condition
@@ -1177,10 +1219,14 @@ type BufferStream <: AsyncStream
     BufferStream() = new(PipeBuffer(), Condition(), Condition(), true, false, ReentrantLock())
 end
 
-lock(s::BufferStream) = lock(s.lock)
-unlock(s::BufferStream) = unlock(s.unlock)
 isopen(s::BufferStream) = s.is_open
 close(s::BufferStream) = (s.is_open = false; notify(s.r_c; all=true); notify(s.close_c; all=true); nothing)
+read(s::BufferStream, ::Type{UInt8}) = (wait_readnb(s, 1); read(s.buffer, UInt8))
+unsafe_read(s::BufferStream, a::Ptr{UInt8}, nb::UInt) = (wait_readnb(s, Int(nb)); unsafe_read(s.buffer, a, nb))
+nb_available(s::BufferStream) = nb_available(s.buffer)
+
+isreadable(s::BufferStream) = s.buffer.readable
+iswritable(s::BufferStream) = s.buffer.writable
 
 function wait_readnb(s::BufferStream, nb::Int)
     while isopen(s) && nb_available(s.buffer) < nb
@@ -1196,21 +1242,19 @@ function wait_readbyte(s::BufferStream, c::UInt8)
     end
 end
 
-wait_close(s::BufferStream) = if isopen(s) wait(s.close_c); end
+wait_close(s::BufferStream) = if isopen(s); wait(s.close_c); end
 start_reading(s::BufferStream) = nothing
 
-write(s::BufferStream, b::UInt8) = write(s, [b])
-write(s::BufferStream, c::Char) = write(s, string(c))
-
-function write{T}(s::BufferStream, a::Array{T})
-    rv=write(s.buffer, a)
-    !(s.buffer_writes) && notify(s.r_c; all=true);
-    rv
+write(s::BufferStream, b::UInt8) = write(s, Ref{UInt8}(b))
+function unsafe_write(s::BufferStream, p::Ptr{UInt8}, nb::UInt)
+    rv = unsafe_write(s.buffer, p, nb)
+    !(s.buffer_writes) && notify(s.r_c; all=true)
+    return rv
 end
-function write(s::BufferStream, p::Ptr, nb::Integer)
-    rv=write(s.buffer, p, nb)
-    !(s.buffer_writes) && notify(s.r_c; all=true);
-    rv
+
+function eof(s::BufferStream)
+    wait_readnb(s, 1)
+    return !isopen(s) && nb_available(s)<=0
 end
 
 # If buffer_writes is called, it will delay notifying waiters till a flush is called.
diff --git a/base/strings/basic.jl b/base/strings/basic.jl
index d0d7a2de94df4..4375b827d6da8 100644
--- a/base/strings/basic.jl
+++ b/base/strings/basic.jl
@@ -15,7 +15,7 @@ bytestring(s::Vector{UInt8}) = bytestring(pointer(s),length(s))
 
 function bytestring(p::Union{Ptr{UInt8},Ptr{Int8}})
     p == C_NULL ? throw(ArgumentError("cannot convert NULL to string")) :
-    ccall(:jl_cstr_to_string, Any, (Ptr{UInt8},), p)::ByteString
+    ccall(:jl_cstr_to_string, Any, (Cstring,), p)::ByteString
 end
 bytestring(s::Cstring) = bytestring(convert(Ptr{UInt8}, s))
 
@@ -48,6 +48,8 @@ sizeof(s::AbstractString) = error("type $(typeof(s)) has no canonical binary rep
 eltype{T<:AbstractString}(::Type{T}) = Char
 
 (*)(s1::AbstractString, ss::AbstractString...) = string(s1, ss...)
+(.*){T<:AbstractString}(v::Vector{T},s::AbstractString) = [i*s for i in v]
+(.*){T<:AbstractString}(s::AbstractString,v::Vector{T}) = [s*i for i in v]
 
 length(s::DirectIndexString) = endof(s)
 function length(s::AbstractString)
diff --git a/base/strings/io.jl b/base/strings/io.jl
index 6bef21cbaa6db..9e8c72780782e 100644
--- a/base/strings/io.jl
+++ b/base/strings/io.jl
@@ -2,8 +2,25 @@
 
 ## core text I/O ##
 
-print(io::IO, x) = show(io, x)
-print(io::IO, xs...) = for x in xs print(io, x) end
+function print(io::IO, x)
+    lock(io)
+    try
+        show(io, x)
+    finally
+        unlock(io)
+    end
+end
+
+function print(io::IO, xs...)
+    lock(io)
+    try
+        for x in xs
+            print(io, x)
+        end
+    finally
+        unlock(io)
+    end
+end
 
 println(io::IO, xs...) = print(io, xs..., '\n')
 
@@ -12,17 +29,47 @@ println(xs...) = println(STDOUT, xs...)
 
 ## conversion of general objects to strings ##
 
-function print_to_string(xs...)
-    # specialized for performance reasons
-    s = IOBuffer(Array(UInt8,isa(xs[1],AbstractString) ? endof(xs[1]) : 0), true, true)
-    for x in xs
-        print(s, x)
+function sprint(size::Integer, f::Function, args...; env=nothing)
+    s = IOBuffer(Array(UInt8,size), true, true)
+    truncate(s,0)
+    if env !== nothing
+        f(IOContext(s, env), args...)
+    else
+        f(s, args...)
     end
     d = s.data
     resize!(d,s.size)
     bytestring(d)
 end
+sprint(f::Function, args...) = sprint(0, f, args...)
+
+tostr_sizehint(x) = 0
+tostr_sizehint(x::AbstractString) = endof(x)
+tostr_sizehint(x::Float64) = 20
+tostr_sizehint(x::Float32) = 12
+
+function print_to_string(xs...; env=nothing)
+    # specialized for performance reasons
+    s = IOBuffer(Array(UInt8,tostr_sizehint(xs[1])), true, true)
+    # specialized version of truncate(s,0)
+    s.size = 0
+    s.ptr = 1
+    if env !== nothing
+        env_io = IOContext(s, env)
+        for x in xs
+            print(env_io, x)
+        end
+    else
+        for x in xs
+            print(s, x)
+        end
+    end
+    d = s.data
+    resize!(d,s.size)
+    return isvalid(ASCIIString, d) ? ASCIIString(d) : UTF8String(d)
+end
 
+string_with_env(env, xs...) = print_to_string(xs...; env=env)
 string(xs...) = print_to_string(xs...)
 bytestring(s::AbstractString...) = print_to_string(s...)
 
diff --git a/base/strings/util.jl b/base/strings/util.jl
index 4e6901ef8d65f..7e9d15b8837aa 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -12,7 +12,7 @@ function startswith(a::AbstractString, b::AbstractString)
     end
     done(b,i)
 end
-startswith(str::AbstractString, chars::Chars) = !isempty(str) && str[start(str)] in chars
+startswith(str::AbstractString, chars::Chars) = !isempty(str) && first(str) in chars
 
 function endswith(a::AbstractString, b::AbstractString)
     i = endof(a)
@@ -28,11 +28,11 @@ function endswith(a::AbstractString, b::AbstractString)
     end
     j < b1
 end
-endswith(str::AbstractString, chars::Chars) = !isempty(str) && str[end] in chars
+endswith(str::AbstractString, chars::Chars) = !isempty(str) && last(str) in chars
 
 startswith(a::ByteString, b::ByteString) = startswith(a.data, b.data)
 startswith(a::Vector{UInt8}, b::Vector{UInt8}) =
-    (length(a) >= length(b) && ccall(:strncmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, length(b)) == 0)
+    (length(a) >= length(b) && ccall(:memcmp, Int32, (Ptr{UInt8}, Ptr{UInt8}, UInt), a, b, length(b)) == 0)
 
 # TODO: fast endswith
 
@@ -173,9 +173,9 @@ function _rsplit{T<:AbstractString,U<:Array}(str::T, splitter, limit::Integer, k
 end
 #rsplit(str::AbstractString) = rsplit(str, _default_delims, 0, false)
 
-_replace(io, repl, str, r, pattern) = write(io, repl)
+_replace(io, repl, str, r, pattern) = print(io, repl)
 _replace(io, repl::Function, str, r, pattern) =
-    write(io, repl(SubString(str, first(r), last(r))))
+    print(io, repl(SubString(str, first(r), last(r))))
 
 function replace(str::ByteString, pattern, repl, limit::Integer)
     n = 1
@@ -212,27 +212,34 @@ replace(s::AbstractString, pat, r) = replace(s, pat, r, 0)
 
 # hex <-> bytes conversion
 
-function hex2bytes(s::ASCIIString)
-    len = length(s)
-    iseven(len) || throw(ArgumentError("string length must be even: length($(repr(s))) == $len"))
-    arr = zeros(UInt8, div(len,2))
-    i = j = 0
-    while i < len
-        n = 0
-        c = s[i+=1]
+function hex2bytes(s::AbstractString)
+    a = zeros(UInt8, div(endof(s), 2))
+    i, j = start(s), 0
+    while !done(s, i)
+        c, i = next(s, i)
         n = '0' <= c <= '9' ? c - '0' :
             'a' <= c <= 'f' ? c - 'a' + 10 :
             'A' <= c <= 'F' ? c - 'A' + 10 :
-                throw(ArgumentError("not a hexadecimal string: $(repr(s))"))
-        c = s[i+=1]
+            throw(ArgumentError("not a hexadecimal string: $(repr(s))"))
+        done(s, i) &&
+            throw(ArgumentError("string length must be even: length($(repr(s))) == $(length(s))"))
+        c, i = next(s, i)
         n = '0' <= c <= '9' ? n << 4 + c - '0' :
             'a' <= c <= 'f' ? n << 4 + c - 'a' + 10 :
             'A' <= c <= 'F' ? n << 4 + c - 'A' + 10 :
-                throw(ArgumentError("not a hexadecimal string: $(repr(s))"))
-        arr[j+=1] = n
+            throw(ArgumentError("not a hexadecimal string: $(repr(s))"))
+        a[j += 1] = n
     end
-    return arr
+    resize!(a, j)
+    return a
 end
-hex2bytes(s::AbstractString) = hex2bytes(ascii(s))
 
-bytes2hex{T<:UInt8}(arr::Vector{T}) = join([hex(i,2) for i in arr])
+function bytes2hex(a::AbstractArray{UInt8})
+    b = Vector{UInt8}(2*length(a))
+    i = 0
+    for x in a
+        b[i += 1] = hex_chars[1 + x >> 4]
+        b[i += 1] = hex_chars[1 + x & 0xf]
+    end
+    return ASCIIString(b)
+end
diff --git a/base/subarray.jl b/base/subarray.jl
index 6d874f899c9f2..2ae359c29acf7 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -1,32 +1,78 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 typealias NonSliceIndex Union{Colon, AbstractVector}
-typealias ViewIndex Union{Int, NonSliceIndex}
+typealias ViewIndex Union{Real, NonSliceIndex}
 
-# LD is the last dimension up through which this object has efficient
-# linear indexing. If LD==length(I), then the object itself has efficient
-# linear indexing.
-immutable SubArray{T,N,P<:AbstractArray,I<:Tuple{Vararg{ViewIndex}},LD} <: AbstractArray{T,N}
+# L is true if the view itself supports fast linear indexing
+immutable SubArray{T,N,P,I,L} <: AbstractArray{T,N}
     parent::P
     indexes::I
     dims::NTuple{N,Int}
-    first_index::Int   # for linear indexing and pointer
+    first_index::Int   # for linear indexing and pointer, only valid when L==true
     stride1::Int       # used only for linear indexing
 end
+# Compute the linear indexability of the indices, and combine it with the linear indexing of the parent
+function SubArray(parent::AbstractArray, indexes::Tuple, dims::Tuple)
+    SubArray(linearindexing(viewindexing(indexes), linearindexing(parent)), parent, indexes, convert(Dims, dims))
+end
+function SubArray{P, I, N}(::LinearSlow, parent::P, indexes::I, dims::NTuple{N, Int})
+    SubArray{eltype(P), N, P, I, false}(parent, indexes, dims, 0, 0)
+end
+function SubArray{P, I, N}(::LinearFast, parent::P, indexes::I, dims::NTuple{N, Int})
+    # Compute the first index and stride
+    SubArray{eltype(P), N, P, I, true}(parent, indexes, dims, compute_first_index(parent, indexes), compute_stride1(parent, indexes))
+end
 
-typealias StridedArray{T,N,A<:DenseArray,I<:Tuple{Vararg{RangeIndex}}} Union{DenseArray{T,N}, SubArray{T,N,A,I}}
-typealias StridedVector{T,A<:DenseArray,I<:Tuple{Vararg{RangeIndex}}}  Union{DenseArray{T,1}, SubArray{T,1,A,I}}
-typealias StridedMatrix{T,A<:DenseArray,I<:Tuple{Vararg{RangeIndex}}}  Union{DenseArray{T,2}, SubArray{T,2,A,I}}
+# The NoSlice one-element vector type keeps dimensions without losing performance
+immutable NoSlice <: AbstractVector{Int}
+    i::Int
+end
+size(::NoSlice) = (1,)
+length(::NoSlice) = 1
+linearindexing(::Type{NoSlice}) = LinearFast()
+function getindex(N::NoSlice, i::Int)
+    @_inline_meta
+    @boundscheck i == 1 || throw_boundserror(N, i)
+    N.i
+end
+function getindex(N::NoSlice, i::NoSlice)
+    @_inline_meta
+    @boundscheck i.i == 1 || throw_boundserror(N, i)
+    N
+end
+getindex(N::NoSlice, ::Colon) = N
+function getindex(N::NoSlice, r::Range{Int})
+    @_inline_meta
+    @boundscheck checkbounds(N, r)
+    N
+end
+
+abstract AbstractCartesianIndex{N} # This is a hacky forward declaration for CartesianIndex
+typealias StridedArray{T,N,A<:DenseArray,I<:Tuple{Vararg{Union{RangeIndex, NoSlice, AbstractCartesianIndex}}}} Union{DenseArray{T,N}, SubArray{T,N,A,I}}
+typealias StridedVector{T,A<:DenseArray,I<:Tuple{Vararg{Union{RangeIndex, NoSlice, AbstractCartesianIndex}}}}  Union{DenseArray{T,1}, SubArray{T,1,A,I}}
+typealias StridedMatrix{T,A<:DenseArray,I<:Tuple{Vararg{Union{RangeIndex, NoSlice, AbstractCartesianIndex}}}}  Union{DenseArray{T,2}, SubArray{T,2,A,I}}
 typealias StridedVecOrMat{T} Union{StridedVector{T}, StridedMatrix{T}}
 
+# This computes the linear indexing compatability for a given tuple of indices
+viewindexing() = LinearFast()
+# Leading scalar indexes simply increase the stride
+viewindexing(I::Tuple{Union{Real, NoSlice}, Vararg{Any}}) = (@_inline_meta; viewindexing(tail(I)))
+# Colons may begin a section which may be followed by any number of Colons
+viewindexing(I::Tuple{Colon, Colon, Vararg{Any}}) = (@_inline_meta; viewindexing(tail(I)))
+# A UnitRange can follow Colons, but only if all other indices are scalar
+viewindexing(I::Tuple{Colon, UnitRange, Vararg{Union{Real, NoSlice}}}) = LinearFast()
+# In general, ranges are only fast if all other indices are scalar
+viewindexing(I::Tuple{Union{Range, Colon}, Vararg{Union{Real, NoSlice}}}) = LinearFast()
+# All other index combinations are slow
+viewindexing(I::Tuple{Vararg{Any}}) = LinearSlow()
+# Of course, all other array types are slow
+viewindexing(I::Tuple{AbstractArray, Vararg{Any}}) = LinearSlow()
+
 # Simple utilities
-eltype{T,N,P,I}(::Type{SubArray{T,N,P,I}}) = T
 size(V::SubArray) = V.dims
-# size(V::SubArray, d::Integer) = d <= ndims(V) ? (@inbounds ret = V.dims[d]; ret) : 1
 length(V::SubArray) = prod(V.dims)
 
 similar(V::SubArray, T, dims::Dims) = similar(V.parent, T, dims)
-copy(V::SubArray) = copy!(similar(V.parent, size(V)), V)
 
 parent(V::SubArray) = V.parent
 parentindexes(V::SubArray) = V.indexes
@@ -36,386 +82,162 @@ parentindexes(a::AbstractArray) = ntuple(i->1:size(a,i), ndims(a))
 
 ## SubArray creation
 # Drops singleton dimensions (those indexed with a scalar)
-slice(A::AbstractArray, I::ViewIndex...) = _slice(A, to_indexes(I...))
-slice(A::AbstractArray, I::Tuple{Vararg{ViewIndex}}) = _slice(A, to_indexes(I...))
-function _slice(A, I)
-    checkbounds(A, I...)
-    slice_unsafe(A, I)
+function slice(A::AbstractArray, I::ViewIndex...)
+    @_inline_meta
+    @boundscheck checkbounds(A, I...)
+    J = to_indexes(I...)
+    SubArray(A, J, index_shape(A, J...))
 end
 
-# The most complicated part of this is matching the axes between the
-# input index tuples (denoted by J), the index tuples that get stored
-# in the view (denoted by I), and the overall dimensionality of the
-# view.
-# The complexities increase when you create a view-of-a-view, because
-# then there is also the index tuple of the parent view (denoted IV)
-# to consider.
-#
-# Examples:
-#    S1 = sub(A::Matrix, 2, 3:5)    ndims(S1) == length(I) == length(J) == 2
-#    S2 = slice(A::Matrix, 2, 3:5)  ndims(S2) == 1, length(I) == length(J) == 2
-#    S3 = sub(A::Matrix, 4:17)      ndims(S3) == length(I) == length(J) == 1
-#    S4 = sub(S2, 1:2)              ndims(S4) == length(J) == 1, length(I) == 2
-# S3 addresses the trailing dimensions of the parent by linear indexing.
-# For S4, J[1] corresponds to I[2], because of the slice along
-# dimension 1 in S2
-
-slice_unsafe(A::AbstractArray, J) = _slice_unsafe(A, to_indexes(J...))
-@generated function _slice_unsafe{T,NP,IndTypes}(A::AbstractArray{T,NP}, J::IndTypes)
-    N = 0
-    sizeexprs = Array(Any, 0)
-    Jp = J.parameters
-    for Jindex = 1:length(Jp)
-        j = Jp[Jindex]
-        if !(j <: Real)
-            N += 1
-            push!(sizeexprs, dimsizeexpr(j, Jindex, length(Jp), :A, :J))
-        end
-    end
-    dims = :(tuple($(sizeexprs...)))
-    LD = subarray_linearindexing_dim(A, J)
-    strideexpr = stride1expr(A, Jp, :A, :J, LD)
-    exfirst = first_index_expr(:A, :J, length(Jp))
-    quote
-        $exfirst
-        SubArray{$T,$N,$A,$J,$LD}(A, J, $dims, f, $strideexpr)
-    end
-end
-
-# Conventional style (drop trailing singleton dimensions, keep any
-# other singletons by converting them to ranges, e.g., 3:3)
-sub(A::AbstractArray, I::ViewIndex...) = _sub(A, I)
-sub(A::AbstractArray, I::Tuple{Vararg{ViewIndex}}) = _sub(A, I)
-function _sub(A, I)
-    checkbounds(A, I...)
-    sub_unsafe(A, I)
-end
+keep_leading_scalars(T::Tuple{}) = T
+keep_leading_scalars(T::Tuple{Real, Vararg{Real}}) = T
+keep_leading_scalars(T::Tuple{Real, Vararg{Any}}) = (@_inline_meta; (NoSlice(T[1]), keep_leading_scalars(tail(T))...))
+keep_leading_scalars(T::Tuple{Any, Vararg{Any}}) = (@_inline_meta; (T[1], keep_leading_scalars(tail(T))...))
 
-sub_unsafe(A::AbstractArray, J) = _sub_unsafe(A, to_indexes(J...))
-@generated function _sub_unsafe{T,NP,IndTypes}(A::AbstractArray{T,NP}, J::IndTypes)
-    sizeexprs = Array(Any, 0)
-    Itypes = Array(Any, 0)
-    Iexprs = Array(Any, 0)
-    Jp = J.parameters
-    N = length(Jp)
-    while N > 0 && Jp[N] <: Real
-        N -= 1
-    end
-    for Jindex = 1:length(Jp)
-        j = Jp[Jindex]
-        if Jindex <= N
-            push!(sizeexprs, dimsizeexpr(j, Jindex, length(Jp), :A, :J))
-        end
-        if Jindex < N && j <: Real
-            push!(Itypes, UnitRange{Int})
-            push!(Iexprs, :(Int(J[$Jindex]):Int(J[$Jindex])))
-        else
-            push!(Itypes, j)
-            push!(Iexprs, :(J[$Jindex]))
-        end
-    end
-    dims = :(tuple($(sizeexprs...)))
-    Iext = :(tuple($(Iexprs...)))
-    It = Tuple{Itypes...}
-    LD = subarray_linearindexing_dim(A, J)
-    strideexpr = stride1expr(A, Jp, :A, :J, LD)
-    exfirst = first_index_expr(:A, :J, length(Itypes))
-    quote
-        $exfirst
-        SubArray{$T,$N,$A,$It,$LD}(A, $Iext, $dims, f, $strideexpr)
-    end
+function sub(A::AbstractArray, I::ViewIndex...)
+    @_inline_meta
+    @boundscheck checkbounds(A, I...)
+    J = keep_leading_scalars(to_indexes(I...))
+    SubArray(A, J, index_shape(A, J...))
 end
 
-# Constructing from another SubArray
-# This "pops" the old SubArray and creates a more compact one
-@generated function _slice_unsafe{T,NV,PV,IV,PLD,IndTypes}(V::SubArray{T,NV,PV,IV,PLD}, J::IndTypes)
-    N = 0
-    sizeexprs = Array(Any, 0)
-    indexexprs = Array(Any, 0)
-    Itypes = Array(Any, 0)
-    Jp = J.parameters
-    # The next two Ints, if nonzero, record information about the place
-    # in the index tuple at which trailing dimensions got packed into a
-    # single Vector{Int}. For stride1 computation, we need to keep track
-    # of whether the index that triggered this had uniform stride.
-    #   Iindex_lin is the spot in the resulting index tuple
-    #   Jindex_lin is the corresponding spot in the input index tuple
-    Iindex_lin = Jindex_lin = 0
-    # Linear indexing inference makes use of the following variables:
-    #   LD: the last dimension up through which linear indexing is efficient
-    #   isLDdone: true if we've quit incrementing LD
-    #   die_next_vector: if true, stop incrementing LD on the next
-    #      "extended" input index
-    #   jprev: holds the previous input index type
-    LD, die_next_vector, jprev, isLDdone = 0, false, Void, false  # for linear indexing inference
-    Jindex = 0
-    IVp = IV.parameters
-    for IVindex = 1:length(IVp)
-        iv = IVp[IVindex]
-        if iv <: Real
-            push!(indexexprs, :(V.indexes[$IVindex]))
-            push!(Itypes, iv)
-            if !isLDdone
-                LD += 1
-            end
-        else
-            Jindex += 1
-            j = Jp[Jindex]
-            if Jindex < length(Jp) || Jindex == NV || IVindex == length(IVp)
-                if !(j <: Real)
-                    N += 1
-                    push!(sizeexprs, dimsizeexpr(j, Jindex, length(Jp), :V, :J))
-                end
-                push!(indexexprs, :(reindex(V.indexes[$IVindex], J[$Jindex])))
-                push!(Itypes, rangetype(iv, j))
-            else
-                # We have a linear index that spans more than one
-                # dimension of the parent
-                N += 1
-                push!(sizeexprs, dimsizeexpr(j, Jindex, length(Jp), :V, :J))
-                push!(indexexprs, :(merge_indexes(V, V.indexes[$IVindex:end], size(V.parent)[$IVindex:end], J[$Jindex], $Jindex)))
-                push!(Itypes, Array{Int, 1})
-                Iindex_lin = length(Itypes)
-                Jindex_lin = Jindex
-                break
-            end
-            if !isLDdone
-                if LD < PLD
-                    LD += 1
-                    jprev, LD, die_next_vector, isdone = nextLD(jprev, j, LD, die_next_vector)
-                    isLDdone |= isdone
-                else
-                    if j <: Real
-                        LD += 1
-                    else
-                        isLDdone = true
-                    end
-                end
-            end
-        end
-    end
-    for Jind = Jindex+1:length(Jp)
-        j = Jp[Jind]
-        if !(j <: Real)
-            N += 1
-            push!(sizeexprs, dimsizeexpr(j, Jind, length(Jp), :V, :J))
-            isLDdone = true
-        elseif !isLDdone
-            LD += 1
-        end
-        push!(indexexprs, :(J[$Jind]))
-        push!(Itypes, j)
-    end
-    Inew = :(tuple($(indexexprs...)))
-    dims = :(tuple($(sizeexprs...)))
-    It = Tuple{Itypes...}
-    LD = max(LD, subarray_linearindexing_dim(PV, It))
-    strideexpr = stride1expr(PV, Itypes, :(V.parent), :Inew, LD, :J, Iindex_lin, Jindex_lin)
-    exfirst = first_index_expr(:(V.parent), :Inew, length(Itypes))
-    quote
-        Inew = $Inew
-        $exfirst
-        SubArray{$T,$N,$PV,$It,$LD}(V.parent, Inew, $dims, f, $strideexpr)
-    end
+# Re-indexing is the heart of a view, transforming A[i, j][x, y] to A[i[x], j[y]]
+#
+# Recursively look through the heads of the parent- and sub-indexes, considering
+# the following cases:
+# * Parent index is empty  -> ignore trailing scalars, but preserve added dimensions
+# * Parent index is Any    -> re-index that with the sub-index
+# * Parent index is Scalar -> that dimension was dropped, so skip the sub-index and use the index as is
+#
+# Furthermore, we must specially consider the case with one final sub-index,
+# as it may be a linear index that spans multiple parent indexes.
+
+typealias DroppedScalar Union{Real, AbstractCartesianIndex}
+# When indexing beyond the parent indices, drop all trailing scalars (they must be 1 to be inbounds)
+reindex(V, idxs::Tuple{}, subidxs::Tuple{Vararg{DroppedScalar}}) = ()
+# Drop any intervening scalars that are beyond the parent indices but before a nonscalar
+reindex(V, idxs::Tuple{}, subidxs::Tuple{DroppedScalar, Vararg{Any}}) =
+    (@_propagate_inbounds_meta; (reindex(V, idxs, tail(subidxs))...))
+# And keep the nonscalar index to add the dimension
+reindex(V, idxs::Tuple{}, subidxs::Tuple{Any, Vararg{Any}}) =
+    (@_propagate_inbounds_meta; (subidxs[1], reindex(V, idxs, tail(subidxs))...))
+
+reindex(V, idxs::Tuple{Any}, subidxs::Tuple{Any}) =
+    (@_propagate_inbounds_meta; (idxs[1][subidxs[1]],))
+reindex(V, idxs::Tuple{Any}, subidxs::Tuple{Any, Any, Vararg{Any}}) =
+    (@_propagate_inbounds_meta; (idxs[1][subidxs[1]],))
+reindex(V, idxs::Tuple{Any, Any, Vararg{Any}}, subidxs::Tuple{Any}) =
+    (@_propagate_inbounds_meta; (merge_indexes(V, idxs, subidxs[1]),))
+# As an optimization, we don't need to merge indices if all trailing indices are dropped scalars
+reindex(V, idxs::Tuple{Any, DroppedScalar, Vararg{DroppedScalar}}, subidxs::Tuple{Any}) =
+    (@_propagate_inbounds_meta; (idxs[1][subidxs[1]], tail(idxs)...))
+reindex(V, idxs::Tuple{Any, Any, Vararg{Any}}, subidxs::Tuple{Any, Any, Vararg{Any}}) =
+    (@_propagate_inbounds_meta; (idxs[1][subidxs[1]], reindex(V, tail(idxs), tail(subidxs))...))
+
+reindex(V, idxs::Tuple{DroppedScalar}, subidxs::Tuple{Any}) = idxs
+reindex(V, idxs::Tuple{DroppedScalar}, subidxs::Tuple{Any, Any, Vararg{Any}}) = idxs
+reindex(V, idxs::Tuple{DroppedScalar, Any, Vararg{Any}}, subidxs::Tuple{Any}) =
+    (@_propagate_inbounds_meta; (idxs[1], reindex(V, tail(idxs), subidxs)...))
+reindex(V, idxs::Tuple{DroppedScalar, Any, Vararg{Any}}, subidxs::Tuple{Any, Any, Vararg{Any}}) =
+    (@_propagate_inbounds_meta; (idxs[1], reindex(V, tail(idxs), subidxs)...))
+
+# In general, we simply re-index the parent indices by the provided ones
+getindex(V::SubArray) = (@_propagate_inbounds_meta; getindex(V, 1))
+function getindex(V::SubArray, I::Real...)
+    @_inline_meta
+    @boundscheck checkbounds(V, I...)
+    @inbounds r = V.parent[reindex(V, V.indexes, to_indexes(I...))...]
+    r
 end
 
-@generated function _sub_unsafe{T,NV,PV,IV,PLD,IndTypes}(V::SubArray{T,NV,PV,IV,PLD}, J::IndTypes)
-    Jp = J.parameters
-    IVp = IV.parameters
-    N = length(Jp)
-    while N > 0 && Jp[N] <: Real
-        N -= 1
-    end
-    sizeexprs = Array(Any, 0)
-    indexexprs = Array(Any, 0)
-    Itypes = Array(Any, 0)
-    ItypesLD = Array(Any, 0)
-    preexprs = Array(Any, 0)
-    LD, die_next_vector, jprev, isLDdone = 0, false, Void, false
-    Jindex = 0
-    for IVindex = 1:length(IVp)
-        iv = IVp[IVindex]
-        if iv <: Real
-            push!(indexexprs, :(V.indexes[$IVindex]))
-            push!(Itypes, iv)
-            push!(ItypesLD, iv)
-            if !isLDdone
-                LD += 1
-            end
-        else
-            Jindex += 1
-            j = Jp[Jindex]
-            if Jindex <= N
-                push!(sizeexprs, dimsizeexpr(j, Jindex, length(Jp), :V, :J))
-            end
-            if Jindex < N && j <: Real
-                # convert scalar to a range
-                sym = gensym()
-                push!(preexprs, :($sym = reindex(V.indexes[$IVindex], Int(J[$Jindex]))))
-                push!(indexexprs, :($sym:$sym))
-                push!(Itypes, UnitRange{Int})
-                push!(ItypesLD, j)
-            elseif Jindex < length(Jp) || Jindex == NV || IVindex == length(IVp)
-                # simple indexing
-                push!(indexexprs, :(reindex(V.indexes[$IVindex], J[$Jindex])))
-                push!(Itypes, rangetype(iv, j))
-                push!(ItypesLD, Itypes[end])
-            else
-                # We have a linear index that spans more than one dimension of the parent
-                push!(indexexprs, :(merge_indexes(V, V.indexes[$IVindex:end], size(V.parent)[$IVindex:end], J[$Jindex], $Jindex)))
-                push!(Itypes, Array{Int, 1})
-                push!(ItypesLD, Itypes[end])
-                break
-            end
-            if !isLDdone
-                if LD < PLD
-                    LD += 1
-                    jprev, LD, die_next_vector, isdone = nextLD(jprev, j, LD, die_next_vector)
-                    isLDdone |= isdone
-                else
-                    if j <: Real
-                        LD += 1
-                    else
-                        isLDdone = true
-                    end
-                end
-            end
-        end
-    end
-    for Jind = Jindex+1:length(Jp)
-        j = Jp[Jind]
-        if Jind <= N
-            push!(sizeexprs, dimsizeexpr(j, Jind, length(Jp), :V, :J))
-        end
-        push!(indexexprs, :(J[$Jind]))
-        push!(Itypes, j)
-        push!(ItypesLD, Itypes[end])
-    end
-    Inew = :(tuple($(indexexprs...)))
-    dims = :(tuple($(sizeexprs...)))
-    It = Tuple{Itypes...}
-    LD = max(LD, subarray_linearindexing_dim(PV, It))
-    strideexpr = stride1expr(PV, ItypesLD, :(V.parent), :Inew, LD)
-    preex = isempty(preexprs) ? nothing : Expr(:block, preexprs...)
-    exfirst = first_index_expr(:(V.parent), :Inew, length(Itypes))
-    quote
-        $preex
-        Inew = $Inew
-        $exfirst
-        SubArray{$T,$N,$PV,$It,$LD}(V.parent, Inew, $dims, f, $strideexpr)
-    end
+typealias FastSubArray{T,N,P,I} SubArray{T,N,P,I,true}
+getindex(V::FastSubArray) = (@_propagate_inbounds_meta; getindex(V, 1))
+function getindex(V::FastSubArray, i::Real)
+    @_inline_meta
+    @boundscheck checkbounds(V, i)
+    @inbounds r = V.parent[V.first_index + V.stride1*(to_index(i)-1)]
+    r
 end
-
-function rangetype(T1, T2)
-    rt = return_types(getindex, Tuple{T1, T2})
-    length(rt) == 1 || error("Can't infer return type")
-    rt[1]
+# We can avoid a multiplication if the first parent index is a Colon or UnitRange
+typealias FastContiguousSubArray{T,N,P,I<:Tuple{Union{Colon, UnitRange}, Vararg{Any}}} SubArray{T,N,P,I,true}
+function getindex(V::FastContiguousSubArray, i::Real)
+    @_inline_meta
+    @boundscheck checkbounds(V, i)
+    @inbounds r = V.parent[V.first_index + to_index(i)-1]
+    r
 end
-
-reindex(a, b) = a[b]
-reindex(a::UnitRange, b::UnitRange{Int}) = range(oftype(first(a), first(a)+first(b)-1), length(b))
-reindex(a::UnitRange, b::StepRange{Int}) = range(oftype(first(a), first(a)+first(b)-1), step(b), length(b))
-reindex(a::StepRange, b::Range{Int}) = range(oftype(first(a), first(a)+(first(b)-1)*step(a)), step(a)*step(b), length(b))
-reindex(a, b::Int) = unsafe_getindex(a, b)
-
-dimsizeexpr(Itype, d::Int, len::Int, Asym::Symbol, Isym::Symbol) = :(length($Isym[$d]))
-function dimsizeexpr(Itype::Type{Colon}, d::Int, len::Int, Asym::Symbol, Isym::Symbol)
-    if d < len
-        :(size($Asym, $d))
-    else
-        :(tailsize($Asym, $d))
-    end
+# We need this because the ::ViewIndex... method would otherwise obscure the Base fallback
+function getindex(V::FastSubArray, I::Real...)
+    @_inline_meta
+    @boundscheck checkbounds(V, I...)
+    @inbounds r = getindex(V, sub2ind(size(V), to_indexes(I...)...))
+    r
 end
-dimsize(P, d, I) = length(I)
-dimsize(P, d::Int, ::Colon) = size(P, d)
-dimsize(P, d::Dims, ::Colon) = prod(size(P)[d])
-function tailsize(P, d)
-    s = 1
-    for i = d:ndims(P)
-        s *= size(P, i)
-    end
-    s
+getindex{T,N}(V::SubArray{T,N}, I::ViewIndex...) = (@_propagate_inbounds_meta; copy(slice(V, I...)))
+
+setindex!(V::SubArray, x) = (@_propagate_inbounds_meta; setindex!(V, x, 1))
+function setindex!{T,N}(V::SubArray{T,N}, x, I::Real...)
+    @_inline_meta
+    @boundscheck checkbounds(V, I...)
+    @inbounds V.parent[reindex(V, V.indexes, to_indexes(I...))...] = x
+    V
 end
+# Nonscalar setindex! falls back to the defaults
 
-@generated function linearindexing{T,N,P,I,LD}(A::SubArray{T,N,P,I,LD})
-    length(I.parameters) == LD ? (:(LinearFast())) : (:(LinearSlow()))
+function slice{T,N}(V::SubArray{T,N}, I::ViewIndex...)
+    @_inline_meta
+    @boundscheck checkbounds(V, I...)
+    idxs = reindex(V, V.indexes, to_indexes(I...))
+    SubArray(V.parent, idxs, index_shape(V.parent, idxs...))
 end
-@generated function linearindexing{A<:SubArray}(::Type{A})
-    T,N,P,I,LD = A.parameters
-    length(I.parameters) == LD ? (:(LinearFast())) : (:(LinearSlow()))
+
+function sub{T,N}(V::SubArray{T,N}, I::ViewIndex...)
+    @_inline_meta
+    @boundscheck checkbounds(V, I...)
+    idxs = reindex(V, V.indexes, keep_leading_scalars(to_indexes(I...)))
+    SubArray(V.parent, idxs, index_shape(V.parent, idxs...))
 end
 
+linearindexing(A::FastSubArray) = LinearFast()
+linearindexing(A::SubArray) = LinearSlow()
+
 getindex(::Colon, i) = to_index(i)
-unsafe_getindex(v::Colon, i) = to_index(i)
+unsafe_getindex(::Colon, i) = to_index(i)
 
 step(::Colon) = 1
 first(::Colon) = 1
 isempty(::Colon) = false
-in(::Int, ::Colon) = true
-
-## Strides
-@generated function strides{T,N,P,I}(V::SubArray{T,N,P,I})
-    Ip = I.parameters
-    all(x->x<:Union{RangeIndex,Colon}, Ip) || throw(ArgumentError("strides valid only for RangeIndex indexing"))
-    strideexprs = Array(Any, N+1)
-    strideexprs[1] = 1
-    i = 1
-    Vdim = 1
-    for i = 1:length(Ip)
-        if Ip[i] != Int
-            strideexprs[Vdim+1] = copy(strideexprs[Vdim])
-            strideexprs[Vdim] = :(step(V.indexes[$i])*$(strideexprs[Vdim]))
-            Vdim += 1
-        end
-        strideexprs[Vdim] = :(size(V.parent, $i) * $(strideexprs[Vdim]))
-    end
-    :(tuple($(strideexprs[1:N]...)))
-end
+in(::Integer, ::Colon) = true
+
+# Strides are the distance between adjacent elements in a given dimension,
+# so they are well-defined even for non-linear memory layouts
+strides{T,N,P,I}(V::SubArray{T,N,P,I}) = substrides(V.parent, V.indexes)
+
+substrides(parent, I::Tuple) = substrides(1, parent, 1, I)
+substrides(s, parent, dim, ::Tuple{}) = ()
+substrides(s, parent, dim, I::Tuple{Real, Vararg{Any}}) = (substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
+substrides(s, parent, dim, I::Tuple{AbstractCartesianIndex, Vararg{Any}}) = substrides(s, parent, dim, (I[1].I..., tail(I)...))
+substrides(s, parent, dim, I::Tuple{NoSlice, Vararg{Any}}) = (s, substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
+substrides(s, parent, dim, I::Tuple{Colon, Vararg{Any}}) = (s, substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
+substrides(s, parent, dim, I::Tuple{Range, Vararg{Any}}) = (s*step(I[1]), substrides(s*size(parent, dim), parent, dim+1, tail(I))...)
+substrides(s, parent, dim, I::Tuple{Any, Vararg{Any}}) = throw(ArgumentError("strides is invalid for SubArrays with indices of type $(typeof(I[1]))"))
 
 stride(V::SubArray, d::Integer) = d <= ndims(V) ? strides(V)[d] : strides(V)[end] * size(V)[end]
 
-function stride1expr(Atype::Type, Itypes, Aexpr, Isym, LD, Jsym=Isym, Iindex_lin=0, Jindex_lin=0)
-    if LD == 0
-        return 0
-    end
-    ex = 1
-    for d = 1:min(LD, length(Itypes))
-        I = Itypes[d]
-        if I <: Real
-            ex = :($ex * size($Aexpr, $d))
-        else
-            if d == Iindex_lin
-                ex = :($ex * step_sa($Jsym[$Jindex_lin]))
-            else
-                ex = :($ex * step($Isym[$d]))
-            end
-            break
-        end
-    end
-    ex
-end
+compute_stride1(parent, I::Tuple) = compute_stride1(1, parent, 1, I)
+compute_stride1(s, parent, dim, I::Tuple{}) = s
+compute_stride1(s, parent, dim, I::Tuple{Union{DroppedScalar, NoSlice}, Vararg{Any}}) =
+    (@_inline_meta; compute_stride1(s*size(parent, dim), parent, dim+1, tail(I)))
+compute_stride1(s, parent, dim, I::Tuple{Range, Vararg{Any}}) = s*step(I[1])
+compute_stride1(s, parent, dim, I::Tuple{Colon, Vararg{Any}}) = s
+compute_stride1(s, parent, dim, I::Tuple{Any, Vararg{Any}}) = throw(ArgumentError("invalid strided index type $(typeof(I[1]))"))
 
-step_sa(arg) = step(arg)
-step_sa(::Integer) = 1
-
-# This might be conservative, but better safe than sorry
-function iscontiguous{T,N,P,I,LD}(::Type{SubArray{T,N,P,I,LD}})
-    Ip = I.parameters
-    LD == length(Ip) || return false
-    length(Ip) < 1 && return true
-    Ip[1] == Colon && return true
-    if Ip[1] <: UnitRange
-        # It might be stride1 == 1, or this might be because `sub` was
-        # used with an integer for the first index
-        for j = 2:length(Ip)
-            (Ip[j] == Colon || (Ip[j] <: AbstractVector)) && return false
-        end
-        return true
-    end
-    false
-end
-iscontiguous(S::SubArray) = iscontiguous(typeof(S))
+iscontiguous(A::SubArray) = iscontiguous(typeof(A))
+iscontiguous{S<:SubArray}(::Type{S}) = false
+iscontiguous{F<:FastContiguousSubArray}(::Type{F}) = true
 
+# Fast linear SubArrays have their first index cached
+first_index(V::FastSubArray) = V.first_index
 first_index(V::SubArray) = first_index(V.parent, V.indexes)
 function first_index(P::AbstractArray, indexes::Tuple)
     f = 1
@@ -427,77 +249,35 @@ function first_index(P::AbstractArray, indexes::Tuple)
     f
 end
 
-function first_index_expr(Asym, Isym::Symbol, n::Int)
-    ex = :(f = s = 1)
-    for i = 1:n
-        ex = quote
-            $ex
-            if isempty($Isym[$i])
-                f = s = 0
-            else
-                f += (first($Isym[$i])-1)*s
-                s *= size($Asym, $i)
-            end
-        end
-    end
-    ex
-end
-
-# Detecting whether one can support fast linear indexing
-function nextLD(jprev, j, LD, die_next_vector)
-    isdone = false
-    if j <: Real
-        if jprev != Void && !(jprev <: Real)
-            die_next_vector = true
-        end
-    elseif die_next_vector
-        LD -= 1
-        isdone = true
-    elseif j == Colon
-    elseif j <: UnitRange
-        die_next_vector = true
-    elseif j <: Range
-        if !(jprev == Void || jprev <: Real)
-            LD -= 1
-            isdone = true
-        end
-        die_next_vector = true
-    elseif j <: AbstractVector
-        LD -= 1
-        isdone = true
-    else
-        error("unsupported SubArray index type $j")
-    end
-    jprev = j
-    return jprev, LD, die_next_vector, isdone
-end
-
-function subarray_linearindexing_dim{A<:AbstractArray}(::Type{A}, It::Type)
-    isa(Base.linearindexing(A), Base.LinearSlow) && return 0
-    isempty(It.parameters) && return 0
-    jprev = Void
-    LD = 0
-    die_next_vector = false
-    while LD < length(It.parameters)
-        LD += 1
-        I = It.parameters[LD]
-        jprev, LD, die_next_vector, isdone = nextLD(jprev, I, LD, die_next_vector)
-        if isdone
-            break
-        end
-    end
-    LD
-end
-
-unsafe_convert{T,N,P<:Array,I<:Tuple{Vararg{RangeIndex}}}(::Type{Ptr{T}}, V::SubArray{T,N,P,I}) =
-    pointer(V.parent) + (V.first_index-1)*sizeof(T)
-
-unsafe_convert{T,N,P<:Array,I<:Tuple{Vararg{RangeIndex}}}(::Type{Ptr{Void}}, V::SubArray{T,N,P,I}) =
+# Computing the first index simply steps through the indices, accumulating the
+# sum of index each multiplied by the parent's stride.
+# The running sum is `f`; the cumulative stride product is `s`.
+compute_first_index(parent, I::Tuple) = compute_first_index(1, 1, parent, 1, I)
+compute_first_index(f, s, parent, dim, I::Tuple{Real, Vararg{Any}}) =
+    (@_inline_meta; compute_first_index(f + (I[1]-1)*s, s*size(parent, dim), parent, dim+1, tail(I)))
+compute_first_index(f, s, parent, dim, I::Tuple{NoSlice, Vararg{Any}}) =
+    (@_inline_meta; compute_first_index(f + (I[1].i-1)*s, s*size(parent, dim), parent, dim+1, tail(I)))
+# Just splat out the cartesian indices and continue
+compute_first_index(f, s, parent, dim, I::Tuple{AbstractCartesianIndex, Vararg{Any}}) =
+    (@_inline_meta; compute_first_index(f, s, parent, dim, (I[1].I..., tail(I)...)))
+compute_first_index(f, s, parent, dim, I::Tuple{Colon, Vararg{Any}}) =
+    (@_inline_meta; compute_first_index(f, s*size(parent, dim), parent, dim+1, tail(I)))
+compute_first_index(f, s, parent, dim, I::Tuple{Any, Vararg{Any}}) =
+    (@_inline_meta; compute_first_index(f + (first(I[1])-1)*s, s*size(parent, dim), parent, dim+1, tail(I)))
+compute_first_index(f, s, parent, dim, I::Tuple{}) = f
+
+
+unsafe_convert{T,N,P<:Array,I<:Tuple{Vararg{Union{RangeIndex, NoSlice}}}}(::Type{Ptr{T}}, V::SubArray{T,N,P,I}) =
+    pointer(V.parent) + (first_index(V)-1)*sizeof(T)
+
+unsafe_convert{T,N,P<:Array,I<:Tuple{Vararg{Union{RangeIndex, NoSlice}}}}(::Type{Ptr{Void}}, V::SubArray{T,N,P,I}) =
     convert(Ptr{Void}, unsafe_convert(Ptr{T}, V))
 
+pointer(V::FastSubArray, i::Int) = pointer(V.parent, V.first_index + V.stride1*(i-1))
+pointer(V::FastContiguousSubArray, i::Int) = pointer(V.parent, V.first_index + i-1)
 pointer(V::SubArray, i::Int) = pointer(V, ind2sub(size(V), i))
 
-function pointer{T,N,P<:Array,I<:Tuple{Vararg{RangeIndex}}}(V::SubArray{T,N,P,I}, is::Tuple{Vararg{Int}})
+function pointer{T,N,P<:Array,I<:Tuple{Vararg{Union{RangeIndex, NoSlice}}}}(V::SubArray{T,N,P,I}, is::Tuple{Vararg{Int}})
     index = first_index(V)
     strds = strides(V)
     for d = 1:length(is)
@@ -527,143 +307,3 @@ function parentdims(s::SubArray)
     end
     dimindex
 end
-
-## Scalar indexing
-
-# While it'd be nice to explicitly check bounds against the SubArray dimensions,
-# the lack of an extensible @inbounds mechanism makes it difficult for users to
-# avoid the cost of the bounds check without rewriting their syntax to use the
-# unwieldy unsafe_getindex/unsafe_setindex! function calls. So instead we define
-# getindex to rely upon the bounds checks in the parent array. It's still
-# advantageous to define the unsafe_ variants without any bounds checks since
-# the abstract indexing fallbacks can make use of them.
-@generated function getindex{T,N,P,IV,LD}(V::SubArray{T,N,P,IV,LD}, I::Int...)
-    ni = length(I)
-    if ni == 1 && length(IV.parameters) == LD  # linear indexing
-        meta = Expr(:meta, :inline)
-        if iscontiguous(V)
-            return :($meta; getindex(V.parent, V.first_index + I[1] - 1))
-        end
-        return :($meta; getindex(V.parent, V.first_index + V.stride1*(I[1]-1)))
-    end
-    Isyms = [:(I[$d]) for d = 1:ni]
-    exhead, idxs = index_generate(ndims(P), IV, :V, Isyms)
-    quote
-        $exhead
-        getindex(V.parent, $(idxs...))
-    end
-end
-@generated function unsafe_getindex{T,N,P,IV,LD}(V::SubArray{T,N,P,IV,LD}, I::Int...)
-    ni = length(I)
-    if ni == 1 && length(IV.parameters) == LD  # linear indexing
-        meta = Expr(:meta, :inline)
-        if iscontiguous(V)
-            return :($meta; unsafe_getindex(V.parent, V.first_index + I[1] - 1))
-        end
-        return :($meta; unsafe_getindex(V.parent, V.first_index + V.stride1*(I[1]-1)))
-    end
-    Isyms = [:(I[$d]) for d = 1:ni]
-    exhead, idxs = index_generate(ndims(P), IV, :V, Isyms)
-    quote
-        $exhead
-        unsafe_getindex(V.parent, $(idxs...))
-    end
-end
-@generated function setindex!{T,N,P,IV,LD}(V::SubArray{T,N,P,IV,LD}, v, I::Int...)
-    ni = length(I)
-    if ni == 1 && length(IV.parameters) == LD  # linear indexing
-        meta = Expr(:meta, :inline)
-        if iscontiguous(V)
-            return :($meta; setindex!(V.parent, v, V.first_index + I[1] - 1))
-        end
-        return :($meta; setindex!(V.parent, v, V.first_index + V.stride1*(I[1]-1)))
-    end
-    Isyms = Any[:(I[$d]) for d = 1:ni]
-    exhead, idxs = index_generate(ndims(P), IV, :V, Isyms)
-    quote
-        $exhead
-        setindex!(V.parent, v, $(idxs...))
-    end
-end
-@generated function unsafe_setindex!{T,N,P,IV,LD}(V::SubArray{T,N,P,IV,LD}, v, I::Int...)
-    ni = length(I)
-    if ni == 1 && length(IV.parameters) == LD  # linear indexing
-        meta = Expr(:meta, :inline)
-        if iscontiguous(V)
-            return :($meta; unsafe_setindex!(V.parent, v, V.first_index + I[1] - 1))
-        end
-        return :($meta; unsafe_setindex!(V.parent, v, V.first_index + V.stride1*(I[1]-1)))
-    end
-    Isyms = Any[:(I[$d]) for d = 1:ni]
-    exhead, idxs = index_generate(ndims(P), IV, :V, Isyms)
-    quote
-        $exhead
-        unsafe_setindex!(V.parent, v, $(idxs...))
-    end
-end
-
-# Indexing with non-scalars. For now, this returns a copy, but changing that
-# is just a matter of deleting the explicit call to copy.
-getindex{T,N,P,IV}(V::SubArray{T,N,P,IV}, I::ViewIndex...) = copy(sub(V, I...))
-unsafe_getindex{T,N,P,IV}(V::SubArray{T,N,P,IV}, I::ViewIndex...) = copy(sub_unsafe(V, I))
-
-# Nonscalar setindex! falls back to the AbstractArray versions
-
-# NP is parent dimensionality, Itypes is the tuple typeof(V.indexes)
-# NP may not be equal to length(Itypes), because a view of a 2d matrix A
-# can be constructed as V = A[5:13] or as V = A[2:4, 1:3, 1].
-function index_generate(NP, Itypes, Vsym, Isyms)
-    Itypes = Itypes.parameters
-    if isempty(Isyms)
-        Isyms = Any[1]  # this handles the syntax getindex(V)
-    end
-    exhead = :nothing
-    NV = 0
-    for I in Itypes
-        NV += !(I == Int)
-    end
-    if length(Isyms) < NV
-        # Linear indexing in the last index
-        n = NV - length(Isyms)
-        m = length(Isyms)
-        strides = [gensym() for i = 1:n]
-        indexes = [gensym() for i = 1:n+1]
-        resid = gensym()
-        linblock = Array(Expr, 2n+2)
-        linblock[1] = :($(strides[1]) = size($Vsym, $m))
-        for k = 2:n
-            m += 1
-            linblock[k] = :($(strides[k]) = $(strides[k-1]) * size($Vsym, $m))
-        end
-        k = n+1
-        linblock[k] = :($resid = $(Isyms[end])-1)
-        for i = n:-1:1
-            k += 1
-            linblock[k] = quote
-                $(indexes[i+1]), $resid = divrem($resid, $(strides[i]))
-                $(indexes[i+1]) += 1
-            end
-        end
-        linblock[end] = :($(indexes[1]) = $resid+1)
-        exhead = Expr(:block, linblock...)
-        pop!(Isyms)
-        append!(Isyms, indexes)
-    end
-    L = length(Itypes)
-    indexexprs = Array(Any, L)
-    j = 0
-    for i = 1:L
-        if Itypes[i] <: Real
-            indexexprs[i] = :($Vsym.indexes[$i])
-        else
-            j += 1
-            indexexprs[i] = :(unsafe_getindex($Vsym.indexes[$i], $(Isyms[j])))
-        end
-    end
-    # Note that we drop any extra indices. We're trusting that the indices are
-    # already checked to be in-bounds, so any extra indices must be 1 (and no-op)
-    if exhead == :nothing
-        exhead = Expr(:meta, :inline)
-    end
-    exhead, indexexprs
-end
diff --git a/base/sysimg.jl b/base/sysimg.jl
index 8e6d20f1a3341..61ea07580c8f3 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -4,8 +4,8 @@ import Core.Intrinsics.ccall
 
 baremodule Base
 
-using Core: Intrinsics, arraylen, arrayref, arrayset, arraysize, _expr,
-            kwcall, _apply, typeassert, apply_type, svec
+using Core: Intrinsics, arrayref, arrayset, arraysize, _expr,
+            _apply, typeassert, apply_type, svec
 ccall(:jl_set_istopmod, Void, (Bool,), true)
 
 include = Core.include
@@ -30,10 +30,8 @@ end
 include("essentials.jl")
 include("docs/bootstrap.jl")
 include("base.jl")
+include("generator.jl")
 include("reflection.jl")
-include("build_h.jl")
-include("version_git.jl")
-include("c.jl")
 include("options.jl")
 
 # core operations & types
@@ -51,12 +49,37 @@ include("operators.jl")
 include("pointer.jl")
 include("refpointer.jl")
 include("functors.jl")
+include("checked.jl")
+importall .Checked
 
 # array structures
 include("abstractarray.jl")
 include("subarray.jl")
 include("array.jl")
 
+# Array convenience converting constructors
+(::Type{Array{T}}){T}(m::Integer) = Array{T}(Int(m))
+(::Type{Array{T}}){T}(m::Integer, n::Integer) = Array{T}(Int(m), Int(n))
+(::Type{Array{T}}){T}(m::Integer, n::Integer, o::Integer) = Array{T}(Int(m), Int(n), Int(o))
+(::Type{Array{T}}){T}(d::Integer...) = Array{T}(convert(Tuple{Vararg{Int}}, d))
+
+(::Type{Vector{T}}){T}(m::Integer) = Array{T}(m)
+(::Type{Vector{T}}){T}() = Array{T}(0)
+(::Type{Vector})(m::Integer) = Array{Any}(m)
+(::Type{Vector})() = Array{Any}(0)
+
+(::Type{Matrix{T}}){T}(m::Integer, n::Integer) = Array{T}(m, n)
+(::Type{Matrix{T}}){T}() = Array{T}(0, 0)
+(::Type{Matrix})(m::Integer, n::Integer) = Array{Any}(m, n)
+(::Type{Matrix})() = Array{Any}(0, 0)
+
+# TODO: possibly turn these into deprecations
+Array{T,N}(::Type{T}, d::NTuple{N,Int}) = Array{T}(d)
+Array{T}(::Type{T}, d::Integer...) = Array{T}(convert(Tuple{Vararg{Int}}, d))
+Array{T}(::Type{T}, m::Integer)                       = Array{T}(m)
+Array{T}(::Type{T}, m::Integer,n::Integer)            = Array{T}(m,n)
+Array{T}(::Type{T}, m::Integer,n::Integer,o::Integer) = Array{T}(m,n,o)
+
 # numeric operations
 include("hashing.jl")
 include("rounding.jl")
@@ -81,13 +104,20 @@ include("dict.jl")
 include("set.jl")
 include("iterator.jl")
 
-# For OS specific stuff in I/O
+# For OS specific stuff
+include(UTF8String(vcat(length(Core.ARGS)>=2?Core.ARGS[2].data:"".data, "build_h.jl".data))) # include($BUILDROOT/base/build_h.jl)
+include(UTF8String(vcat(length(Core.ARGS)>=2?Core.ARGS[2].data:"".data, "version_git.jl".data))) # include($BUILDROOT/base/version_git.jl)
 include("osutils.jl")
+include("c.jl")
+
+# Core I/O
+include("io.jl")
+include("iostream.jl")
+include("iobuffer.jl")
 
 # strings & printing
 include("char.jl")
 include("ascii.jl")
-include("iobuffer.jl")
 include("string.jl")
 include("unicode.jl")
 include("parse.jl")
@@ -96,17 +126,12 @@ include("regex.jl")
 include("base64.jl")
 importall .Base64
 
-# Core I/O
-include("io.jl")
-include("iostream.jl")
-
 # system & environment
 include("libc.jl")
 using .Libc: getpid, gethostname, time
 include("libdl.jl")
 using .Libdl: DL_LOAD_PATH
 include("env.jl")
-include("path.jl")
 include("intfuncs.jl")
 
 # nullable types
@@ -118,15 +143,13 @@ include("lock.jl")
 include("show.jl")
 include("stream.jl")
 include("socket.jl")
-include("stat.jl")
-include("fs.jl")
-importall .FS
+include("filesystem.jl")
+importall .Filesystem
 include("process.jl")
 include("multimedia.jl")
 importall .Multimedia
 include("grisu.jl")
 import .Grisu.print_shortest
-include("file.jl")
 include("methodshow.jl")
 
 # core math functions
@@ -209,9 +232,6 @@ include("managers.jl")
 # code loading
 include("loading.jl")
 
-# Polling (requires multi.jl)
-include("poll.jl")
-
 # memory-mapped and shared arrays
 include("mmap.jl")
 import .Mmap
@@ -228,19 +248,13 @@ include("i18n.jl")
 using .I18n
 
 # frontend
+include("initdefs.jl")
 include("Terminals.jl")
 include("LineEdit.jl")
 include("REPLCompletions.jl")
 include("REPL.jl")
 include("client.jl")
 
-# Documentation
-
-include("markdown/Markdown.jl")
-include("docs/Docs.jl")
-using .Docs
-using .Markdown
-
 # misc useful functions & macros
 include("util.jl")
 
@@ -255,10 +269,6 @@ importall .Broadcast
 # statistics
 include("statistics.jl")
 
-# sparse matrices and sparse linear algebra
-include("sparse.jl")
-importall .SparseMatrix
-
 # irrational mathematical constants
 include("irrationals.jl")
 
@@ -280,10 +290,17 @@ importall .QuadGK
 include("fastmath.jl")
 importall .FastMath
 
+# libgit2 support
+include("libgit2.jl")
+
 # package manager
 include("pkg.jl")
 const Git = Pkg.Git
 
+# Stack frames and traces
+include("stacktraces.jl")
+importall .StackTraces
+
 # profiler
 include("profile.jl")
 importall .Profile
@@ -292,6 +309,17 @@ importall .Profile
 include("Dates.jl")
 import .Dates: Date, DateTime, now
 
+# sparse matrices, vectors, and sparse linear algebra
+include("sparse.jl")
+importall .SparseArrays
+
+# Documentation
+
+include("markdown/Markdown.jl")
+include("docs/Docs.jl")
+using .Docs
+using .Markdown
+
 # deprecated functions
 include("deprecated.jl")
 
@@ -299,6 +327,10 @@ include("deprecated.jl")
 include("docs/helpdb.jl")
 include("docs/basedocs.jl")
 
+# threads
+include("threads.jl")
+include("threadcall.jl")
+
 function __init__()
     # Base library init
     reinit_stdio()
@@ -306,6 +338,7 @@ function __init__()
     early_init()
     init_load_path()
     init_parallel()
+    init_threadcall()
 end
 
 include = include_from_node1
diff --git a/base/sysinfo.jl b/base/sysinfo.jl
index f02950920c46b..984d1a0a6ac90 100644
--- a/base/sysinfo.jl
+++ b/base/sysinfo.jl
@@ -20,7 +20,7 @@ import ..Base: show, uv_error
 
 global CPU_CORES
 
-function init_sysinfo()
+function __init__()
     # set CPU core count
     global const CPU_CORES =
         haskey(ENV,"JULIA_CPU_CORES") ? parse(Int,ENV["JULIA_CPU_CORES"]) :
@@ -146,4 +146,6 @@ function set_process_title(title::AbstractString)
     uv_error("set_process_title", err)
 end
 
+maxrss() = ccall(:jl_maxrss, Csize_t, ())
+
 end # module Sys
diff --git a/base/task.jl b/base/task.jl
index ab436a2f1c518..a0e2422f84d01 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -2,15 +2,8 @@
 
 ## basic task functions and TLS
 
-# allow tasks to be constructed with arbitrary function objects
-Task(f) = Task(()->f())
-
 function show(io::IO, t::Task)
     print(io, "Task ($(t.state)) @0x$(hex(convert(UInt, pointer_from_objref(t)), WORD_SIZE>>2))")
-    if t.state == :failed
-        println(io)
-        show(io, CapturedException(t.result, t.backtrace))
-    end
 end
 
 # Container for a captured exception and its backtrace. Can be serialized.
@@ -24,8 +17,7 @@ type CapturedException
 
         # Process bt_raw so that it can be safely serialized
         bt_lines = Any[]
-        process_func(name, file, line, inlined_file, inlined_line, n) =
-            push!(bt_lines, (name, file, line, inlined_file, inlined_line, n))
+        process_func(args...) = push!(bt_lines, args)
         process_backtrace(process_func, :(:), bt_raw, 1:100) # Limiting this to 100 lines.
 
         new(ex, bt_lines)
@@ -35,14 +27,18 @@ end
 showerror(io::IO, ce::CapturedException) = showerror(io, ce.ex, ce.processed_bt, backtrace=true)
 
 type CompositeException <: Exception
-    exceptions::Array
+    exceptions::Vector{Any}
     CompositeException() = new(Any[])
 end
 length(c::CompositeException) = length(c.exceptions)
 push!(c::CompositeException, ex) = push!(c.exceptions, ex)
+isempty(c::CompositeException) = isempty(c.exceptions)
+start(c::CompositeException) = start(c.exceptions)
+next(c::CompositeException, state) = next(c.exceptions, state)
+done(c::CompositeException, state) = done(c.exceptions, state)
 
 function showerror(io::IO, ex::CompositeException)
-    if length(ex) > 0
+    if !isempty(ex)
         showerror(io, ex.exceptions[1])
         remaining = length(ex) - 1
         if remaining > 0
@@ -66,7 +62,13 @@ end
 
 current_task() = ccall(:jl_get_current_task, Any, ())::Task
 istaskdone(t::Task) = ((t.state == :done) | (t.state == :failed))
-istaskstarted(t::Task) = isdefined(t, :last)
+
+"""
+    istaskstarted(task) -> Bool
+
+Tell whether a task has started executing.
+"""
+istaskstarted(t::Task) = ccall(:jl_is_task_started, Cint, (Any,), t) != 0
 
 yieldto(t::Task, x::ANY = nothing) = ccall(:jl_switchto, Any, (Any, Any), t, x)
 
@@ -119,57 +121,52 @@ suppress_excp_printing(t::Task) = isa(t.storage, ObjectIdDict) ? get(get_task_tl
 function task_done_hook(t::Task)
     err = (t.state == :failed)
     result = t.result
-    nexttask = t.last
-    handled = true
+    handled = false
     if err
         t.backtrace = catch_backtrace()
     end
 
     q = t.consumers
+    t.consumers = nothing
+
+    if isa(t.donenotify, Condition) && !isempty(t.donenotify.waitq)
+        handled = true
+        notify(t.donenotify, result, error=err)
+    end
 
     #### un-optimized version
     #isa(q,Condition) && notify(q, result, error=err)
     if isa(q,Task)
+        handled = true
         nexttask = q
         nexttask.state = :runnable
+        if err
+            nexttask.exception = result
+        end
+        yieldto(nexttask, result) # this terminates the task
     elseif isa(q,Condition) && !isempty(q.waitq)
+        handled = true
         notify(q, result, error=err)
-    else
-        handled = false
-    end
-
-    t.consumers = nothing
-
-    if isa(t.donenotify,Condition)
-        handled |= !isempty(t.donenotify.waitq)
-        notify(t.donenotify, result, error=err)
     end
 
-    if nexttask.state == :runnable
-        if err
-            nexttask.exception = result
+    if err && !handled
+        if isa(result,InterruptException) && isdefined(Base,:active_repl_backend) &&
+            active_repl_backend.backend_task.state == :runnable && isempty(Workqueue) &&
+            active_repl_backend.in_eval
+            throwto(active_repl_backend.backend_task, result)
         end
-        yieldto(nexttask, result)
-    else
-        if err && !handled
-            if isa(result,InterruptException) && isdefined(Base,:active_repl_backend) &&
-                active_repl_backend.backend_task.state == :waiting && isempty(Workqueue) &&
-                active_repl_backend.in_eval
-                throwto(active_repl_backend.backend_task, result)
-            end
-            if !suppress_excp_printing(t)
-                let bt = t.backtrace
-                    # run a new task to print the error for us
-                    @schedule with_output_color(:red, STDERR) do io
-                        print(io, "ERROR (unhandled task failure): ")
-                        showerror(io, result, bt)
-                        println(io)
-                    end
+        if !suppress_excp_printing(t)
+            let bt = t.backtrace
+                # run a new task to print the error for us
+                @schedule with_output_color(:red, STDERR) do io
+                    print(io, "ERROR (unhandled task failure): ")
+                    showerror(io, result, bt)
+                    println(io)
                 end
             end
         end
-        wait()
     end
+    wait()
 end
 
 
@@ -197,13 +194,9 @@ function produce(v)
         wait()
     end
 
-    t.state = :runnable
+    t.state == :runnable || throw(AssertionError("producer.consumer.state == :runnable"))
     if empty
-        if isempty(Workqueue)
-            yieldto(t, v)
-        else
-            schedule_and_wait(t, v)
-        end
+        schedule_and_wait(t, v)
         while true
             # wait until there are more consumers
             q = ct.consumers
@@ -250,9 +243,8 @@ function consume(P::Task, values...)
         end
         push!(P.consumers.waitq, ct)
     end
-    ct.state = :waiting
 
-    schedule_and_wait(P)
+    P.state == :runnable ? schedule_and_wait(P) : wait() # don't attempt to queue it twice
 end
 
 start(t::Task) = nothing
@@ -275,16 +267,12 @@ end
 function wait(c::Condition)
     ct = current_task()
 
-    ct.state = :waiting
     push!(c.waitq, ct)
 
     try
         return wait()
     catch
         filter!(x->x!==ct, c.waitq)
-        if ct.state == :waiting
-            ct.state = :runnable
-        end
         rethrow()
     end
 end
@@ -314,7 +302,8 @@ notify1_error(c::Condition, err) = notify(c, err, error=true, all=false)
 global const Workqueue = Any[]
 
 function enq_work(t::Task)
-    ccall(:uv_stop,Void,(Ptr{Void},),eventloop())
+    t.state == :runnable || error("schedule: Task not runnable")
+    ccall(:uv_stop, Void, (Ptr{Void},), eventloop())
     push!(Workqueue, t)
     t.state = :queued
     t
@@ -334,16 +323,13 @@ end
 
 # fast version of schedule(t,v);wait()
 function schedule_and_wait(t, v=nothing)
+    t.state == :runnable || error("schedule: Task not runnable")
     if isempty(Workqueue)
-        if t.state == :runnable
-            return yieldto(t, v)
-        end
+        return yieldto(t, v)
     else
-        if t.state == :runnable
-            t.result = v
-            push!(Workqueue, t)
-            t.state = :queued
-        end
+        t.result = v
+        push!(Workqueue, t)
+        t.state = :queued
     end
     wait()
 end
@@ -361,10 +347,12 @@ function wait()
             end
         else
             t = shift!(Workqueue)
+            t.state == :queued || throw(AssertionError("shift!(Workqueue).state == :queued"))
             arg = t.result
             t.result = nothing
             t.state = :runnable
             result = yieldto(t, arg)
+            current_task().state == :runnable || throw(AssertionError("current_task().state == :runnable"))
             process_events(false)
             # return when we come out of the queue
             return result
@@ -405,7 +393,7 @@ function sync_end()
         end
     end
 
-    if length(c_ex) > 0
+    if !isempty(c_ex)
         throw(c_ex)
     end
     nothing
@@ -440,6 +428,6 @@ function async_run_thunk(thunk)
 end
 
 macro async(expr)
-    expr = localize_vars(:(()->($expr)), false)
-    :(async_run_thunk($(esc(expr))))
+    expr = localize_vars(esc(:(()->($expr))), false)
+    :(async_run_thunk($expr))
 end
diff --git a/base/test.jl b/base/test.jl
index a9172998fa513..2f7fd79b4899a 100644
--- a/base/test.jl
+++ b/base/test.jl
@@ -1,111 +1,727 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+"""
+Simple unit testing functionality:
+
+* `@test`
+* `@test_throws`
+
+All tests belong to a *test set*. There is a default, task-level
+test set that throws on the first failure. Users can choose to wrap
+their tests in (possibly nested) test sets that will store results
+and summarize them at the end of the test set with `@testset`.
+"""
 module Test
 
-export @test, @test_throws, @test_approx_eq, @test_approx_eq_eps, @inferred
+export @test, @test_throws
+export @testset
+# Legacy approximate testing functions, yet to be included
+export @test_approx_eq, @test_approx_eq_eps, @inferred
+
+#-----------------------------------------------------------------------
 
+"""
+    Result
+
+All tests produce a result object. This object may or may not be
+'stored', depending on whether the test is part of a test set.
+"""
 abstract Result
-type Success <: Result
+
+"""
+    Pass
+
+The test condition was true, i.e. the expression evaluated to true or
+the correct exception was thrown.
+"""
+immutable Pass <: Result
+    test_type::Symbol
+    orig_expr
     expr
-    resultexpr
-    res
-    Success(expr, resultexpr=nothing, res=nothing) = new(expr, resultexpr, res)
+    value
+end
+function Base.show(io::IO, t::Pass)
+    print_with_color(:green, io, "Test Passed\n")
+    print(io, "  Expression: ", t.orig_expr)
+    if t.test_type == :test_throws
+        # The correct type of exception was thrown
+        print(io, "\n      Thrown: ", typeof(t.value))
+    elseif !isa(t.expr, Expr)
+        # Maybe just a constant, like true
+        print(io, "\n   Evaluated: ", t.expr)
+    elseif t.test_type == :test && t.expr.head == :comparison
+        # The test was an expression, so display the term-by-term
+        # evaluated version as well
+        print(io, "\n   Evaluated: ", t.expr)
+    end
 end
-type Failure <: Result
+
+"""
+    Fail
+
+The test condition was false, i.e. the expression evaluated to false or
+the correct exception was not thrown.
+"""
+type Fail <: Result
+    test_type::Symbol
+    orig_expr
     expr
-    resultexpr
+    value
 end
-Failure(expr) = Failure(expr, nothing)
+function Base.show(io::IO, t::Fail)
+    print_with_color(:red, io, "Test Failed\n")
+    print(io, "  Expression: ", t.orig_expr)
+    if t.test_type == :test_throws_wrong
+        # An exception was thrown, but it was of the wrong type
+        print(io, "\n    Expected: ", t.expr)
+        print(io, "\n      Thrown: ", typeof(t.value))
+    elseif t.test_type == :test_throws_nothing
+        # An exception was expected, but no exception was thrown
+        print(io, "\n    Expected: ", t.expr)
+        print(io, "\n  No exception thrown")
+    elseif !isa(t.expr, Expr)
+        # Maybe just a constant, like false
+        print(io, "\n   Evaluated: ", t.expr)
+    elseif t.test_type == :test && t.expr.head == :comparison
+        # The test was an expression, so display the term-by-term
+        # evaluated version as well
+        print(io, "\n   Evaluated: ", t.expr)
+    end
+end
+
+"""
+    Error
+
+The test condition couldn't be evaluated due to an exception, or
+it evaluated to something other than a `Bool`.
+"""
 type Error <: Result
-    expr
-    err
+    test_type::Symbol
+    orig_expr
+    value
+    backtrace
+end
+function Base.show(io::IO, t::Error)
+    print_with_color(:red, io, "Error During Test\n")
+    if t.test_type == :test_nonbool
+        println(io, "  Expression evaluated to non-Boolean")
+        println(io, "  Expression: ", t.orig_expr)
+        print(  io, "       Value: ", t.value)
+    elseif t.test_type == :test_error
+        println(io, "  Test threw an exception of type ", typeof(t.value))
+        println(io, "  Expression: ", t.orig_expr)
+        # Capture error message and indent to match
+        errmsg = sprint(showerror, t.value, t.backtrace)
+        print(io, join(map(line->string("  ",line),
+                            split(errmsg, "\n")), "\n"))
+    elseif t.test_type == :nontest_error
+        # we had an error outside of a @test
+        println(io, "  Got an exception of type $(typeof(t.value)) outside of a @test")
+        # Capture error message and indent to match
+        errmsg = sprint(showerror, t.value, t.backtrace)
+        print(io, join(map(line->string("  ",line),
+                            split(errmsg, "\n")), "\n"))
+    end
+end
+
+
+#-----------------------------------------------------------------------
+
+abstract ExecutionResult
+
+immutable Returned <: ExecutionResult
+    value
+end
+
+immutable Threw <: ExecutionResult
+    exception
     backtrace
 end
 
-default_handler(r::Success) = r.res
-function default_handler(r::Failure)
-    if r.resultexpr !== nothing
-        error("test failed: $(r.resultexpr)\n in expression: $(r.expr)")
+# @test - check if the expression evaluates to true
+# In the special case of a comparison, e.g. x == 5, generate code to
+# evaluate each term in the comparison individually so the results
+# can be displayed nicely.
+"""
+    @test ex
+
+Tests that the expression `ex` evaluates to `true`.
+Returns a `Pass` `Result` if it does, a `Fail` `Result` if it is
+`false`, and an `Error` `Result` if it could not be evaluated.
+"""
+macro test(ex)
+    orig_ex = Expr(:quote,ex)
+    # If the test is a comparison
+    if isa(ex, Expr) && ex.head == :comparison
+        # Generate a temporary for every term in the expression
+        n = length(ex.args)
+        terms = [gensym() for i in 1:n]
+        # Create a new block that evaluates each term in the
+        # comparison indivudally
+        comp_block = Expr(:block)
+        comp_block.args = [:(
+                            $(terms[i]) = $(esc(ex.args[i]))
+                            ) for i in 1:n]
+        # The block should then evaluate whether the comparison
+        # evaluates to true by splicing in the new terms into the
+        # original comparsion. The block returns
+        # - an expression with the values of terms spliced in
+        # - the result of the comparison itself
+        push!(comp_block.args,
+              :(  Expr(:comparison, $(terms...)),  # Terms spliced in
+                $(Expr(:comparison,   terms...))   # Comparison itself
+                  ))
+        testpair = comp_block
     else
-        error("test failed in expression: $(r.expr)")
+        testpair = :(($orig_ex, $(esc(ex))))
+    end
+    result = quote
+        try
+            Returned($testpair)
+        catch _e
+            Threw(_e, catch_backtrace())
+        end
     end
+    Base.remove_linenums!(result)
+    # code to call do_test with execution result and original expr
+    :(do_test($result, $orig_ex))
 end
-default_handler(r::Error) = rethrow(r)
 
-handler() = get(task_local_storage(), :TEST_HANDLER, default_handler)
+# An internal function, called by the code generated by the @test
+# macro to actually perform the evaluation and manage the result.
+function do_test(result::ExecutionResult, orig_expr)
+    # get_testset() returns the most recently added tests set
+    # We then call record() with this test set and the test result
+    if isa(result, Returned)
+        # expr, in the case of a comparison, will contain the
+        # comparison with evaluated values of each term spliced in.
+        # For anything else, just contains the test expression.
+        # value is the evaluated value of the whole test expression.
+        # Ideally it is true, but it may be false or non-Boolean.
+        expr, value = result.value
+        testres = if isa(value, Bool)
+            value ? Pass(:test, orig_expr, expr, value) :
+                    Fail(:test, orig_expr, expr, value)
+        else
+            # If the result is non-Boolean, this counts as an Error
+            Error(:test_nonbool, orig_expr, value, nothing)
+        end
+    else
+        # The predicate couldn't be evaluated without throwing an
+        # exception, so that is an Error and not a Fail
+        @assert isa(result, Threw)
+        testres = Error(:test_error, orig_expr, result.exception, result.backtrace)
+    end
+    record(get_testset(), testres)
+end
 
-with_handler(f::Function, handler) =
-    task_local_storage(f, :TEST_HANDLER, handler)
+#-----------------------------------------------------------------------
 
-import Base.showerror
+"""
+    @test_throws extype ex
 
-showerror(io::IO, r::Error) = showerror(io, r, [])
-function showerror(io::IO, r::Error, bt)
-    println(io, "test error in expression: $(r.expr)")
-    showerror(io, r.err, r.backtrace)
+Tests that the expression `ex` throws an exception of type `extype`.
+"""
+macro test_throws(extype, ex)
+    orig_ex = Expr(:quote,ex)
+    result = quote
+        try
+            Returned($(esc(ex)))
+        catch _e
+            Threw(_e, nothing)
+        end
+    end
+    Base.remove_linenums!(result)
+    :(do_test_throws($result, $orig_ex, $(esc(extype))))
 end
 
-function do_test(body,qex)
-    handler()(try
-        rex, val = body()
-        val ? Success(qex, rex) : Failure(qex,rex)
-    catch err
-        Error(qex,err,catch_backtrace())
-    end)
+# An internal function, called by the code generated by @test_throws
+# to evaluate and catch the thrown exception - if it exists
+function do_test_throws(result::ExecutionResult, orig_expr, extype)
+    if isa(result, Threw)
+        # Check the right type of exception was thrown
+        if is(typeof(result.exception), extype)
+            testres = Pass(:test_throws, orig_expr, extype, result.exception)
+        else
+            testres = Fail(:test_throws_wrong, orig_expr, extype, result.exception)
+        end
+    else
+        testres = Fail(:test_throws_nothing, orig_expr, extype, nothing)
+    end
+    record(get_testset(), testres)
 end
 
-function do_test_throws(body, qex, bt, extype)
-    handler()(try
-        body()
-        Failure(qex, "$qex did not throw $(extype === nothing ? "anything" : extype)")
-    catch err
-        if extype === nothing
-            Base.warn("""
-            @test_throws without an exception type is deprecated;
-            Use `@test_throws $(typeof(err)) $(qex)` instead.
-            """, bt = bt)
-            Success(qex, nothing, err)
-        else
-            if isa(err, extype)
-                Success(qex, nothing, err)
-            else
-                if isa(err,Type)
-                    Failure(qex, "the type $err was thrown instead of an instance of $extype")
-                else
-                    Failure(qex, "$err was thrown instead of $extype")
-                end
+#-----------------------------------------------------------------------
+
+# The AbstractTestSet interface is defined by two methods:
+# record(AbstractTestSet, Result)
+#   Called by do_test after a test is evaluated
+# finish(AbstractTestSet)
+#   Called after the test set has been popped from the test set stack
+abstract AbstractTestSet
+
+"""
+    record(ts::AbstractTestSet, res::Result)
+
+Record a result to a testset. This function is called by the `@testset`
+infrastructure each time a contained `@test` macro completes, and is given the
+test result (which could be an `Error`). This will also be called with an `Error`
+if an exception is thrown inside the test block but outside of a `@test` context.
+"""
+function record end
+
+"""
+    finish(ts::AbstractTestSet)
+
+Do any final processing necessary for the given testset. This is called by the
+`@testset` infrastructure after a test block executes. One common use for this
+function is to record the testset to the parent's results list, using
+`get_testset`.
+"""
+function finish end
+
+"""
+    TestSetException
+
+Thrown when a test set finishes and not all tests passed.
+"""
+type TestSetException <: Exception
+    pass::Int
+    fail::Int
+    error::Int
+end
+
+function Base.show(io::IO, ex::TestSetException)
+    print(io, "Some tests did not pass: ")
+    print(io, ex.pass,  " passed, ")
+    print(io, ex.fail,  " failed, ")
+    print(io, ex.error, " errored.")
+end
+
+#-----------------------------------------------------------------------
+
+"""
+    FallbackTestSet
+
+A simple fallback test set that throws immediately on a failure.
+"""
+immutable FallbackTestSet <: AbstractTestSet
+end
+fallback_testset = FallbackTestSet()
+
+# Records nothing, and throws an error immediately whenever a Fail or
+# Error occurs. Takes no action in the event of a Pass result
+record(ts::FallbackTestSet, t::Pass) = t
+function record(ts::FallbackTestSet, t::Union{Fail,Error})
+    println(t)
+    error("There was an error during testing")
+end
+# We don't need to do anything as we don't record anything
+finish(ts::FallbackTestSet) = ts
+
+#-----------------------------------------------------------------------
+
+"""
+    DefaultTestSet
+
+If using the DefaultTestSet, the test results will be recorded. If there
+are any `Fail`s or `Error`s, an exception will be thrown only at the end,
+along with a summary of the test results.
+"""
+type DefaultTestSet <: AbstractTestSet
+    description::AbstractString
+    results::Vector
+    anynonpass::Bool
+end
+DefaultTestSet(desc) = DefaultTestSet(desc, [], false)
+
+# For a passing result, simply store the result
+record(ts::DefaultTestSet, t::Pass) = (push!(ts.results, t); t)
+# For the other result types, immediately print the error message
+# but do not terminate. Print a backtrace.
+function record(ts::DefaultTestSet, t::Union{Fail,Error})
+    print_with_color(:white, ts.description, ": ")
+    print(t)
+    # don't print the backtrace for Errors because it gets printed in the show
+    # method
+    isa(t, Error) || Base.show_backtrace(STDOUT, backtrace())
+    println()
+    push!(ts.results, t)
+    t
+end
+
+# When a DefaultTestSet finishes, it records itself to its parent
+# testset, if there is one. This allows for recursive printing of
+# the results at the end of the tests
+record(ts::DefaultTestSet, t::AbstractTestSet) = push!(ts.results, t)
+
+# Called at the end of a @testset, behaviour depends on whether
+# this is a child of another testset, or the "root" testset
+function finish(ts::DefaultTestSet)
+    # If we are a nested test set, do not print a full summary
+    # now - let the parent test set do the printing
+    if get_testset_depth() != 0
+        # Attach this test set to the parent test set
+        parent_ts = get_testset()
+        record(parent_ts, ts)
+        return
+    end
+    # Calculate the overall number for each type so each of
+    # the test result types are aligned
+    passes, fails, errors, c_passes, c_fails, c_errors = get_test_counts(ts)
+    total_pass  = passes + c_passes
+    total_fail  = fails  + c_fails
+    total_error = errors + c_errors
+    dig_pass  = total_pass  > 0 ? ndigits(total_pass) : 0
+    dig_fail  = total_fail  > 0 ? ndigits(total_fail)  : 0
+    dig_error = total_error > 0 ? ndigits(total_error) : 0
+    total = total_pass + total_fail + total_error
+    dig_total = total > 0 ? ndigits(total) : 0
+    # For each category, take max of digits and header width if there are
+    # tests of that type
+    pass_width  = dig_pass  > 0 ? max(length("Pass"),  dig_pass)  : 0
+    fail_width  = dig_fail  > 0 ? max(length("Fail"),  dig_fail)  : 0
+    error_width = dig_error > 0 ? max(length("Error"), dig_error) : 0
+    total_width = dig_total > 0 ? max(length("Total"), dig_total) : 0
+    # Calculate the alignment of the test result counts by
+    # recursively walking the tree of test sets
+    align = max(get_alignment(ts, 0), length("Test Summary:"))
+    # Print the outer test set header once
+    print_with_color(:white, rpad("Test Summary:",align," "))
+    print(" | ")
+    if pass_width > 0
+        print_with_color(:green, lpad("Pass",pass_width," "))
+        print("  ")
+    end
+    if fail_width > 0
+        print_with_color(:red, lpad("Fail",fail_width," "))
+        print("  ")
+    end
+    if error_width > 0
+        print_with_color(:red, lpad("Error",error_width," "))
+        print("  ")
+    end
+    if total_width > 0
+        print_with_color(:blue, lpad("Total",total_width," "))
+    end
+    println()
+    # Recursively print a summary at every level
+    print_counts(ts, 0, align, pass_width, fail_width, error_width, total_width)
+    # Finally throw an error as we are the outermost test set
+    if total != total_pass
+        throw(TestSetException(total_pass,total_fail,total_error))
+    end
+
+    # return the testset so it is returned from the @testset macro
+    ts
+end
+
+# Recursive function that finds the column that the result counts
+# can begin at by taking into account the width of the descriptions
+# and the amount of indentation. If a test set had no failures, and
+# no failures in child test sets, there is no need to include those
+# in calculating the alignment
+function get_alignment(ts::DefaultTestSet, depth::Int)
+    # The minimum width at this depth is...
+    ts_width = 2*depth + length(ts.description)
+    # If all passing, no need to look at children
+    !ts.anynonpass && return ts_width
+    # Return the maximum of this width and the minimum width
+    # for all children (if they exist)
+    isempty(ts.results) && return ts_width
+    child_widths = map(t->get_alignment(t, depth+1), ts.results)
+    return max(ts_width, maximum(child_widths))
+end
+get_alignment(ts, depth::Int) = 0
+
+# Recursive function that counts the number of test results of each
+# type directly in the testset, and totals across the child testsets
+function get_test_counts(ts::DefaultTestSet)
+    passes, fails, errors = 0, 0, 0
+    c_passes, c_fails, c_errors = 0, 0, 0
+    for t in ts.results
+        isa(t, Pass)  && (passes += 1)
+        isa(t, Fail)  && (fails  += 1)
+        isa(t, Error) && (errors += 1)
+        if isa(t, DefaultTestSet)
+            np, nf, ne, ncp, ncf, nce = get_test_counts(t)
+            c_passes += np + ncp
+            c_fails  += nf + ncf
+            c_errors += ne + nce
+        end
+    end
+    ts.anynonpass = (fails + errors + c_fails + c_errors > 0)
+    return passes, fails, errors, c_passes, c_fails, c_errors
+end
+
+# Recursive function that prints out the results at each level of
+# the tree of test sets
+function print_counts(ts::DefaultTestSet, depth, align,
+                        pass_width, fail_width, error_width, total_width)
+    # Count results by each type at this level, and recursively
+    # through and child test sets
+    passes, fails, errors, c_passes, c_fails, c_errors = get_test_counts(ts)
+    subtotal = passes + fails + errors + c_passes + c_fails + c_errors
+
+    # Print test set header, with an alignment that ensures all
+    # the test results appear above each other
+    print(rpad(string("  "^depth, ts.description), align, " "), " | ")
+
+    np = passes + c_passes
+    if np > 0
+        print_with_color(:green, lpad(string(np), pass_width, " "), "  ")
+    elseif pass_width > 0
+        # No passes at this level, but some at another level
+        print(" "^pass_width, "  ")
+    end
+
+    nf = fails + c_fails
+    if nf > 0
+        print_with_color(:red, lpad(string(nf), fail_width, " "), "  ")
+    elseif fail_width > 0
+        # No fails at this level, but some at another level
+        print(" "^fail_width, "  ")
+    end
+
+    ne = errors + c_errors
+    if ne > 0
+        print_with_color(:red, lpad(string(ne), error_width, " "), "  ")
+    elseif error_width > 0
+        # No errors at this level, but some at another level
+        print(" "^error_width, "  ")
+    end
+
+    if np == 0 && nf == 0 && ne == 0
+        print_with_color(:blue, "No tests")
+    else
+        print_with_color(:blue, lpad(string(subtotal), total_width, " "))
+    end
+    println()
+
+    # Only print results at lower levels if we had failures
+    if np != subtotal
+        for t in ts.results
+            if isa(t, DefaultTestSet)
+                print_counts(t, depth + 1, align,
+                                pass_width, fail_width, error_width, total_width)
             end
         end
-    end)
+    end
 end
 
-macro test(ex)
-    if typeof(ex) == Expr && ex.head == :comparison
-        syms = [gensym() for i = 1:length(ex.args)]
-        func_block = Expr(:block)
-        # insert assignment into a block
-        func_block.args = [:($(syms[i]) = $(esc(ex.args[i]))) for i = 1:length(ex.args)]
-        # finish the block with a return
-        push!(func_block.args, Expr(:return, :(Expr(:comparison, $(syms...)), $(Expr(:comparison, syms...)))))
-        :(do_test(()->($func_block), $(Expr(:quote,ex))))
+#-----------------------------------------------------------------------
+
+"""
+    @testset [CustomTestSet] [option=val  ...] ["description"] begin ... end
+    @testset [CustomTestSet] [option=val  ...] ["description \$v"] for v in (...) ... end
+    @testset [CustomTestSet] [option=val  ...] ["description \$v, \$w"] for v in (...), w in (...) ... end
+
+Starts a new test set, or multiple test sets if a `for` loop is provided.
+
+If no custom testset type is given it defaults to creating a `DefaultTestSet`.
+`DefaultTestSet` records all the results and, and if there are any `Fail`s or
+`Error`s, throws an exception at the end of the top-level (non-nested) test set,
+along with a summary of the test results.
+
+Any custom testset type (subtype of `AbstractTestSet`) can be given and it will
+also be used for any nested `@testset` invocations. The given options are only
+applied to the test set where they are given. The default test set type does
+not take any options.
+
+The description string accepts interpolation from the loop indices.
+If no description is provided, one is constructed based on the variables.
+
+By default the `@testset` macro will return the testset object itself, though
+this behavior can be customized in other testset types. If a `for` loop is used
+then the macro collects and returns a list of the return values of the `finish`
+method, which by default will return a list of the testset objects used in
+each iteration.
+"""
+macro testset(args...)
+    isempty(args) && error("No arguments to @testset")
+
+    tests = args[end]
+
+    # Determine if a single block or for-loop style
+    if !isa(tests,Expr) || (tests.head != :for && tests.head != :block)
+        error("Expected begin/end block or for loop as argument to @testset")
+    end
+
+    if tests.head == :for
+        return testset_forloop(args, tests)
     else
-        :(do_test(()->($(Expr(:quote,ex)), $(esc(ex))), $(Expr(:quote,ex))))
+        return testset_beginend(args, tests)
     end
 end
 
-macro test_throws(args...)
-    ex = nothing
-    extype = nothing
-    # Users should pass (ExceptionType, Expression) but we give a warning to users that only pass (Expression)
-    if length(args) == 1
-        ex = args[1]
-    elseif length(args) == 2
-        ex = args[2]
-        extype = args[1]
+"""
+Generate the code for a `@testset` with a `begin`/`end` argument
+"""
+function testset_beginend(args, tests)
+    desc, testsettype, options = parse_testset_args(args[1:end-1])
+    if desc == nothing
+        desc = "test set"
+    end
+    # if we're at the top level we'll default to DefaultTestSet. Otherwise
+    # default to the type of the parent testset
+    if testsettype == nothing
+        testsettype = :(get_testset_depth() == 0 ? DefaultTestSet : typeof(get_testset()))
+    end
+
+    # Generate a block of code that initializes a new testset, adds
+    # it to the task local storage, evaluates the test(s), before
+    # finally removing the testset and giving it a change to take
+    # action (such as reporting the results)
+    quote
+        ts = $(testsettype)($desc; $options...)
+        push_testset(ts)
+        try
+            $(esc(tests))
+        catch err
+            # something in the test block threw an error. Count that as an
+            # error in this test set
+            record(ts, Error(:nontest_error, :(), err, catch_backtrace()))
+        end
+        pop_testset()
+        finish(ts)
     end
-    :(do_test_throws(()->($(esc(ex))),$(Expr(:quote,ex)),backtrace(),$(esc(extype))))
 end
 
+
+"""
+Generate the code for a `@testset` with a `for` loop argument
+"""
+function testset_forloop(args, testloop)
+    # pull out the loop variables. We might need them for generating the
+    # description and we'll definitely need them for generating the
+    # comprehension expression at the end
+    loopvars = Expr[]
+    if testloop.args[1].head == :(=)
+        push!(loopvars, testloop.args[1])
+    elseif testloop.args[1].head == :block
+        for loopvar in testloop.args[1].args
+            push!(loopvars, loopvar)
+        end
+    else
+        error("Unexpected argument to @testset")
+    end
+
+    desc, testsettype, options = parse_testset_args(args[1:end-1])
+
+    if desc == nothing
+        # No description provided. Generate from the loop variable names
+        v = loopvars[1].args[1]
+        desc = Expr(:string,"$v = ", esc(v)) # first variable
+        for l = loopvars[2:end]
+            v = l.args[1]
+            push!(desc.args,", $v = ")
+            push!(desc.args, esc(v))
+        end
+    end
+
+    if testsettype == nothing
+        testsettype = :(get_testset_depth() == 0 ? DefaultTestSet : typeof(get_testset()))
+    end
+
+    # Uses a similar block as for `@testset`, except that it is
+    # wrapped in the outer loop provided by the user
+    tests = testloop.args[2]
+    blk = quote
+        ts = $(testsettype)($desc; $options...)
+        push_testset(ts)
+        try
+            $(esc(tests))
+        catch err
+            # something in the test block threw an error. Count that as an
+            # error in this test set
+            record(ts, Error(:nontest_error, :(), err, catch_backtrace()))
+        end
+        pop_testset()
+        finish(ts)
+    end
+    Expr(:comprehension, blk, [esc(v) for v in loopvars]...)
+end
+
+"""
+Parse the arguments to the `@testset` macro to pull out the description,
+Testset Type, and options. Generally this should be called with all the macro
+arguments except the last one, which is the test expression itself.
+"""
+function parse_testset_args(args)
+    desc = nothing
+    testsettype = nothing
+    options = :(Dict{Symbol, Any}())
+    for arg in args[1:end]
+        # a standalone symbol is assumed to be the test set we should use
+        if isa(arg, Symbol)
+            testsettype = esc(arg)
+        # a string is the description
+        elseif isa(arg, AbstractString) || (isa(arg, Expr) && arg.head == :string)
+            desc = esc(arg)
+        # an assignment is an option
+        elseif isa(arg, Expr) && arg.head == :(=)
+            # we're building up a Dict literal here
+            key = Expr(:quote, arg.args[1])
+            push!(options.args, Expr(:(=>), key, arg.args[2]))
+        else
+            error("Unexpected argument $arg to @testset")
+        end
+    end
+
+    (desc, testsettype, options)
+end
+
+#-----------------------------------------------------------------------
+# Various helper methods for test sets
+
+"""
+    get_testset()
+
+Retrieve the active test set from the task's local storage. If no
+test set is active, use the fallback default test set.
+"""
+function get_testset()
+    testsets = get(task_local_storage(), :__BASETESTNEXT__, AbstractTestSet[])
+    return isempty(testsets) ? fallback_testset : testsets[end]
+end
+
+"""
+    push_testset(ts::AbstractTestSet)
+
+Adds the test set to the task_local_storage.
+"""
+function push_testset(ts::AbstractTestSet)
+    testsets = get(task_local_storage(), :__BASETESTNEXT__, AbstractTestSet[])
+    push!(testsets, ts)
+    setindex!(task_local_storage(), testsets, :__BASETESTNEXT__)
+end
+
+"""
+    pop_testset()
+
+Pops the last test set added to the task_local_storage. If there are no
+active test sets, returns the fallback default test set.
+"""
+function pop_testset()
+    testsets = get(task_local_storage(), :__BASETESTNEXT__, AbstractTestSet[])
+    ret = isempty(testsets) ? fallback_testset : pop!(testsets)
+    setindex!(task_local_storage(), testsets, :__BASETESTNEXT__)
+    return ret
+end
+
+"""
+    get_testset_depth()
+
+Returns the number of active test sets, not including the defaut test set
+"""
+function get_testset_depth()
+    testsets = get(task_local_storage(), :__BASETESTNEXT__, AbstractTestSet[])
+    return length(testsets)
+end
+
+#-----------------------------------------------------------------------
+# Legacy approximate testing functions, yet to be included
+
 approx_full(x::AbstractArray) = x
 approx_full(x::Number) = x
 approx_full(x) = full(x)
@@ -145,17 +761,27 @@ array_eps(a) = eps(float(maximum(x->(isfinite(x) ? abs(x) : oftype(x,NaN)), a)))
 test_approx_eq(va, vb, astr, bstr) =
     test_approx_eq(va, vb, 1E4*length(va)*max(array_eps(va), array_eps(vb)), astr, bstr)
 
+"""
+    @test_approx_eq_eps(a, b, tol)
+
+Test two floating point numbers `a` and `b` for equality taking in account a margin of tolerance given by `tol`.
+"""
 macro test_approx_eq_eps(a, b, c)
     :(test_approx_eq($(esc(a)), $(esc(b)), $(esc(c)), $(string(a)), $(string(b))))
 end
 
+"""
+    @test_approx_eq(a, b)
+
+Test two floating point numbers `a` and `b` for equality taking in account small numerical errors.
+"""
 macro test_approx_eq(a, b)
     :(test_approx_eq($(esc(a)), $(esc(b)), $(string(a)), $(string(b))))
 end
 
 macro inferred(ex)
     ex.head == :call || error("@inferred requires a call expression")
-    quote
+    Base.remove_linenums!(quote
         vals = ($([esc(ex.args[i]) for i = 2:length(ex.args)]...),)
         inftypes = Base.return_types($(esc(ex.args[1])), Base.typesof(vals...))
         @assert length(inftypes) == 1
@@ -163,7 +789,7 @@ macro inferred(ex)
         rettype = isa(result, Type) ? Type{result} : typeof(result)
         rettype == inftypes[1] || error("return type $rettype does not match inferred return type $(inftypes[1])")
         result
-    end
+    end)
 end
 
 # Test approximate equality of vectors or columns of matrices modulo floating
diff --git a/base/threadcall.jl b/base/threadcall.jl
new file mode 100644
index 0000000000000..fd50221e31ab4
--- /dev/null
+++ b/base/threadcall.jl
@@ -0,0 +1,97 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+const max_ccall_threads = parse(Int, get(ENV, "UV_THREADPOOL_SIZE", "4"))
+const thread_notifiers = [Nullable{Condition}() for i in 1:max_ccall_threads]
+const threadcall_restrictor = Semaphore(max_ccall_threads)
+
+function notify_fun(idx)
+    global thread_notifiers
+    notify(get(thread_notifiers[idx]))
+    return
+end
+
+function init_threadcall()
+    global c_notify_fun = cfunction(notify_fun, Void, (Cint,))
+end
+
+"""
+    @threadcall((cfunc, clib), rettype, (argtypes...), argvals...)
+
+The `@threadcall` macro is called in the same way as `ccall` but does the work
+in a different thread. This is useful when you want to call a blocking C
+function without causing the main `julia` thread to become blocked. Concurrency
+is limited by size of the libuv thread pool, which defaults to 4 threads but
+can be increased by setting the `UV_THREADPOOL_SIZE` environment variable and
+restarting the `julia` process.
+"""
+macro threadcall(f, rettype, argtypes, argvals...)
+    # check for usage errors
+    isa(argtypes,Expr) && argtypes.head == :tuple ||
+        error("threadcall: argument types must be a tuple")
+    length(argtypes.args) == length(argvals) ||
+        error("threadcall: wrong number of arguments to C function")
+
+    # hygiene escape arguments
+    f = esc(f)
+    rettype = esc(rettype)
+    argtypes = map(esc, argtypes.args)
+    argvals = map(esc, argvals)
+
+    # construct non-allocating wrapper to call C function
+    wrapper = :(function wrapper(args_ptr::Ptr{Void}, retval_ptr::Ptr{Void})
+        p = args_ptr
+    end)
+    body = wrapper.args[2].args
+    args = Symbol[]
+    for (i,T) in enumerate(argtypes)
+        arg = symbol("arg$i")
+        push!(body, :($arg = unsafe_load(convert(Ptr{$T}, p))))
+        push!(body, :(p += sizeof($T)))
+        push!(args, arg)
+    end
+    push!(body, :(ret = ccall($f, $rettype, ($(argtypes...),), $(args...))))
+    push!(body, :(unsafe_store!(convert(Ptr{$rettype}, retval_ptr), ret)))
+    push!(body, :(return sizeof($rettype)))
+
+    # return code to generate wrapper function and send work request thread queue
+    :(let
+        $wrapper
+        do_threadcall(wrapper, $rettype, Any[$(argtypes...)], Any[$(argvals...)])
+    end)
+end
+
+function do_threadcall(wrapper::Function, rettype::Type, argtypes::Vector, argvals::Vector)
+    # generate function pointer
+    fun_ptr = cfunction(wrapper, Int, (Ptr{Void}, Ptr{Void}))
+
+    # cconvert, root and unsafe_convert arguments
+    roots = Any[]
+    args_size = isempty(argtypes) ? 0 : sum(sizeof, argtypes)
+    args_arr = Array{UInt8}(args_size)
+    ptr = pointer(args_arr)
+    for (T, x) in zip(argtypes, argvals)
+        y = cconvert(T, x)
+        push!(roots, y)
+        unsafe_store!(convert(Ptr{T}, ptr), unsafe_convert(T, y))
+    end
+
+    # create return buffer
+    ret_arr = Array(UInt8, sizeof(rettype))
+
+    # wait for a worker thread to be available
+    acquire(threadcall_restrictor)
+    idx = findfirst(isnull, thread_notifiers)
+    thread_notifiers[idx] = Nullable{Condition}(Condition())
+
+    # queue up the work to be done
+    ccall(:jl_queue_work, Void,
+        (Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}, Ptr{Void}, Cint),
+        fun_ptr, args_arr, ret_arr, c_notify_fun, idx)
+
+    # wait for a result & return it
+    wait(get(thread_notifiers[idx]))
+    thread_notifiers[idx] = Nullable{Condition}()
+    release(threadcall_restrictor)
+
+    unsafe_load(convert(Ptr{rettype}, pointer(ret_arr)))
+end
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
new file mode 100644
index 0000000000000..e2adacf9c88bd
--- /dev/null
+++ b/base/threadingconstructs.jl
@@ -0,0 +1,65 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+export threadid, nthreads, @threads
+
+threadid() = Int(ccall(:jl_threadid, Int16, ())+1)
+
+# Inclusive upper bound on threadid()
+nthreads() = Int(unsafe_load(cglobal(:jl_n_threads, Cint)))
+
+function _threadsfor(iter,lbody)
+    fun = gensym("_threadsfor")
+    lidx = iter.args[1]         # index
+    range = iter.args[2]
+    quote
+        function $fun()
+            tid = threadid()
+            r = $(esc(range))
+            # divide loop iterations among threads
+            len, rem = divrem(length(r), nthreads())
+            # not enough iterations for all the threads?
+            if len == 0
+                if tid > rem
+                    return
+                end
+                len, rem = 1, 0
+            end
+            # compute this thread's iterations
+            f = 1 + ((tid-1) * len)
+            l = f + len - 1
+            # distribute remaining iterations evenly
+            if rem > 0
+                if tid <= rem
+                    f = f + (tid-1)
+                    l = l + tid
+                else
+                    f = f + rem
+                    l = l + rem
+                end
+            end
+            # run this thread's iterations
+            for i = f:l
+                local $(esc(lidx)) = Base.unsafe_getindex(r,i)
+                $(esc(lbody))
+            end
+        end
+        ccall(:jl_threading_run, Void, (Any,), Core.svec($fun))
+    end
+end
+
+macro threads(args...)
+    na = length(args)
+    if na != 1
+        throw(ArgumentError("wrong number of arguments in @threads"))
+    end
+    ex = args[1]
+    if !isa(ex, Expr)
+        throw(ArgumentError("need an expression argument to @threads"))
+    end
+    if is(ex.head, :for)
+        return _threadsfor(ex.args[1],ex.args[2])
+    else
+        throw(ArgumentError("unrecognized argument to @threads"))
+    end
+end
+
diff --git a/base/threads.jl b/base/threads.jl
new file mode 100644
index 0000000000000..4550e41dd0ba7
--- /dev/null
+++ b/base/threads.jl
@@ -0,0 +1,10 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+module Threads
+
+include("threadingconstructs.jl")
+include("atomics.jl")
+include("locks.jl")
+
+end
+
diff --git a/base/tuple.jl b/base/tuple.jl
index 270f44e9e4f71..5e0e6529bd9ca 100644
--- a/base/tuple.jl
+++ b/base/tuple.jl
@@ -16,6 +16,18 @@ start(t::Tuple) = 1
 done(t::Tuple, i::Int) = (length(t) < i)
 next(t::Tuple, i::Int) = (t[i], i+1)
 
+eachindex(t::Tuple) = 1:length(t)
+
+function eachindex(t::Tuple, t2::Tuple...)
+    @_inline_meta
+    1:_maxlength(t, t2...)
+end
+_maxlength(t::Tuple) = length(t)
+function _maxlength(t::Tuple, t2::Tuple, t3::Tuple...)
+    @_inline_meta
+    max(length(t), _maxlength(t2, t3...))
+end
+
 # this allows partial evaluation of bounded sequences of next() calls on tuples,
 # while reducing to plain next() for arbitrary iterables.
 indexed_next(t::Tuple, i::Int, state) = (t[i], i+1)
diff --git a/base/unicode/UnicodeError.jl b/base/unicode/UnicodeError.jl
index 5b9002729ccf3..b1b694df7fdf2 100644
--- a/base/unicode/UnicodeError.jl
+++ b/base/unicode/UnicodeError.jl
@@ -2,12 +2,12 @@
 
 ##    Error messages for Unicode / UTF support
 
-const UTF_ERR_SHORT             = "invalid UTF-8 sequence starting at index <<1>> (0x<<2>>) missing one or more continuation bytes)"
+const UTF_ERR_SHORT             = "invalid UTF-8 sequence starting at index <<1>> (0x<<2>> missing one or more continuation bytes)"
 const UTF_ERR_CONT              = "invalid UTF-8 sequence starting at index <<1>> (0x<<2>> is not a continuation byte)"
 const UTF_ERR_LONG              = "invalid UTF-8 sequence, overlong encoding starting at index <<1>> (0x<<2>>)"
 const UTF_ERR_NOT_LEAD          = "not a leading Unicode surrogate code unit at index <<1>> (0x<<2>>)"
 const UTF_ERR_NOT_TRAIL         = "not a trailing Unicode surrogate code unit at index <<1>> (0x<<2>>)"
-const UTF_ERR_NOT_SURROGATE     = "not a valid Unicode surrogate code unit at index <<1>> (0x<<2>>"
+const UTF_ERR_NOT_SURROGATE     = "not a valid Unicode surrogate code unit at index <<1>> (0x<<2>>)"
 const UTF_ERR_MISSING_SURROGATE = "missing trailing Unicode surrogate code unit after index <<1>> (0x<<2>>)"
 const UTF_ERR_INVALID           = "invalid Unicode character starting at index <<1>> (0x<<2>> > 0x10ffff)"
 const UTF_ERR_SURROGATE         = "surrogate encoding not allowed in UTF-8 or UTF-32, at index <<1>> (0x<<2>>)"
diff --git a/base/unicode/utf16.jl b/base/unicode/utf16.jl
index 2384177e1128d..712adbb75a896 100644
--- a/base/unicode/utf16.jl
+++ b/base/unicode/utf16.jl
@@ -259,7 +259,7 @@ function map(fun, str::UTF16String)
         if !isa(c2, Char)
             throw(UnicodeError(UTF_ERR_MAP_CHAR, 0, 0))
         end
-        uc = reinterpret(UInt32, c2)
+        uc = UInt32(c2)
         if uc < 0x10000
             if is_surrogate_codeunit(UInt16(uc))
                 throw(UnicodeError(UTF_ERR_INVALID_CHAR, 0, uc))
diff --git a/base/unicode/utf32.jl b/base/unicode/utf32.jl
index 83e7b60830152..4b9ebeee4f278 100644
--- a/base/unicode/utf32.jl
+++ b/base/unicode/utf32.jl
@@ -122,9 +122,12 @@ function convert(::Type{UTF32String}, dat::AbstractVector{UInt32})
     @inbounds return fast_utf_copy(UTF32String, UInt32, length(dat), dat, true)
 end
 
-convert{T<:Union{Int32,Char}}(::Type{UTF32String}, data::AbstractVector{T}) =
+convert(::Type{UTF32String}, data::AbstractVector{Int32}) =
     convert(UTF32String, reinterpret(UInt32, convert(Vector{T}, data)))
 
+convert(::Type{UTF32String}, data::AbstractVector{Char}) =
+    convert(UTF32String, map(UInt32, data))
+
 convert{T<:AbstractString, S<:Union{UInt32,Char,Int32}}(::Type{T}, v::AbstractVector{S}) =
     convert(T, utf32(v))
 
diff --git a/base/unicode/utf8.jl b/base/unicode/utf8.jl
index a269ad9486082..5f278c0e18b4b 100644
--- a/base/unicode/utf8.jl
+++ b/base/unicode/utf8.jl
@@ -79,7 +79,7 @@ function next(s::UTF8String, i::Int)
 end
 
 function first_utf8_byte(ch::Char)
-    c = reinterpret(UInt32, ch)
+    c = UInt32(ch)
     c < 0x80    ? c%UInt8 :
     c < 0x800   ? ((c>>6)  | 0xc0)%UInt8 :
     c < 0x10000 ? ((c>>12) | 0xe0)%UInt8 :
@@ -166,7 +166,7 @@ function string(a::Union{ByteString,Char}...)
     s = Array(UInt8,0)
     for d in a
         if isa(d,Char)
-            c = reinterpret(UInt32, d::Char)
+            c = UInt32(d::Char)
             if c < 0x80
                 push!(s, c%UInt8)
             elseif c < 0x800
diff --git a/base/unicode/utf8proc.jl b/base/unicode/utf8proc.jl
index 55ed682974a5c..d098ce3c993da 100644
--- a/base/unicode/utf8proc.jl
+++ b/base/unicode/utf8proc.jl
@@ -3,7 +3,7 @@
 # Various Unicode functionality from the utf8proc library
 module UTF8proc
 
-import Base: show, showcompact, ==, hash, string, symbol, isless, length, eltype, start, next, done, convert, isvalid, lowercase, uppercase
+import Base: show, ==, hash, string, symbol, isless, length, eltype, start, next, done, convert, isvalid, lowercase, uppercase
 
 export isgraphemebreak
 
@@ -73,7 +73,7 @@ function utf8proc_map(s::ByteString, flags::Integer)
     result = ccall(:utf8proc_map, Cssize_t,
                    (Ptr{UInt8}, Cssize_t, Ref{Ptr{UInt8}}, Cint),
                    s, sizeof(s), p, flags)
-    result < 0 && error(bytestring(ccall(:utf8proc_errmsg, Ptr{UInt8},
+    result < 0 && error(bytestring(ccall(:utf8proc_errmsg, Cstring,
                                          (Cssize_t,), result)))
     pointer_to_string(p[], result, true)::ByteString
 end
@@ -118,11 +118,8 @@ end
 
 charwidth(c::Char) = Int(ccall(:utf8proc_charwidth, Cint, (UInt32,), c))
 
-# faster x+y that does no overflow checking
-fastplus(x::Char, y::UInt32) = reinterpret(Char, reinterpret(UInt32, x) + y)
-
-lowercase(c::Char) = isascii(c) ? ('A' <= c <= 'Z' ? fastplus(c,0x00000020) : c) : ccall(:utf8proc_tolower, Char, (UInt32,), c)
-uppercase(c::Char) = isascii(c) ? ('a' <= c <= 'z' ? fastplus(c,0xffffffe0) : c) : ccall(:utf8proc_toupper, Char, (UInt32,), c)
+lowercase(c::Char) = isascii(c) ? ('A' <= c <= 'Z' ? c + 0x20 : c) : Char(ccall(:utf8proc_tolower, UInt32, (UInt32,), c))
+uppercase(c::Char) = isascii(c) ? ('a' <= c <= 'z' ? c - 0x20 : c) : Char(ccall(:utf8proc_toupper, UInt32, (UInt32,), c))
 
 ############################################################################
 
@@ -219,7 +216,7 @@ function next(g::GraphemeIterator, i)
         k = ℓ
         c0 = c
     end
-    return (s[i:j], k)
+    return (SubString(s, i, j), k)
 end
 
 ==(g1::GraphemeIterator, g2::GraphemeIterator) = g1.s == g2.s
diff --git a/base/util.jl b/base/util.jl
index 173d9044fa27c..42b96ed70333a 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -232,10 +232,14 @@ function blas_vendor()
 end
 
 if blas_vendor() == :openblas64
-    blasfunc(x) = string(x)*"64_"
+    macro blasfunc(x)
+        return Expr(:quote, symbol(x, "64_"))
+    end
     openblas_get_config() = strip(bytestring( ccall((:openblas_get_config64_, Base.libblas_name), Ptr{UInt8}, () )))
 else
-    blasfunc(x) = string(x)
+    macro blasfunc(x)
+        return Expr(:quote, x)
+    end
     openblas_get_config() = strip(bytestring( ccall((:openblas_get_config, Base.libblas_name), Ptr{UInt8}, () )))
 end
 
@@ -329,7 +333,7 @@ println_with_color(color::Symbol, msg::AbstractString...) =
 ## warnings and messages ##
 
 function info(io::IO, msg...; prefix="INFO: ")
-    println_with_color(:blue, io, prefix, chomp(string(msg...)))
+    println_with_color(info_color(), io, prefix, chomp(string(msg...)))
 end
 info(msg...; prefix="INFO: ") = info(STDERR, msg..., prefix=prefix)
 
@@ -351,7 +355,7 @@ function warn(io::IO, msg...;
         (key in have_warned) && return
         push!(have_warned, key)
     end
-    print_with_color(:red, io, prefix, str)
+    print_with_color(warn_color(), io, prefix, str)
     if bt !== nothing
         show_backtrace(io, bt)
     end
@@ -373,7 +377,16 @@ function julia_cmd(julia=joinpath(JULIA_HOME, julia_exename()))
     opts = JLOptions()
     cpu_target = bytestring(opts.cpu_target)
     image_file = bytestring(opts.image_file)
-    `$julia -C$cpu_target -J$image_file`
+    compile = if opts.compile_enabled == 0
+                  "no"
+              elseif opts.compile_enabled == 2
+                  "all"
+              elseif opts.compile_enabled == 3
+                  "min"
+              else
+                  "yes"
+              end
+    `$julia -C$cpu_target -J$image_file --compile=$compile`
 end
 
 julia_exename() = ccall(:jl_is_debugbuild,Cint,())==0 ? "julia" : "julia-debug"
diff --git a/base/version.jl b/base/version.jl
index 9c0fed92d0762..3f63dcdc6bf2f 100644
--- a/base/version.jl
+++ b/base/version.jl
@@ -219,7 +219,7 @@ function banner(io::IO = STDOUT)
     elseif GIT_VERSION_INFO.commit == ""
         commit_string = ""
     else
-        days = Int(floor((ccall(:clock_now, Float64, ()) - GIT_VERSION_INFO.fork_master_timestamp) / (60 * 60 * 24)))
+        days = Int(floor((ccall(:jl_clock_now, Float64, ()) - GIT_VERSION_INFO.fork_master_timestamp) / (60 * 60 * 24)))
         days = max(0, days)
         unit = days == 1 ? "day" : "days"
         distance = GIT_VERSION_INFO.fork_master_distance
diff --git a/base/version_git.sh b/base/version_git.sh
index bcd9820c82648..e8a517219f1f5 100644
--- a/base/version_git.sh
+++ b/base/version_git.sh
@@ -15,8 +15,10 @@ echo "    fork_master_timestamp::Float64"
 echo "end"
 echo ""
 
+cd $1
+
 # If the script didn't ask not to use git info
-if [  "$#" = "1"  -a "$1" = "NO_GIT" ]; then
+if [  "$#" = "2"  -a "$2" = "NO_GIT" ]; then
     # this comment is used in base/Makefile to distinguish boilerplate
     echo "# Default output if git is not available."
     echo "const GIT_VERSION_INFO = GitVersionInfo(\"\" ,\"\" ,\"\" ,0 ,\"\" ,true ,0 ,0.)"
diff --git a/contrib/BBEditTextWrangler-julia.plist b/contrib/BBEditTextWrangler-julia.plist
index 2581462dda7e7..e4761c8b1dcf3 100644
--- a/contrib/BBEditTextWrangler-julia.plist
+++ b/contrib/BBEditTextWrangler-julia.plist
@@ -5,10 +5,11 @@
 <plist version="1.0">
 
 <!--
-      Julia codeless language module for BBEdit and TextWrangler text editors
-
-      version of 2014-09-10 20:17:45
+    Julia codeless language module for the text editors:
+        BBEdit and TextWrangler
+    from BareBones Software, http://www.barebones.com
 
+    version of 2016 Feb 23 17:12, incorporating Julia 0.4 vocabulary
 -->
 
 <dict>
@@ -36,1255 +37,1527 @@
     <true/>
 
     <key>BBLMKeywordList</key>
-      <array>
-      <!-- these reserved words from julia-parser.scm added by hand -->
+        <array>
+            <string>@__FILE__</string>
+            <string>@allocated</string>
+            <string>@assert</string>
+            <string>@async</string>
+            <string>@b_str</string>
+            <string>@big_str</string>
+            <string>@bigint_str</string>
+            <string>@boundscheck</string>
+            <string>@cmd</string>
+            <string>@code_llvm</string>
+            <string>@code_lowered</string>
+            <string>@code_native</string>
+            <string>@code_typed</string>
+            <string>@code_warntype</string>
+            <string>@compat</string>
+            <string>@deprecate</string>
+            <string>@doc</string>
+            <string>@doc_str</string>
+            <string>@edit</string>
+            <string>@elapsed</string>
+            <string>@enum</string>
+            <string>@eval</string>
+            <string>@evalpoly</string>
+            <string>@everywhere</string>
+            <string>@fastmath</string>
+            <string>@fetch</string>
+            <string>@fetchfrom</string>
+            <string>@generated</string>
+            <string>@gensym</string>
+            <string>@goto</string>
+            <string>@html_str</string>
+            <string>@inbounds</string>
+            <string>@inline</string>
+            <string>@int128_str</string>
+            <string>@ip_str</string>
+            <string>@label</string>
+            <string>@less</string>
+            <string>@linux</string>
+            <string>@linux_only</string>
+            <string>@math_const</string>
+            <string>@MIME</string>
+            <string>@MIME_str</string>
+            <string>@noinline</string>
+            <string>@non_windowsxp_only</string>
+            <string>@osx</string>
+            <string>@osx_only</string>
+            <string>@parallel</string>
+            <string>@printf</string>
+            <string>@profile</string>
+            <string>@r_str</string>
+            <string>@s_str</string>
+            <string>@schedule</string>
+            <string>@show</string>
+            <string>@simd</string>
+            <string>@spawn</string>
+            <string>@spawnat</string>
+            <string>@sprintf</string>
+            <string>@sync</string>
+            <string>@task</string>
+            <string>@text_str</string>
+            <string>@thunk</string>
+            <string>@time</string>
+            <string>@timed</string>
+            <string>@timev</string>
+            <string>@uint128_str</string>
+            <string>@unexpected</string>
+            <string>@unix</string>
+            <string>@unix_only</string>
+            <string>@v_str</string>
+            <string>@vectorize_1arg</string>
+            <string>@vectorize_2arg</string>
+            <string>@which</string>
+            <string>@windows</string>
+            <string>@windows_only</string>
+            <string>@windowsxp_only</string>
+            <string>\</string>
+            <string>^</string>
+            <string>__precompile__</string>
+            <string>A_ldiv_B!</string>
+            <string>A_ldiv_Bc</string>
+            <string>A_ldiv_Bt</string>
+            <string>A_mul_B!</string>
+            <string>A_mul_Bc!</string>
+            <string>A_mul_Bc</string>
+            <string>A_mul_Bt!</string>
+            <string>A_mul_Bt</string>
+            <string>A_rdiv_Bc</string>
+            <string>A_rdiv_Bt</string>
+            <string>abs2</string>
+            <string>abs</string>
+            <string>abspath</string>
             <string>abstract</string>
+            <string>Ac_ldiv_B</string>
+            <string>Ac_ldiv_Bc</string>
+            <string>Ac_mul_B!</string>
+            <string>Ac_mul_B</string>
+            <string>Ac_mul_Bc!</string>
+            <string>Ac_mul_Bc</string>
+            <string>Ac_rdiv_B</string>
+            <string>Ac_rdiv_Bc</string>
+            <string>accept</string>
+            <string>acos</string>
+            <string>acosd</string>
+            <string>acosh</string>
+            <string>acot</string>
+            <string>acotd</string>
+            <string>acoth</string>
+            <string>acsc</string>
+            <string>acscd</string>
+            <string>acsch</string>
+            <string>addprocs</string>
+            <string>airy</string>
+            <string>airyai</string>
+            <string>airyaiprime</string>
+            <string>airybi</string>
+            <string>airybiprime</string>
+            <string>airyprime</string>
+            <string>airyx</string>
+            <string>all!</string>
+            <string>all</string>
+            <string>angle</string>
+            <string>any!</string>
+            <string>any</string>
+            <string>append!</string>
+            <string>apply</string>
+            <string>apropos</string>
+            <string>ascii</string>
+            <string>asec</string>
+            <string>asecd</string>
+            <string>asech</string>
+            <string>asin</string>
+            <string>asind</string>
+            <string>asinh</string>
+            <string>assert</string>
+            <string>At_ldiv_B</string>
+            <string>At_ldiv_Bt</string>
+            <string>At_mul_B!</string>
+            <string>At_mul_B</string>
+            <string>At_mul_Bt!</string>
+            <string>At_mul_Bt</string>
+            <string>At_rdiv_B</string>
+            <string>At_rdiv_Bt</string>
+            <string>atan2</string>
+            <string>atan</string>
+            <string>atand</string>
+            <string>atanh</string>
+            <string>atexit</string>
+            <string>atreplinit</string>
+            <string>backtrace</string>
             <string>baremodule</string>
+            <string>base64</string>
+            <string>base64decode</string>
+            <string>base64encode</string>
+            <string>base</string>
+            <string>basename</string>
             <string>begin</string>
+            <string>beginswith</string>
+            <string>besselh</string>
+            <string>besselhx</string>
+            <string>besseli</string>
+            <string>besselix</string>
+            <string>besselj0</string>
+            <string>besselj1</string>
+            <string>besselj</string>
+            <string>besseljx</string>
+            <string>besselk</string>
+            <string>besselkx</string>
+            <string>bessely0</string>
+            <string>bessely1</string>
+            <string>bessely</string>
+            <string>besselyx</string>
+            <string>beta</string>
+            <string>bfft!</string>
+            <string>bfft</string>
+            <string>big</string>
+            <string>bin</string>
+            <string>bind</string>
+            <string>binomial</string>
+            <string>bitbroadcast</string>
+            <string>bitmix</string>
+            <string>bitpack</string>
+            <string>bitrand</string>
+            <string>bits</string>
             <string>bitstype</string>
+            <string>bitunpack</string>
+            <string>bkfact!</string>
+            <string>bkfact</string>
+            <string>blas_set_num_threads</string>
+            <string>blkdiag</string>
+            <string>bool</string>
             <string>break</string>
+            <string>brfft</string>
+            <string>broadcast!</string>
+            <string>broadcast!_function</string>
+            <string>broadcast</string>
+            <string>broadcast_function</string>
+            <string>broadcast_getindex</string>
+            <string>broadcast_setindex!</string>
+            <string>bswap</string>
+            <string>bytes2hex</string>
+            <string>bytestring</string>
+            <string>c_calloc</string>
+            <string>c_free</string>
+            <string>c_malloc</string>
+            <string>c_realloc</string>
+            <string>call</string>
+            <string>cartesianmap</string>
+            <string>cat</string>
+            <string>catalan</string>
+            <string>catch</string>
+            <string>catch_backtrace</string>
+            <string>cbrt</string>
             <string>ccall</string>
+            <string>cd</string>
+            <string>ceil</string>
+            <string>cell</string>
+            <string>cfunction</string>
+            <string>cglobal</string>
+            <string>char</string>
+            <string>charwidth</string>
+            <string>checkbounds</string>
+            <string>chmod</string>
+            <string>chol</string>
+            <string>cholfact!</string>
+            <string>cholfact</string>
+            <string>chomp</string>
+            <string>chop</string>
+            <string>chr2ind</string>
+            <string>circshift</string>
+            <string>cis</string>
+            <string>clamp!</string>
+            <string>clamp</string>
+            <string>cld</string>
+            <string>clear_malloc_data</string>
+            <string>clipboard</string>
+            <string>close</string>
+            <string>cmp</string>
+            <string>code_llvm</string>
+            <string>code_lowered</string>
+            <string>code_native</string>
+            <string>code_typed</string>
+            <string>code_warntype</string>
+            <string>collect</string>
+            <string>colon</string>
+            <string>combinations</string>
+            <string>complement!</string>
+            <string>complement</string>
+            <string>complex128</string>
+            <string>complex32</string>
+            <string>complex64</string>
+            <string>complex</string>
+            <string>cond</string>
+            <string>condskeel</string>
+            <string>conj!</string>
+            <string>conj</string>
+            <string>connect</string>
             <string>const</string>
+            <string>consume</string>
+            <string>contains</string>
             <string>continue</string>
+            <string>conv2</string>
+            <string>conv</string>
+            <string>convert</string>
+            <string>copy!</string>
+            <string>copy</string>
+            <string>copysign</string>
+            <string>cor</string>
+            <string>cos</string>
+            <string>cosc</string>
+            <string>cosd</string>
+            <string>cosh</string>
+            <string>cospi</string>
+            <string>cot</string>
+            <string>cotd</string>
+            <string>coth</string>
+            <string>count</string>
+            <string>count_ones</string>
+            <string>count_zeros</string>
+            <string>countfrom</string>
+            <string>countlines</string>
+            <string>countnz</string>
+            <string>cov</string>
+            <string>cp</string>
+            <string>cross</string>
+            <string>csc</string>
+            <string>cscd</string>
+            <string>csch</string>
+            <string>ctime</string>
+            <string>ctranspose!</string>
+            <string>ctranspose</string>
+            <string>cummax</string>
+            <string>cummin</string>
+            <string>cumprod!</string>
+            <string>cumprod</string>
+            <string>cumsum!</string>
+            <string>cumsum</string>
+            <string>cumsum_kbn</string>
+            <string>current_module</string>
+            <string>current_task</string>
+            <string>cycle</string>
+            <string>dawson</string>
+            <string>dct!</string>
+            <string>dct</string>
+            <string>dec</string>
+            <string>deconv</string>
+            <string>deepcopy</string>
+            <string>deg2rad</string>
+            <string>degrees2radians</string>
+            <string>delete!</string>
+            <string>deleteat!</string>
+            <string>den</string>
+            <string>dense</string>
+            <string>deserialize</string>
+            <string>det</string>
+            <string>detach</string>
+            <string>dfill</string>
+            <string>diag</string>
+            <string>diagind</string>
+            <string>diagm</string>
+            <string>diff</string>
+            <string>digamma</string>
+            <string>digits!</string>
+            <string>digits</string>
+            <string>dirname</string>
+            <string>disable_sigint</string>
+            <string>display</string>
+            <string>displayable</string>
+            <string>distribute</string>
+            <string>div</string>
+            <string>divrem</string>
+            <string>dlclose</string>
+            <string>dlopen</string>
+            <string>dlopen_e</string>
+            <string>dlsym</string>
+            <string>dlsym_e</string>
             <string>do</string>
+            <string>done</string>
+            <string>dones</string>
+            <string>dot</string>
+            <string>download</string>
+            <string>drand</string>
+            <string>drandn</string>
+            <string>drop</string>
+            <string>dump</string>
+            <string>dzeros</string>
+            <string>e</string>
+            <string>eachindex</string>
+            <string>eachline</string>
+            <string>eachmatch</string>
+            <string>edit</string>
+            <string>eig</string>
+            <string>eigfact!</string>
+            <string>eigfact</string>
+            <string>eigmax</string>
+            <string>eigmin</string>
+            <string>eigs</string>
+            <string>eigvals!</string>
+            <string>eigvals</string>
+            <string>eigvecs</string>
             <string>else</string>
             <string>elseif</string>
+            <string>eltype</string>
+            <string>empty!</string>
             <string>end</string>
+            <string>endof</string>
+            <string>endswith</string>
+            <string>enumerate</string>
+            <string>eof</string>
+            <string>eps</string>
+            <string>erf</string>
+            <string>erfc</string>
+            <string>erfcinv</string>
+            <string>erfcx</string>
+            <string>erfi</string>
+            <string>erfinv</string>
+            <string>errno</string>
+            <string>error</string>
+            <string>esc</string>
+            <string>escape_string</string>
+            <string>eta</string>
+            <string>etree</string>
+            <string>eu</string>
+            <string>eulergamma</string>
+            <string>evalfile</string>
+            <string>exit</string>
+            <string>exp10</string>
+            <string>exp2</string>
+            <string>exp</string>
+            <string>expand</string>
+            <string>expanduser</string>
+            <string>expm1</string>
+            <string>expm</string>
+            <string>exponent</string>
             <string>export</string>
+            <string>extrema</string>
+            <string>eye</string>
+            <string>factor</string>
+            <string>factorial</string>
+            <string>factorize</string>
+            <string>falses</string>
+            <string>fd</string>
+            <string>fdio</string>
+            <string>fetch</string>
+            <string>fft!</string>
+            <string>fft</string>
+            <string>fftshift</string>
+            <string>fieldnames</string>
+            <string>filemode</string>
+            <string>filesize</string>
+            <string>fill!</string>
+            <string>fill</string>
+            <string>filt!</string>
+            <string>filt</string>
+            <string>filter!</string>
+            <string>filter</string>
+            <string>finalize</string>
+            <string>finalizer</string>
+            <string>finally</string>
+            <string>find</string>
+            <string>find_library</string>
+            <string>findfirst</string>
+            <string>findin</string>
+            <string>findlast</string>
+            <string>findmax</string>
+            <string>findmin</string>
+            <string>findn</string>
+            <string>findnext</string>
+            <string>findnz</string>
+            <string>findprev</string>
+            <string>first</string>
+            <string>fld</string>
+            <string>fldmod</string>
+            <string>flipbits!</string>
+            <string>flipdim</string>
+            <string>fliplr</string>
+            <string>flipsign</string>
+            <string>flipud</string>
+            <string>float16</string>
+            <string>float32</string>
+            <string>float32_isvalid</string>
+            <string>float64</string>
+            <string>float64_isvalid</string>
+            <string>float</string>
+            <string>floor</string>
+            <string>flush</string>
+            <string>flush_cstdio</string>
+            <string>fma</string>
+            <string>foldl</string>
+            <string>foldr</string>
             <string>for</string>
+            <string>frexp</string>
+            <string>full</string>
+            <string>fullname</string>
             <string>function</string>
+            <string>functionloc</string>
+            <string>functionlocs</string>
+            <string>gamma</string>
+            <string>gc</string>
+            <string>gc_disable</string>
+            <string>gc_enable</string>
+            <string>gcd</string>
+            <string>gcdx</string>
+            <string>gensym</string>
+            <string>get!</string>
+            <string>get</string>
+            <string>get_zero_subnormals</string>
+            <string>getaddrinfo</string>
+            <string>gethostname</string>
+            <string>getindex</string>
+            <string>getipaddr</string>
+            <string>getkey</string>
+            <string>getpid</string>
+            <string>givens</string>
             <string>global</string>
+            <string>golden</string>
+            <string>gperm</string>
+            <string>gradient</string>
+            <string>graphemes</string>
+            <string>hankelh1</string>
+            <string>hankelh1x</string>
+            <string>hankelh2</string>
+            <string>hankelh2x</string>
+            <string>hash</string>
+            <string>haskey</string>
+            <string>hcat</string>
+            <string>help</string>
+            <string>hessfact!</string>
+            <string>hessfact</string>
+            <string>hex2bytes</string>
+            <string>hex2num</string>
+            <string>hex</string>
+            <string>hist!</string>
+            <string>hist2d!</string>
+            <string>hist2d</string>
+            <string>hist</string>
+            <string>histrange</string>
+            <string>homedir</string>
+            <string>htol</string>
+            <string>hton</string>
+            <string>hvcat</string>
+            <string>hypot</string>
+            <string>iceil</string>
+            <string>idct!</string>
+            <string>idct</string>
+            <string>identity</string>
             <string>if</string>
+            <string>ifelse</string>
+            <string>ifft!</string>
+            <string>ifft</string>
+            <string>ifftshift</string>
+            <string>ifloor</string>
+            <string>ignorestatus</string>
+            <string>im</string>
+            <string>imag</string>
             <string>immutable</string>
             <string>import</string>
             <string>importall</string>
+            <string>in</string>
+            <string>include</string>
+            <string>include_dependency</string>
+            <string>include_string</string>
+            <string>ind2chr</string>
+            <string>ind2sub!</string>
+            <string>ind2sub</string>
+            <string>indexin</string>
+            <string>indexpids</string>
+            <string>indmax</string>
+            <string>indmin</string>
+            <string>inf</string>
+            <string>info</string>
+            <string>infs</string>
+            <string>init_worker</string>
+            <string>insert!</string>
+            <string>instances</string>
+            <string>int128</string>
+            <string>int16</string>
+            <string>int32</string>
+            <string>int64</string>
+            <string>int8</string>
+            <string>int</string>
+            <string>integer</string>
+            <string>interrupt</string>
+            <string>intersect!</string>
+            <string>intersect</string>
+            <string>inv</string>
+            <string>invdigamma</string>
+            <string>invmod</string>
+            <string>invperm</string>
+            <string>ipermute!</string>
+            <string>ipermutedims</string>
+            <string>irfft</string>
+            <string>iround</string>
+            <string>is_assigned_char</string>
+            <string>is_valid_ascii</string>
+            <string>is_valid_char</string>
+            <string>is_valid_utf16</string>
+            <string>is_valid_utf32</string>
+            <string>is_valid_utf8</string>
+            <string>isabspath</string>
+            <string>isalnum</string>
+            <string>isalpha</string>
+            <string>isapprox</string>
+            <string>isascii</string>
+            <string>isassigned</string>
+            <string>isbits</string>
+            <string>isblank</string>
+            <string>isblockdev</string>
+            <string>ischardev</string>
+            <string>iscntrl</string>
+            <string>isconst</string>
+            <string>isdiag</string>
+            <string>isdigit</string>
+            <string>isdir</string>
+            <string>isdirpath</string>
+            <string>iseltype</string>
+            <string>isempty</string>
+            <string>isequal</string>
+            <string>iseven</string>
+            <string>isexecutable</string>
+            <string>isfifo</string>
+            <string>isfile</string>
+            <string>isfinite</string>
+            <string>isgeneric</string>
+            <string>isgraph</string>
+            <string>ishermitian</string>
+            <string>isimmutable</string>
+            <string>isinf</string>
+            <string>isinteger</string>
+            <string>isinteractive</string>
+            <string>isleaftype</string>
+            <string>isless</string>
+            <string>islink</string>
+            <string>islower</string>
+            <string>ismarked</string>
+            <string>ismatch</string>
+            <string>ismount</string>
+            <string>isnan</string>
+            <string>isnull</string>
+            <string>isnumber</string>
+            <string>isodd</string>
+            <string>isopen</string>
+            <string>ispath</string>
+            <string>isperm</string>
+            <string>isposdef!</string>
+            <string>isposdef</string>
+            <string>ispow2</string>
+            <string>isprime</string>
+            <string>isprint</string>
+            <string>ispunct</string>
+            <string>isqrt</string>
+            <string>isreadable</string>
+            <string>isreadonly</string>
+            <string>isready</string>
+            <string>isreal</string>
+            <string>issetgid</string>
+            <string>issetuid</string>
+            <string>issocket</string>
+            <string>issorted</string>
+            <string>isspace</string>
+            <string>issparse</string>
+            <string>issticky</string>
+            <string>issubnormal</string>
+            <string>issubset</string>
+            <string>issym</string>
+            <string>istaskdone</string>
+            <string>istaskstarted</string>
+            <string>istext</string>
+            <string>istril</string>
+            <string>istriu</string>
+            <string>isupper</string>
+            <string>isvalid</string>
+            <string>iswritable</string>
+            <string>isxdigit</string>
+            <string>itrunc</string>
+            <string>join</string>
+            <string>joinpath</string>
+            <string>keys</string>
+            <string>kill</string>
+            <string>kron</string>
+            <string>last</string>
+            <string>launch</string>
+            <string>lbeta</string>
+            <string>lcfirst</string>
+            <string>lcm</string>
+            <string>ldexp</string>
+            <string>ldltfact!</string>
+            <string>ldltfact</string>
+            <string>leading_ones</string>
+            <string>leading_zeros</string>
+            <string>length</string>
+            <string>less</string>
             <string>let</string>
+            <string>levicivita</string>
+            <string>lexcmp</string>
+            <string>lexless</string>
+            <string>lfact</string>
+            <string>lgamma</string>
+            <string>linrange</string>
+            <string>linreg</string>
+            <string>linspace</string>
+            <string>listen</string>
+            <string>listenany</string>
             <string>local</string>
+            <string>localindexes</string>
+            <string>localpart</string>
+            <string>lock</string>
+            <string>log10</string>
+            <string>log1p</string>
+            <string>log2</string>
+            <string>log</string>
+            <string>logabsdet</string>
+            <string>logdet</string>
+            <string>logm</string>
+            <string>logspace</string>
+            <string>lowercase</string>
+            <string>lpad</string>
+            <string>lstat</string>
+            <string>lstrip</string>
+            <string>ltoh</string>
+            <string>lu</string>
+            <string>lufact!</string>
+            <string>lufact</string>
+            <string>lyap</string>
             <string>macro</string>
+            <string>macroexpand</string>
+            <string>manage</string>
+            <string>map!</string>
+            <string>map</string>
+            <string>mapfoldl</string>
+            <string>mapfoldr</string>
+            <string>mapreduce</string>
+            <string>mapreducedim</string>
+            <string>mapslices</string>
+            <string>mark</string>
+            <string>match</string>
+            <string>matchall</string>
+            <string>max</string>
+            <string>maxabs!</string>
+            <string>maxabs</string>
+            <string>maximum!</string>
+            <string>maximum</string>
+            <string>maxintfloat</string>
+            <string>mean!</string>
+            <string>mean</string>
+            <string>median!</string>
+            <string>median</string>
+            <string>merge!</string>
+            <string>merge</string>
+            <string>methods</string>
+            <string>methodswith</string>
+            <string>middle</string>
+            <string>midpoints</string>
+            <string>mimewritable</string>
+            <string>min</string>
+            <string>minabs!</string>
+            <string>minabs</string>
+            <string>minimum!</string>
+            <string>minimum</string>
+            <string>minmax</string>
+            <string>mkdir</string>
+            <string>mkpath</string>
+            <string>mktemp</string>
+            <string>mktempdir</string>
+            <string>mmap</string>
+            <string>mmap_array</string>
+            <string>mmap_bitarray</string>
+            <string>mod1</string>
+            <string>mod2pi</string>
+            <string>mod</string>
+            <string>modf</string>
             <string>module</string>
+            <string>module_name</string>
+            <string>module_parent</string>
+            <string>msync</string>
+            <string>mtime</string>
+            <string>muladd</string>
+            <string>mv</string>
+            <string>myid</string>
+            <string>myindexes</string>
+            <string>names</string>
+            <string>nan</string>
+            <string>nans</string>
+            <string>nb_available</string>
+            <string>ndigits</string>
+            <string>ndims</string>
+            <string>next</string>
+            <string>nextfloat</string>
+            <string>nextind</string>
+            <string>nextpow2</string>
+            <string>nextpow</string>
+            <string>nextprod</string>
+            <string>nfilled</string>
+            <string>nnz</string>
+            <string>nonzeros</string>
+            <string>norm</string>
+            <string>normalize_string</string>
+            <string>normfro</string>
+            <string>normpath</string>
+            <string>notify</string>
+            <string>now</string>
+            <string>nprocs</string>
+            <string>nthperm!</string>
+            <string>nthperm</string>
+            <string>ntoh</string>
+            <string>ntuple</string>
+            <string>null</string>
+            <string>nullspace</string>
+            <string>num2hex</string>
+            <string>num</string>
+            <string>nworkers</string>
+            <string>nzrange</string>
+            <string>object_id</string>
+            <string>oct</string>
+            <string>oftype</string>
+            <string>one</string>
+            <string>ones</string>
+            <string>open</string>
+            <string>operm</string>
+            <string>ordschur!</string>
+            <string>ordschur</string>
+            <string>parent</string>
+            <string>parentindexes</string>
+            <string>parity</string>
+            <string>parse</string>
+            <string>parsefloat</string>
+            <string>parseint</string>
+            <string>partitions</string>
+            <string>peakflops</string>
+            <string>permutations</string>
+            <string>permute!</string>
+            <string>permutedims!</string>
+            <string>permutedims</string>
+            <string>pi</string>
+            <string>pinv</string>
+            <string>pipe</string>
+            <string>pipeline</string>
+            <string>plan_bfft!</string>
+            <string>plan_bfft</string>
+            <string>plan_brfft</string>
+            <string>plan_dct!</string>
+            <string>plan_dct</string>
+            <string>plan_fft!</string>
+            <string>plan_fft</string>
+            <string>plan_idct!</string>
+            <string>plan_idct</string>
+            <string>plan_ifft!</string>
+            <string>plan_ifft</string>
+            <string>plan_irfft</string>
+            <string>plan_rfft</string>
+            <string>pmap</string>
+            <string>pointer</string>
+            <string>pointer_from_objref</string>
+            <string>pointer_to_array</string>
+            <string>pointer_to_string</string>
+            <string>poll_fd</string>
+            <string>poll_file</string>
+            <string>polygamma</string>
+            <string>pop!</string>
+            <string>popdisplay</string>
+            <string>position</string>
+            <string>powermod</string>
+            <string>precision</string>
+            <string>precompile</string>
+            <string>prepend!</string>
+            <string>prevfloat</string>
+            <string>prevind</string>
+            <string>prevpow2</string>
+            <string>prevpow</string>
+            <string>prevprod</string>
+            <string>primes</string>
+            <string>primesmask</string>
+            <string>print</string>
+            <string>print_escaped</string>
+            <string>print_joined</string>
+            <string>print_shortest</string>
+            <string>print_unescaped</string>
+            <string>print_with_color</string>
+            <string>println</string>
+            <string>process_exited</string>
+            <string>process_running</string>
+            <string>procs</string>
+            <string>prod!</string>
+            <string>prod</string>
+            <string>produce</string>
+            <string>promote</string>
+            <string>promote_rule</string>
+            <string>promote_shape</string>
+            <string>promote_type</string>
+            <string>push!</string>
+            <string>pushdisplay</string>
+            <string>put!</string>
+            <string>put</string>
+            <string>pwd</string>
+            <string>qr</string>
+            <string>qrfact!</string>
+            <string>qrfact</string>
+            <string>quadgk</string>
+            <string>quantile!</string>
+            <string>quantile</string>
+            <string>quit</string>
             <string>quote</string>
+            <string>rad2deg</string>
+            <string>radians2degrees</string>
+            <string>rand!</string>
+            <string>rand</string>
+            <string>randbool!</string>
+            <string>randbool</string>
+            <string>randcycle</string>
+            <string>randexp!</string>
+            <string>randexp</string>
+            <string>randjump</string>
+            <string>randn!</string>
+            <string>randn</string>
+            <string>randperm</string>
+            <string>randstring</string>
+            <string>randsubseq!</string>
+            <string>randsubseq</string>
+            <string>range</string>
+            <string>rank</string>
+            <string>rationalize</string>
+            <string>read!</string>
+            <string>read</string>
+            <string>readandwrite</string>
+            <string>readavailable</string>
+            <string>readbytes!</string>
+            <string>readbytes</string>
+            <string>readchomp</string>
+            <string>readcsv</string>
+            <string>readdir</string>
+            <string>readdlm</string>
+            <string>readline</string>
+            <string>readlines</string>
+            <string>readlink</string>
+            <string>readsfrom</string>
+            <string>readstring</string>
+            <string>readuntil</string>
+            <string>real</string>
+            <string>realmax</string>
+            <string>realmin</string>
+            <string>realpath</string>
+            <string>recv</string>
+            <string>recvfrom</string>
+            <string>redirect_stderr</string>
+            <string>redirect_stdin</string>
+            <string>redirect_stdout</string>
+            <string>redisplay</string>
+            <string>reduce</string>
+            <string>reducedim</string>
+            <string>reenable_sigint</string>
+            <string>reim</string>
+            <string>reinterpret</string>
+            <string>reload</string>
+            <string>relpath</string>
+            <string>rem1</string>
+            <string>rem</string>
+            <string>remotecall</string>
+            <string>remotecall_fetch</string>
+            <string>remotecall_wait</string>
+            <string>repeat</string>
+            <string>repeated</string>
+            <string>replace</string>
+            <string>repmat</string>
+            <string>repr</string>
+            <string>reprmime</string>
+            <string>require</string>
+            <string>reset</string>
+            <string>reshape</string>
+            <string>resize!</string>
+            <string>rest</string>
+            <string>rethrow</string>
             <string>return</string>
+            <string>reverse!</string>
+            <string>reverse</string>
+            <string>reverseind</string>
+            <string>rfft</string>
+            <string>rm</string>
+            <string>rmdir</string>
+            <string>rmprocs</string>
+            <string>rol!</string>
+            <string>rol</string>
+            <string>ror!</string>
+            <string>ror</string>
+            <string>rot180</string>
+            <string>rotl90</string>
+            <string>rotr90</string>
+            <string>round</string>
+            <string>rounding</string>
+            <string>rowvals</string>
+            <string>rpad</string>
+            <string>rref</string>
+            <string>rsearch</string>
+            <string>rsearchindex</string>
+            <string>rsplit</string>
+            <string>rstrip</string>
+            <string>run</string>
+            <string>scale!</string>
+            <string>scale</string>
+            <string>schedule</string>
+            <string>schur</string>
+            <string>schurfact!</string>
+            <string>schurfact</string>
+            <string>sdata</string>
+            <string>search</string>
+            <string>searchindex</string>
+            <string>searchsorted</string>
+            <string>searchsortedfirst</string>
+            <string>searchsortedlast</string>
+            <string>sec</string>
+            <string>secd</string>
+            <string>sech</string>
+            <string>seek</string>
+            <string>seekend</string>
+            <string>seekstart</string>
+            <string>select!</string>
+            <string>select</string>
+            <string>selectperm!</string>
+            <string>selectperm</string>
+            <string>send</string>
+            <string>serialize</string>
+            <string>set_zero_subnormals</string>
+            <string>setdiff!</string>
+            <string>setdiff</string>
+            <string>setenv</string>
+            <string>setfield</string>
+            <string>setindex!</string>
+            <string>setprecision</string>
+            <string>setrounding</string>
+            <string>shift!</string>
+            <string>show</string>
+            <string>showall</string>
+            <string>showcompact</string>
+            <string>showerror</string>
+            <string>shuffle!</string>
+            <string>shuffle</string>
+            <string>sign</string>
+            <string>signbit</string>
+            <string>signed</string>
+            <string>signif</string>
+            <string>significand</string>
+            <string>similar</string>
+            <string>sin</string>
+            <string>sinc</string>
+            <string>sind</string>
+            <string>sinh</string>
+            <string>sinpi</string>
+            <string>size</string>
+            <string>sizehint!</string>
+            <string>sizehint</string>
+            <string>sizeof</string>
+            <string>skip</string>
+            <string>skipchars</string>
+            <string>sleep</string>
+            <string>slice</string>
+            <string>slicedim</string>
+            <string>sort!</string>
+            <string>sort</string>
+            <string>sortcols</string>
+            <string>sortperm!</string>
+            <string>sortperm</string>
+            <string>sortrows</string>
+            <string>sparse</string>
+            <string>sparsevec</string>
+            <string>spawn</string>
+            <string>spdiagm</string>
+            <string>speye</string>
+            <string>splice!</string>
+            <string>split</string>
+            <string>splitdir</string>
+            <string>splitdrive</string>
+            <string>splitext</string>
+            <string>spones</string>
+            <string>sprand</string>
+            <string>sprandbool</string>
+            <string>sprandn</string>
+            <string>sprint</string>
+            <string>spzeros</string>
+            <string>sqrt</string>
+            <string>sqrtm</string>
+            <string>squeeze</string>
+            <string>srand</string>
+            <string>start</string>
+            <string>start_reading</string>
+            <string>start_timer</string>
+            <string>start_watching</string>
+            <string>startswith</string>
+            <string>stat</string>
+            <string>std</string>
+            <string>stdm</string>
+            <string>step</string>
+            <string>stop_reading</string>
+            <string>stop_timer</string>
+            <string>strerror</string>
+            <string>strftime</string>
+            <string>stride</string>
+            <string>strides</string>
+            <string>string</string>
+            <string>stringmime</string>
+            <string>strip</string>
+            <string>strptime</string>
+            <string>strwidth</string>
+            <string>sub2ind</string>
+            <string>sub</string>
+            <string>subtypes</string>
+            <string>success</string>
+            <string>sum!</string>
+            <string>sum</string>
+            <string>sum_kbn</string>
+            <string>sumabs!</string>
+            <string>sumabs2!</string>
+            <string>sumabs2</string>
+            <string>sumabs</string>
+            <string>summary</string>
+            <string>super</string>
+            <string>svd</string>
+            <string>svdfact!</string>
+            <string>svdfact</string>
+            <string>svds</string>
+            <string>svdvals!</string>
+            <string>svdvals</string>
+            <string>sylvester</string>
+            <string>symbol</string>
+            <string>symdiff!</string>
+            <string>symdiff</string>
+            <string>symlink</string>
+            <string>symperm</string>
+            <string>systemerror</string>
+            <string>take!</string>
+            <string>take</string>
+            <string>takebuf_array</string>
+            <string>takebuf_string</string>
+            <string>tan</string>
+            <string>tand</string>
+            <string>tanh</string>
+            <string>task_local_storage</string>
+            <string>tempdir</string>
+            <string>tempname</string>
+            <string>tic</string>
+            <string>time</string>
+            <string>time_ns</string>
+            <string>timedwait</string>
+            <string>toc</string>
+            <string>toq</string>
+            <string>touch</string>
+            <string>trace</string>
+            <string>trailing_ones</string>
+            <string>trailing_zeros</string>
+            <string>transpose!</string>
+            <string>transpose</string>
+            <string>trigamma</string>
+            <string>tril!</string>
+            <string>tril</string>
+            <string>triu!</string>
+            <string>triu</string>
+            <string>trues</string>
+            <string>trunc</string>
+            <string>truncate</string>
             <string>try</string>
+            <string>tryparse</string>
             <string>type</string>
             <string>typealias</string>
+            <string>typeintersect</string>
+            <string>typejoin</string>
+            <string>typemax</string>
+            <string>typemin</string>
+            <string>typeof</string>
+            <string>ucfirst</string>
+            <string>uint128</string>
+            <string>uint16</string>
+            <string>uint32</string>
+            <string>uint64</string>
+            <string>uint8</string>
+            <string>uint</string>
+            <string>unescape_string</string>
+            <string>union!</string>
+            <string>union</string>
+            <string>unique</string>
+            <string>unlock</string>
+            <string>unmark</string>
+            <string>unsafe_copy!</string>
+            <string>unsafe_load</string>
+            <string>unsafe_pointer_to_objref</string>
+            <string>unsafe_store!</string>
+            <string>unsafe_trunc</string>
+            <string>unshift!</string>
+            <string>unsigned</string>
+            <string>uperm</string>
+            <string>uppercase</string>
             <string>using</string>
+            <string>utf16</string>
+            <string>utf32</string>
+            <string>utf8</string>
+            <string>values</string>
+            <string>var</string>
+            <string>varm</string>
+            <string>vcat</string>
+            <string>vec</string>
+            <string>vecdot</string>
+            <string>vecnorm</string>
+            <string>versioninfo</string>
+            <string>wait</string>
+            <string>warn</string>
+            <string>watch_file</string>
+            <string>which</string>
             <string>while</string>
-
-      <!-- dunno where this one is defined, added by hand -->
-
-            <string>typeof</string>
-
-      <!-- these generated from names(Base) -->
-              <string>@MIME</string>
-              <string>@MIME_str</string>
-              <string>@__FILE__</string>
-              <string>@allocated</string>
-              <string>@assert</string>
-              <string>@async</string>
-              <string>@b_str</string>
-              <string>@bigint_str</string>
-              <string>@boundscheck</string>
-              <string>@cmd</string>
-              <string>@code_llvm</string>
-              <string>@code_lowered</string>
-              <string>@code_native</string>
-              <string>@code_typed</string>
-              <string>@deprecate</string>
-              <string>@edit</string>
-              <string>@elapsed</string>
-              <string>@eval</string>
-              <string>@evalpoly</string>
-              <string>@everywhere</string>
-              <string>@fetch</string>
-              <string>@fetchfrom</string>
-              <string>@gensym</string>
-              <string>@goto</string>
-              <string>@inbounds</string>
-              <string>@int128_str</string>
-              <string>@ip_str</string>
-              <string>@label</string>
-              <string>@less</string>
-              <string>@linux</string>
-              <string>@linux_only</string>
-              <string>@non_windowsxp_only</string>
-              <string>@osx</string>
-              <string>@osx_only</string>
-              <string>@parallel</string>
-              <string>@printf</string>
-              <string>@profile</string>
-              <string>@r_str</string>
-              <string>@schedule</string>
-              <string>@show</string>
-              <string>@simd</string>
-              <string>@spawn</string>
-              <string>@spawnat</string>
-              <string>@sprintf</string>
-              <string>@sync</string>
-              <string>@task</string>
-              <string>@thunk</string>
-              <string>@time</string>
-              <string>@timed</string>
-              <string>@uint128_str</string>
-              <string>@unexpected</string>
-              <string>@unix</string>
-              <string>@unix_only</string>
-              <string>@v_str</string>
-              <string>@vectorize_1arg</string>
-              <string>@vectorize_2arg</string>
-              <string>@which</string>
-              <string>@windows</string>
-              <string>@windows_only</string>
-              <string>@windowsxp_only</string>
-              <string>A_ldiv_B!</string>
-              <string>A_ldiv_Bc</string>
-              <string>A_ldiv_Bt</string>
-              <string>A_mul_B!</string>
-              <string>A_mul_Bc</string>
-              <string>A_mul_Bc!</string>
-              <string>A_mul_Bt</string>
-              <string>A_mul_Bt!</string>
-              <string>A_rdiv_Bc</string>
-              <string>A_rdiv_Bt</string>
-              <string>Ac_ldiv_B</string>
-              <string>Ac_ldiv_Bc</string>
-              <string>Ac_mul_B</string>
-              <string>Ac_mul_B!</string>
-              <string>Ac_mul_Bc</string>
-              <string>Ac_mul_Bc!</string>
-              <string>Ac_rdiv_B</string>
-              <string>Ac_rdiv_Bc</string>
-              <string>At_ldiv_B</string>
-              <string>At_ldiv_Bt</string>
-              <string>At_mul_B</string>
-              <string>At_mul_B!</string>
-              <string>At_mul_Bt</string>
-              <string>At_mul_Bt!</string>
-              <string>At_rdiv_B</string>
-              <string>At_rdiv_Bt</string>
-              <string>PipeBuffer</string>
-              <string>abs</string>
-              <string>abs2</string>
-              <string>abspath</string>
-              <string>accept</string>
-              <string>acos</string>
-              <string>acosd</string>
-              <string>acosh</string>
-              <string>acot</string>
-              <string>acotd</string>
-              <string>acoth</string>
-              <string>acsc</string>
-              <string>acscd</string>
-              <string>acsch</string>
-              <string>addprocs</string>
-              <string>airy</string>
-              <string>airyai</string>
-              <string>airyaiprime</string>
-              <string>airybi</string>
-              <string>airybiprime</string>
-              <string>airyprime</string>
-              <string>airyx</string>
-              <string>all</string>
-              <string>all!</string>
-              <string>angle</string>
-              <string>any</string>
-              <string>any!</string>
-              <string>append!</string>
-              <string>ascii</string>
-              <string>asec</string>
-              <string>asecd</string>
-              <string>asech</string>
-              <string>asin</string>
-              <string>asind</string>
-              <string>asinh</string>
-              <string>assert</string>
-              <string>atan</string>
-              <string>atan2</string>
-              <string>atand</string>
-              <string>atanh</string>
-              <string>atexit</string>
-              <string>backtrace</string>
-              <string>base</string>
-              <string>base64</string>
-              <string>basename</string>
-              <string>beginswith</string>
-              <string>besselh</string>
-              <string>besseli</string>
-              <string>besselix</string>
-              <string>besselj</string>
-              <string>besselj0</string>
-              <string>besselj1</string>
-              <string>besseljx</string>
-              <string>besselk</string>
-              <string>besselkx</string>
-              <string>bessely</string>
-              <string>bessely0</string>
-              <string>bessely1</string>
-              <string>besselyx</string>
-              <string>beta</string>
-              <string>bfft</string>
-              <string>bfft!</string>
-              <string>big</string>
-              <string>bin</string>
-              <string>bind</string>
-              <string>binomial</string>
-              <string>bitbroadcast</string>
-              <string>bitmix</string>
-              <string>bitpack</string>
-              <string>bits</string>
-              <string>bitunpack</string>
-              <string>bkfact</string>
-              <string>bkfact!</string>
-              <string>blas_set_num_threads</string>
-              <string>blkdiag</string>
-              <string>bool</string>
-              <string>brfft</string>
-              <string>broadcast</string>
-              <string>broadcast!</string>
-              <string>broadcast!_function</string>
-              <string>broadcast_function</string>
-              <string>broadcast_getindex</string>
-              <string>broadcast_setindex!</string>
-              <string>bswap</string>
-              <string>bytes2hex</string>
-              <string>bytestring</string>
-              <string>c_calloc</string>
-              <string>c_free</string>
-              <string>c_malloc</string>
-              <string>c_realloc</string>
-              <string>cartesianmap</string>
-              <string>cat</string>
-              <string>catch_backtrace</string>
-              <string>cbrt</string>
-              <string>cd</string>
-              <string>ceil</string>
-              <string>cell</string>
-              <string>cfunction</string>
-              <string>char</string>
-              <string>charwidth</string>
-              <string>checkbounds</string>
-              <string>chol</string>
-              <string>cholfact</string>
-              <string>cholfact!</string>
-              <string>chomp</string>
-              <string>chop</string>
-              <string>chr2ind</string>
-              <string>circshift</string>
-              <string>cis</string>
-              <string>clamp</string>
-              <string>clear_malloc_data</string>
-              <string>clipboard</string>
-              <string>close</string>
-              <string>cmp</string>
-              <string>code_llvm</string>
-              <string>code_lowered</string>
-              <string>code_native</string>
-              <string>code_typed</string>
-              <string>collect</string>
-              <string>colon</string>
-              <string>combinations</string>
-              <string>complement</string>
-              <string>complement!</string>
-              <string>complex</string>
-              <string>complex128</string>
-              <string>complex32</string>
-              <string>complex64</string>
-              <string>cond</string>
-              <string>condskeel</string>
-              <string>conj</string>
-              <string>conj!</string>
-              <string>connect</string>
-              <string>consume</string>
-              <string>contains</string>
-              <string>conv</string>
-              <string>conv2</string>
-              <string>convert</string>
-              <string>copy</string>
-              <string>copy!</string>
-              <string>copysign</string>
-              <string>cor</string>
-              <string>cos</string>
-              <string>cosc</string>
-              <string>cosd</string>
-              <string>cosh</string>
-              <string>cospi</string>
-              <string>cot</string>
-              <string>cotd</string>
-              <string>coth</string>
-              <string>count</string>
-              <string>count_ones</string>
-              <string>count_zeros</string>
-              <string>countlines</string>
-              <string>countnz</string>
-              <string>cov</string>
-              <string>cp</string>
-              <string>cross</string>
-              <string>csc</string>
-              <string>cscd</string>
-              <string>csch</string>
-              <string>ctime</string>
-              <string>ctranspose</string>
-              <string>cummax</string>
-              <string>cummin</string>
-              <string>cumprod</string>
-              <string>cumprod!</string>
-              <string>cumsum</string>
-              <string>cumsum!</string>
-              <string>cumsum_kbn</string>
-              <string>current_module</string>
-              <string>current_task</string>
-              <string>dawson</string>
-              <string>dct</string>
-              <string>dct!</string>
-              <string>dec</string>
-              <string>deconv</string>
-              <string>deepcopy</string>
-              <string>deg2rad</string>
-              <string>degrees2radians</string>
-              <string>delete!</string>
-              <string>deleteat!</string>
-              <string>den</string>
-              <string>dense</string>
-              <string>deserialize</string>
-              <string>det</string>
-              <string>detach</string>
-              <string>dfill</string>
-              <string>diag</string>
-              <string>diagind</string>
-              <string>diagm</string>
-              <string>diff</string>
-              <string>digamma</string>
-              <string>digits</string>
-              <string>dirname</string>
-              <string>disable_sigint</string>
-              <string>display</string>
-              <string>displayable</string>
-              <string>distribute</string>
-              <string>div</string>
-              <string>divrem</string>
-              <string>dlclose</string>
-              <string>dlopen</string>
-              <string>dlopen_e</string>
-              <string>dlsym</string>
-              <string>dlsym_e</string>
-              <string>done</string>
-              <string>dones</string>
-              <string>dot</string>
-              <string>download</string>
-              <string>drand</string>
-              <string>drandn</string>
-              <string>dump</string>
-              <string>dzeros</string>
-              <string>eachline</string>
-              <string>eachmatch</string>
-              <string>edit</string>
-              <string>eig</string>
-              <string>eigfact</string>
-              <string>eigfact!</string>
-              <string>eigmax</string>
-              <string>eigmin</string>
-              <string>eigs</string>
-              <string>eigvals</string>
-              <string>eigvecs</string>
-              <string>eltype</string>
-              <string>empty!</string>
-              <string>endof</string>
-              <string>endswith</string>
-              <string>enumerate</string>
-              <string>eof</string>
-              <string>eps</string>
-              <string>erf</string>
-              <string>erfc</string>
-              <string>erfcinv</string>
-              <string>erfcx</string>
-              <string>erfi</string>
-              <string>erfinv</string>
-              <string>errno</string>
-              <string>error</string>
-              <string>esc</string>
-              <string>escape_string</string>
-              <string>eta</string>
-              <string>etree</string>
-              <string>evalfile</string>
-              <string>exit</string>
-              <string>exp</string>
-              <string>exp10</string>
-              <string>exp2</string>
-              <string>expand</string>
-              <string>expanduser</string>
-              <string>expm</string>
-              <string>expm1</string>
-              <string>exponent</string>
-              <string>extrema</string>
-              <string>eye</string>
-              <string>factor</string>
-              <string>factorial</string>
-              <string>factorize</string>
-              <string>falses</string>
-              <string>fd</string>
-              <string>fdio</string>
-              <string>fetch</string>
-              <string>fft</string>
-              <string>fft!</string>
-              <string>fftshift</string>
-              <string>fieldoffsets</string>
-              <string>filemode</string>
-              <string>filesize</string>
-              <string>fill</string>
-              <string>fill!</string>
-              <string>filt</string>
-              <string>filt!</string>
-              <string>filter</string>
-              <string>filter!</string>
-              <string>finalizer</string>
-              <string>find</string>
-              <string>find_library</string>
-              <string>findfirst</string>
-              <string>findin</string>
-              <string>findmax</string>
-              <string>findmin</string>
-              <string>findn</string>
-              <string>findnext</string>
-              <string>findnz</string>
-              <string>first</string>
-              <string>fld</string>
-              <string>flipbits!</string>
-              <string>flipdim</string>
-              <string>fliplr</string>
-              <string>flipsign</string>
-              <string>flipud</string>
-              <string>float</string>
-              <string>float16</string>
-              <string>float32</string>
-              <string>float32_isvalid</string>
-              <string>float64</string>
-              <string>float64_isvalid</string>
-              <string>floor</string>
-              <string>flush</string>
-              <string>flush_cstdio</string>
-              <string>foldl</string>
-              <string>foldr</string>
-              <string>frexp</string>
-              <string>full</string>
-              <string>fullname</string>
-              <string>functionloc</string>
-              <string>functionlocs</string>
-              <string>gamma</string>
-              <string>gc</string>
-              <string>gc_disable</string>
-              <string>gc_enable</string>
-              <string>gcd</string>
-              <string>gcdx</string>
-              <string>gensym</string>
-              <string>get</string>
-              <string>get!</string>
-              <string>get_bigfloat_precision</string>
-              <string>get_bigfloat_rounding</string>
-              <string>get_rounding</string>
-              <string>getaddrinfo</string>
-              <string>gethostname</string>
-              <string>getindex</string>
-              <string>getipaddr</string>
-              <string>getkey</string>
-              <string>getpid</string>
-              <string>givens</string>
-              <string>gperm</string>
-              <string>gradient</string>
-              <string>hankelh1</string>
-              <string>hankelh1x</string>
-              <string>hankelh2</string>
-              <string>hankelh2x</string>
-              <string>hash</string>
-              <string>haskey</string>
-              <string>hcat</string>
-              <string>hessfact</string>
-              <string>hessfact!</string>
-              <string>hex</string>
-              <string>hex2bytes</string>
-              <string>hex2num</string>
-              <string>hist</string>
-              <string>hist2d</string>
-              <string>histrange</string>
-              <string>homedir</string>
-              <string>htol</string>
-              <string>hton</string>
-              <string>hvcat</string>
-              <string>hypot</string>
-              <string>iceil</string>
-              <string>idct</string>
-              <string>idct!</string>
-              <string>identity</string>
-              <string>ifelse</string>
-              <string>ifft</string>
-              <string>ifft!</string>
-              <string>ifftshift</string>
-              <string>ifloor</string>
-              <string>ignorestatus</string>
-              <string>imag</string>
-              <string>in</string>
-              <string>include</string>
-              <string>include_string</string>
-              <string>ind2chr</string>
-              <string>ind2sub</string>
-              <string>indexin</string>
-              <string>indexpids</string>
-              <string>indmax</string>
-              <string>indmin</string>
-              <string>inf</string>
-              <string>info</string>
-              <string>infs</string>
-              <string>insert!</string>
-              <string>int</string>
-              <string>int128</string>
-              <string>int16</string>
-              <string>int32</string>
-              <string>int64</string>
-              <string>int8</string>
-              <string>integer</string>
-              <string>interrupt</string>
-              <string>intersect</string>
-              <string>intersect!</string>
-              <string>inv</string>
-              <string>invdigamma</string>
-              <string>invmod</string>
-              <string>invperm</string>
-              <string>ipermute!</string>
-              <string>ipermutedims</string>
-              <string>irfft</string>
-              <string>iround</string>
-              <string>is_assigned_char</string>
-              <string>is_valid_ascii</string>
-              <string>is_valid_char</string>
-              <string>is_valid_utf16</string>
-              <string>is_valid_utf8</string>
-              <string>isabspath</string>
-              <string>isalnum</string>
-              <string>isalpha</string>
-              <string>isapprox</string>
-              <string>isascii</string>
-              <string>isbits</string>
-              <string>isblank</string>
-              <string>isblockdev</string>
-              <string>ischardev</string>
-              <string>iscntrl</string>
-              <string>isconst</string>
-              <string>isdigit</string>
-              <string>isdir</string>
-              <string>isdirpath</string>
-              <string>iseltype</string>
-              <string>isempty</string>
-              <string>isequal</string>
-              <string>iseven</string>
-              <string>isexecutable</string>
-              <string>isfifo</string>
-              <string>isfile</string>
-              <string>isfinite</string>
-              <string>isgeneric</string>
-              <string>isgraph</string>
-              <string>ishermitian</string>
-              <string>isimmutable</string>
-              <string>isinf</string>
-              <string>isinteger</string>
-              <string>isinteractive</string>
-              <string>isleaftype</string>
-              <string>isless</string>
-              <string>islink</string>
-              <string>islower</string>
-              <string>ismarked</string>
-              <string>ismatch</string>
-              <string>isnan</string>
-              <string>isodd</string>
-              <string>isopen</string>
-              <string>ispath</string>
-              <string>isperm</string>
-              <string>isposdef</string>
-              <string>isposdef!</string>
-              <string>ispow2</string>
-              <string>isprime</string>
-              <string>isprint</string>
-              <string>ispunct</string>
-              <string>isqrt</string>
-              <string>isreadable</string>
-              <string>isreadonly</string>
-              <string>isready</string>
-              <string>isreal</string>
-              <string>issetgid</string>
-              <string>issetuid</string>
-              <string>issocket</string>
-              <string>issorted</string>
-              <string>isspace</string>
-              <string>issparse</string>
-              <string>issticky</string>
-              <string>issubnormal</string>
-              <string>issubset</string>
-              <string>issym</string>
-              <string>istaskdone</string>
-              <string>istext</string>
-              <string>istril</string>
-              <string>istriu</string>
-              <string>isupper</string>
-              <string>isvalid</string>
-              <string>iswritable</string>
-              <string>isxdigit</string>
-              <string>itrunc</string>
-              <string>join</string>
-              <string>joinpath</string>
-              <string>keys</string>
-              <string>kill</string>
-              <string>kron</string>
-              <string>last</string>
-              <string>lbeta</string>
-              <string>lcfirst</string>
-              <string>lcm</string>
-              <string>ldexp</string>
-              <string>ldltfact</string>
-              <string>ldltfact!</string>
-              <string>leading_ones</string>
-              <string>leading_zeros</string>
-              <string>length</string>
-              <string>less</string>
-              <string>lexcmp</string>
-              <string>lexless</string>
-              <string>lfact</string>
-              <string>lgamma</string>
-              <string>linrange</string>
-              <string>linreg</string>
-              <string>linspace</string>
-              <string>listen</string>
-              <string>listenany</string>
-              <string>localindexes</string>
-              <string>localpart</string>
-              <string>log</string>
-              <string>log10</string>
-              <string>log1p</string>
-              <string>log2</string>
-              <string>logdet</string>
-              <string>logspace</string>
-              <string>lowercase</string>
-              <string>lpad</string>
-              <string>lstat</string>
-              <string>lstrip</string>
-              <string>ltoh</string>
-              <string>lu</string>
-              <string>lufact</string>
-              <string>lufact!</string>
-              <string>lyap</string>
-              <string>macroexpand</string>
-              <string>map</string>
-              <string>map!</string>
-              <string>mapreduce</string>
-              <string>mapslices</string>
-              <string>mark</string>
-              <string>match</string>
-              <string>matchall</string>
-              <string>max</string>
-              <string>maxabs</string>
-              <string>maxabs!</string>
-              <string>maximum</string>
-              <string>maximum!</string>
-              <string>maxintfloat</string>
-              <string>mean</string>
-              <string>mean!</string>
-              <string>median</string>
-              <string>median!</string>
-              <string>merge</string>
-              <string>merge!</string>
-              <string>methods</string>
-              <string>methodswith</string>
-              <string>middle</string>
-              <string>midpoints</string>
-              <string>mimewritable</string>
-              <string>min</string>
-              <string>minabs</string>
-              <string>minabs!</string>
-              <string>minimum</string>
-              <string>minimum!</string>
-              <string>minmax</string>
-              <string>mkdir</string>
-              <string>mkpath</string>
-              <string>mktemp</string>
-              <string>mktempdir</string>
-              <string>mmap</string>
-              <string>mmap_array</string>
-              <string>mmap_bitarray</string>
-              <string>mod</string>
-              <string>mod1</string>
-              <string>mod2pi</string>
-              <string>modf</string>
-              <string>module_name</string>
-              <string>module_parent</string>
-              <string>msync</string>
-              <string>mtime</string>
-              <string>mv</string>
-              <string>myid</string>
-              <string>myindexes</string>
-              <string>names</string>
-              <string>nan</string>
-              <string>nans</string>
-              <string>nb_available</string>
-              <string>ndigits</string>
-              <string>ndims</string>
-              <string>next</string>
-              <string>nextfloat</string>
-              <string>nextind</string>
-              <string>nextpow</string>
-              <string>nextpow2</string>
-              <string>nextprod</string>
-              <string>nfilled</string>
-              <string>nnz</string>
-              <string>nonzeros</string>
-              <string>norm</string>
-              <string>normalize_string</string>
-              <string>normfro</string>
-              <string>normpath</string>
-              <string>notify</string>
-              <string>nprocs</string>
-              <string>nthperm</string>
-              <string>nthperm!</string>
-              <string>ntoh</string>
-              <string>ntuple</string>
-              <string>null</string>
-              <string>num</string>
-              <string>num2hex</string>
-              <string>nworkers</string>
-              <string>object_id</string>
-              <string>oct</string>
-              <string>oftype</string>
-              <string>one</string>
-              <string>ones</string>
-              <string>open</string>
-              <string>operm</string>
-              <string>parent</string>
-              <string>parentindexes</string>
-              <string>parse</string>
-              <string>parsefloat</string>
-              <string>parseint</string>
-              <string>parseip</string>
-              <string>partitions</string>
-              <string>peakflops</string>
-              <string>permutations</string>
-              <string>permute!</string>
-              <string>permutedims</string>
-              <string>permutedims!</string>
-              <string>pinv</string>
-              <string>plan_bfft</string>
-              <string>plan_bfft!</string>
-              <string>plan_brfft</string>
-              <string>plan_dct</string>
-              <string>plan_dct!</string>
-              <string>plan_fft</string>
-              <string>plan_fft!</string>
-              <string>plan_idct</string>
-              <string>plan_idct!</string>
-              <string>plan_ifft</string>
-              <string>plan_ifft!</string>
-              <string>plan_irfft</string>
-              <string>plan_rfft</string>
-              <string>pmap</string>
-              <string>pointer</string>
-              <string>pointer_from_objref</string>
-              <string>pointer_to_array</string>
-              <string>poll_fd</string>
-              <string>poll_file</string>
-              <string>polygamma</string>
-              <string>pop!</string>
-              <string>popdisplay</string>
-              <string>position</string>
-              <string>powermod</string>
-              <string>precision</string>
-              <string>precompile</string>
-              <string>prepend!</string>
-              <string>prevfloat</string>
-              <string>prevind</string>
-              <string>prevpow</string>
-              <string>prevpow2</string>
-              <string>prevprod</string>
-              <string>primes</string>
-              <string>print</string>
-              <string>print_escaped</string>
-              <string>print_joined</string>
-              <string>print_shortest</string>
-              <string>print_unescaped</string>
-              <string>print_with_color</string>
-              <string>println</string>
-              <string>process_exited</string>
-              <string>process_running</string>
-              <string>procs</string>
-              <string>prod</string>
-              <string>prod!</string>
-              <string>produce</string>
-              <string>promote</string>
-              <string>promote_rule</string>
-              <string>promote_shape</string>
-              <string>promote_type</string>
-              <string>push!</string>
-              <string>pushdisplay</string>
-              <string>put</string>
-              <string>put!</string>
-              <string>pwd</string>
-              <string>qr</string>
-              <string>qrfact</string>
-              <string>qrfact!</string>
-              <string>quadgk</string>
-              <string>quantile</string>
-              <string>quantile!</string>
-              <string>quit</string>
-              <string>rad2deg</string>
-              <string>radians2degrees</string>
-              <string>rand</string>
-              <string>rand!</string>
-              <string>randbool</string>
-              <string>randbool!</string>
-              <string>randcycle</string>
-              <string>randn</string>
-              <string>randn!</string>
-              <string>randperm</string>
-              <string>randstring</string>
-              <string>randsubseq</string>
-              <string>randsubseq!</string>
-              <string>range</string>
-              <string>rank</string>
-              <string>rationalize</string>
-              <string>read</string>
-              <string>read!</string>
-              <string>readall</string>
-              <string>readandwrite</string>
-              <string>readavailable</string>
-              <string>readbytes</string>
-              <string>readbytes!</string>
-              <string>readchomp</string>
-              <string>readcsv</string>
-              <string>readdir</string>
-              <string>readdlm</string>
-              <string>readline</string>
-              <string>readlines</string>
-              <string>readsfrom</string>
-              <string>readuntil</string>
-              <string>real</string>
-              <string>realmax</string>
-              <string>realmin</string>
-              <string>realpath</string>
-              <string>recv</string>
-              <string>redirect_stderr</string>
-              <string>redirect_stdin</string>
-              <string>redirect_stdout</string>
-              <string>redisplay</string>
-              <string>reduce</string>
-              <string>reducedim</string>
-              <string>reenable_sigint</string>
-              <string>reim</string>
-              <string>reinterpret</string>
-              <string>reload</string>
-              <string>rem</string>
-              <string>rem1</string>
-              <string>remotecall</string>
-              <string>remotecall_fetch</string>
-              <string>remotecall_wait</string>
-              <string>repeat</string>
-              <string>replace</string>
-              <string>repmat</string>
-              <string>repr</string>
-              <string>reprmime</string>
-              <string>require</string>
-              <string>reset</string>
-              <string>reshape</string>
-              <string>resize!</string>
-              <string>rethrow</string>
-              <string>reverse</string>
-              <string>reverse!</string>
-              <string>rfft</string>
-              <string>rm</string>
-              <string>rmdir</string>
-              <string>rmprocs</string>
-              <string>rol</string>
-              <string>ror</string>
-              <string>rot180</string>
-              <string>rotl90</string>
-              <string>rotr90</string>
-              <string>round</string>
-              <string>rpad</string>
-              <string>rref</string>
-              <string>rsearch</string>
-              <string>rsearchindex</string>
-              <string>rsplit</string>
-              <string>rstrip</string>
-              <string>run</string>
-              <string>scale</string>
-              <string>scale!</string>
-              <string>schedule</string>
-              <string>schur</string>
-              <string>schurfact</string>
-              <string>schurfact!</string>
-              <string>sdata</string>
-              <string>search</string>
-              <string>searchindex</string>
-              <string>searchsorted</string>
-              <string>searchsortedfirst</string>
-              <string>searchsortedlast</string>
-              <string>sec</string>
-              <string>secd</string>
-              <string>sech</string>
-              <string>seek</string>
-              <string>seekend</string>
-              <string>seekstart</string>
-              <string>select</string>
-              <string>select!</string>
-              <string>send</string>
-              <string>serialize</string>
-              <string>set_bigfloat_precision</string>
-              <string>set_bigfloat_rounding</string>
-              <string>set_rounding</string>
-              <string>setdiff</string>
-              <string>setdiff!</string>
-              <string>setenv</string>
-              <string>setfield</string>
-              <string>setindex!</string>
-              <string>shift!</string>
-              <string>show</string>
-              <string>showall</string>
-              <string>showcompact</string>
-              <string>showerror</string>
-              <string>shuffle</string>
-              <string>shuffle!</string>
-              <string>sign</string>
-              <string>signbit</string>
-              <string>signed</string>
-              <string>signif</string>
-              <string>significand</string>
-              <string>similar</string>
-              <string>sin</string>
-              <string>sinc</string>
-              <string>sind</string>
-              <string>sinh</string>
-              <string>sinpi</string>
-              <string>size</string>
-              <string>sizehint</string>
-              <string>sizeof</string>
-              <string>skip</string>
-              <string>skipchars</string>
-              <string>sleep</string>
-              <string>slice</string>
-              <string>slicedim</string>
-              <string>sort</string>
-              <string>sort!</string>
-              <string>sortcols</string>
-              <string>sortperm</string>
-              <string>sortrows</string>
-              <string>sparse</string>
-              <string>sparsevec</string>
-              <string>spawn</string>
-              <string>spdiagm</string>
-              <string>speye</string>
-              <string>splice!</string>
-              <string>split</string>
-              <string>splitdir</string>
-              <string>splitdrive</string>
-              <string>splitext</string>
-              <string>spones</string>
-              <string>sprand</string>
-              <string>sprandbool</string>
-              <string>sprandn</string>
-              <string>sprint</string>
-              <string>spzeros</string>
-              <string>sqrt</string>
-              <string>sqrtm</string>
-              <string>squeeze</string>
-              <string>srand</string>
-              <string>start</string>
-              <string>start_reading</string>
-              <string>start_timer</string>
-              <string>start_watching</string>
-              <string>stat</string>
-              <string>std</string>
-              <string>stdm</string>
-              <string>step</string>
-              <string>stop_reading</string>
-              <string>stop_timer</string>
-              <string>strerror</string>
-              <string>strftime</string>
-              <string>stride</string>
-              <string>strides</string>
-              <string>string</string>
-              <string>stringmime</string>
-              <string>strip</string>
-              <string>strptime</string>
-              <string>strwidth</string>
-              <string>sub</string>
-              <string>sub2ind</string>
-              <string>subtypes</string>
-              <string>success</string>
-              <string>sum</string>
-              <string>sum!</string>
-              <string>sum_kbn</string>
-              <string>sumabs</string>
-              <string>sumabs!</string>
-              <string>sumabs2</string>
-              <string>sumabs2!</string>
-              <string>summary</string>
-              <string>super</string>
-              <string>svd</string>
-              <string>svdfact</string>
-              <string>svdfact!</string>
-              <string>svdvals</string>
-              <string>svdvals!</string>
-              <string>sylvester</string>
-              <string>symbol</string>
-              <string>symdiff</string>
-              <string>symdiff!</string>
-              <string>symlink</string>
-              <string>symperm</string>
-              <string>systemerror</string>
-              <string>take</string>
-              <string>take!</string>
-              <string>takebuf_array</string>
-              <string>takebuf_string</string>
-              <string>tan</string>
-              <string>tand</string>
-              <string>tanh</string>
-              <string>task_local_storage</string>
-              <string>tempdir</string>
-              <string>tempname</string>
-              <string>tic</string>
-              <string>time</string>
-              <string>time_ns</string>
-              <string>timedwait</string>
-              <string>toc</string>
-              <string>toq</string>
-              <string>touch</string>
-              <string>trace</string>
-              <string>trailing_ones</string>
-              <string>trailing_zeros</string>
-              <string>transpose</string>
-              <string>trigamma</string>
-              <string>tril</string>
-              <string>tril!</string>
-              <string>triu</string>
-              <string>triu!</string>
-              <string>trues</string>
-              <string>trunc</string>
-              <string>truncate</string>
-              <string>typeintersect</string>
-              <string>typejoin</string>
-              <string>typemax</string>
-              <string>typemin</string>
-              <string>ucfirst</string>
-              <string>uint</string>
-              <string>uint128</string>
-              <string>uint16</string>
-              <string>uint32</string>
-              <string>uint64</string>
-              <string>uint8</string>
-              <string>unescape_string</string>
-              <string>union</string>
-              <string>union!</string>
-              <string>unique</string>
-              <string>unmark</string>
-              <string>unsafe_copy!</string>
-              <string>unsafe_load</string>
-              <string>unsafe_pointer_to_objref</string>
-              <string>unsafe_store!</string>
-              <string>unshift!</string>
-              <string>unsigned</string>
-              <string>uperm</string>
-              <string>uppercase</string>
-              <string>utf16</string>
-              <string>utf32</string>
-              <string>utf8</string>
-              <string>values</string>
-              <string>var</string>
-              <string>varm</string>
-              <string>vcat</string>
-              <string>vec</string>
-              <string>vecnorm</string>
-              <string>versioninfo</string>
-              <string>wait</string>
-              <string>warn</string>
-              <string>watch_file</string>
-              <string>which</string>
-              <string>whos</string>
-              <string>widemul</string>
-              <string>widen</string>
-              <string>with_bigfloat_precision</string>
-              <string>with_bigfloat_rounding</string>
-              <string>with_rounding</string>
-              <string>workers</string>
-              <string>workspace</string>
-              <string>write</string>
-              <string>writecsv</string>
-              <string>writedlm</string>
-              <string>writemime</string>
-              <string>writesto</string>
-              <string>wstring</string>
-              <string>xcorr</string>
-              <string>xdump</string>
-              <string>yield</string>
-              <string>zero</string>
-              <string>zeros</string>
-              <string>zeta</string>
-              <string>zip</string>
+            <string>whos</string>
+            <string>widemul</string>
+            <string>widen</string>
+            <string>with_env</string>
+            <string>withenv</string>
+            <string>workers</string>
+            <string>workspace</string>
+            <string>write</string>
+            <string>writecsv</string>
+            <string>writedlm</string>
+            <string>writemime</string>
+            <string>writesto</string>
+            <string>wstring</string>
+            <string>xcorr</string>
+            <string>xdump</string>
+            <string>yield</string>
+            <string>yieldto</string>
+            <string>zero</string>
+            <string>zeros</string>
+            <string>zeta</string>
+            <string>zip</string>
+            <string>γ</string>
+            <string>π</string>
+            <string>φ</string>
     </array>
-
-    <!-- these are the names(Base) ... strings that start with capital letter and are not functions. -->
-
     <key>BBLMPredefinedNameList</key>
-      <array>
-              <string>AbstractMatrix</string>
-              <string>AbstractRNG</string>
-              <string>AbstractSparseArray</string>
-              <string>AbstractSparseMatrix</string>
-              <string>AbstractSparseVector</string>
-              <string>AbstractVecOrMat</string>
-              <string>AbstractVector</string>
-              <string>ArgumentError</string>
-              <string>Array</string>
-              <string>Associative</string>
-              <string>BLAS</string>
-              <string>Base</string>
-              <string>Base64Pipe</string>
-              <string>Bidiagonal</string>
-              <string>BigFloat</string>
-              <string>BigInt</string>
-              <string>BitArray</string>
-              <string>BitMatrix</string>
-              <string>BitVector</string>
-              <string>CFILE</string>
-              <string>Cchar</string>
-              <string>Cdouble</string>
-              <string>Cfloat</string>
-              <string>CharString</string>
-              <string>Cint</string>
-              <string>Clong</string>
-              <string>Clonglong</string>
-              <string>ClusterManager</string>
-              <string>Cmd</string>
-              <string>Coff_t</string>
-              <string>Collections</string>
-              <string>Colon</string>
-              <string>Complex</string>
-              <string>Complex128</string>
-              <string>Complex32</string>
-              <string>Complex64</string>
-              <string>Condition</string>
-              <string>Cptrdiff_t</string>
-              <string>Cshort</string>
-              <string>Csize_t</string>
-              <string>Cssize_t</string>
-              <string>Cuchar</string>
-              <string>Cuint</string>
-              <string>Culong</string>
-              <string>Culonglong</string>
-              <string>Cushort</string>
-              <string>Cwchar_t</string>
-              <string>DArray</string>
-              <string>DenseMatrix</string>
-              <string>DenseVecOrMat</string>
-              <string>DenseVector</string>
-              <string>Diagonal</string>
-              <string>Dict</string>
-              <string>DimensionMismatch</string>
-              <string>Display</string>
-              <string>EOFError</string>
-              <string>EachLine</string>
-              <string>Enumerate</string>
-              <string>ErrorException</string>
-              <string>FFTW</string>
-              <string>Factorization</string>
-              <string>FileMonitor</string>
-              <string>FileOffset</string>
-              <string>Filter</string>
-              <string>FloatRange</string>
-              <string>Graphics</string>
-              <string>Hermitian</string>
-              <string>IO</string>
-              <string>IOBuffer</string>
-              <string>IOStream</string>
-              <string>IPv4</string>
-              <string>IPv6</string>
-              <string>IntSet</string>
-              <string>KeyError</string>
-              <string>LAPACK</string>
-              <string>LoadError</string>
-              <string>LocalProcess</string>
-              <string>MIME</string>
-              <string>Irrational</string>
-              <string>Matrix</string>
-              <string>MersenneTwister</string>
-              <string>Meta</string>
-              <string>MethodError</string>
-              <string>ObjectIdDict</string>
-              <string>Operators</string>
-              <string>OrdinalRange</string>
-              <string>ParseError</string>
-              <string>Pkg</string>
-              <string>PollingFileWatcher</string>
-              <string>ProcessExitedException</string>
-              <string>ProcessGroup</string>
-              <string>Profile</string>
-              <string>Range</string>
-              <string>Range1</string>
-              <string>Ranges</string>
-              <string>Rational</string>
-              <string>RawFD</string>
-              <string>Regex</string>
-              <string>RegexMatch</string>
-              <string>RemoteRef</string>
-              <string>RepString</string>
-              <string>RevString</string>
-              <string>RopeString</string>
-              <string>RoundDown</string>
-              <string>RoundFromZero</string>
-              <string>RoundNearest</string>
-              <string>RoundToZero</string>
-              <string>RoundUp</string>
-              <string>RoundingMode</string>
-              <string>Set</string>
-              <string>SharedArray</string>
-              <string>SharedMatrix</string>
-              <string>SharedVector</string>
-              <string>SparseMatrixCSC</string>
-              <string>Stat</string>
-              <string>StatStruct</string>
-              <string>StepRange</string>
-              <string>StridedArray</string>
-              <string>StridedMatrix</string>
-              <string>StridedVecOrMat</string>
-              <string>StridedVector</string>
-              <string>SubArray</string>
-              <string>SubDArray</string>
-              <string>SubOrDArray</string>
-              <string>SubString</string>
-              <string>SymTridiagonal</string>
-              <string>Symmetric</string>
-              <string>Sys</string>
-              <string>SystemError</string>
-              <string>Test</string>
-              <string>TextDisplay</string>
-              <string>Timer</string>
-              <string>TmStruct</string>
-              <string>Triangular</string>
-              <string>Tridiagonal</string>
-              <string>TypeError</string>
-              <string>UTF16String</string>
-              <string>UTF32String</string>
-              <string>UdpSocket</string>
-              <string>UniformScaling</string>
-              <string>UnitRange</string>
-              <string>VecOrMat</string>
-              <string>Vector</string>
-              <string>VersionNumber</string>
-              <string>WString</string>
-              <string>WeakKeyDict</string>
-              <string>WeakRef</string>
-              <string>Zip</string>
+     <array>
+        <string>A_ldiv_B!</string>
+        <string>A_ldiv_Bc</string>
+        <string>A_ldiv_Bt</string>
+        <string>A_mul_B!</string>
+        <string>A_mul_Bc!</string>
+        <string>A_mul_Bc</string>
+        <string>A_mul_Bt!</string>
+        <string>A_mul_Bt</string>
+        <string>A_rdiv_Bc</string>
+        <string>A_rdiv_Bt</string>
+        <string>AbstractArray</string>
+        <string>AbstractChannel</string>
+        <string>AbstractFloat</string>
+        <string>AbstractMatrix</string>
+        <string>AbstractRNG</string>
+        <string>AbstractSparseArray</string>
+        <string>AbstractSparseMatrix</string>
+        <string>AbstractSparseVector</string>
+        <string>AbstractVecOrMat</string>
+        <string>AbstractVector</string>
+        <string>Ac_ldiv_B</string>
+        <string>Ac_ldiv_Bc</string>
+        <string>Ac_mul_B!</string>
+        <string>Ac_mul_B</string>
+        <string>Ac_mul_Bc!</string>
+        <string>Ac_mul_Bc</string>
+        <string>Ac_rdiv_B</string>
+        <string>Ac_rdiv_Bc</string>
+        <string>ARGS</string>
+        <string>ArgumentError</string>
+        <string>Array</string>
+        <string>ASCIIString</string>
+        <string>AssertionError</string>
+        <string>Associative</string>
+        <string>AsyncStream</string>
+        <string>At_ldiv_B</string>
+        <string>At_ldiv_Bt</string>
+        <string>At_mul_B!</string>
+        <string>At_mul_B</string>
+        <string>At_mul_Bt!</string>
+        <string>At_mul_Bt</string>
+        <string>At_rdiv_B</string>
+        <string>At_rdiv_Bt</string>
+        <string>Base64DecodePipe</string>
+        <string>Base64EncodePipe</string>
+        <string>Base64Pipe</string>
+        <string>Base</string>
+        <string>Bidiagonal</string>
+        <string>BigFloat</string>
+        <string>BigInt</string>
+        <string>BitArray</string>
+        <string>BitMatrix</string>
+        <string>BitVector</string>
+        <string>BLAS</string>
+        <string>BufferStream</string>
+        <string>BunchKaufman</string>
+        <string>C_NULL</string>
+        <string>CapturedException</string>
+        <string>CartesianIndex</string>
+        <string>CartesianRange</string>
+        <string>Cchar</string>
+        <string>Cdouble</string>
+        <string>Cfloat</string>
+        <string>Channel</string>
+        <string>CharString</string>
+        <string>Cholesky</string>
+        <string>CholeskyDense</string>
+        <string>CholeskyPivoted</string>
+        <string>CholeskyPivotedDense</string>
+        <string>Cint</string>
+        <string>Cintmax_t</string>
+        <string>Clong</string>
+        <string>Clonglong</string>
+        <string>ClusterManager</string>
+        <string>Cmd</string>
+        <string>Collections</string>
+        <string>Colon</string>
+        <string>Complex128</string>
+        <string>Complex32</string>
+        <string>Complex64</string>
+        <string>Complex</string>
+        <string>ComplexPair</string>
+        <string>CompositeException</string>
+        <string>Condition</string>
+        <string>Cptrdiff_t</string>
+        <string>CPU_CORES</string>
+        <string>Cshort</string>
+        <string>Csize_t</string>
+        <string>Cssize_t</string>
+        <string>Cstring</string>
+        <string>Cuchar</string>
+        <string>Cuint</string>
+        <string>Cuintmax_t</string>
+        <string>Culong</string>
+        <string>Culonglong</string>
+        <string>Cushort</string>
+        <string>Cwchar_t</string>
+        <string>Cwstring</string>
+        <string>DArray</string>
+        <string>Date</string>
+        <string>Dates</string>
+        <string>DateTime</string>
+        <string>DenseMatrix</string>
+        <string>DenseVecOrMat</string>
+        <string>DenseVector</string>
+        <string>DevNull</string>
+        <string>Diagonal</string>
+        <string>Dict</string>
+        <string>DimensionMismatch</string>
+        <string>Dims</string>
+        <string>DisconnectException</string>
+        <string>Display</string>
+        <string>DL_LOAD_PATH</string>
+        <string>Docs</string>
+        <string>EachLine</string>
+        <string>Eigen</string>
+        <string>ENDIAN_BOM</string>
+        <string>Enum</string>
+        <string>Enumerate</string>
+        <string>ENV</string>
+        <string>EnvHash</string>
+        <string>EOFError</string>
+        <string>ErrorException</string>
+        <string>Exception</string>
+        <string>Expr</string>
+        <string>Factorization</string>
+        <string>FFTW</string>
+        <string>FileMonitor</string>
+        <string>Filter</string>
+        <string>FloatingPoint</string>
+        <string>FloatRange</string>
+        <string>Function</string>
+        <string>GeneralizedSchur</string>
+        <string>GeneralizedSVD</string>
+        <string>Graphics</string>
+        <string>GSVDDense</string>
+        <string>HeapSort</string>
+        <string>Hermitian</string>
+        <string>Hessenberg</string>
+        <string>HTML</string>
+        <string>I</string>
+        <string>ImaginaryUnit</string>
+        <string>Inf16</string>
+        <string>Inf32</string>
+        <string>Inf64</string>
+        <string>Inf</string>
+        <string>InitError</string>
+        <string>InsertionSort</string>
+        <string>IntSet</string>
+        <string>InvalidStateException</string>
+        <string>IO</string>
+        <string>IOBuffer</string>
+        <string>IOStream</string>
+        <string>IPv4</string>
+        <string>IPv6</string>
+        <string>Irrational</string>
+        <string>JULIA_HOME</string>
+        <string>KeyError</string>
+        <string>LAPACK</string>
+        <string>LDLTTridiagonal</string>
+        <string>Libc</string>
+        <string>Libdl</string>
+        <string>LinAlg</string>
+        <string>LinSpace</string>
+        <string>LOAD_PATH</string>
+        <string>LoadError</string>
+        <string>LocalProcess</string>
+        <string>LowerTriangular</string>
+        <string>LUDense</string>
+        <string>LUTridiagonal</string>
+        <string>Markdown</string>
+        <string>Matrix</string>
+        <string>MemoryError</string>
+        <string>MergeSort</string>
+        <string>MersenneTwister</string>
+        <string>Meta</string>
+        <string>MethodError</string>
+        <string>MIME</string>
+        <string>Mmap</string>
+        <string>MS_ASYNC</string>
+        <string>MS_INVALIDATE</string>
+        <string>MS_SYNC</string>
+        <string>NaN16</string>
+        <string>NaN32</string>
+        <string>NaN64</string>
+        <string>NaN</string>
+        <string>None</string>
+        <string>Nothing</string>
+        <string>Nullable</string>
+        <string>NullException</string>
+        <string>Number</string>
+        <string>ObjectIdDict</string>
+        <string>Operators</string>
+        <string>Order</string>
+        <string>OrdinalRange</string>
+        <string>OS_NAME</string>
+        <string>Pair</string>
+        <string>ParseError</string>
+        <string>PartialQuickSort</string>
+        <string>Pipe</string>
+        <string>PipeBuffer</string>
+        <string>Pkg2</string>
+        <string>Pkg</string>
+        <string>PollingFileWatcher</string>
+        <string>ProcessExitedException</string>
+        <string>ProcessGroup</string>
+        <string>Profile</string>
+        <string>Ptr</string>
+        <string>QRDense</string>
+        <string>QRPivoted</string>
+        <string>QRPivotedDense</string>
+        <string>QuickSort</string>
+        <string>RandomDevice</string>
+        <string>Range1</string>
+        <string>Range</string>
+        <string>RangeIndex</string>
+        <string>Ranges</string>
+        <string>Rational</string>
+        <string>RawFD</string>
+        <string>ReentrantLock</string>
+        <string>Regex</string>
+        <string>RegexMatch</string>
+        <string>RegexMatchIterator</string>
+        <string>RemoteException</string>
+        <string>RemoteRef</string>
+        <string>RepString</string>
+        <string>RevString</string>
+        <string>RopeString</string>
+        <string>RoundDown</string>
+        <string>RoundFromZero</string>
+        <string>RoundingMode</string>
+        <string>RoundNearest</string>
+        <string>RoundNearestTiesAway</string>
+        <string>RoundNearestTiesUp</string>
+        <string>RoundToZero</string>
+        <string>RoundUp</string>
+        <string>RTLD_DEEPBIND</string>
+        <string>RTLD_FIRST</string>
+        <string>RTLD_GLOBAL</string>
+        <string>RTLD_LAZY</string>
+        <string>RTLD_LOCAL</string>
+        <string>RTLD_NODELETE</string>
+        <string>RTLD_NOLOAD</string>
+        <string>RTLD_NOW</string>
+        <string>SerializationState</string>
+        <string>Serializer</string>
+        <string>Set</string>
+        <string>SharedArray</string>
+        <string>SharedMatrix</string>
+        <string>SharedVector</string>
+        <string>SparseMatrix</string>
+        <string>SparseMatrixCSC</string>
+        <string>SpawnNullStream</string>
+        <string>StatStruct</string>
+        <string>STDERR</string>
+        <string>STDIN</string>
+        <string>STDOUT</string>
+        <string>StepRange</string>
+        <string>StridedArray</string>
+        <string>StridedMatrix</string>
+        <string>StridedVecOrMat</string>
+        <string>StridedVector</string>
+        <string>String</string>
+        <string>SubArray</string>
+        <string>SubDArray</string>
+        <string>SubOrDArray</string>
+        <string>SubString</string>
+        <string>SVDDense</string>
+        <string>Symmetric</string>
+        <string>SymTridiagonal</string>
+        <string>Sys</string>
+        <string>SystemError</string>
+        <string>Task</string>
+        <string>TcpSocket</string>
+        <string>Test</string>
+        <string>Text</string>
+        <string>TextDisplay</string>
+        <string>TimeoutAsyncWork</string>
+        <string>Timer</string>
+        <string>TimSort</string>
+        <string>TmStruct</string>
+        <string>Triangular</string>
+        <string>Tridiagonal</string>
+        <string>Tuple</string>
+        <string>Type</string>
+        <string>TypeError</string>
+        <string>UdpSocket</string>
+        <string>Uint128</string>
+        <string>Uint16</string>
+        <string>Uint32</string>
+        <string>Uint64</string>
+        <string>Uint8</string>
+        <string>Uint</string>
+        <string>UnicodeError</string>
+        <string>UniformScaling</string>
+        <string>UnionType</string>
+        <string>UnitRange</string>
+        <string>UpperTriangular</string>
+        <string>UTF16String</string>
+        <string>UTF32String</string>
+        <string>UTF8String</string>
+        <string>UV_READABLE</string>
+        <string>UV_WRITEABLE</string>
+        <string>UVError</string>
+        <string>Val</string>
+        <string>VecOrMat</string>
+        <string>Vector</string>
+        <string>VERSION</string>
+        <string>VersionNumber</string>
+        <string>Void</string>
+        <string>WeakKeyDict</string>
+        <string>WeakRef</string>
+        <string>WindowsRawSocket</string>
+        <string>WORD_SIZE</string>
+        <string>WorkerConfig</string>
+        <string>WString</string>
+        <string>Zip</string>
     </array>
-
 	<key>Language Features</key>
 	<dict>
 		<key>Identifier and Keyword Character Class</key>
-		<string>A-Za-z0-9_!</string>
+		<string>A-Za-z0-9_!@</string>
 
 		<key>Escape Char in Strings 1</key>
 		<string>\</string>
 
+		<key>Escape Char in Strings 2w</key>
+		<string>$</string>
+
 		<key>End-of-line Ends Strings 1</key>
 		<false/>
 
@@ -1293,46 +1566,54 @@
 
         <!-- function-matching regex, might need tweaking -->
 		<key>Function Pattern</key>
-        <string><![CDATA[
-        (?x:
-            (?P<leadspace>^\s*)
-            (?P<function>
-                function\s+
-                (?P<function_name>
-                    [a-zA-Z0-9_!?.]+
-                )
-                (?s:.+?)
-                \r(?P=leadspace)end
-            )
-        )
-        ]]>
-        </string>
+              <string><![CDATA[
+              (?x:
+                  (?P<leadspace>^\s*)
+                  (?P<function>
+                      function\s+
+                      (?P<function_name>
+                          [a-zA-Z0-9_!?.@]+
+                      )
+                      (?s:.+?)
+                      \r(?P=leadspace)end
+                  )
+              )
+              ]]>
+             </string>
 
         <!-- string-matching regex -->
         <key>String Pattern</key>
-        <string><![CDATA[
-        (?x:
-            (\"\"\"(\\"\"\"|[^\"\"\"]|\\\r)*\"\"\")  | (?# Triple-Double-quote)
-            ("(\\"|[^"\r]|\\\r)*")        | (?# Single-Double-quote)
-            (r"(\\"|[^"\r]|\\\r)*")       | (?# Regex-quote)
-            ('(\\|[^'\r]|\\\r)*')         | (?# Character single)
-            (`(\\"|[^`\r]|\\\r)*`)          (?# Back-quote)
-        )
-        ]]></string>
+              <string><![CDATA[
+              (?x:
+                  ("{3}([\s\S]*?)"{3})          | (?# Triple-Double-quote)
+                  ("(\\"|[^"\r]|\\\r)*")        | (?# Single-Double-quote)
+                  (r"(\\"|[^"\r]|\\\r)*")       | (?# Regex-quote)
+                  ('(\\|[^'\r]|\\\r)*')         | (?# Character single)
+                  (`(\\"|[^`\r]|\\\r)*`)          (?# Back-quote)
+              )
+              ]]></string>
 
-     <!-- comment-matching regex - nicked from the BBEdit docs.
+     <!-- comment-matching regex
 
-          I can only do a single unnested multiline comment block, but
-          perhaps some fiendishly cunning recursive regex could do nested multiline comments...?
+          Can only do a single unnested multiline comment block, can't do
+          nested multiline comments...
 
     -->
 	<key>Comment Pattern</key>
+          <string><![CDATA[
+              (?x:
+                  (\#(?!=).*?$)              |      (?# Line comment not allowing = immediately after #)
+                  (?s:\#=(.*?)=\#)                  (?# Block comment)
+              )
+          ]]></string>
+
+    <key>Skip Pattern</key>
     <string><![CDATA[
-    (?msx:
-        (\#=(.*?)=\#) | (?# one unnested multiline comment block)
-        (\#.*?$)        (?# a single line comment)
-    )
-    ]]></string>
+    (?x:
+        (?P>comment) |
+        (?P>string)
+    )]]></string>
+
 	</dict>
 </dict>
 </plist>
diff --git a/contrib/Julia_Notepad++.xml b/contrib/Julia_Notepad++.xml
index f92cbdf4a856f..ea137be18b6a9 100644
--- a/contrib/Julia_Notepad++.xml
+++ b/contrib/Julia_Notepad++.xml
@@ -25,7 +25,7 @@
             <Keywords name="Folders in comment, middle"></Keywords>
             <Keywords name="Folders in comment, close"></Keywords>
             <Keywords name="Keywords1">true false C_NULL Inf NaN Inf32 NaN32 nothing</Keywords>
-            <Keywords name="Keywords2">ASCIIString AbstractArray AbstractMatrix AbstractSparseMatrix AbstractString AbstractVector Any ArgumentError Array Associative AsyncStream BigFloat BigInt BitArray BitMatrix BitVector Bool BunchKaufman ByteString Cchar Cdouble Cfloat Char CharString CholeskyDense CholeskyPivotedDense Cint Cintmax_t Clong Clonglong Colon Complex Complex128 Complex64 ComplexPair Cptrdiff_t Cshort Csize_t Cuchar Cuint Cuintmax_t Culong Culonglong Cushort DArray Dict Dims DisconnectException EOFError EachLine EnvHash ErrorException Exception Expr Factorization FileOffset Filter Float Float32 Float64 Function GSVDDense IO IOBuffer IOStream ImaginaryUnit InsertionSort Int Int128 Int16 Int32 Int64 Int8 IntSet Integer KeyError LDLTTridiagonal LUDense LUTridiagonal LoadError LocalProcess Matrix MergeSort MethodError NTuple Number ObjectIdDict ObjectIdDict OrdinalRange ParseError PipeBuffer ProcessGroup Ptr QRDense QRPivotedDense QuickSort Range Range1 RangeIndex Ranges Rational Real Regex RegexMatch RegexMatchIterator RemoteRef RepString RevString Reverse RopeString SVDDense Set Signed SparseMatrixCSC SpawnNullStream Stat StridedArray StridedMatrix StridedVecOrMat StridedVector SubArray SubDArray SubOrDArray SubString SymTridiagonal Symbol SystemError Task TcpSocket TimSort Tridiagonal Tuple Type TypeError UInt UInt128 UInt16 UInt32 UInt64 UInt8 UTF8String UVError Union Unsigned VecOrMat Vector VersionNumber Void WeakKeyDict WeakRef Zip</Keywords>
+            <Keywords name="Keywords2">ASCIIString AbstractArray AbstractMatrix AbstractSparseMatrix AbstractString AbstractVector Any ArgumentError Array Associative AsyncStream BigFloat BigInt BitArray BitMatrix BitVector Bool BunchKaufman ByteString Cchar Cdouble Cfloat Char CharString CholeskyDense CholeskyPivotedDense Cint Cintmax_t Clong Clonglong Colon Complex Complex128 Complex64 ComplexPair Cptrdiff_t Cshort Csize_t Cuchar Cuint Cuintmax_t Culong Culonglong Cushort DArray Dict Dims DisconnectException EOFError EachLine EnvHash ErrorException Exception Expr Factorization Filter Float Float32 Float64 Function GSVDDense IO IOBuffer IOStream ImaginaryUnit InsertionSort Int Int128 Int16 Int32 Int64 Int8 IntSet Integer KeyError LDLTTridiagonal LUDense LUTridiagonal LoadError LocalProcess Matrix MergeSort MethodError NTuple Number ObjectIdDict ObjectIdDict OrdinalRange ParseError PipeBuffer ProcessGroup Ptr QRDense QRPivotedDense QuickSort Range Range1 RangeIndex Ranges Rational Real Regex RegexMatch RegexMatchIterator RemoteRef RepString RevString Reverse RopeString SVDDense Set Signed SparseMatrixCSC SpawnNullStream Stat StridedArray StridedMatrix StridedVecOrMat StridedVector SubArray SubDArray SubOrDArray SubString SymTridiagonal Symbol SystemError Task TCPSocket TimSort Tridiagonal Tuple Type TypeError UInt UInt128 UInt16 UInt32 UInt64 UInt8 UTF8String UVError Union Unsigned VecOrMat Vector VersionNumber Void WeakKeyDict WeakRef Zip</Keywords>
             <Keywords name="Keywords3">abstract begin baremodule bitstype break catch ccall const continue do else elseif end export finally for function global if immutable import importall let local macro module quote return try type typealias using while</Keywords>
             <Keywords name="Keywords4">close enumerate error info open print println read write warn</Keywords>
             <Keywords name="Keywords5">print println</Keywords>
diff --git a/contrib/README.md b/contrib/README.md
index a32ab3c37a7dc..60011fd9db9f7 100644
--- a/contrib/README.md
+++ b/contrib/README.md
@@ -3,7 +3,6 @@ Installation
 
 | Name                           |  Description                                                |
 |  ----------------------------  |  ---------------------------------------------------------  |
-|[ build_executable.jl ](https://github.com/JuliaLang/julia/blob/master/contrib/build_executable.jl) | Support building standalone executables |
 |[ build_sysimg.jl ](https://github.com/JuliaLang/julia/blob/master/contrib/build_sysimg.jl) | Build a system image binary |
 |[ check-whitespace.sh ](https://github.com/JuliaLang/julia/blob/master/contrib/check-whitespace.sh) | Check for trailing white space |
 |[ commit-name.sh ](https://github.com/JuliaLang/julia/blob/master/contrib/commit-name.sh) | Computes a version name for a commit |
diff --git a/contrib/add_license_to_files.jl b/contrib/add_license_to_files.jl
index 53a7e94ddfe38..64ced59076297 100644
--- a/contrib/add_license_to_files.jl
+++ b/contrib/add_license_to_files.jl
@@ -30,26 +30,30 @@ const excludedirs = [
 
 const skipfiles = [
     "../contrib/add_license_to_files.jl",
+    "../contrib/windows/juliarc.jl",
     # files to check - already copyright
-   # see: https://github.com/JuliaLang/julia/pull/11073#issuecomment-98099389
-   "../base/special/trig.jl",
-   "../base/sparse/csparse.jl",
-   "../base/linalg/givens.jl",
-   #
-   "../src/abi_llvm.cpp",
-   "../src/abi_win32.cpp",
-   "../src/abi_win64.cpp",
-   "../src/abi_x86.cpp",
-   "../src/abi_x86_64.cpp",
-   "../src/disasm.cpp",
-   "../src/support/END.h",
-   "../src/support/ENTRY.amd64.h",
-   "../src/support/ENTRY.i387.h",
-   "../src/support/MurmurHash3.c",
-   "../src/support/MurmurHash3.h",
-   "../src/support/asprintf.c",
-   "../src/support/strtod.c",
-   "../src/support/utf8.c",
+    # see: https://github.com/JuliaLang/julia/pull/11073#issuecomment-98099389
+    "../base/special/trig.jl",
+    "../base/sparse/csparse.jl",
+    "../base/linalg/givens.jl",
+    #
+    "../src/abi_llvm.cpp",
+    "../src/abi_win32.cpp",
+    "../src/abi_win64.cpp",
+    "../src/abi_x86.cpp",
+    "../src/abi_x86_64.cpp",
+    "../src/disasm.cpp",
+    "../src/jitlayers.cpp",
+    "../src/support/END.h",
+    "../src/support/ENTRY.amd64.h",
+    "../src/support/ENTRY.i387.h",
+    "../src/support/MurmurHash3.c",
+    "../src/support/MurmurHash3.h",
+    "../src/support/asprintf.c",
+    "../src/support/strptime.c",
+    "../src/support/strtod.c",
+    "../src/support/tzfile.h",
+    "../src/support/utf8.c",
 ]
 
 const ext_prefix = Dict([
diff --git a/contrib/build_executable.jl b/contrib/build_executable.jl
deleted file mode 100644
index 09b356eca8106..0000000000000
--- a/contrib/build_executable.jl
+++ /dev/null
@@ -1,278 +0,0 @@
-#!/usr/bin/env julia
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-# Builds an executable that doesn't require any julia source code.
-# The user needs to provide a julia script that contains a function main(),
-# taking no argument, which will be run when executing the
-# produced executable.
-
-# Note on packages:
-# Even if the script contains using statements, exported functions
-# will not be available in main(). Full qualification of names is
-# required. It's suggested to replace using statements with import
-# statements to produce a consistent result between running main() in
-# the REPL and running the executable.
-
-# Windows note:
-# gcc is required to compile the program. gcc can be installed using WinRPM.
-# $ Pkg.add("WinRPM")
-# $ using WinRPM
-# $ WinRPM.install("gcc")
-
-type Executable
-    name
-    filename
-    buildfile
-    targetfile
-    libjulia
-end
-
-function Executable(exename, targetdir, debug)
-    if debug
-        exename = exename * "-debug"
-    end
-    filename = exename
-    @windows_only filename = filename * ".exe"
-    buildfile = abspath(joinpath(JULIA_HOME, filename))
-    targetfile = targetdir == nothing ? buildfile : joinpath(targetdir, filename)
-    libjulia = debug ? "-ljulia-debug" : "-ljulia"
-
-    Executable(exename, filename, buildfile, targetfile, libjulia)
-end
-
-type SysFile
-    buildpath
-    buildfile
-    buildfile0
-end
-
-function SysFile(exename)
-    buildpath = abspath(dirname(Libdl.dlpath("libjulia")))
-    buildfile = joinpath(buildpath, "lib"*exename)
-    buildfile0 = joinpath(buildpath, "sys0")
-
-    SysFile(buildpath, buildfile, buildfile0)
-end
-
-function build_executable(exename, script_file, targetdir=nothing, cpu_target="native"; force=false)
-    julia = abspath(joinpath(JULIA_HOME, "julia"))
-    build_sysimg = abspath(joinpath(dirname(@__FILE__), "build_sysimg.jl"))
-
-    if targetdir != nothing
-        patchelf = find_patchelf()
-        if patchelf == nothing && !(OS_NAME == :Windows)
-            println("ERROR: Using the 'targetdir' option requires the 'patchelf' utility. Please install it.")
-            return 1
-        end
-    end
-
-    if !isfile(script_file)
-        println("ERROR: $(script_file) not found.")
-        return 1
-    end
-
-    tmpdir = mktempdir()
-    cfile = joinpath(tmpdir, "start_func.c")
-    userimgjl = joinpath(tmpdir, "userimg.jl")
-    script_file = abspath(script_file)
-
-    if targetdir != nothing
-        targetdir = abspath(targetdir)
-        if !isdir(targetdir)
-            println("ERROR: targetdir is not a directory.")
-            return 1
-        end
-    end
-
-    exe_release = Executable(exename, targetdir, false)
-    exe_debug   = Executable(exename, targetdir, true)
-    sys = SysFile(exename)
-
-    if !force
-        for f in [cfile, userimgjl, "$(sys.buildfile).$(Libdl.dlext)", "$(sys.buildfile).ji", exe_release.buildfile, exe_debug.buildfile]
-            if isfile(f)
-                println("ERROR: File '$(f)' already exists. Delete it or use --force.")
-                return 1
-            end
-        end
-
-        if targetdir != nothing && !isempty(readdir(targetdir))
-            println("ERROR: targetdir is not an empty diectory. Delete all contained files or use --force.")
-            return 1
-        end
-    end
-
-    emit_cmain(cfile, exename, targetdir != nothing)
-    emit_userimgjl(userimgjl, script_file)
-
-    println("running: $(julia) $(build_sysimg) $(sys.buildfile) $(cpu_target) $(userimgjl) --force")
-    run(`$(julia) $(build_sysimg) $(sys.buildfile) $(cpu_target) $(userimgjl) --force`)
-    println()
-
-    gcc = find_system_gcc()
-    # This argument is needed for the gcc, see issue #9973
-    win_arg = @windows ? `-D_WIN32_WINNT=0x0502` : ``
-    incs = get_includes()
-    ENV2 = deepcopy(ENV)
-    @windows_only begin
-        if contains(gcc, "WinRPM")
-            # This should not bee necessary, it is done due to WinRPM's gcc's
-            # include paths is not correct see WinRPM.jl issue #38
-            ENV2["PATH"] *= ";" * dirname(gcc)
-            push!(incs, "-I"*abspath(joinpath(dirname(gcc),"..","include")))
-        end
-    end
-
-    for exe in [exe_release, exe_debug]
-        println("running: $gcc -g -Wl,--no-as-needed $win_arg $(join(incs, " ")) $(cfile) -o $(exe.buildfile) -Wl,-rpath,$(sys.buildpath) -L$(sys.buildpath) $(exe.libjulia) -l$(exename)")
-        cmd = setenv(`$gcc -g -Wl,--no-as-needed $win_arg $(incs) $(cfile) -o $(exe.buildfile) -Wl,-rpath,$(sys.buildpath) -L$(sys.buildpath) $(exe.libjulia) -l$(exename)`, ENV2)
-        run(cmd)
-        println()
-    end
-
-    println("running: rm -rf $(tmpdir) $(sys.buildfile).o $(sys.buildfile0).o $(sys.buildfile0).ji")
-    map(f-> rm(f, recursive=true), [tmpdir, sys.buildfile*".o", sys.buildfile0*".o", sys.buildfile0*".ji"])
-    println()
-
-    if targetdir != nothing
-        # Move created files to target directory
-        for file in [exe_release.buildfile, exe_debug.buildfile, sys.buildfile*".$(Libdl.dlext)", sys.buildfile*".ji"]
-            mv(file,joinpath(targetdir, basename(file)))
-        end
-
-        # Copy needed shared libraries to the target directory
-        tmp = ".*\.$(Libdl.dlext).*"
-        shlibs = filter(Regex(tmp),readdir(sys.buildpath))
-        for shlib in shlibs
-            cp(joinpath(sys.buildpath, shlib), joinpath(targetdir, shlib))
-        end
-
-        @unix_only begin
-            # Fix rpath in executable and shared libraries
-            shlibs = filter(Regex(tmp),readdir(targetdir))
-            push!(shlibs, exe_release.filename)
-            push!(shlibs, exe_debug.filename)
-            println(shlibs)
-            for shlib in shlibs
-                rpath = readall(`$(patchelf) --print-rpath $(joinpath(targetdir, shlib))`)[1:end-1]
-                if Base.samefile(rpath, sys.buildpath)
-                    run(`$(patchelf) --set-rpath $(targetdir) $(joinpath(targetdir, shlib))`)
-                end
-            end
-        end
-    end
-
-    for exe in [exe_release, exe_debug]
-        println("$(exe.targetfile) successfully created.")
-    end
-    return 0
-end
-
-function find_patchelf()
-    for patchelf in [joinpath(JULIA_HOME, "patchelf"), "patchelf"]
-        try
-            if success(`$(patchelf) --version`)
-                return patchelf
-            end
-        end
-    end
-end
-
-function get_includes()
-    ret = []
-
-    # binary install
-    incpath = abspath(joinpath(JULIA_HOME, "..", "include", "julia"))
-    push!(ret, "-I$(incpath)")
-
-    # Git checkout
-    julia_root = abspath(joinpath(JULIA_HOME, "..", ".."))
-    push!(ret, "-I$(julia_root)src")
-    push!(ret, "-I$(julia_root)src/support")
-    push!(ret, "-I$(julia_root)usr/include")
-
-    ret
-end
-
-function emit_cmain(cfile, exename, relocation)
-    if relocation
-        sysji = joinpath("lib"*exename)
-    else
-        sysji = joinpath(dirname(Libdl.dlpath("libjulia")), "lib"*exename)
-    end
-    sysji = escape_string(sysji)
-    f = open(cfile, "w")
-    write( f, """
-        #include <julia.h>
-        #include <stdio.h>
-
-        int main(int argc, char *argv[])
-        {
-            char sysji[] = \"$(sysji).ji\";
-            char mainfunc[] = \"main()\";
-            jl_init_with_image(NULL, sysji);
-            jl_eval_string(mainfunc);
-
-            int ret = 0;
-            if (jl_exception_occurred())
-            {
-                jl_show(jl_stderr_obj(), jl_exception_occurred());
-                jl_printf(jl_stderr_stream(), \"\\n\");
-                ret = 1;
-            }
-
-            jl_atexit_hook();
-            return ret;
-        }
-        """
-    )
-    close(f)
-end
-
-function emit_userimgjl(userimgjl, script_file)
-    open(userimgjl, "w") do f
-        write( f, "include(\"$(escape_string(script_file))\")")
-    end
-end
-
-function find_system_gcc()
-    # On Windows, check to see if WinRPM is installed, and if so, see if gcc is installed
-    @windows_only try
-        require("WinRPM")
-        winrpmgcc = joinpath(WinRPM.installdir,"usr","$(Sys.ARCH)-w64-mingw32",
-            "sys-root","mingw","bin","gcc.exe")
-        if success(`$winrpmgcc --version`)
-            return winrpmgcc
-        end
-    end
-
-    # See if `gcc` exists
-    @unix_only try
-        if success(`gcc -v`)
-            return "gcc"
-        end
-    end
-
-    error( "GCC not found on system: " * @windows? "GCC can be installed via `Pkg.add(\"WinRPM\"); WinRPM.install(\"gcc\")`" : "" )
-end
-
-if !isinteractive()
-    if length(ARGS) < 2 || ("--help" in ARGS || "-h" in ARGS)
-        println("Usage: build_executable.jl <exename> <script_file> [targetdir] <cpu_target> [--help]")
-        println("   <exename>        is the filename of the resulting executable and the resulting sysimg")
-        println("   <script_file>    is the path to a jl file containing a main() function.")
-        println("   [targetdir]     (optional) is the path to a directory to put the executable and other")
-        println("   <cpu_target>     is an LLVM cpu target to build the system image against")
-        println("                    needed files into (default: julia directory structure)")
-        println("   --force          Set if you wish to overwrite existing files")
-        println("   --help           Print out this help text and exit")
-        println()
-        println(" Example:")
-        println("   julia build_executable.jl standalone_test hello_world.jl targetdir core2")
-        return 0
-    end
-
-    force_flag = "--force" in ARGS
-    filter!(x -> x != "--force", ARGS)
-    build_executable(ARGS..., force=force_flag)
-end
diff --git a/contrib/build_sysimg.jl b/contrib/build_sysimg.jl
index 3aad063b88516..e31c72d354efb 100644
--- a/contrib/build_sysimg.jl
+++ b/contrib/build_sysimg.jl
@@ -1,13 +1,22 @@
 #!/usr/bin/env julia
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-# Build a system image binary at sysimg_path.dlext.  By default, put the system image
-# next to libjulia (except on Windows, where it goes in $JULIA_HOME\..\lib\julia)
-# Allow insertion of a userimg via userimg_path.  If sysimg_path.dlext is currently loaded into memory,
-# don't continue unless force is set to true.  Allow targeting of a CPU architecture via cpu_target
-@unix_only const default_sysimg_path = joinpath(dirname(Libdl.dlpath("libjulia")),"sys")
-@windows_only const default_sysimg_path = joinpath(JULIA_HOME,"..","lib","julia","sys")
-function build_sysimg(sysimg_path=default_sysimg_path, cpu_target="native", userimg_path=nothing; force=false)
+# Build a system image binary at sysimg_path.dlext. Allow insertion of a userimg via
+# userimg_path.  If sysimg_path.dlext is currently loaded into memory, don't continue
+# unless force is set to true.  Allow targeting of a CPU architecture via cpu_target
+@unix_only function default_sysimg_path(debug=false)
+    splitext(Libdl.dlpath(debug ? "sys-debug" : "sys"))[1]
+end
+
+@windows_only function default_sysimg_path(debug=false)
+    joinpath(JULIA_HOME, "..", "lib", "julia", debug ? "sys-debug" : "sys")
+end
+
+function build_sysimg(sysimg_path=nothing, cpu_target="native", userimg_path=nothing; force=false, debug=false)
+    if sysimg_path == nothing
+        sysimg_path = default_sysimg_path(debug)
+    end
+
     # Quit out if a sysimg is already loaded and is in the same spot as sysimg_path, unless forcing
     sysimg = Libdl.dlopen_e("sys")
     if sysimg != C_NULL
@@ -25,8 +34,8 @@ function build_sysimg(sysimg_path=default_sysimg_path, cpu_target="native", user
     # Enter base/ and setup some useful paths
     base_dir = dirname(Base.find_source_file("sysimg.jl"))
     cd(base_dir) do
-        julia = joinpath(JULIA_HOME, "julia")
-        ld = find_system_linker()
+        julia = joinpath(JULIA_HOME, debug ? "julia-debug" : "julia")
+        cc = find_system_compiler()
 
         # Ensure we have write-permissions to wherever we're trying to write to
         try
@@ -39,8 +48,8 @@ function build_sysimg(sysimg_path=default_sysimg_path, cpu_target="native", user
 
         # Copy in userimg.jl if it exists...
         if userimg_path != nothing
-            if !isreadable(userimg_path)
-                error("$userimg_path is not readable, ensure it is an absolute path!")
+            if !isfile(userimg_path)
+                error("$userimg_path is not found, ensure it is an absolute path!")
             end
             if isfile("userimg.jl")
                 error("$base_dir/userimg.jl already exists, delete manually to continue.")
@@ -65,13 +74,13 @@ function build_sysimg(sysimg_path=default_sysimg_path, cpu_target="native", user
             println("$julia -C $cpu_target --output-ji $sysimg_path.ji --output-o $sysimg_path.o -J $inference_path.ji --startup-file=no sysimg.jl")
             run(`$julia -C $cpu_target --output-ji $sysimg_path.ji --output-o $sysimg_path.o -J $inference_path.ji --startup-file=no sysimg.jl`)
 
-            if ld != nothing
-                link_sysimg(sysimg_path, ld)
+            if cc != nothing
+                link_sysimg(sysimg_path, cc, debug)
             else
                 info("System image successfully built at $sysimg_path.ji")
             end
 
-            if !Base.samefile("$default_sysimg_path.ji", "$sysimg_path.ji")
+            if !Base.samefile("$(default_sysimg_path(debug)).ji", "$sysimg_path.ji")
                 if Base.isfile("$sysimg_path.$(Libdl.dlext)")
                     info("To run Julia with this image loaded, run: julia -J $sysimg_path.$(Libdl.dlext)")
                 else
@@ -89,18 +98,18 @@ function build_sysimg(sysimg_path=default_sysimg_path, cpu_target="native", user
     end
 end
 
-# Search for a linker to link sys.o into sys.dl_ext.  Honor LD environment variable.
-function find_system_linker()
-    if haskey( ENV, "LD" )
-        if !success(`$(ENV["LD"]) -v`)
-            warn("Using linker override $(ENV["LD"]), but unable to run `$(ENV["LD"]) -v`")
+# Search for a compiler to link sys.o into sys.dl_ext.  Honor LD environment variable.
+function find_system_compiler()
+    if haskey( ENV, "CC" )
+        if !success(`$(ENV["CC"]) -v`)
+            warn("Using compiler override $(ENV["CC"]), but unable to run `$(ENV["CC"]) -v`")
         end
-        return ENV["LD"]
+        return ENV["CC"]
     end
 
     # On Windows, check to see if WinRPM is installed, and if so, see if gcc is installed
     @windows_only try
-        require("WinRPM")
+        eval(Main, :(using WinRPM))
         winrpmgcc = joinpath(WinRPM.installdir,"usr","$(Sys.ARCH)-w64-mingw32",
             "sys-root","mingw","bin","gcc.exe")
         if success(`$winrpmgcc --version`)
@@ -113,52 +122,44 @@ function find_system_linker()
     end
 
 
-    # See if `ld` exists
+    # See if `cc` exists
     try
-        if success(`ld -v`)
-            return "ld"
+        if success(`cc -v`)
+            return "cc"
         end
     end
 
-    warn( "No supported linker found; startup times will be longer" )
+    warn( "No supported compiler found; startup times will be longer" )
 end
 
 # Link sys.o into sys.$(dlext)
-function link_sysimg(sysimg_path=default_sysimg_path, ld=find_system_linker())
-    julia_libdir = dirname(Libdl.dlpath("libjulia"))
+function link_sysimg(sysimg_path=nothing, cc=find_system_compiler(), debug=false)
+    if sysimg_path == nothing
+        sysimg_path = default_sysimg_path(debug)
+    end
+    julia_libdir = dirname(Libdl.dlpath(debug ? "libjulia-debug" : "libjulia"))
 
     FLAGS = ["-L$julia_libdir"]
-    if OS_NAME == :Darwin
-        push!(FLAGS, "-dylib")
-        push!(FLAGS, "-macosx_version_min")
-        push!(FLAGS, "10.7")
-    else
-        push!(FLAGS, "-shared")
-    end
-    push!(FLAGS, "-ljulia")
+
+    push!(FLAGS, "-shared")
+    push!(FLAGS, debug ? "-ljulia-debug" : "-ljulia")
     @windows_only push!(FLAGS, "-lssp")
 
     info("Linking sys.$(Libdl.dlext)")
-    run(`$ld $FLAGS -o $sysimg_path.$(Libdl.dlext) $sysimg_path.o`)
+    run(`$cc $FLAGS -o $sysimg_path.$(Libdl.dlext) $sysimg_path.o`)
 
     info("System image successfully built at $sysimg_path.$(Libdl.dlext)")
-    @windows_only begin
-        if convert(VersionNumber, Base.libllvm_version) < v"3.5.0"
-            LLVM_msg = "Building sys.dll on Windows against LLVM < 3.5.0 can cause incorrect backtraces!"
-            LLVM_msg *= " Delete generated sys.dll to avoid these problems"
-            warn( LLVM_msg )
-        end
-    end
 end
 
 # When running this file as a script, try to do so with default values.  If arguments are passed
 # in, use them as the arguments to build_sysimg above
 if !isinteractive()
-    if length(ARGS) > 4 || ("--help" in ARGS || "-h" in ARGS)
-        println("Usage: build_sysimg.jl <sysimg_path> <cpu_target> <usrimg_path.jl> [--force] [--help]")
+    if length(ARGS) > 5 || ("--help" in ARGS || "-h" in ARGS)
+        println("Usage: build_sysimg.jl <sysimg_path> <cpu_target> <usrimg_path.jl> [--force] [--debug] [--help]")
         println("   <sysimg_path>    is an absolute, extensionless path to store the system image at")
         println("   <cpu_target>     is an LLVM cpu target to build the system image against")
         println("   <usrimg_path.jl> is the path to a user image to be baked into the system image")
+        println("   --debug          Using julia-debug instead of julia to build the system image")
         println("   --force          Set if you wish to overwrite the default system image")
         println("   --help           Print out this help text and exit")
         println()
@@ -166,11 +167,13 @@ if !isinteractive()
         println("   build_sysimg.jl /usr/local/lib/julia/sys core2 ~/my_usrimg.jl --force")
         println()
         println(" Running this script with no arguments is equivalent to:")
-        println("   build_sysimg.jl $(default_sysimg_path) native")
+        println("   build_sysimg.jl $(default_sysimg_path()) native")
         return 0
     end
 
+    debug_flag = "--debug" in ARGS
+    filter!(x -> x != "--debug", ARGS)
     force_flag = "--force" in ARGS
     filter!(x -> x != "--force", ARGS)
-    build_sysimg(ARGS..., force=force_flag)
+    build_sysimg(ARGS...; force=force_flag, debug=debug_flag)
 end
diff --git a/contrib/check-whitespace.sh b/contrib/check-whitespace.sh
index ddbd3dda16bc8..cdb843c6fa876 100755
--- a/contrib/check-whitespace.sh
+++ b/contrib/check-whitespace.sh
@@ -5,6 +5,7 @@
 # report an error if so
 
 # Files to check:
+set -f # disable glob expansion in this script
 file_patterns='
 *.1
 *.c
diff --git a/contrib/julia-config.jl b/contrib/julia-config.jl
index f8415f249f249..53c8538d6a09d 100755
--- a/contrib/julia-config.jl
+++ b/contrib/julia-config.jl
@@ -51,6 +51,7 @@ end
 function cflags()
     arg1 = replace(initDir(),"\\","\\\\\\\\");
     arg2 = replace(includeDir(),"\\","\\\\");
+    @unix_only return """-fPIC -DJULIA_INIT_DIR=\\"$arg1\\" -I$arg2""";
     return """-DJULIA_INIT_DIR=\\"$arg1\\" -I$arg2""";
 end
 
diff --git a/contrib/julia-mode-tests.el b/contrib/julia-mode-tests.el
new file mode 100644
index 0000000000000..bd57f17cb8466
--- /dev/null
+++ b/contrib/julia-mode-tests.el
@@ -0,0 +1,298 @@
+;;; julia-mode-tests.el --- Tests for julia-mode.el
+
+;; Copyright (C) 2009-2014 Julia contributors
+;; URL: https://github.com/JuliaLang/julia
+;; Version: 0.3
+;; Keywords: languages
+
+;;; Usage:
+
+;; From command line:
+;;
+;; emacs -batch -L . -l ert -l julia-mode-tests.el -f  ert-run-tests-batch-and-exit
+
+;;; Commentary:
+;; Contains ert tests for julia-mode.el
+
+;;; License:
+;; Permission is hereby granted, free of charge, to any person obtaining
+;; a copy of this software and associated documentation files (the
+;; "Software"), to deal in the Software without restriction, including
+;; without limitation the rights to use, copy, modify, merge, publish,
+;; distribute, sublicense, and/or sell copies of the Software, and to
+;; permit persons to whom the Software is furnished to do so, subject to
+;; the following conditions:
+;;
+;; The above copyright notice and this permission notice shall be
+;; included in all copies or substantial portions of the Software.
+;;
+;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+;;; Code:
+
+;; We can't use cl-lib whilst supporting Emacs 23 users who don't use
+;; ELPA.
+(with-no-warnings
+  (require 'cl)) ;; incf, decf, plusp
+
+(require 'julia-mode)
+(require 'ert)
+
+(defmacro julia--should-indent (from to)
+  "Assert that we indent text FROM producing text TO in `julia-mode'."
+  `(with-temp-buffer
+     (let ((julia-indent-offset 4))
+       (julia-mode)
+       (insert ,from)
+       (indent-region (point-min) (point-max))
+       (should (equal (buffer-substring-no-properties (point-min) (point-max))
+                      ,to)))))
+
+
+(ert-deftest julia--test-indent-if ()
+  "We should indent inside if bodies."
+  (julia--should-indent
+     "
+if foo
+bar
+end"
+     "
+if foo
+    bar
+end"))
+
+(ert-deftest julia--test-indent-else ()
+  "We should indent inside else bodies."
+  (julia--should-indent
+     "
+if foo
+    bar
+else
+baz
+end"
+     "
+if foo
+    bar
+else
+    baz
+end"))
+
+(ert-deftest julia--test-indent-toplevel ()
+  "We should not indent toplevel expressions. "
+  (julia--should-indent
+     "
+foo()
+bar()"
+     "
+foo()
+bar()"))
+
+(ert-deftest julia--test-indent-nested-if ()
+  "We should indent for each level of indentation."
+  (julia--should-indent
+     "
+if foo
+    if bar
+bar
+    end
+end"
+     "
+if foo
+    if bar
+        bar
+    end
+end"))
+
+(ert-deftest julia--test-indent-module-keyword ()
+  "Module should not increase indentation at any level."
+  (julia--should-indent
+   "
+module
+begin
+    a = 1
+end
+end"
+   "
+module
+begin
+    a = 1
+end
+end")
+  (julia--should-indent
+   "
+begin
+module
+foo
+end
+end"
+   "
+begin
+    module
+    foo
+    end
+end"))
+
+(ert-deftest julia--test-indent-function ()
+  "We should indent function bodies."
+  (julia--should-indent
+     "
+function foo()
+bar
+end"
+     "
+function foo()
+    bar
+end"))
+
+(ert-deftest julia--test-indent-begin ()
+  "We should indent after a begin keyword."
+  (julia--should-indent
+     "
+@async begin
+bar
+end"
+     "
+@async begin
+    bar
+end"))
+
+(ert-deftest julia--test-indent-paren ()
+  "We should indent to line up with the text after an open paren."
+  (julia--should-indent
+     "
+foobar(bar,
+baz)"
+     "
+foobar(bar,
+       baz)"))
+
+(ert-deftest julia--test-indent-paren-space ()
+  "We should indent to line up with the text after an open
+paren, even if there are additional spaces."
+  (julia--should-indent
+     "
+foobar( bar,
+baz )"
+     "
+foobar( bar,
+        baz )"))
+
+(ert-deftest julia--test-indent-equals ()
+  "We should increase indent on a trailing =."
+  (julia--should-indent
+     "
+foo() =
+bar"
+     "
+foo() =
+    bar"))
+
+(ert-deftest julia--test-indent-operator ()
+  "We should increase indent after the first trailing operator
+but not again after that."
+  (julia--should-indent
+   "
+foo() |>
+bar |>
+baz
+qux"
+   "
+foo() |>
+    bar |>
+    baz
+qux"))
+
+(ert-deftest julia--test-indent-ignores-blank-lines ()
+  "Blank lines should not affect indentation of non-blank lines."
+  (julia--should-indent
+     "
+if foo
+        
+bar
+end"
+     "
+if foo
+    
+    bar
+end"))
+
+(ert-deftest julia--test-indent-comment-equal ()
+  "`=` at the end of comment should not increase indent level."
+  (julia--should-indent
+     "
+# a =
+# b =
+c"
+     "
+# a =
+# b =
+c"))
+
+(ert-deftest julia--test-indent-leading-paren ()
+  "`(` at the beginning of a line should not affect indentation."
+  (julia--should-indent
+     "
+\(1)"
+     "
+\(1)"))
+
+(ert-deftest julia--test-top-level-following-paren-indent ()
+  "`At the top level, a previous line indented due to parens should not affect indentation."
+  (julia--should-indent
+     "y1 = f(x,
+       z)
+y2 = g(x)"
+     "y1 = f(x,
+       z)
+y2 = g(x)"))
+
+(ert-deftest julia--test-indentation-of-multi-line-strings ()
+  "Indentation should only affect the first line of a multi-line string."
+    (julia--should-indent
+     "   a = \"\"\"
+    description
+begin
+    foo
+bar
+end
+\"\"\""
+     "a = \"\"\"
+    description
+begin
+    foo
+bar
+end
+\"\"\""))
+
+(ert-deftest julia--test-indent-of-end-in-brackets ()
+  "Ignore end keyword in brackets for the purposes of indenting blocks."
+  (julia--should-indent
+   "begin
+    begin
+        arr[1: end - 1]
+        end
+end"
+   "begin
+    begin
+        arr[1: end - 1]
+    end
+end"))
+
+(defun julia--run-tests ()
+  (interactive)
+  (if (featurep 'ert)
+      (ert-run-tests-interactively "julia--test")
+    (message "Can't run julia-mode-tests because ert is not available.")))
+
+(provide 'julia-mode-tests)
+;; Local Variables:
+;; coding: utf-8
+;; byte-compile-warnings: (not obsolete)
+;; End:
+;;; julia-mode-tests.el ends here
diff --git a/contrib/julia-mode.el b/contrib/julia-mode.el
index bd5e792ac85c4..bf365a4ccfead 100644
--- a/contrib/julia-mode.el
+++ b/contrib/julia-mode.el
@@ -131,6 +131,71 @@ This function provides equivalent functionality, but makes no efforts to optimis
              "\\\\"))
         (group "'"))))
 
+(defconst julia-hanging-operator-regexp
+  ;; taken from julia-parser.scm
+  (concat "^[^#\n]+ "
+          (regexp-opt
+           '( ;; conditional
+             "?"
+             ;; assignment
+             "=" ":=" "+=" "-=" "*=" "/=" "//=" ".//=" ".*=" "./=" "\\=" ".\\="
+             "^=" ".^=" "÷=" ".÷=" "%=" ".%=" "|=" "&=" "$=" "=>" "<<=" ">>="
+             ">>>=" "~" ".+=" ".-="
+             ;; arrow
+             "--" "-->" "←" "→" "↔" "↚" "↛" "↠" "↣" "↦" "↮" "⇎" "⇏" "⇒" "⇔" "⇴"
+             "⇶" "⇷" "⇸" "⇹" "⇺" "⇻" "⇼" "⇽" "⇾" "⇿" "⟵" "⟶" "⟷" "⟷" "⟹"
+             "⟺" "⟻" "⟼" "⟽" "⟾" "⟿" "⤀" "⤁" "⤂" "⤃" "⤄" "⤅" "⤆" "⤇" "⤌"
+             "⤍" "⤎" "⤏" "⤐" "⤑" "⤔" "⤕" "⤖" "⤗" "⤘" "⤝" "⤞" "⤟" "⤠" "⥄" "⥅"
+             "⥆" "⥇" "⥈" "⥊" "⥋" "⥎" "⥐" "⥒" "⥓" "⥖" "⥗" "⥚" "⥛" "⥞" "⥟" "⥢"
+             "⥤" "⥦" "⥧" "⥨" "⥩" "⥪" "⥫" "⥬" "⥭" "⥰" "⧴" "⬱" "⬰" "⬲" "⬳" "⬴"
+             "⬵" "⬶" "⬷" "⬸" "⬹" "⬺" "⬻" "⬼" "⬽" "⬾" "⬿" "⭀" "⭁" "⭂" "⭃" "⭄"
+             "⭇" "⭈" "⭉" "⭊" "⭋" "⭌" "￩" "￫"
+             ;; or and and
+             "&&" "||"
+             ;; comparison
+             ">" "<" ">=" "≥" "<=" "≤" "==" "===" "≡" "!=" "≠" "!==" "≢" ".>"
+             ".<" ".>=" ".≥" ".<=" ".≤" ".==" ".!=" ".≠" ".=" ".!" "<:" ">:" "∈"
+             "∉" "∋" "∌" "⊆" "⊈" "⊂" "⊄" "⊊" "∝" "∊" "∍" "∥" "∦" "∷" "∺" "∻" "∽"
+             "∾" "≁" "≃" "≄" "≅" "≆" "≇" "≈" "≉" "≊" "≋" "≌" "≍" "≎" "≐" "≑" "≒"
+             "≓" "≔" "≕" "≖" "≗" "≘" "≙" "≚" "≛" "≜" "≝" "≞" "≟" "≣" "≦" "≧" "≨"
+             "≩" "≪" "≫" "≬" "≭" "≮" "≯" "≰" "≱" "≲" "≳" "≴" "≵" "≶" "≷" "≸" "≹"
+             "≺" "≻" "≼" "≽" "≾" "≿" "⊀" "⊁" "⊃" "⊅" "⊇" "⊉" "⊋" "⊏" "⊐" "⊑" "⊒"
+             "⊜" "⊩" "⊬" "⊮" "⊰" "⊱" "⊲" "⊳" "⊴" "⊵" "⊶" "⊷" "⋍" "⋐" "⋑" "⋕" "⋖"
+             "⋗" "⋘" "⋙" "⋚" "⋛" "⋜" "⋝" "⋞" "⋟" "⋠" "⋡" "⋢" "⋣" "⋤" "⋥" "⋦" "⋧"
+             "⋨" "⋩" "⋪" "⋫" "⋬" "⋭" "⋲" "⋳" "⋴" "⋵" "⋶" "⋷" "⋸" "⋹" "⋺" "⋻" "⋼"
+             "⋽" "⋾" "⋿" "⟈" "⟉" "⟒" "⦷" "⧀" "⧁" "⧡" "⧣" "⧤" "⧥" "⩦" "⩧" "⩪" "⩫"
+             "⩬" "⩭" "⩮" "⩯" "⩰" "⩱" "⩲" "⩳" "⩴" "⩵" "⩶" "⩷" "⩸" "⩹" "⩺" "⩻" "⩼"
+             "⩽" "⩾" "⩿" "⪀" "⪁" "⪂" "⪃" "⪄" "⪅" "⪆" "⪇" "⪈" "⪉" "⪊" "⪋" "⪌" "⪍"
+             "⪎" "⪏" "⪐" "⪑" "⪒" "⪓" "⪔" "⪕" "⪖" "⪗" "⪘" "⪙" "⪚" "⪛" "⪜" "⪝" "⪞"
+             "⪟" "⪠" "⪡" "⪢" "⪣" "⪤" "⪥" "⪦" "⪧" "⪨" "⪩" "⪪" "⪫" "⪬" "⪭" "⪮" "⪯"
+             "⪰" "⪱" "⪲" "⪳" "⪴" "⪵" "⪶" "⪷" "⪸" "⪹" "⪺" "⪻" "⪼" "⪽" "⪾" "⪿" "⫀"
+             "⫁" "⫂" "⫃" "⫄" "⫅" "⫆" "⫇" "⫈" "⫉" "⫊" "⫋" "⫌" "⫍" "⫎" "⫏" "⫐" "⫑"
+             "⫒" "⫓" "⫔" "⫕" "⫖" "⫗" "⫘" "⫙" "⫷" "⫸" "⫹" "⫺" "⊢" "⊣"
+             ;; pipe, colon
+             "|>" "<|" ":" ".."
+             ;; plus
+             "+" "-" "⊕" "⊖" "⊞" "⊟" ".+" ".-" "++" "|" "∪" "∨" "$" "⊔" "±" "∓"
+             "∔" "∸" "≂" "≏" "⊎" "⊻" "⊽" "⋎" "⋓" "⧺" "⧻" "⨈" "⨢" "⨣" "⨤" "⨥" "⨦"
+             "⨧" "⨨" "⨩" "⨪" "⨫" "⨬" "⨭" "⨮" "⨹" "⨺" "⩁" "⩂" "⩅" "⩊" "⩌" "⩏" "⩐"
+             "⩒" "⩔" "⩖" "⩗" "⩛" "⩝" "⩡" "⩢" "⩣"
+             ;; bitshift
+             "<<" ">>" ">>>" ".<<" ".>>" ".>>>"
+             ;; times
+             "*" "/" "./" "÷" ".÷" "%" "⋅" "∘" "×" ".%" ".*" "\\"
+             ".\\" "&" "∩" "∧" "⊗" "⊘" "⊙" "⊚" "⊛" "⊠" "⊡" "⊓" "∗" "∙" "∤" "⅋"
+             "≀" "⊼" "⋄" "⋆" "⋇" "⋉" "⋊" "⋋" "⋌" "⋏" "⋒" "⟑" "⦸" "⦼" "⦾" "⦿" "⧶"
+             "⧷" "⨇" "⨰" "⨱" "⨲" "⨳" "⨴" "⨵" "⨶" "⨷" "⨸" "⨻" "⨼" "⨽" "⩀" "⩃" "⩄"
+             "⩋" "⩍" "⩎" "⩑" "⩓" "⩕" "⩘" "⩚" "⩜" "⩞" "⩟" "⩠" "⫛" "⊍" "▷" "⨝" "⟕"
+             "⟖" "⟗"
+             ;; rational
+             "//" ".//"
+             ;; power
+             "^" ".^" "↑" "↓" "⇵" "⟰" "⟱" "⤈" "⤉" "⤊" "⤋" "⤒" "⤓" "⥉" "⥌" "⥍"
+             "⥏" "⥑" "⥔" "⥕" "⥘" "⥙" "⥜" "⥝" "⥠" "⥡" "⥣" "⥥" "⥮" "⥯" "￪" "￬"
+             ;; decl, dot
+             "::" "."))
+          (regexp-opt '(" #" " \n" "#" "\n"))))
+
 (defconst julia-triple-quoted-string-regex
   ;; We deliberately put a group on the first and last delimiter, so
   ;; we can mark these as string delimiters for font-lock.
@@ -258,7 +323,11 @@ This function provides equivalent functionality, but makes no efforts to optimis
 
 (defconst julia-block-start-keywords
   (list "if" "while" "for" "begin" "try" "function" "type" "let" "macro"
-        "quote" "do" "immutable"))
+        "quote" "do" "immutable" "module"))
+
+;; For keywords that begin a block without additional indentation
+(defconst julia-block-start-keywords-no-indent
+  (list "module"))
 
 (defconst julia-block-end-keywords
   (list "end" "else" "elseif" "catch" "finally"))
@@ -332,12 +401,13 @@ As a result, it is true inside \"foo\", `foo` and 'f'."
 (defun julia-at-keyword (kw-list)
   "Return the word at point if it matches any keyword in KW-LIST.
 KW-LIST is a list of strings.  The word at point is not considered
-a keyword if used as a field name, X.word, or quoted, :word."
+a keyword if used as a field name, X.word, or quoted, :word.
+
+Assumes that point is not inside a comment."
   (and (or (= (point) 1)
 	   (and (not (equal (char-before (point)) ?.))
 		(not (equal (char-before (point)) ?:))))
        (member (current-word t) kw-list)
-       (not (julia-in-comment))
        ;; 'end' is not a keyword when used for indexing, e.g. foo[end-2]
        (or (not (equal (current-word t) "end"))
            (not (julia-in-brackets)))))
@@ -357,9 +427,7 @@ Do not move back beyond position MIN."
         (setq count
               (cond ((julia-at-keyword julia-block-start-keywords)
                      (+ count 1))
-                    ;; fixme: breaks on strings
-                    ((and (equal (current-word t) "end")
-                          (not (julia-in-comment)) (not (julia-in-brackets)))
+                    ((equal (current-word t) "end")
                      (- count 1))
                     (t count))))
       (if (> count 0)
@@ -383,13 +451,6 @@ beginning of the buffer."
   (unless (eq (point) (point-min))
     (backward-char)))
 
-(defvar julia-max-paren-lookback 400
-  "When indenting, don't look back more than this
-many characters to see if there are unclosed parens.
-
-This variable has a major effect on indent performance if set too
-high.")
-
 (defvar julia-max-block-lookback 5000
   "When indenting, don't look back more than this
 many characters to see if there are unclosed blocks.
@@ -402,237 +463,113 @@ high.")
 containing paren before point, so we can align succeeding code
 with it. Returns nil if we're not within nested parens."
   (save-excursion
-    ;; Back up to previous line (beginning-of-line was already called)
-    (backward-char)
-    (let ((min-pos (max (- (point) julia-max-paren-lookback)
-                        (point-min)))
-          (open-count 0))
-      (while (and (> (point) min-pos)
-                  (not (plusp open-count)))
-
-        (when (looking-at (rx (any "[" "]" "(" ")")))
-          (unless (or (julia-in-string) (julia-in-comment))
-            (cond ((looking-at (rx (any "[" "(")))
-                   (incf open-count))
-                  ((looking-at (rx (any "]" ")")))
-                   (decf open-count)))))
-
-        (julia--safe-backward-char))
-
-      (if (plusp open-count)
-          (progn (forward-char 2)
-                 (while (looking-at (rx blank))
-                   (forward-char))
-                 (current-column))
-        nil))))
+    (beginning-of-line)
+    (let ((parser-state (syntax-ppss)))
+      (cond ((nth 3 parser-state) nil)       ;; strings
+            ((= (nth 0 parser-state) 0) nil) ;; top level
+            (t
+             (ignore-errors ;; return nil if any of these movements fail
+               (backward-up-list)
+               (forward-char)
+               (skip-syntax-forward " ")
+               (current-column)))))))
+
+(defun julia-prev-line-skip-blank-or-comment ()
+  "Move point to beginning of previous line skipping blank lines
+and lines including only comments. Returns number of lines moved.
+A return of -1 signals that we moved to the first line of
+the (possibly narrowed) buffer, so there is nowhere else to go."
+  (catch 'result
+    (let ((moved 0) this-move)
+      (while t
+        (setq this-move (forward-line -1))
+        (cond
+         ;; moved into comment or blank
+         ((and (= 0 this-move)
+               (or (looking-at-p "^\\s-*\\(?:#.*\\)*$")
+                   (julia-in-comment)))
+          (incf moved))
+         ;; success
+         ((= 0 this-move)
+          (throw 'result (1+ moved)))
+         ;; on first line and in comment
+         ((and (bobp)
+               (or (looking-at-p "^\\s-*\\(?:#.*\\)*$")
+                   (julia-in-comment)))
+          (throw 'result -1))
+         ((bobp)
+          (throw 'result moved))
+         (t
+          (throw 'result 0)))))))
+
+(defun julia-indent-hanging ()
+  "Calculate indentation for lines that follow \"hanging\"
+operators (operators that end the previous line) as defined in
+`julia-hanging-operator-regexp'. An assignment operator ending
+the previous line increases the indent as do the other operators
+unless another operator is found two lines up. Previous line
+means previous line after skipping blank lines and lines with
+only comments."
+  (let (prev-indent)
+    (save-excursion
+      (when (> (julia-prev-line-skip-blank-or-comment) 0)
+        (setq prev-indent (current-indentation))
+        (when (looking-at-p julia-hanging-operator-regexp)
+          (if (and (> (julia-prev-line-skip-blank-or-comment) 0)
+                   (looking-at-p julia-hanging-operator-regexp))
+              ;; two preceding hanging operators => indent same as line
+              ;; above
+              prev-indent
+            ;; one preceding hanging operator => increase indent from line
+            ;; above
+            (+ julia-indent-offset prev-indent)))))))
+
+(defun julia-indent-in-string ()
+  "Indentation inside strings with newlines is \"manual\",
+meaning always increase indent on TAB and decrease on S-TAB."
+  (save-excursion
+    (beginning-of-line)
+    (when (julia-in-string)
+      (if (member this-command '(julia-latexsub-or-indent
+                                 ess-indent-or-complete))
+          (+ julia-indent-offset (current-indentation))
+        ;; return the current indentation to prevent other functions from
+        ;; indenting inside strings
+        (current-indentation)))))
 
 (defun julia-indent-line ()
   "Indent current line of julia code."
   (interactive)
   (let* ((point-offset (- (current-column) (current-indentation))))
-    (end-of-line)
     (indent-line-to
      (or
-      ;; If we're inside an open paren, indent to line up arguments.
-      (save-excursion
-        (beginning-of-line)
-        (ignore-errors (julia-paren-indent)))
-      ;; If the previous line ends in =, increase the indent.
-      (ignore-errors ; if previous line is (point-min)
-        (save-excursion
-          (if (and (not (equal (point-min) (line-beginning-position)))
-                   (progn
-                     (forward-line -1)
-                     (end-of-line) (backward-char 1)
-                     (and (equal (char-after (point)) ?=)
-                          (not (julia-in-comment)))))
-              (+ julia-indent-offset (current-indentation))
-            nil)))
+      ;; note: if this first function returns nil the beginning of the line
+      ;; cannot be in a string
+      (julia-indent-in-string)
+      ;; If we're inside an open paren, indent to line up arguments. After this,
+      ;; we cannot be inside parens which includes brackets
+      (julia-paren-indent)
+      ;; indent due to hanging operators (lines ending in an operator)
+      (julia-indent-hanging)
       ;; Indent according to how many nested blocks we are in.
       (save-excursion
         (beginning-of-line)
+        ;; jump out of any comments
+        (let ((state (syntax-ppss)))
+          (when (nth 4 state)
+            (goto-char (nth 8 state))))
         (forward-to-indentation 0)
         (let ((endtok (julia-at-keyword julia-block-end-keywords))
               (last-open-block (julia-last-open-block (- (point) julia-max-block-lookback))))
           (max 0 (+ (or last-open-block 0)
-                    (if endtok (- julia-indent-offset) 0)))))))
+                    (if (or endtok
+                            (julia-at-keyword julia-block-start-keywords-no-indent))
+                        (- julia-indent-offset) 0)))))))
     ;; Point is now at the beginning of indentation, restore it
     ;; to its original position (relative to indentation).
     (when (>= point-offset 0)
       (move-to-column (+ (current-indentation) point-offset)))))
 
-(defmacro julia--should-indent (from to)
-  "Assert that we indent text FROM producing text TO in `julia-mode'."
-  `(with-temp-buffer
-     (let ((julia-indent-offset 4))
-       (julia-mode)
-       (insert ,from)
-       (indent-region (point-min) (point-max))
-       (should (equal (buffer-substring-no-properties (point-min) (point-max))
-                      ,to)))))
-
-;; Emacs 23.X doesn't include ert, so we ignore any errors that occur
-;; when we define tests.
-(ignore-errors
-  (require 'ert)
-
-  (ert-deftest julia--test-indent-if ()
-    "We should indent inside if bodies."
-    (julia--should-indent
-     "
-if foo
-bar
-end"
-     "
-if foo
-    bar
-end"))
-
-  (ert-deftest julia--test-indent-else ()
-    "We should indent inside else bodies."
-    (julia--should-indent
-     "
-if foo
-    bar
-else
-baz
-end"
-     "
-if foo
-    bar
-else
-    baz
-end"))
-
-  (ert-deftest julia--test-indent-toplevel ()
-    "We should not indent toplevel expressions. "
-    (julia--should-indent
-     "
-foo()
-bar()"
-     "
-foo()
-bar()"))
-
-  (ert-deftest julia--test-indent-nested-if ()
-    "We should indent for each level of indentation."
-    (julia--should-indent
-     "
-if foo
-    if bar
-bar
-    end
-end"
-     "
-if foo
-    if bar
-        bar
-    end
-end"))
-
-  (ert-deftest julia--test-indent-function ()
-    "We should indent function bodies."
-    (julia--should-indent
-     "
-function foo()
-bar
-end"
-     "
-function foo()
-    bar
-end"))
-
-  (ert-deftest julia--test-indent-begin ()
-    "We should indent after a begin keyword."
-    (julia--should-indent
-     "
-@async begin
-bar
-end"
-     "
-@async begin
-    bar
-end"))
-
-  (ert-deftest julia--test-indent-paren ()
-    "We should indent to line up with the text after an open paren."
-    (julia--should-indent
-     "
-foobar(bar,
-baz)"
-     "
-foobar(bar,
-       baz)"))
-
-  (ert-deftest julia--test-indent-paren-space ()
-    "We should indent to line up with the text after an open
-paren, even if there are additional spaces."
-    (julia--should-indent
-     "
-foobar( bar,
-baz )"
-     "
-foobar( bar,
-        baz )"))
-
-  (ert-deftest julia--test-indent-equals ()
-    "We should increase indent on a trailing =."
-    (julia--should-indent
-     "
-foo() =
-bar"
-     "
-foo() =
-    bar"))
-
-  (ert-deftest julia--test-indent-ignores-blank-lines ()
-    "Blank lines should not affect indentation of non-blank lines."
-    (julia--should-indent
-     "
-if foo
-        
-bar
-end"
-     "
-if foo
-    
-    bar
-end"))
-
-  (ert-deftest julia--test-indent-comment-equal ()
-    "`=` at the end of comment should not increase indent level."
-    (julia--should-indent
-     "
-# a =
-# b =
-c"
-     "
-# a =
-# b =
-c"))
-
-  (ert-deftest julia--test-indent-leading-paren ()
-    "`(` at the beginning of a line should not affect indentation."
-    (julia--should-indent
-     "
-(1)"
-     "
-(1)"))
-
-  (ert-deftest julia--test-top-level-following-paren-indent ()
-    "`At the top level, a previous line indented due to parens should not affect indentation."
-    (julia--should-indent
-     "y1 = f(x,
-       z)
-y2 = g(x)"
-     "y1 = f(x,
-       z)
-y2 = g(x)"))
-
-  (defun julia--run-tests ()
-    (interactive)
-    (ert-run-tests-interactively "julia--test")))
-
 (defalias 'julia-mode-prog-mode
   (if (fboundp 'prog-mode)
       'prog-mode
@@ -685,6 +622,14 @@ y2 = g(x)"))
   (setq imenu-generic-expression julia-imenu-generic-expression)
   (imenu-add-to-menubar "Imenu"))
 
+(defun julia-manual-deindent ()
+  "Deindent by `julia-indent-offset' regardless of current
+indentation context. To be used to manually indent inside
+strings."
+  (interactive)
+  (indent-line-to (max 0 (- (current-indentation) julia-indent-offset))))
+(define-key julia-mode-map (kbd "<backtab>") 'julia-manual-deindent)
+
 (defvar julia-latexsubs (make-hash-table :test 'equal))
 
 (defun julia-latexsub ()
@@ -3202,7 +3147,7 @@ y2 = g(x)"))
   :type 'string
   :group 'julia)
 
-(defvar julia-prompt-regexp "julia>"
+(defvar julia-prompt-regexp "^\\w*> "
   "Regexp for matching `inferior-julia' prompt.")
 
 (defvar inferior-julia-mode-map
diff --git a/contrib/julia.lang b/contrib/julia.lang
index c57e0e096e789..0e93bfbddbff0 100644
--- a/contrib/julia.lang
+++ b/contrib/julia.lang
@@ -288,7 +288,7 @@
       <keyword>InetAddr</keyword>
       <keyword>IpAddr|IPv[46]</keyword>
       <keyword>(Key|Value)Iterator</keyword>
-      <keyword>LambdaStaticData</keyword>
+      <keyword>LambdaInfo</keyword>
       <keyword>LocalProcess</keyword>
       <keyword>Long(Expr|Symbol|Tuple)</keyword>
       <keyword>MersenneTwister</keyword>
diff --git a/contrib/julia.xml b/contrib/julia.xml
index 587841cdc657d..d068b9a56ec38 100644
--- a/contrib/julia.xml
+++ b/contrib/julia.xml
@@ -113,7 +113,6 @@
       <item> Exception </item>
       <item> Expr </item>
       <item> FileMonitor </item>
-      <item> FileOffset </item>
       <item> Filter </item>
       <item> AbstractFloat </item>
       <item> Float16 </item>
@@ -252,7 +251,6 @@
       <item> Culonglong </item>
       <item> Cintmax_t </item>
       <item> Cuintmax_t </item>
-      <item> Coff_t </item>
       <item> Cfloat </item>
       <item> Cdouble </item>
       <item> Cwchar_t </item>
diff --git a/contrib/mac/app/Makefile b/contrib/mac/app/Makefile
index 90ae14e829222..1a10ce5def3ed 100644
--- a/contrib/mac/app/Makefile
+++ b/contrib/mac/app/Makefile
@@ -2,19 +2,35 @@
 # You may have to wipe your openblas build to ensure that it is built
 # with support for all architectures, or else performance may suffer.
 
-JULIAHOME = $(abspath ../../..)
+JULIAHOME := $(abspath ../../..)
 include ../../../Make.inc
 
-JULIA_PKGDIR=$(shell echo $$JULIA_PKGDIR)
+JULIA_PKGDIR:=$(shell echo $$JULIA_PKGDIR)
 ifeq ($(JULIA_PKGDIR),)
-	JULIA_PKGDIR=$(shell echo ~)/.julia
+	JULIA_PKGDIR:=$(shell echo ~)/.julia
 endif
 
-VERSION_SUFFIX=$(shell [ $$(git describe --tags --exact-match 2>/dev/null) ] && echo $(JULIA_VERSION) || echo $(JULIA_VERSION)-$(JULIA_COMMIT))
+# X.Y.Z or X.Y.Z-hash
+DMG_VERSION_SUFFIX:=$(shell [ $$(git describe --tags --exact-match 2>/dev/null) ] && echo $(JULIA_VERSION) || echo $(JULIA_VERSION)-$(JULIA_COMMIT))
 
-all: clean dmg
+# X.Y
+APP_VERSION_SUFFIX:=$(shell echo $(JULIA_VERSION) | grep -o '^[0-9]\+.[0-9]\+')
 
-dmg:
+DMG_NAME:=Julia-$(DMG_VERSION_SUFFIX).dmg
+APP_NAME:=Julia-$(APP_VERSION_SUFFIX).app
+VOL_NAME:=Julia-$(DMG_VERSION_SUFFIX)
+
+all: clean $(DMG_NAME)
+
+$(DMG_NAME): dmg/$(APP_NAME)
+	-cp -f julia.icns dmg/.VolumeIcon.icns
+	-ln -fs /Applications ./dmg/Applications
+	-chmod 755 ./dmg/$(APP_NAME)/Contents/MacOS/Julia
+	@echo "We're going to chown the .app file to root:admin now, which requires sudo.  You may be asked for your password:"
+	sudo chown -R root:admin ./dmg/$(APP_NAME)
+	sudo hdiutil create $(DMG_NAME) -size 500m -ov -volname "$(VOL_NAME)" -imagekey zlib-level=9 -srcfolder dmg
+
+dmg/$(APP_NAME): julia.icns
 	make -C ../../../deps install-git
 	make -C ../../.. binary-dist
 	tar zxf ../../../julia-*.tar.gz
@@ -24,16 +40,11 @@ dmg:
 	-cp -a $(build_datarootdir)/git* ./julia/share
 	rm -f julia/lib/*.{a,la}
 	-mkdir dmg
-	platypus -a Julia -p /bin/bash -V $(JULIA_VERSION) -R -u "The Julia Project" -i julia.icns -Q julia.icns -o "None" -I org.julialang -x -f julia script ./dmg/Julia-$(VERSION_SUFFIX).app
-	-codesign -s "AFB379C0B4CBD9DB9A762797FC2AB5460A2B0DBE" --deep ./dmg/Julia-$(VERSION_SUFFIX).app
-	-cp -f Julia.icns dmg/.VolumeIcon.icns
-	-ln -fs /Applications ./dmg/Applications
-	-chmod 755 ./dmg/Julia-$(VERSION_SUFFIX).app/Contents/MacOS/Julia
-	@echo "We're going to chown the .app file to root:admin now, which requires sudo.  You may be asked for your password:"
-	sudo chown -R root:admin ./dmg/Julia-$(VERSION_SUFFIX).app
-	sudo hdiutil create Julia-$(VERSION_SUFFIX).dmg -size 500m -ov -volname "Julia" -imagekey zlib-level=9 -srcfolder dmg
-
+	platypus -a Julia -p /bin/bash -V $(JULIA_VERSION) -R -u "The Julia Project" -i julia.icns -Q julia.icns -o "None" -I org.julialang.julia -x -f julia script ./dmg/$(APP_NAME)
+	-codesign -s "AFB379C0B4CBD9DB9A762797FC2AB5460A2B0DBE" --deep ./dmg/$(APP_NAME)
 
 clean:
 	@echo "We have to use sudo here to clean out folders owned by root.  You may be asked for your password"
 	sudo rm -fr julia dmg *.dmg
+
+.PHONY: clean all
diff --git a/contrib/mac/app/script b/contrib/mac/app/script
index 3d513916c171d..9a4e46c939314 100755
--- a/contrib/mac/app/script
+++ b/contrib/mac/app/script
@@ -1,38 +1,9 @@
 #!/bin/sh
-# Copyright (C) 2007, Thomas Treichl and Paul Kienzle
-# Copyright (C) 2008-2009, Thomas Treichl
-# Copyright (C) 2013, Viral B. Shah (Adapted for Julia from Octave)
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; If not, see <http://www.gnu.org/licenses/>.
 
 ROOT="${0%/script}"
-
-# This is the startup procedure written as AppleScript to open a
-# Terminal.app (if the Terminal.app is not already running) and start
-# the Julia program.
-# 20071007 removed: open -a /Applications/Utilities/Terminal.app
 osascript 2>&1>/dev/null <<EOF
-  tell application "System Events" to set ProcessList to get name of every process
   tell application "Terminal"
-    activate
-    if (ProcessList contains "Terminal") or ((count of every window) is less than 1) then
-      tell application "System Events" to tell process "Terminal" to keystroke "n" using command down
-    end if
     do script ("exec '${ROOT}/julia/bin/julia'")
+    activate
   end tell
 EOF
-
-# The app quits immediately after startup, as the app is completely 
-# separate from the actual Julia process. Something it would be neat to
-# change, once we're not just using the .app to tell Terminal what to do
diff --git a/contrib/prepare_release.sh b/contrib/prepare_release.sh
new file mode 100755
index 0000000000000..0d564ab163f07
--- /dev/null
+++ b/contrib/prepare_release.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# script to prepare binaries and source tarballs for a Julia release
+# aka "bucket dance" julianightlies -> julialang
+set -e # stop on failure
+cd "$(dirname "$0")"/.. # run in top-level directory
+
+shashort=$(git rev-parse --short=10 HEAD)
+tag=$(git tag --points-at $shashort)
+if [ -z "$tag" ]; then
+  echo "error: this script must be run with a tagged commit checked out" >&2
+  exit 1
+fi
+version=$(cat VERSION)
+majmin=$(cut -d. -f1-2 VERSION)
+if [ "$tag" != "v$version" ]; then
+  echo "error: tagged commit does not match content of VERSION file" >&2
+  exit 1
+fi
+
+# create full-source-dist and light-source-dist tarballs from a separate
+# clone to ensure the directory name in them is julia-$version
+git clone https://github.com/JuliaLang/julia -b $tag julia-$version
+cd julia-$version
+make full-source-dist
+make light-source-dist
+mv julia-${version}_$shashort-full.tar.gz ../julia-$version-full.tar.gz
+mv julia-${version}_$shashort.tar.gz ../julia-$version.tar.gz
+cd ..
+rm -rf julia-$version
+
+# download and rename binaries, with -latest copies
+julianightlies="https://s3.amazonaws.com/julianightlies/bin"
+curl -L -o julia-$version-linux-x86_64.tar.gz \
+  $julianightlies/linux/x64/$majmin/julia-$version-$shashort-linux64.tar.gz
+cp julia-$version-linux-x86_64.tar.gz julia-$majmin-latest-linux-x86_64.tar.gz
+curl -L -o julia-$version-linux-i686.tar.gz \
+  $julianightlies/linux/x86/$majmin/julia-$version-$shashort-linux32.tar.gz
+cp julia-$version-linux-i686.tar.gz julia-$majmin-latest-linux-i686.tar.gz
+curl -L -o "julia-$version-osx10.7 .dmg" \
+  $julianightlies/osx/x64/$majmin/julia-$version-$shashort-osx.dmg
+cp "julia-$version-osx10.7 .dmg" "julia-$majmin-latest-osx10.7 .dmg"
+curl -L -o julia-$version-win64.exe \
+  $julianightlies/winnt/x64/$majmin/julia-$version-$shashort-win64.exe
+cp julia-$version-win64.exe julia-$majmin-latest-win64.exe
+curl -L -o julia-$version-win32.exe \
+  $julianightlies/winnt/x86/$majmin/julia-$version-$shashort-win32.exe
+cp julia-$version-win32.exe julia-$majmin-latest-win32.exe
+
+shasum -a 256 julia-$version* | grep -v sha256 | grep -v md5 > julia-$version.sha256
+md5sum julia-$version* | grep -v sha256 | grep -v md5 > julia-$version.md5
+
+gpg -u julia --armor --detach-sig julia-$version-full.tar.gz
+gpg -u julia --armor --detach-sig julia-$version.tar.gz
+gpg -u julia --armor --detach-sig julia-$version-linux-x86_64.tar.gz
+gpg -u julia --armor --detach-sig julia-$version-linux-i686.tar.gz
+
+echo "All files prepared. Attach julia-$version.tar.gz and julia-$version-full.tar.gz"
+echo "to github releases, upload all binaries and checksums to julialang S3. Be sure"
+echo "to set all S3 uploads to publicly readable, and replace $majmin-latest binaries."
+# TODO: also automate uploads via aws cli and github api?
diff --git a/contrib/relative_path.sh b/contrib/relative_path.sh
index 407c057ef704b..0dabdbc509c4c 100755
--- a/contrib/relative_path.sh
+++ b/contrib/relative_path.sh
@@ -17,7 +17,7 @@ fi
 common_part=$source # for now
 result="" # for now
 
-while [[ "${target#$common_part}" == "${target}" ]]; do
+while [[ "${target#$common_part/}" == "${target}" ]] && [[ "$common_part" != "/" ]]; do
     # no match, means that candidate common part is not correct
     # go up one level (reduce common part)
     common_part="$(dirname $common_part)"
@@ -29,7 +29,7 @@ while [[ "${target#$common_part}" == "${target}" ]]; do
     fi
 done
 
-if [[ $common_part == "/" ]]; then
+if [[ "$common_part" == "/" ]]; then
     # special case for root (no common path)
     result="$result/"
 fi
diff --git a/contrib/repackage_system_suitesparse4.make b/contrib/repackage_system_suitesparse4.make
index 08f80f164dd84..cb39df7a46060 100755
--- a/contrib/repackage_system_suitesparse4.make
+++ b/contrib/repackage_system_suitesparse4.make
@@ -1,6 +1,6 @@
 #!/usr/bin/make -f
 
-JULIAHOME = $(abspath ..)
+JULIAHOME := $(abspath ..)
 include $(JULIAHOME)/Make.inc
 
 all: default
@@ -22,8 +22,8 @@ endif
 
 default:
 	mkdir -p $(build_libdir)
-	mkdir -p $(JULIAHOME)/deps/SuiteSparse-SYSTEM/lib
-	cd $(JULIAHOME)/deps/SuiteSparse-SYSTEM/lib && \
+	mkdir -p $(JULIAHOME)/deps/build/SuiteSparse-SYSTEM/lib
+	cd $(JULIAHOME)/deps/build/SuiteSparse-SYSTEM/lib && \
 	rm -f $(build_libdir)/lib{amd,cholmod,colamd,spqr,umfpack}.$(SHLIB_EXT)
 	$(CC) -shared $(WHOLE_ARCHIVE) $(SS_LIB)/libsuitesparseconfig.a $(NO_WHOLE_ARCHIVE) -o $(build_libdir)/libsuitesparseconfig.$(SHLIB_EXT)
 	$(INSTALL_NAME_CMD)libsuitesparseconfig.$(SHLIB_EXT) $(build_libdir)/libsuitesparseconfig.$(SHLIB_EXT)
diff --git a/contrib/travis_fastfail.sh b/contrib/travis_fastfail.sh
index 8d692c430653b..6eb349a49b1ff 100755
--- a/contrib/travis_fastfail.sh
+++ b/contrib/travis_fastfail.sh
@@ -5,9 +5,10 @@ curlhdr="Accept: application/vnd.travis-ci.2+json"
 endpoint="https://api.travis-ci.org/repos/$TRAVIS_REPO_SLUG"
 
 # Fail fast for superseded builds to PR's
-if ! [ "$TRAVIS_PULL_REQUEST" = "false" ]; then
-  if ! [ \"$TRAVIS_BUILD_NUMBER\" = $(curl -H "$curlhdr" $endpoint/builds?event_type=pull_request | \
-      jq ".builds | map(select(.pull_request_number == $TRAVIS_PULL_REQUEST))[0].number") ]; then
+if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
+  newestbuildforthisPR=$(curl -H "$curlhdr" $endpoint/builds?event_type=pull_request | \
+      jq ".builds | map(select(.pull_request_number == $TRAVIS_PULL_REQUEST))[0].number")
+  if [ $newestbuildforthisPR != null -a $newestbuildforthisPR != \"$TRAVIS_BUILD_NUMBER\" ]; then
     echo "There are newer queued builds for this pull request, failing early."
     exit 1
   fi
@@ -17,7 +18,7 @@ else
     master | release*)
       ;;
     *)
-      if ! [ \"$TRAVIS_BUILD_NUMBER\" = $(curl -H "$curlhdr" \
+      if [ \"$TRAVIS_BUILD_NUMBER\" != $(curl -H "$curlhdr" \
           $endpoint/branches/$TRAVIS_BRANCH | jq ".branch.number") ]; then
         echo "There are newer queued builds for this branch, failing early."
         exit 1
diff --git a/contrib/windows/Vagrantfile b/contrib/windows/Vagrantfile
index 6e10d86428bfd..6aff0481cf709 100644
--- a/contrib/windows/Vagrantfile
+++ b/contrib/windows/Vagrantfile
@@ -5,7 +5,7 @@ $script_msys2 = <<SCRIPT
 $bits = "64"
 $arch = "x86_$bits".Replace("x86_32", "i686")
 # change the date in the following for future msys2 releases
-$msys2tarball = "msys2-base-$arch-20150512.tar"
+$msys2tarball = "msys2-base-$arch-20150916.tar"
 
 # these environment variables need to be set, or Julia gets confused
 [Environment]::SetEnvironmentVariable("HOMEDRIVE", "C:")
@@ -75,6 +75,6 @@ Vagrant.configure("2") do |config|
     # Use VBoxManage to customize the VM. For example to change memory:
     vb.memory = 2048
   end
-  # change the following to $script_cygwin to build with Cygwin instead of MSYS2
-  config.vm.provision :shell, privileged: false, :inline => $script_msys2
+  # change the following to $script_msys2 to build with MSYS2 instead of Cygwin
+  config.vm.provision :shell, privileged: false, :inline => $script_cygwin
 end
diff --git a/contrib/windows/build-installer.nsi b/contrib/windows/build-installer.nsi
index ba236623e32d1..8896b0a0b1552 100644
--- a/contrib/windows/build-installer.nsi
+++ b/contrib/windows/build-installer.nsi
@@ -33,9 +33,6 @@ Function createDesktopLink
   ${EndIf}
 FunctionEnd
 
-# Icon settings
-!define MUI_ICON "contrib\windows\julia.ico"
-
 # Variable definitions used in installer pages
 InstallDir "$LOCALAPPDATA\Julia-${Version}"
 !define JuliaStartMenuFolder "Julia ${Version}"
@@ -148,8 +145,8 @@ SectionEnd
 # Helper function to create Start Menu folder and shortcuts
 Function AddToStartMenu
     CreateDirectory "$SMPROGRAMS\${JuliaStartMenuFolder}"
-    CreateShortcut "$SMPROGRAMS\${JuliaStartMenuFolder}\julia.lnk" "$INSTDIR\julia.lnk" "" "" "" "" "" "The Julia Language"
-    CreateShortcut "$SMPROGRAMS\${JuliaStartMenuFolder}\Uninstall.lnk" "$instdir\Uninstall.exe"
+    CreateShortcut "$SMPROGRAMS\${JuliaStartMenuFolder}\julia-${Version}.lnk" "$INSTDIR\julia.lnk" "" "" "" "" "" "The Julia Language"
+    CreateShortcut "$SMPROGRAMS\${JuliaStartMenuFolder}\Uninstall-Julia-${Version}.lnk" "$instdir\Uninstall.exe"
 FunctionEnd
 
 # Opens the installation folder
diff --git a/contrib/windows/get_toolchain.sh b/contrib/windows/get_toolchain.sh
index 3d7448e61a85a..796e203f0f61e 100755
--- a/contrib/windows/get_toolchain.sh
+++ b/contrib/windows/get_toolchain.sh
@@ -27,7 +27,7 @@ case $bits in
     ;;
 esac
 echo "Downloading $host toolchain, check $PWD/get_toolchain.log for full output"
-contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win$bits/openSUSE_13.1 \
+contrib/windows/winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win$bits/openSUSE_13.2 \
   "mingw$bits-gcc mingw$bits-gcc-c++ mingw$bits-gcc-fortran \
    mingw$bits-libssp0 mingw$bits-libstdc++6 mingw$bits-libgfortran3" > get_toolchain.log
 
diff --git a/contrib/windows/juliarc.jl b/contrib/windows/juliarc.jl
index 533dc06c5fd34..0f04c6729f5cf 100644
--- a/contrib/windows/juliarc.jl
+++ b/contrib/windows/juliarc.jl
@@ -1,6 +1,2 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-let user_data_dir
-    ENV["PATH"] = JULIA_HOME*";"*joinpath(JULIA_HOME,"..","Git","bin")*";"*ENV["PATH"]
-    #haskey(ENV,"JULIA_EDITOR") || (ENV["JULIA_EDITOR"] = "start") #start is not a program, so this doesn't work
-end
+# Set up environment for Julia Windows binary distribution
+ENV["PATH"] = JULIA_HOME*";"*joinpath(JULIA_HOME,"..","Git","bin")*";"*ENV["PATH"]
diff --git a/contrib/windows/msys_build.sh b/contrib/windows/msys_build.sh
index bb4b88c84cc2a..b4ba7e879613d 100755
--- a/contrib/windows/msys_build.sh
+++ b/contrib/windows/msys_build.sh
@@ -10,6 +10,8 @@
 cd `dirname "$0"`/../..
 # Stop on error
 set -e
+# Make sure stdin exists (not true on appveyor msys2)
+exec < /dev/null
 
 curlflags="curl --retry 10 -k -L -y 5"
 checksum_download() {
@@ -25,21 +27,6 @@ checksum_download() {
   deps/jlchecksum "$f"
 }
 
-# Fail fast on AppVeyor if there are newer pending commits in this PR
-if [ -n "$APPVEYOR_PULL_REQUEST_NUMBER" ]; then
-  # download a handy cli json parser
-  if ! [ -e jq.exe ]; then
-    $curlflags -O http://stedolan.github.io/jq/download/win64/jq.exe
-  fi
-  av_api_url="https://ci.appveyor.com/api/projects/StefanKarpinski/julia/history?recordsNumber=50"
-  query=".builds | map(select(.pullRequestId == \"$APPVEYOR_PULL_REQUEST_NUMBER\"))[0].buildNumber"
-  latestbuild="$(curl $av_api_url | ./jq "$query")"
-  if [ -n "$latestbuild" -a "$latestbuild" != "null" -a "$latestbuild" != "$APPVEYOR_BUILD_NUMBER" ]; then
-    echo "There are newer queued builds for this pull request, failing early."
-    exit 1
-  fi
-fi
-
 # If ARCH environment variable not set, choose based on uname -m
 if [ -z "$ARCH" -a -z "$XC_HOST" ]; then
   export ARCH=`uname -m`
@@ -56,12 +43,15 @@ if [ "$ARCH" = x86_64 ]; then
   exc=seh
   echo "override MARCH = x86-64" >> Make.user
   echo 'USE_BLAS64 = 1' >> Make.user
+  echo 'LIBBLAS = -L$(JULIAHOME)/usr/bin -lopenblas64_' >> Make.user
+  echo 'LIBBLASNAME = libopenblas64_' >> Make.user
 else
   bits=32
   archsuffix=86
   exc=sjlj
-  echo "override MARCH = i686" >> Make.user
-  echo "override JULIA_CPU_TARGET = pentium4" >> Make.user
+  echo "override MARCH = pentium4" >> Make.user
+  echo 'LIBBLAS = -L$(JULIAHOME)/usr/bin -lopenblas' >> Make.user
+  echo 'LIBBLASNAME = libopenblas' >> Make.user
 fi
 
 # Set XC_HOST if in Cygwin or Linux
@@ -103,43 +93,45 @@ if ! [ -e julia-installer.exe ]; then
   echo "Extracting $f"
   $SEVENZIP x -y $f >> get-deps.log
 fi
-for i in bin/*.dll Git/bin/msys-1.0.dll Git/bin/msys-perl5_8.dll Git/bin/*.exe; do
+for i in bin/*.dll Git/usr/bin/*.dll Git/usr/bin/*.exe; do
   $SEVENZIP e -y julia-installer.exe "\$_OUTDIR/$i" \
     -ousr\\`dirname $i | sed -e 's|/julia||' -e 's|/|\\\\|g'` >> get-deps.log
 done
 for i in share/julia/base/pcre_h.jl; do
   $SEVENZIP e -y julia-installer.exe "\$_OUTDIR/$i" -obase >> get-deps.log
 done
+echo "override PCRE_INCL_PATH =" >> Make.user
 # suppress "bash.exe: warning: could not find /tmp, please create!"
 mkdir -p usr/Git/tmp
 # Remove libjulia.dll if it was copied from downloaded binary
 rm -f usr/bin/libjulia.dll
 rm -f usr/bin/libjulia-debug.dll
+rm -f usr/bin/libgcc_s_s*-1.dll
+rm -f usr/bin/libgfortran-3.dll
+rm -f usr/bin/libquadmath-0.dll
+rm -f usr/bin/libssp-0.dll
+rm -f usr/bin/libstdc++-6.dll
 
 if [ -z "$USEMSVC" ]; then
-  if [ -z "`which ${CROSS_COMPILE}gcc 2>/dev/null`" ]; then
+  if [ -z "`which ${CROSS_COMPILE}gcc 2>/dev/null`" -o -n "$APPVEYOR" ]; then
     f=$ARCH-4.9.2-release-win32-$exc-rt_v4-rev3.7z
     checksum_download \
         "$f" "https://bintray.com/artifact/download/tkelman/generic/$f"
     echo "Extracting $f"
     $SEVENZIP x -y $f >> get-deps.log
-    export PATH=$PATH:$PWD/mingw$bits/bin
+    export PATH=$PWD/mingw$bits/bin:$PATH
     # If there is a version of make.exe here, it is mingw32-make which won't work
     rm -f mingw$bits/bin/make.exe
   fi
   export AR=${CROSS_COMPILE}ar
 
-  f=llvm-3.3-$ARCH-w64-mingw32-juliadeps.7z
-  # The MinGW binary version of LLVM doesn't include libgtest or libgtest_main
-  mkdir -p usr/lib
-  $AR cr usr/lib/libgtest.a
-  $AR cr usr/lib/libgtest_main.a
+  f=llvm-3.7.1-$ARCH-w64-mingw32-juliadeps-r04.7z
 else
   echo "override USEMSVC = 1" >> Make.user
   echo "override ARCH = $ARCH" >> Make.user
   echo "override XC_HOST = " >> Make.user
-  export CC="$PWD/deps/libuv/compile cl -nologo -MD -Z7"
-  export AR="$PWD/deps/libuv/ar-lib lib"
+  export CC="$PWD/deps/srccache/libuv/compile cl -nologo -MD -Z7"
+  export AR="$PWD/deps/srccache/libuv/ar-lib lib"
   export LD="$PWD/linkld link"
   echo "override CC = $CC" >> Make.user
   echo 'override CXX = $(CC) -EHsc' >> Make.user
@@ -153,16 +145,9 @@ checksum_download \
     "$f" "https://bintray.com/artifact/download/tkelman/generic/$f"
 echo "Extracting $f"
 $SEVENZIP x -y $f >> get-deps.log
-echo 'override LLVM_CONFIG = $(JULIAHOME)/usr/bin/llvm-config' >> Make.user
+echo 'override LLVM_CONFIG := $(JULIAHOME)/usr/tools/llvm-config.exe' >> Make.user
+echo 'override LLVM_SIZE := $(JULIAHOME)/usr/tools/llvm-size.exe' >> Make.user
 
-if [ -n "$APPVEYOR" ]; then
-  for i in make.exe touch.exe msys-intl-8.dll msys-iconv-2.dll; do
-    f="/c/MinGW/msys/1.0/bin/$i"
-    if [ -e $f ]; then
-      cp $f /bin/$i
-    fi
-  done
-fi
 if [ -z "`which make 2>/dev/null`" ]; then
   if [ -n "`uname | grep CYGWIN`" ]; then
     echo "Install the Cygwin package for 'make' and try again."
@@ -175,8 +160,6 @@ if [ -z "`which make 2>/dev/null`" ]; then
   fi
   $SEVENZIP x -y `basename $f.lzma` >> get-deps.log
   tar -xf `basename $f`
-  # msysgit has an ancient version of touch that fails with `touch -c nonexistent`
-  cp usr/Git/bin/echo.exe bin/touch.exe
   export PATH=$PWD/bin:$PATH
 fi
 
@@ -184,8 +167,6 @@ for lib in SUITESPARSE ARPACK BLAS LAPACK FFTW \
     GMP MPFR PCRE LIBUNWIND RMATH OPENSPECFUN; do
   echo "USE_SYSTEM_$lib = 1" >> Make.user
 done
-echo 'LIBBLAS = -L$(JULIAHOME)/usr/bin -lopenblas' >> Make.user
-echo 'LIBBLASNAME = libopenblas' >> Make.user
 echo 'override LIBLAPACK = $(LIBBLAS)' >> Make.user
 echo 'override LIBLAPACKNAME = $(LIBBLASNAME)' >> Make.user
 echo 'JULIA_SYSIMG_BUILD_FLAGS=--output-ji ../usr/lib/julia/sys.ji' >> Make.user
@@ -199,12 +180,6 @@ echo 'override STAGE2_DEPS = utf8proc' >> Make.user
 echo 'override STAGE3_DEPS = ' >> Make.user
 
 if [ -n "$USEMSVC" ]; then
-  make -C deps get-libuv
-  # Create a modified version of compile for wrapping link
-  sed -e 's/-link//' -e 's/cl/link/g' -e 's/ -Fe/ -OUT:/' \
-    -e 's|$dir/$lib|$dir/lib$lib|g' deps/libuv/compile > linkld
-  chmod +x linkld
-
   # Openlibm doesn't build well with MSVC right now
   echo 'USE_SYSTEM_OPENLIBM = 1' >> Make.user
   # Since we don't have a static library for openlibm
@@ -215,13 +190,20 @@ if [ -n "$USEMSVC" ]; then
   cp usr/lib/uv.lib usr/lib/libuv.a
   echo 'override CC += -TP' >> Make.user
   echo 'override STAGE1_DEPS += dsfmt' >> Make.user
+
+  # Create a modified version of compile for wrapping link
+  sed -e 's/-link//' -e 's/cl/link/g' -e 's/ -Fe/ -OUT:/' \
+    -e 's|$dir/$lib|$dir/lib$lib|g' deps/srccache/libuv/compile > linkld
+  chmod +x linkld
 else
   echo 'override STAGE1_DEPS += openlibm' >> Make.user
   make check-whitespace
   make VERBOSE=1 -C base version_git.jl.phony
   echo 'NO_GIT = 1' >> Make.user
 fi
+echo 'FORCE_ASSERTIONS = 1' >> Make.user
 
 cat Make.user
-make VERBOSE=1
+make -j3 VERBOSE=1
+make build-stats
 #make debug
diff --git a/contrib/windows/winrpm.sh b/contrib/windows/winrpm.sh
index dbd4964659217..fe00f3889fca2 100755
--- a/contrib/windows/winrpm.sh
+++ b/contrib/windows/winrpm.sh
@@ -2,7 +2,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 # build-time mini version of WinRPM, usage:
-# ./winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_13.1/ mingw64-zlib1
+# ./winrpm.sh http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_13.2/ mingw64-zlib1
 # depends on curl, xmllint, gunzip, sort -V, sha256sum, and p7zip
 
 set -e
diff --git a/deps/.gitignore b/deps/.gitignore
index 11fdbc52bfac4..89ab4cc8ca36d 100644
--- a/deps/.gitignore
+++ b/deps/.gitignore
@@ -1,3 +1,6 @@
+/srccache
+/build
+
 /arpack-*
 /cfe-*
 /clang-*
diff --git a/deps/Makefile b/deps/Makefile
index 2a49983db59ff..28174e13e8a1a 100644
--- a/deps/Makefile
+++ b/deps/Makefile
@@ -1,6 +1,12 @@
 ## high-level setup ##
-JULIAHOME = $(abspath ..)
-include Versions.make
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/..)
+ifeq ($(abspath .),$(abspath $(SRCDIR)))
+BUILDDIR := build
+else
+BUILDDIR := .
+endif
+include $(SRCDIR)/Versions.make
 include $(JULIAHOME)/Make.inc
 
 # Special comments:
@@ -10,11 +16,12 @@ include $(JULIAHOME)/Make.inc
 # additionally all targets should be listed in the getall target for easier off-line compilation
 # if you are adding a new target, it can help to copy an similar, existing target
 #
-# autoconf configure-driven scripts: llvm pcre arpack fftw unwind gmp mpfr patchelf libuv
-# custom Makefile rules: openlibm Rmath-julia dsfmt suitesparse-wrapper suitesparse lapack openblas utf8proc objconv
+# autoconf configure-driven scripts: llvm pcre arpack fftw unwind gmp mpfr patchelf libuv git
+# custom Makefile rules: openlibm Rmath-julia dsfmt suitesparse-wrapper suitesparse lapack openblas utf8proc objconv osxunwind
+# entirely custom: virtualenv
 # CMake libs: libgit2
 #
-# downloaded from git: llvm-svn, libuv, libopenlibm, utf8proc, openspecfun
+# downloaded from git: llvm-svn, libuv, libopenlibm, utf8proc, openspecfun, libgit2
 #
 # there are rules in this file with the . replaced by a %
 # this is some magic Makefile trick that tells make
@@ -24,7 +31,7 @@ include $(JULIAHOME)/Make.inc
 
 ## Some shared configuration options ##
 
-CONFIGURE_COMMON = --prefix=$(abspath $(build_prefix)) --build=$(BUILD_MACHINE) --libdir=$(abspath $(build_libdir)) $(CUSTOM_LD_LIBRARY_PATH)
+CONFIGURE_COMMON := --prefix=$(abspath $(build_prefix)) --build=$(BUILD_MACHINE) --libdir=$(abspath $(build_libdir)) $(CUSTOM_LD_LIBRARY_PATH)
 ifneq ($(XC_HOST),)
 CONFIGURE_COMMON += --host=$(XC_HOST)
 endif
@@ -35,10 +42,10 @@ endif
 endif
 CONFIGURE_COMMON += F77="$(FC)" CC="$(CC) $(DEPS_CFLAGS)" CXX="$(CXX) $(DEPS_CXXFLAGS)"
 
-CMAKE_CC_ARG = $(CC_ARG) $(DEPS_CFLAGS)
-CMAKE_CXX_ARG = $(CXX_ARG) $(DEPS_CXXFLAGS)
+CMAKE_CC_ARG := $(CC_ARG) $(DEPS_CFLAGS)
+CMAKE_CXX_ARG := $(CXX_ARG) $(DEPS_CXXFLAGS)
 
-CMAKE_COMMON = -DCMAKE_INSTALL_PREFIX:PATH=$(build_prefix) -DCMAKE_BUILD_TYPE=Release
+CMAKE_COMMON := -DCMAKE_INSTALL_PREFIX:PATH=$(build_prefix)
 ifneq ($(VERBOSE), 0)
 CMAKE_COMMON += -DCMAKE_VERBOSE_MAKEFILE=ON
 endif
@@ -51,12 +58,19 @@ ifneq ($(strip $(CMAKE_CXX_ARG)),)
 CMAKE_COMMON += -DCMAKE_CXX_COMPILER_ARG1="$(CMAKE_CXX_ARG)"
 endif
 
+ifeq ($(OS),WINNT)
+CMAKE_COMMON += -DCMAKE_SYSTEM_NAME=Windows
+ifneq ($(BUILD_OS),WINNT)
+CMAKE_COMMON += -DCMAKE_RC_COMPILER=`which $(CROSS_COMPILE)windres`
+endif
+endif
+
 # For now this is LLVM specific, but I expect it won't be in the future
-ifneq ($(LLVM_USE_CMAKE),)
+ifeq ($(LLVM_USE_CMAKE),1)
 ifeq ($(CMAKE_GENERATOR),Ninja)
-CMAKE_GENERATOR_COMMAND = -G Ninja
+CMAKE_GENERATOR_COMMAND := -G Ninja
 else ifeq ($(CMAKE_GENERATOR),make)
-CMAKE_GENERATOR_COMMAND = -G "Unix Makefiles"
+CMAKE_GENERATOR_COMMAND := -G "Unix Makefiles"
 else
 $(error Unknown CMake generator '$(CMAKE_GENERATOR)'. Options are 'Ninja' and 'make')
 endif
@@ -64,7 +78,7 @@ endif
 
 # If the top-level Makefile is called with environment variables,
 # they will override the values passed above to ./configure
-MAKE_COMMON = DESTDIR="" prefix=$(build_prefix) bindir=$(build_bindir) libdir=$(build_libdir) libexecdir=$(build_libexecdir) datarootdir=$(build_datarootdir) includedir=$(build_includedir) sysconfdir=$(build_sysconfdir)
+MAKE_COMMON := DESTDIR="" prefix=$(build_prefix) bindir=$(build_bindir) libdir=$(build_libdir) libexecdir=$(build_libexecdir) datarootdir=$(build_datarootdir) includedir=$(build_includedir) sysconfdir=$(build_sysconfdir) O=
 
 
 ## Overall configuration of which rules exist and should be run by default ##
@@ -73,13 +87,13 @@ MAKE_COMMON = DESTDIR="" prefix=$(build_prefix) bindir=$(build_bindir) libdir=$(
 unexport CONFIG_SITE
 
 ifeq ($(USE_GPL_LIBS), 1)
-STAGE1_DEPS =
-STAGE2_DEPS = Rmath-julia
-STAGE3_DEPS = suitesparse-wrapper
+STAGE1_DEPS :=
+STAGE2_DEPS := Rmath-julia
+STAGE3_DEPS := suitesparse-wrapper
 else
-STAGE1_DEPS =
-STAGE2_DEPS =
-STAGE3_DEPS =
+STAGE1_DEPS :=
+STAGE2_DEPS :=
+STAGE3_DEPS :=
 endif
 
 ifeq ($(USE_SYSTEM_LIBUV), 0)
@@ -99,11 +113,12 @@ endif
 ifeq ($(OS), Linux)
 ifeq ($(USE_SYSTEM_PATCHELF), 0)
 STAGE1_DEPS += patchelf
-PATCHELF=$(build_bindir)/patchelf
+PATCHELF:=$(build_bindir)/patchelf
 else
-PATCHELF=patchelf
+PATCHELF:=patchelf
 endif
 endif
+PATCHELF_BIN := $(CUSTOM_LD_LIBRARY_PATH) $(PATCHELF)
 
 ## USE_SYSTEM_LIBS options
 
@@ -183,12 +198,12 @@ endif
 #Platform specific flags
 
 ifeq ($(OS), WINNT)
-LIBTOOL_CCLD = CCLD="$(CC) -no-undefined -avoid-version"
+LIBTOOL_CCLD := CCLD="$(CC) -no-undefined -avoid-version"
 endif
 
 ## Common build target prefixes
 
-DEP_LIBS = $(STAGE1_DEPS) $(STAGE2_DEPS) $(STAGE3_DEPS)
+DEP_LIBS := $(STAGE1_DEPS) $(STAGE2_DEPS) $(STAGE3_DEPS)
 
 default: install | $(build_prefix)
 get: $(addprefix get-, $(DEP_LIBS))
@@ -203,15 +218,16 @@ getall: get-llvm get-libuv get-pcre get-openlibm get-openspecfun get-dsfmt get-R
 
 ## PATHS ##
 # sort is used to remove potential duplicates
-DIRS = $(sort $(build_bindir) $(build_libdir) $(build_includedir) $(build_sysconfdir) $(build_datarootdir) $(build_staging))
+DIRS := $(sort $(build_bindir) $(build_libdir) $(build_includedir) $(build_sysconfdir) $(build_datarootdir) $(build_staging))
 
 $(foreach dir,$(DIRS),$(eval $(call dir_target,$(dir))))
 
 $(build_prefix): | $(DIRS)
+$(eval $(call dir_target,$(SRCDIR)/srccache))
 
 ## A rule for calling `make install` ##
 #	rule: dependencies
-#   	$(call make-install build-directory,add-args)
+#   	$(call make-install,rel-build-directory,add-args)
 #   	touch -c $@
 # this rule ensures that make install is more nearly atomic
 # so it's harder to get half-installed (or half-reinstalled) dependencies
@@ -224,16 +240,17 @@ define staged-install
 endef
 
 define make-install
-	$(call staged-install,$1,+$(MAKE) -C $1 install $(MAKE_COMMON) $2 DESTDIR=$(call MAKE_DESTDIR,$1))
+	$(call staged-install,$1,+$(MAKE) -C $(BUILDDIR)/$1 install $(MAKE_COMMON) $2 DESTDIR=$(call MAKE_DESTDIR,$1))
 endef
 
 ## A rule for making a git-external dependency ##
 # call syntax:
-#   $(eval $(call git-external,dirname,VARNAME,file_from_download,file_from_compile)
+#   $(eval $(call git-external,dirname,VARNAME,file_from_download,file_from_compile,SRCDIR)
 # dirname is the folder name to create
 # VARNAME is the uppercased variable name prefix
 # file_from_download is the name of a file inside the git repo to indicate when it's cloned (relative to dirname)
 # file_from_compile is the rule to run to compile the dependency (relative to dirname)
+# SRCDIR is either $(SRCDIR)/srccache or $(BUILDDIR), depending on whether the target supports out-of-tree builds
 #
 # also, in a file named dirname.version, define variables VARNAME_BRANCH and VARNAME_SHA1
 #
@@ -242,42 +259,57 @@ endef
 # this will pass along the VARNAME_SHA1 target in $1 for its use
 #
 # this defines rules for:
-#   VARNAME_SRC_DIR = source directory for the output
+#   VARNAME_SRC_DIR = source directory for the output, relative to $(SRCDIR)/srccache or $(BUILDDIR)
+#   VARNAME_SRC_FILE = target file for make get-VARNAME target
 #   dirname:
 #   dirname/file_from_download:
 #   distclean-dirname:
 #
 define git-external
-include $1.version
+include $(SRCDIR)/$1.version
+
 ifneq ($(NO_GIT),1)
-$2_SRC_DIR = $1
-$1:
-	git clone -q --depth=50 --branch $$($2_BRANCH) $$($2_GIT_URL) $1
-	touch -c $1/$3
-$1/$3: $1.version | $1
-	cd $1 && git fetch -q $$($2_GIT_URL) $$($2_BRANCH):remotes/origin/$$($2_BRANCH)
-	cd $1 && git checkout -q --detach $$($2_SHA1)
-	@[ '$$($2_SHA1)' = "$$$$(cd $1 && git show -s --format='%H' HEAD)" ] || echo $$(WARNCOLOR)'==> warning: SHA1 hash did not match $1.version file'$$(ENDCOLOR)
+$2_SRC_DIR := $1
+$2_SRC_FILE := $$(SRCDIR)/srccache/$1.git
+$$($2_SRC_FILE)/HEAD: | $$(SRCDIR)/srccache
+	git clone -q --mirror --branch $$($2_BRANCH) $$($2_GIT_URL) $$(dir $$@)
+$5/$1/.git/HEAD: | $$($2_SRC_FILE)/HEAD
+	# try to update the cache, if that fails, attempt to continue anyways (the ref might already be local)
+	-cd $$($2_SRC_FILE) && git fetch -q $$($2_GIT_URL) $$($2_BRANCH):remotes/origin/$$($2_BRANCH)
+	git clone -q --depth=10 --branch $$($2_BRANCH) $$($2_SRC_FILE) $5/$1
+	cd $5/$1 && git remote set-url origin $$($2_GIT_URL)
+	touch -c $5/$1/$3
+ifneq ($5,$$(BUILDDIR))
+$$(BUILDDIR)/$1:
+	mkdir -p $$@
+$5/$1/$3: | $$(BUILDDIR)/$1
+endif
+$5/$1/$3: $$(SRCDIR)/$1.version | $5/$1/.git/HEAD
+	# try to update the cache, if that fails, attempt to continue anyways (the ref might already be local)
+	-cd $$(SRCDIR)/srccache/$1.git && git fetch -q $$($2_GIT_URL) $$($2_BRANCH):remotes/origin/$$($2_BRANCH)
+	cd $5/$1 && git fetch -q $$(SRCDIR)/srccache/$1.git remotes/origin/$$($2_BRANCH):remotes/origin/$$($2_BRANCH)
+	cd $5/$1 && git checkout -q --detach $$($2_SHA1)
+	@[ '$$($2_SHA1)' = "$$$$(cd $5/$1 && git show -s --format='%H' HEAD)" ] || echo $$(WARNCOLOR)'==> warning: SHA1 hash did not match $1.version file'$$(ENDCOLOR)
 	touch -c $$@
-# also allow backwards compatibility with an existing git-submodule:
-ifeq (exists, $$(shell [ -d $1/.git ] && echo exists ))
-$1/$4: $1/.git/HEAD
-endif
-ifeq (exists, $$(shell [ -d $$(JULIAHOME)/.git/modules/deps/$1 ] && echo exists ))
-$1/$4: $$(JULIAHOME)/.git/modules/deps/$1/HEAD
-endif
+$5/$1/$4: $5/$1/.git/HEAD
+$$($2_SRC_FILE): | $$($2_SRC_FILE)/HEAD
+	touch -c $$@
+
 else # NO_GIT
-$2_SRC_DIR = $1-$$($2_SHA1)
-$$($2_SRC_DIR).tar.gz:
+
+$2_SRC_DIR := $1-$$($2_SHA1)
+$2_SRC_FILE := $$(SRCDIR)/srccache/$$($2_SRC_DIR).tar.gz
+$$($2_SRC_FILE): | $$(SRCDIR)/srccache
 	$$(JLDOWNLOAD) $$@ $$(call $2_TAR_URL,$$($2_SHA1))
-$$($2_SRC_DIR)/$3: $$($2_SRC_DIR).tar.gz
-	$$(JLCHECKSUM) $$($2_SRC_DIR).tar.gz
-	mkdir -p $$($2_SRC_DIR) && \
-	$(TAR) -C $$($2_SRC_DIR) --strip-components 1 -xf $$<
+$5/$$($2_SRC_DIR)/$3: $$($2_SRC_FILE)
+	$$(JLCHECKSUM) $$<
+	mkdir -p $$(dir $$@) && \
+	$(TAR) -C $$(dir $$@) --strip-components 1 -xf $$<
 	touch -c $$@
-endif
+endif # NO_GIT
+
 distclean-$1:
-	-rm -rf $$($2_SRC_DIR) $$($2_SRC_DIR).tar.gz
+	-rm -rf $5/$$($2_SRC_DIR) $$($2_SRC_FILE) $$(BUILDDIR)/$1
 endef
 
 
@@ -291,15 +323,16 @@ LLVM_GIT_URL_LIBCXX ?= $(LLVM_GIT_URL_BASE)/libcxx.git
 LLVM_GIT_URL_LIBCXXABI ?= $(LLVM_GIT_URL_BASE)/libcxxabi.git
 
 ifeq ($(BUILD_LLDB), 1)
-BUILD_LLVM_CLANG = 1
+BUILD_LLVM_CLANG := 1
 # because it's a build requirement
 endif
 
 ifeq ($(LLVM_DEBUG),1)
-LLVM_BUILDTYPE = Debug
+LLVM_BUILDTYPE := Debug
 else
-LLVM_BUILDTYPE = Release
+LLVM_BUILDTYPE := Release
 endif
+LLVM_CMAKE_BUILDTYPE := $(LLVM_BUILDTYPE)
 ifeq ($(LLVM_ASSERTIONS),1)
 LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+Asserts
 endif
@@ -312,58 +345,74 @@ LLVM_BUILDTYPE := $(LLVM_BUILDTYPE)+ASAN
 endif
 endif
 
-LLVM_LIB_FILE = libLLVMCodeGen.a
-ifeq ($(LLVM_USE_CMAKE),1)
-LLVM_OBJ_SOURCE = llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE)/lib/$(LLVM_LIB_FILE)
+LLVM_VER_MAJ:=$(word 1, $(subst ., ,$(LLVM_VER)))
+LLVM_VER_MIN:=$(word 2, $(subst ., ,$(LLVM_VER)))
+# define a "short" LLVM version for easy comparisons
+ifeq ($(LLVM_VER),svn)
+LLVM_VER_SHORT:=svn
 else
-LLVM_OBJ_SOURCE = llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE)/$(LLVM_FLAVOR)/lib/$(LLVM_LIB_FILE)
+LLVM_VER_SHORT:=$(LLVM_VER_MAJ).$(LLVM_VER_MIN)
+endif
+LLVM_VER_PATCH:=$(word 3, $(subst ., ,$(LLVM_VER)))
+ifeq ($(LLVM_VER_PATCH),)
+LLVM_VER_PATCH := 0
 endif
-LLVM_OBJ_TARGET = $(build_libdir)/$(LLVM_LIB_FILE)
 
-ifneq ($(LLVM_VER),svn)
-ifeq ($(LLVM_VER), 3.3)
-LLVM_TAR=llvm-$(LLVM_VER).src.tar.gz
+ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7 3.8))
+LLVM_USE_CMAKE := 0
 else
-LLVM_TAR=llvm-$(LLVM_VER).src.tar.xz
+LLVM_USE_CMAKE := 1
 endif
 
-ifeq ($(BUILD_LLDB),1)
+LLVM_SRC_DIR:=$(SRCDIR)/srccache/llvm-$(LLVM_VER)
+LLVM_BUILD_DIR:=$(BUILDDIR)/llvm-$(LLVM_VER)
+LLVM_BUILDDIR_withtype := $(LLVM_BUILD_DIR)/build_$(LLVM_BUILDTYPE)
+LLVM_LIB_FILE := libLLVMCodeGen.a
+ifeq ($(LLVM_USE_CMAKE),1)
+LLVM_OBJ_SOURCE := $(LLVM_BUILDDIR_withtype)/lib/$(LLVM_LIB_FILE)
+else
+LLVM_OBJ_SOURCE := $(LLVM_BUILDDIR_withtype)/$(LLVM_FLAVOR)/lib/$(LLVM_LIB_FILE)
+endif
+LLVM_OBJ_TARGET := $(build_libdir)/$(LLVM_LIB_FILE)
+
 ifeq ($(LLVM_VER), 3.3)
-LLVM_LLDB_TAR=lldb-$(LLVM_VER).src.tar.gz
+LLVM_TAR_EXT:=$(LLVM_VER).src.tar.gz
 else
-LLVM_LLDB_TAR=lldb-$(LLVM_VER).src.tar.xz
+LLVM_TAR_EXT:=$(LLVM_VER).src.tar.xz
 endif # LLVM_VER == 3.3
+
+ifneq ($(LLVM_VER),svn)
+LLVM_TAR:=$(SRCDIR)/srccache/llvm-$(LLVM_TAR_EXT)
+
+ifeq ($(BUILD_LLDB),1)
+LLVM_LLDB_TAR:=$(SRCDIR)/srccache/lldb-$(LLVM_TAR_EXT)
 endif # BUILD_LLDB
 
 ifeq ($(BUILD_LLVM_CLANG),1)
-ifeq ($(LLVM_VER), 3.3)
-LLVM_CLANG_TAR=cfe-$(LLVM_VER).src.tar.gz
-LLVM_COMPILER_RT_TAR=compiler-rt-$(LLVM_VER).src.tar.gz
-else
-LLVM_CLANG_TAR=cfe-$(LLVM_VER).src.tar.xz
-LLVM_COMPILER_RT_TAR=compiler-rt-$(LLVM_VER).src.tar.xz
-endif # LLVM_VER
+LLVM_CLANG_TAR:=$(SRCDIR)/srccache/cfe-$(LLVM_TAR_EXT)
+LLVM_COMPILER_RT_TAR:=$(SRCDIR)/srccache/compiler-rt-$(LLVM_TAR_EXT)
 else
-LLVM_CLANG_TAR=
-LLVM_COMPILER_RT_TAR=
-LLVM_LIBCXX_TAR=
+LLVM_CLANG_TAR:=
+LLVM_COMPILER_RT_TAR:=
+LLVM_LIBCXX_TAR:=
 endif # BUILD_LLVM_CLANG
 
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
-LLVM_LIBCXX_TAR=libcxx-$(LLVM_VER).src.tar.gz
+LLVM_LIBCXX_TAR:=$(SRCDIR)/srccache/libcxx-$(LLVM_TAR_EXT)
 endif
 endif # LLVM_VER != svn
 
-LLVM_CXXFLAGS = $(CXXFLAGS)
-LLVM_CPPFLAGS = $(CPPFLAGS)
-LLVM_LDFLAGS = $(LDFLAGS)
-LLVM_TARGETS = host
-LLVM_TARGET_FLAGS = --enable-targets=$(LLVM_TARGETS)
-LLVM_CMAKE += -DLLVM_TARGETS_TO_BUILD:STRING="$(LLVM_TARGETS)" -DCMAKE_BUILD_TYPE="$(LLVM_BUILDTYPE)" -DLLVM_BUILD_LLVM_DYLIB:BOOL=ON -DLLVM_DYLIB_EXPORT_ALL:BOOL=ON
-LLVM_FLAGS += --disable-profiling --enable-shared --enable-static $(LLVM_TARGET_FLAGS) --disable-bindings --disable-docs
+LLVM_CXXFLAGS := $(CXXFLAGS)
+LLVM_CPPFLAGS := $(CPPFLAGS)
+LLVM_LDFLAGS := $(LDFLAGS)
+LLVM_TARGETS := host
+LLVM_TARGET_FLAGS := --enable-targets=$(LLVM_TARGETS)
+LLVM_CMAKE += -DLLVM_TARGETS_TO_BUILD:STRING="$(LLVM_TARGETS)" -DCMAKE_BUILD_TYPE="$(LLVM_CMAKE_BUILDTYPE)"
+LLVM_FLAGS += --disable-profiling --enable-static $(LLVM_TARGET_FLAGS)
+LLVM_FLAGS += --disable-bindings --disable-docs --disable-libedit --disable-terminfo
 # LLVM has weird install prefixes (see llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE)/Makefile.config for the full list)
 # We map them here to the "normal" ones, which means just prefixing "PROJ_" to the variable name.
-LLVM_MFLAGS = PROJ_libdir=$(build_libdir) PROJ_bindir=$(build_bindir) PROJ_includedir=$(build_includedir)
+LLVM_MFLAGS := PROJ_libdir=$(build_libdir) PROJ_bindir=$(build_bindir) PROJ_includedir=$(build_includedir)
 ifeq ($(LLVM_ASSERTIONS), 1)
 LLVM_FLAGS += --enable-assertions
 LLVM_CMAKE += -DLLVM_ENABLE_ASSERTIONS:BOOL=ON
@@ -383,12 +432,19 @@ LLVM_FLAGS += --enable-libcpp
 endif # USE_LIBCPP
 ifeq ($(OS), WINNT)
 LLVM_FLAGS += --with-extra-ld-options="-Wl,--stack,8388608" LDFLAGS=""
-# turn off shared LLVM on Windows unless explicitly requested
-ifneq ($(USE_LLVM_SHLIB),1)
-LLVM_FLAGS += --disable-shared
-endif
 LLVM_CPPFLAGS += -D__USING_SJLJ_EXCEPTIONS__ -D__CRT__NO_INLINE
+ifneq ($(BUILD_OS),WINNT)
+LLVM_CMAKE += -DCROSS_TOOLCHAIN_FLAGS_NATIVE=-DCMAKE_TOOLCHAIN_FILE=$(SRCDIR)/NATIVE.cmake
+endif # BUILD_OS != WINNT
 endif # OS == WINNT
+ifeq ($(USE_LLVM_SHLIB),1)
+# NOTE: we could also --disable-static here (on the condition we link tools
+#       against libLLVM) but there doesn't seem to be a CMake counterpart option
+LLVM_FLAGS += --enable-shared
+LLVM_CMAKE += -DLLVM_BUILD_LLVM_DYLIB:BOOL=ON -DLLVM_DYLIB_EXPORT_ALL:BOOL=ON
+# NOTE: LLVM_DYLIB_EXPORT_ALL has been removed recently,
+#       and LLVM now defaults to exporting all symbols
+endif
 ifeq ($(USE_INTEL_JITEVENTS), 1)
 LLVM_FLAGS += --with-intel-jitevents
 ifeq ($(OS), WINNT)
@@ -398,6 +454,10 @@ else
 LLVM_FLAGS += --disable-threads
 endif # USE_INTEL_JITEVENTS
 
+ifeq ($(USE_OPROFILE_JITEVENTS), 1)
+LLVM_FLAGS += --with-oprofile=/usr/
+endif # USE_OPROFILE_JITEVENTS
+
 ifeq ($(BUILD_LLDB),1)
 ifeq ($(USECLANG),1)
 LLVM_FLAGS += --enable-cxx11
@@ -414,22 +474,37 @@ ifeq ($(ARCH), ppc64)
 LLVM_CXXFLAGS += -mminimal-toc
 endif # ARCH == ppc64
 
+# LLVM bug #24157
+ifeq ($(USE_LLVM_SHLIB),1)
+ifeq ($(LLVM_USE_CMAKE),1)
+ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7))
+$(error USE_LLVM_SHLIB=1 with LLVM_USE_CMAKE=1 requires LLVM > 3.7.x)
+endif
+endif
+endif
 
 ifeq ($(LLVM_SANITIZE),1)
+# autotools doesn't provide a sanitation build mode (linking libLLVM will fail)
+ifeq ($(USE_LLVM_SHLIB),1)
+ifeq ($(LLVM_USE_CMAKE),0)
+$(error LLVM_SANITIZE=1 with USE_LLVM_SHLIB=1 requires LLVM_USE_CMAKE=1)
+endif
+endif
 ifeq ($(SANITIZE_MEMORY),1)
-LLVM_CC = CFLAGS="$(CFLAGS) -fsanitize=memory -fsanitize-memory-track-origins"
+LLVM_CC := CFLAGS="$(CFLAGS) -fsanitize=memory -fsanitize-memory-track-origins"
 LLVM_LDFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
 LLVM_CXXFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
 LLVM_CMAKE += -DLLVM_USE_SANITIZER="MemoryWithOrigins"
+LLVM_FLAGS += --disable-terminfo
 else
-LLVM_CC = CFLAGS="$(CFLAGS) -fsanitize=address"
+LLVM_CC := CFLAGS="$(CFLAGS) -fsanitize=address"
 LLVM_LDFLAGS += -fsanitize=address
 LLVM_CXXFLAGS += -fsanitize=address
 LLVM_CMAKE += -DLLVM_USE_SANITIZER="Address"
 endif
 LLVM_MFLAGS += TOOL_NO_EXPORTS= HAVE_LINK_VERSION_SCRIPT=0
 else
-LLVM_CC =
+LLVM_CC :=
 endif # LLVM_SANITIZE
 
 ifneq ($(LLVM_CXXFLAGS),)
@@ -454,94 +529,119 @@ LLVM_FLAGS += LDFLAGS="$(LLVM_LDFLAGS)"
 LLVM_MFLAGS += LDFLAGS="$(LLVM_LDFLAGS)"
 endif
 
+ifeq ($(BUILD_LLVM_CLANG),1)
+LLVM_MFLAGS += OPTIONAL_PARALLEL_DIRS=clang
+else
+# block default building of Clang
+LLVM_MFLAGS += OPTIONAL_PARALLEL_DIRS=
+ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7 3.8))
+LLVM_CMAKE += -DLLVM_EXTERNAL_CLANG_BUILD=OFF
+LLVM_CMAKE += -DLLVM_EXTERNAL_COMPILER_RT_BUILD=OFF
+else
+LLVM_CMAKE += -DLLVM_TOOL_CLANG_BUILD=OFF
+LLVM_CMAKE += -DLLVM_TOOL_COMPILER_RT_BUILD=OFF
+endif
+endif
+ifeq ($(BUILD_LLDB),1)
+LLVM_MFLAGS += OPTIONAL_DIRS=lldb
+else
+# block default building of lldb
+LLVM_MFLAGS += OPTIONAL_DIRS=
+ifeq ($(LLVM_VER_SHORT),$(filter $(LLVM_VER_SHORT),3.3 3.4 3.5 3.6 3.7 3.8))
+LLVM_CMAKE += -DLLVM_EXTERNAL_LLDB_BUILD=OFF
+else
+LLVM_CMAKE += -DLLVM_TOOL_LLDB_BUILD=OFF
+endif
+endif
+
+LLVM_SRC_URL := http://llvm.org/releases/$(LLVM_VER)
+
 ifneq ($(LLVM_CLANG_TAR),)
-$(LLVM_CLANG_TAR):
-	$(JLDOWNLOAD) $@ http://llvm.org/releases/$(LLVM_VER)/$@
+$(LLVM_CLANG_TAR): | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 ifneq ($(LLVM_COMPILER_RT_TAR),)
-$(LLVM_COMPILER_RT_TAR):
-	$(JLDOWNLOAD) $@ http://llvm.org/releases/$(LLVM_VER)/$@
+$(LLVM_COMPILER_RT_TAR): | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 
 ifneq ($(LLVM_LIBCXX_TAR),)
-$(LLVM_LIBCXX_TAR):
-	$(JLDOWNLOAD) $@ http://llvm.org/releases/$(LLVM_VER)/$@
+$(LLVM_LIBCXX_TAR): | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 ifneq ($(LLVM_VER),svn)
-$(LLVM_TAR):
-	$(JLDOWNLOAD) $@ http://llvm.org/releases/$(LLVM_VER)/$@
+$(LLVM_TAR): | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 
 ifneq ($(LLVM_LLDB_TAR),)
-$(LLVM_LLDB_TAR):
-	$(JLDOWNLOAD) $@ http://llvm.org/releases/$(LLVM_VER)/$@
+$(LLVM_LLDB_TAR): | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ $(LLVM_SRC_URL)/$(notdir $@)
 endif
 ifeq ($(BUILD_LLDB),1)
-llvm-$(LLVM_VER)/tools/lldb:
-llvm-$(LLVM_VER)/configure: llvm-$(LLVM_VER)/tools/lldb
+$(LLVM_SRC_DIR)/tools/lldb:
+$(LLVM_SRC_DIR)/configure: $(LLVM_SRC_DIR)/tools/lldb
 endif
 
-llvm-$(LLVM_VER)/python2_path:
-	mkdir -p llvm-$(LLVM_VER)/python2_path
+# LLDB still relies on plenty of python 2.x infrastructure, without checking
+llvm_python_workaround=$(SRCDIR)/srccache/python2_path
+$(llvm_python_workaround):
+	mkdir -p $@
 	-python -c 'import sys; sys.exit(not sys.version_info > (3, 0))' && \
 	/usr/bin/python2 -c 'import sys; sys.exit(not sys.version_info < (3, 0))' && \
-	ln -sf /usr/bin/python2 "llvm-$(LLVM_VER)/python2_path/python" && \
-	ln -sf /usr/bin/python2-config "llvm-$(LLVM_VER)/python2_path/python-config"
-LLVM_FLAGS += --with-python="$(shell ./find_python2)"
-# LLDB still relies on plenty of python 2.x infrastructure, without checking
-ifeq ($(BUILD_LLDB),1)
-llvm_python_workaround=llvm-$(LLVM_VER)/python2_path
-endif
+	ln -sf /usr/bin/python2 "$@/python" && \
+	ln -sf /usr/bin/python2-config "$@/python-config"
+LLVM_FLAGS += --with-python="$(shell $(SRCDIR)/find_python2)"
 
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
 
 ifeq ($(USEICC),1)
-LIBCXX_EXTRA_FLAGS = -Bstatic -lirc -Bdynamic
+LIBCXX_EXTRA_FLAGS := -Bstatic -lirc -Bdynamic
 endif
 
-llvm-$(LLVM_VER)/projects/libcxx: $(LLVM_LIBCXX_TAR) | llvm-svn/configure
-	([ ! -d llvm-$(LLVM_VER)/projects/libcxx ] && \
-	git clone $(LLVM_GIT_URL_LIBCXX) llvm-$(LLVM_VER)/projects/libcxx  ) || \
-	(cd llvm-$(LLVM_VER)/projects/libcxx  && \
+$(LLVM_SRC_DIR)/projects/libcxx: $(LLVM_LIBCXX_TAR) | $(LLVM_SRC_DIR)/configure
+	([ ! -d $@ ] && \
+	git clone $(LLVM_GIT_URL_LIBCXX) $@  ) || \
+	(cd $@  && \
 	git pull --ff-only)
-llvm-$(LLVM_VER)/projects/libcxxabi: $(LLVM_LIBCXXABI_TAR) | llvm-svn/configure
-	([ ! -d llvm-$(LLVM_VER)/projects/libcxxabi ] && \
-	git clone $(LLVM_GIT_URL_LIBCXXABI) llvm-$(LLVM_VER)/projects/libcxxabi  ) || \
-	(cd llvm-$(LLVM_VER)/projects/libcxxabi  && \
+$(LLVM_SRC_DIR)/projects/libcxx/.git/HEAD: | $(LLVM_SRC_DIR)/projects/libcxx/.git/HEAD
+$(LLVM_SRC_DIR)/projects/libcxxabi: $(LLVM_LIBCXXABI_TAR) | $(LLVM_SRC_DIR)/configure
+	([ ! -d $@ ] && \
+	git clone $(LLVM_GIT_URL_LIBCXXABI) $@ ) || \
+	(cd $@ && \
 	git pull --ff-only)
-libcxx-build:
-	mkdir -p libcxx-build
-libcxx-build/Makefile: llvm-$(LLVM_VER)/projects/libcxx | llvm-$(LLVM_VER)/projects/libcxxabi libcxx-build
-	cd libcxx-build && \
-		$(CMAKE) -G "Unix Makefiles" $(CMAKE_COMMON) $(LLVM_CMAKE) -DLIBCXX_CXX_ABI=libcxxabi -DLIBCXX_CXX_ABI_INCLUDE_PATHS="../llvm-$(LLVM_VER)/projects/libcxxabi/include" ../llvm-$(LLVM_VER)/projects/libcxx -DCMAKE_SHARED_LINKER_FLAGS="-L$(build_libdir) $(LIBCXX_EXTRA_FLAGS)" -DCMAKE_CXX_FLAGS="$(CXXFLAGS)"
-libcxxabi-build:
-	mkdir -p libcxxabi-build
-libcxxabi-build/Makefile: llvm-$(LLVM_VER)/projects/libcxxabi | llvm-$(LLVM_VER)/projects/libcxx libcxxabi-build
-	cd libcxxabi-build && \
-        $(CMAKE) -G "Unix Makefiles" $(CMAKE_COMMON) $(LLVM_CMAKE) -DLLVM_ABI_BREAKING_CHECKS="WITH_ASSERTS" -DLLVM_PATH="../llvm-$(LLVM_VER)" ../llvm-$(LLVM_VER)/projects/libcxxabi -DLIBCXXABI_CXX_ABI_LIBRARIES="$(LIBCXX_EXTRA_FLAGS)" -DCMAKE_CXX_FLAGS="$(CXXFLAGS) -std=c++11"
-llvm-$(LLVM_VER)/projects/libcxxabi/lib/libc++abi.so.1.0: llvm-$(LLVM_VER)/projects/libcxxabi | llvm-$(LLVM_VER)/projects/libcxx
-libcxxabi-build/lib/libc++abi.so.1.0: | libcxxabi-build/Makefile
-	cd libcxxabi-build && $(MAKE)
-$(build_libdir)/libc++abi.so.1.0: libcxxabi-build/lib/libc++abi.so.1.0
-	cd libcxxabi-build && $(MAKE) install
-	touch $@
+$(LLVM_SRC_DIR)/projects/libcxxabi/.git/HEAD: | $(LLVM_SRC_DIR)/projects/libcxxabi
+$(LLVM_BUILD_DIR)/libcxx-build/Makefile: | $(LLVM_SRC_DIR)/projects/libcxx $(LLVM_SRC_DIR)/projects/libcxxabi
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+		$(CMAKE) -G "Unix Makefiles" $(CMAKE_COMMON) $(LLVM_CMAKE) -DLIBCXX_CXX_ABI=libcxxabi -DLIBCXX_CXX_ABI_INCLUDE_PATHS="$(LLVM_SRC_DIR)/projects/libcxxabi/include" $(LLVM_SRC_DIR)/projects/libcxx -DCMAKE_SHARED_LINKER_FLAGS="-L$(build_libdir) $(LIBCXX_EXTRA_FLAGS)" -DCMAKE_CXX_FLAGS="$(CXXFLAGS)"
+$(LLVM_BUILD_DIR)/libcxxabi-build/Makefile: | $(LLVM_SRC_DIR)/projects/libcxxabi $(LLVM_SRC_DIR)/projects/libcxx
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+        $(CMAKE) -G "Unix Makefiles" $(CMAKE_COMMON) $(LLVM_CMAKE) -DLLVM_ABI_BREAKING_CHECKS="WITH_ASSERTS" -DLLVM_PATH="$(LLVM_SRC_DIR)" $(LLVM_SRC_DIR)/projects/libcxxabi -DLIBCXXABI_CXX_ABI_LIBRARIES="$(LIBCXX_EXTRA_FLAGS)" -DCMAKE_CXX_FLAGS="$(CXXFLAGS) -std=c++11"
+$(LLVM_BUILD_DIR)/libcxxabi-build/lib/libc++abi.so.1.0: $(LLVM_BUILD_DIR)/libcxxabi-build/Makefile $(LLVM_SRC_DIR)/projects/libcxxabi/.git/HEAD
+	$(MAKE) -C $(LLVM_BUILD_DIR)/libcxxabi-build
+	touch -c $@
+$(build_libdir)/libc++abi.so.1.0: $(LLVM_BUILD_DIR)/libcxxabi-build/lib/libc++abi.so.1.0
+	$(MAKE) -C $(LLVM_BUILD_DIR)/libcxxabi-build install
+	touch -c $@
+$(LLVM_BUILD_DIR)/libcxx-build/lib/libc++.so.1.0: $(build_libdir)/libc++abi.so.1.0 $(LLVM_BUILD_DIR)/libcxx-build/Makefile $(LLVM_SRC_DIR)/projects/libcxx/.git/HEAD
+	$(MAKE) -C $(LLVM_BUILD_DIR)/libcxx-build
+$(build_libdir)/libc++.so.1.0: $(LLVM_BUILD_DIR)/libcxx-build/lib/libc++.so.1.0
+	$(MAKE) -C $(LLVM_BUILD_DIR)/libcxx-build install
+	touch -c $@
+get-libcxx: $(LLVM_SRC_DIR)/projects/libcxx
+get-libcxxabi: $(LLVM_SRC_DIR)/projects/libcxxabi
 install-libcxxabi: $(build_libdir)/libc++abi.so.1.0
-libcxx-build/lib/libc++.so.1.0: | $(build_libdir)/libc++abi.so.1.0 libcxx-build/Makefile
-	cd libcxx-build && $(MAKE)
-$(build_libdir)/libc++.so.1.0: libcxx-build/lib/libc++.so.1.0
-	cd libcxx-build && $(MAKE) install
-	touch $@
 install-libcxx: $(build_libdir)/libc++.so.1.0
-get-libcxx: llvm-$(LLVM_VER)/projects/libcxx
-get-libcxxabi: llvm-$(LLVM_VER)/projects/libcxxabi
 endif
 
 ifeq ($(BUILD_CUSTOM_LIBCXX),1)
-LIBCXX_DEPENDENCY = $(build_libdir)/libc++abi.so.1.0 $(build_libdir)/libc++.so.1.0
-LIBCXX_GET_DEPENDENCY = get-libcxx get-libcxxabi
+LIBCXX_DEPENDENCY := $(build_libdir)/libc++abi.so.1.0 $(build_libdir)/libc++.so.1.0
+get-llvm: get-libcxx get-libcxxabi
 endif
 
-llvm-$(LLVM_VER)/configure: $(LLVM_TAR) $(LLVM_CLANG_TAR) $(LLVM_COMPILER_RT_TAR) $(LLVM_LIBCXX_TAR) $(LLVM_LLDB_TAR)
+$(LLVM_SRC_DIR)/configure: $(LLVM_TAR) $(LLVM_CLANG_TAR) $(LLVM_COMPILER_RT_TAR) $(LLVM_LIBCXX_TAR) $(LLVM_LLDB_TAR)
 ifneq ($(LLVM_CLANG_TAR),)
 	$(JLCHECKSUM) $(LLVM_CLANG_TAR)
 endif
@@ -558,177 +658,191 @@ ifneq ($(LLVM_LLDB_TAR),)
 	$(JLCHECKSUM) $(LLVM_LLDB_TAR)
 endif
 ifneq ($(LLVM_VER),svn)
-	mkdir -p llvm-$(LLVM_VER) && \
-	$(TAR) -C llvm-$(LLVM_VER) --strip-components 1 -xf $(LLVM_TAR)
+	mkdir -p $(LLVM_SRC_DIR)
+	$(TAR) -C $(LLVM_SRC_DIR) --strip-components 1 -xf $(LLVM_TAR)
 else
-	([ ! -d llvm-$(LLVM_VER) ] && \
-		git clone $(LLVM_GIT_URL_LLVM) llvm-$(LLVM_VER) ) || \
-		(cd llvm-$(LLVM_VER) && \
+	([ ! -d $(LLVM_SRC_DIR) ] && \
+		git clone $(LLVM_GIT_URL_LLVM) $(LLVM_SRC_DIR) ) || \
+		(cd $(LLVM_SRC_DIR) && \
 		git pull --ff-only)
 ifneq ($(LLVM_GIT_VER),)
-	(cd llvm-$(LLVM_VER) && \
+	(cd $(LLVM_SRC_DIR) && \
 		git checkout $(LLVM_GIT_VER))
 endif # LLVM_GIT_VER
 endif # LLVM_VER
 ifneq ($(LLVM_VER),svn)
 ifneq ($(LLVM_CLANG_TAR),)
-	mkdir -p llvm-$(LLVM_VER)/tools/clang && \
-	$(TAR) -C llvm-$(LLVM_VER)/tools/clang --strip-components 1 -xf $(LLVM_CLANG_TAR)
+	mkdir -p $(LLVM_SRC_DIR)/tools/clang
+	$(TAR) -C $(LLVM_SRC_DIR)/tools/clang --strip-components 1 -xf $(LLVM_CLANG_TAR)
 endif # LLVM_CLANG_TAR
 ifneq ($(LLVM_COMPILER_RT_TAR),)
-	mkdir -p llvm-$(LLVM_VER)/projects/compiler-rt && \
-	$(TAR) -C llvm-$(LLVM_VER)/projects/compiler-rt --strip-components 1 -xf $(LLVM_COMPILER_RT_TAR)
+	mkdir -p $(LLVM_SRC_DIR)/projects/compiler-rt
+	$(TAR) -C $(LLVM_SRC_DIR)/projects/compiler-rt --strip-components 1 -xf $(LLVM_COMPILER_RT_TAR)
 endif # LLVM_COMPILER_RT_TAR
 ifneq ($(LLVM_LLDB_TAR),)
-	mkdir -p llvm-$(LLVM_VER)/tools/lldb && \
-	$(TAR) -C llvm-$(LLVM_VER)/tools/lldb --strip-components 1 -xf $(LLVM_LLDB_TAR)
+	mkdir -p $(LLVM_SRC_DIR)/tools/lldb
+	$(TAR) -C $(LLVM_SRC_DIR)/tools/lldb --strip-components 1 -xf $(LLVM_LLDB_TAR)
 endif # LLVM_LLDB_TAR
-else
+else # LLVM_VER
 ifeq ($(BUILD_LLVM_CLANG),1)
-	([ ! -d llvm-$(LLVM_VER)/tools/clang ] && \
-		git clone $(LLVM_GIT_URL_CLANG) llvm-$(LLVM_VER)/tools/clang  ) || \
-		(cd llvm-$(LLVM_VER)/tools/clang  && \
+	([ ! -d $(LLVM_SRC_DIR)/tools/clang ] && \
+		git clone $(LLVM_GIT_URL_CLANG) $(LLVM_SRC_DIR)/tools/clang  ) || \
+		(cd $(LLVM_SRC_DIR)/tools/clang  && \
+		git pull --ff-only)
+	([ ! -d $(LLVM_SRC_DIR)/projects/compiler-rt ] && \
+		git clone $(LLVM_GIT_URL_COMPILER_RT) $(LLVM_SRC_DIR)/projects/compiler-rt  ) || \
+		(cd $(LLVM_SRC_DIR)/projects/compiler-rt  && \
 		git pull --ff-only)
+ifneq ($(LLVM_GIT_VER_CLANG),)
+	(cd $(LLVM_SRC_DIR)/tools/clang && \
+		git checkout $(LLVM_GIT_VER_CLANG))
+endif # LLVM_GIT_VER_CLANG
 endif # BUILD_LLVM_CLANG
 ifeq ($(BUILD_LLDB),1)
-	([ ! -d llvm-$(LLVM_VER)/tools/lldb ] && \
-		git clone $(LLVM_GIT_URL_LLDB) llvm-$(LLVM_VER)/tools/lldb  ) || \
-		(cd llvm-$(LLVM_VER)/tools/lldb  && \
+	([ ! -d $(LLVM_SRC_DIR)/tools/lldb ] && \
+		git clone $(LLVM_GIT_URL_LLDB) $(LLVM_SRC_DIR)/tools/lldb  ) || \
+		(cd $(LLVM_SRC_DIR)/tools/lldb  && \
 		git pull --ff-only)
+ifneq ($(LLVM_GIT_VER_LLDB),)
+	(cd $(LLVM_SRC_DIR)/tools/lldb && \
+		git checkout $(LLVM_GIT_VER_LLDB))
+endif # LLVM_GIT_VER_CLANG
 endif # BUILD_LLDB
 endif # LLVM_VER
-ifeq ($(LLVM_VER),svn)
-ifeq ($(BUILD_LLVM_CLANG),1)
-	([ ! -d llvm-$(LLVM_VER)/tools/clang ] && \
-		git clone $(LLVM_GIT_URL_CLANG) llvm-$(LLVM_VER)/tools/clang  ) || \
-		(cd llvm-$(LLVM_VER)/tools/clang  && \
-		git pull --ff-only)
-	([ ! -d llvm-$(LLVM_VER)/projects/compiler-rt ] && \
-		git clone $(LLVM_GIT_URL_COMPILER_RT) llvm-$(LLVM_VER)/projects/compiler-rt  ) || \
-		(cd llvm-$(LLVM_VER)/projects/compiler-rt  && \
-		git pull --ff-only)
-ifneq ($(LLVM_CLANG_VER),)
-	(cd llvm-$(LLVM_VER) && \
-		git checkout $(LLVM_GIT_VER))
-endif # LLVM_CLANG_VER
-endif # BUILD_LLVM_CLANG
-endif # LLVM_VER
+	touch -c $@
 
 # Apply version-specific LLVM patches
+LLVM_PATCH_LIST:=
+define LLVM_PATCH
+$$(LLVM_SRC_DIR)/$1.patch-applied: $(LLVM_SRC_DIR)/configure | $$(SRCDIR)/$1.patch
+	cd $$(LLVM_SRC_DIR) && patch -p1 < $$(SRCDIR)/$1.patch
+	echo 1 > $$@
+LLVM_PATCH_LIST += $$(LLVM_SRC_DIR)/$1.patch-applied
+endef
 ifeq ($(LLVM_VER),3.3)
-	patch -p0 < llvm-3.3.patch
-	patch -p0 < instcombine-llvm-3.3.patch
-	patch -p0 < int128-vector.llvm-3.3.patch
-	(cd llvm-$(LLVM_VER) && patch < ../osx-10.10.llvm-3.3.patch)
-
-ifeq ($(OS),WINNT)
-ifeq ($(ARCH),x86_64)
-	patch -p0 < win64-int128.llvm-3.3.patch
-endif # x86_64
-endif # WINNT
-
-else ifeq ($(LLVM_VER),3.6.0)
-	cd llvm-3.6.0 && patch -p1 < ../zerosign-llvm-3.6.0.patch
-ifeq ($(OS),WINNT)
-ifeq ($(ARCH),x86_64)
-	cd llvm-3.6.0 && patch -p1 < ../win64-allocas-llvm-3.6.0.patch
-endif # x86_64
-endif # WINNT
-
+$(eval $(call LLVM_PATCH,llvm-3.3))
+$(eval $(call LLVM_PATCH,instcombine-llvm-3.3))
+$(eval $(call LLVM_PATCH,int128-vector.llvm-3.3))
+$(eval $(call LLVM_PATCH,osx-10.10.llvm-3.3))
+$(eval $(call LLVM_PATCH,win64-int128.llvm-3.3))
+else ifeq ($(LLVM_VER),3.7.0)
+$(eval $(call LLVM_PATCH,llvm-3.7.0))
+$(eval $(call LLVM_PATCH,llvm-3.7.1))
+$(eval $(call LLVM_PATCH,llvm-3.7.1_2))
+$(eval $(call LLVM_PATCH,llvm-3.7.1_3))
+$(eval $(call LLVM_PATCH,llvm-D14260))
+$(LLVM_SRC_DIR)/llvm-3.7.1_2.patch-applied: $(LLVM_SRC_DIR)/llvm-3.7.1.patch-applied
+else ifeq ($(LLVM_VER),3.7.1)
+$(eval $(call LLVM_PATCH,llvm-3.7.1))
+$(eval $(call LLVM_PATCH,llvm-3.7.1_2))
+$(eval $(call LLVM_PATCH,llvm-3.7.1_3))
+$(eval $(call LLVM_PATCH,llvm-D14260))
+$(LLVM_SRC_DIR)/llvm-3.7.1_2.patch-applied: $(LLVM_SRC_DIR)/llvm-3.7.1.patch-applied
 endif # LLVM_VER
-	touch -c $@
-# end target llvm-$(LLVM_VER)/configure
 
-LLVM_BUILDDIR = llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE)
-ifneq ($(LLVM_USE_CMAKE),)
+ifeq ($(LLVM_VER),3.7.1)
+ifeq ($(BUILD_LLDB),1)
+$(eval $(call LLVM_PATCH,lldb-3.7.1))
+endif
+ifeq ($(BUILD_LLVM_CLANG),1)
+$(eval $(call LLVM_PATCH,compiler-rt-3.7.1))
+endif
+endif
 
-$(LLVM_BUILDDIR)/CMakeCache.txt: llvm-$(LLVM_VER)/configure | $(llvm_python_workaround) $(LIBCXX_DEPENDENCY)
-	cd llvm-$(LLVM_VER) && \
-	mkdir -p build_$(LLVM_BUILDTYPE) && cd build_$(LLVM_BUILDTYPE) && \
-	export PATH=$(abspath llvm-$(LLVM_VER)/python2_path):$$PATH && \
-	$(CMAKE) .. $(CMAKE_GENERATOR_COMMAND) $(CMAKE_COMMON) $(LLVM_CMAKE)
+ifeq ($(LLVM_USE_CMAKE),1)
+
+$(LLVM_BUILDDIR_withtype)/CMakeCache.txt: $(LLVM_SRC_DIR)/configure $(LLVM_PATCH_LIST) | $(llvm_python_workaround) $(LIBCXX_DEPENDENCY)
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+		export PATH=$(llvm_python_workaround):$$PATH && \
+		$(CMAKE) $(LLVM_SRC_DIR) $(CMAKE_GENERATOR_COMMAND) $(CMAKE_COMMON) $(LLVM_CMAKE)
 	touch -c $@
 
-$(LLVM_OBJ_SOURCE): $(LLVM_BUILDDIR)/CMakeCache.txt | $(llvm_python_workaround)
-	cd llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE) && \
-	export PATH=$(abspath llvm-$(LLVM_VER)/python2_path):$$PATH && \
-	$(CMAKE) --build .
+$(LLVM_OBJ_SOURCE): $(LLVM_BUILDDIR_withtype)/CMakeCache.txt | $(llvm_python_workaround)
+	cd $(LLVM_BUILDDIR_withtype) && \
+		export PATH=$(llvm_python_workaround):$$PATH && \
+		$(if $(filter $(CMAKE_GENERATOR),make), \
+		  $(MAKE), \
+		  $(CMAKE) --build .)
 	touch -c $@
 
 else
 
-$(LLVM_BUILDDIR)/config.status: llvm-$(LLVM_VER)/configure | $(llvm_python_workaround) $(LIBCXX_DEPENDENCY)
-	cd llvm-$(LLVM_VER) && \
-	mkdir -p build_$(LLVM_BUILDTYPE) && cd build_$(LLVM_BUILDTYPE) && \
-	export PATH=$(abspath llvm-$(LLVM_VER)/python2_path):$$PATH && \
-	../configure $(CONFIGURE_COMMON) $(LLVM_CC) $(LLVM_FLAGS)
+$(LLVM_BUILDDIR_withtype)/config.status: $(LLVM_SRC_DIR)/configure $(LLVM_PATCH_LIST) | $(llvm_python_workaround) $(LIBCXX_DEPENDENCY)
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+		export PATH=$(llvm_python_workaround):$$PATH && \
+		$< $(CONFIGURE_COMMON) $(LLVM_CC) $(LLVM_FLAGS)
 	touch -c $@
 
-$(LLVM_OBJ_SOURCE): $(LLVM_BUILDDIR)/config.status | $(llvm_python_workaround)
-	cd llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE) && \
-	export PATH=$(abspath llvm-$(LLVM_VER)/python2_path):$$PATH && \
-	$(MAKE) $(LLVM_MFLAGS) $(MAKE_COMMON)
+$(LLVM_OBJ_SOURCE): $(LLVM_BUILDDIR_withtype)/config.status | $(llvm_python_workaround)
+	cd $(LLVM_BUILDDIR_withtype) && \
+		export PATH=$(llvm_python_workaround):$$PATH && \
+		$(MAKE) $(LLVM_MFLAGS) $(MAKE_COMMON)
 	touch -c $@
 
 endif # LLVM_USE_CMAKE
 
-ifeq ($(LLVM_USE_CMAKE),1)
-CHECK_COMMAND = $(CMAKE) --build . check
-else
-CHECK_COMMAND = $(MAKE) $(LLVM_MFLAGS) check
-endif
-$(LLVM_BUILDDIR)/checked: $(LLVM_OBJ_SOURCE) | $(llvm_python_workaround)
+$(LLVM_BUILDDIR_withtype)/checked: $(LLVM_OBJ_SOURCE) | $(llvm_python_workaround)
 ifeq ($(OS),$(BUILD_OS))
-	cd llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE) && \
-	export PATH=$(abspath llvm-$(LLVM_VER)/python2_path):$$PATH && \
-	$(CHECK_COMMAND)
+	cd $(LLVM_BUILDDIR_withtype) && \
+		export PATH=$(llvm_python_workaround):$$PATH && \
+		$(if $(filter $(LLVM_USE_CMAKE),1), \
+		  $(CMAKE) --build . check, \
+		  $(MAKE) $(LLVM_MFLAGS) check)
 endif
 	echo 1 > $@
-
 $(LLVM_OBJ_TARGET): $(LLVM_OBJ_SOURCE) | $(llvm_python_workaround)
 ifeq ($(LLVM_USE_CMAKE),1)
-	$(call staged-install,$(LLVM_BUILDDIR),cd $(LLVM_BUILDDIR) && $(CMAKE) -DCMAKE_INSTALL_PREFIX="$(call MAKE_DESTDIR,$(LLVM_BUILDDIR))$(build_prefix)" -P cmake_install.cmake)
+	$(call staged-install,llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE),\
+	                      cd $(BUILDDIR)/llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE) &&\
+	                      $(CMAKE) -DCMAKE_INSTALL_PREFIX="$(call MAKE_DESTDIR,llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE))$(build_prefix)" -P cmake_install.cmake)
 else
-	$(call make-install,$(LLVM_BUILDDIR),$(LLVM_MFLAGS) PATH="$(abspath llvm-$(LLVM_VER)/python2_path):$$PATH")
+	$(call   make-install,llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE),\
+	                      $(LLVM_MFLAGS) PATH="$(llvm_python_workaround):$$PATH")
 endif # LLVM_USE_CMAKE
 	touch -c $@
 
 reinstall-llvm:
 	-rm $(LLVM_OBJ_TARGET)
-	$(MAKE) -s install-llvm
+	$(MAKE) -f $(SRCDIR)/Makefile -s install-llvm
 
 clean-llvm:
-	-$(MAKE) -C llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE) clean
+	-$(MAKE) -C $(LLVM_BUILDDIR_withtype) clean
 	-rm -f $(build_bindir)/llvm-config
 distclean-llvm:
-	-rm -rf llvm-$(LLVM_VER).tar.gz llvm-$(LLVM_VER).src.tar.gz clang-$(LLVM_VER).src.tar.gz clang-$(LLVM_VER).tar.gz libcxx-$(LLVM_VER).src.tar.gz compiler-rt-$(LLVM_VER).src.tar.gz llvm-$(LLVM_VER)
+	-rm -rf $(LLVM_TAR) $(LLVM_CLANG_TAR) \
+		$(LLVM_COMPILER_RT_TAR) $(LLVM_LIBCXX_TAR) $(LLVM_LLDB_TAR) \
+		$(LLVM_SRC_DIR) $(LLVM_BUILDDIR_withtype)
 
 ifneq ($(LLVM_VER),svn)
 get-llvm: $(LLVM_TAR) $(LLVM_CLANG_TAR) $(LLVM_COMPILER_RT_TAR) $(LLVM_LIBCXX_TAR) $(LLVM_LLDB_TAR)
 else
-get-llvm: llvm-$(LLVM_VER)/configure $(LIBCXX_GET_DEPENDENCY)
+get-llvm: $(LLVM_SRC_DIR)/configure
 endif
-configure-llvm: llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE)/config.status
+configure-llvm: $(LLVM_BUILDDIR_withtype)/config.status
 compile-llvm: $(LLVM_OBJ_SOURCE)
-check-llvm: llvm-$(LLVM_VER)/build_$(LLVM_BUILDTYPE)/checked
+check-llvm: $(LLVM_BUILDDIR_withtype)/checked
 install-llvm: $(LLVM_OBJ_TARGET)
 #todo: LLVM make check target is broken on julia.mit.edu (and really slow elsewhere)
 
+ifeq ($(LLVM_VER),svn)
 update-llvm:
-	(cd llvm-$(LLVM_VER); git pull --ff-only)
-	([ -d "llvm-$(LLVM_VER)/tools/clang"  ] || exit 0;          cd llvm-$(LLVM_VER)/tools/clang; git pull --ff-only)
-	([ -d "llvm-$(LLVM_VER)/projects/compiler-rt" ] || exit 0;  cd llvm-$(LLVM_VER)/projects/compiler-rt; git pull --ff-only)
-	([ -d "llvm-$(LLVM_VER)/tools/lldb" ] || exit 0;            cd llvm-$(LLVM_VER)/tools/lldb; git pull --ff-only)
+	(cd $(LLVM_SRC_DIR); git pull --ff-only)
+	([ -d "$(LLVM_SRC_DIR)/tools/clang"  ] || exit 0;          cd $(LLVM_SRC_DIR)/tools/clang; git pull --ff-only)
+	([ -d "$(LLVM_SRC_DIR)/projects/compiler-rt" ] || exit 0;  cd $(LLVM_SRC_DIR)/projects/compiler-rt; git pull --ff-only)
+	([ -d "$(LLVM_SRC_DIR)/tools/lldb" ] || exit 0;            cd $(LLVM_SRC_DIR)/tools/lldb; git pull --ff-only)
+endif
 
 ## LIBUV ##
-LIBUV_GIT_URL=git://github.com/JuliaLang/libuv.git
+LIBUV_GIT_URL:=git://github.com/JuliaLang/libuv.git
 LIBUV_TAR_URL=https://api.github.com/repos/JuliaLang/libuv/tarball/$1
-$(eval $(call git-external,libuv,LIBUV,configure,.libs/libuv.la))
+$(eval $(call git-external,libuv,LIBUV,configure,.libs/libuv.la,$(SRCDIR)/srccache))
 
-UV_SRC_TARGET = $(LIBUV_SRC_DIR)/.libs/libuv.la
-UV_OBJ_TARGET = $(build_libdir)/libuv.la
+UV_SRC_TARGET := $(BUILDDIR)/$(LIBUV_SRC_DIR)/.libs/libuv.la
+UV_OBJ_TARGET := $(build_libdir)/libuv.la
 
-UV_CFLAGS =
+UV_CFLAGS :=
 ifeq ($(USEMSVC), 1)
 UV_CFLAGS += -DBUILDING_UV_SHARED
 endif
@@ -744,73 +858,76 @@ ifneq ($(VERBOSE), 0)
 UV_MFLAGS += V=1
 endif
 ifneq ($(USEMSVC), 1)
-UV_FLAGS = $(UV_MFLAGS)
+UV_FLAGS := $(UV_MFLAGS)
 else
-UV_FLAGS = --disable-shared $(UV_MFLAGS)
+UV_FLAGS := --disable-shared $(UV_MFLAGS)
 endif
 
-$(LIBUV_SRC_DIR)/config.status: $(LIBUV_SRC_DIR)/configure
-	touch -c $(LIBUV_SRC_DIR)/aclocal.m4 # touch a few files to prevent autogen from getting called
-	touch -c $(LIBUV_SRC_DIR)/Makefile.in
-	touch -c $(LIBUV_SRC_DIR)/configure
-	cd $(LIBUV_SRC_DIR) && \
-	./configure --with-pic $(CONFIGURE_COMMON) $(UV_FLAGS)
+$(BUILDDIR)/$(LIBUV_SRC_DIR)/config.status: $(SRCDIR)/srccache/$(LIBUV_SRC_DIR)/configure
+	touch -c $(SRCDIR)/srccache/$(LIBUV_SRC_DIR)/aclocal.m4 # touch a few files to prevent autogen from getting called
+	touch -c $(SRCDIR)/srccache/$(LIBUV_SRC_DIR)/Makefile.in
+	touch -c $(SRCDIR)/srccache/$(LIBUV_SRC_DIR)/configure
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< --with-pic $(CONFIGURE_COMMON) $(UV_FLAGS)
 	touch -c $@
-$(UV_SRC_TARGET): $(LIBUV_SRC_DIR)/config.status
-	$(MAKE) -C $(LIBUV_SRC_DIR) $(UV_MFLAGS)
+$(UV_SRC_TARGET): $(BUILDDIR)/$(LIBUV_SRC_DIR)/config.status
+	$(MAKE) -C $(dir $<) $(UV_MFLAGS)
 	touch -c $@
-$(LIBUV_SRC_DIR)/checked: $(UV_SRC_TARGET)
+$(BUILDDIR)/$(LIBUV_SRC_DIR)/checked: $(UV_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
-	-$(MAKE) -C $(LIBUV_SRC_DIR) check
+	-$(MAKE) -C $(dir $@) check
 endif
 	echo 1 > $@
 $(UV_OBJ_TARGET): $(UV_SRC_TARGET)
 	$(call make-install,$(LIBUV_SRC_DIR),)
 	$(INSTALL_NAME_CMD)libuv.$(SHLIB_EXT) $(build_shlibdir)/libuv.$(SHLIB_EXT)
+	touch -c $@
 
 clean-libuv:
-	-$(MAKE) -C $(LIBUV_SRC_DIR) clean
+	-$(MAKE) -C $(BUILDDIR)/$(LIBUV_SRC_DIR) clean
 	-rm -rf $(build_libdir)/libuv.a $(build_libdir)/libuv.la $(build_includedir)/libuv.h $(build_includedir)/libuv-private
 
-get-libuv: $(LIBUV_SRC_DIR)/configure
-configure-libuv: $(LIBUV_SRC_DIR)/config.status
+get-libuv: $(LIBUV_SRC_FILE)
+configure-libuv: $(BUILDDIR)/$(LIBUV_SRC_DIR)/config.status
 compile-libuv: $(UV_SRC_TARGET)
-check-libuv: $(LIBUV_SRC_DIR)/checked
+check-libuv: $(BUILDDIR)/$(LIBUV_SRC_DIR)/checked
 install-libuv: $(UV_OBJ_TARGET)
 
 
 ## PCRE ##
 
-PCRE_SRC_TARGET = pcre2-$(PCRE_VER)/.libs/libpcre2-8.$(SHLIB_EXT)
-PCRE_OBJ_TARGET = $(build_shlibdir)/libpcre2-8.$(SHLIB_EXT)
+PCRE_SRC_TARGET := $(BUILDDIR)/pcre2-$(PCRE_VER)/.libs/libpcre2-8.$(SHLIB_EXT)
+PCRE_OBJ_TARGET := $(build_shlibdir)/libpcre2-8.$(SHLIB_EXT)
 
 # Force optimization for PCRE flags (Issue #11668)
-PCRE_CFLAGS = -O3
+PCRE_CFLAGS := -O3
 ifneq ($(OS),WINNT)
-PCRE_LDFLAGS = "-Wl,-rpath,'$(build_libdir)'"
+PCRE_LDFLAGS := "-Wl,-rpath,'$(build_libdir)'"
 endif
 
-pcre2-$(PCRE_VER).tar.bz2:
+$(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ https://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre2-$(PCRE_VER).tar.bz2
-pcre2-$(PCRE_VER)/configure: pcre2-$(PCRE_VER).tar.bz2
+$(SRCDIR)/srccache/pcre2-$(PCRE_VER)/configure: $(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2
 	$(JLCHECKSUM) $<
-	$(TAR) jxf $<
+	cd $(dir $<) && $(TAR) jxf $(notdir $<)
 	touch -c $@
-pcre2-$(PCRE_VER)/config.status: pcre2-$(PCRE_VER)/configure
-	cd pcre2-$(PCRE_VER) && \
-	./configure $(CONFIGURE_COMMON) --enable-jit --includedir=$(build_includedir) CFLAGS="$(CFLAGS) $(PCRE_CFLAGS)" LDFLAGS="$(LDFLAGS) $(PCRE_LDFLAGS)"
+$(BUILDDIR)/pcre2-$(PCRE_VER)/config.status: $(SRCDIR)/srccache/pcre2-$(PCRE_VER)/configure
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(CONFIGURE_COMMON) --enable-jit --includedir=$(build_includedir) CFLAGS="$(CFLAGS) $(PCRE_CFLAGS)" LDFLAGS="$(LDFLAGS) $(PCRE_LDFLAGS)"
 	touch -c $@
-$(PCRE_SRC_TARGET): pcre2-$(PCRE_VER)/config.status
-	$(MAKE) -C pcre2-$(PCRE_VER) $(LIBTOOL_CCLD)
+$(PCRE_SRC_TARGET): $(BUILDDIR)/pcre2-$(PCRE_VER)/config.status
+	$(MAKE) -C $(dir $<) $(LIBTOOL_CCLD)
 	touch -c $@
-pcre2-$(PCRE_VER)/checked: $(PCRE_SRC_TARGET)
+$(BUILDDIR)/pcre2-$(PCRE_VER)/checked: $(PCRE_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
 ifneq ($(OS),WINNT)
-	$(MAKE) -C pcre2-$(PCRE_VER) check -j1
+	$(MAKE) -C $(dir $@) check -j1
 endif
 endif
 	echo 1 > $@
-$(PCRE_OBJ_TARGET): $(PCRE_SRC_TARGET) pcre2-$(PCRE_VER)/checked
+$(PCRE_OBJ_TARGET): $(PCRE_SRC_TARGET)
 	$(call make-install,pcre2-$(PCRE_VER),$(LIBTOOL_CCLD))
 	$(INSTALL_NAME_CMD)libpcre2-8.$(SHLIB_EXT) $@
 	touch -c $@
@@ -818,30 +935,27 @@ $(PCRE_OBJ_TARGET): $(PCRE_SRC_TARGET) pcre2-$(PCRE_VER)/checked
 clean-pcre:
 	-$(MAKE) -C pcre2-$(PCRE_VER) clean
 	-rm -f $(build_shlibdir)/libpcre*
-distclean-pcre: clean-pcre
-	-rm -rf pcre2-$(PCRE_VER).tar.bz2 pcre2-$(PCRE_VER)
+distclean-pcre:
+	-rm -rf $(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2 $(SRCDIR)/srccache/pcre2-$(PCRE_VER) $(BUILDDIR)/pcre2-$(PCRE_VER)
 
-get-pcre: pcre2-$(PCRE_VER).tar.bz2
-configure-pcre: pcre2-$(PCRE_VER)/config.status
+get-pcre: $(SRCDIR)/srccache/pcre2-$(PCRE_VER).tar.bz2
+configure-pcre: $(BUILDDIR)/pcre2-$(PCRE_VER)/config.status
 compile-pcre: $(PCRE_SRC_TARGET)
-check-pcre: pcre2-$(PCRE_VER)/checked
+check-pcre: $(BUILDDIR)/pcre2-$(PCRE_VER)/checked
 install-pcre: $(PCRE_OBJ_TARGET)
 
 
 ## openlibm ##
-OPENLIBM_GIT_URL = git://github.com/JuliaLang/openlibm.git
+OPENLIBM_GIT_URL := git://github.com/JuliaLang/openlibm.git
 OPENLIBM_TAR_URL = https://api.github.com/repos/JuliaLang/openlibm/tarball/$1
-$(eval $(call git-external,openlibm,OPENLIBM,Makefile,libopenlibm.$(SHLIB_EXT)))
+$(eval $(call git-external,openlibm,OPENLIBM,Makefile,libopenlibm.$(SHLIB_EXT),$(BUILDDIR)))
 
-OPENLIBM_OBJ_TARGET = $(build_shlibdir)/libopenlibm.$(SHLIB_EXT) $(build_libdir)/libopenlibm.a
-OPENLIBM_OBJ_SOURCE = $(OPENLIBM_SRC_DIR)/libopenlibm.$(SHLIB_EXT)
-OPENLIBM_FLAGS = ARCH="$(ARCH)" CC="$(CC)" FC="$(FC)" AR="$(AR)" OS="$(OS)" USECLANG=$(USECLANG) USEGCC=$(USEGCC)
-ifeq (CYGWIN,$(findstring CYGWIN,$(BUILD_OS)))
-OPENLIBM_FLAGS += OPENLIBM_HOME="$(call cygpath_w,$(abspath $(OPENLIBM_SRC_DIR)))"
-endif
+OPENLIBM_OBJ_TARGET := $(build_shlibdir)/libopenlibm.$(SHLIB_EXT) $(build_libdir)/libopenlibm.a
+OPENLIBM_OBJ_SOURCE := $(BUILDDIR)/$(OPENLIBM_SRC_DIR)/libopenlibm.$(SHLIB_EXT)
+OPENLIBM_FLAGS := ARCH="$(ARCH)" CC="$(CC)" FC="$(FC)" AR="$(AR)" OS="$(OS)" USECLANG=$(USECLANG) USEGCC=$(USEGCC)
 
-$(OPENLIBM_OBJ_SOURCE): $(OPENLIBM_SRC_DIR)/Makefile
-	$(MAKE) -C $(OPENLIBM_SRC_DIR) $(OPENLIBM_FLAGS) $(MAKE_COMMON)
+$(OPENLIBM_OBJ_SOURCE): $(BUILDDIR)/$(OPENLIBM_SRC_DIR)/Makefile
+	$(MAKE) -C $(dir $<) $(OPENLIBM_FLAGS) $(MAKE_COMMON)
 	touch -c $@
 $(build_shlibdir)/libopenlibm%$(SHLIB_EXT) $(build_libdir)/libopenlibm%a: $(OPENLIBM_OBJ_SOURCE)
 	$(call make-install,$(OPENLIBM_SRC_DIR),$(OPENLIBM_FLAGS))
@@ -849,38 +963,39 @@ $(build_shlibdir)/libopenlibm%$(SHLIB_EXT) $(build_libdir)/libopenlibm%a: $(OPEN
 	touch -c $(OPENLIBM_OBJ_TARGET)
 
 clean-openlibm:
-	-$(MAKE) -C $(OPENLIBM_SRC_DIR) distclean $(OPENLIBM_FLAGS)
+	-$(MAKE) -C $(BUILDDIR)/$(OPENLIBM_SRC_DIR) distclean $(OPENLIBM_FLAGS)
 	-rm $(OPENLIBM_OBJ_TARGET)
 	-rm $(build_libdir)/libopenlibm.a
 
-get-openlibm: $(OPENLIBM_SRC_DIR)/Makefile
-configure-openlibm: get-openlibm
+get-openlibm: $(OPENLIBM_SRC_FILE)
+configure-openlibm: $(BUILDDIR)/$(OPENLIBM_SRC_DIR)/Makefile
 compile-openlibm: $(OPENLIBM_OBJ_SOURCE)
 check-openlibm: compile-openlibm
 install-openlibm: $(OPENLIBM_OBJ_TARGET)
 
+
 ## openspecfun ##
-OPENSPECFUN_GIT_URL = git://github.com/JuliaLang/openspecfun.git
+OPENSPECFUN_GIT_URL := git://github.com/JuliaLang/openspecfun.git
 OPENSPECFUN_TAR_URL = https://api.github.com/repos/JuliaLang/openspecfun/tarball/$1
-$(eval $(call git-external,openspecfun,OPENSPECFUN,Makefile,libopenspecfun.$(SHLIB_EXT)))
+$(eval $(call git-external,openspecfun,OPENSPECFUN,Makefile,libopenspecfun.$(SHLIB_EXT),$(BUILDDIR)))
 
 # issue 8799
-OPENSPECFUN_CFLAGS = -O3 -std=c99
+OPENSPECFUN_CFLAGS := -O3 -std=c99
 ifeq ($(USEICC),1)
   OPENSPECFUN_CFLAGS += -fp-model precise
 endif
 
-OPENSPECFUN_OBJ_TARGET = $(build_shlibdir)/libopenspecfun.$(SHLIB_EXT)
-OPENSPECFUN_OBJ_SOURCE = $(OPENSPECFUN_SRC_DIR)/libopenspecfun.$(SHLIB_EXT)
-OPENSPECFUN_FLAGS = ARCH="$(ARCH)" CC="$(CC)" FC="$(FC)" AR="$(AR)" OS="$(OS)" USECLANG=$(USECLANG) USEGCC=$(USEGCC) FFLAGS="$(JFFLAGS)" CFLAGS="$(CFLAGS) $(OPENSPECFUN_CFLAGS)"
+OPENSPECFUN_OBJ_TARGET := $(build_shlibdir)/libopenspecfun.$(SHLIB_EXT)
+OPENSPECFUN_OBJ_SOURCE := $(BUILDDIR)/$(OPENSPECFUN_SRC_DIR)/libopenspecfun.$(SHLIB_EXT)
+OPENSPECFUN_FLAGS := ARCH="$(ARCH)" CC="$(CC)" FC="$(FC)" AR="$(AR)" OS="$(OS)" USECLANG=$(USECLANG) USEGCC=$(USEGCC) FFLAGS="$(JFFLAGS)" CFLAGS="$(CFLAGS) $(OPENSPECFUN_CFLAGS)"
 
 ifeq ($(USE_SYSTEM_LIBM),0)
 	OPENSPECFUN_FLAGS += USE_OPENLIBM=1
 $(OPENSPECFUN_OBJ_SOURCE): $(OPENLIBM_OBJ_TARGET)
 endif
 
-$(OPENSPECFUN_OBJ_SOURCE): $(OPENSPECFUN_SRC_DIR)/Makefile
-	$(MAKE) -C $(OPENSPECFUN_SRC_DIR) $(OPENSPECFUN_FLAGS) $(MAKE_COMMON)
+$(OPENSPECFUN_OBJ_SOURCE): $(BUILDDIR)/$(OPENSPECFUN_SRC_DIR)/Makefile
+	$(MAKE) -C $(dir $<) $(OPENSPECFUN_FLAGS) $(MAKE_COMMON)
 	touch -c $@
 $(OPENSPECFUN_OBJ_TARGET): $(OPENSPECFUN_OBJ_SOURCE)
 	$(call make-install,$(OPENSPECFUN_SRC_DIR),$(OPENSPECFUN_FLAGS))
@@ -888,56 +1003,58 @@ $(OPENSPECFUN_OBJ_TARGET): $(OPENSPECFUN_OBJ_SOURCE)
 	touch -c $@
 
 clean-openspecfun:
-	-$(MAKE) -C $(OPENSPECFUN_SRC_DIR) distclean $(OPENSPECFUN_FLAGS)
+	-$(MAKE) -C $(BUILDDIR)/$(OPENSPECFUN_SRC_DIR) distclean $(OPENSPECFUN_FLAGS)
 	-rm $(OPENSPECFUN_OBJ_TARGET)
 	-rm $(build_libdir)/libopenspecfun.a
 
-get-openspecfun: $(OPENSPECFUN_SRC_DIR)/Makefile
-configure-openspecfun: get-openspecfun
+get-openspecfun: $(OPENSPECFUN_SRC_FILE)
+configure-openspecfun: $(BUILDDIR)/$(OPENSPECFUN_SRC_DIR)/Makefile
 compile-openspecfun: $(OPENSPECFUN_OBJ_SOURCE)
 check-openspecfun: compile-openspecfun
 install-openspecfun: $(OPENSPECFUN_OBJ_TARGET)
 
+
 ## DSFMT ##
 
-DSFMT_OBJ_TARGET = $(build_shlibdir)/libdSFMT.$(SHLIB_EXT) $(build_includedir)/dSFMT.h
-DSFMT_OBJ_SOURCE = dsfmt-$(DSFMT_VER)/libdSFMT.$(SHLIB_EXT)
+DSFMT_OBJ_TARGET := $(build_shlibdir)/libdSFMT.$(SHLIB_EXT) $(build_includedir)/dSFMT.h
+DSFMT_OBJ_SOURCE := $(BUILDDIR)/dsfmt-$(DSFMT_VER)/libdSFMT.$(SHLIB_EXT)
 
-DSFMT_CFLAGS = $(CFLAGS) -DNDEBUG -DDSFMT_MEXP=19937 $(fPIC) -DDSFMT_DO_NOT_USE_OLD_NAMES
+DSFMT_CFLAGS := $(CFLAGS) -DNDEBUG -DDSFMT_MEXP=19937 $(fPIC) -DDSFMT_DO_NOT_USE_OLD_NAMES
 ifneq ($(USEMSVC), 1)
 DSFMT_CFLAGS += -O3 -finline-functions -fomit-frame-pointer -fno-strict-aliasing \
 		--param max-inline-insns-single=1800 -Wmissing-prototypes -Wall  -std=c99 -shared
 else
-DSFMT_CFLAGS += -Wl,-dll,-def:../libdSFMT.def
+DSFMT_CFLAGS += -Wl,-dll,-def:../../libdSFMT.def
 endif
 ifeq ($(ARCH), x86_64)
 DSFMT_CFLAGS += -msse2 -DHAVE_SSE2
 endif
 
-dsfmt-$(DSFMT_VER).tar.gz:
+$(SRCDIR)/srccache/dsfmt-$(DSFMT_VER).tar.gz: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/dSFMT-src-$(DSFMT_VER).tar.gz
 	touch -c $@
-dsfmt-$(DSFMT_VER)/config.status: dsfmt-$(DSFMT_VER).tar.gz
+$(BUILDDIR)/dsfmt-$(DSFMT_VER)/config.status: $(SRCDIR)/srccache/dsfmt-$(DSFMT_VER).tar.gz
 	$(JLCHECKSUM) $<
-	mkdir -p dsfmt-$(DSFMT_VER) && \
-	$(TAR) -C dsfmt-$(DSFMT_VER) --strip-components 1 -xf dsfmt-$(DSFMT_VER).tar.gz && \
-	cd dsfmt-$(DSFMT_VER) && patch < ../dSFMT.h.patch && patch < ../dSFMT.c.patch
+	mkdir -p $(dir $@) && \
+	$(TAR) -C $(dir $@) --strip-components 1 -xf $< && \
+	cd $(dir $@) && patch < $(SRCDIR)/dSFMT.h.patch
+	cd $(dir $@) && patch < $(SRCDIR)/dSFMT.c.patch
 	echo 1 > $@
-$(DSFMT_OBJ_SOURCE): dsfmt-$(DSFMT_VER)/config.status
-	cd dsfmt-$(DSFMT_VER) && \
+$(DSFMT_OBJ_SOURCE): $(BUILDDIR)/dsfmt-$(DSFMT_VER)/config.status
+	cd $(dir $<) && \
 	$(CC) $(CPPFLAGS) $(DSFMT_CFLAGS) $(LDFLAGS) dSFMT.c -o libdSFMT.$(SHLIB_EXT)
 $(build_shlibdir)/libdSFMT%$(SHLIB_EXT) $(build_includedir)/dSFMT%h: $(DSFMT_OBJ_SOURCE) | $(build_includedir) $(build_shlibdir)
-	cp dsfmt-$(DSFMT_VER)/dSFMT.h $(build_includedir)
+	cp $(dir $<)/dSFMT.h $(build_includedir)
 	cp $< $(build_shlibdir)/libdSFMT.$(SHLIB_EXT) && \
 	$(INSTALL_NAME_CMD)libdSFMT.$(SHLIB_EXT) $(build_shlibdir)/libdSFMT.$(SHLIB_EXT)
 
 clean-dsfmt:
-	-rm -f dsfmt-$(DSFMT_VER)/libdSFMT.$(SHLIB_EXT)
+	-rm -f $(BUILDDIR)/dsfmt-$(DSFMT_VER)/libdSFMT.$(SHLIB_EXT)
 distclean-dsfmt:
-	-rm -rf dsfmt*.tar.gz dsfmt-$(DSFMT_VER)
+	-rm -rf $(SRCDIR)/srccache/dsfmt*.tar.gz $(SRCDIR)/srccache/dsfmt-$(DSFMT_VER) $(BUILDDIR)/dsfmt-$(DSFMT_VER)
 
-get-dsfmt: dsfmt-$(DSFMT_VER).tar.gz
-configure-dsfmt: dsfmt-$(DSFMT_VER)/config.status
+get-dsfmt: $(SRCDIR)/srccache/dsfmt-$(DSFMT_VER).tar.gz
+configure-dsfmt: $(BUILDDIR)/dsfmt-$(DSFMT_VER)/config.status
 compile-dsfmt: $(DSFMT_OBJ_SOURCE)
 check-dsfmt: compile-dsfmt
 install-dsfmt: $(DSFMT_OBJ_TARGET)
@@ -945,8 +1062,8 @@ install-dsfmt: $(DSFMT_OBJ_TARGET)
 
 ## Rmath-julia ##
 
-RMATH_JULIA_OBJ_TARGET = $(build_shlibdir)/libRmath-julia.$(SHLIB_EXT)
-RMATH_JULIA_OBJ_SOURCE = Rmath-julia-$(RMATH_JULIA_VER)/src/libRmath-julia.$(SHLIB_EXT)
+RMATH_JULIA_OBJ_TARGET := $(build_shlibdir)/libRmath-julia.$(SHLIB_EXT)
+RMATH_JULIA_OBJ_SOURCE := $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)/src/libRmath-julia.$(SHLIB_EXT)
 
 ifeq ($(USE_SYSTEM_DSFMT),0)
 $(RMATH_JULIA_OBJ_SOURCE): $(DSFMT_OBJ_TARGET)
@@ -957,25 +1074,27 @@ RMATH_JULIA_FLAGS += CC="$(CC)" USECLANG=$(USECLANG) USEGCC=$(USEGCC) \
 			   USE_DSFMT=1 DSFMT_libdir="$(build_shlibdir)" \
 			   DSFMT_includedir="$(build_includedir)"
 
-Rmath-julia-$(RMATH_JULIA_VER).tar.gz:
+$(SRCDIR)/srccache/Rmath-julia-$(RMATH_JULIA_VER).tar.gz: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ https://api.github.com/repos/JuliaLang/Rmath-julia/tarball/v$(RMATH_JULIA_VER)
-$(RMATH_JULIA_OBJ_SOURCE): Rmath-julia-$(RMATH_JULIA_VER).tar.gz
-	$(JLCHECKSUM) Rmath-julia-$(RMATH_JULIA_VER).tar.gz && \
-	mkdir -p Rmath-julia-$(RMATH_JULIA_VER) && \
-	$(TAR) -C Rmath-julia-$(RMATH_JULIA_VER) --strip-components 1 -xf $< && \
-	$(MAKE) -C Rmath-julia-$(RMATH_JULIA_VER)/src $(RMATH_JULIA_FLAGS) $(MAKE_COMMON) && \
+$(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)/Makefile: $(SRCDIR)/srccache/Rmath-julia-$(RMATH_JULIA_VER).tar.gz | $(SRCDIR)/srccache
+	$(JLCHECKSUM) $<
+	mkdir -p $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)
+	$(TAR) -C $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER) --strip-components 1 -xf $<
+	touch -c $@
+$(RMATH_JULIA_OBJ_SOURCE): $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)/Makefile
+	$(MAKE) -C $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)/src $(RMATH_JULIA_FLAGS) $(MAKE_COMMON)
 	touch -c $@
 $(RMATH_JULIA_OBJ_TARGET): $(RMATH_JULIA_OBJ_SOURCE) | $(build_shlibdir)
 	cp $< $@
 	$(INSTALL_NAME_CMD)libRmath-julia.$(SHLIB_EXT) $@
 
 clean-Rmath-julia:
-	-$(MAKE) -C Rmath-julia-$(RMATH_JULIA_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER) clean
 distclean-Rmath-julia: clean-Rmath-julia
-	-rm -rf Rmath-julia-$(RMATH_JULIA_VER).tar.gz Rmath-julia-$(RMATH_JULIA_VER)
+	-rm -rf $(SRCDIR)/srccache/Rmath-julia-$(RMATH_JULIA_VER).tar.gz $(SRCDIR)/srccache/Rmath-julia-$(RMATH_JULIA_VER) $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)
 
-get-Rmath-julia: Rmath-julia-$(RMATH_JULIA_VER).tar.gz
-configure-Rmath-julia: get-Rmath-julia
+get-Rmath-julia: $(SRCDIR)/srccache/Rmath-julia-$(RMATH_JULIA_VER).tar.gz
+configure-Rmath-julia: $(BUILDDIR)/Rmath-julia-$(RMATH_JULIA_VER)/Makefile
 compile-Rmath-julia: $(RMATH_JULIA_OBJ_SOURCE)
 check-Rmath-julia: compile-Rmath-julia
 install-Rmath-julia: $(RMATH_JULIA_OBJ_TARGET)
@@ -983,27 +1102,28 @@ install-Rmath-julia: $(RMATH_JULIA_OBJ_TARGET)
 
 ## objconv ##
 
-OBJCONV_SOURCE = objconv/objconv
-OBJCONV_TARGET = $(build_bindir)/objconv
+OBJCONV_SOURCE := $(BUILDDIR)/objconv/objconv
+OBJCONV_TARGET := $(build_bindir)/objconv
 
-objconv.zip:
+$(SRCDIR)/srccache/objconv.zip: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ http://www.agner.org/optimize/objconv.zip
-objconv/config.status: objconv.zip
-	unzip -d objconv $<
-	cd objconv && unzip source.zip
+$(BUILDDIR)/objconv/config.status: $(SRCDIR)/srccache/objconv.zip
+	-rm -r $(dir $@)
+	unzip -d $(dir $@) $<
+	cd $(dir $@) && unzip source.zip
 	echo 1 > $@
-$(OBJCONV_SOURCE): objconv/config.status
-	cd objconv && $(CXX) -o objconv -O2 *.cpp
+$(OBJCONV_SOURCE): $(BUILDDIR)/objconv/config.status
+	cd $(dir $<) && $(CXX) -o objconv -O2 *.cpp
 $(OBJCONV_TARGET): $(OBJCONV_SOURCE) | $(build_bindir)
 	cp -f $< $@
 
 clean-objconv:
 	-rm -f $(OBJCONV_TARGET)
 distclean-objconv:
-	-rm -rf objconv.zip objconv
+	-rm -rf $(SRCDIR)/srccache/objconv.zip $(BUILDDIR)/objconv
 
-get-objconv: objconv.zip
-configure-objconv: objconv/config.status
+get-objconv: $(SRCDIR)/srccache/objconv.zip
+configure-objconv: $(BUILDDIR)/objconv/config.status
 compile-objconv: $(OBJCONV_SOURCE)
 check-objconv: compile-objconv
 install-objconv: $(OBJCONV_TARGET)
@@ -1011,13 +1131,13 @@ install-objconv: $(OBJCONV_TARGET)
 
 ## OpenBLAS ##
 # LAPACK is built into OpenBLAS by default
-OPENBLAS_GIT_URL = git://github.com/xianyi/OpenBLAS.git
+OPENBLAS_GIT_URL := git://github.com/xianyi/OpenBLAS.git
 OPENBLAS_TAR_URL = https://api.github.com/repos/xianyi/OpenBLAS/tarball/$1
-$(eval $(call git-external,openblas,OPENBLAS,Makefile,libopenblas.$(SHLIB_EXT)))
+$(eval $(call git-external,openblas,OPENBLAS,Makefile,$(LIBBLASNAME).$(SHLIB_EXT),$(BUILDDIR)))
 
-OPENBLAS_OBJ_SOURCE = $(OPENBLAS_SRC_DIR)/libopenblas.$(SHLIB_EXT)
-OPENBLAS_OBJ_TARGET = $(build_shlibdir)/libopenblas.$(SHLIB_EXT)
-OPENBLAS_BUILD_OPTS = CC="$(CC)" FC="$(FC)" RANLIB="$(RANLIB)" FFLAGS="$(FFLAGS) $(JFFLAGS)" TARGET=$(OPENBLAS_TARGET_ARCH) BINARY=$(BINARY)
+OPENBLAS_OBJ_SOURCE := $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/$(LIBBLASNAME).$(SHLIB_EXT)
+OPENBLAS_OBJ_TARGET := $(build_shlibdir)/$(LIBBLASNAME).$(SHLIB_EXT)
+OPENBLAS_BUILD_OPTS := CC="$(CC)" FC="$(FC)" RANLIB="$(RANLIB)" FFLAGS="$(FFLAGS) $(JFFLAGS)" TARGET=$(OPENBLAS_TARGET_ARCH) BINARY=$(BINARY)
 
 # Thread support
 ifeq ($(OPENBLAS_USE_THREAD), 1)
@@ -1052,9 +1172,9 @@ endif
 
 # 64-bit BLAS interface
 ifeq ($(USE_BLAS64), 1)
-OPENBLAS_BUILD_OPTS += INTERFACE64=1 SYMBOLSUFFIX="$(OPENBLAS_SYMBOLSUFFIX)"
+OPENBLAS_BUILD_OPTS += INTERFACE64=1 SYMBOLSUFFIX="$(OPENBLAS_SYMBOLSUFFIX)" LIBPREFIX="$(LIBBLASNAME)"
 ifeq ($(OS), Darwin)
-OPENBLAS_BUILD_OPTS += OBJCONV=$(JULIAHOME)/deps/objconv/objconv
+OPENBLAS_BUILD_OPTS += OBJCONV=$(abspath $(BUILDDIR)/objconv/objconv)
 $(OPENBLAS_OBJ_SOURCE): $(OBJCONV_SOURCE)
 endif
 endif
@@ -1082,26 +1202,31 @@ else ifeq ($(OPENBLAS_NO_AVX2), 1)
 OPENBLAS_BUILD_OPTS += NO_AVX2=1
 endif
 
-$(OPENBLAS_SRC_DIR)/config.status: $(OPENBLAS_SRC_DIR)/Makefile
-	perl -i -ple 's/^\s*(EXTRALIB\s*\+=\s*-lSystemStubs)\s*$$/# $$1/g' $(OPENBLAS_SRC_DIR)/Makefile.system
+$(BUILDDIR)/$(OPENBLAS_SRC_DIR)/config.status: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/Makefile
+ifeq ($(OS),WINNT)
+	cd $(dir $@) && patch -p1 < $(SRCDIR)/openblas-win64.patch
+endif
+	perl -i -ple 's/^\s*(EXTRALIB\s*\+=\s*-lSystemStubs)\s*$$/# $$1/g' $<.system
 	touch $@
-$(OPENBLAS_OBJ_SOURCE): $(OPENBLAS_SRC_DIR)/config.status
-	echo $(MAKE) -C $(OPENBLAS_SRC_DIR) $(OPENBLAS_BUILD_OPTS) # echo first, so we only print the error message below in a failure case
-	@$(MAKE) -C $(OPENBLAS_SRC_DIR) $(OPENBLAS_BUILD_OPTS) || (echo $(WARNCOLOR)"*** Clean the OpenBLAS build with 'make -C deps clean-openblas'. Rebuild with 'make OPENBLAS_USE_THREAD=0 if OpenBLAS had trouble linking libpthread.so, and with 'make OPENBLAS_TARGET_ARCH=NEHALEM' if there were errors building SandyBridge support. Both these options can also be used simultaneously. ***"$(ENDCOLOR) && false)
+$(OPENBLAS_OBJ_SOURCE): $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/config.status
+	echo $(MAKE) -C $(dir $<) $(OPENBLAS_BUILD_OPTS) # echo first, so we only print the error message below in a failure case
+	@$(MAKE) -C $(dir $<) $(OPENBLAS_BUILD_OPTS) || (echo $(WARNCOLOR)"*** Clean the OpenBLAS build with 'make -C deps clean-openblas'. Rebuild with 'make OPENBLAS_USE_THREAD=0' if OpenBLAS had trouble linking libpthread.so, and with 'make OPENBLAS_TARGET_ARCH=NEHALEM' if there were errors building SandyBridge support. Both these options can also be used simultaneously. ***"$(ENDCOLOR) && false)
 	touch -c $@
+ifneq ($(USE_SYSTEM_BLAS),1)
 $(OPENBLAS_OBJ_TARGET): $(OPENBLAS_OBJ_SOURCE) | $(build_shlibdir)
-	cp -f $(OPENBLAS_SRC_DIR)/libopenblas.$(SHLIB_EXT) $(build_shlibdir)
+	cp -f $< $@
 ifeq ($(OS), Linux)
-	cd $(build_shlibdir) && \
-	ln -sf libopenblas.$(SHLIB_EXT) libopenblas.$(SHLIB_EXT).0
+	cd $(dir $@) && \
+	ln -sf $(LIBBLASNAME).$(SHLIB_EXT) $(LIBBLASNAME).$(SHLIB_EXT).0
+endif
+	$(INSTALL_NAME_CMD)$(LIBBLASNAME).$(SHLIB_EXT) $@
 endif
-	$(INSTALL_NAME_CMD)libopenblas.$(SHLIB_EXT) $(build_shlibdir)/libopenblas.$(SHLIB_EXT)
 
 clean-openblas:
-	-$(MAKE) -C $(OPENBLAS_SRC_DIR) clean
+	-$(MAKE) -C $(BUILDDIR)/$(OPENBLAS_SRC_DIR) clean
 
-get-openblas: $(OPENBLAS_SRC_DIR)/Makefile
-configure-openblas: $(OPENBLAS_SRC_DIR)/config.status
+get-openblas: $(OPENBLAS_SRC_FILE)
+configure-openblas: $(BUILDDIR)/$(OPENBLAS_SRC_DIR)/config.status
 compile-openblas: $(OPENBLAS_OBJ_SOURCE)
 check-openblas: compile-openblas
 install-openblas: $(OPENBLAS_OBJ_TARGET)
@@ -1113,9 +1238,9 @@ install-openblas: $(OPENBLAS_OBJ_TARGET)
 # should always be compiled with (a real) gcc, it's
 # configure script will search for the best match
 # (gcc 4.7, gcc, clang,ICC/microsoft/others)
-ATLAS_OBJ_SOURCE = atlas/build/lib/libsatlas.$(SHLIB_EXT)
-ATLAS_OBJ_TARGET = $(build_shlibdir)/libsatlas.$(SHLIB_EXT)
-ATLAS_FLAGS = --shared --prefix=$(build_prefix) --cc=gcc -t 0 \
+ATLAS_OBJ_SOURCE := $(BUILDDIR)/atlas/build/lib/libsatlas.$(SHLIB_EXT)
+ATLAS_OBJ_TARGET := $(build_shlibdir)/libsatlas.$(SHLIB_EXT)
+ATLAS_FLAGS := --shared --prefix=$(build_prefix) --cc=gcc -t 0 \
 	--with-netlib-lapack-tarfile=$(JULIAHOME)/deps/lapack-$(LAPACK_VER).tgz
 ifeq ($(OS), WINNT)
 ATLAS_FLAGS += -b 32
@@ -1127,18 +1252,18 @@ endif
 #ATLAS_FLAGS += -V -1 -A 11 # any x87 (PentiumPro or Athlon & later)
 #ATLAS_FLAGS += -A 25  # requires Corei132 (Corei232 doesn't have definition yet)
 
-atlas/configure:
-	git clone git://github.com/vtjnash/atlas-3.10.0.git atlas
+$(SRCDIR)/srccache/atlas/configure:
+	git clone git://github.com/vtjnash/atlas-3.10.0.git $(SRCDIR)/srccache/atlas
 ifeq "$(MAKECMDGOALS)" "compile-atlas"
 # only allow building atlas as the sole target (without -jN)
 # since it internally handles parallelism, for tuning timing accuracy
-atlas/build/Make.top: atlas/configure lapack-$(LAPACK_VER).tgz
-	cd atlas && \
-	(test -d build || mkdir build) && cd build && \
-	../configure $(ATLAS_FLAGS)
+$(BUILDDIR)/atlas/Make.top: $(SRCDIR)/srccache/atlas/configure $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(ATLAS_FLAGS)
 	touch -c $@
-$(ATLAS_OBJ_SOURCE): atlas/build/Make.top
-	$(MAKE) -C atlas/build -j1
+$(ATLAS_OBJ_SOURCE): $(BUILDDIR)/atlas/Make.top
+	$(MAKE) -C $(dir $<) -j1
 	touch -c $@
 else
 $(ATLAS_OBJ_SOURCE):
@@ -1148,20 +1273,28 @@ endif
 $(ATLAS_OBJ_TARGET): $(ATLAS_OBJ_SOURCE)
 	cp -f $(ATLAS_OBJ_SOURCE) $@
 	$(INSTALL_NAME_CMD)libsatlas.$(SHLIB_EXT) $@
+	touch -c $@
 
 clean-atlas:
-	rm -rf atlas/build
+	rm -rf $(BUILDDIR)/atlas/build
 distclean-atlas:
-	rm -rf atlas
+	rm -rf $(BUILDDIR)/atlas
 
-get-atlas: atlas/configure
-configure-atlas: atlas/build/Make.top
+get-atlas: $(SRCDIR)/srccache/atlas/configure $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz
+configure-atlas: $(BUILDDIR)/atlas/Make.top
 compile-atlas: $(ATLAS_OBJ_SOURCE)
 check-atlas: compile-atlas
 install-atlas: $(ATLAS_OBJ_TARGET)
 
 ## Mac gfortran BLAS wrapper ##
-GFORTBLAS_FFLAGS =
+GFORTBLAS_FFLAGS :=
+ifeq ($(USE_BLAS64), 1)
+ifeq ($(USEIFC),1)
+GFORTBLAS_FFLAGS += -i8
+else
+GFORTBLAS_FFLAGS += -fdefault-integer-8
+endif
+endif
 ifeq ($(OS),Darwin)
 ifeq ($(USE_SYSTEM_BLAS),1)
 ifeq ($(USE_SYSTEM_LAPACK),0)
@@ -1180,10 +1313,10 @@ GFORTBLAS_FFLAGS += -cpp -ffree-line-length-0 -ffixed-line-length-0 \
 endif
 endif
 
-libgfortblas.$(SHLIB_EXT): gfortblas.c gfortblas.alias
+$(BUILDDIR)/libgfortblas.$(SHLIB_EXT): $(SRCDIR)/gfortblas.c $(SRCDIR)/gfortblas.alias
 	$(CC) -Wall -O3 $(CPPFLAGS) $(CFLAGS) $(fPIC) -shared $< -o $@ -pipe \
-				-Wl,-reexport_framework,Accelerate -Wl,-alias_list,gfortblas.alias
-$(build_shlibdir)/libgfortblas.$(SHLIB_EXT): libgfortblas.$(SHLIB_EXT)
+				-Wl,-reexport_framework,Accelerate -Wl,-alias_list,$(SRCDIR)/gfortblas.alias
+$(build_shlibdir)/libgfortblas.$(SHLIB_EXT): $(BUILDDIR)/libgfortblas.$(SHLIB_EXT)
 	cp -f $< $@
 	$(INSTALL_NAME_CMD)libgfortblas.$(SHLIB_EXT) $@
 endif
@@ -1191,74 +1324,71 @@ endif
 ## LAPACK ##
 
 ifeq ($(USE_SYSTEM_LAPACK), 0)
-LAPACK_OBJ_TARGET = $(build_shlibdir)/liblapack.$(SHLIB_EXT)
-LAPACK_OBJ_SOURCE = lapack-$(LAPACK_VER)/liblapack.$(SHLIB_EXT)
+LAPACK_OBJ_TARGET := $(build_shlibdir)/liblapack.$(SHLIB_EXT)
+LAPACK_OBJ_SOURCE := $(BUILDDIR)/lapack-$(LAPACK_VER)/liblapack.$(SHLIB_EXT)
 else
-LAPACK_OBJ_TARGET =
-LAPACK_OBJ_SOURCE =
+LAPACK_OBJ_TARGET :=
+LAPACK_OBJ_SOURCE :=
 endif
 
-LAPACK_MFLAGS = NOOPT="$(FFLAGS) $(JFFLAGS) $(GFORTBLAS_FFLAGS) -O0" OPTS="$(FFLAGS) $(JFFLAGS) $(GFORTBLAS_FFLAGS)" FORTRAN="$(FC)" LOADER="$(FC)"
+LAPACK_MFLAGS := NOOPT="$(FFLAGS) $(JFFLAGS) $(GFORTBLAS_FFLAGS) -O0" OPTS="$(FFLAGS) $(JFFLAGS) $(GFORTBLAS_FFLAGS)" FORTRAN="$(FC)" LOADER="$(FC)"
 ifneq ($(OS),WINNT)
 LAPACK_MFLAGS += BLASLIB="-Wl,-rpath,'$(build_libdir)' $(LIBBLAS)"
 endif
 
-lapack-$(LAPACK_VER).tgz:
-	$(JLDOWNLOAD) $@ http://www.netlib.org/lapack/$@
-lapack-$(LAPACK_VER)/Makefile: lapack-$(LAPACK_VER).tgz
+$(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ http://www.netlib.org/lapack/$(notdir $@)
+$(BUILDDIR)/lapack-$(LAPACK_VER)/make.inc: $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz
 	$(JLCHECKSUM) $<
-	$(TAR) zxf $<
+	cd $(BUILDDIR) && $(TAR) zxf $<
+	cp $(dir $@)INSTALL/make.inc.gfortran $(dir $@)make.inc
 	touch -c $@
 ifeq ($(USE_SYSTEM_BLAS), 0)
-lapack-$(LAPACK_VER)/liblapack.a: | $(OPENBLAS_OBJ_TARGET)
+$(BUILDDIR)/lapack-$(LAPACK_VER)/liblapack.a: | $(OPENBLAS_OBJ_TARGET)
 else ifeq ($(OS),Darwin)
-lapack-$(LAPACK_VER)/liblapack.a: | $(build_shlibdir)/libgfortblas.$(SHLIB_EXT)
+$(BUILDDIR)/lapack-$(LAPACK_VER)/liblapack.a: | $(build_shlibdir)/libgfortblas.$(SHLIB_EXT)
 endif
-lapack-$(LAPACK_VER)/liblapack.a: lapack-$(LAPACK_VER)/Makefile
-	cd lapack-$(LAPACK_VER) && \
-	cp INSTALL/make.inc.gfortran ./make.inc && \
-	$(MAKE) lapacklib $(LAPACK_MFLAGS)
+$(BUILDDIR)/lapack-$(LAPACK_VER)/liblapack.a: $(BUILDDIR)/lapack-$(LAPACK_VER)/make.inc
+	$(MAKE) -C $(dir $@) lapacklib $(LAPACK_MFLAGS)
 	touch -c $@
-lapack-$(LAPACK_VER)/checked: lapack-$(LAPACK_VER)/liblapack.a
-	cd lapack-$(LAPACK_VER) && \
-	$(MAKE) lapack_testing $(LAPACK_MFLAGS) -k
+$(BUILDDIR)/lapack-$(LAPACK_VER)/checked: $(BUILDDIR)/lapack-$(LAPACK_VER)/liblapack.a
+ifeq ($(BUILD_OS),$(OS))
+	$(MAKE) -C $(dir $@) lapack_testing $(LAPACK_MFLAGS) -k
+endif
 	touch $@
-$(LAPACK_OBJ_SOURCE): lapack-$(LAPACK_VER)/liblapack.a
-	cd lapack-$(LAPACK_VER) && \
-	$(FC) -shared $(FFLAGS) $(JFFLAGS) SRC/*.o INSTALL/dlamch.o INSTALL/dsecnd_INT_ETIME.o INSTALL/ilaver.o INSTALL/slamch.o $(LIBBLAS) -o liblapack.$(SHLIB_EXT)
+$(LAPACK_OBJ_SOURCE): $(BUILDDIR)/lapack-$(LAPACK_VER)/liblapack.a
+	$(FC) -shared $(FFLAGS) $(JFFLAGS) $(dir $<)/SRC/*.o $(dir $<)/INSTALL/dlamch.o $(dir $<)/INSTALL/dsecnd_INT_ETIME.o $(dir $<)/INSTALL/ilaver.o $(dir $<)/INSTALL/slamch.o $(LIBBLAS) -o $@
 $(LAPACK_OBJ_TARGET): $(LAPACK_OBJ_SOURCE)
 	cp $< $@
 	$(INSTALL_NAME_CMD)liblapack.$(SHLIB_EXT) $@
 
 clean-lapack:
-	-$(MAKE) -C lapack-$(LAPACK_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/lapack-$(LAPACK_VER) clean
 	-rm -f $(LAPACK_OBJ_SOURCE) $(LAPACK_OBJ_TARGET)
 distclean-lapack:
-	-rm -rf lapack-$(LAPACK_VER).tgz lapack-$(LAPACK_VER)
+	-rm -rf $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz $(BUILDDIR)/lapack-$(LAPACK_VER)
 
-get-lapack: lapack-$(LAPACK_VER).tgz
-configure-lapack: get-lapack
+get-lapack: $(SRCDIR)/srccache/lapack-$(LAPACK_VER).tgz
+configure-lapack: $(BUILDDIR)/lapack-$(LAPACK_VER)/make.inc
 compile-lapack: $(LAPACK_OBJ_SOURCE)
-check-lapack: lapack-$(LAPACK_VER)/checked
+check-lapack: $(BUILDDIR)/lapack-$(LAPACK_VER)/checked
 install-lapack: $(LAPACK_OBJ_TARGET)
 
 
 ## ARPACK ##
-ARPACK_FFLAGS = $(GFORTBLAS_FFLAGS)
-ARPACK_CFLAGS =
+ARPACK_FFLAGS := $(GFORTBLAS_FFLAGS)
+ARPACK_CFLAGS :=
 
 ifeq ($(USE_BLAS64), 1)
-ifeq ($(USEIFC),1)
-ARPACK_FFLAGS += -i8
-else
-ARPACK_FFLAGS += -fdefault-integer-8
+ARPACK_CFLAGS += -DBLASINT=int64_t
+ifneq ($(USEIFC),1)
 ifeq ($(USE_SYSTEM_BLAS), 0)
 ifeq ($(OPENBLAS_SYMBOLSUFFIX), 64_)
 ARPACK_FFLAGS += -cpp -ffixed-line-length-none
-ARPACK_OPENBLASFCNS1 = axpy copy gemv geqr2 lacpy lahqr lanhs larnv lartg lascl laset scal trevc trmm trsen
-ARPACK_OPENBLASFCNS2 = dot ger labad laev2 lamch lanst lanv2 lapy2 larf larfg lasr nrm2 orm2r rot steqr swap
-ARPACK_OPENBLASFCNS3 = dotc geru unm2r
-ARPACK_OPENBLASFCNS4 = COPY LABAD LAMCH LANHS LANV2 LARFG ROT
+ARPACK_OPENBLASFCNS1 := axpy copy gemv geqr2 lacpy lahqr lanhs larnv lartg lascl laset scal trevc trmm trsen gbmv gbtrf gbtrs gttrf gttrs pttrf pttrs
+ARPACK_OPENBLASFCNS2 := dot ger labad laev2 lamch lanst lanv2 lapy2 larf larfg lasr nrm2 orm2r rot steqr swap
+ARPACK_OPENBLASFCNS3 := dotc geru unm2r
+ARPACK_OPENBLASFCNS4 := COPY LABAD LAMCH LANHS LANV2 LARFG ROT GEMV
 ARPACK_FFLAGS += $(foreach fcn, $(ARPACK_OPENBLASFCNS1) $(ARPACK_OPENBLASFCNS2), -Ds$(fcn)=s$(fcn)_64 -Dd$(fcn)=d$(fcn)_64)
 ARPACK_FFLAGS += $(foreach fcn, $(ARPACK_OPENBLASFCNS1) $(ARPACK_OPENBLASFCNS3), -Dc$(fcn)=c$(fcn)_64 -Dz$(fcn)=z$(fcn)_64)
 ARPACK_FFLAGS += $(foreach fcn, $(ARPACK_OPENBLASFCNS4), -DS$(fcn)=S$(fcn)_64 -DD$(fcn)=D$(fcn)_64)
@@ -1271,52 +1401,60 @@ endif
 endif
 
 ifeq ($(OS),WINNT)
-ARPACK_OBJ_SOURCE = arpack-ng-$(ARPACK_VER)/.libs/libarpack-2.$(SHLIB_EXT)
+ARPACK_OBJ_SOURCE := $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/.libs/libarpack-2.$(SHLIB_EXT)
 else
-ARPACK_OBJ_SOURCE = arpack-ng-$(ARPACK_VER)/.libs/libarpack.$(SHLIB_EXT)
+ARPACK_OBJ_SOURCE := $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/.libs/libarpack.$(SHLIB_EXT)
 endif
-ARPACK_OBJ_TARGET = $(build_shlibdir)/libarpack.$(SHLIB_EXT)
+ARPACK_OBJ_TARGET := $(build_shlibdir)/libarpack.$(SHLIB_EXT)
 
-ARPACK_MFLAGS = F77="$(FC)" MPIF77="$(FC)"
+ARPACK_MFLAGS := F77="$(FC)" MPIF77="$(FC)"
 ARPACK_FFLAGS += $(FFLAGS) $(JFFLAGS)
-ARPACK_FLAGS = --with-blas="$(LIBBLAS)" --with-lapack="$(LIBLAPACK)" --disable-mpi --enable-shared FFLAGS="$(ARPACK_FFLAGS)" CFLAGS="$(CFLAGS) $(ARPACK_CFLAGS)"
+ARPACK_FLAGS := --with-blas="$(LIBBLAS)" --with-lapack="$(LIBLAPACK)" --disable-mpi --enable-shared FFLAGS="$(ARPACK_FFLAGS)" CFLAGS="$(CFLAGS) $(ARPACK_CFLAGS)"
 ifneq ($(OS),WINNT)
 ARPACK_FLAGS += LDFLAGS="$(LDFLAGS) -Wl,-rpath,'$(build_libdir)'"
 endif
 
 # ARPACK-NG upstream keeps changing their download filenames
-arpack-ng-$(ARPACK_VER).tar.gz:
+$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ https://github.com/opencollab/arpack-ng/archive/$(ARPACK_VER).tar.gz
 	touch -c $@
-arpack-ng-$(ARPACK_VER)/configure: arpack-ng-$(ARPACK_VER).tar.gz
+$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ https://raw.githubusercontent.com/opencollab/arpack-ng/$(ARPACK_VER)/TESTS/testA.mtx
+	touch -c $@
+$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/configure: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz
 	$(JLCHECKSUM) $<
-	$(TAR) zxf $<
+	cd $(dir $<) && $(TAR) zxf $<
 	touch -c $@
 
 ifeq ($(USE_ATLAS), 1)
-arpack-ng-$(ARPACK_VER)/config.status: | $(ATLAS_OBJ_TARGET)
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/config.status: | $(ATLAS_OBJ_TARGET)
 endif
 
 ifeq ($(USE_SYSTEM_BLAS), 0)
-arpack-ng-$(ARPACK_VER)/config.status: | $(OPENBLAS_OBJ_TARGET)
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/config.status: | $(OPENBLAS_OBJ_TARGET)
 else ifeq ($(USE_SYSTEM_LAPACK), 0)
-arpack-ng-$(ARPACK_VER)/config.status: | $(LAPACK_OBJ_TARGET)
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/config.status: | $(LAPACK_OBJ_TARGET)
 endif
 
-arpack-ng-$(ARPACK_VER)/config.status: arpack-ng-$(ARPACK_VER)/configure
-	cd arpack-ng-$(ARPACK_VER) && \
-	./configure $(CONFIGURE_COMMON) $(ARPACK_FLAGS)
+$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/configure
+	cd $(dir $@) && patch -p1 < $(SRCDIR)/arpack-tests-blasint.patch
+	echo 1 > $@
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/config.status: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/configure $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)/arpack-tests-blasint.patch-applied
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(CONFIGURE_COMMON) $(ARPACK_FLAGS)
 	touch -c $@
-$(ARPACK_OBJ_SOURCE): arpack-ng-$(ARPACK_VER)/config.status
-	cd arpack-ng-$(ARPACK_VER) && \
-	$(MAKE) $(ARPACK_MFLAGS)
+$(ARPACK_OBJ_SOURCE): $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/config.status
+	$(MAKE) -C $(dir $<) $(ARPACK_MFLAGS)
 	touch -c $@
-arpack-ng-$(ARPACK_VER)/checked: $(ARPACK_OBJ_SOURCE)
-	cd arpack-ng-$(ARPACK_VER)
-#	$(MAKE) check $(ARPACK_MFLAGS) && \
-#	cd TESTS && $(call spawn,./dnsimp$(EXE))
+$(BUILDDIR)/arpack-ng-$(ARPACK_VER)/checked: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx $(ARPACK_OBJ_SOURCE)
+	$(JLCHECKSUM) $<
+	cp $< $(dir $@)/TESTS/testA.mtx
+ifeq ($(OS),$(BUILD_OS))
+	$(MAKE) -C $(dir $@) check $(ARPACK_MFLAGS)
+endif
 	echo 1 > $@
-$(ARPACK_OBJ_TARGET): $(ARPACK_OBJ_SOURCE) arpack-ng-$(ARPACK_VER)/checked | $(build_shlibdir)
+$(ARPACK_OBJ_TARGET): $(ARPACK_OBJ_SOURCE) | $(build_shlibdir)
 	$(call make-install,arpack-ng-$(ARPACK_VER),$(ARPACK_MFLAGS))
 ifeq ($(OS), WINNT)
 	mv $(build_shlibdir)/libarpack-2.dll $@
@@ -1324,7 +1462,7 @@ endif
 	$(INSTALL_NAME_CMD)libarpack.$(SHLIB_EXT) $(build_shlibdir)/libarpack.$(SHLIB_EXT)
 ifeq ($(OS), Linux)
 	for filename in $(build_shlibdir)/libarpack.so* ; do \
-		[ -L $$filename ] || $(PATCHELF) --set-rpath '$$ORIGIN' $$filename ;\
+		[ -L $$filename ] || $(PATCHELF_BIN) --set-rpath '$$ORIGIN' $$filename ;\
 	done
 endif
 	touch -c $@
@@ -1333,30 +1471,33 @@ $(ARPACK_OBJ_TARGET): $(PATCHELF)
 endif
 
 clean-arpack:
-	-$(MAKE) -C arpack-ng-$(ARPACK_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/arpack-ng-$(ARPACK_VER) clean
 	-rm -f $(ARPACK_OBJ_SOURCE) $(ARPACK_OBJ_TARGET)
 distclean-arpack:
-	-rm -rf arpack-ng-$(ARPACK_VER).tar.gz arpack-ng-$(ARPACK_VER)
+	-rm -rf $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz \
+		$(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER) \
+		$(SRCDIR)/srccache/arpack-ng-3.2.0-testA.mtx \
+		$(BUILDDIR)/arpack-ng-$(ARPACK_VER)
 
-get-arpack: arpack-ng-$(ARPACK_VER).tar.gz
-configure-arpack: arpack-ng-$(ARPACK_VER)/config.status
+get-arpack: $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER).tar.gz $(SRCDIR)/srccache/arpack-ng-$(ARPACK_VER)-testA.mtx
+configure-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/config.status
 compile-arpack: $(ARPACK_OBJ_SOURCE)
-check-arpack: arpack-ng-$(ARPACK_VER)/checked
+check-arpack: $(BUILDDIR)/arpack-ng-$(ARPACK_VER)/checked
 install-arpack: $(ARPACK_OBJ_TARGET)
 
 
 ## FFTW ##
 ifeq ($(OS),WINNT)
-FFTW_SINGLE_SRC_TARGET = fftw-$(FFTW_VER)-single/.libs/libfftw3f-3.$(SHLIB_EXT)
-FFTW_DOUBLE_SRC_TARGET = fftw-$(FFTW_VER)-double/.libs/libfftw3-3.$(SHLIB_EXT)
+FFTW_SINGLE_SRC_TARGET := $(BUILDDIR)/fftw-$(FFTW_VER)-single/.libs/libfftw3f-3.$(SHLIB_EXT)
+FFTW_DOUBLE_SRC_TARGET := $(BUILDDIR)/fftw-$(FFTW_VER)-double/.libs/libfftw3-3.$(SHLIB_EXT)
 else
-FFTW_SINGLE_SRC_TARGET = fftw-$(FFTW_VER)-single/.libs/libfftw3f.$(SHLIB_EXT)
-FFTW_DOUBLE_SRC_TARGET = fftw-$(FFTW_VER)-double/.libs/libfftw3.$(SHLIB_EXT)
+FFTW_SINGLE_SRC_TARGET := $(BUILDDIR)/fftw-$(FFTW_VER)-single/.libs/libfftw3f.$(SHLIB_EXT)
+FFTW_DOUBLE_SRC_TARGET := $(BUILDDIR)/fftw-$(FFTW_VER)-double/.libs/libfftw3.$(SHLIB_EXT)
 endif
-FFTW_SINGLE_OBJ_TARGET = $(build_shlibdir)/libfftw3f.$(SHLIB_EXT)
-FFTW_DOUBLE_OBJ_TARGET = $(build_shlibdir)/libfftw3.$(SHLIB_EXT)
+FFTW_SINGLE_OBJ_TARGET := $(build_shlibdir)/libfftw3f.$(SHLIB_EXT)
+FFTW_DOUBLE_OBJ_TARGET := $(build_shlibdir)/libfftw3.$(SHLIB_EXT)
 
-FFTW_CONFIG = --enable-shared --disable-fortran --disable-mpi --enable-threads
+FFTW_CONFIG := --enable-shared --disable-fortran --disable-mpi --enable-threads
 ifneq (,$(findstring arm,$(ARCH)))
   FFTW_CONFIG +=
 else ifeq ($(ARCH), ppc)
@@ -1370,29 +1511,34 @@ ifneq ($(ARCH),x86_64)
 FFTW_CONFIG += --with-incoming-stack-boundary=2
 endif
 endif
+FFTW_ENABLE_single := --enable-single
+FFTW_ENABLE_double :=
 
-fftw-$(FFTW_VER).tar.gz:
-	$(JLDOWNLOAD) $@ http://www.fftw.org/$@
-
-fftw-$(FFTW_VER)-single/configure: fftw-$(FFTW_VER).tar.gz
+$(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ http://www.fftw.org/$(notdir $@)
+$(SRCDIR)/srccache/fftw-$(FFTW_VER)/configure: $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz
 	$(JLCHECKSUM) $<
-	mkdir -p fftw-$(FFTW_VER)-single && \
-	$(TAR) -C fftw-$(FFTW_VER)-single --strip-components 1 -xf $<
-	touch -c $@
-fftw-$(FFTW_VER)-single/config.status: fftw-$(FFTW_VER)-single/configure
-	cd fftw-$(FFTW_VER)-single && \
-	(./configure $(CONFIGURE_COMMON) $(FFTW_CONFIG) --enable-avx --enable-single || \
-	  ./configure $(CONFIGURE_COMMON) $(FFTW_CONFIG) --enable-single) && \
-	$(MAKE) clean
-	touch -c $@
-$(FFTW_SINGLE_SRC_TARGET): fftw-$(FFTW_VER)-single/config.status
-	$(MAKE) -C fftw-$(FFTW_VER)-single
-fftw-$(FFTW_VER)-single/checked: $(FFTW_SINGLE_SRC_TARGET)
+	mkdir -p $(dir $@) && \
+	$(TAR) -C $(dir $@) --strip-components 1 -xf $<
+	touch -c $@
+$(BUILDDIR)/fftw-$(FFTW_VER)-%/config.status: $(SRCDIR)/srccache/fftw-$(FFTW_VER)/configure
+	mkdir -p $(dir $@)
+	@# try to configure with avx support. if that fails, try again without it
+	cd $(dir $@) && \
+	($< $(CONFIGURE_COMMON) $(FFTW_CONFIG) $(FFTW_ENABLE_$*) --enable-avx || \
+	  $< $(CONFIGURE_COMMON) $(FFTW_CONFIG) $(FFTW_ENABLE_$*))
+	$(MAKE) -C $(dir $@) clean
+	touch -c $@
+
+$(FFTW_SINGLE_SRC_TARGET): $(BUILDDIR)/fftw-$(FFTW_VER)-single/config.status
+	$(MAKE) -C $(dir $<)
+	touch -c $@
+$(BUILDDIR)/fftw-$(FFTW_VER)-single/checked: $(FFTW_SINGLE_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C fftw-$(FFTW_VER)-single check
+	$(MAKE) -C $(dir $@) check
 endif
 	echo 1 > $@
-$(FFTW_SINGLE_OBJ_TARGET): $(FFTW_SINGLE_SRC_TARGET) fftw-$(FFTW_VER)-single/checked
+$(FFTW_SINGLE_OBJ_TARGET): $(FFTW_SINGLE_SRC_TARGET)
 	$(call make-install,fftw-$(FFTW_VER)-single,)
 ifeq ($(OS), Darwin)
 	$(INSTALL_NAME_CMD)libfftw3f.$(SHLIB_EXT) $(build_shlibdir)/libfftw3f.$(SHLIB_EXT)
@@ -1402,31 +1548,20 @@ else ifeq ($(OS), WINNT)
 	mv -f $(build_shlibdir)/libfftw3f-3.dll $@
 else ifeq ($(OS), Linux)
 	for filename in $(build_shlibdir)/libfftw3f_threads.so* ; do \
-		[ -L $$filename ] || $(PATCHELF) --set-rpath '$$ORIGIN' $$filename ;\
+		[ -L $$filename ] || $(PATCHELF_BIN) --set-rpath '$$ORIGIN' $$filename ;\
 	done
 endif
 	touch -c $@
 
-fftw-$(FFTW_VER)-double/configure: fftw-$(FFTW_VER).tar.gz
-	$(JLCHECKSUM) $<
-	mkdir -p fftw-$(FFTW_VER)-double && \
-	$(TAR) -C fftw-$(FFTW_VER)-double --strip-components 1 -xf $<
+$(FFTW_DOUBLE_SRC_TARGET): $(BUILDDIR)/fftw-$(FFTW_VER)-double/config.status
+	$(MAKE) -C $(dir $<)
 	touch -c $@
-fftw-$(FFTW_VER)-double/config.status: fftw-$(FFTW_VER)-double/configure
-	cd fftw-$(FFTW_VER)-double && \
-	(./configure $(CONFIGURE_COMMON) $(FFTW_CONFIG) --enable-avx || \
-	  ./configure $(CONFIGURE_COMMON) $(FFTW_CONFIG)) && \
-	$(MAKE) clean
-	touch -c $@
-$(FFTW_DOUBLE_SRC_TARGET): fftw-$(FFTW_VER)-double/config.status
-	$(MAKE) -C fftw-$(FFTW_VER)-double
-	touch -c $@
-fftw-$(FFTW_VER)-double/checked: $(FFTW_DOUBLE_SRC_TARGET)
+$(BUILDDIR)/fftw-$(FFTW_VER)-double/checked: $(FFTW_DOUBLE_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C fftw-$(FFTW_VER)-double check
+	$(MAKE) -C $(dir $@) check
 endif
 	echo 1 > $@
-$(FFTW_DOUBLE_OBJ_TARGET): $(FFTW_DOUBLE_SRC_TARGET) fftw-$(FFTW_VER)-double/checked
+$(FFTW_DOUBLE_OBJ_TARGET): $(FFTW_DOUBLE_SRC_TARGET)
 	$(call make-install,fftw-$(FFTW_VER)-double,)
 ifeq ($(OS), Darwin)
 	$(INSTALL_NAME_CMD)libfftw3.$(SHLIB_EXT) $(build_shlibdir)/libfftw3.$(SHLIB_EXT)
@@ -1436,7 +1571,7 @@ else ifeq ($(OS), WINNT)
 	mv -f $(build_shlibdir)/libfftw3-3.dll $@
 else ifeq ($(OS), Linux)
 	for filename in $(build_shlibdir)/libfftw3_threads.so* ; do \
-		[ -L $$filename ] || $(PATCHELF) --set-rpath '$$ORIGIN' $$filename ;\
+		[ -L $$filename ] || $(PATCHELF_BIN) --set-rpath '$$ORIGIN' $$filename ;\
 	done
 endif
 	touch -c $@
@@ -1448,81 +1583,82 @@ endif
 
 clean-fftw: clean-fftw-single clean-fftw-double
 clean-fftw-single:
-	-$(MAKE) -C fftw-$(FFTW_VER)-single clean
+	-$(MAKE) -C $(BUILDDIR)/fftw-$(FFTW_VER)-single clean
 	-rm -f $(FFTW_SINGLE_OBJ_TARGET)
 clean-fftw-double:
-	-$(MAKE) -C fftw-$(FFTW_VER)-double clean
+	-$(MAKE) -C $(BUILDDIR)/fftw-$(FFTW_VER)-double clean
 	-rm -f $(FFTW_DOUBLE_OBJ_TARGET)
 distclean-fftw: distclean-fftw-single distclean-fftw-double
+	-rm -rf $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz $(SRCDIR)/srccache/fftw-$(FFTW_VER)
 distclean-fftw-single:
-	-rm -rf fftw-$(FFTW_VER).tar.gz fftw-$(FFTW_VER)-single
+	-rm -rf $(BUILDDIR)/fftw-$(FFTW_VER)-single
 distclean-fftw-double:
-	-rm -rf fftw-$(FFTW_VER).tar.gz fftw-$(FFTW_VER)-double
+	-rm -rf $(BUILDDIR)/fftw-$(FFTW_VER)-double
 
 get-fftw: get-fftw-single get-fftw-double
 configure-fftw: configure-fftw-single configure-fftw-double
 compile-fftw: compile-fftw-single compile-fftw-double
 check-fftw: check-fftw-single check-fftw-double
-install-fftw: check-fftw-single check-fftw-double
-	@$(MAKE) -s install-fftw-single
-	@$(MAKE) -s install-fftw-double
-
-get-fftw-single: fftw-$(FFTW_VER).tar.gz
-configure-fftw-single: fftw-$(FFTW_VER)-single/config.status
-compile-fftw-single: $(FFTW_SINGLE_OBJ_TARGET)
-check-fftw-single: fftw-$(FFTW_VER)-single/checked
+install-fftw: install-fftw-single install-fftw-double
+
+get-fftw-single: $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz
+configure-fftw-single: $(BUILDDIR)/fftw-$(FFTW_VER)-single/config.status
+compile-fftw-single: $(FFTW_SINGLE_SRC_TARGET)
+check-fftw-single: $(BUILDDIR)/fftw-$(FFTW_VER)-single/checked
 install-fftw-single: $(FFTW_SINGLE_OBJ_TARGET)
 
-get-fftw-double: fftw-$(FFTW_VER).tar.gz
-configure-fftw-double: fftw-$(FFTW_VER)-double/config.status
-compile-fftw-double: $(FFTW_DOUBLE_OBJ_TARGET)
-check-fftw-double: fftw-$(FFTW_VER)-double/checked
+get-fftw-double: $(SRCDIR)/srccache/fftw-$(FFTW_VER).tar.gz
+configure-fftw-double: $(BUILDDIR)/fftw-$(FFTW_VER)-double/config.status
+compile-fftw-double: $(FFTW_DOUBLE_SRC_TARGET)
+check-fftw-double: $(BUILDDIR)/fftw-$(FFTW_VER)-double/checked
 install-fftw-double: $(FFTW_DOUBLE_OBJ_TARGET)
 
 ## UTF8PROC ##
-UTF8PROC_GIT_URL = git://github.com/JuliaLang/utf8proc.git
+UTF8PROC_GIT_URL := git://github.com/JuliaLang/utf8proc.git
 UTF8PROC_TAR_URL = https://api.github.com/repos/JuliaLang/utf8proc/tarball/$1
-$(eval $(call git-external,utf8proc,UTF8PROC,Makefile,libutf8proc.a))
+$(eval $(call git-external,utf8proc,UTF8PROC,Makefile,libutf8proc.a,$(BUILDDIR)))
 
-UTF8PROC_SRC_TARGET = $(UTF8PROC_SRC_DIR)/libutf8proc.a
-UTF8PROC_OBJ_LIB    = $(build_libdir)/libutf8proc.a
-UTF8PROC_OBJ_HEADER = $(build_includedir)/utf8proc.h
-UTF8PROC_OBJ_TARGET = $(UTF8PROC_OBJ_LIB) $(UTF8PROC_OBJ_HEADER)
-UTF8PROC_CFLAGS     = -O2
+UTF8PROC_SRC_TARGET := $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/libutf8proc.a
+UTF8PROC_OBJ_LIB    := $(build_libdir)/libutf8proc.a
+UTF8PROC_OBJ_HEADER := $(build_includedir)/utf8proc.h
+UTF8PROC_OBJ_TARGET := $(UTF8PROC_OBJ_LIB) $(UTF8PROC_OBJ_HEADER)
+UTF8PROC_CFLAGS     := -O2
+UTF8PROC_MFLAGS     := CC="$(CC) $(DEPS_CFLAGS)" CFLAGS="$(CFLAGS) $(UTF8PROC_CFLAGS)" PICFLAG="$(fPIC)" AR="$(AR)"
 
-$(UTF8PROC_SRC_TARGET): $(UTF8PROC_SRC_DIR)/Makefile
-	$(MAKE) -C $(UTF8PROC_SRC_DIR) CC="$(CC) $(DEPS_CFLAGS)" CFLAGS="$(CFLAGS) $(UTF8PROC_CFLAGS)" PICFLAG="$(fPIC)" AR="$(AR)" libutf8proc.a
+$(UTF8PROC_SRC_TARGET): $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/Makefile
+	$(MAKE) -C $(dir $<) $(UTF8PROC_MFLAGS) libutf8proc.a
 	touch -c $@
-$(UTF8PROC_SRC_DIR)/checked: $(UTF8PROC_SRC_TARGET)
+# make check doesn't actually compile (missing prototype / implementation for getline)
+$(BUILDDIR)/$(UTF8PROC_SRC_DIR)/checked: $(UTF8PROC_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
-	-$(MAKE) -C $(UTF8PROC_SRC_DIR) check
+	$(MAKE) -C $(dir $@) $(UTF8PROC_MFLAGS) check
 endif
 	echo 1 > $@
 $(UTF8PROC_OBJ_LIB): $(UTF8PROC_SRC_TARGET)
 	cp -f $< $@
 $(UTF8PROC_OBJ_HEADER): $(UTF8PROC_SRC_TARGET)
-	cp -f $(UTF8PROC_SRC_DIR)/utf8proc.h $@
+	cp -f $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/utf8proc.h $@
 
 clean-utf8proc:
-	-$(MAKE) -C $(UTF8PROC_SRC_DIR) clean
+	-$(MAKE) -C $(BUILDDIR)/$(UTF8PROC_SRC_DIR) clean
 	-rm -rf $(build_libdir)/libutf8proc.a $(build_includedir)/utf8proc.h
 
-get-utf8proc: $(UTF8PROC_SRC_DIR)/Makefile
-configure-utf8proc: get-utf8proc
+get-utf8proc: $(UTF8PROC_SRC_FILE)
+configure-utf8proc: $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/Makefile
 compile-utf8proc: $(UTF8PROC_SRC_TARGET)
-check-utf8proc: $(UTF8PROC_SRC_DIR)/checked
+check-utf8proc: $(BUILDDIR)/$(UTF8PROC_SRC_DIR)/checked
 install-utf8proc: $(UTF8PROC_OBJ_TARGET)
 
-## SUITESPARSE ##
 
-SUITESPARSE_OBJ_SOURCE = SuiteSparse-$(SUITESPARSE_VER)/UMFPACK/Lib/libumfpack.a
-SUITESPARSE_OBJ_TARGET = $(build_shlibdir)/libspqr.$(SHLIB_EXT)
+## SUITESPARSE ##
 
+SUITESPARSE_OBJ_SOURCE := $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/UMFPACK/Lib/libumfpack.a
+SUITESPARSE_OBJ_TARGET := $(build_shlibdir)/libspqr.$(SHLIB_EXT)
 
 ifeq ($(USE_BLAS64), 1)
-UMFPACK_CONFIG = -DLONGBLAS='long long'
-CHOLMOD_CONFIG = -DLONGBLAS='long long'
-SPQR_CONFIG = -DLONGBLAS='long long'
+UMFPACK_CONFIG := -DLONGBLAS='long long'
+CHOLMOD_CONFIG := -DLONGBLAS='long long'
+SPQR_CONFIG := -DLONGBLAS='long long'
 ifeq ($(USE_SYSTEM_BLAS), 0)
 ifeq ($(OPENBLAS_SYMBOLSUFFIX), 64_)
 UMFPACK_CONFIG += -DSUN64
@@ -1532,7 +1668,7 @@ endif
 endif
 endif
 
-SUITE_SPARSE_LIB = -lm
+SUITE_SPARSE_LIB := -lm
 ifneq ($(OS), Darwin)
 ifneq ($(OS), WINNT)
 SUITE_SPARSE_LIB += -lrt
@@ -1541,16 +1677,16 @@ endif
 ifneq ($(OS), WINNT)
 SUITE_SPARSE_LIB += -Wl,-rpath,'$(build_libdir)'
 endif
-SUITESPARSE_MFLAGS = CC="$(CC)" CXX="$(CXX)" F77="$(FC)" AR="$(AR)" RANLIB="$(RANLIB)" BLAS="$(LIBBLAS)" LAPACK="$(LIBLAPACK)" \
+SUITESPARSE_MFLAGS := CC="$(CC)" CXX="$(CXX)" F77="$(FC)" AR="$(AR)" RANLIB="$(RANLIB)" BLAS="$(LIBBLAS)" LAPACK="$(LIBLAPACK)" \
 	  INSTALL_LIB="$(build_libdir)" INSTALL_INCLUDE="$(build_includedir)" LIB="$(SUITE_SPARSE_LIB)" \
 	  UMFPACK_CONFIG="$(UMFPACK_CONFIG)" CHOLMOD_CONFIG="$(CHOLMOD_CONFIG)" SPQR_CONFIG="$(SPQR_CONFIG)"
 
-SuiteSparse-$(SUITESPARSE_VER).tar.gz:
-	$(JLDOWNLOAD) $@ http://faculty.cse.tamu.edu/davis/SuiteSparse/$@
-SuiteSparse-$(SUITESPARSE_VER)/Makefile: SuiteSparse-$(SUITESPARSE_VER).tar.gz
+$(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ http://faculty.cse.tamu.edu/davis/SuiteSparse/$(notdir $@)
+$(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/Makefile: $(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
-	mkdir -p SuiteSparse-$(SUITESPARSE_VER)
-	$(TAR) -C SuiteSparse-$(SUITESPARSE_VER) --strip-components 1 -zxf $<
+	mkdir -p $(dir $@)
+	$(TAR) -C $(dir $@) --strip-components 1 -zxf $<
 	touch -c $@
 
 ifeq ($(USE_ATLAS), 1)
@@ -1562,17 +1698,15 @@ $(SUITESPARSE_OBJ_SOURCE): | $(OPENBLAS_OBJ_TARGET)
 else ifeq ($(USE_SYSTEM_LAPACK), 0)
 $(SUITESPARSE_OBJ_SOURCE): | $(LAPACK_OBJ_TARGET)
 endif
-$(SUITESPARSE_OBJ_SOURCE): SuiteSparse-$(SUITESPARSE_VER)/Makefile
-	cd SuiteSparse-$(SUITESPARSE_VER) && \
-	$(MAKE) library $(SUITESPARSE_MFLAGS)
+$(SUITESPARSE_OBJ_SOURCE): $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/Makefile
+	$(MAKE) -C $(dir $<) library $(SUITESPARSE_MFLAGS)
 	touch -c $@
-SuiteSparse-$(SUITESPARSE_VER)/checked: $(SUITESPARSE_OBJ_SOURCE)
-	cd SuiteSparse-$(SUITESPARSE_VER) && \
-	$(MAKE) default $(SUITESPARSE_MFLAGS)
+$(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/checked: $(SUITESPARSE_OBJ_SOURCE)
+	$(MAKE) -C $(dir $@) default $(SUITESPARSE_MFLAGS)
 	touch $@
 $(SUITESPARSE_OBJ_TARGET): $(SUITESPARSE_OBJ_SOURCE)
-	mkdir -p SuiteSparse-$(SUITESPARSE_VER)/lib && \
-	cd SuiteSparse-$(SUITESPARSE_VER)/lib && \
+	mkdir -p $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/lib && \
+	cd $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/lib && \
 	rm -f *.a && \
 	cp -f `find .. -name libamd.a -o -name libcolamd.a -o -name libcamd.a -o -name libccolamd.a -o -name libcholmod.a -o -name libumfpack.a -o -name libsuitesparseconfig.a -o -name libspqr.a 2>/dev/null` . && \
 	$(CC) -shared $(WHOLE_ARCHIVE) libsuitesparseconfig.a $(NO_WHOLE_ARCHIVE) -o $(build_shlibdir)/libsuitesparseconfig.$(SHLIB_EXT) && \
@@ -1585,7 +1719,7 @@ $(SUITESPARSE_OBJ_TARGET): $(SUITESPARSE_OBJ_SOURCE)
 	$(INSTALL_NAME_CMD)libcamd.$(SHLIB_EXT) $(build_shlibdir)/libcamd.$(SHLIB_EXT) && \
 	$(CC) -shared $(WHOLE_ARCHIVE) libccolamd.a $(NO_WHOLE_ARCHIVE) -o $(build_shlibdir)/libccolamd.$(SHLIB_EXT) $(LDFLAGS) -L$(build_shlibdir) -lsuitesparseconfig $(RPATH_ORIGIN) && \
 	$(INSTALL_NAME_CMD)libccolamd.$(SHLIB_EXT) $(build_shlibdir)/libccolamd.$(SHLIB_EXT) && \
-	$(CXX) -shared $(WHOLE_ARCHIVE) libcholmod.a $(NO_WHOLE_ARCHIVE) -o $(build_shlibdir)/libcholmod.$(SHLIB_EXT) $(LDFLAGS) -L$(build_shlibdir) -lcolamd -lamd -lcamd -lccolamd -lsuitesparseconfig $(LIBBLAS) $(RPATH_ORIGIN) && \
+	$(CXX) -shared $(WHOLE_ARCHIVE) libcholmod.a $(NO_WHOLE_ARCHIVE) -o $(build_shlibdir)/libcholmod.$(SHLIB_EXT) $(LDFLAGS) -L$(build_shlibdir) -lcolamd -lamd -lcamd -lccolamd -lsuitesparseconfig $(LIBLAPACK) $(LIBBLAS) $(RPATH_ORIGIN) && \
 	$(INSTALL_NAME_CMD)libcholmod.$(SHLIB_EXT) $(build_shlibdir)/libcholmod.$(SHLIB_EXT) && \
 	$(CXX) -shared $(WHOLE_ARCHIVE) libumfpack.a $(NO_WHOLE_ARCHIVE) -o $(build_shlibdir)/libumfpack.$(SHLIB_EXT) $(LDFLAGS) -L$(build_shlibdir) -lcholmod -lcolamd -lamd -lsuitesparseconfig $(LIBBLAS) $(RPATH_ORIGIN) && \
 	$(INSTALL_NAME_CMD)libumfpack.$(SHLIB_EXT) $(build_shlibdir)/libumfpack.$(SHLIB_EXT) && \
@@ -1593,35 +1727,37 @@ $(SUITESPARSE_OBJ_TARGET): $(SUITESPARSE_OBJ_SOURCE)
 	$(INSTALL_NAME_CMD)libspqr.$(SHLIB_EXT) $(build_shlibdir)/libspqr.$(SHLIB_EXT)
 
 clean-suitesparse:
-	-$(MAKE) -C SuiteSparse-$(SUITESPARSE_VER) clean
-	-rm -fr SuiteSparse-$(SUITESPARSE_VER)/lib
+	-$(MAKE) -C $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER) clean
+	-rm -fr $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/lib
+	-rm -f $(SUITESPARSE_OBJ_TARGET)
 distclean-suitesparse:
-	-rm -rf SuiteSparse-$(SUITESPARSE_VER).tar.gz SuiteSparse-$(SUITESPARSE_VER)
+	-rm -rf $(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz \
+		$(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)
 
-get-suitesparse: SuiteSparse-$(SUITESPARSE_VER).tar.gz
-configure-suitesparse: get-suitesparse
+get-suitesparse: $(SRCDIR)/srccache/SuiteSparse-$(SUITESPARSE_VER).tar.gz
+configure-suitesparse: $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/Makefile
 compile-suitesparse: $(SUITESPARSE_OBJ_SOURCE)
-check-suitesparse: SuiteSparse-$(SUITESPARSE_VER)/checked
+check-suitesparse: $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/checked
 install-suitesparse: $(SUITESPARSE_OBJ_TARGET) install-suitesparse-wrapper
 
 # SUITESPARSE WRAPPER
 
 ifeq ($(USE_SYSTEM_SUITESPARSE), 1)
-SUITESPARSE_INC = -I /usr/include/suitesparse
-SUITESPARSE_LIB = -lumfpack -lcholmod -lamd -lcamd -lcolamd -lspqr
+SUITESPARSE_INC := -I /usr/include/suitesparse
+SUITESPARSE_LIB := -lumfpack -lcholmod -lamd -lcamd -lcolamd -lspqr
 else
-SUITESPARSE_INC = -I SuiteSparse-$(SUITESPARSE_VER)/CHOLMOD/Include -I SuiteSparse-$(SUITESPARSE_VER)/SuiteSparse_config -I SuiteSparse-$(SUITESPARSE_VER)/SPQR/Include
-SUITESPARSE_LIB = -L$(build_shlibdir) -lcholmod -lumfpack -lspqr $(RPATH_ORIGIN)
+SUITESPARSE_INC := -I $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/CHOLMOD/Include -I $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/SuiteSparse_config -I $(BUILDDIR)/SuiteSparse-$(SUITESPARSE_VER)/SPQR/Include
+SUITESPARSE_LIB := -L$(build_shlibdir) -lcholmod -lumfpack -lspqr $(RPATH_ORIGIN)
 $(build_shlibdir)/libsuitesparse_wrapper.$(SHLIB_EXT):  $(SUITESPARSE_OBJ_TARGET)
 endif
 
-$(build_shlibdir)/libsuitesparse_wrapper.$(SHLIB_EXT): SuiteSparse_wrapper.c
+$(build_shlibdir)/libsuitesparse_wrapper.$(SHLIB_EXT): $(SRCDIR)/SuiteSparse_wrapper.c
 	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -O2 -shared $(fPIC) $(SUITESPARSE_INC) $< -o $@ $(SUITESPARSE_LIB)
 	$(INSTALL_NAME_CMD)libsuitesparse_wrapper.$(SHLIB_EXT) $@
 	touch -c $@
 
 clean-suitesparse-wrapper:
-	-rm -f $(SUITESPARSE_OBJ_TARGET) $(build_shlibdir)/libsuitesparse_wrapper.$(SHLIB_EXT)
+	-rm -f $(build_shlibdir)/libsuitesparse_wrapper.$(SHLIB_EXT)
 distclean-suitesparse-wrapper: clean-suitesparse-wrapper
 
 get-suitesparse-wrapper:
@@ -1633,143 +1769,154 @@ install-suitesparse-wrapper: $(build_shlibdir)/libsuitesparse_wrapper.$(SHLIB_EX
 
 ## UNWIND ##
 
-LIBUNWIND_TARGET_OBJ = $(build_libdir)/libunwind.a
-LIBUNWIND_TARGET_SOURCE = libunwind-$(UNWIND_VER)/src/.libs/libunwind.a
-LIBUNWIND_CFLAGS = -U_FORTIFY_SOURCE $(fPIC)
-LIBUNWIND_CPPFLAGS =
+LIBUNWIND_TARGET_OBJ := $(build_libdir)/libunwind.a
+LIBUNWIND_TARGET_SOURCE := $(BUILDDIR)/libunwind-$(UNWIND_VER)/src/.libs/libunwind.a
+LIBUNWIND_CFLAGS := -U_FORTIFY_SOURCE $(fPIC)
+LIBUNWIND_CPPFLAGS :=
 
-libunwind-$(UNWIND_VER).tar.gz:
-	$(JLDOWNLOAD) $@ http://download.savannah.gnu.org/releases/libunwind/$@
-libunwind-$(UNWIND_VER)/configure: libunwind-$(UNWIND_VER).tar.gz
+$(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ https://s3.amazonaws.com/julialang/src/libunwind-$(UNWIND_VER).tar.gz
+$(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/configure: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz
 	$(JLCHECKSUM) $<
-	$(TAR) xfz $<
-	cd libunwind-$(UNWIND_VER) && patch -p1 < ../libunwind.patch
+	cd $(dir $<) && $(TAR) xfz $<
 	touch -c $@
-libunwind-$(UNWIND_VER)/config.status: libunwind-$(UNWIND_VER)/configure
-	cd libunwind-$(UNWIND_VER) && \
-	./configure $(CONFIGURE_COMMON) CPPFLAGS="$(CPPFLAGS) $(LIBUNWIND_CPPFLAGS)" CFLAGS="$(CFLAGS) $(LIBUNWIND_CFLAGS)" --disable-shared --disable-minidebuginfo
+$(BUILDDIR)/libunwind-$(UNWIND_VER)/config.status: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER)/configure
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(CONFIGURE_COMMON) CPPFLAGS="$(CPPFLAGS) $(LIBUNWIND_CPPFLAGS)" CFLAGS="$(CFLAGS) $(LIBUNWIND_CFLAGS)" --disable-shared --disable-minidebuginfo
 	touch -c $@
-$(LIBUNWIND_TARGET_SOURCE): libunwind-$(UNWIND_VER)/config.status
-	$(MAKE) -C libunwind-$(UNWIND_VER)
+$(LIBUNWIND_TARGET_SOURCE): $(BUILDDIR)/libunwind-$(UNWIND_VER)/config.status
+	$(MAKE) -C $(dir $<)
 	touch -c $@
-libunwind-$(UNWIND_VER)/checked: $(LIBUNWIND_TARGET_SOURCE)
+$(BUILDDIR)/libunwind-$(UNWIND_VER)/checked: $(LIBUNWIND_TARGET_SOURCE)
 ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C libunwind-$(UNWIND_VER) check
+	$(MAKE) -C $(dir $@) check
 endif
 	echo 1 > $@
-#todo: libunwind tests known to fail
+#todo: libunwind tests are known to fail, so they aren't run
 $(LIBUNWIND_TARGET_OBJ): $(LIBUNWIND_TARGET_SOURCE)
 	$(call make-install,libunwind-$(UNWIND_VER),)
 ifeq ($(ARCH), ppc64)
-	# workaround for configure script bug
+	@# workaround for configure script bug
 	mv $(build_prefix)/lib64/libunwind*.a $(build_libdir)
 endif
 	touch $@
 
 clean-unwind:
-	-$(MAKE) -C libunwind-$(UNWIND_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/libunwind-$(UNWIND_VER) clean
 	-rm -f $(LIBUNWIND_TARGET_OBJ) $(LIBUNWIND_TARGET_SOURCE)
 distclean-unwind:
-	-rm -rf libunwind-$(UNWIND_VER).tar.gz libunwind-$(UNWIND_VER)
+	-rm -rf $(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz \
+		$(SRCDIR)/srccache/libunwind-$(UNWIND_VER) \
+		$(BUILDDIR)/libunwind-$(UNWIND_VER)
 
-get-unwind: libunwind-$(UNWIND_VER).tar.gz
-configure-unwind: libunwind-$(UNWIND_VER)/config.status
+get-unwind: $(SRCDIR)/srccache/libunwind-$(UNWIND_VER).tar.gz
+configure-unwind: $(BUILDDIR)/libunwind-$(UNWIND_VER)/config.status
 compile-unwind: $(LIBUNWIND_TARGET_SOURCE)
-check-unwind: libunwind-$(UNWIND_VER)/checked
+check-unwind: $(BUILDDIR)/libunwind-$(UNWIND_VER)/checked
 install-unwind: $(LIBUNWIND_TARGET_OBJ)
 
 ## OS X Unwind ##
 
-OSXUNWIND_FLAGS = ARCH="$(ARCH)" CC="$(CC)" FC="$(FC)" AR="$(AR)" OS="$(OS)" USECLANG=$(USECLANG) USEGCC=$(USEGCC) CFLAGS="$(CFLAGS) -ggdb3 -O0" CXXFLAGS="$(CXXFLAGS) -ggdb3 -O0" SFLAGS="-ggdb3" LDFLAGS="$(LDFLAGS) -Wl,-macosx_version_min,10.7"
+OSXUNWIND_FLAGS := ARCH="$(ARCH)" CC="$(CC)" FC="$(FC)" AR="$(AR)" OS="$(OS)" USECLANG=$(USECLANG) USEGCC=$(USEGCC) CFLAGS="$(CFLAGS) -ggdb3 -O0" CXXFLAGS="$(CXXFLAGS) -ggdb3 -O0" SFLAGS="-ggdb3" LDFLAGS="$(LDFLAGS) -Wl,-macosx_version_min,10.7"
 
-OSXUNWIND_OBJ_TARGET = $(build_shlibdir)/libosxunwind.$(SHLIB_EXT)
-OSXUNWIND_OBJ_SOURCE = libosxunwind-$(OSXUNWIND_VER)/libosxunwind.$(SHLIB_EXT)
+OSXUNWIND_OBJ_TARGET := $(build_shlibdir)/libosxunwind.$(SHLIB_EXT)
+OSXUNWIND_OBJ_SOURCE := $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/libosxunwind.$(SHLIB_EXT)
 
-libosxunwind-$(OSXUNWIND_VER).tar.gz:
+$(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ https://github.com/JuliaLang/libosxunwind/archive/v$(OSXUNWIND_VER).tar.gz
 
-libosxunwind-$(OSXUNWIND_VER)/Makefile: libosxunwind-$(OSXUNWIND_VER).tar.gz
+$(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/Makefile: $(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz
 	$(JLCHECKSUM) $<
-	$(TAR) xfz $<
+	cd $(BUILDDIR) && $(TAR) xfz $<
 	touch -c $@
 
-$(OSXUNWIND_OBJ_SOURCE): libosxunwind-$(OSXUNWIND_VER)/Makefile
-	$(MAKE) -C libosxunwind-$(OSXUNWIND_VER) $(OSXUNWIND_FLAGS)
+$(OSXUNWIND_OBJ_SOURCE): $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/Makefile
+	$(MAKE) -C $(dir $<) $(OSXUNWIND_FLAGS)
 	touch -c $@
 $(OSXUNWIND_OBJ_TARGET): $(OSXUNWIND_OBJ_SOURCE) | $(build_shlibdir)
-	cp libosxunwind-$(OSXUNWIND_VER)/libosxunwind.a $(build_libdir)/libosxunwind.a
+	cp $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/libosxunwind.a $(build_libdir)/libosxunwind.a
 	cp $< $@
-	cp -R libosxunwind-$(OSXUNWIND_VER)/include/* $(build_includedir)
+	cp -R $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/include/* $(build_includedir)
 	$(INSTALL_NAME_CMD)libosxunwind.$(SHLIB_EXT) $@
 
 clean-osxunwind:
-	-$(MAKE) -C libosxunwind-$(OSXUNWIND_VER) distclean $(OSXUNWIND_FLAGS)
+	-$(MAKE) -C $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER) clean $(OSXUNWIND_FLAGS)
 	-rm $(OSXUNWIND_OBJ_TARGET)
 distclean-osxunwind:
-	-rm -rf libosxunwind-$(OSXUNWIND_VER)
+	-rm -rf $(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz \
+		$(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)
 
-get-osxunwind: libosxunwind-$(OSXUNWIND_VER)/Makefile
-configure-osxunwind: get-osxunwind
+
+get-osxunwind: $(SRCDIR)/srccache/libosxunwind-$(OSXUNWIND_VER).tar.gz
+configure-osxunwind: $(BUILDDIR)/libosxunwind-$(OSXUNWIND_VER)/Makefile
 compile-osxunwind: $(OSXUNWIND_OBJ_SOURCE)
 check-osxunwind: compile-osxunwind
 install-osxunwind: $(OSXUNWIND_OBJ_TARGET)
 
 ## GMP ##
 
-GMP_SRC_TARGET = gmp-$(GMP_VER)/.libs/libgmp.$(SHLIB_EXT)
-GMP_OBJ_TARGET = $(build_shlibdir)/libgmp.$(SHLIB_EXT)
+GMP_SRC_TARGET := $(BUILDDIR)/gmp-$(GMP_VER)/.libs/libgmp.$(SHLIB_EXT)
+GMP_OBJ_TARGET := $(build_shlibdir)/libgmp.$(SHLIB_EXT)
 
 ifeq ($(SANITIZE),1)
 GMP_CONFIGURE_OPTS += --disable-assembly
 endif
 
-gmp-$(GMP_VER).tar.bz2:
-	$(JLDOWNLOAD) $@ https://gmplib.org/download/gmp/$@
-gmp-$(GMP_VER)/configure: gmp-$(GMP_VER).tar.bz2
-	$(JLCHECKSUM) $<
-	$(TAR) jxf $<
-ifeq ($(OS), Darwin)
-	cd gmp-$(GMP_VER) && patch -p1 < ../gmp_6.0.0_osx.patch
+ifeq ($(BUILD_OS),WINNT)
+GMP_CONFIGURE_OPTS += --srcdir="$(subst \,/,$(call mingw_to_dos,$(SRCDIR)/srccache/gmp-$(GMP_VER)))"
 endif
+
+$(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ https://gmplib.org/download/gmp/$(notdir $@)
+$(SRCDIR)/srccache/gmp-$(GMP_VER)/configure: $(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2
+	$(JLCHECKSUM) $<
+	cd $(dir $<) && $(TAR) jxf $<
+	touch -c $@
+$(SRCDIR)/srccache/gmp-$(GMP_VER)/patched: $(SRCDIR)/srccache/gmp-$(GMP_VER)/configure
+	echo 1 > $@
+$(BUILDDIR)/gmp-$(GMP_VER)/config.status: $(SRCDIR)/srccache/gmp-$(GMP_VER)/configure $(SRCDIR)/srccache/gmp-$(GMP_VER)/patched
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(CONFIGURE_COMMON) F77= --enable-shared --disable-static $(GMP_CONFIGURE_OPTS)
 	touch -c $@
-gmp-$(GMP_VER)/config.status: gmp-$(GMP_VER)/configure
-	cd gmp-$(GMP_VER) && \
-	./configure $(CONFIGURE_COMMON) F77= --enable-shared --disable-static $(GMP_CONFIGURE_OPTS)
+$(GMP_SRC_TARGET): $(BUILDDIR)/gmp-$(GMP_VER)/config.status
+	$(MAKE) -C $(dir $<) $(LIBTOOL_CCLD)
 	touch -c $@
-$(GMP_SRC_TARGET): gmp-$(GMP_VER)/config.status
-	$(MAKE) -C gmp-$(GMP_VER) $(LIBTOOL_CCLD)
-gmp-$(GMP_VER)/checked: $(GMP_SRC_TARGET)
+$(BUILDDIR)/gmp-$(GMP_VER)/checked: $(GMP_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C gmp-$(GMP_VER) $(LIBTOOL_CCLD) check
+	$(MAKE) -C $(dir $@) $(LIBTOOL_CCLD) check
 endif
 	echo 1 > $@
-$(GMP_OBJ_TARGET): $(GMP_SRC_TARGET) gmp-$(GMP_VER)/checked | $(build_shlibdir) $(build_includedir)
-	$(INSTALL_M) gmp-$(GMP_VER)/.libs/libgmp.*$(SHLIB_EXT)* $(build_shlibdir)
-	$(INSTALL_F) gmp-$(GMP_VER)/gmp.h $(build_includedir)
+$(GMP_OBJ_TARGET): $(GMP_SRC_TARGET) | $(build_shlibdir) $(build_includedir)
+	$(INSTALL_M) $(BUILDDIR)/gmp-$(GMP_VER)/.libs/libgmp.*$(SHLIB_EXT)* $(build_shlibdir)
+	$(INSTALL_F) $(BUILDDIR)/gmp-$(GMP_VER)/gmp.h $(build_includedir)
 	$(INSTALL_NAME_CMD)libgmp.$(SHLIB_EXT) $@
 	touch -c $@
 
 clean-gmp:
-	-$(MAKE) -C gmp-$(GMP_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/gmp-$(GMP_VER) clean
 	-rm -f $(GMP_OBJ_TARGET)
 distclean-gmp:
-	-rm -rf gmp-$(GMP_VER).tar.bz2 gmp-$(GMP_VER)
+	-rm -rf $(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2 \
+		$(SRCDIR)/srccache/gmp-$(GMP_VER) \
+		$(BUILDDIR)/gmp-$(GMP_VER)
 
-get-gmp: gmp-$(GMP_VER).tar.bz2
-configure-gmp: gmp-$(GMP_VER)/config.status
+get-gmp: $(SRCDIR)/srccache/gmp-$(GMP_VER).tar.bz2
+configure-gmp: $(BUILDDIR)/gmp-$(GMP_VER)/config.status
 compile-gmp: $(GMP_SRC_TARGET)
-check-gmp: gmp-$(GMP_VER)/checked
+check-gmp: $(BUILDDIR)/gmp-$(GMP_VER)/checked
 install-gmp: $(GMP_OBJ_TARGET)
 
 ifeq ($(USE_SYSTEM_GMP), 0)
-MPFR_DEPS = $(GMP_OBJ_TARGET)
+MPFR_DEPS := $(GMP_OBJ_TARGET)
 endif
 
 ## MPFR ##
 
 ifeq ($(USE_SYSTEM_MPFR), 0)
 ifeq ($(USE_SYSTEM_GMP), 0)
-MPFR_OPTS = --with-gmp-include=$(abspath $(build_includedir)) --with-gmp-lib=$(abspath $(build_shlibdir))
+MPFR_OPTS := --with-gmp-include=$(abspath $(build_includedir)) --with-gmp-lib=$(abspath $(build_shlibdir))
 endif
 endif
 ifeq ($(BUILD_OS),WINNT)
@@ -1779,10 +1926,10 @@ endif
 endif
 
 
-MPFR_SRC_TARGET = mpfr-$(MPFR_VER)/src/.libs/libmpfr.$(SHLIB_EXT)
-MPFR_OBJ_TARGET = $(build_shlibdir)/libmpfr.$(SHLIB_EXT)
+MPFR_SRC_TARGET := $(BUILDDIR)/mpfr-$(MPFR_VER)/src/.libs/libmpfr.$(SHLIB_EXT)
+MPFR_OBJ_TARGET := $(build_shlibdir)/libmpfr.$(SHLIB_EXT)
 ifeq ($(OS),Darwin)
-MPFR_CHECK_MFLAGS = LDFLAGS="$(LDFLAGS) -Wl,-rpath,'$(build_libdir)'"
+MPFR_CHECK_MFLAGS := LDFLAGS="$(LDFLAGS) -Wl,-rpath,'$(build_libdir)'"
 endif
 
 ifeq ($(SANITIZE),1)
@@ -1790,145 +1937,150 @@ ifeq ($(SANITIZE),1)
 MPFR_OPTS += --host=none-unknown-linux
 endif
 
-mpfr-$(MPFR_VER).tar.bz2:
-	$(JLDOWNLOAD) $@ http://www.mpfr.org/mpfr-$(MPFR_VER)/$@
-mpfr-$(MPFR_VER)/configure: mpfr-$(MPFR_VER).tar.bz2
+$(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ http://www.mpfr.org/mpfr-$(MPFR_VER)/$(notdir $@)
+$(SRCDIR)/srccache/mpfr-$(MPFR_VER)/configure: $(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2
 	$(JLCHECKSUM) $<
-	$(TAR) jxf $<
+	cd $(dir $<) && $(TAR) jxf $<
 	touch -c $@
-mpfr-$(MPFR_VER)/config.status: mpfr-$(MPFR_VER)/configure | $(MPFR_DEPS)
-	cd mpfr-$(MPFR_VER) && \
-	./configure $(CONFIGURE_COMMON) $(MPFR_OPTS) F77= --enable-shared --disable-static
+$(BUILDDIR)/mpfr-$(MPFR_VER)/config.status: $(SRCDIR)/srccache/mpfr-$(MPFR_VER)/configure | $(MPFR_DEPS)
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(CONFIGURE_COMMON) $(MPFR_OPTS) F77= --enable-shared --disable-static
 	touch -c $@
-$(MPFR_SRC_TARGET): mpfr-$(MPFR_VER)/config.status
-	$(MAKE) -C mpfr-$(MPFR_VER) $(LIBTOOL_CCLD)
-mpfr-$(MPFR_VER)/checked: $(MPFR_SRC_TARGET)
+$(MPFR_SRC_TARGET): $(BUILDDIR)/mpfr-$(MPFR_VER)/config.status
+	$(MAKE) -C $(dir $<) $(LIBTOOL_CCLD)
+	touch -c $@
+$(BUILDDIR)/mpfr-$(MPFR_VER)/checked: $(MPFR_SRC_TARGET)
 ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C mpfr-$(MPFR_VER) $(LIBTOOL_CCLD) check $(MPFR_CHECK_MFLAGS)
+	$(MAKE) -C $(dir $@) $(LIBTOOL_CCLD) check $(MPFR_CHECK_MFLAGS)
 endif
 	echo 1 > $@
-$(MPFR_OBJ_TARGET): $(MPFR_SRC_TARGET) mpfr-$(MPFR_VER)/checked
+$(MPFR_OBJ_TARGET): $(MPFR_SRC_TARGET)
 	$(call make-install,mpfr-$(MPFR_VER),$(LIBTOOL_CCLD))
 	$(INSTALL_NAME_CMD)libmpfr.$(SHLIB_EXT) $@
 	touch -c $@
 
 clean-mpfr:
-	-$(MAKE) -C mpfr-$(MPFR_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/mpfr-$(MPFR_VER) clean
 	-rm -f $(MPFR_OBJ_TARGET)
 distclean-mpfr:
-	-rm -rf mpfr-$(MPFR_VER).tar.bz2 mpfr-$(MPFR_VER)
+	-rm -rf $(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2 \
+		$(SRCDIR)/srccache/mpfr-$(MPFR_VER) \
+		$(BUILDDIR)/mpfr-$(MPFR_VER)
 
-get-mpfr: mpfr-$(MPFR_VER).tar.bz2
-configure-mpfr: mpfr-$(MPFR_VER)/config.status
+get-mpfr: $(SRCDIR)/srccache/mpfr-$(MPFR_VER).tar.bz2
+configure-mpfr: $(BUILDDIR)/mpfr-$(MPFR_VER)/config.status
 compile-mpfr: $(MPFR_SRC_TARGET)
-check-mpfr: mpfr-$(MPFR_VER)/checked
+check-mpfr: $(BUILDDIR)/mpfr-$(MPFR_VER)/checked
 install-mpfr: $(MPFR_OBJ_TARGET)
 
 ## patchelf ##
 
-PATCHELF_SOURCE = patchelf-$(PATCHELF_VER)/src/patchelf
-PATCHELF_TARGET = $(build_bindir)/patchelf
-
-compile-patchelf: install-patchelf
-install-patchelf: $(PATCHELF_TARGET)
+PATCHELF_SOURCE := $(BUILDDIR)/patchelf-$(PATCHELF_VER)/src/patchelf
+PATCHELF_TARGET := $(build_bindir)/patchelf
 
-patchelf-$(PATCHELF_VER).tar.gz:
+$(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ http://nixos.org/releases/patchelf/patchelf-$(PATCHELF_VER)/patchelf-$(PATCHELF_VER).tar.gz
-patchelf-$(PATCHELF_VER)/configure: patchelf-$(PATCHELF_VER).tar.gz
+$(SRCDIR)/srccache/patchelf-$(PATCHELF_VER)/configure: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz
 	$(JLCHECKSUM) $<
-	$(TAR) zxf $<
+	cd $(dir $<) && $(TAR) zxf $<
 	touch -c $@
-patchelf-$(PATCHELF_VER)/config.status: patchelf-$(PATCHELF_VER)/configure
-	cd patchelf-$(PATCHELF_VER) && \
-	./configure $(CONFIGURE_COMMON)
+$(BUILDDIR)/patchelf-$(PATCHELF_VER)/config.status: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER)/configure | $(LIBCXX_DEPENDENCY)
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$< $(CONFIGURE_COMMON) LDFLAGS="$(CXXLDFLAGS)" CPPFLAGS="$(CPPFLAGS)"
 	touch -c $@
-$(PATCHELF_SOURCE): patchelf-$(PATCHELF_VER)/config.status
-	$(MAKE) -C patchelf-$(PATCHELF_VER)
+$(PATCHELF_SOURCE): $(BUILDDIR)/patchelf-$(PATCHELF_VER)/config.status
+	$(MAKE) -C $(dir $<)
 	touch -c $@
-patchelf-$(PATCHELF_VER)/checked: $(PATCHELF_SOURCE)
+$(BUILDDIR)/patchelf-$(PATCHELF_VER)/checked: $(PATCHELF_SOURCE)
 ifeq ($(OS),$(BUILD_OS))
 	# disabled due to bug in v0.6
-	#$(MAKE) -C patchelf-$(PATCHELF_VER) check
+	#$(MAKE) -C $(dir $@) check
 endif
 	echo 1 > $@
-$(PATCHELF_TARGET): $(PATCHELF_SOURCE) patchelf-$(PATCHELF_VER)/checked
+$(PATCHELF_TARGET): $(PATCHELF_SOURCE)
 	$(call make-install,patchelf-$(PATCHELF_VER),)
 	touch -c $@
 
 clean-patchelf:
-	-$(MAKE) -C patchelf-$(PATCHELF_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/patchelf-$(PATCHELF_VER) clean
 	-rm -f $(PATCHELF_OBJ_TARGET)
 distclean-patchelf:
-	-rm -rf patchelf-$(PATCHELF_VER).tar.gz patchelf-$(PATCHELF_VER)
+	-rm -rf $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz \
+		$(SRCDIR)/srccache/patchelf-$(PATCHELF_VER) \
+		$(BUILDDIR)/patchelf-$(PATCHELF_VER)
 
-get-patchelf: patchelf-$(PATCHELF_VER).tar.gz
-configure-patchelf: patchelf-$(PATCHELF_VER)/config.status
+get-patchelf: $(SRCDIR)/srccache/patchelf-$(PATCHELF_VER).tar.gz
+configure-patchelf: $(BUILDDIR)/patchelf-$(PATCHELF_VER)/config.status
 compile-patchelf: $(PATCHELF_SOURCE)
-check-patchelf: patchelf-$(PATCHELF_VER)/checked
+check-patchelf: $(BUILDDIR)/patchelf-$(PATCHELF_VER)/checked
 install-patchelf: $(PATCHELF_TARGET)
 
 ## Git
 # only used for the mac binaries in contrib/mac/app/Makefile
 
-GIT_SOURCE = git-$(GIT_VER)/git
-GIT_TARGET = $(build_libexecdir)/git
+GIT_SOURCE := $(BUILDDIR)/git-$(GIT_VER)/git
+GIT_TARGET := $(build_libexecdir)/git
 
-git-$(GIT_VER).tar.gz:
+$(SRCDIR)/srccache/git-$(GIT_VER).tar.gz: | $(SRCDIR)/srccache
 	$(JLDOWNLOAD) $@ https://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.gz
-git-$(GIT_VER)/configure: git-$(GIT_VER).tar.gz
+$(BUILDDIR)/git-$(GIT_VER)/configure: $(SRCDIR)/srccache/git-$(GIT_VER).tar.gz
 	$(JLCHECKSUM) $<
-	$(TAR) zxf $<
+	cd $(BUILDDIR) && $(TAR) zxf $<
 	touch -c $@
-git-$(GIT_VER)/config.status: git-$(GIT_VER)/configure
-	cd git-$(GIT_VER) && \
+$(BUILDDIR)/git-$(GIT_VER)/config.status: $(BUILDDIR)/git-$(GIT_VER)/configure
+	cd $(dir $@) && \
 	./configure $(CONFIGURE_COMMON) --bindir="$(build_libexecdir)"
 	touch -c $@
-$(GIT_SOURCE): git-$(GIT_VER)/config.status
-	$(MAKE) -C git-$(GIT_VER)
+$(GIT_SOURCE): $(BUILDDIR)/git-$(GIT_VER)/config.status
+	$(MAKE) -C $(dir $<)
 	touch -c $@
-git-$(GIT_VER)/checked: $(GIT_SOURCE)
+$(BUILDDIR)/git-$(GIT_VER)/checked: $(GIT_SOURCE)
 	echo 1 > $@
-$(GIT_TARGET): $(GIT_SOURCE) git-$(GIT_VER)/checked
+$(GIT_TARGET): $(GIT_SOURCE)
 	$(call make-install,git-$(GIT_VER),NO_INSTALL_HARDLINKS=1 bindir="$(build_libexecdir)")
 	touch -c $@
 
 clean-git:
-	-$(MAKE) -C git-$(GIT_VER) clean
+	-$(MAKE) -C $(BUILDDIR)/git-$(GIT_VER) clean
 	-rm -f $(GIT_OBJ_TARGET)
 distclean-git:
-	-rm -rf git-$(GIT_VER).tar.gz git-$(GIT_VER)
+	-rm -rf $(SRCDIR)/srccache/git-$(GIT_VER).tar.gz \
+		$(BUILDDIR)/git-$(GIT_VER)
 
-get-git: git-$(GIT_VER).tar.gz
-configure-git: git-$(GIT_VER)/config.status
+get-git: $(SRCDIR)/srccache/git-$(GIT_VER).tar.gz
+configure-git: $(BUILDDIR)/git-$(GIT_VER)/config.status
 compile-git: $(GIT_SOURCE)
-check-git: git-$(GIT_VER)/checked
+check-git: $(BUILDDIR)/git-$(GIT_VER)/checked
 install-git: $(GIT_TARGET)
 
 ## virtualenv
 
-VIRTUALENV_SOURCE = virtualenv-$(VIRTUALENV_VER)/virtualenv.py
-VIRTUALENV_TARGET = julia-env
+VIRTUALENV_SOURCE := $(SRCDIR)/srccache/virtualenv-$(VIRTUALENV_VER)/virtualenv.py
+VIRTUALENV_TARGET := $(BUILDDIR)/julia-env
 
-virtualenv-$(VIRTUALENV_VER).tar.gz:
-	$(JLDOWNLOAD) $@ https://pypi.python.org/packages/source/v/virtualenv/$@
-$(VIRTUALENV_SOURCE): virtualenv-$(VIRTUALENV_VER).tar.gz
+$(SRCDIR)/srccache/virtualenv-$(VIRTUALENV_VER).tar.gz: | $(SRCDIR)/srccache
+	$(JLDOWNLOAD) $@ https://pypi.python.org/packages/source/v/virtualenv/$(notdir $@)
+$(VIRTUALENV_SOURCE): $(SRCDIR)/srccache/virtualenv-$(VIRTUALENV_VER).tar.gz
 	$(JLCHECKSUM) $<
-	$(TAR) zxf $<
+	cd $(dir $<) && $(TAR) zxf $<
 	touch -c $@
 $(VIRTUALENV_TARGET): $(VIRTUALENV_SOURCE)
-	"$(shell ./find_python2)" $< $@
+	"$(shell $(SRCDIR)/find_python2)" $< $@
 ifeq ($(BUILD_OS), WINNT)
-	-[ -e $@/Scripts ] && ! [ -e $@/bin ] && cmd //C mklink //J $@\\bin $@\\Scripts
+	-[ -e $@/Scripts ] && ! [ -e $@/bin ] && cmd //C mklink //J `echo $@/bin $@/Scripts | sed -e 's#/#\\\\#g'`
 endif
 	touch -c $@
 
 clean-virtualenv:
-	-$(MAKE) -C virtualenv-$(VIRTUALENV_VER) clean
 	-rm -rf $(VIRTUALENV_TARGET)
 distclean-virtualenv: clean-virtualenv
-	-rm -rf virtualenv-$(VIRTUALENV_VER).tar.gz virtualenv-$(VIRTUALENV_VER)
+	-rm -rf $(SRCDIR)/srccache/virtualenv-$(VIRTUALENV_VER).tar.gz \
+		$(SRCDIR)/srccache/virtualenv-$(VIRTUALENV_VER)
 
-get-virtualenv: virtualenv-$(VIRTUALENV_VER).tar.gz
+get-virtualenv: $(SRCDIR)/srccache/virtualenv-$(VIRTUALENV_VER).tar.gz
 configure-virtualenv: get-virtualenv
 compile-virtualenv: $(VIRTUALENV_SOURCE)
 check-virtualenv: compile-virtualenv
@@ -1936,45 +2088,48 @@ install-virtualenv: $(VIRTUALENV_TARGET)
 
 ## libgit2
 
-LIBGIT2_GIT_URL = git://github.com/libgit2/libgit2.git
+LIBGIT2_GIT_URL := git://github.com/libgit2/libgit2.git
 LIBGIT2_TAR_URL = https://api.github.com/repos/libgit2/libgit2/tarball/$1
-$(eval $(call git-external,libgit2,LIBGIT2,CMakeLists.txt,build/libgit2.$(SHLIB_EXT)))
+$(eval $(call git-external,libgit2,LIBGIT2,CMakeLists.txt,build/libgit2.$(SHLIB_EXT),$(SRCDIR)/srccache))
 
-LIBGIT2_OBJ_SOURCE = $(LIBGIT2_SRC_DIR)/build/libgit2.$(SHLIB_EXT)
-LIBGIT2_OBJ_TARGET = $(build_shlibdir)/libgit2.$(SHLIB_EXT)
+LIBGIT2_OBJ_SOURCE := $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/libgit2.$(SHLIB_EXT)
+LIBGIT2_OBJ_TARGET := $(build_shlibdir)/libgit2.$(SHLIB_EXT)
 
-LIBGIT2_OPTS = $(CMAKE_COMMON) -DTHREADSAFE=ON
+LIBGIT2_OPTS := $(CMAKE_COMMON) -DTHREADSAFE=ON
 ifeq ($(OS),WINNT)
-LIBGIT2_OPTS += -DWIN32=ON -DMINGW=ON -DUSE_SSH=OFF -DCMAKE_SYSTEM_NAME=Windows
+LIBGIT2_OPTS += -DWIN32=ON -DMINGW=ON -DUSE_SSH=OFF -DCMAKE_BUILD_TYPE=RelWithDebInfo
 ifneq ($(ARCH),x86_64)
 LIBGIT2_OPTS += -DCMAKE_C_FLAGS="-mincoming-stack-boundary=2"
 endif
 ifeq ($(BUILD_OS),WINNT)
 LIBGIT2_OPTS += -G"MSYS Makefiles"
 else
-LIBGIT2_OPTS += -DBUILD_CLAR=OFF -DCMAKE_RC_COMPILER=`which $(CROSS_COMPILE)windres` -DDLLTOOL=`which $(CROSS_COMPILE)dlltool`
+LIBGIT2_OPTS += -DBUILD_CLAR=OFF -DDLLTOOL=`which $(CROSS_COMPILE)dlltool`
 LIBGIT2_OPTS += -DCMAKE_FIND_ROOT_PATH=/usr/$(XC_HOST) -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY
 endif
+else
+LIBGIT2_OPTS += -DCMAKE_BUILD_TYPE=Release
 endif
 
-$(LIBGIT2_SRC_DIR)/build/Makefile: $(LIBGIT2_SRC_DIR)/CMakeLists.txt
-	mkdir -p $(LIBGIT2_SRC_DIR)/build
-	cd $(LIBGIT2_SRC_DIR)/build/ && \
-	$(CMAKE) .. $(LIBGIT2_OPTS)
+$(BUILDDIR)/$(LIBGIT2_SRC_DIR)/Makefile: $(SRCDIR)/srccache/$(LIBGIT2_SRC_DIR)/CMakeLists.txt
+	-cd $(SRCDIR)/srccache/$(LIBGIT2_SRC_DIR) && patch -p1 -f < $(SRCDIR)/libgit2-require-openssl.patch
+	mkdir -p $(dir $@)
+	cd $(dir $@) && \
+	$(CMAKE) $(dir $<) $(LIBGIT2_OPTS)
 	touch -c $@
-$(LIBGIT2_OBJ_SOURCE): $(LIBGIT2_SRC_DIR)/build/Makefile
-	$(MAKE) -C $(LIBGIT2_SRC_DIR)/build
+$(LIBGIT2_OBJ_SOURCE): $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/Makefile
+	$(MAKE) -C $(dir $<)
 	touch -c $@
-$(LIBGIT2_SRC_DIR)/build/checked: $(LIBGIT2_OBJ_SOURCE)
+$(BUILDDIR)/$(LIBGIT2_SRC_DIR)/checked: $(LIBGIT2_OBJ_SOURCE)
 ifeq ($(OS),$(BUILD_OS))
-	$(MAKE) -C $(LIBGIT2_SRC_DIR)/build test
+	$(MAKE) -C $(dir $@) test
 endif
 	echo 1 > $@
 $(LIBGIT2_OBJ_TARGET): $(LIBGIT2_OBJ_SOURCE) | $(build_shlibdir)
 	cp $< $@
-	#$$(call make-install,$(LIBGIT2_SRC_DIR)/build,)
+	@#$$(call make-install,$(LIBGIT2_SRC_DIR),) # currently don't need the full install
 ifeq ($(OS),Linux)
-	# If we're on linux, copy over libssl and libcrypto for libgit2
+	@# If we're on linux, copy over libssl and libcrypto for libgit2
 	-LIBGIT_LIBS=$$(ldd "$@" | tail -n +2 | awk '{print $$(NF-1)}'); \
 	for LIB in libssl libcrypto; do \
 		LIB_PATH=$$(echo "$$LIBGIT_LIBS" | grep "$$LIB"); \
@@ -1985,13 +2140,13 @@ endif
 	touch -c $@
 
 clean-libgit2:
-	-rm -rf $(LIBGIT2_SRC_DIR)/build/
+	-rm -rf $(BUILDDIR)/$(LIBGIT2_SRC_DIR)
 	-rm -f $(LIBGIT2_OBJ_TARGET)
 
-get-libgit2: $(LIBGIT2_SRC_DIR)/CMakeLists.txt
-configure-libgit2: $(LIBGIT2_SRC_DIR)/build/Makefile
+get-libgit2: $(LIBGIT2_SRC_FILE)
+configure-libgit2: $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/Makefile
 compile-libgit2: $(LIBGIT2_OBJ_SOURCE)
-check-libgit2: $(LIBGIT2_SRC_DIR)/build/checked
+check-libgit2: $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/checked
 install-libgit2: $(LIBGIT2_OBJ_TARGET)
 
 ## phony targets ##
diff --git a/deps/NATIVE.cmake b/deps/NATIVE.cmake
new file mode 100644
index 0000000000000..026ee4de66934
--- /dev/null
+++ b/deps/NATIVE.cmake
@@ -0,0 +1,4 @@
+# native toolchain file to fix llvm cross-compilation finickiness
+# ref http://lists.llvm.org/pipermail/llvm-dev/2016-February/095366.html
+set(CMAKE_C_COMPILER cc)
+set(CMAKE_CXX_COMPILER c++)
diff --git a/deps/Versions.make b/deps/Versions.make
index b735d8f6adec0..e5819ef8f87b0 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -1,15 +1,15 @@
-LLVM_VER = 3.3
+LLVM_VER = 3.7.1
 LLVM_LIB_SUFFIX =
-PCRE_VER = 10.20
+PCRE_VER = 10.21
 DSFMT_VER = 2.2.3
 LAPACK_VER = 3.5.0
 ARPACK_VER = 3.2.0
 FFTW_VER = 3.3.4
-SUITESPARSE_VER = 4.4.2
-UNWIND_VER = 1.1
-OSXUNWIND_VER = 0.0.1
-GMP_VER=6.0.0
-MPFR_VER=3.1.2
+SUITESPARSE_VER = 4.4.5
+UNWIND_VER = 1.1-julia2
+OSXUNWIND_VER = 0.0.3
+GMP_VER = 6.1.0
+MPFR_VER = 3.1.3
 PATCHELF_VER = 0.8
 GIT_VER = 1.8.5.6
 VIRTUALENV_VER = 1.11.6
diff --git a/deps/arpack-tests-blasint.patch b/deps/arpack-tests-blasint.patch
new file mode 100644
index 0000000000000..915b03034798a
--- /dev/null
+++ b/deps/arpack-tests-blasint.patch
@@ -0,0 +1,158 @@
+diff -urN arpack-ng-3.2.0/TESTS/bug_1315_double.c arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_double.c
+--- arpack-ng-3.2.0/TESTS/bug_1315_double.c	2014-11-14 09:47:06.000000000 -0500
++++ arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_double.c	2015-08-10 01:08:29.000000000 -0400
+@@ -9,15 +9,18 @@
+  * This is not efficient since the problem is
+  * symmetric but is done to exhibit the bug.
+  * */
+-
+-extern void dnaupd_(int *, char *, int *, char *, int *,
+-		   double *, double *, int *, double *,
+-		   int *, int *, int *, double *,
+-		   double *, int *, int *);
+-
+-extern void dneupd_( int*, char*, int *, double *, double *, double *, int*, double *,
+-		double *, double *, char *, int *, char *, int *, double *, double *, int *,
+-		double *, int *, int *, int *, double *, double *, int *, int * );
++#ifndef BLASINT
++#define BLASINT int
++#endif
++
++extern void dnaupd_(BLASINT *, char *, BLASINT *, char *, BLASINT *,
++		   double *, double *, BLASINT *, double *,
++		   BLASINT *, BLASINT *, BLASINT *, double *,
++		   double *, BLASINT *, BLASINT *);
++
++extern void dneupd_( BLASINT*, char*, BLASINT *, double *, double *, double *, BLASINT*, double *,
++		double *, double *, char *, BLASINT *, char *, BLASINT *, double *, double *, BLASINT *,
++		double *, BLASINT *, BLASINT *, BLASINT *, double *, double *, BLASINT *, BLASINT * );
+ 
+ void matVec(double * x, double * y) {
+   int i;
+@@ -26,26 +29,26 @@
+ };
+ 
+ int main() {
+-  int ido = 0;
++  BLASINT ido = 0;
+   char bmat[] = "I";
+-  int N = 1000;
++  BLASINT N = 1000;
+   char which[] = "LM";
+-  int nev = 9;
++  BLASINT nev = 9;
+   double tol = 0;
+   double resid[N];
+-  int ncv = 2*nev+1;
++  BLASINT ncv = 2*nev+1;
+   double V[ncv*N];
+-  int ldv = N;
+-  int iparam[11];
+-  int ipntr[14];
++  BLASINT ldv = N;
++  BLASINT iparam[11];
++  BLASINT ipntr[14];
+   double workd[3*N];
+-  int rvec = 1;
++  BLASINT rvec = 1;
+   char howmny[] = "A";
+   double* dr = (double*) malloc((nev+1)*sizeof(double));
+   double* di = (double*) malloc((nev+1)*sizeof(double));
+-  int select[3*ncv];
++  BLASINT select[3*ncv];
+   double z[(N+1)*(nev+1)];
+-  int ldz = N+1;
++  BLASINT ldz = N+1;
+   double sigmar=0;
+   double sigmai=0;
+   double workev[3*ncv];
+@@ -55,8 +58,8 @@
+   double workl[3*(ncv*ncv) + 6*ncv];
+   for (k=0; k < 3*(ncv*ncv) + 6*ncv; ++k )
+     workl[k] = 0;
+-  int lworkl = 3*(ncv*ncv) + 6*ncv;
+-  int info = 0;
++  BLASINT lworkl = 3*(ncv*ncv) + 6*ncv;
++  BLASINT info = 0;
+ 
+   iparam[0] = 1;
+   iparam[2] = 10*N;
+diff -urN arpack-ng-3.2.0/TESTS/bug_1315_single.c arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_single.c
+--- arpack-ng-3.2.0/TESTS/bug_1315_single.c	2014-11-14 09:47:06.000000000 -0500
++++ arpack-ng-3.2.0-BLASINT/TESTS/bug_1315_single.c	2015-08-10 01:29:58.000000000 -0400
+@@ -9,15 +9,18 @@
+  * This is not efficient since the problem is
+  * symmetric but is done to exhibit the bug.
+  */
+-
+-extern void snaupd_(int *, char *, int *, char *, int *,
+-		   float *, float *, int *, float *,
+-		   int *, int *, int *, float *,
+-		   float *, int *, int *);
+-
+-extern void sneupd_( int*, char*, int *, float *, float *, float *, int*, float *,
+-		float *, float *, char *, int *, char *, int *, float *, float *, int *,
+-		float *, int *, int *, int *, float *, float *, int *, int * );
++#ifndef BLASINT
++#define BLASINT int
++#endif
++
++extern void snaupd_(BLASINT *, char *, BLASINT *, char *, BLASINT *,
++		   float *, float *, BLASINT *, float *,
++		   BLASINT *, BLASINT *, BLASINT *, float *,
++		   float *, BLASINT *, BLASINT *);
++
++extern void sneupd_( BLASINT*, char*, BLASINT *, float *, float *, float *, BLASINT*, float *,
++		float *, float *, char *, BLASINT *, char *, BLASINT *, float *, float *, BLASINT *,
++		float *, BLASINT *, BLASINT *, BLASINT *, float *, float *, BLASINT *, BLASINT * );
+ 
+ 
+ void matVec(float * x, float * y) {
+@@ -27,26 +30,26 @@
+ };
+ 
+ int main() {
+-  int ido = 0;
++  BLASINT ido = 0;
+   char bmat[] = "I";
+-  int N = 1000;
++  BLASINT N = 1000;
+   char which[] = "LM";
+-  int nev = 9;
++  BLASINT nev = 9;
+   float tol = 0;
+   float resid[N];
+-  int ncv = 2*nev+1;
++  BLASINT ncv = 2*nev+1;
+   float V[ncv*N];
+-  int ldv = N;
+-  int iparam[11];
+-  int ipntr[14];
++  BLASINT ldv = N;
++  BLASINT iparam[11];
++  BLASINT ipntr[14];
+   float workd[3*N];
+-  int rvec = 1;
++  BLASINT rvec = 1;
+   char howmny[] = "A";
+   float* dr = (float*) malloc((nev+1)*sizeof(float));
+   float* di = (float*) malloc((nev+1)*sizeof(float));
+-  int select[3*ncv];
++  BLASINT select[3*ncv];
+   float z[(N+1)*(nev+1)];
+-  int ldz = N+1;
++  BLASINT ldz = N+1;
+   float sigmar=0;
+   float sigmai=0;
+   float workev[3*ncv];
+@@ -56,8 +59,8 @@
+   float workl[3*(ncv*ncv) + 6*ncv];
+   for (k=0; k < 3*(ncv*ncv) + 6*ncv; ++k )
+     workl[k] = 0;
+-  int lworkl = 3*(ncv*ncv) + 6*ncv;
+-  int info = 0;
++  BLASINT lworkl = 3*(ncv*ncv) + 6*ncv;
++  BLASINT info = 0;
+ 
+   iparam[0] = 1;
+   iparam[2] = 10*N;
diff --git a/deps/checksums/SuiteSparse-4.4.2.tar.gz/md5 b/deps/checksums/SuiteSparse-4.4.2.tar.gz/md5
deleted file mode 100644
index e1c6a5e246d30..0000000000000
--- a/deps/checksums/SuiteSparse-4.4.2.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-db3560d96ae78fb28b8996b5be7194b1
diff --git a/deps/checksums/SuiteSparse-4.4.2.tar.gz/sha512 b/deps/checksums/SuiteSparse-4.4.2.tar.gz/sha512
deleted file mode 100644
index 9e65ba5d7bf9a..0000000000000
--- a/deps/checksums/SuiteSparse-4.4.2.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-00425b94f5955e44b7ef6faf7773d23977827a74fe86833cf3cd8532eb4b42a0971e3cfb07caa3df990da2cf95947ad23fd429fd169270a016b1145e4f6b0c11
diff --git a/deps/checksums/SuiteSparse-4.4.5.tar.gz/md5 b/deps/checksums/SuiteSparse-4.4.5.tar.gz/md5
new file mode 100644
index 0000000000000..a52379502373e
--- /dev/null
+++ b/deps/checksums/SuiteSparse-4.4.5.tar.gz/md5
@@ -0,0 +1 @@
+a2926c27f8a5285e4a10265cc68bbc18
diff --git a/deps/checksums/SuiteSparse-4.4.5.tar.gz/sha512 b/deps/checksums/SuiteSparse-4.4.5.tar.gz/sha512
new file mode 100644
index 0000000000000..08ff5296f3ecd
--- /dev/null
+++ b/deps/checksums/SuiteSparse-4.4.5.tar.gz/sha512
@@ -0,0 +1 @@
+7f9c19c3c58f61e7d82cd2de25eeeec910ad3d6a5c7c79c62a23cbb7dc880cddeca6efa9860a87b3b3c05e74385c8c67bf61d44149b700ac094898237915a6d9
diff --git a/deps/checksums/arpack-ng-3.2.0-testA.mtx/md5 b/deps/checksums/arpack-ng-3.2.0-testA.mtx/md5
new file mode 100644
index 0000000000000..8e47827354ee3
--- /dev/null
+++ b/deps/checksums/arpack-ng-3.2.0-testA.mtx/md5
@@ -0,0 +1 @@
+2826846e98bcb009d339fb69973951d3
diff --git a/deps/checksums/arpack-ng-3.2.0-testA.mtx/sha512 b/deps/checksums/arpack-ng-3.2.0-testA.mtx/sha512
new file mode 100644
index 0000000000000..70eec3327a719
--- /dev/null
+++ b/deps/checksums/arpack-ng-3.2.0-testA.mtx/sha512
@@ -0,0 +1 @@
+00af7f2353441c4197c52d105d3670fe250a312b8e67ae2794246f2ce8cd0b63585e5c5ab764921d357efd9ad685fcc0ee5b8b8ee7ab9af2bea26ccbb97c50ba
diff --git a/deps/checksums/cfe-3.6.1.src.tar.xz/md5 b/deps/checksums/cfe-3.6.1.src.tar.xz/md5
deleted file mode 100644
index b69db72fcd1ee..0000000000000
--- a/deps/checksums/cfe-3.6.1.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-9ff6811757735051f8651833b22ae014
diff --git a/deps/checksums/cfe-3.6.1.src.tar.xz/sha512 b/deps/checksums/cfe-3.6.1.src.tar.xz/sha512
deleted file mode 100644
index d224afab17988..0000000000000
--- a/deps/checksums/cfe-3.6.1.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-a96944bccfd9341be7adafdcc40367d458e85e7e74b0d2f3a7ea18edf1454d04a232c2d0003d6449c52f81d1e235b434acc1bb63eb5f7d16f8f4a43b70826743
diff --git a/deps/checksums/cfe-3.7.0.src.tar.xz/md5 b/deps/checksums/cfe-3.7.0.src.tar.xz/md5
new file mode 100644
index 0000000000000..05e1a3361ab84
--- /dev/null
+++ b/deps/checksums/cfe-3.7.0.src.tar.xz/md5
@@ -0,0 +1 @@
+8f9d27335e7331cf0a4711e952f21f01
diff --git a/deps/checksums/cfe-3.7.0.src.tar.xz/sha512 b/deps/checksums/cfe-3.7.0.src.tar.xz/sha512
new file mode 100644
index 0000000000000..3f84b7f3fa035
--- /dev/null
+++ b/deps/checksums/cfe-3.7.0.src.tar.xz/sha512
@@ -0,0 +1 @@
+099d34cb019ea548c6ee85efd22b150beba0aa92061394fa3e423b1ebfe4a5c98c0586e5d56fc5c39e2b1606d36db59f442c056cc59473e32df76c8790c9d0ae
diff --git a/deps/checksums/cfe-3.7.1.src.tar.xz/md5 b/deps/checksums/cfe-3.7.1.src.tar.xz/md5
new file mode 100644
index 0000000000000..9cdf1474655c0
--- /dev/null
+++ b/deps/checksums/cfe-3.7.1.src.tar.xz/md5
@@ -0,0 +1 @@
+0acd026b5529164197563d135a8fd83e
diff --git a/deps/checksums/cfe-3.7.1.src.tar.xz/sha512 b/deps/checksums/cfe-3.7.1.src.tar.xz/sha512
new file mode 100644
index 0000000000000..9783b35d29eb8
--- /dev/null
+++ b/deps/checksums/cfe-3.7.1.src.tar.xz/sha512
@@ -0,0 +1 @@
+8e3285a32ad0fd4721fa77c4fb9709f31bb4e4f7cb5245357aaf57b0767b6ef18a30d902b59d1437a6febffb6c2128214f9ce5aa913bb298743221a28c4f9de5
diff --git a/deps/checksums/compiler-rt-3.6.1.src.tar.xz/md5 b/deps/checksums/compiler-rt-3.6.1.src.tar.xz/md5
deleted file mode 100644
index ab5fe2f6d1998..0000000000000
--- a/deps/checksums/compiler-rt-3.6.1.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-6f204b1feb324b1672ac907b32d927c0
diff --git a/deps/checksums/compiler-rt-3.6.1.src.tar.xz/sha512 b/deps/checksums/compiler-rt-3.6.1.src.tar.xz/sha512
deleted file mode 100644
index da7c526619e78..0000000000000
--- a/deps/checksums/compiler-rt-3.6.1.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-121c048fe60bccccd4a188a18613c94e1e1d9abd8fbae6405d23418f0c9b3562fff72fe77aea9bc0f8632ec9ad89503b9c67fcab5bf378001f90ad7492a1845a
diff --git a/deps/checksums/compiler-rt-3.7.0.src.tar.xz/md5 b/deps/checksums/compiler-rt-3.7.0.src.tar.xz/md5
new file mode 100644
index 0000000000000..72f9deb233c60
--- /dev/null
+++ b/deps/checksums/compiler-rt-3.7.0.src.tar.xz/md5
@@ -0,0 +1 @@
+383c10affd513026f08936b5525523f5
diff --git a/deps/checksums/compiler-rt-3.7.0.src.tar.xz/sha512 b/deps/checksums/compiler-rt-3.7.0.src.tar.xz/sha512
new file mode 100644
index 0000000000000..bc0b953409998
--- /dev/null
+++ b/deps/checksums/compiler-rt-3.7.0.src.tar.xz/sha512
@@ -0,0 +1 @@
+2ba6abb3d6ec7f1469cfe1d48fde2069e9a767d19144f80f05516ac63f353ace90a9df3e9d1c1f708f3c397aba0ec61b12e4f105b25a2e1cd26b25b0dd252bc9
diff --git a/deps/checksums/compiler-rt-3.7.1.src.tar.xz/md5 b/deps/checksums/compiler-rt-3.7.1.src.tar.xz/md5
new file mode 100644
index 0000000000000..db72b60b85cf9
--- /dev/null
+++ b/deps/checksums/compiler-rt-3.7.1.src.tar.xz/md5
@@ -0,0 +1 @@
+1c6975daf30bb3b0473b53c3a1a6ff01
diff --git a/deps/checksums/compiler-rt-3.7.1.src.tar.xz/sha512 b/deps/checksums/compiler-rt-3.7.1.src.tar.xz/sha512
new file mode 100644
index 0000000000000..4fbca97b42879
--- /dev/null
+++ b/deps/checksums/compiler-rt-3.7.1.src.tar.xz/sha512
@@ -0,0 +1 @@
+bf434519ea0838264c30de1e1e8681320aa868df0ecc825a45c659077b963a4120c18216946558cbf8aea24a8ac8ec39af2066dab906bc7cabc0894d51d61325
diff --git a/deps/checksums/gmp-6.0.0.tar.bz2/md5 b/deps/checksums/gmp-6.0.0.tar.bz2/md5
deleted file mode 100644
index 8c5aee0b4ee27..0000000000000
--- a/deps/checksums/gmp-6.0.0.tar.bz2/md5
+++ /dev/null
@@ -1 +0,0 @@
-6ef5869ae735db9995619135bd856b84
diff --git a/deps/checksums/gmp-6.0.0.tar.bz2/sha512 b/deps/checksums/gmp-6.0.0.tar.bz2/sha512
deleted file mode 100644
index 586dcf1bbd314..0000000000000
--- a/deps/checksums/gmp-6.0.0.tar.bz2/sha512
+++ /dev/null
@@ -1 +0,0 @@
-06bdd312146f77bd23d1447e60b02bfea2f1e6d00798b073879e8a50a6cf7264bdbf6f31a8347dd3a0889c7a9dee2d24051b74542fc4f9f07ba2d0f744e092ad
diff --git a/deps/checksums/gmp-6.1.0.tar.bz2/md5 b/deps/checksums/gmp-6.1.0.tar.bz2/md5
new file mode 100644
index 0000000000000..1c15d750c7cee
--- /dev/null
+++ b/deps/checksums/gmp-6.1.0.tar.bz2/md5
@@ -0,0 +1 @@
+86ee6e54ebfc4a90b643a65e402c4048
diff --git a/deps/checksums/gmp-6.1.0.tar.bz2/sha512 b/deps/checksums/gmp-6.1.0.tar.bz2/sha512
new file mode 100644
index 0000000000000..2c00b193e5a79
--- /dev/null
+++ b/deps/checksums/gmp-6.1.0.tar.bz2/sha512
@@ -0,0 +1 @@
+3c82aeab9c1596d4da8afac2eec38e429e84f3211e1a572cf8fd2b546493c44c039b922a1133eaaa48bd7f3e11dbe795a384e21ed95cbe3ecc58d7ac02246117
diff --git a/deps/checksums/libgit2-e8feafe32007ebd16a61820c70abd221655d053c.tar.gz/md5 b/deps/checksums/libgit2-e8feafe32007ebd16a61820c70abd221655d053c.tar.gz/md5
new file mode 100644
index 0000000000000..745069f22c64f
--- /dev/null
+++ b/deps/checksums/libgit2-e8feafe32007ebd16a61820c70abd221655d053c.tar.gz/md5
@@ -0,0 +1 @@
+417d9be015cda7fcd25e873b4c8fa648
diff --git a/deps/checksums/libgit2-e8feafe32007ebd16a61820c70abd221655d053c.tar.gz/sha512 b/deps/checksums/libgit2-e8feafe32007ebd16a61820c70abd221655d053c.tar.gz/sha512
new file mode 100644
index 0000000000000..d1d4e9b2108d5
--- /dev/null
+++ b/deps/checksums/libgit2-e8feafe32007ebd16a61820c70abd221655d053c.tar.gz/sha512
@@ -0,0 +1 @@
+987f0649a85fd79bf06db6aca9829eacbbbeac6cedd283c84e385ecc41eab86a47d14b80ec1edda133202a4a7f22ee56a9ac1e80b00d1ad78cabce7066b32c0b
diff --git a/deps/checksums/libgit2-f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b.tar.gz/md5 b/deps/checksums/libgit2-f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b.tar.gz/md5
deleted file mode 100644
index ed9ac40afad0c..0000000000000
--- a/deps/checksums/libgit2-f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-5ec6d4caf6218c27b73f7c00226de7aa
diff --git a/deps/checksums/libgit2-f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b.tar.gz/sha512 b/deps/checksums/libgit2-f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b.tar.gz/sha512
deleted file mode 100644
index d3fe19ddf87fd..0000000000000
--- a/deps/checksums/libgit2-f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-76d85f5fce5c7a9ee142a7eb216253618845efd60962f2140865a2953faffc95d3855e5b87fd5cb1e0ef8d46cc93e9f51582adc60530ef1e86b0493013e16f49
diff --git a/deps/checksums/libosxunwind-0.0.1.tar.gz/md5 b/deps/checksums/libosxunwind-0.0.1.tar.gz/md5
deleted file mode 100644
index ca41251be1e56..0000000000000
--- a/deps/checksums/libosxunwind-0.0.1.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-8461714dc7f91bdb8fee5fa93e05f585
diff --git a/deps/checksums/libosxunwind-0.0.1.tar.gz/sha512 b/deps/checksums/libosxunwind-0.0.1.tar.gz/sha512
deleted file mode 100644
index 7b26a9f17580d..0000000000000
--- a/deps/checksums/libosxunwind-0.0.1.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-c253398bd5f81492192731727000547e86e9620247aef9463f2794cf33d9d4b11c13c99844d5234d9da12100bb755a73989256c84058b4e1356f42453b86c072
diff --git a/deps/checksums/libosxunwind-0.0.3.tar.gz/md5 b/deps/checksums/libosxunwind-0.0.3.tar.gz/md5
new file mode 100644
index 0000000000000..6ff05f1bef8d8
--- /dev/null
+++ b/deps/checksums/libosxunwind-0.0.3.tar.gz/md5
@@ -0,0 +1 @@
+40510da5eb85e099050cadbc620d0af9
diff --git a/deps/checksums/libosxunwind-0.0.3.tar.gz/sha512 b/deps/checksums/libosxunwind-0.0.3.tar.gz/sha512
new file mode 100644
index 0000000000000..27de36c88d78d
--- /dev/null
+++ b/deps/checksums/libosxunwind-0.0.3.tar.gz/sha512
@@ -0,0 +1 @@
+64c57c297b6b3779ed7d675d3ebcf471247b0d15bb560fce631afd82229adb352d438cf71509ab076610c6867bcc9ee359cf609c0257e53bea431235ff1da349
diff --git a/deps/checksums/libunwind-1.1-julia2.tar.gz/md5 b/deps/checksums/libunwind-1.1-julia2.tar.gz/md5
new file mode 100644
index 0000000000000..bf053cceb330a
--- /dev/null
+++ b/deps/checksums/libunwind-1.1-julia2.tar.gz/md5
@@ -0,0 +1 @@
+8310cbf1288248996e5b4f5450e24588
diff --git a/deps/checksums/libunwind-1.1-julia2.tar.gz/sha512 b/deps/checksums/libunwind-1.1-julia2.tar.gz/sha512
new file mode 100644
index 0000000000000..f0115b99e9c93
--- /dev/null
+++ b/deps/checksums/libunwind-1.1-julia2.tar.gz/sha512
@@ -0,0 +1 @@
+5047890e727069c6ed74ca84bbe999ba6bc5c41d8d3914d6fbce19d18ff8a5944a7276d805ef5f67a857598852ae996a671c264d34a19123bb04d4daf6316f9a
diff --git a/deps/checksums/libunwind-1.1.tar.gz/md5 b/deps/checksums/libunwind-1.1.tar.gz/md5
deleted file mode 100644
index a2ae8703b6795..0000000000000
--- a/deps/checksums/libunwind-1.1.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-fb4ea2f6fbbe45bf032cd36e586883ce
diff --git a/deps/checksums/libunwind-1.1.tar.gz/sha512 b/deps/checksums/libunwind-1.1.tar.gz/sha512
deleted file mode 100644
index 50aacdb9c2863..0000000000000
--- a/deps/checksums/libunwind-1.1.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-bfe04f2bfac9f9e47c37f0b23ed2f264d8d3d3d6f1392fe9d794ee13cad216b3740979e922e4276fb65c1ccdc836fce48812cb5459ecdd2a89a621036a35d7c1
diff --git a/deps/checksums/libuv-07730c4bd595b4d45a498a8ee0bcd53878ff7c10.tar.gz/md5 b/deps/checksums/libuv-07730c4bd595b4d45a498a8ee0bcd53878ff7c10.tar.gz/md5
new file mode 100644
index 0000000000000..5355045bcbadc
--- /dev/null
+++ b/deps/checksums/libuv-07730c4bd595b4d45a498a8ee0bcd53878ff7c10.tar.gz/md5
@@ -0,0 +1 @@
+b05f089b4ac277deaac0d8372b7d4ea6
diff --git a/deps/checksums/libuv-07730c4bd595b4d45a498a8ee0bcd53878ff7c10.tar.gz/sha512 b/deps/checksums/libuv-07730c4bd595b4d45a498a8ee0bcd53878ff7c10.tar.gz/sha512
new file mode 100644
index 0000000000000..05d413371d84d
--- /dev/null
+++ b/deps/checksums/libuv-07730c4bd595b4d45a498a8ee0bcd53878ff7c10.tar.gz/sha512
@@ -0,0 +1 @@
+5bf5a4a026c57a26c8a4cbce2d69b4b12a0d325bd46a83c48ca8a24af1fc8548967f2060258e6cd751c8b86b653c42d41c42512fc6ce2114a06738332fdd243b
diff --git a/deps/checksums/libuv-28f5f06b5ff6f010d666ec26552e0badaca5cdcd.tar.gz/md5 b/deps/checksums/libuv-28f5f06b5ff6f010d666ec26552e0badaca5cdcd.tar.gz/md5
deleted file mode 100644
index 4edee6e62e585..0000000000000
--- a/deps/checksums/libuv-28f5f06b5ff6f010d666ec26552e0badaca5cdcd.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-429c128e55147c8b43d6555fe406869b
diff --git a/deps/checksums/libuv-28f5f06b5ff6f010d666ec26552e0badaca5cdcd.tar.gz/sha512 b/deps/checksums/libuv-28f5f06b5ff6f010d666ec26552e0badaca5cdcd.tar.gz/sha512
deleted file mode 100644
index 00006bb78791c..0000000000000
--- a/deps/checksums/libuv-28f5f06b5ff6f010d666ec26552e0badaca5cdcd.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-c80390c970cebded5a444cabce95e80314f10c56aa59a37c67f9221ba69d1ebe8ece2d524abb71d83aa7d239e92149171bc2f7428f4efe9a7e259ab2b019b871
diff --git a/deps/checksums/lldb-3.5.0.src.tar.xz/md5 b/deps/checksums/lldb-3.5.0.src.tar.xz/md5
deleted file mode 100644
index 2529cb607ebd6..0000000000000
--- a/deps/checksums/lldb-3.5.0.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-9597d5376309805ac586adfbd1e992f4
diff --git a/deps/checksums/lldb-3.5.0.src.tar.xz/sha512 b/deps/checksums/lldb-3.5.0.src.tar.xz/sha512
deleted file mode 100644
index fa86c452a9dac..0000000000000
--- a/deps/checksums/lldb-3.5.0.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-b3a45dd6b6c2d2d0e9909bc31d2bb3e19c63ae4e94c2a43db5a320a646a83d626d29ea1f45a0995123f9390f5db0c2b366e3a147e9a96cf454276a0a61a8497e
diff --git a/deps/checksums/lldb-3.7.0.src.tar.xz/md5 b/deps/checksums/lldb-3.7.0.src.tar.xz/md5
new file mode 100644
index 0000000000000..169bc27601afb
--- /dev/null
+++ b/deps/checksums/lldb-3.7.0.src.tar.xz/md5
@@ -0,0 +1 @@
+e5931740400d1dc3e7db4c7ba2ceff68
diff --git a/deps/checksums/lldb-3.7.0.src.tar.xz/sha512 b/deps/checksums/lldb-3.7.0.src.tar.xz/sha512
new file mode 100644
index 0000000000000..74bb25ddf19ef
--- /dev/null
+++ b/deps/checksums/lldb-3.7.0.src.tar.xz/sha512
@@ -0,0 +1 @@
+52157782ef13e2c8b7b35ff3ccc05887195fe46ddb6bafcf0707a3c46c1e034734b55342b8dbfc46cae7a8c3cb1012345284e4bedb2344c5016b8d19a12e90df
diff --git a/deps/checksums/llvm-3.3-i686-w64-mingw32-juliadeps.7z/md5 b/deps/checksums/llvm-3.3-i686-w64-mingw32-juliadeps.7z/md5
deleted file mode 100644
index 352dbfc0a8fc2..0000000000000
--- a/deps/checksums/llvm-3.3-i686-w64-mingw32-juliadeps.7z/md5
+++ /dev/null
@@ -1 +0,0 @@
-e10c7a38c00bd79925c5ca60668cdc04
diff --git a/deps/checksums/llvm-3.3-i686-w64-mingw32-juliadeps.7z/sha512 b/deps/checksums/llvm-3.3-i686-w64-mingw32-juliadeps.7z/sha512
deleted file mode 100644
index 1c93816157523..0000000000000
--- a/deps/checksums/llvm-3.3-i686-w64-mingw32-juliadeps.7z/sha512
+++ /dev/null
@@ -1 +0,0 @@
-fea52f6b115767fea76fa501cf29e96922cba5a5738e21fd83ddf90754bacbdd811adb0579cdf3072b0165619c27097b957e3013cbb358c586c68cf8cf903622
diff --git a/deps/checksums/llvm-3.3-x86_64-w64-mingw32-juliadeps.7z/md5 b/deps/checksums/llvm-3.3-x86_64-w64-mingw32-juliadeps.7z/md5
deleted file mode 100644
index 583f1f3e80a5d..0000000000000
--- a/deps/checksums/llvm-3.3-x86_64-w64-mingw32-juliadeps.7z/md5
+++ /dev/null
@@ -1 +0,0 @@
-311a181c91e3b176fe780e53bccbf445
diff --git a/deps/checksums/llvm-3.3-x86_64-w64-mingw32-juliadeps.7z/sha512 b/deps/checksums/llvm-3.3-x86_64-w64-mingw32-juliadeps.7z/sha512
deleted file mode 100644
index 0d2db90dc9239..0000000000000
--- a/deps/checksums/llvm-3.3-x86_64-w64-mingw32-juliadeps.7z/sha512
+++ /dev/null
@@ -1 +0,0 @@
-6c34119a4c162afd6425d90b950115eaf87abfce99186cf4a593c69562871e66941542992cdaf96cdcd78e2dda0656b8b0aa0d3682a06ae9bfdfa33607402366
diff --git a/deps/checksums/llvm-3.3.src.tar.gz/md5 b/deps/checksums/llvm-3.3.src.tar.gz/md5
deleted file mode 100644
index 41e901cf95ea4..0000000000000
--- a/deps/checksums/llvm-3.3.src.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-40564e1dc390f9844f1711c08b08e391
diff --git a/deps/checksums/llvm-3.3.src.tar.gz/sha512 b/deps/checksums/llvm-3.3.src.tar.gz/sha512
deleted file mode 100644
index 0f4323d9b381f..0000000000000
--- a/deps/checksums/llvm-3.3.src.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-1b7f7c5e907a68f642dcbe48fdff9585cb1504022bc9d386f310ebe5d25103d0d5f7cf0abf19e0e3fd666970160a98c90033754e2b79b2fac0cf866c984f8038
diff --git a/deps/checksums/llvm-3.5.0.src.tar.xz/md5 b/deps/checksums/llvm-3.5.0.src.tar.xz/md5
deleted file mode 100644
index 034bfe1edb4b8..0000000000000
--- a/deps/checksums/llvm-3.5.0.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-d6987305a1a0e58e128c1374cd3b8fef
diff --git a/deps/checksums/llvm-3.5.0.src.tar.xz/sha512 b/deps/checksums/llvm-3.5.0.src.tar.xz/sha512
deleted file mode 100644
index d274147641c1d..0000000000000
--- a/deps/checksums/llvm-3.5.0.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-b4d0f325dbdb0a8f10e5fd031954ef4b1971d8f99f4e4b53834801a2b74a7acde3f77c655c8355b407424b363edfb10f71d85fc370356dc52af5c636a1bba197
diff --git a/deps/checksums/llvm-3.5.1.src.tar.xz/md5 b/deps/checksums/llvm-3.5.1.src.tar.xz/md5
deleted file mode 100644
index b86ee689336d3..0000000000000
--- a/deps/checksums/llvm-3.5.1.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-2d3d8004f38852aa679e5945b8ce0b14
diff --git a/deps/checksums/llvm-3.5.1.src.tar.xz/sha512 b/deps/checksums/llvm-3.5.1.src.tar.xz/sha512
deleted file mode 100644
index 0c1418c0fc1b8..0000000000000
--- a/deps/checksums/llvm-3.5.1.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-a643ff173627e813b26077829b1af801b75daa5dcea540c4f05366ed57ef6aeafaf8b3fe4208d4c1b303a048a90ddac48a23488480c165637ae9218de140ae55
diff --git a/deps/checksums/llvm-3.6.0.src.tar.xz/md5 b/deps/checksums/llvm-3.6.0.src.tar.xz/md5
deleted file mode 100644
index 06f8b98fe5c2e..0000000000000
--- a/deps/checksums/llvm-3.6.0.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-f1e14e949f8df3047c59816c55278cec
diff --git a/deps/checksums/llvm-3.6.0.src.tar.xz/sha512 b/deps/checksums/llvm-3.6.0.src.tar.xz/sha512
deleted file mode 100644
index 834869b9242ca..0000000000000
--- a/deps/checksums/llvm-3.6.0.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-ca492b7d86333f05930dc849c7a8beff981da51ca174cd844650b516d0a592a2c3837d5a8a9b62713c0f29292b845f27ef0ec361809e325c6b60cbbcd3f20357
diff --git a/deps/checksums/llvm-3.6.1.src.tar.xz/md5 b/deps/checksums/llvm-3.6.1.src.tar.xz/md5
deleted file mode 100644
index 1db183f9c50f6..0000000000000
--- a/deps/checksums/llvm-3.6.1.src.tar.xz/md5
+++ /dev/null
@@ -1 +0,0 @@
-ebf9e97be405ae126e134d3a357cd58a
diff --git a/deps/checksums/llvm-3.6.1.src.tar.xz/sha512 b/deps/checksums/llvm-3.6.1.src.tar.xz/sha512
deleted file mode 100644
index 76a3280267efe..0000000000000
--- a/deps/checksums/llvm-3.6.1.src.tar.xz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-fa07d0fe6c527d86c0b91b1b62597f949d777e3609e4e8ca2ea5e07931e1ebc7a363273cc705cf4a13b45e7ab00716b76de26688d077c1b51341d9dd2972de3f
diff --git a/deps/checksums/llvm-3.7.0.src.tar.xz/md5 b/deps/checksums/llvm-3.7.0.src.tar.xz/md5
new file mode 100644
index 0000000000000..af48058221db3
--- /dev/null
+++ b/deps/checksums/llvm-3.7.0.src.tar.xz/md5
@@ -0,0 +1 @@
+b98b9495e5655a672d6cb83e1a180f8e
diff --git a/deps/checksums/llvm-3.7.0.src.tar.xz/sha512 b/deps/checksums/llvm-3.7.0.src.tar.xz/sha512
new file mode 100644
index 0000000000000..668a1537f3948
--- /dev/null
+++ b/deps/checksums/llvm-3.7.0.src.tar.xz/sha512
@@ -0,0 +1 @@
+fe3bfefd3d49423831ad12b89f944ac9f469aaaaafdea1dd94fc7fb6d5cc9fbe66b6463796aeaabfc145ae474ec3ad68da41c4a011e8aa4bc650f1835af75388
diff --git a/deps/checksums/llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z/md5 b/deps/checksums/llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z/md5
new file mode 100644
index 0000000000000..17b03f2082646
--- /dev/null
+++ b/deps/checksums/llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z/md5
@@ -0,0 +1 @@
+d639c06cdad6b7c55c1dbdb82e3def15
diff --git a/deps/checksums/llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z/sha512 b/deps/checksums/llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z/sha512
new file mode 100644
index 0000000000000..de93e76809c83
--- /dev/null
+++ b/deps/checksums/llvm-3.7.1-i686-w64-mingw32-juliadeps-r04.7z/sha512
@@ -0,0 +1 @@
+93785655d61d3eec63a1834669153148102171115982bfc01011a1f154192395ee7e787efc52047dc63a2887a11832ae3faccd7cf3fae4b168ffcd160786adee
diff --git a/deps/checksums/llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z/md5 b/deps/checksums/llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z/md5
new file mode 100644
index 0000000000000..df47ab34abf50
--- /dev/null
+++ b/deps/checksums/llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z/md5
@@ -0,0 +1 @@
+f27bdc73c67ce670b30a2494dcf82e58
diff --git a/deps/checksums/llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z/sha512 b/deps/checksums/llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z/sha512
new file mode 100644
index 0000000000000..c6faf62f87059
--- /dev/null
+++ b/deps/checksums/llvm-3.7.1-x86_64-w64-mingw32-juliadeps-r04.7z/sha512
@@ -0,0 +1 @@
+a61e0564816427be4c8d5005077354f01b9c4cb1c0abb1c6ccedf90b44654be4350edabe9a0c5fcd52833f1c4caa6aa286713879bec2eae96cb848c5422113c1
diff --git a/deps/checksums/llvm-3.7.1.src.tar.xz/md5 b/deps/checksums/llvm-3.7.1.src.tar.xz/md5
new file mode 100644
index 0000000000000..196eeed9e8758
--- /dev/null
+++ b/deps/checksums/llvm-3.7.1.src.tar.xz/md5
@@ -0,0 +1 @@
+bf8b3a2c79e61212c5409041dfdbd319
diff --git a/deps/checksums/llvm-3.7.1.src.tar.xz/sha512 b/deps/checksums/llvm-3.7.1.src.tar.xz/sha512
new file mode 100644
index 0000000000000..ecc9cdac3895c
--- /dev/null
+++ b/deps/checksums/llvm-3.7.1.src.tar.xz/sha512
@@ -0,0 +1 @@
+ac521debc02f6deba96ef975d6a546b0c5c77299c1dbf5e1b87a7974ff5e7fd715bd7e384b92d9adf572ce47130bdbf6d3c648eb0d7f72f16f976292e4909e90
diff --git a/deps/checksums/mpfr-3.1.2.tar.bz2/md5 b/deps/checksums/mpfr-3.1.2.tar.bz2/md5
deleted file mode 100644
index b68c167253ca6..0000000000000
--- a/deps/checksums/mpfr-3.1.2.tar.bz2/md5
+++ /dev/null
@@ -1 +0,0 @@
-ee2c3ac63bf0c2359bf08fc3ee094c19
diff --git a/deps/checksums/mpfr-3.1.2.tar.bz2/sha512 b/deps/checksums/mpfr-3.1.2.tar.bz2/sha512
deleted file mode 100644
index 3612956a44ac6..0000000000000
--- a/deps/checksums/mpfr-3.1.2.tar.bz2/sha512
+++ /dev/null
@@ -1 +0,0 @@
-0312a1ac813c51737e7d2b40fa771a73adb796ef962bbbd81ffd5e18a16b13346dd20875710e29f5304146750253d7d3755dc4c7b28c1b3b6cd527a6a7affd14
diff --git a/deps/checksums/mpfr-3.1.3.tar.bz2/md5 b/deps/checksums/mpfr-3.1.3.tar.bz2/md5
new file mode 100644
index 0000000000000..918e7bc05813a
--- /dev/null
+++ b/deps/checksums/mpfr-3.1.3.tar.bz2/md5
@@ -0,0 +1 @@
+5fdfa3cfa5c86514ee4a241a1affa138
diff --git a/deps/checksums/mpfr-3.1.3.tar.bz2/sha512 b/deps/checksums/mpfr-3.1.3.tar.bz2/sha512
new file mode 100644
index 0000000000000..dfc623a84f5c5
--- /dev/null
+++ b/deps/checksums/mpfr-3.1.3.tar.bz2/sha512
@@ -0,0 +1 @@
+29f1f18628e8f46cb4f12f246cc8e67e44457b549bad9e6ec5dcc3af0e5ba0f60594aef489081cee5a439eb2a0a22c5e2a793a38bf2f501b43d37bae8d9b3280
diff --git a/deps/checksums/openblas-53e849f4fcae4363a64576de00e982722c7304f9.tar.gz/md5 b/deps/checksums/openblas-53e849f4fcae4363a64576de00e982722c7304f9.tar.gz/md5
new file mode 100644
index 0000000000000..43459f64579c2
--- /dev/null
+++ b/deps/checksums/openblas-53e849f4fcae4363a64576de00e982722c7304f9.tar.gz/md5
@@ -0,0 +1 @@
+0d12e5bd5beb6a6948ea72efc3126264
diff --git a/deps/checksums/openblas-53e849f4fcae4363a64576de00e982722c7304f9.tar.gz/sha512 b/deps/checksums/openblas-53e849f4fcae4363a64576de00e982722c7304f9.tar.gz/sha512
new file mode 100644
index 0000000000000..da697473111c7
--- /dev/null
+++ b/deps/checksums/openblas-53e849f4fcae4363a64576de00e982722c7304f9.tar.gz/sha512
@@ -0,0 +1 @@
+4bfbd7ed531138ec935346c0476a5ff857938c9e1e8090f71ed21fe6329a07b1b38577bfa1e5bfabfc397209c1b800aec315c5bfbe917229ec0dcf5a523ea688
diff --git a/deps/checksums/openblas-d0c51c4de91b2356b770f92862c6b0e1d54953cd.tar.gz/md5 b/deps/checksums/openblas-d0c51c4de91b2356b770f92862c6b0e1d54953cd.tar.gz/md5
deleted file mode 100644
index 293daf8b35e68..0000000000000
--- a/deps/checksums/openblas-d0c51c4de91b2356b770f92862c6b0e1d54953cd.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-806c02d13f31644f021a1c111d0d5c8a
diff --git a/deps/checksums/openblas-d0c51c4de91b2356b770f92862c6b0e1d54953cd.tar.gz/sha512 b/deps/checksums/openblas-d0c51c4de91b2356b770f92862c6b0e1d54953cd.tar.gz/sha512
deleted file mode 100644
index 7a77ea4425943..0000000000000
--- a/deps/checksums/openblas-d0c51c4de91b2356b770f92862c6b0e1d54953cd.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-4664e7ad9e3071360948f413acf17be923619aa76d892f1e53749b20665b8da24ff184d04baba023cd67f6c02f8550e4c7142077771a6578f472b9f0203226f9
diff --git a/deps/checksums/pcre2-10.20.tar.bz2/md5 b/deps/checksums/pcre2-10.20.tar.bz2/md5
deleted file mode 100644
index c477aca7929e5..0000000000000
--- a/deps/checksums/pcre2-10.20.tar.bz2/md5
+++ /dev/null
@@ -1 +0,0 @@
-dcd027c57ecfdc8a6c3af9d0acf5e3f7
diff --git a/deps/checksums/pcre2-10.20.tar.bz2/sha512 b/deps/checksums/pcre2-10.20.tar.bz2/sha512
deleted file mode 100644
index 7bc4139e671d7..0000000000000
--- a/deps/checksums/pcre2-10.20.tar.bz2/sha512
+++ /dev/null
@@ -1 +0,0 @@
-3fcad35581a9d8e3b84b3509ada618165c0b53edb9622aa6ad92e83103eddabd6cfa8ce3aa9339bf5e0cf560b6f4ed07f37fcd3faa3b977964e610f23c99f639
diff --git a/deps/checksums/pcre2-10.21.tar.bz2/md5 b/deps/checksums/pcre2-10.21.tar.bz2/md5
new file mode 100644
index 0000000000000..f8bed624bb5e5
--- /dev/null
+++ b/deps/checksums/pcre2-10.21.tar.bz2/md5
@@ -0,0 +1 @@
+e79460519f916e3fcb204e59714bfd4a
diff --git a/deps/checksums/pcre2-10.21.tar.bz2/sha512 b/deps/checksums/pcre2-10.21.tar.bz2/sha512
new file mode 100644
index 0000000000000..30486a0fa4a15
--- /dev/null
+++ b/deps/checksums/pcre2-10.21.tar.bz2/sha512
@@ -0,0 +1 @@
+82f16e5476919de66bbd15a96a0f769bc03f55e679280d470f13e932b660efb7f57637c42a5d0907d1a84f836636bf57756ea961ae1d5763463c6964a8c37bb6
diff --git a/deps/compiler-rt-3.7.1.patch b/deps/compiler-rt-3.7.1.patch
new file mode 100644
index 0000000000000..3c91eaebfd8f4
--- /dev/null
+++ b/deps/compiler-rt-3.7.1.patch
@@ -0,0 +1,73 @@
+From efecb2c285bd444b6def43ac62e5f0278df387eb Mon Sep 17 00:00:00 2001
+From: Keno Fischer <kfischer@college.harvard.edu>
+Date: Mon, 5 Oct 2015 22:24:12 +0000
+Subject: [PATCH] [compiler-rt] Properly detect lack of available system
+ libraries for arch in clang_darwin.mk
+
+Summary: This is the Makefile analog of r247833, except that the test also had to be changed such that clang actually attempts to link the program as opposed to just building it. Because of that change, I also switched the order to checking for ld/clang architecture support, because now lack of ld support would make the clang check fail. This fixes PR24776.
+
+Reviewers: beanz
+
+Subscribers: llvm-commits
+
+Differential Revision: http://reviews.llvm.org/D13425
+
+git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@249358 91177308-0d34-0410-b5e6-96231b3b80d8
+---
+ make/platform/clang_darwin.mk           | 16 ++++++++--------
+ make/platform/clang_darwin_test_input.c |  9 +++++++++
+ 2 files changed, 17 insertions(+), 8 deletions(-)
+
+diff --git a/make/platform/clang_darwin.mk b/make/platform/clang_darwin.mk
+index 3a034b8..dff2694 100644
+--- a/projects/compiler-rt/make/platform/clang_darwin.mk
++++ b/projects/compiler-rt/make/platform/clang_darwin.mk
+@@ -17,23 +17,23 @@ CheckArches = \
+     result=""; \
+     if [ "X$(3)" != X ]; then \
+       for arch in $(1); do \
+-        if $(CC) -arch $$arch -c \
++        if $(LD) -v 2>&1 | grep "configured to support" \
++             | tr ' ' '\n' | grep "^$$arch$$" >/dev/null 2>/dev/null; then \
++          if $(CC) -arch $$arch \
+             -integrated-as \
+             $(ProjSrcRoot)/make/platform/clang_darwin_test_input.c \
+             -isysroot $(3) \
+             -o /dev/null > /dev/null 2> /dev/null; then \
+-          if $(LD) -v 2>&1 | grep "configured to support" \
+-             | tr ' ' '\n' | grep "^$$arch$$" >/dev/null 2>/dev/null; then \
+-            result="$$result$$arch "; \
++              result="$$result$$arch "; \
+           else \
+             printf 1>&2 \
+-            "warning: clang_darwin.mk: dropping arch '$$arch' from lib '$(2)'";\
+-            printf 1>&2 " (ld does not support it)\n"; \
++             "warning: clang_darwin.mk: dropping arch '$$arch' from lib '$(2)'"; \
++            printf 1>&2 " (clang or system libraries do not support it)\n"; \
+           fi; \
+         else \
+           printf 1>&2 \
+-           "warning: clang_darwin.mk: dropping arch '$$arch' from lib '$(2)'"; \
+-          printf 1>&2 " (clang does not support it)\n"; \
++            "warning: clang_darwin.mk: dropping arch '$$arch' from lib '$(2)'";\
++          printf 1>&2 " (ld does not support it)\n"; \
+         fi; \
+       done; \
+     fi; \
+diff --git a/make/platform/clang_darwin_test_input.c b/make/platform/clang_darwin_test_input.c
+index b7074b8..b406a28 100644
+--- a/projects/compiler-rt/make/platform/clang_darwin_test_input.c
++++ b/projects/compiler-rt/make/platform/clang_darwin_test_input.c
+@@ -4,3 +4,12 @@
+ #include <stdint.h>
+ #include <stdlib.h>
+ #include <stdio.h>
++#include <string.h>
++
++// Force us to link at least one symbol in a system library
++// to detect systems where we don't have those for a given
++// architecture.
++int main(int argc, const char **argv) {
++    int x;
++    memcpy(&x,&argc,sizeof(int));
++}
diff --git a/deps/gmp_6.0.0_osx.patch b/deps/gmp_6.0.0_osx.patch
deleted file mode 100644
index 8c6bf34d797e1..0000000000000
--- a/deps/gmp_6.0.0_osx.patch
+++ /dev/null
@@ -1,21 +0,0 @@
-diff -r db645603dcdb -r 1fab0adc5ff7 mpn/x86_64/k8/redc_1.asm
---- a/mpn/x86_64/k8/redc_1.asm	Mon Mar 31 23:04:32 2014 +0200
-+++ b/mpn/x86_64/k8/redc_1.asm	Wed Apr 02 22:28:24 2014 +0200
-@@ -114,7 +114,7 @@
- 
- 	JUMPTABSECT
- 	ALIGN(8)
--L(tab):	JMPENT(	L(0m4), L(tab))
-+L(tab):	JMPENT(	L(0), L(tab))
- 	JMPENT(	L(1), L(tab))
- 	JMPENT(	L(2), L(tab))
- 	JMPENT(	L(3), L(tab))
-@@ -397,6 +397,7 @@
- 
- 
- 	ALIGN(16)
-+L(0):
- L(0m4):
- L(lo0):	mov	(mp,nneg,8), %rax
- 	mov	nneg, i
-
diff --git a/deps/jlchecksum b/deps/jlchecksum
index 57120b5e0368c..7def72031f865 100755
--- a/deps/jlchecksum
+++ b/deps/jlchecksum
@@ -12,6 +12,7 @@ fi
 DIR="$( cd "$( dirname "$0" )" && pwd )"
 
 # Get the basename of the file we're trying to checksum
+ARG1=$1
 BASENAME=$(basename $1)
 
 # Print out a hash, and wrap around if we're longer than 64 characters
@@ -36,7 +37,7 @@ checksum_error()
     echo "  But \`$CHECKSUM_PROG\` results in:" >&2
     print_hash "$CURR_CHECKSUM"
     echo "  This can happen due to bad downloads or network proxies, please check your" >&2
-    echo "  network proxy/firewall settings and delete deps/$BASENAME" >&2
+    echo "  network proxy/firewall settings and delete deps/srccache/$BASENAME" >&2
     echo "  to force a redownload when you are ready" >&2
     echo "===============================================================================" >&2
     exit 2
@@ -66,15 +67,15 @@ MD5_PROG=""
 find_checksum_progs()
 {
     if [ ! -z $(which sha512sum) ]; then
-        SHA512_PROG="sha512sum $BASENAME | awk '{ print \$1; }'"
+        SHA512_PROG="sha512sum $ARG1 | awk '{ print \$1; }'"
     elif [ ! -z $(which shasum) ]; then
-        SHA512_PROG="shasum -a 512 $BASENAME | awk '{ print \$1; }'"
+        SHA512_PROG="shasum -a 512 $ARG1 | awk '{ print \$1; }'"
     fi
 
     if [ ! -z $(which md5sum) ]; then
-        MD5_PROG="md5sum $BASENAME | awk '{ print \$1; }'"
+        MD5_PROG="md5sum $ARG1 | awk '{ print \$1; }'"
     elif [ ! -z $(which md5) ]; then
-        MD5_PROG="md5 -q $BASENAME"
+        MD5_PROG="md5 -q $ARG1"
     fi
 }
 
diff --git a/deps/libgit2-require-openssl.patch b/deps/libgit2-require-openssl.patch
new file mode 100644
index 0000000000000..fce6e10635397
--- /dev/null
+++ b/deps/libgit2-require-openssl.patch
@@ -0,0 +1,13 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 73c9630..3dedd0a 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -217,7 +217,7 @@ ELSE ()
+ 	ENDIF ()
+ 
+ 	IF (NOT AMIGA AND USE_OPENSSL)
+-		FIND_PACKAGE(OpenSSL)
++		FIND_PACKAGE(OpenSSL REQUIRED)
+ 	ENDIF ()
+ 
+ 	IF (CURL_FOUND)
diff --git a/deps/libgit2.version b/deps/libgit2.version
index 466d0faca846f..7bf40ce38f5f4 100644
--- a/deps/libgit2.version
+++ b/deps/libgit2.version
@@ -1,2 +1,2 @@
-LIBGIT2_BRANCH=v0.23.1
-LIBGIT2_SHA1=f6dedf2c2eb806e2a6fdd4cf31f68386efc2ee0b
+LIBGIT2_BRANCH=v0.23.4
+LIBGIT2_SHA1=e8feafe32007ebd16a61820c70abd221655d053c
diff --git a/deps/libunwind.patch b/deps/libunwind.patch
deleted file mode 100644
index 1d12a81af7a91..0000000000000
--- a/deps/libunwind.patch
+++ /dev/null
@@ -1,22 +0,0 @@
-From e1d7c78d95e4b73a311f10149d0a54547d307d5d Mon Sep 17 00:00:00 2001
-From: Kevin Modzelewski <kmod@dropbox.com>
-Date: Tue, 22 Apr 2014 15:50:40 -0700
-Subject: [PATCH] Change the RBP-validation heuristic to allow size-0 call frames
-
----
-diff --git a/src/x86_64/Gstep.c b/src/x86_64/Gstep.c
-index 9fa0967..809d60b 100644
---- a/src/x86_64/Gstep.c
-+++ b/src/x86_64/Gstep.c
-@@ -173,7 +173,7 @@ unw_step (unw_cursor_t *cursor)
- 		 anything about new RBP (rbp1) since it may not be a frame
- 		 pointer in the frame above.  Just check we get the value. */
-               if (ret < 0
--		  || rbp <= c->dwarf.cfa
-+		  || rbp < c->dwarf.cfa
- 		  || (rbp - c->dwarf.cfa) > 0x4000)
- 	        {
-                   rip_loc = DWARF_NULL_LOC;
--- 
-1.7.4.1
-
diff --git a/deps/libuv.version b/deps/libuv.version
index 07dde31f2ac4d..63aee4a1f549e 100644
--- a/deps/libuv.version
+++ b/deps/libuv.version
@@ -1,2 +1,2 @@
 LIBUV_BRANCH=julia-uv0.11.26
-LIBUV_SHA1=28f5f06b5ff6f010d666ec26552e0badaca5cdcd
+LIBUV_SHA1=07730c4bd595b4d45a498a8ee0bcd53878ff7c10
diff --git a/deps/lldb-3.7.1.patch b/deps/lldb-3.7.1.patch
new file mode 100644
index 0000000000000..15ace008c4991
--- /dev/null
+++ b/deps/lldb-3.7.1.patch
@@ -0,0 +1,41 @@
+diff --git a/tools/lldb/source/Host/Makefile b/tools/lldb/source/Host/Makefile
+index a8e4260..da90c8c 100644
+--- a/tools/lldb/source/Host/Makefile
++++ b/tools/lldb/source/Host/Makefile
+@@ -14,7 +14,7 @@ include $(LEVEL)/Makefile.config
+
+ define DIR_SOURCES
+ SOURCES += $$(addprefix $(1)/,$$(notdir $$(wildcard $$(PROJ_SRC_DIR)/$(1)/*.cpp \
+-					 $$(PROJ_SRC_DIR)/*.cc $$(PROJ_SRC_DIR)/$(1)/*.c)))
++					 $$(PROJ_SRC_DIR)/*.cc $$(PROJ_SRC_DIR)/$(1)/*.c $$(PROJ_SRC_DIR)/$(1)/*.mm)))
+ endef
+
+ $(eval $(call DIR_SOURCES,common))
+@@ -22,6 +22,15 @@ $(eval $(call DIR_SOURCES,common))
+ ifeq ($(HOST_OS),Darwin)
+ $(eval $(call DIR_SOURCES,posix))
+ $(eval $(call DIR_SOURCES,macosx))
++CFCPP_SOURCES = \
++          $(addprefix macosx/cfcpp/,$(notdir $(wildcard $(PROJ_SRC_DIR)/macosx/cfcpp/*.cpp)))
++SOURCES += $(CFCPP_SOURCES)
++
++CFCPP_BaseNameSources := $(sort $(basename $(CFCPP_SOURCES)))
++CFCPP_OBJECTS := $(CFCPP_BaseNameSources:%=$(ObjDir)/%.o)
++
++# Make sure the cfcpp output directory exists
++$(CFCPP_OBJECTS): $(ObjDir)/cfcpp/.dir
+ endif
+
+ ifeq ($(HOST_OS),Linux)
+@@ -34,6 +43,11 @@ $(eval $(call DIR_SOURCES,posix))
+ $(eval $(call DIR_SOURCES,freebsd))
+ endif
+
++ifeq ($(HOST_OS),NetBSD)
++$(eval $(call DIR_SOURCES,posix))
++$(eval $(call DIR_SOURCES,netbsd))
++endif
++
+ ifeq ($(HOST_OS),MingW)
+ $(eval $(call DIR_SOURCES,windows))
+ endif
diff --git a/deps/llvm-3.7.0.patch b/deps/llvm-3.7.0.patch
new file mode 100644
index 0000000000000..6ae438393a22a
--- /dev/null
+++ b/deps/llvm-3.7.0.patch
@@ -0,0 +1,29 @@
+commit 06e88db43d1ff367d03b731c9c1f4f69da78149b
+Author: Keno Fischer <kfischer@college.harvard.edu>
+Date:   Fri Oct 9 17:24:54 2015 +0000
+
+    Clear SectionSymbols in MCContext::Reset
+    
+    This was just forgotten when SectionSymbols was introduced and could cause
+    corruption if the MCContext was reused after Reset.
+    
+    Reviewers: rafael
+    
+    Subscribers: llvm-commits
+    
+    Differential Revision: http://reviews.llvm.org/D13547
+    
+    git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@249854 91177308-0d34-0410-b5e6-96231b3b80d8
+
+diff --git a/lib/MC/MCContext.cpp b/lib/MC/MCContext.cpp
+index ff195d0..2160b4e 100644
+--- a/lib/MC/MCContext.cpp
++++ b/lib/MC/MCContext.cpp
+@@ -80,6 +80,7 @@ void MCContext::reset() {
+ 
+   UsedNames.clear();
+   Symbols.clear();
++  SectionSymbols.clear();
+   Allocator.Reset();
+   Instances.clear();
+   CompilationDir.clear();
diff --git a/deps/llvm-3.7.1.patch b/deps/llvm-3.7.1.patch
new file mode 100644
index 0000000000000..2291b72a5a71e
--- /dev/null
+++ b/deps/llvm-3.7.1.patch
@@ -0,0 +1,550 @@
+diff --git a/include/llvm/ExecutionEngine/SectionMemoryManager.h b/include/llvm/ExecutionEngine/SectionMemoryManager.h
+index 0b0dcb0..7bb96eb 100644
+--- a/include/llvm/ExecutionEngine/SectionMemoryManager.h
++++ b/include/llvm/ExecutionEngine/SectionMemoryManager.h
+@@ -83,10 +83,28 @@ public:
+   virtual void invalidateInstructionCache();
+ 
+ private:
++  struct FreeMemBlock {
++    // The actual block of free memory
++    sys::MemoryBlock Free;
++    // If there is a pending allocation from the same reservation right before
++    // this block, store it's index in PendingMem, to be able to update the
++    // pending region if part of this block is allocated, rather than having to
++    // create a new one
++    unsigned PendingPrefixIndex;
++  };
++
+   struct MemoryGroup {
+-      SmallVector<sys::MemoryBlock, 16> AllocatedMem;
+-      SmallVector<sys::MemoryBlock, 16> FreeMem;
+-      sys::MemoryBlock Near;
++    // PendingMem contains all blocks of memory (subblocks of AllocatedMem)
++    // which have not yet had their permissions applied, but have been given
++    // out to the user. FreeMem contains all block of memory, which have
++    // neither had their permissions applied, nor been given out to the user.
++    SmallVector<sys::MemoryBlock, 16> PendingMem;
++    SmallVector<FreeMemBlock, 16> FreeMem;
++
++    // All memory blocks that have been requested from the system
++    SmallVector<sys::MemoryBlock, 16> AllocatedMem;
++
++    sys::MemoryBlock Near;
+   };
+ 
+   uint8_t *allocateSection(MemoryGroup &MemGroup, uintptr_t Size,
+@@ -103,4 +121,3 @@ private:
+ }
+ 
+ #endif // LLVM_EXECUTION_ENGINE_SECTION_MEMORY_MANAGER_H
+-
+diff --git a/include/llvm/Support/raw_ostream.h b/include/llvm/Support/raw_ostream.h
+index 28e512c..686e8c8 100644
+--- a/include/llvm/Support/raw_ostream.h
++++ b/include/llvm/Support/raw_ostream.h
+@@ -485,6 +485,9 @@ public:
+ 
+ /// A raw_ostream that writes to an SmallVector or SmallString.  This is a
+ /// simple adaptor class. This class does not encounter output errors.
++/// raw_svector_ostream operates without a buffer, delegating all memory
++/// management to the SmallString. Thus the SmallString is always up-to-date,
++/// may be used directly and there is no need to call flush().
+ class raw_svector_ostream : public raw_pwrite_stream {
+   SmallVectorImpl<char> &OS;
+ 
+@@ -493,32 +496,24 @@ class raw_svector_ostream : public raw_pwrite_stream {
+ 
+   void pwrite_impl(const char *Ptr, size_t Size, uint64_t Offset) override;
+ 
+-  /// Return the current position within the stream, not counting the bytes
+-  /// currently in the buffer.
++  /// Return the current position within the stream.
+   uint64_t current_pos() const override;
+ 
+-protected:
+-  // Like the regular constructor, but doesn't call init.
+-  explicit raw_svector_ostream(SmallVectorImpl<char> &O, unsigned);
+-  void init();
+-
+ public:
+   /// Construct a new raw_svector_ostream.
+   ///
+   /// \param O The vector to write to; this should generally have at least 128
+   /// bytes free to avoid any extraneous memory overhead.
+-  explicit raw_svector_ostream(SmallVectorImpl<char> &O);
+-  ~raw_svector_ostream() override;
+-
++  explicit raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
++    SetUnbuffered();
++  }
++  ~raw_svector_ostream() override {}
+ 
+-  /// This is called when the SmallVector we're appending to is changed outside
+-  /// of the raw_svector_ostream's control.  It is only safe to do this if the
+-  /// raw_svector_ostream has previously been flushed.
+-  void resync();
++  // FIXME: resync is no-op. Remove it and its users.
++  void resync() {}
+ 
+-  /// Flushes the stream contents to the target vector and return a StringRef
+-  /// for the vector contents.
+-  StringRef str();
++  /// Return a StringRef for the vector contents.
++  StringRef str() { return StringRef(OS.data(), OS.size()); }
+ };
+ 
+ /// A raw_ostream that discards all output.
+@@ -541,9 +536,7 @@ class buffer_ostream : public raw_svector_ostream {
+   SmallVector<char, 0> Buffer;
+ 
+ public:
+-  buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer, 0), OS(OS) {
+-    init();
+-  }
++  buffer_ostream(raw_ostream &OS) : raw_svector_ostream(Buffer), OS(OS) {}
+   ~buffer_ostream() { OS << str(); }
+ };
+ 
+diff --git a/lib/CodeGen/MachineModuleInfo.cpp b/lib/CodeGen/MachineModuleInfo.cpp
+index 6a20624..53a9ea7 100644
+--- a/lib/CodeGen/MachineModuleInfo.cpp
++++ b/lib/CodeGen/MachineModuleInfo.cpp
+@@ -227,6 +227,7 @@ bool MachineModuleInfo::doFinalization(Module &M) {
+   AddrLabelSymbols = nullptr;
+ 
+   Context.reset();
++  FuncInfoMap.clear();
+ 
+   delete ObjFileMMI;
+   ObjFileMMI = nullptr;
+diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+index 93287a3..93bbd6f 100644
+--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
++++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
+@@ -85,20 +85,25 @@ void RuntimeDyldImpl::resolveRelocations() {
+   // First, resolve relocations associated with external symbols.
+   resolveExternalSymbols();
+ 
+-  // Just iterate over the sections we have and resolve all the relocations
+-  // in them. Gross overkill, but it gets the job done.
+-  for (int i = 0, e = Sections.size(); i != e; ++i) {
++  // Iterate over all outstanding relocations
++  for (auto it = Relocations.begin(), e = Relocations.end(); it != e; ++it) {
+     // The Section here (Sections[i]) refers to the section in which the
+     // symbol for the relocation is located.  The SectionID in the relocation
+     // entry provides the section to which the relocation will be applied.
+-    uint64_t Addr = Sections[i].LoadAddress;
+-    DEBUG(dbgs() << "Resolving relocations Section #" << i << "\t"
++    int Idx = it->first;
++    uint64_t Addr = Sections[Idx].LoadAddress;
++    DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
+                  << format("%p", (uintptr_t)Addr) << "\n");
+-    DEBUG(dumpSectionMemory(Sections[i], "before relocations"));
+-    resolveRelocationList(Relocations[i], Addr);
+-    DEBUG(dumpSectionMemory(Sections[i], "after relocations"));
+-    Relocations.erase(i);
++    resolveRelocationList(it->second, Addr);
+   }
++  Relocations.clear();
++
++  // Print out sections after relocation.
++  DEBUG(
++    for (int i = 0, e = Sections.size(); i != e; ++i)
++      dumpSectionMemory(Sections[i], "after relocations");
++  );
++
+ }
+ 
+ void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
+diff --git a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+index e085a92..cc12093 100644
+--- a/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
++++ b/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
+@@ -30,6 +30,7 @@
+ #include "llvm/Support/SwapByteOrder.h"
+ #include "llvm/Support/raw_ostream.h"
+ #include <map>
++#include <unordered_map>
+ #include <system_error>
+ 
+ using namespace llvm;
+@@ -224,7 +225,7 @@ protected:
+   // Relocations to sections already loaded. Indexed by SectionID which is the
+   // source of the address. The target where the address will be written is
+   // SectionID/Offset in the relocation itself.
+-  DenseMap<unsigned, RelocationList> Relocations;
++  std::unordered_map<unsigned, RelocationList> Relocations;
+ 
+   // Relocations to external symbols that are not yet resolved.  Symbols are
+   // external when they aren't found in the global symbol table of all loaded
+diff --git a/lib/ExecutionEngine/SectionMemoryManager.cpp b/lib/ExecutionEngine/SectionMemoryManager.cpp
+index 5986084..e2f2208 100644
+--- a/lib/ExecutionEngine/SectionMemoryManager.cpp
++++ b/lib/ExecutionEngine/SectionMemoryManager.cpp
+@@ -15,6 +15,7 @@
+ #include "llvm/Config/config.h"
+ #include "llvm/ExecutionEngine/SectionMemoryManager.h"
+ #include "llvm/Support/MathExtras.h"
++#include "llvm/Support/Process.h"
+ 
+ namespace llvm {
+ 
+@@ -48,16 +49,27 @@ uint8_t *SectionMemoryManager::allocateSection(MemoryGroup &MemGroup,
+ 
+   // Look in the list of free memory regions and use a block there if one
+   // is available.
+-  for (int i = 0, e = MemGroup.FreeMem.size(); i != e; ++i) {
+-    sys::MemoryBlock &MB = MemGroup.FreeMem[i];
+-    if (MB.size() >= RequiredSize) {
+-      Addr = (uintptr_t)MB.base();
+-      uintptr_t EndOfBlock = Addr + MB.size();
++  for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
++    if (FreeMB.Free.size() >= RequiredSize) {
++      Addr = (uintptr_t)FreeMB.Free.base();
++      uintptr_t EndOfBlock = Addr + FreeMB.Free.size();
+       // Align the address.
+       Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
+-      // Store cutted free memory block.
+-      MemGroup.FreeMem[i] = sys::MemoryBlock((void*)(Addr + Size),
+-                                             EndOfBlock - Addr - Size);
++
++      if (FreeMB.PendingPrefixIndex == (unsigned)-1) {
++        // The part of the block we're giving out to the user is now pending
++        MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));
++
++        // Remember this pending block, such that future allocations can just
++        // modify it rather than creating a new one
++        FreeMB.PendingPrefixIndex = MemGroup.PendingMem.size() - 1;
++      } else {
++        sys::MemoryBlock &PendingMB = MemGroup.PendingMem[FreeMB.PendingPrefixIndex];
++        PendingMB = sys::MemoryBlock(PendingMB.base(), Addr + Size - (uintptr_t)PendingMB.base());
++      }
++
++      // Remember how much free space is now left in this block
++      FreeMB.Free = sys::MemoryBlock((void *)(Addr + Size), EndOfBlock - Addr - Size);
+       return (uint8_t*)Addr;
+     }
+   }
+@@ -85,6 +97,7 @@ uint8_t *SectionMemoryManager::allocateSection(MemoryGroup &MemGroup,
+   // Save this address as the basis for our next request
+   MemGroup.Near = MB;
+ 
++  // Remember that we allocated this memory
+   MemGroup.AllocatedMem.push_back(MB);
+   Addr = (uintptr_t)MB.base();
+   uintptr_t EndOfBlock = Addr + MB.size();
+@@ -92,11 +105,18 @@ uint8_t *SectionMemoryManager::allocateSection(MemoryGroup &MemGroup,
+   // Align the address.
+   Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
+ 
++  // The part of the block we're giving out to the user is now pending
++  MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));
++
+   // The allocateMappedMemory may allocate much more memory than we need. In
+   // this case, we store the unused memory as a free memory block.
+   unsigned FreeSize = EndOfBlock-Addr-Size;
+-  if (FreeSize > 16)
+-    MemGroup.FreeMem.push_back(sys::MemoryBlock((void*)(Addr + Size), FreeSize));
++  if (FreeSize > 16) {
++    FreeMemBlock FreeMB;
++    FreeMB.Free = sys::MemoryBlock((void*)(Addr + Size), FreeSize);
++    FreeMB.PendingPrefixIndex = (unsigned)-1;
++    MemGroup.FreeMem.push_back(FreeMB);
++  }
+ 
+   // Return aligned address
+   return (uint8_t*)Addr;
+@@ -107,9 +127,6 @@ bool SectionMemoryManager::finalizeMemory(std::string *ErrMsg)
+   // FIXME: Should in-progress permissions be reverted if an error occurs?
+   std::error_code ec;
+ 
+-  // Don't allow free memory blocks to be used after setting protection flags.
+-  CodeMem.FreeMem.clear();
+-
+   // Make code memory executable.
+   ec = applyMemoryGroupPermissions(CodeMem,
+                                    sys::Memory::MF_READ | sys::Memory::MF_EXEC);
+@@ -143,36 +160,62 @@ bool SectionMemoryManager::finalizeMemory(std::string *ErrMsg)
+   return false;
+ }
+ 
++static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M) {
++  static const size_t PageSize = sys::Process::getPageSize();
++
++  size_t StartOverlap =
++      (PageSize - ((uintptr_t)M.base() % PageSize)) % PageSize;
++
++  size_t TrimmedSize = M.size();
++  TrimmedSize -= StartOverlap;
++  TrimmedSize -= TrimmedSize % PageSize;
++
++  sys::MemoryBlock Trimmed((void *)((uintptr_t)M.base() + StartOverlap), TrimmedSize);
++
++  assert(((uintptr_t)Trimmed.base() % PageSize) == 0);
++  assert((Trimmed.size() % PageSize) == 0);
++  assert(M.base() <= Trimmed.base() && Trimmed.size() <= M.size());
++
++  return Trimmed;
++}
++
++
+ std::error_code
+ SectionMemoryManager::applyMemoryGroupPermissions(MemoryGroup &MemGroup,
+                                                   unsigned Permissions) {
+-
+-  for (int i = 0, e = MemGroup.AllocatedMem.size(); i != e; ++i) {
+-    std::error_code ec;
+-    ec =
+-        sys::Memory::protectMappedMemory(MemGroup.AllocatedMem[i], Permissions);
+-    if (ec) {
+-      return ec;
+-    }
++  for (sys::MemoryBlock &MB : MemGroup.PendingMem)
++    if (std::error_code EC = sys::Memory::protectMappedMemory(MB, Permissions))
++      return EC;
++
++  MemGroup.PendingMem.clear();
++
++  // Now go through free blocks and trim any of them that don't span the entire
++  // page because one of the pending blocks may have overlapped it.
++  for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
++    FreeMB.Free = trimBlockToPageSize(FreeMB.Free);
++    // We cleared the PendingMem list, so all these pointers are now invalid
++    FreeMB.PendingPrefixIndex = (unsigned)-1;
+   }
+ 
++  // Remove all blocks which are now empty
++  MemGroup.FreeMem.erase(
++      std::remove_if(MemGroup.FreeMem.begin(), MemGroup.FreeMem.end(),
++                     [](FreeMemBlock &FreeMB) { return FreeMB.Free.size() == 0; }),
++      MemGroup.FreeMem.end());
++
+   return std::error_code();
+ }
+ 
+ void SectionMemoryManager::invalidateInstructionCache() {
+-  for (int i = 0, e = CodeMem.AllocatedMem.size(); i != e; ++i)
+-    sys::Memory::InvalidateInstructionCache(CodeMem.AllocatedMem[i].base(),
+-                                            CodeMem.AllocatedMem[i].size());
++  for (sys::MemoryBlock &Block : CodeMem.PendingMem)
++    sys::Memory::InvalidateInstructionCache(Block.base(), Block.size());
+ }
+ 
+ SectionMemoryManager::~SectionMemoryManager() {
+-  for (unsigned i = 0, e = CodeMem.AllocatedMem.size(); i != e; ++i)
+-    sys::Memory::releaseMappedMemory(CodeMem.AllocatedMem[i]);
+-  for (unsigned i = 0, e = RWDataMem.AllocatedMem.size(); i != e; ++i)
+-    sys::Memory::releaseMappedMemory(RWDataMem.AllocatedMem[i]);
+-  for (unsigned i = 0, e = RODataMem.AllocatedMem.size(); i != e; ++i)
+-    sys::Memory::releaseMappedMemory(RODataMem.AllocatedMem[i]);
++  for (MemoryGroup *Group : {&CodeMem, &RWDataMem, &RODataMem}) {
++    for (sys::MemoryBlock &Block : Group->AllocatedMem)
++      sys::Memory::releaseMappedMemory(Block);
++  }
+ }
+ 
+ } // namespace llvm
+-
+diff --git a/lib/IR/Verifier.cpp b/lib/IR/Verifier.cpp
+index 2a0a4ff..228c09f 100644
+--- a/lib/IR/Verifier.cpp
++++ b/lib/IR/Verifier.cpp
+@@ -1754,6 +1754,14 @@ void Verifier::visitFunction(const Function &F) {
+   assert(F.hasMetadata() != MDs.empty() && "Bit out-of-sync");
+   VerifyFunctionMetadata(MDs);
+ 
++  // Check validity of the personality function
++  if (F.hasPersonalityFn()) {
++    auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
++    if (Per)
++      Assert(Per->getParent() == F.getParent(),
++             "Referencing personality function in another module!", &F, Per);
++  }
++
+   if (F.isMaterializable()) {
+     // Function has a body somewhere we can't see.
+     Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
+diff --git a/lib/Support/Unix/Memory.inc b/lib/Support/Unix/Memory.inc
+index c421ee8..33beff5 100644
+--- a/lib/Support/Unix/Memory.inc
++++ b/lib/Support/Unix/Memory.inc
+@@ -153,6 +153,7 @@ Memory::releaseMappedMemory(MemoryBlock &M) {
+ 
+ std::error_code
+ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
++  static const size_t PageSize = Process::getPageSize();
+   if (M.Address == nullptr || M.Size == 0)
+     return std::error_code();
+ 
+@@ -161,7 +162,7 @@ Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
+ 
+   int Protect = getPosixProtectionFlags(Flags);
+ 
+-  int Result = ::mprotect(M.Address, M.Size, Protect);
++  int Result = ::mprotect((void*)((uintptr_t)M.Address & ~(PageSize-1)), PageSize*((M.Size+PageSize-1)/PageSize), Protect);
+   if (Result != 0)
+     return std::error_code(errno, std::generic_category());
+ 
+@@ -181,7 +182,7 @@ Memory::AllocateRWX(size_t NumBytes, const MemoryBlock* NearBlock,
+                     std::string *ErrMsg) {
+   if (NumBytes == 0) return MemoryBlock();
+ 
+-  size_t PageSize = Process::getPageSize();
++  static const size_t PageSize = Process::getPageSize();
+   size_t NumPages = (NumBytes+PageSize-1)/PageSize;
+ 
+   int fd = -1;
+diff --git a/lib/Support/raw_ostream.cpp b/lib/Support/raw_ostream.cpp
+index 42f830b..3a37987 100644
+--- a/lib/Support/raw_ostream.cpp
++++ b/lib/Support/raw_ostream.cpp
+@@ -755,72 +755,15 @@ void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
+ //  raw_svector_ostream
+ //===----------------------------------------------------------------------===//
+ 
+-// The raw_svector_ostream implementation uses the SmallVector itself as the
+-// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is
+-// always pointing past the end of the vector, but within the vector
+-// capacity. This allows raw_ostream to write directly into the correct place,
+-// and we only need to set the vector size when the data is flushed.
++uint64_t raw_svector_ostream::current_pos() const { return OS.size(); }
+ 
+-raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O, unsigned)
+-    : OS(O) {}
+-
+-raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
+-  init();
+-}
+-
+-void raw_svector_ostream::init() {
+-  // Set up the initial external buffer. We make sure that the buffer has at
+-  // least 128 bytes free; raw_ostream itself only requires 64, but we want to
+-  // make sure that we don't grow the buffer unnecessarily on destruction (when
+-  // the data is flushed). See the FIXME below.
+-  OS.reserve(OS.size() + 128);
+-  SetBuffer(OS.end(), OS.capacity() - OS.size());
+-}
+-
+-raw_svector_ostream::~raw_svector_ostream() {
+-  // FIXME: Prevent resizing during this flush().
+-  flush();
+-}
++void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
++  OS.append(Ptr, Ptr + Size);
++};
+ 
+ void raw_svector_ostream::pwrite_impl(const char *Ptr, size_t Size,
+                                       uint64_t Offset) {
+-  flush();
+-  memcpy(OS.begin() + Offset, Ptr, Size);
+-}
+-
+-/// resync - This is called when the SmallVector we're appending to is changed
+-/// outside of the raw_svector_ostream's control.  It is only safe to do this
+-/// if the raw_svector_ostream has previously been flushed.
+-void raw_svector_ostream::resync() {
+-  assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector");
+-
+-  if (OS.capacity() - OS.size() < 64)
+-    OS.reserve(OS.capacity() * 2);
+-  SetBuffer(OS.end(), OS.capacity() - OS.size());
+-}
+-
+-void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
+-  if (Ptr == OS.end()) {
+-    // Grow the buffer to include the scratch area without copying.
+-    size_t NewSize = OS.size() + Size;
+-    assert(NewSize <= OS.capacity() && "Invalid write_impl() call!");
+-    OS.set_size(NewSize);
+-  } else {
+-    assert(!GetNumBytesInBuffer());
+-    OS.append(Ptr, Ptr + Size);
+-  }
+-
+-  OS.reserve(OS.size() + 64);
+-  SetBuffer(OS.end(), OS.capacity() - OS.size());
+-}
+-
+-uint64_t raw_svector_ostream::current_pos() const {
+-  return OS.size();
+-}
+-
+-StringRef raw_svector_ostream::str() {
+-  flush();
+-  return StringRef(OS.begin(), OS.size());
++  memcpy(OS.data() + Offset, Ptr, Size);
+ }
+ 
+ //===----------------------------------------------------------------------===//
+diff --git a/lib/Transforms/Scalar/Sink.cpp b/lib/Transforms/Scalar/Sink.cpp
+index f49f4ea..1bdbf11 100644
+--- a/lib/Transforms/Scalar/Sink.cpp
++++ b/lib/Transforms/Scalar/Sink.cpp
+@@ -169,7 +169,8 @@ static bool isSafeToMove(Instruction *Inst, AliasAnalysis *AA,
+         return false;
+   }
+ 
+-  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst))
++  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst) ||
++      isa<LandingPadInst>(Inst))
+     return false;
+ 
+   // Convergent operations can only be moved to control equivalent blocks.
+diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
+index cc4d6c6..404b007 100644
+--- a/lib/Transforms/Utils/CloneFunction.cpp
++++ b/lib/Transforms/Utils/CloneFunction.cpp
+@@ -96,6 +96,13 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
+   NewFunc->copyAttributesFrom(OldFunc);
+   NewFunc->setAttributes(NewAttrs);
+ 
++  // Fix up the personality function that got copied over.
++  if (OldFunc->hasPersonalityFn())
++    NewFunc->setPersonalityFn(
++        MapValue(OldFunc->getPersonalityFn(), VMap,
++                 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
++                 TypeMapper, Materializer));
++
+   AttributeSet OldAttrs = OldFunc->getAttributes();
+   // Clone any argument attributes that are present in the VMap.
+   for (const Argument &OldArg : OldFunc->args())
+diff --git a/test/Transforms/Sink/landingpad.ll b/test/Transforms/Sink/landingpad.ll
+new file mode 100644
+index 0000000..10548fd
+--- /dev/null
++++ b/test/Transforms/Sink/landingpad.ll
+@@ -0,0 +1,33 @@
++; Test that we don't sink landingpads
++; RUN: opt -sink -S < %s | FileCheck %s
++
++declare hidden void @g()
++declare void @h()
++declare i32 @__gxx_personality_v0(...)
++
++define void @f() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
++entry:
++  invoke void @g()
++          to label %invoke.cont.15 unwind label %lpad
++
++invoke.cont.15:
++  unreachable
++
++; CHECK: lpad:
++; CHECK: %0 = landingpad { i8*, i32 }
++lpad:
++  %0 = landingpad { i8*, i32 }
++          catch i8* null
++  invoke void @h()
++          to label %invoke.cont unwind label %lpad.1
++
++; CHECK: invoke.cont
++; CHECK-NOT: %0 = landingpad { i8*, i32 }
++invoke.cont:
++  ret void
++
++lpad.1:
++  %1 = landingpad { i8*, i32 }
++          cleanup
++  resume { i8*, i32 } %1
++}
diff --git a/deps/llvm-3.7.1_2.patch b/deps/llvm-3.7.1_2.patch
new file mode 100644
index 0000000000000..5e7a7ee03588b
--- /dev/null
+++ b/deps/llvm-3.7.1_2.patch
@@ -0,0 +1,220 @@
+diff --git a/include/llvm/MC/MCStreamer.h b/include/llvm/MC/MCStreamer.h
+index 6b9b8a1..86e273b 100644
+--- a/include/llvm/MC/MCStreamer.h
++++ b/include/llvm/MC/MCStreamer.h
+@@ -131,6 +131,10 @@ public:
+ 
+   void finish() override;
+ 
++  /// Reset any state between object emissions, i.e. the equivalent of
++  /// MCStreamer's reset method.
++  virtual void reset();
++
+   /// Callback used to implement the ldr= pseudo.
+   /// Add a new entry to the constant pool for the current section and return an
+   /// MCExpr that can be used to refer to the constant pool location.
+diff --git a/include/llvm/Support/MathExtras.h b/include/llvm/Support/MathExtras.h
+index 2cf7e0e..6bacca0 100644
+--- a/include/llvm/Support/MathExtras.h
++++ b/include/llvm/Support/MathExtras.h
+@@ -63,7 +63,7 @@ template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
+   }
+ };
+ 
+-#if __GNUC__ >= 4 || _MSC_VER
++#if __GNUC__ >= 4 || defined(_MSC_VER)
+ template <typename T> struct TrailingZerosCounter<T, 4> {
+   static std::size_t count(T Val, ZeroBehavior ZB) {
+     if (ZB != ZB_Undefined && Val == 0)
+@@ -71,7 +71,7 @@ template <typename T> struct TrailingZerosCounter<T, 4> {
+ 
+ #if __has_builtin(__builtin_ctz) || LLVM_GNUC_PREREQ(4, 0, 0)
+     return __builtin_ctz(Val);
+-#elif _MSC_VER
++#elif defined(_MSC_VER)
+     unsigned long Index;
+     _BitScanForward(&Index, Val);
+     return Index;
+@@ -87,7 +87,7 @@ template <typename T> struct TrailingZerosCounter<T, 8> {
+ 
+ #if __has_builtin(__builtin_ctzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+     return __builtin_ctzll(Val);
+-#elif _MSC_VER
++#elif defined(_MSC_VER)
+     unsigned long Index;
+     _BitScanForward64(&Index, Val);
+     return Index;
+@@ -132,7 +132,7 @@ template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
+   }
+ };
+ 
+-#if __GNUC__ >= 4 || _MSC_VER
++#if __GNUC__ >= 4 || defined(_MSC_VER)
+ template <typename T> struct LeadingZerosCounter<T, 4> {
+   static std::size_t count(T Val, ZeroBehavior ZB) {
+     if (ZB != ZB_Undefined && Val == 0)
+@@ -140,7 +140,7 @@ template <typename T> struct LeadingZerosCounter<T, 4> {
+ 
+ #if __has_builtin(__builtin_clz) || LLVM_GNUC_PREREQ(4, 0, 0)
+     return __builtin_clz(Val);
+-#elif _MSC_VER
++#elif defined(_MSC_VER)
+     unsigned long Index;
+     _BitScanReverse(&Index, Val);
+     return Index ^ 31;
+@@ -156,7 +156,7 @@ template <typename T> struct LeadingZerosCounter<T, 8> {
+ 
+ #if __has_builtin(__builtin_clzll) || LLVM_GNUC_PREREQ(4, 0, 0)
+     return __builtin_clzll(Val);
+-#elif _MSC_VER
++#elif defined(_MSC_VER)
+     unsigned long Index;
+     _BitScanReverse64(&Index, Val);
+     return Index ^ 63;
+diff --git a/lib/ExecutionEngine/SectionMemoryManager.cpp b/lib/ExecutionEngine/SectionMemoryManager.cpp
+index e2f2208..1ad5f17 100644
+--- a/lib/ExecutionEngine/SectionMemoryManager.cpp
++++ b/lib/ExecutionEngine/SectionMemoryManager.cpp
+@@ -137,9 +137,6 @@ bool SectionMemoryManager::finalizeMemory(std::string *ErrMsg)
+     return true;
+   }
+ 
+-  // Don't allow free memory blocks to be used after setting protection flags.
+-  RODataMem.FreeMem.clear();
+-
+   // Make read-only data memory read-only.
+   ec = applyMemoryGroupPermissions(RODataMem,
+                                    sys::Memory::MF_READ | sys::Memory::MF_EXEC);
+diff --git a/lib/MC/MCMachOStreamer.cpp b/lib/MC/MCMachOStreamer.cpp
+index 53cd131..7f9a6c5 100644
+--- a/lib/MC/MCMachOStreamer.cpp
++++ b/lib/MC/MCMachOStreamer.cpp
+@@ -60,6 +60,7 @@ public:
+ 
+   /// state management
+   void reset() override {
++    CreatedADWARFSection = false;
+     HasSectionLabel.clear();
+     MCObjectStreamer::reset();
+   }
+diff --git a/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp b/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
+index d17fdb9..62d3914 100644
+--- a/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
++++ b/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
+@@ -388,6 +388,9 @@ private:
+ 
+   size_t calculateContentSize() const;
+ 
++  // Reset state between object emissions
++  void reset() override;
++
+ public:
+   ARMTargetELFStreamer(MCStreamer &S)
+     : ARMTargetStreamer(S), CurrentVendor("aeabi"), FPU(ARM::FK_INVALID),
+@@ -415,7 +418,7 @@ public:
+                  MCCodeEmitter *Emitter, bool IsThumb)
+       : MCELFStreamer(Context, TAB, OS, Emitter), IsThumb(IsThumb),
+         MappingSymbolCounter(0), LastEMS(EMS_None) {
+-    Reset();
++    EHReset();
+   }
+ 
+   ~ARMELFStreamer() {}
+@@ -578,7 +581,10 @@ private:
+   }
+ 
+   // Helper functions for ARM exception handling directives
+-  void Reset();
++  void EHReset();
++
++  // Reset state between object emissions
++  void reset() override;
+ 
+   void EmitPersonalityFixup(StringRef Name);
+   void FlushPendingOffset();
+@@ -1045,6 +1051,8 @@ void ARMTargetELFStreamer::emitInst(uint32_t Inst, char Suffix) {
+   getStreamer().emitInst(Inst, Suffix);
+ }
+ 
++void ARMTargetELFStreamer::reset() { AttributeSection = nullptr; }
++
+ void ARMELFStreamer::FinishImpl() {
+   MCTargetStreamer &TS = *getTargetStreamer();
+   ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
+@@ -1053,6 +1061,18 @@ void ARMELFStreamer::FinishImpl() {
+   MCELFStreamer::FinishImpl();
+ }
+ 
++void ARMELFStreamer::reset() {
++  MCTargetStreamer &TS = *getTargetStreamer();
++  ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
++  ATS.reset();
++  MappingSymbolCounter = 0;
++  MCELFStreamer::reset();
++  // MCELFStreamer clear's the assembler's e_flags. However, for
++  // arm we manually set the ABI version on streamer creation, so
++  // do the same here
++  getAssembler().setELFHeaderEFlags(ELF::EF_ARM_EABI_VER5);
++}
++
+ inline void ARMELFStreamer::SwitchToEHSection(const char *Prefix,
+                                               unsigned Type,
+                                               unsigned Flags,
+@@ -1104,7 +1124,7 @@ void ARMELFStreamer::EmitFixup(const MCExpr *Expr, MCFixupKind Kind) {
+                                               Kind));
+ }
+ 
+-void ARMELFStreamer::Reset() {
++void ARMELFStreamer::EHReset() {
+   ExTab = nullptr;
+   FnStart = nullptr;
+   Personality = nullptr;
+@@ -1174,7 +1194,7 @@ void ARMELFStreamer::emitFnEnd() {
+   SwitchSection(&FnStart->getSection());
+ 
+   // Clean exception handling frame information
+-  Reset();
++  EHReset();
+ }
+ 
+ void ARMELFStreamer::emitCantUnwind() { CantUnwind = true; }
+diff --git a/lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp b/lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp
+index b680db5..25da8fc 100644
+--- a/lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp
++++ b/lib/Target/ARM/MCTargetDesc/ARMTargetStreamer.cpp
+@@ -38,6 +38,9 @@ void ARMTargetStreamer::emitCurrentConstantPool() {
+ // finish() - write out any non-empty assembler constant pools.
+ void ARMTargetStreamer::finish() { ConstantPools->emitAll(Streamer); }
+ 
++// reset() - Reset any state
++void ARMTargetStreamer::reset() {}
++
+ // The remaining callbacks should be handled separately by each
+ // streamer.
+ void ARMTargetStreamer::emitFnStart() {}
+diff --git a/tools/llvm-shlib/Makefile b/tools/llvm-shlib/Makefile
+index 2bc81da..4ff211d 100644
+--- a/tools/llvm-shlib/Makefile
++++ b/tools/llvm-shlib/Makefile
+@@ -86,11 +86,19 @@ $(LibName.SO): $(SHLIB_STUBS)
+ 	$(Echo) Collecting global symbols of $(notdir $*)
+ 	$(Verb) $(NM_PATH) -g $< > $@
+ 
++# The Windows ABI specifies leading underscores only on 32bit, so
++# make sure we don't strip them on x86_64
++ifeq ($(ARCH),x86_64)
++ABI_UNDERSCORE =
++else
++ABI_UNDERSCORE =_
++endif
++
+ $(ObjDir)/$(LIBRARYNAME).exports: $(SHLIB_FRAGS) $(ObjDir)/.dir
+ 	$(Echo) Generating exports for $(LIBRARYNAME)
+ 	$(Verb) ($(SED) -n \
+-			-e "s/^.* T _\([^.][^.]*\)$$/\1/p" \
+-			-e "s/^.* [BDR] _\([^.][^.]*\)$$/\1 DATA/p" \
++			-e "s/^.* T $(ABI_UNDERSCORE)\([^.][^.]*\)$$/\1/p" \
++			-e "s/^.* [BDR] $(ABI_UNDERSCORE)\([^.][^.]*\)$$/\1 DATA/p" \
+ 			$(SHLIB_FRAGS) \
+ 		 | sort -u) > $@
+ 
diff --git a/deps/llvm-3.7.1_3.patch b/deps/llvm-3.7.1_3.patch
new file mode 100644
index 0000000000000..c955da9a0e26b
--- /dev/null
+++ b/deps/llvm-3.7.1_3.patch
@@ -0,0 +1,16 @@
+Index: /lib/Analysis/ScalarEvolutionExpander.cpp
+===================================================================
+--- /lib/Analysis/ScalarEvolutionExpander.cpp
++++ /lib/Analysis/ScalarEvolutionExpander.cpp
+@@ -1273,6 +1273,11 @@
+   if (!SE.dominates(Step, L->getHeader())) {
+     PostLoopScale = Step;
+     Step = SE.getConstant(Normalized->getType(), 1);
++    if (!PostLoopOffset) {
++        // otherwise, Start is known to already be a constant zero
++        PostLoopOffset = Start;
++        Start = SE.getConstant(Normalized->getType(), 0);
++    }
+     Normalized =
+       cast<SCEVAddRecExpr>(SE.getAddRecExpr(
+                              Start, Step, Normalized->getLoop(),
diff --git a/deps/llvm-D14260.patch b/deps/llvm-D14260.patch
new file mode 100644
index 0000000000000..a930ce9ac8227
--- /dev/null
+++ b/deps/llvm-D14260.patch
@@ -0,0 +1,136 @@
+Index: lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
+===================================================================
+--- a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
++++ b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
+@@ -879,6 +879,61 @@
+   return nullptr;
+ }
+
++/// \brief Look for extractelement/insertvalue sequence that acts like a bitcast.
++///
++/// \returns underlying value that was "cast", or nullptr otherwise.
++///
++/// For example, if we have:
++///
++///     %E0 = extractelement <2 x double> %U, i32 0
++///     %V0 = insertvalue [2 x double] undef, double %E0, 0
++///     %E1 = extractelement <2 x double> %U, i32 1
++///     %V1 = insertvalue [2 x double] %V0, double %E1, 1
++///
++/// and the layout of a <2 x double> is isomorphic to a [2 x double],
++/// then %V1 can be safely approximated by a conceptual "bitcast" of %U.
++/// Note that %U may contain non-undef values where %V1 has undef.
++static Value* likeBitCastFromVector(InstCombiner &IC, Value* V) {
++  Value *U = nullptr;
++  while (auto *IV = dyn_cast<InsertValueInst>(V)) {
++    auto *E = dyn_cast<ExtractElementInst>(IV->getInsertedValueOperand());
++    if (!E)
++      return nullptr;
++    auto *W = E->getVectorOperand();
++    if (!U)
++      U = W;
++    else if (U != W)
++      return nullptr;
++    auto *CI = dyn_cast<ConstantInt>(E->getIndexOperand());
++    if (!CI || IV->getNumIndices() != 1 || CI->getZExtValue() != *IV->idx_begin())
++      return nullptr;
++    V = IV->getAggregateOperand();
++  }
++  if (!isa<UndefValue>(V) ||!U)
++    return nullptr;
++
++  VectorType *UT = cast<VectorType>(U->getType());
++  Type *VT = V->getType();
++  // Check that types UT and VT are bitwise isomorphic.
++  const DataLayout &DL = IC.getDataLayout();
++  if (DL.getTypeSizeInBits(UT) != DL.getTypeSizeInBits(VT)) {
++    return nullptr;
++  }
++  if (ArrayType *AT = dyn_cast<ArrayType>(VT)) {
++    if (AT->getNumElements() != UT->getNumElements())
++      return nullptr;
++  } else {
++    StructType *ST = cast<StructType>(VT);
++    if (ST->getNumElements() != UT->getNumElements())
++      return nullptr;
++    for (const Type *EltT : ST->elements()) {
++      if (EltT != UT->getElementType())
++        return nullptr;
++    }
++  }
++  return U;
++}
++
+ /// \brief Combine stores to match the type of value being stored.
+ ///
+ /// The core idea here is that the memory does not have any intrinsic type and
+@@ -914,6 +969,11 @@
+     return true;
+   }
+
++  if (Value *U = likeBitCastFromVector(IC, V)) {
++    combineStoreToNewValue(IC, SI, U);
++    return true;
++  }
++
+   // FIXME: We should also canonicalize loads of vectors when their elements are
+   // cast to other types.
+   return false;
+Index: test/Transforms/InstCombine/insert-val-extract-elem.ll
+===================================================================
+--- a/test/Transforms/InstCombine/insert-val-extract-elem.ll
++++ b/test/Transforms/InstCombine/insert-val-extract-elem.ll
+@@ -0,0 +1,53 @@
++; RUN: opt -S -instcombine %s | FileCheck %s
++
++; CHECK-NOT: insertvalue
++; CHECK-NOT: extractelement
++; CHECK: store <2 x double>
++define void @julia_2xdouble([2 x double]* sret, <2 x double>*) {
++top:
++  %x = load <2 x double>, <2 x double>* %1
++  %x0 = extractelement <2 x double> %x, i32 0
++  %i0 = insertvalue [2 x double] undef, double %x0, 0
++  %x1 = extractelement <2 x double> %x, i32 1
++  %i1 = insertvalue [2 x double] %i0, double %x1, 1
++  store [2 x double] %i1, [2 x double]* %0, align 4
++  ret void
++}
++
++; CHECK-NOT: insertvalue
++; CHECK-NOT: extractelement
++; CHECK: store <4 x float>
++define void @julia_4xfloat([4 x float]* sret, <4 x float>*) {
++top:
++  %x = load <4 x float>, <4 x float>* %1
++  %x0 = extractelement <4 x float> %x, i32 0
++  %i0 = insertvalue [4 x float] undef, float %x0, 0
++  %x1 = extractelement <4 x float> %x, i32 1
++  %i1 = insertvalue [4 x float] %i0, float %x1, 1
++  %x2 = extractelement <4 x float> %x, i32 2
++  %i2 = insertvalue [4 x float] %i1, float %x2, 2
++  %x3 = extractelement <4 x float> %x, i32 3
++  %i3 = insertvalue [4 x float] %i2, float %x3, 3
++  store [4 x float] %i3, [4 x float]* %0, align 4
++  ret void
++}
++
++%pseudovec = type { float, float, float, float }
++
++; CHECK-NOT: insertvalue
++; CHECK-NOT: extractelement
++; CHECK: store <4 x float>
++define void @julia_pseudovec(%pseudovec* sret, <4 x float>*) {
++top:
++  %x = load <4 x float>, <4 x float>* %1
++  %x0 = extractelement <4 x float> %x, i32 0
++  %i0 = insertvalue %pseudovec undef, float %x0, 0
++  %x1 = extractelement <4 x float> %x, i32 1
++  %i1 = insertvalue %pseudovec %i0, float %x1, 1
++  %x2 = extractelement <4 x float> %x, i32 2
++  %i2 = insertvalue %pseudovec %i1, float %x2, 2
++  %x3 = extractelement <4 x float> %x, i32 3
++  %i3 = insertvalue %pseudovec %i2, float %x3, 3
++  store %pseudovec %i3, %pseudovec* %0, align 4
++  ret void
++}
diff --git a/deps/openblas-win64.patch b/deps/openblas-win64.patch
new file mode 100644
index 0000000000000..a93e874499f7c
--- /dev/null
+++ b/deps/openblas-win64.patch
@@ -0,0 +1,75 @@
+commit 640cccc2b159dba6d99b9eea11b7f23f98d6c85d
+Author: Zhang Xianyi <traits.zhang@gmail.com>
+Date:   Mon Nov 30 15:19:45 2015 -0600
+
+    Refs #697. Fixed gemv bug for Windows.
+    
+    Thank matzeri's patch.
+
+diff --git a/interface/gemv.c b/interface/gemv.c
+index 0a222a6..97c68bf 100644
+--- a/interface/gemv.c
++++ b/interface/gemv.c
+@@ -37,6 +37,7 @@
+ /*********************************************************************/
+ 
+ #include <stdio.h>
++#include <assert.h>
+ #include "common.h"
+ #include "l1param.h"
+ #ifdef FUNCTION_PROFILE
+@@ -224,13 +225,17 @@ void CNAME(enum CBLAS_ORDER order,
+ #ifdef ALIGNED_ACCESS
+   stack_alloc_size += 3;
+ #endif
+-  if(stack_alloc_size < 128)
++//  if(stack_alloc_size < 128)
+     //dgemv_n.S require a 128 bytes buffer
+-    stack_alloc_size = 128;
++// increasing instead of capping 128 
++// ABI STACK for windows 288 bytes
++    stack_alloc_size += 288 / sizeof(FLOAT) ;
+ 
+   if(stack_alloc_size > MAX_STACK_ALLOC / sizeof(FLOAT))
+     stack_alloc_size = 0;
+ 
++// stack overflow check
++  volatile double stack_check = 3.14159265358979323846;
+   FLOAT stack_buffer[stack_alloc_size];
+   buffer = stack_alloc_size ? stack_buffer : (FLOAT *)blas_memory_alloc(1);
+   //  printf("stack_alloc_size=%d\n", stack_alloc_size);
+@@ -265,6 +270,8 @@ void CNAME(enum CBLAS_ORDER order,
+ 
+   }
+ #endif
++// stack overflow check
++assert(stack_check==3.14159265358979323846);
+ 
+ #ifdef MAX_STACK_ALLOC
+   if(!stack_alloc_size){
+diff --git a/exports/Makefile b/exports/Makefile
+index 177e975..29a9ca8 100644
+--- a/exports/Makefile
++++ b/exports/Makefile
+@@ -96,9 +96,9 @@ libgoto_hpl.def : gensymbol
+ ifeq (, $(SYMBOLPREFIX)$(SYMBOLSUFFIX))
+ $(LIBDYNNAME) : ../$(LIBNAME) osx.def
+ else
+-../$(LIBNAME).renamed : ../$(LIBNAME) objconv.def
+-	$(OBJCONV) @objconv.def ../$(LIBNAME) ../$(LIBNAME).renamed
+-$(LIBDYNNAME) : ../$(LIBNAME).renamed osx.def
++../$(LIBNAME).osx.renamed : ../$(LIBNAME) objconv.def
++	$(OBJCONV) @objconv.def ../$(LIBNAME) ../$(LIBNAME).osx.renamed
++$(LIBDYNNAME) : ../$(LIBNAME).osx.renamed osx.def
+ endif
+ ifeq ($(NOFORTRAN), $(filter $(NOFORTRAN),1 2))
+ #only build without Fortran
+@@ -220,7 +220,7 @@ linktest.c : gensymbol ../Makefile.system ../getarch.c
+ 	perl ./gensymbol linktest  $(ARCH) $(BU) $(EXPRECISION) $(NO_CBLAS) $(NO_LAPACK) $(NO_LAPACKE) $(NEED2UNDERSCORES) $(ONLY_CBLAS) "$(SYMBOLPREFIX)" "$(SYMBOLSUFFIX)" > linktest.c
+ 
+ clean ::
+-	@rm -f *.def *.dylib __.SYMDEF*
++	@rm -f *.def *.dylib __.SYMDEF* *.renamed
+ 
+ include ../Makefile.tail
+ 
diff --git a/deps/openblas.version b/deps/openblas.version
index 5f672524d5d0b..7c97e1bf1705d 100644
--- a/deps/openblas.version
+++ b/deps/openblas.version
@@ -1,2 +1,2 @@
-OPENBLAS_BRANCH=v0.2.14
-OPENBLAS_SHA1=d0c51c4de91b2356b770f92862c6b0e1d54953cd
+OPENBLAS_BRANCH=v0.2.15
+OPENBLAS_SHA1=53e849f4fcae4363a64576de00e982722c7304f9
diff --git a/deps/osx-10.10.llvm-3.3.patch b/deps/osx-10.10.llvm-3.3.patch
index 85897ae7f25c7..f22aaf03432f2 100644
--- a/deps/osx-10.10.llvm-3.3.patch
+++ b/deps/osx-10.10.llvm-3.3.patch
@@ -1,5 +1,5 @@
---- Makefile.rules.old	2014-07-29 12:01:50.000000000 +0530
-+++ Makefile.rules	2014-07-29 12:02:10.000000000 +0530
+--- llvm-3.3.src/Makefile.rules.old	2014-07-29 12:01:50.000000000 +0530
++++ llvm-3.3/Makefile.rules	2014-07-29 12:02:10.000000000 +0530
 @@ -571,9 +571,9 @@ ifeq ($(HOST_OS),Darwin)
    DARWIN_VERSION := `sw_vers -productVersion`
   endif
diff --git a/deps/win64-allocas-llvm-3.6.0.patch b/deps/win64-allocas-llvm-3.6.0.patch
deleted file mode 100644
index 14aad5506b630..0000000000000
--- a/deps/win64-allocas-llvm-3.6.0.patch
+++ /dev/null
@@ -1,313 +0,0 @@
-diff --git a/lib/Target/X86/X86FrameLowering.cpp b/lib/Target/X86/X86FrameLowering.cpp
-index 16aab16..41e717f 100644
---- a/lib/Target/X86/X86FrameLowering.cpp
-+++ b/lib/Target/X86/X86FrameLowering.cpp
-@@ -375,12 +375,25 @@ static bool usesTheStack(const MachineFunction &MF) {
-   return false;
- }
- 
--void X86FrameLowering::getStackProbeFunction(const X86Subtarget &STI,
--                                             unsigned &CallOp,
--                                             const char *&Symbol) {
--  CallOp = STI.is64Bit() ? X86::W64ALLOCA : X86::CALLpcrel32;
-+void X86FrameLowering::emitStackProbeCall(MachineFunction &MF,
-+                                          MachineBasicBlock &MBB,
-+                                          MachineBasicBlock::iterator MBBI,
-+                                          DebugLoc DL) {
-+  const TargetInstrInfo &TII = *MF.getSubtarget().getInstrInfo();
-+  const X86Subtarget &STI = MF.getTarget().getSubtarget<X86Subtarget>();
-+  bool Is64Bit = STI.is64Bit();
-+  bool IsLargeCodeModel = MF.getTarget().getCodeModel() == CodeModel::Large;
-+  const X86RegisterInfo *RegInfo =
-+      static_cast<const X86RegisterInfo *>(MF.getSubtarget().getRegisterInfo());
-+
-+  unsigned CallOp;
-+  if (Is64Bit)
-+    CallOp = IsLargeCodeModel ? X86::CALL64r : X86::CALL64pcrel32;
-+  else
-+    CallOp = X86::CALLpcrel32;
- 
--  if (STI.is64Bit()) {
-+  const char *Symbol;
-+  if (Is64Bit) {
-     if (STI.isTargetCygMing()) {
-       Symbol = "___chkstk_ms";
-     } else {
-@@ -390,6 +403,37 @@ void X86FrameLowering::getStackProbeFunction(const X86Subtarget &STI,
-     Symbol = "_alloca";
-   else
-     Symbol = "_chkstk";
-+
-+  MachineInstrBuilder CI;
-+
-+  // All current stack probes take AX and SP as input, clobber flags, and
-+  // preserve all registers. x86_64 probes leave RSP unmodified.
-+  if (Is64Bit && MF.getTarget().getCodeModel() == CodeModel::Large) {
-+    // For the large code model, we have to call through a register. Use R11,
-+    // as it is scratch in all supported calling conventions.
-+    BuildMI(MBB, MBBI, DL, TII.get(X86::MOV64ri), X86::R11)
-+        .addExternalSymbol(Symbol);
-+    CI = BuildMI(MBB, MBBI, DL, TII.get(CallOp)).addReg(X86::R11);
-+  } else {
-+    CI = BuildMI(MBB, MBBI, DL, TII.get(CallOp)).addExternalSymbol(Symbol);
-+  }
-+
-+  unsigned AX = Is64Bit ? X86::RAX : X86::EAX;
-+  unsigned SP = Is64Bit ? X86::RSP : X86::ESP;
-+  CI.addReg(AX, RegState::Implicit)
-+      .addReg(SP, RegState::Implicit)
-+      .addReg(AX, RegState::Define | RegState::Implicit)
-+      .addReg(SP, RegState::Define | RegState::Implicit)
-+      .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
-+
-+  if (Is64Bit) {
-+    // MSVC x64's __chkstk and cygwin/mingw's ___chkstk_ms do not adjust %rsp
-+    // themselves. It also does not clobber %rax so we can reuse it when
-+    // adjusting %rsp.
-+    BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64rr), X86::RSP)
-+        .addReg(X86::RSP)
-+        .addReg(X86::RAX);
-+  }
- }
- 
- /// emitPrologue - Push callee-saved registers onto the stack, which
-@@ -722,11 +766,6 @@ void X86FrameLowering::emitPrologue(MachineFunction &MF) const {
-   // increments is necessary to ensure that the guard pages used by the OS
-   // virtual memory manager are allocated in correct sequence.
-   if (NumBytes >= StackProbeSize && UseStackProbe) {
--    const char *StackProbeSymbol;
--    unsigned CallOp;
--
--    getStackProbeFunction(STI, CallOp, StackProbeSymbol);
--
-     // Check whether EAX is livein for this function.
-     bool isEAXAlive = isEAXLiveIn(MF);
- 
-@@ -755,22 +794,17 @@ void X86FrameLowering::emitPrologue(MachineFunction &MF) const {
-         .setMIFlag(MachineInstr::FrameSetup);
-     }
- 
--    BuildMI(MBB, MBBI, DL,
--            TII.get(CallOp))
--      .addExternalSymbol(StackProbeSymbol)
--      .addReg(StackPtr,    RegState::Define | RegState::Implicit)
--      .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit)
--      .setMIFlag(MachineInstr::FrameSetup);
-+    // Save a pointer to the MI where we set AX.
-+    MachineBasicBlock::iterator SetRAX = MBBI;
-+    --SetRAX;
-+
-+    // Call __chkstk, __chkstk_ms, or __alloca.
-+    emitStackProbeCall(MF, MBB, MBBI, DL);
-+
-+    // Apply the frame setup flag to all inserted instrs.
-+    for (; SetRAX != MBBI; ++SetRAX)
-+      SetRAX->setFlag(MachineInstr::FrameSetup);
- 
--    if (Is64Bit) {
--      // MSVC x64's __chkstk and cygwin/mingw's ___chkstk_ms do not adjust %rsp
--      // themself. It also does not clobber %rax so we can reuse it when
--      // adjusting %rsp.
--      BuildMI(MBB, MBBI, DL, TII.get(X86::SUB64rr), StackPtr)
--        .addReg(StackPtr)
--        .addReg(X86::RAX)
--        .setMIFlag(MachineInstr::FrameSetup);
--    }
-     if (isEAXAlive) {
-       // Restore EAX
-       MachineInstr *MI = addRegOffset(BuildMI(MF, DL, TII.get(X86::MOV32rm),
-diff --git a/lib/Target/X86/X86FrameLowering.h b/lib/Target/X86/X86FrameLowering.h
-index ee0ee22..dd8fc32 100644
---- a/lib/Target/X86/X86FrameLowering.h
-+++ b/lib/Target/X86/X86FrameLowering.h
-@@ -27,9 +27,11 @@ public:
-   explicit X86FrameLowering(StackDirection D, unsigned StackAl, int LAO)
-     : TargetFrameLowering(StackGrowsDown, StackAl, LAO) {}
- 
--  static void getStackProbeFunction(const X86Subtarget &STI,
--                                    unsigned &CallOp,
--                                    const char *&Symbol);
-+  /// Emit a call to the target's stack probe function. This is required for all
-+  /// large stack allocations on Windows. The caller is required to materialize
-+  /// the number of bytes to probe in RAX/EAX.
-+  static void emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB,
-+                                 MachineBasicBlock::iterator MBBI, DebugLoc DL);
- 
-   void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
-                                  MachineBasicBlock::iterator MBBI,
-diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp
-index 177299b..cd5c80d 100644
---- a/lib/Target/X86/X86ISelLowering.cpp
-+++ b/lib/Target/X86/X86ISelLowering.cpp
-@@ -15,6 +15,7 @@
- #include "X86ISelLowering.h"
- #include "Utils/X86ShuffleDecode.h"
- #include "X86CallingConv.h"
-+#include "X86FrameLowering.h"
- #include "X86InstrBuilder.h"
- #include "X86MachineFunctionInfo.h"
- #include "X86TargetMachine.h"
-@@ -21076,47 +21077,7 @@ X86TargetLowering::EmitLoweredWinAlloca(MachineInstr *MI,
- 
-   assert(!Subtarget->isTargetMachO());
- 
--  // The lowering is pretty easy: we're just emitting the call to _alloca.  The
--  // non-trivial part is impdef of ESP.
--
--  if (Subtarget->isTargetWin64()) {
--    if (Subtarget->isTargetCygMing()) {
--      // ___chkstk(Mingw64):
--      // Clobbers R10, R11, RAX and EFLAGS.
--      // Updates RSP.
--      BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
--        .addExternalSymbol("___chkstk")
--        .addReg(X86::RAX, RegState::Implicit)
--        .addReg(X86::RSP, RegState::Implicit)
--        .addReg(X86::RAX, RegState::Define | RegState::Implicit)
--        .addReg(X86::RSP, RegState::Define | RegState::Implicit)
--        .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
--    } else {
--      // __chkstk(MSVCRT): does not update stack pointer.
--      // Clobbers R10, R11 and EFLAGS.
--      BuildMI(*BB, MI, DL, TII->get(X86::W64ALLOCA))
--        .addExternalSymbol("__chkstk")
--        .addReg(X86::RAX, RegState::Implicit)
--        .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
--      // RAX has the offset to be subtracted from RSP.
--      BuildMI(*BB, MI, DL, TII->get(X86::SUB64rr), X86::RSP)
--        .addReg(X86::RSP)
--        .addReg(X86::RAX);
--    }
--  } else {
--    const char *StackProbeSymbol = (Subtarget->isTargetKnownWindowsMSVC() ||
--                                    Subtarget->isTargetWindowsItanium())
--                                       ? "_chkstk"
--                                       : "_alloca";
--
--    BuildMI(*BB, MI, DL, TII->get(X86::CALLpcrel32))
--      .addExternalSymbol(StackProbeSymbol)
--      .addReg(X86::EAX, RegState::Implicit)
--      .addReg(X86::ESP, RegState::Implicit)
--      .addReg(X86::EAX, RegState::Define | RegState::Implicit)
--      .addReg(X86::ESP, RegState::Define | RegState::Implicit)
--      .addReg(X86::EFLAGS, RegState::Define | RegState::Implicit);
--  }
-+  X86FrameLowering::emitStackProbeCall(*BB->getParent(), *BB, MI, DL);
- 
-   MI->eraseFromParent();   // The pseudo instruction is gone now.
-   return BB;
-diff --git a/lib/Target/X86/X86InstrControl.td b/lib/Target/X86/X86InstrControl.td
-index 71415c6..7baff19 100644
---- a/lib/Target/X86/X86InstrControl.td
-+++ b/lib/Target/X86/X86InstrControl.td
-@@ -279,7 +279,8 @@ let isCall = 1, Uses = [RSP], SchedRW = [WriteJump] in {
- }
- 
- let isCall = 1, isCodeGenOnly = 1 in
--  // __chkstk(MSVC):     clobber R10, R11 and EFLAGS.
-+  // __chkstk(MSVC):     clobber R10, R11 and EFLAGS
-+  // ___chkstk_ms(Mingw64): clobber R10, R11 and EFLAGS
-   // ___chkstk(Mingw64): clobber R10, R11, RAX and EFLAGS, and update RSP.
-   let Defs = [RAX, R10, R11, RSP, EFLAGS],
-       Uses = [RSP] in {
-diff --git a/test/CodeGen/X86/inalloca-stdcall.ll b/test/CodeGen/X86/inalloca-stdcall.ll
-index e5b07e2..65a0f77 100644
---- a/test/CodeGen/X86/inalloca-stdcall.ll
-+++ b/test/CodeGen/X86/inalloca-stdcall.ll
-@@ -6,6 +6,7 @@ declare x86_stdcallcc void @f(%Foo* inalloca %a)
- declare x86_stdcallcc void @i(i32 %a)
- 
- define void @g() {
-+; CHECK-LABEL: _g:
-   %b = alloca inalloca %Foo
- ; CHECK: movl    $8, %eax
- ; CHECK: calll   __chkstk
-diff --git a/test/CodeGen/X86/win64_alloca_dynalloca.ll b/test/CodeGen/X86/win64_alloca_dynalloca.ll
-index a6b6536..aab2eea 100644
---- a/test/CodeGen/X86/win64_alloca_dynalloca.ll
-+++ b/test/CodeGen/X86/win64_alloca_dynalloca.ll
-@@ -1,5 +1,6 @@
- ; RUN: llc < %s -mcpu=generic -enable-misched=false -mtriple=x86_64-mingw32     | FileCheck %s -check-prefix=M64
- ; RUN: llc < %s -mcpu=generic -enable-misched=false -mtriple=x86_64-win32       | FileCheck %s -check-prefix=W64
-+; RUN: llc < %s -mcpu=generic -enable-misched=false -mtriple=x86_64-win32 -code-model=large | FileCheck %s -check-prefix=L64
- ; RUN: llc < %s -mcpu=generic -enable-misched=false -mtriple=x86_64-win32-macho | FileCheck %s -check-prefix=EFI
- ; PR8777
- ; PR8778
-@@ -24,6 +25,13 @@ entry:
- ; W64: callq __chkstk
- ; W64: subq  %rax, %rsp
- 
-+; Use %r11 for the large model.
-+; L64: movq  %rsp, %rbp
-+; L64:       $4096, %rax
-+; L64: movabsq $__chkstk, %r11
-+; L64: callq *%r11
-+; L64: subq  %rax, %rsp
-+
- ; Freestanding
- ; EFI: movq  %rsp, %rbp
- ; EFI:       $[[B0OFS:4096|4104]], %rsp
-@@ -33,8 +41,8 @@ entry:
- 
- ; M64: leaq  15(%{{.*}}), %rax
- ; M64: andq  $-16, %rax
--; M64: callq ___chkstk
--; M64-NOT:   %rsp
-+; M64: callq ___chkstk_ms
-+; M64: subq  %rax, %rsp
- ; M64: movq  %rsp, %rax
- 
- ; W64: leaq  15(%{{.*}}), %rax
-@@ -43,6 +51,13 @@ entry:
- ; W64: subq  %rax, %rsp
- ; W64: movq  %rsp, %rax
- 
-+; L64: leaq  15(%{{.*}}), %rax
-+; L64: andq  $-16, %rax
-+; L64: movabsq $__chkstk, %r11
-+; L64: callq *%r11
-+; L64: subq  %rax, %rsp
-+; L64: movq  %rsp, %rax
-+
- ; EFI: leaq  15(%{{.*}}), [[R1:%r.*]]
- ; EFI: andq  $-16, [[R1]]
- ; EFI: movq  %rsp, [[R64:%r.*]]
-@@ -84,7 +99,8 @@ entry:
- 
- ; M64: leaq  15(%{{.*}}), %rax
- ; M64: andq  $-16, %rax
--; M64: callq ___chkstk
-+; M64: callq ___chkstk_ms
-+; M64: subq  %rax, %rsp
- ; M64: movq  %rsp, [[R2:%r.*]]
- ; M64: andq  $-128, [[R2]]
- ; M64: movq  [[R2]], %rsp
-diff --git a/test/CodeGen/X86/win_chkstk.ll b/test/CodeGen/X86/win_chkstk.ll
-index 0c02c1a..4edc89f 100644
---- a/test/CodeGen/X86/win_chkstk.ll
-+++ b/test/CodeGen/X86/win_chkstk.ll
-@@ -1,5 +1,6 @@
- ; RUN: llc < %s -mtriple=i686-pc-win32 | FileCheck %s -check-prefix=WIN_X32
- ; RUN: llc < %s -mtriple=x86_64-pc-win32 | FileCheck %s -check-prefix=WIN_X64
-+; RUN: llc < %s -mtriple=x86_64-pc-win32 -code-model=large | FileCheck %s -check-prefix=WIN64_LARGE
- ; RUN: llc < %s -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X32
- ; RUN: llc < %s -mtriple=x86_64-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X64
- ; RUN: llc < %s -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX
-@@ -16,6 +17,8 @@ define i32 @main4k() nounwind {
- entry:
- ; WIN_X32:    calll __chkstk
- ; WIN_X64:    callq __chkstk
-+; WIN64_LARGE: movabsq $__chkstk, %r11
-+; WIN64_LARGE: callq *%r11
- ; MINGW_X32:  calll __alloca
- ; MINGW_X64:  callq ___chkstk_ms
- ; LINUX-NOT:  call __chkstk
-@@ -52,6 +55,8 @@ define x86_64_win64cc i32 @main4k_win64() nounwind {
- entry:
- ; WIN_X32:    calll __chkstk
- ; WIN_X64:    callq __chkstk
-+; WIN64_LARGE: movabsq $__chkstk, %r11
-+; WIN64_LARGE: callq *%r11
- ; MINGW_X32:  calll __alloca
- ; MINGW_X64:  callq ___chkstk_ms
- ; LINUX-NOT:  call __chkstk
diff --git a/deps/zerosign-llvm-3.6.0.patch b/deps/zerosign-llvm-3.6.0.patch
deleted file mode 100644
index 9bf48082677ac..0000000000000
--- a/deps/zerosign-llvm-3.6.0.patch
+++ /dev/null
@@ -1,103 +0,0 @@
-diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp
-index 4a85780..73a1f25 100644
---- a/lib/Transforms/Scalar/GVN.cpp
-+++ b/lib/Transforms/Scalar/GVN.cpp
-@@ -2182,12 +2182,16 @@ bool GVN::propagateEquality(Value *LHS, Value *RHS,
-       // Handle the floating point versions of equality comparisons too.
-       if ((isKnownTrue && Cmp->getPredicate() == CmpInst::FCMP_OEQ) ||
-           (isKnownFalse && Cmp->getPredicate() == CmpInst::FCMP_UNE)) {
--        // Floating point -0.0 and 0.0 compare equal, so we can't
--        // propagate a constant based on that comparison.
-+
-+        // Floating point -0.0 and 0.0 compare equal, so we can only
-+        // propagate values if we know that we have a constant and that
-+        // its value is non-zero.
-+        
-         // FIXME: We should do this optimization if 'no signed zeros' is
-         // applicable via an instruction-level fast-math-flag or some other
-         // indicator that relaxed FP semantics are being used.
--        if (!isa<ConstantFP>(Op1) || !cast<ConstantFP>(Op1)->isZero())
-+
-+        if (isa<ConstantFP>(Op1) && !cast<ConstantFP>(Op1)->isZero())
-           Worklist.push_back(std::make_pair(Op0, Op1));
-       }
-  
-diff --git a/test/Transforms/GVN/edge.ll b/test/Transforms/GVN/edge.ll
-index f28a76b..0c1a3fb 100644
---- a/test/Transforms/GVN/edge.ll
-+++ b/test/Transforms/GVN/edge.ll
-@@ -59,7 +59,7 @@ bb2:
-   ret void
- }
- 
--define double @fcmp_oeq(double %x, double %y) {
-+define double @fcmp_oeq_not_zero(double %x, double %y) {
- entry:
-   %cmp = fcmp oeq double %y, 2.0
-   br i1 %cmp, label %if, label %return
-@@ -72,11 +72,11 @@ return:
-   %retval = phi double [ %div, %if ], [ %x, %entry ]
-   ret double %retval
- 
--; CHECK-LABEL: define double @fcmp_oeq(
-+; CHECK-LABEL: define double @fcmp_oeq_not_zero(
- ; CHECK: %div = fdiv double %x, 2.0
- }
- 
--define double @fcmp_une(double %x, double %y) {
-+define double @fcmp_une_not_zero(double %x, double %y) {
- entry:
-   %cmp = fcmp une double %y, 2.0
-   br i1 %cmp, label %return, label %else
-@@ -89,7 +89,7 @@ return:
-   %retval = phi double [ %div, %else ], [ %x, %entry ]
-   ret double %retval
- 
--; CHECK-LABEL: define double @fcmp_une(
-+; CHECK-LABEL: define double @fcmp_une_not_zero(
- ; CHECK: %div = fdiv double %x, 2.0
- }
- 
-@@ -129,3 +129,42 @@ return:
- ; CHECK-LABEL: define double @fcmp_une_zero(
- ; CHECK: %div = fdiv double %x, %y
- }
-+
-+; We also cannot propagate a value if it's not a constant.
-+; This is because the value could be 0.0 or -0.0.
-+
-+define double @fcmp_oeq_maybe_zero(double %x, double %y, double %z1, double %z2) {
-+entry:
-+ %z = fadd double %z1, %z2
-+ %cmp = fcmp oeq double %y, %z
-+ br i1 %cmp, label %if, label %return
-+
-+if:
-+ %div = fdiv double %x, %z
-+ br label %return
-+
-+return:
-+ %retval = phi double [ %div, %if ], [ %x, %entry ]
-+ ret double %retval
-+
-+; CHECK-LABEL: define double @fcmp_oeq_maybe_zero(
-+; CHECK: %div = fdiv double %x, %z
-+}
-+
-+define double @fcmp_une_maybe_zero(double %x, double %y, double %z1, double %z2) {
-+entry:
-+ %z = fadd double %z1, %z2
-+ %cmp = fcmp une double %y, %z
-+ br i1 %cmp, label %return, label %else
-+
-+else:
-+ %div = fdiv double %x, %z
-+ br label %return
-+
-+return:
-+ %retval = phi double [ %div, %else ], [ %x, %entry ]
-+ ret double %retval
-+
-+; CHECK-LABEL: define double @fcmp_une_maybe_zero(
-+; CHECK: %div = fdiv double %x, %z
-+}
diff --git a/doc/DocCheck.jl b/doc/DocCheck.jl
index 59be92428a7ab..ca737f5c1f55c 100644
--- a/doc/DocCheck.jl
+++ b/doc/DocCheck.jl
@@ -91,7 +91,7 @@ function _undocumented_rst()
     depdoc = havecount = total = 0
     out = AbstractString["The following exports are not documented:"]
     undoc_exports = Set()
-    exports=[strip(x) for x in split(replace(open(readall, "$JULIA_HOME/../../base/exports.jl"),",",""),"\n")]
+    exports=[strip(x) for x in split(replace(readstring("$JULIA_HOME/../../base/exports.jl"),",",""),"\n")]
     for line in exports
         if search(line, "deprecated")!=0:-1; continue end
         if haskey(MODULE_DICT, line); havecount+=1; total+=1; continue end
@@ -117,7 +117,7 @@ function _undocumented_rst()
 
     append!(out, AbstractString["", "Documented and deprecated functions/exports (please update docs)", ""])
 
-    deprecated=[strip(x) for x in split(replace(open(readall, "$JULIA_HOME/../../base/deprecated.jl"),",",""),"\n")]
+    deprecated=[strip(x) for x in split(replace(readstring("$JULIA_HOME/../../base/deprecated.jl"),",",""),"\n")]
     for line in deprecated
         if startswith(line, "@deprecated")
             fn = split(line, r" +")[2]
@@ -141,7 +141,7 @@ function gen_undocumented_template(outfile = "$JULIA_HOME/../../doc/UNDOCUMENTED
     init_help()
     println(out, ".. currentmodule:: Base")
     println(out)
-    exports=[strip(x) for x in split(replace(open(readall, "$JULIA_HOME/../../base/exports.jl"),",",""),"\n")]
+    exports=[strip(x) for x in split(replace(readstring("$JULIA_HOME/../../base/exports.jl"),",",""),"\n")]
     for line in exports
         if search(line, "deprecated")!=0:-1; continue end
         if haskey(MODULE_DICT, line); continue end
diff --git a/doc/Makefile b/doc/Makefile
index 08ba8dd25ff9a..c5091f3764c04 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -3,29 +3,35 @@
 default: html
 
 # You can set these variables from the command line.
-SPHINXOPTS       =
-PAPER            =
-JULIAHOME        = $(abspath ..)
-JULIA_EXECUTABLE = $(JULIAHOME)/usr/bin/julia
+SPHINXOPTS       :=
+PAPER            :=
+SRCDIR           := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+BUILDDIR         := .
+JULIAHOME        := $(abspath $(SRCDIR)/..)
+JULIA_EXECUTABLE := $(JULIAHOME)/usr/bin/julia
 
 # Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d _build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+PAPEROPT_a4      := -D latex_paper_size=a4
+PAPEROPT_letter  := -D latex_paper_size=letter
+ALLSPHINXOPTS    := -d $(BUILDDIR)/_build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) $(SRCDIR)
 # the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+I18NSPHINXOPTS   := $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 
-JULIA_ENV     = $(JULIAHOME)/deps/julia-env
-ACTIVATE      = $(JULIA_ENV)/bin/activate
-SPHINX_BUILD  = $(JULIA_ENV)/bin/sphinx-build
+ifeq ($(abspath .),$(abspath $(SRCDIR)))
+JULIA_ENV        := $(BUILDDIR)/../deps/build/julia-env
+else
+JULIA_ENV        := $(BUILDDIR)/../deps/julia-env
+endif
+ACTIVATE         := $(JULIA_ENV)/bin/activate
+SPHINX_BUILD     := $(JULIA_ENV)/bin/sphinx-build
 
 $(ACTIVATE):
-	$(MAKE) -C $(JULIAHOME)/deps install-virtualenv
+	$(MAKE) -C $(BUILDDIR)/../deps install-virtualenv
 	touch -c $@
 
-$(SPHINX_BUILD): $(ACTIVATE) requirements.txt
+$(SPHINX_BUILD): $(SRCDIR)/requirements.txt $(ACTIVATE)
 	. $(ACTIVATE) && pip install sphinx==1.3.1 \
-	              && pip install -r requirements.txt
+	              && pip install -r $<
 	touch -c $@
 
 SPHINXBUILD = . $(ACTIVATE) && sphinx-build
@@ -61,38 +67,38 @@ clean:
 cleanall: clean
 
 html: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) _build/html
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/_build/html
 	@echo
 	@echo "Build finished. The HTML pages are in _build/html."
 
 dirhtml: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) _build/dirhtml
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/_build/dirhtml
 	@echo
 	@echo "Build finished. The HTML pages are in _build/dirhtml."
 
 singlehtml: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) _build/singlehtml
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/_build/singlehtml
 	@echo
 	@echo "Build finished. The HTML page is in _build/singlehtml."
 
 pickle: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) _build/pickle
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/_build/pickle
 	@echo
 	@echo "Build finished; now you can process the pickle files."
 
 json: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) _build/json
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/_build/json
 	@echo
 	@echo "Build finished; now you can process the JSON files."
 
 htmlhelp: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) _build/htmlhelp
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/_build/htmlhelp
 	@echo
 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 	      ".hhp project file in _build/htmlhelp."
 
 qthelp: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) _build/qthelp
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/_build/qthelp
 	@echo
 	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
 	      ".qhcp project file in _build/qthelp, like this:"
@@ -101,7 +107,7 @@ qthelp: $(SPHINX_BUILD)
 	@echo "# assistant -collectionFile _build/qthelp/JuliaLanguage.qhc"
 
 devhelp: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) _build/devhelp
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/_build/devhelp
 	@echo
 	@echo "Build finished."
 	@echo "To view the help file:"
@@ -110,69 +116,72 @@ devhelp: $(SPHINX_BUILD)
 	@echo "# devhelp"
 
 epub: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) _build/epub
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/_build/epub
 	@echo
 	@echo "Build finished. The epub file is in _build/epub."
 
 latex: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) _build/latex
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/_build/latex
 	@echo
 	@echo "Build finished; the LaTeX files are in _build/latex."
 	@echo "Run 'make' in that directory to run these through (pdf)latex" \
 	      "(use 'make latexpdf' here to do that automatically)."
 
 latexpdf: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) _build/latex
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/_build/latex
 	@echo "Running LaTeX files through pdflatex..."
 	$(MAKE) -C _build/latex all-pdf
 	@echo "pdflatex finished; the PDF files are in _build/latex."
 
 text: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) _build/text
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/_build/text
 	@echo
 	@echo "Build finished. The text files are in _build/text."
 
 man: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) _build/man
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/_build/man
 	@echo
 	@echo "Build finished. The manual pages are in _build/man."
 
 texinfo: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) _build/texinfo
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/_build/texinfo
 	@echo
 	@echo "Build finished. The Texinfo files are in _build/texinfo."
 	@echo "Run 'make' in that directory to run these through makeinfo" \
 	      "(use 'make info' here to do that automatically)."
 
 info: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) _build/texinfo
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/_build/texinfo
 	@echo "Running Texinfo files through makeinfo..."
 	make -C _build/texinfo info
 	@echo "makeinfo finished; the Info files are in _build/texinfo."
 
 gettext: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) _build/locale
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/_build/locale
 	@echo
 	@echo "Build finished. The message catalogs are in _build/locale."
 
 changes: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) _build/changes
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/_build/changes
 	@echo
 	@echo "The overview file is in _build/changes."
 
 linkcheck: $(SPHINX_BUILD)
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) _build/linkcheck
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/_build/linkcheck
 	@echo
 	@echo "Link check complete; look for any errors in the above output " \
 	      "or in _build/linkcheck/output.txt."
 
 doctest: $(SPHINX_BUILD)
-	PATH="$(PATH):$(build_bindir)" $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) _build/doctest
+	PATH="$(build_bindir):$(PATH)" $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/_build/doctest
 	@echo "Testing of doctests in the sources finished, look at the " \
 	      "results in _build/doctest/output.txt."
 
-manual/unicode-input-table.rst: $(JULIAHOME)/base/latex_symbols.jl
-	$(JULIA_EXECUTABLE) tabcomplete.jl > manual/unicode-input-table.rst
+$(BUILDDIR)/manual:
+	mkdir -p $@
 
-unicode: manual/unicode-input-table.rst
+$(BUILDDIR)/manual/unicode-input-table.rst: $(SRCDIR)/tabcomplete.jl $(JULIAHOME)/base/latex_symbols.jl | $(BUILDDIR)/manual
+	$(JULIA_EXECUTABLE) $< > $@
+
+unicode: $(BUILDDIR)/manual/unicode-input-table.rst
 
diff --git a/doc/NEWS-update.jl b/doc/NEWS-update.jl
index f39cc295d909e..ebfda62c4de3b 100644
--- a/doc/NEWS-update.jl
+++ b/doc/NEWS-update.jl
@@ -3,7 +3,7 @@
 
 NEWS = get(ARGS, 1, "NEWS.md")
 
-s = readall(NEWS)
+s = readstring(NEWS)
 
 s = s[1:match(r"\[#[0-9]+\]:", s).offset-1];
 
diff --git a/doc/README.md b/doc/README.md
index 627feb73b262b..060e5ac1bb7e7 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -17,7 +17,7 @@ On ubuntu, you'll need the following packages installed:
     texlive-lang-cjk
     texlive-latex-extra
 
-On OS X, you can install install MacTex using the GUI installer
+On OS X, you can install MacTex using the GUI installer
 
 
 Building the documentation
diff --git a/doc/devdocs/ast.rst b/doc/devdocs/ast.rst
index 7d70c973c6f3a..b01e3b97f4f03 100644
--- a/doc/devdocs/ast.rst
+++ b/doc/devdocs/ast.rst
@@ -30,8 +30,8 @@ The following data types exist in lowered ASTs:
 ``Symbol``
     used to name local variables and static parameters within a function.
 
-``LambdaStaticData``
-    wraps the AST of each function, including inner functions.
+``LambdaInfo``
+    wraps the AST of each method.
 
 ``LineNumberNode``
     line number metadata
@@ -62,7 +62,8 @@ The following data types exist in lowered ASTs:
     (SSA) variable inserted by the compiler.
 
 ``NewvarNode``
-    marks a point where a closed variable needs to have a new box allocated.
+    Marks a point where a variable is created. This has the effect of resetting a
+    variable to undefined.
 
 
 Expr types
@@ -87,20 +88,34 @@ These symbols appear in the ``head`` field of ``Expr``\s in lowered form.
 ``method``
     adds a method to a generic function and assigns the result if necessary.
 
-    ``args[1]`` - function name (symbol), or a ``GlobalRef``, or an ``Expr``
-    with head ``kw``.  In the ``(kw f)`` case, the method is actually a keyword
-    argument sorting function for ``f``. It will be stored instead in
-    ``generic_function->env->kwsorter``.
-
-    If ``method`` has only one argument, it corresponds to the form ``function
-    foo end`` and only creates a function without adding any methods.
+    Has a 1-argument form and a 4-argument form. The 1-argument form arises
+    from the syntax ``function foo end``. In the 1-argument form, the
+    argument is a symbol. If this symbol already names a function in the
+    current scope, nothing happens. If the symbol is undefined, a new function
+    is created and assigned to the identifier specified by the symbol.
+    If the symbol is defined but names a non-function, an error is raised.
+    The definition of "names a function" is that the binding is constant, and
+    refers to an object of singleton type. The rationale for this is that an
+    instance of a singleton type uniquely identifies the type to add the method
+    to. When the type has fields, it wouldn't be clear whether the method was
+    being added to the instance or its type.
+
+    The 4-argument form has the following arguments:
+    ``args[1]`` - A function name, or ``false`` if unknown. If a symbol,
+    then the expression first behaves like the 1-argument form above.
+    This argument is ignored from then on.
+    When this is ``false``, it means a method is being added strictly by type,
+    ``(::T)(x) = x``.
 
     ``args[2]`` - a ``SimpleVector`` of argument type data. ``args[2][1]`` is
-    a ``Tuple type`` of the argument types, and ``args[2][2]`` is a
+    a ``Tuple`` type of the argument types, and ``args[2][2]`` is a
     ``SimpleVector`` of type variables corresponding to the method's static
     parameters.
 
-    ``args[3]`` - a ``LambdaStaticData`` of the method itself.
+    ``args[3]`` - a ``LambdaInfo`` of the method itself. For "out of scope"
+    method definitions (adding a method to a function that also has methods defined
+    in different scopes) this is an expression that evaluates to a ``:lambda``
+    expression.
 
     ``args[4]`` - ``true`` or ``false``, identifying whether the method is
     staged (``@generated function``)
@@ -139,12 +154,17 @@ These symbols appear in the ``head`` field of ``Expr``\s in lowered form.
 ``leave``
     pop exception handlers. ``args[1]`` is the number of handlers to pop.
 
-``boundscheck``
+``inbounds``
     controls turning bounds checks on or off. A stack is maintained; if the
     first argument of this expression is true or false (``true`` means bounds
-    checks are enabled), it is pushed onto the stack. If the first argument is
+    checks are disabled), it is pushed onto the stack. If the first argument is
     ``:pop``, the stack is popped.
 
+``boundscheck``
+    indicates the beginning or end of a section of code that performs a bounds
+    check. Like ``inbounds``, a stack is maintained, and the second argument
+    can be one of: ``true``, ``false``, or ``:pop``.
+
 ``copyast``
     part of the implementation of quasi-quote. The argument is a surface syntax
     AST that is simply copied recursively and returned at run time.
@@ -154,8 +174,12 @@ These symbols appear in the ``head`` field of ``Expr``\s in lowered form.
     ``:inline`` and ``:noinline``.
 
 
-LambdaStaticData
-~~~~~~~~~~~~~~~~
+LambdaInfo
+~~~~~~~~~~
+
+``sparam_syms`` - The names (symbols) of static parameters.
+
+``sparam_vals`` - The values of the static parameters (once known), indexed by ``sparam_syms``.
 
 Has an ``->ast`` field pointing to an ``Expr`` with head ``lambda``. This
 ``Expr`` has the following layout:
@@ -186,8 +210,6 @@ Has an ``->ast`` field pointing to an ``Expr`` with head ``lambda``. This
     ``args[2][3]`` - The types of variables represented by ``GenSym`` objects.
     Given ``GenSym`` ``g``, its type will be at ``args[2][3][g.id+1]``.
 
-    ``args[2][4]`` - The names (symbols) of static parameters.
-
 ``args[3]``
     an ``Expr`` with head ``body`` whose arguments are the statements
     comprising the function body.
@@ -300,6 +322,7 @@ x"y"                     (macrocall @x_str "y")
 x"y"z                    (macrocall @x_str "y" "z")
 "x = $x"                 (string "x = " x)
 \`a b c\`                (macrocall @cmd "a b c")
+x ~ distr                (macrocall @~ x distr)
 =======================  ====================================
 
 Doc string syntax::
diff --git a/doc/devdocs/boundscheck.rst b/doc/devdocs/boundscheck.rst
new file mode 100644
index 0000000000000..c6ab3e758da29
--- /dev/null
+++ b/doc/devdocs/boundscheck.rst
@@ -0,0 +1,61 @@
+.. _devdocs-boundscheck:
+
+.. currentmodule:: Base
+
+**************************
+Bounds checking
+**************************
+
+Like many modern programming languages, Julia uses bounds checking to ensure
+program safety when accessing arrays. In tight inner loops or other performance
+critical situations, you may wish to skip these bounds checks to improve runtime
+performance. For instance, in order to emit vectorized (SIMD) instructions, your
+loop body cannot contain branches, and thus cannot contain bounds checks.
+Consequently, Julia includes an ``@inbounds(...)`` macro to tell the compiler to
+skip such bounds checks within the given block. For the built-in ``Array`` type,
+the magic happens inside the ``arrayref`` and ``arrayset`` intrinsics.
+User-defined array types instead use the ``@boundscheck(...)`` macro to achieve
+context-sensitive code selection.
+
+Eliding bounds checks
+---------------------
+
+The ``@boundscheck(...)`` macro marks blocks of code that perform bounds
+checking. When such blocks appear inside of an ``@inbounds(...)`` block, the
+compiler removes these blocks. When the ``@boundscheck(...)`` is nested inside
+of a calling function containing an ``@inbounds(...)``, the compiler will remove
+the ``@boundscheck`` block *only if it is inlined* into the calling function.
+For example, you might write the method ``sum`` as::
+
+    function sum(A::AbstractArray)
+        r = zero(eltype(A))
+        for i = 1:length(A)
+            @inbounds r += A[i]
+        end
+        return r
+    end
+
+With a custom array-like type ``MyArray`` having::
+
+    @inline getindex(A::MyArray, i::Real) = (@boundscheck checkbounds(A,i); A.data[to_index(i)])
+
+Then when ``getindex`` is inlined into ``sum``, the call to ``checkbounds(A,i)``
+will be elided. If your function contains multiple layers of inlining, only
+``@boundscheck`` blocks at most one level of inlining deeper are eliminated. The
+rule prevents unintended changes in program behavior from code further up the
+stack.
+
+
+Propagating inbounds
+--------------------
+
+There may be certain scenarios where for code-organization reasons you want more
+than one layer between the ``@inbounds`` and ``@boundscheck`` declarations. For
+instance, the default ``getindex`` methods have the chain
+``getindex(A::AbstractArray, i::Real)`` calls
+``getindex(linearindexing(A), A, i)`` calls
+``_getindex(::LinearFast, A, i)``.
+
+To override the "one layer of inlining" rule, a function may be marked with
+``@propagate_inbounds`` to propagate an inbounds context (or out of bounds
+context) through one additional layer of inlining.
diff --git a/doc/devdocs/callconv.rst b/doc/devdocs/callconv.rst
new file mode 100644
index 0000000000000..1019cad5431f3
--- /dev/null
+++ b/doc/devdocs/callconv.rst
@@ -0,0 +1,60 @@
+.. _devdocs-callconv:
+
+*******************
+Calling Conventions
+*******************
+
+.. currentmodule:: Base
+
+Julia uses three calling conventions for four distinct purposes:
+
++-------+--------------+----------------------------------+
+|Name   |Prefix        |Purpose                           |
++=======+==============+==================================+
+|Native |``julia_``    | Speed via specialized signatures |
++-------+--------------+----------------------------------+
+|JL Call|``jlcall_``   | Wrapper for generic calls        |
++       +--------------+----------------------------------+
+|       |``jl_``       | Builtins                         |
++-------+--------------+----------------------------------+
+|C ABI  |``jlcapi_``   | Wrapper callable from C          |
++-------+--------------+----------------------------------+
+
+Julia Native Calling Convention
+-------------------------------
+
+The native calling convention is designed for fast non-generic calls.
+It usually uses a specialized signature.
+
+* LLVM ghosts (zero-length types) are omitted.
+* LLVM scalars and vectors are passed by value.
+* LLVM aggregates (arrays and structs) are passed by reference.
+
+A small return values is returned as LLVM return values.
+A large return values is returned via the "structure return" (``sret``)
+convention, where the caller provides a pointer to a return slot.
+
+An argument or return values thta is a homogeneous tuple is
+sometimes represented as an LLVM vector instead of an LLVM array.
+
+JL Call Convention
+------------------
+
+The JL Call convention is for builtins and generic dispatch.
+Hand-written functions using this convention are declared via the macro ``JL_CALLABLE``.
+The convention uses exactly 3 parameters:
+
+* ``F``  - Julia representation of function that is being applied
+* ``args`` - pointer to array of pointers to boxes
+* ``nargs`` - length of the array
+
+The return value is a pointer to a box.
+
+C ABI
+-----
+
+C ABI wrappers enable calling Julia from C.
+The wrapper calls a function using the native calling convention.
+
+Tuples are always represented as C arrays.
+
diff --git a/doc/devdocs/cartesian.rst b/doc/devdocs/cartesian.rst
index bff3e4ea8569d..3b43d0cf832ee 100644
--- a/doc/devdocs/cartesian.rst
+++ b/doc/devdocs/cartesian.rst
@@ -144,7 +144,7 @@ Macro reference
 
    Generate ``N`` nested loops, using ``itersym`` as the prefix for the iteration variables. ``rangeexpr`` may be an anonymous-function expression, or a simple symbol ``var`` in which case the range is ``1:size(var,d)`` for dimension ``d``\ .
 
-   Optionally, you can provide "pre" and "post" expressions. These get executed first and last, respectively, in the body of each loop. For example, :
+   Optionally, you can provide "pre" and "post" expressions. These get executed first and last, respectively, in the body of each loop. For example:
 
    .. code-block:: julia
 
@@ -152,7 +152,7 @@ Macro reference
            s += @nref 2 A j
        end
 
-   would generate :
+   would generate:
 
    .. code-block:: julia
 
@@ -164,7 +164,7 @@ Macro reference
            end
        end
 
-   If you want just a post-expression, supply ``nothing`` for the pre-expression. Using parenthesis and semicolons, you can supply multi-statement expressions.
+   If you want just a post-expression, supply ``nothing`` for the pre-expression. Using parentheses and semicolons, you can supply multi-statement expressions.
 
 .. function:: @nref N A indexexpr
 
@@ -172,12 +172,51 @@ Macro reference
 
    Generate expressions like ``A[i_1,i_2,...]``\ . ``indexexpr`` can either be an iteration-symbol prefix, or an anonymous-function expression.
 
+.. function:: @nextract N esym isym
+
+   .. Docstring generated from Julia source
+
+   Generate ``N`` variables ``esym_1``\ , ``esym_2``\ , ..., ``esym_N`` to extract values from ``isym``\ . ``isym`` can be either a ``Symbol`` or anonymous-function expression.
+
+   ``@nextract 2 x y`` would generate
+
+   .. code-block:: julia
+
+       x_1 = y[1]
+       x_2 = y[2]
+
+   while ``@nextract 3 x d->y[2d-1]`` yields
+
+   .. code-block:: julia
+
+       x_1 = y[1]
+       x_2 = y[3]
+       x_3 = y[5]
+
 .. function:: @nexprs N expr
 
    .. Docstring generated from Julia source
 
    Generate ``N`` expressions. ``expr`` should be an anonymous-function expression.
 
+.. function:: @ncall N f sym...
+
+   .. Docstring generated from Julia source
+
+   Generate a function call expression. ``sym`` represents any number of function arguments, the last of which may be an anonymous-function expression and is expanded into ``N`` arguments.
+
+   For example ``@ncall 3 func a`` generates
+
+   .. code-block:: julia
+
+       func(a_1, a_2, a_3)
+
+   while ``@ncall 2 func a b i->c[i]`` yields
+
+   .. code-block:: julia
+
+       func(a, b, c[1], c[2])
+
 .. function:: @ntuple N expr
 
    .. Docstring generated from Julia source
@@ -188,8 +227,18 @@ Macro reference
 
    .. Docstring generated from Julia source
 
+   Check whether all of the expressions generated by the anonymous-function expression ``expr`` evaluate to ``true``\ .
+
    ``@nall 3 d->(i_d > 1)`` would generate the expression ``(i_1 > 1 && i_2 > 1 && i_3 > 1)``\ . This can be convenient for bounds-checking.
 
+.. function:: @nany N expr
+
+   .. Docstring generated from Julia source
+
+   Check whether any of the expressions generated by the anonymous-function expression ``expr`` evaluate to ``true``\ .
+
+   ``@nany 3 d->(i_d > 1)`` would generate the expression ``(i_1 > 1 || i_2 > 1 || i_3 > 1)``\ .
+
 .. function:: @nif N conditionexpr expr
               @nif N conditionexpr expr elseexpr
 
diff --git a/doc/devdocs/debuggingtips.rst b/doc/devdocs/debuggingtips.rst
index 70242120e7e4e..5ebb31b9cbe89 100644
--- a/doc/devdocs/debuggingtips.rst
+++ b/doc/devdocs/debuggingtips.rst
@@ -24,8 +24,8 @@ Similarly, if you're debugging some of julia's internals (e.g.,
 
 This is a good way to circumvent problems that arise from the order in which julia's output streams are initialized.
 
-Julia's flisp interpreter uses ``value_t*`` objects; these can be displayed
-with ``call fl_print(ios_stdout, obj)``.
+Julia's flisp interpreter uses ``value_t`` objects; these can be displayed
+with ``call fl_print(fl_ctx, ios_stdout, obj)``.
 
 Useful Julia variables for Inspecting
 -------------------------------------
@@ -43,7 +43,7 @@ there are a number of additional variables (see julia.h for a complete list) tha
 Useful Julia functions for Inspecting those variables
 -----------------------------------------------------
 
-- ``gdblookup($rip)`` :: For looking up the current function and line. (use ``$eip`` on i686 platforms)
+- ``jl_gdblookup($rip)`` :: For looking up the current function and line. (use ``$eip`` on i686 platforms)
 - ``jlbacktrace()`` :: For dumping the current julia backtrace stack to stderr. Only usable after ``record_backtrace()`` has been called.
 - ``jl_dump_llvm_value(Value*)`` :: For invoking ``Value->dump()`` in gdb, where it doesn't work natively. For example, ``f->linfo->functionObject``, ``f->linfo->specFunctionObject``, and ``to_function(f->linfo)``.
 - ``Type->dump()`` :: only works in lldb. Note: add something like ``;1`` to prevent lldb from printing its prompt over the output
@@ -74,7 +74,7 @@ Another useful frame is ``to_function(jl_lambda_info_t *li, bool cstyle)``. The
 
    #2  0x00007ffff7928bf7 in to_function (li=0x2812060, cstyle=false) at codegen.cpp:584
    584	        abort();
-   (gdb) p jl_(jl_uncompress_ast(li, li.ast))
+   (gdb) p jl_(jl_uncompress_ast(li, li->ast))
 
 Inserting breakpoints upon certain conditions
 ---------------------------------------------
@@ -91,10 +91,31 @@ Calling a particular method
 
 ::
 
-   (gdb) break jl_apply_generic if strcmp(F->name->name, "method_to_break")==0
+   (gdb) break jl_apply_generic if strcmp((char*)(jl_symbol_name)(jl_gf_mtable(F)->name), "method_to_break")==0
 
 Since this function is used for every call, you will make everything 1000x slower if you do this.
 
+Dealing with signals
+--------------------
+
+Julia requires a few signal to function property. The profiler uses ``SIGUSR2``
+for sampling and the garbage collector uses ``SIGSEGV`` for threads
+synchronization. If you are debugging some code that uses the profiler or
+multiple julia threads, you may want to let the debugger ignore these signals
+since they can be triggered very often during normal operations. The command to
+do this in GDB is (replace ``SIGSEGV`` with ``SIGUSRS`` or other signals you
+want to ignore)::
+
+   (gdb) handle SIGSEGV noprint nostop pass
+
+The corresponding LLDB command is (after the process is started)::
+
+   (lldb) pro hand -p true -s false -n false SIGSEGV
+
+If you are debugging a segfault with threaded code, you can set a breakpoint on
+``jl_critical_error`` (``sigdie_handler`` should also work on Linux and BSD) in
+order to only catch the actual segfault rather than the GC synchronization points.
+
 Debugging during julia's build process (bootstrap)
 --------------------------------------------------
 
@@ -166,8 +187,27 @@ codegen::
     ... # your breakpoint here
 
 
+Debugging precompilation errors
+-------------------------------
+
+Module precompilation spawns a separate Julia process to precompile each module. Setting a breakpoint
+or catching failures in a precompile worker requires attaching a debugger to the worker. The easiest
+approach is to set the debugger watch for new process launches matching a given name. For example::
+
+    (gdb) attach -w -n julia-debug
+
+or::
+
+    (lldb) process attach -w -n julia-debug
+
+Then run a script/command to start precompilation. As described earlier, use conditional breakpoints
+in the parent process to catch specific file-loading events and narrow the debugging window.
+(some operating systems may require alternative approaches, such as following each ``fork`` from the
+parent process)
+
+
 Mozilla's Record and Replay Framework (rr)
----------------------------------------------
+------------------------------------------
 
 Julia now works out of the box with `rr, <http://rr-project.org/>`_ the lightweight recording and
 deterministic debugging framework from Mozilla. This allows you to replay the trace of an execution
diff --git a/doc/devdocs/eval.rst b/doc/devdocs/eval.rst
index e4418453727f3..9d944838c0d28 100644
--- a/doc/devdocs/eval.rst
+++ b/doc/devdocs/eval.rst
@@ -8,15 +8,10 @@ One of the hardest parts about learning how the Julia Language runs code is lear
 how all of the pieces work together to execute a block of code.
 
 Each chunk of code typically makes a trip through many esoteric acronyms such as (in no particular order),
-`flisp`, `AST`, `C++`, `LLVM`, `eval`, `typeinf`, `macroexpand`, `sysimg` (or `system image`), `bootstrapping`,
-`compile`, `parse`, `execute`, `JIT`, `interpret`, `box`, `unbox`, `intrinsic function`, `primitive function`
+``flisp``, ``AST``, ``C++``, ``LLVM``, ``eval``, ``typeinf``, ``macroexpand``, ``sysimg`` (or ``system image``), ``bootstrapping``,
+``compile``, ``parse``, ``execute``, ``JIT``, ``interpret``, ``box``, ``unbox``, ``intrinsic function``, ``primitive function``
 before turning into the desired result (hopefully).
 
-Julia Execution
----------------
-
-The 10,000 foot view of the whole process is as follows:
-
 .. sidebar:: Definitions
 
    REPL
@@ -29,30 +24,36 @@ The 10,000 foot view of the whole process is as follows:
      In this form the code has been tokenized for meaning
      so that it is more suitable for manipulation and execution.
 
-1. The user starts `julia`.
-2. The C function :c:func:`main` from `ui/repl.c` gets called.
+
+Julia Execution
+---------------
+
+The 10,000 foot view of the whole process is as follows:
+
+1. The user starts ``julia``.
+2. The C function :c:func:`main` from ``ui/repl.c`` gets called.
    This function processes the command line arguments, filling in the :c:type:`jl_options` struct and setting the variable :code:`ARGS`.
    It then initializes Julia (by calling `julia_init in task.c <https://github.com/JuliaLang/julia/blob/master/src/task.c>`_,
    which may load a previously compiled sysimg_).
    Finally, it passes off control to Julia by calling `Base._start() <https://github.com/JuliaLang/julia/blob/master/base/client.jl>`_.
-#. When `_start()` takes over control, the subsequent sequence of commands depends on the command line arguments given.
+#. When ``_start()`` takes over control, the subsequent sequence of commands depends on the command line arguments given.
    For example, if a filename was supplied, it will proceed to execute that file. Otherwise, it will start an interactive REPL.
 #. Skipping the details about how the REPL interacts with the user,
    let's just say the program ends up with a block of code that it wants to run.
 #. If the block of code to run is in a file, `jl_load(char *filename) <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_
-   gets invoked to load the file and parse_ it. Each fragment of code is then passed to `eval` to execute.
+   gets invoked to load the file and parse_ it. Each fragment of code is then passed to ``eval`` to execute.
 #. Each fragment of code (or AST), is handed off to :func:`eval` to turn into results.
 #. :func:`eval` takes each code fragment and tries to run it in `jl_toplevel_eval_flex() <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_.
-#. :c:func:`jl_toplevel_eval_flex` decides whether the code is a "toplevel" action (such as `using` or `module`), which would be invalid inside a function.
+#. :c:func:`jl_toplevel_eval_flex` decides whether the code is a "toplevel" action (such as ``using`` or ``module``), which would be invalid inside a function.
    If so, it passes off the code to the toplevel interpreter.
 #. :c:func:`jl_toplevel_eval_flex` then expands_ the code to eliminate any macros and to "lower" the AST to make it simpler to execute.
 #. :c:func:`jl_toplevel_eval_flex` then uses some simple heuristics to decide whether to JIT compiler the AST or to interpret it directly.
 #. The bulk of the work to interpret code is handled by `eval in interpreter.c <https://github.com/JuliaLang/julia/blob/master/src/interpreter.c>`_.
-#. If instead, the code is compiled, the bulk of the work is handled by `codegen.cpp`.
+#. If instead, the code is compiled, the bulk of the work is handled by ``codegen.cpp``.
    Whenever a Julia function is called for the first time with a given set of argument types, `type inference`_ will be run on that function.
    This information is used by the codegen_ step to generate faster code.
 #. Eventually, the user quits the REPL, or the end of the program is reached, and the :func:`_start` method returns.
-#. Just before exiting, :c:func:`main` calls `jl_atexit_hook() <https://github.com/JuliaLang/julia/blob/master/src/init.c>`_.
+#. Just before exiting, :c:func:`main` calls `jl_atexit_hook(exit_code) <https://github.com/JuliaLang/julia/blob/master/src/init.c>`_.
    This calls :func:`Base._atexit` (which calls any functions registered to :func:`atexit` inside Julia).
    Then it calls `jl_gc_run_all_finalizers() <https://github.com/JuliaLang/julia/blob/master/src/gc.c>`_.
    Finally, it gracefully cleans up all ``libuv`` handles and waits for them to flush and close.
@@ -79,8 +80,8 @@ Macro Expansion
 ---------------
 
 When :func:`eval` encounters a macro, it expands that AST node before attempting to evaluate the expression.
-Macro expansion involves a handoff from :func:`eval` (in Julia), to the parser function :c:func:`jl_macroexpand` (written in `flisp`)
-to the Julia macro itself (written in - what else - `Julia`) via :c:func:`fl_invoke_julia_macro`, and back.
+Macro expansion involves a handoff from :func:`eval` (in Julia), to the parser function :c:func:`jl_macroexpand` (written in ``flisp``)
+to the Julia macro itself (written in - what else - Julia) via :c:func:`fl_invoke_julia_macro`, and back.
 
 Typically, macro expansion is invoked as a first step during a call to :func:`expand`/:c:func:`jl_expand`,
 although it can also be invoked directly by a call to :func:`macroexpand`/:c:func:`jl_macroexpand`.
@@ -97,11 +98,6 @@ This enables many future optimizations, such as unboxing of known immutable valu
 and compile-time hoisting of various run-time operations such as computing field offsets and function pointers.
 Type inference may also include other steps such as constant propagation and inlining.
 
-.. _codegen:
-
-JIT Code Generation
--------------------
-
 .. sidebar:: More Definitions
 
     JIT
@@ -143,7 +139,12 @@ JIT Code Generation
       These pseudo-functions implement operations on raw bits such as add and sign extend
       that cannot be expressed directly in any other way.
       Since they operate on bits directly, they must be compiled into a function
-      and surrounded by a call to `Core.Intrinsics.box(T, ...)` to reassign type information to the value.
+      and surrounded by a call to ``Core.Intrinsics.box(T, ...)`` to reassign type information to the value.
+
+.. _codegen:
+
+JIT Code Generation
+-------------------
 
 Codegen is the process of turning a Julia AST into native machine code.
 
@@ -163,16 +164,11 @@ Other parts of codegen are handled by various helper files:
   Handles backtraces for JIT functions
 
 `ccall.cpp <https://github.com/JuliaLang/julia/blob/master/src/ccall.cpp>`_
-  Handles the ccall and llvmcall FFI, along with various `abi_*.cpp` files
+  Handles the ccall and llvmcall FFI, along with various ``abi_*.cpp`` files
 
 `intrinsics.cpp <https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp>`_
   Handles the emission of various low-level intrinsic functions
 
-.. _sysimg:
-
-System Image
-------------
-
 .. sidebar:: Bootstrapping
 
     The process of creating a new system image is called "bootstrapping".
@@ -181,15 +177,20 @@ System Image
     and refers to the idea of starting from a very limited set of available functions and definitions
     and ending with the creation of a full-featured environment.
 
+.. _sysimg:
+
+System Image
+------------
+
 The system image is a precompiled archive of a set of Julia files.
-The `sys.ji` file distributed with Julia is one such system image,
+The ``sys.ji`` file distributed with Julia is one such system image,
 generated by executing the file `sysimg.jl <https://github.com/JuliaLang/julia/blob/master/base/sysimg.jl>`_,
 and serializing the resulting environment (including Types, Functions, Modules, and all other defined values)
 into a file. Therefore, it contains a frozen version of the :mod:`Main`, :mod:`Core`, and :mod:`Base` modules (and whatever else was in the environment at the end of bootstrapping).
 This serializer/deserializer is implemented by `jl_save_system_image/jl_restore_system_image in dump.c <https://github.com/JuliaLang/julia/blob/master/src/dump.c>`_.
 
 If there is no sysimg file (:code:`jl_options.image_file == NULL`),
-this also implies that `--build` was given on the command line,
+this also implies that ``--build`` was given on the command line,
 so the final result should be a new sysimg file.
 During Julia initialization, minimal :mod:`Core` and :mod:`Main` modules are created.
 Then a file named ``boot.jl`` is evaluated from the current directory.
diff --git a/doc/devdocs/functions.rst b/doc/devdocs/functions.rst
new file mode 100644
index 0000000000000..326202c798277
--- /dev/null
+++ b/doc/devdocs/functions.rst
@@ -0,0 +1,344 @@
+.. _devdocs-functions:
+
+*******************
+Julia Functions
+*******************
+
+.. currentmodule:: Base
+
+This document will explain how functions, method definitions, and method tables work.
+
+Method Tables
+-------------
+
+Every function in Julia is a generic function. A generic function is conceptually a single
+function, but consists of many definitions, or methods. The methods of a generic
+function are stored in a method table.
+Method tables (type ``MethodTable``) are associated with ``TypeName``\s. A ``TypeName``
+describes a family of parameterized types. For example ``Complex{Float32}`` and
+``Complex{Float64}`` share the same ``Complex`` type name object.
+
+All objects in Julia are potentially callable, because every object has a type, which
+in turn has a ``TypeName``.
+
+
+Function calls
+--------------
+
+Given the call ``f(x,y)``, the following steps are performed: first, the method table
+to use is accessed as ``typeof(f).name.mt``. Second, an argument tuple type is formed,
+``Tuple{typeof(f), typeof(x), typeof(y)}``. Note that the type of the function itself
+is the first element. This is because the type might have parameters, and so needs to
+take part in dispatch. This tuple type is looked up in the method table.
+
+This dispatch process is performed by ``jl_apply_generic``, which takes two arguments:
+a pointer to an array of the values f, x, and y, and the number of values (in this
+case 3).
+
+Throughout the system, there are two kinds of APIs that handle functions and argument
+lists: those that accept the function and arguments separately, and those that accept
+a single argument structure. In the first kind of API, the "arguments" part does *not*
+contain information about the function, since that is passed separately. In the
+second kind of API, the function is the first element of the argument structure.
+
+For example, the following function for performing a call accepts just an ``args`` pointer,
+so the first element of the args array will be the function to call::
+
+    jl_value_t *jl_apply(jl_value_t **args, uint32_t nargs)
+
+This entry point for the same functionality accepts the function separately, so the
+``args`` array does not contain the function::
+
+    jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs);
+
+
+Adding methods
+--------------
+
+Given the above dispatch process, conceptually all that is needed to add a new
+method is (1) a tuple type, and (2) code for the body of the method.
+``jl_method_def`` implements this operation.
+``jl_first_argument_datatype`` is called to extract the relevant method table
+from what would be the type of the first argument. This is much more complicated
+than the corresponding procedure during dispatch, since the argument tuple
+type might be abstract. For example, we can define::
+
+    (::Union{Foo{Int},Foo{Int8}})(x) = 0
+
+which works since all possible matching methods would belong to the same method
+table.
+
+
+Creating generic functions
+--------------------------
+
+Since every object is callable, nothing special is needed to create a generic
+function. Therefore ``jl_new_generic_function`` simply creates a new singleton
+(0 size) subtype of ``Function`` and returns its instance.
+A function can have a mnemonic "display name" which is used in debug info and
+when printing objects. For example the name of ``Base.sin`` is ``sin``. By
+convention, the name of the created *type* is the same as the function name,
+with a ``#`` prepended. So ``typeof(sin)`` is ``Base.#sin``.
+
+
+Closures
+--------
+
+A closure is simply a callable object with field names corresponding to
+captured variables. For example, the following code::
+
+    function adder(x)
+        return y->x+y
+    end
+
+is lowered to (roughly)::
+
+    immutable ##1{T}
+        x::T
+    end
+
+    (_::##1)(y) = _.x + y
+
+    function adder(x)
+        return ##1(x)
+    end
+
+
+Constructors
+------------
+
+A constructor call is just a call to a type. The type of most types is ``DataType``,
+so the method table for ``DataType`` contains most constructor definitions.
+One wrinkle is the fallback definition that makes all types callable via ``convert``::
+
+    (::Type{T}){T}(args...) = convert(T, args...)::T
+
+In this definition the function type is abstract, which is not normally supported.
+To make this work, all subtypes of ``Type`` (``Type``, ``TypeConstructor``, ``Union``, and
+``DataType``) currently share a method table via special arrangement.
+
+
+Builtins
+--------
+
+The "builtin" functions, defined in the ``Core`` module, are::
+
+    is typeof sizeof issubtype isa typeassert throw tuple getfield setfield! fieldtype
+    nfields isdefined arrayref arrayset arraysize applicable invoke apply_type _apply
+    _expr svec
+
+These are all singleton objects whose types are subtypes of ``Builtin``, which is
+a subtype of ``Function``. Their purpose is to expose entry points in the run time
+that use the "jlcall" calling convention::
+
+    jl_value_t *(jl_value_t*, jl_value_t**, uint32_t)
+
+The method tables of builtins are empty. Instead, they have a single catch-all method
+cache entry (``Tuple{Vararg{Any}}``) whose jlcall fptr points to the correct function.
+This is kind of a hack but works reasonably well.
+
+
+Keyword arguments
+-----------------
+
+Keyword arguments work by associating a special, hidden function object with each
+method table that has definitions with keyword arguments.
+This function is called the "keyword argument sorter" or "keyword sorter", or
+"kwsorter", and is stored in the ``kwsorter`` field of ``MethodTable`` objects.
+Every definition in the kwsorter function has the same arguments as some definition
+in the normal method table, except with a single ``Array`` argument prepended.
+This array contains alternating symbols and values that represent the passed
+keyword arguments.
+The kwsorter's job is to move keyword arguments into their canonical positions based
+on name, plus evaluate and substite any needed default value expressions.
+The result is a normal positional argument list, which is then passed to yet another
+function.
+
+The easiest way to understand the process is to look at how a keyword argument
+method definition is lowered.
+The code::
+
+    function circle(center, radius; color = black, fill::Bool = true, options...)
+        # draw
+    end
+
+actually produces *three* method definitions.
+The first is a function that accepts all arguments (including keywords) as
+positional arguments, and includes the code for the method body.
+It has an auto-generated name::
+
+    function #circle#1(color, fill::Bool, options, circle, center, radius)
+        # draw
+    end
+
+The second method is an ordinary definition for the original ``circle`` function,
+which handles the case where no keyword arguments are passed::
+
+    function circle(center, radius)
+        #circle#1(black, true, Any[], circle, center, radius)
+    end
+
+This simply dispatches to the first method, passing along default values.
+Finally there is the kwsorter definition::
+
+    function (::Core.kwftype(typeof(circle)))(kw::Array, circle, center, radius)
+        options = Any[]
+        color = arg associated with :color, or black if not found
+        fill = arg associated with :fill, or true if not found
+        # push remaining elements of kw into options array
+        #circle#1(color, fill, options, circle, center, radius)
+    end
+
+The front end generates code to loop over the ``kw`` array and pick out
+arguments in the right order, evaluating default expressions when
+an argument is not found.
+
+The function ``Core.kwftype(t)`` fetches (and creates, if necessary) the
+field ``t.name.mt.kwsorter``.
+
+This design has the feature that call sites that don't use keyword arguments
+require no special handling; everything works as if they were not part of
+the language at all.
+Call sites that do use keyword arguments are dispatched directly to the
+called function's kwsorter.
+For example the call::
+
+    circle((0,0), 1.0, color = red; other...)
+
+is lowered to::
+
+    kwfunc(circle)(Any[:color,red,other...], circle, (0,0), 1.0)
+
+The unpacking procedure represented here as ``other...`` actually
+further unpacks each *element* of ``other``, expecting each one to
+contain two values (a symbol and a value).
+``kwfunc`` (also in ``Core``) fetches the kwsorter for the called function.
+Notice that the original ``circle`` function is passed through, to
+handle closures.
+
+
+Compiler efficiency issues
+--------------------------
+
+Generating a new type for every function has potentially serious consequences for
+compiler resource use when combined with Julia's "specialize on all arguments by
+default" design.
+Indeed, the initial implementation of this design suffered from much longer build
+and test times, higher memory use, and a system image nearly 2x larger than the
+baseline.
+In a naive implementation, the problem is bad enough to make the system nearly
+unusable.
+Several significant optimizations were needed to make the design practical.
+
+The first issue is excessive specialization of functions for different
+values of function-valued arguments.
+Many functions simply "pass through" an argument to somewhere else, e.g.
+to another function or to a storage location.
+Such functions do not need to be specialized for every closure that might be
+passed in.
+Fortunately this case is easy to distinguish by simply considering whether
+a function *calls* one of its arguments (i.e. the argument appears in "head
+position" somewhere).
+Performance-critical higher-order functions like ``map`` certainly call
+their argument function and so will still be specialized as expected.
+This optimization is implemented by recording which arguments are called
+during the ``analyze-variables`` pass in the front end.
+When ``cache_method`` sees an argument in the ``Function`` type hierarchy
+passed to a slot declared as ``Any`` or ``Function``, it pretends the slot
+was declared as ``ANY`` (the "don't specialize" hint).
+This heuristic seems to be extremely effective in practice.
+
+The next issue concerns the structure of method cache hash tables.
+Empirical studies show that the vast majority of dynamically-dispatched calls
+involve one or two arguments.
+In turn, many of these cases can be resolved by considering only the first
+argument.
+(Aside: proponents of single dispatch would not be surprised by this at all.
+However, this argument means "multiple dispatch is easy to optimize in practice",
+and that we should therefore use it, *not* "we should use single dispatch"!)
+So the method cache uses the type of the first argument as its primary key.
+Note, however, that this corresponds to the *second* element of the tuple type
+for a function call (the first element being the type of the function itself).
+Typically, type variation in head position is extremely low --- indeed, the
+majority of functions belong to singleton types with no parameters.
+However, this is not the case for constructors, where a single method table holds
+constructors for every type.
+Therefore the ``Type`` method table is special-cased to use the *first* tuple type
+element instead of the second.
+
+The front end generates type declarations for all closures.
+Initially, this was implemented by generating normal type declarations.
+However, this produced an extremely large number of constructors, all of which
+were trivial (simply passing all arguments through to ``new``).
+Since methods are partially ordered, inserting all of these methods is O(n^2),
+plus there are just too many of them to keep around.
+This was optimized by generating ``composite_type`` expressions directly
+(bypassing default constructor generation), and using ``new`` directly to create
+closure instances.
+Not the prettiest thing ever, but you do what you gotta do.
+
+The next problem was the ``@test`` macro, which generated a 0-argument closure
+for each test case.
+This is not really necessary, since each test case is simply run once in place.
+Therefore I modified ``@test`` to expand to a try-catch block that records the
+test result (true, false, or exception raised) and calls the test suite handler
+on it.
+
+However this caused a new problem.
+When many tests are grouped together in a single function, e.g. a single top
+level expression, or some other test grouping function, that function could
+have a very large number of exception handlers.
+This triggered a kind of dataflow analysis worst case, where type inference
+spun around for minutes enumerating possible paths through the forest of
+handlers.
+This was fixed by simply bailing out of type inference when it encounters
+more than some number of handlers (currently 25).
+Presumably no performance-critical function will have more than 25 exception
+handlers.
+If one ever does, I'm willing to raise the limit to 26.
+
+A minor issue occurs during the bootstrap process due to storing all constructors
+in a single method table.
+In the second bootstrap step, where inference.ji is compiled using inference0.ji,
+constructors for inference0's types remain in the table, so there are still
+references to the old inference module and inference.ji is 2x the size it should be.
+This was fixed in dump.c by filtering definitions from "replaced modules" out of
+method tables and caches before saving a system image.
+A "replaced module" is one that satisfies the condition
+``m != jl_get_global(m->parent, m->name)`` --- in other words, some newer module
+has taken its name and place.
+
+Another type inference worst case was triggered by the following code from
+quadgk.jl::
+
+    function do_quadgk{Tw}(f, s, n, ::Type{Tw}, abstol, reltol, maxevals, nrm)
+        if eltype(s) <: Real # check for infinite or semi-infinite intervals
+            s1 = s[1]; s2 = s[end]; inf1 = isinf(s1); inf2 = isinf(s2)
+            if inf1 || inf2
+                if inf1 && inf2 # x = t/(1-t^2) coordinate transformation
+                    return do_quadgk(t -> begin t2 = t*t; den = 1 / (1 - t2);
+                                                f(t*den) * (1+t2)*den*den; end,
+                                     map(x -> isinf(x) ? copysign(one(x), x) : 2x / (1+hypot(1,2x)), s),
+                                     n, Tw, abstol, reltol, maxevals, nrm)
+                end
+                s0,si = inf1 ? (s2,s1) : (s1,s2)
+                if si < 0 # x = s0 - t/(1-t)
+                    return do_quadgk(t -> begin den = 1 / (1 - t);
+                                                f(s0 - t*den) * den*den; end,
+                                     reverse!(map(x -> 1 / (1 + 1 / (s0 - x)), s)),
+                                     n, Tw, abstol, reltol, maxevals, nrm)
+                else # x = s0 + t/(1-t)
+                    return do_quadgk(t -> begin den = 1 / (1 - t);
+                                                f(s0 + t*den) * den*den; end,
+                                     map(x -> 1 / (1 + 1 / (x - s0)), s),
+                                     n, Tw, abstol, reltol, maxevals, nrm)
+                end
+            end
+        end
+
+This code has a 3-way tail recursion, where each call wraps the current function
+argument ``f`` in a different new closure.
+Inference must consider 3^n (where n is the call depth) possible signatures.
+This blows up way too quickly, so logic was added to typeinf_uncached to
+immediately widen any argument that is a subtype of ``Function`` and that grows
+in depth down the stack.
diff --git a/doc/devdocs/init.rst b/doc/devdocs/init.rst
index 8bc4cd0f487c0..548e3b10aa2b1 100644
--- a/doc/devdocs/init.rst
+++ b/doc/devdocs/init.rst
@@ -92,15 +92,6 @@ initialises 8-bit serialisation tags for 256 frequently used
 ``jl_value_t`` values. The serialisation mechanism uses these tags as
 shorthand (in lieu of storing whole objects) to save storage space.
 
-.. sidebar:: sysimg
-
-    If there is a sysimg file, it contains a pre-cooked image of the :mod:`Core` and :mod:`Main` modules (and whatever else is created by ``boot.jl``). See :ref:`dev-sysimg`.
-
-    `jl_restore_system_image() <https://github.com/JuliaLang/julia/blob/master/src/dump.c>`_ de-serialises the saved sysimg into the current Julia runtime environment and initialisation continues after :c:func:`jl_init_box_caches` below...
-
-    Note: `jl_restore_system_image() (and dump.c in general) <https://github.com/JuliaLang/julia/blob/master/src/dump.c>`_ uses the :ref:`dev-ios`.
-
-
 If there is no sysimg file (:code:`!jl_options.image_file`) then
 then :mod:`Core` and :mod:`Main` modules are created and ``boot.jl`` is evaluated:
 
@@ -135,7 +126,7 @@ creates the global "Main" module and sets
 
 Note: _julia_init() `then sets <https://github.com/JuliaLang/julia/blob/master/src/init.c>`_ :code:`jl_root_task->current_module = jl_core_module`. :code:`jl_root_task` is an alias of :code:`jl_current_task` at this point, so the current_module set by :c:func:`jl_new_main_module` above is overwritten.
 
-`jl_load("boot.jl", sizeof("boot.jl")) <https://github.com/JuliaLang/julia/blob/master/src/init.c>`_ calls `jl_parse_eval_all("boot.jl") <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ which repeatedly calls `jl_parse_next() <https://github.com/JuliaLang/julia/blob/master/src/ast.c>`_ and `jl_toplevel_eval_flex() <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ to parse and execute `boot.jl <https://github.com/JuliaLang/julia/blob/master/base/boot.jl>`_. TODO -- drill down into eval?
+`jl_load("boot.jl", sizeof("boot.jl")) <https://github.com/JuliaLang/julia/blob/master/src/init.c>`_ calls `jl_parse_eval_all <https://github.com/JuliaLang/julia/blob/master/src/ast.c>`_ which repeatedly calls `jl_toplevel_eval_flex() <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ to execute `boot.jl <https://github.com/JuliaLang/julia/blob/master/base/boot.jl>`_. TODO -- drill down into eval?
 
 `jl_get_builtin_hooks() <https://github.com/JuliaLang/julia/blob/master/src/init.c>`_ initialises global C pointers to Julia globals defined in ``boot.jl``.
 
@@ -164,12 +155,20 @@ Finally `sigint_handler() <https://github.com/JuliaLang/julia/blob/master/src/si
 :c:func:`_julia_init` then returns `back to main() in julia/ui/repl.c
 <https://github.com/JuliaLang/julia/blob/master/ui/repl.c>`_ and main() calls :code:`true_main(argc, (char**)argv)`.
 
+.. sidebar:: sysimg
+
+    If there is a sysimg file, it contains a pre-cooked image of the :mod:`Core` and :mod:`Main` modules (and whatever else is created by ``boot.jl``). See :ref:`dev-sysimg`.
+
+    `jl_restore_system_image() <https://github.com/JuliaLang/julia/blob/master/src/dump.c>`_ de-serialises the saved sysimg into the current Julia runtime environment and initialisation continues after :c:func:`jl_init_box_caches` below...
+
+    Note: `jl_restore_system_image() (and dump.c in general) <https://github.com/JuliaLang/julia/blob/master/src/dump.c>`_ uses the :ref:`dev-ios`.
+
 true_main()
 -----------
 
 `true_main() <https://github.com/JuliaLang/julia/blob/master/ui/repl.c>`_ loads the contents of :code:`argv[]` into :data:`Base.ARGS`.
 
-If a .jl "program" file was supplied on the command line, then `exec_program() <https://github.com/JuliaLang/julia/blob/master/ui/repl.c>`_ calls `jl_load(program,len) <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ which calls `jl_parse_eval_all() <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ which repeatedly calls `jl_parse_next() <https://github.com/JuliaLang/julia/blob/master/src/ast.c>`_ and `jl_toplevel_eval_flex() <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ to parse and execute the program.
+If a .jl "program" file was supplied on the command line, then `exec_program() <https://github.com/JuliaLang/julia/blob/master/ui/repl.c>`_ calls `jl_load(program,len) <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ which calls `jl_parse_eval_all <https://github.com/JuliaLang/julia/blob/master/src/ast.c>`_ which repeatedly calls `jl_toplevel_eval_flex() <https://github.com/JuliaLang/julia/blob/master/src/toplevel.c>`_ to execute the program.
 
 However, in our example (:code:`julia -e 'println("Hello World!")'`), `jl_get_global(jl_base_module, jl_symbol("_start")) <https://github.com/JuliaLang/julia/blob/master/src/module.c>`_ looks up `Base._start <https://github.com/JuliaLang/julia/blob/master/base/client.jl>`_ and `jl_apply() <https://github.com/JuliaLang/julia/blob/master/src/julia.h>`_ executes it.
 
diff --git a/doc/devdocs/julia.rst b/doc/devdocs/julia.rst
index 7506b05f86b0c..ce66286c99d88 100644
--- a/doc/devdocs/julia.rst
+++ b/doc/devdocs/julia.rst
@@ -14,6 +14,8 @@
    ast
    types
    object
+   functions
+   callconv
    cartesian
    meta
    subarrays
@@ -21,3 +23,4 @@
    llvm
    stdio
    promote-op
+   boundscheck
diff --git a/doc/devdocs/llvm.rst b/doc/devdocs/llvm.rst
index addc45f36742e..b66e72fa4f567 100644
--- a/doc/devdocs/llvm.rst
+++ b/doc/devdocs/llvm.rst
@@ -37,7 +37,7 @@ directory ``src/``.
 |``sys.c``            | I/O and operating system utility functions                  |
 +---------------------+-------------------------------------------------------------+
 
-Some of the `.cpp` files form a group that compile to a single object.
+Some of the ``.cpp`` files form a group that compile to a single object.
 
 The difference between an intrinsic and a builtin is that a builtin is a first class
 function that can be used like any other Julia function.  An intrinsic can operate
@@ -50,7 +50,7 @@ Julia currently uses LLVM's `Type Based Alias Analysis <http://llvm.org/docs/Lan
 To find the comments that document the inclusion relationships, look for ``static MDNode*``
 in ``src/codegen.cpp``.
 
-The `-O` option enables LLVM's `Basic Alias Analysis <http://llvm.org/docs/AliasAnalysis.html#the-basicaa-pass>`_.
+The ``-O`` option enables LLVM's `Basic Alias Analysis <http://llvm.org/docs/AliasAnalysis.html#the-basicaa-pass>`_.
 
 Building Julia with a different version of LLVM
 -----------------------------------------------
@@ -58,7 +58,9 @@ Building Julia with a different version of LLVM
 The default version of LLVM is specified in ``deps/Versions.make``.
 You can override it by creating a file called ``Make.user`` in the top-level directory and adding a line to it such as:
 
-    ``LLVM_VER = 3.5.0``
+.. code-block:: make
+
+    LLVM_VER = 3.5.0
 
 Besides the LLVM release numerals, you can
 also use ``LLVM_VER = svn`` to bulid against the latest development version
@@ -74,7 +76,7 @@ Here are example settings using ``bash`` syntax:
 
 * ``export JULIA_LLVM_ARGS = -print-after-all`` dumps IR after each pass.
 
-* ``export JULIA_LLVM_ARGS = -debug-only=loop-vectorize`` dumps LLVM `DEBUG(`...`)`
+* ``export JULIA_LLVM_ARGS = -debug-only=loop-vectorize`` dumps LLVM ``DEBUG(...)``
   diagnostics for loop vectorizer *if* you built Julia with ``LLVM_ASSERTIONS=1``.
   Otherwise you will get warnings about "Unknown command line argument".
   Counter-intuitively, building Julia with ``LLVM_DEBUG=1`` is *not* enough to
diff --git a/doc/devdocs/object.rst b/doc/devdocs/object.rst
index e8369ae0ce44e..f4a8aa1d0323d 100644
--- a/doc/devdocs/object.rst
+++ b/doc/devdocs/object.rst
@@ -136,7 +136,7 @@ Symbols::
 
     jl_sym_t *jl_symbol(const char *str);
 
-Functions and LambdaStaticData::
+Functions and LambdaInfo::
 
     jl_function_t *jl_new_generic_function(jl_sym_t *name);
     jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast, jl_tuple_t *sparams);
@@ -166,6 +166,9 @@ then tagged with its type::
     jl_value_t *jl_gc_allocobj(size_t nbytes);
     void jl_set_typeof(jl_value_t *v, jl_datatype_t *type);
 
+Note that all objects are allocated in multiples of 4 bytes and aligned to the platform pointer size.
+Memory is allocated from a pool for smaller objects, or directly with :c:func:`malloc` for large objects.
+
 .. sidebar:: :ref:`man-singleton-types`
 
     Singleton types have only one instance and no data fields.
@@ -174,6 +177,3 @@ then tagged with its type::
     e.g. :data:`nothing::Void`.
 
     See :ref:`man-singleton-types` and :ref:`man-nothing`
-
-Note that all objects are allocated in multiples of 4 bytes and aligned to the platform pointer size.
-Memory is allocated from a pool for smaller objects, or directly with :c:func:`malloc` for large objects.
diff --git a/doc/devdocs/reflection.rst b/doc/devdocs/reflection.rst
index e5356ada69dee..2f3ace38417db 100644
--- a/doc/devdocs/reflection.rst
+++ b/doc/devdocs/reflection.rst
@@ -74,8 +74,8 @@ The internal representation of a :obj:`DataType` is critically important when in
 C code and several functions are available to inspect these details.
 :func:`isbits(T::DataType) <isbits>` returns true if ``T`` is
 stored with C-compatible alignment.
-:func:`fieldoffsets(T::DataType) <fieldoffsets>` returns the (byte) offset for each
-field relative to the start of the type.
+:func:`fieldoffset(T::DataType, i::Integer) <fieldoffset>` returns the (byte) offset for
+field `i` relative to the start of the type.
 
 .. rubric:: Function methods
 
diff --git a/doc/devdocs/stdio.rst b/doc/devdocs/stdio.rst
index c2f1599a08ef2..63efb74b43283 100644
--- a/doc/devdocs/stdio.rst
+++ b/doc/devdocs/stdio.rst
@@ -101,9 +101,9 @@ It provides cross-platform buffered file IO and in-memory temporary buffers.
 
 :code:`ios.c` is still used by:
 
-    - :code:`julia/src/flisp/*.c`
-    - :code:`julia/src/dump.c` -- for serialisation file IO and for memory buffers.
-    - :code:`base/iostream.jl` -- for file IO (see :code:`base/fs.jl` for ``libuv`` equivalent).
+- :code:`julia/src/flisp/*.c`
+- :code:`julia/src/dump.c` -- for serialisation file IO and for memory buffers.
+- :code:`base/iostream.jl` -- for file IO (see :code:`base/fs.jl` for ``libuv`` equivalent).
 
 Use of :code:`ios.c` in these modules is mostly self-contained and
 separated from the ``libuv`` I/O system. However, there is `one place
diff --git a/doc/devdocs/types.rst b/doc/devdocs/types.rst
index cfea8aff7155a..e4470fbdc521c 100644
--- a/doc/devdocs/types.rst
+++ b/doc/devdocs/types.rst
@@ -578,20 +578,20 @@ constraints that we just saw in ``typeintersect``.
 ``jltypes.c`` contains three closely related collections of functions
 for testing how types ``a`` and ``b`` are ordered:
 
-  - The ``subtype`` functions implement ``a <: b``. Among other uses, they
-    serve in matching function arguments against method signatures in
-    the function cache.
-
-  - The ``type_morespecific`` functions are used for imposing a partial
-    order on functions in method tables (from most-to-least
-    specific). Note that ``jl_type_morespecific(a,b,0)`` really means "is ``a``
-    at least as specific as ``b``?" and not "is ``a`` strictly more specific
-    than ``b``?"
-
-  - The ``type_match`` functions are similar to ``type_morespecific``, but
-    additionally accept (and employ) an environment to constrain
-    typevars. The related ``type_match_morespecific`` functions call
-    ``type_match`` with an argument ``morespecific=1``
+- The ``subtype`` functions implement ``a <: b``. Among other uses, they
+  serve in matching function arguments against method signatures in
+  the function cache.
+
+- The ``type_morespecific`` functions are used for imposing a partial
+  order on functions in method tables (from most-to-least
+  specific). Note that ``jl_type_morespecific(a,b,0)`` really means "is ``a``
+  at least as specific as ``b``?" and not "is ``a`` strictly more specific
+  than ``b``?"
+
+- The ``type_match`` functions are similar to ``type_morespecific``, but
+  additionally accept (and employ) an environment to constrain
+  typevars. The related ``type_match_morespecific`` functions call
+  ``type_match`` with an argument ``morespecific=1``
 
 All three of these take an argument, ``invariant``, which is set to 1 when
 comparing type parameters and otherwise is 0.
diff --git a/doc/genstdlib.jl b/doc/genstdlib.jl
index f0054b249ac1e..00b29763dba09 100644
--- a/doc/genstdlib.jl
+++ b/doc/genstdlib.jl
@@ -1,318 +1,198 @@
-using .Markdown
-using Base.Markdown: MD
+module GenStdLib
 
-cd(dirname(@__FILE__))
+import Base.Docs: Binding, DocStr
 
-isop(func) = ismatch(r"[^\w@!.]|^!$", func)
+# Constants.
+const DOCSTRING_DIRECTIVE = r"^(.. (function):: ).*"
 
-ident(mod, x) = "$mod.$(isop(x) ? "(:($x))" : x)"
+# Types.
 
-all_docs = ObjectIdDict()
+typealias Signature Tuple{Binding, Type}
 
-function add_all_docs(it)
-    for (k, v) in it
-        all_docs[v] = k
-    end
-end
-
-function add_all_docs(it, k)
-    for (_, v) in it
-        all_docs[v] = k
-    end
+type State
+    files      :: Dict{UTF8String, Vector{UTF8String}}
+    validdocs  :: Dict{UTF8String, Tuple{Module, Signature, DocStr}}
+    baddocs    :: Dict{Signature, Tuple{Module, DocStr}}
+    documented :: Dict{Signature, Tuple{Module, DocStr, UTF8String}}
+    errorlevel :: Int
+    debug      :: Bool
+    State() = new(Dict(), Dict(), Dict(), Dict(), 0, "JULIA_GENSTDLIB_DEBUG" in keys(ENV))
 end
 
-function sym_exported(obj::ANY, m, exports)
-    if isa(obj, Union{Function,DataType,Module})
-        return symbol(string(obj)) in exports
-    elseif isa(obj, IntrinsicFunction)
-        # Only example seems to be cglobal for now
-        return true
-    elseif isa(obj, Docs.Binding)
-        return (obj::Docs.Binding).var in exports
-    else
-        return false
+# Documentation Translator.
+
+function translate(dirs::Vector; root = dirname(@__FILE__))
+    cd(root) do
+        state = State()
+        println("\n# GENSTDLIB\n")
+        # Find all available docstrings within `Base` and its submodules.
+        info("loading docstrings from modules.")
+        loaddocs!(state)
+        # Read in rst pages and update all docstrings.
+        info("parsing external documentation.")
+        for dir in dirs, file in readdir(dir)
+            translate(state, joinpath(dir, file))
+        end
+        # Write the newly updated rst docs back to their files -- replaces original content.
+        if state.errorlevel < 2
+            info("writing documentation back to file.")
+            for (file, contents) in state.files
+                open(file, "w") do io
+                    for line in contents
+                        println(io, line)
+                    end
+                end
+            end
+        else
+            warn("errors found while generating documentation. Aborting file writing.")
+        end
+        # Report statistics about 'Base' docs.
+        summarise(state)
     end
 end
-
-function add_all_docs_meta(m::Module,meta)
-    exports = names(m)
-    for (obj, d) in meta
-        isexported = sym_exported(obj, m, exports)
-        if isa(d, Base.Docs.FuncDoc) || isa(d, Base.Docs.TypeDoc)
-            add_all_docs(d.meta, (obj, isexported))
+function translate(state::State, file::AbstractString)
+    input, output = split(readstring(file), '\n')[1:end-1], []
+    while !isempty(input)
+        if ismatch(DOCSTRING_DIRECTIVE, first(input))
+            append!(output, getdoc(state, file, input))
         else
-            all_docs[d] = (obj, isexported)
+            push!(output, shift!(input))
         end
     end
+    state.files[file] = output
+    return state
 end
 
-mod_added = ObjectIdDict()
-
-function add_all_docs_mod(m::Module)
-    mod_added[m] = m
-    try
-        add_all_docs_meta(m,Docs.meta(m))
-    end
-    for name in names(m)
-        try
-            sub_m = getfield(m,name)
-            isa(sub_m, Module) || continue
-            if !(sub_m in keys(mod_added))
-                add_all_docs_mod(sub_m)
-            end
+# Documentation Summary Report.
+
+function summarise(state::State)
+    println("\n# SUMMARY\n")
+    println("   ", length(state.validdocs),  " docstrings found in modules.")
+    println("   ", length(state.documented), " docstrings found in external docs.")
+
+    # Of the missing docstrings, which are public and which are private?
+    public, private = [], []
+    for (sig, (mod, signature, docstr)) in state.validdocs
+        # The docstring is valid, but not found in the external docs.
+        if !haskey(state.documented, signature)
+            binding, typesig = signature
+            exported = binding.var in names(binding.mod)
+            push!(exported ? public : private, (binding, typesig))
         end
     end
+    println("   ", length(public), " public docstrings missing from external docs.")
+    state.debug && (println(); foreach(printmissing, public); println())
+    println("   ", length(private), " private docstrings missing from external docs.")
+    state.debug && (println(); foreach(printmissing, private); println())
+
+    # Expected format is: first element in docstring should be a code block.
+    println("   ", length(state.baddocs),    " docstrings not matching expected format. Skipped.")
+    println("   ", length(state.files),      " files parsed.\n")
+    state.debug || println("Set 'JULIA_GENSTDLIB_DEBUG' ENV for additional debug info.\n")
 end
+printmissing(x) = println("     X ", x[1], " :: ", x[2])
 
-add_all_docs_mod(Base)
-# Most of the keywords are not functions and they are easy to check by hand
-# add_all_docs(Docs.keywords)
-
-println("Collect $(length(all_docs)) Docs")
+# Documentation Loader.
 
-function find_docs(v)
-    docs = []
-    for mod in keys(mod_added)
-        try
-            meta = Docs.meta(mod)[v]
-            if isa(meta, Base.Docs.FuncDoc) || isa(meta, Base.Docs.TypeDoc)
-                append!(docs, collect(values(meta.meta)))
-            else
-                push!(docs, meta)
+function loaddocs!(state::State)
+    for mod in Base.Docs.modules
+        for (binding, multidoc) in Base.Docs.meta(mod)
+            for (typesig, docstr) in multidoc.docs
+                loaddocs!(state, mod, binding, typesig, docstr)
             end
         end
     end
-    if isempty(docs)
-        error("Cannot find doc for $v")
+    for (keyword, docstr) in Base.Docs.keywords
+        loaddocs!(state, Main, keyword, Union{}, docstr)
     end
-    return docs
+    return state
 end
-
-function getdoc(mod, x)
-    try
-        x = unescape_string(x)
-        if symbol(x) in keys(Docs.keywords)
-            return Any[Docs.keywords[symbol(x)]]
+function loaddocs!(state::State, mod, binding::Binding, typesig, docstr)
+    markdown = Base.Docs.parsedoc(docstr)
+    if validdocstr(markdown)
+        code = rstrip(markdown.content[1].code)
+        if haskey(state.validdocs, code)
+            code = indent(code)
+            warn("duplicate signature found for '$binding' in module '$mod':\n\n$code\n")
+            state.errorlevel = 2
+        else
+            state.validdocs[code] = (mod, (binding, typesig), docstr)
         end
-        if x[1] != '@'
-            v = eval(parse(ident(mod, x)))
-            isa(v, Colon) && (v = Base.colon)
-            return find_docs(v)
+    else
+        if haskey(state.baddocs, (binding, typesig))
+            warn("duplicate binding '$binding :: $typesig' found in module '$mod'.")
+            state.errorlevel = 2
         else
-            for m in [eval(parse(mod)); collect(keys(mod_added));]
-                try
-                    v = Docs.Binding(m, symbol(x))
-                    return find_docs(v)
-                end
-            end
-            error("Cannot find doc for $x")
+            state.baddocs[(binding, typesig)] = (mod, docstr)
         end
-    catch e
-        println(e)
-        warn("Mod $mod $x")
     end
-    []
+    return state
 end
-
-flat_content(md) = md
-flat_content(xs::Vector) = reduce((xs, x) -> vcat(xs,flat_content(x)), [], xs)
-flat_content(md::MD) = flat_content(md.content)
-
-flatten(md::MD) = MD(flat_content(md))
-
-isrst(md) =
-    length(flatten(md).content) == 1 &&
-    isa(flatten(md).content[1], Markdown.Code) &&
-    flatten(md).content[1].language == "rst"
-
-function tryrst(md, remove_decl)
-    try
-        if remove_decl && isa(md.content[1], Markdown.Code) && md.content[1].language == ""
-            shift!(md.content)
-        end
-        return Markdown.rst(md)
-    catch e
-        warn("Error converting docstring:")
-#        display(md)
-        println(e)
-        return
-    end
+function loaddocs!(state::State, mod, keyword::Symbol, typesig, docstr)
+    binding = Base.Docs.Binding(mod, keyword)
+    loaddocs!(state, mod, binding, typesig, docstr)
 end
 
-torst(md,remove_decl) = isrst(md) ? flatten(md).content[1].code : tryrst(md, remove_decl)
+# Retrieve and format docstrings.
 
-function split_decl_rst(md, decl)
-    if isrst(md)
-        rst_text = flatten(md).content[1].code
-        ls = split(rst_text, "\n")
-        body_start = 1
-        if startswith(ls[1], ".. ") && !endswith(ls[1], "::")
-            decl = ".. function:: " * replace(ls[1], r"^.. *", "")
-            body_start += 1
-            while startswith(ls[body_start], "   ")
-                decl *= replace(ls[body_start], r"^ *", "\n              ")
-                body_start += 1
-            end
-            while ls[body_start] == ""
-                body_start += 1
-            end
-            return decl, join(ls[body_start:end], "\n")
+function getdoc(state::State, file::AbstractString, input::Vector)
+    # Capture the lines containing the docstring signature.
+    output = []
+    while !isempty(input)
+        line = shift!(input)
+        push!(output, line)
+        ismatch(r"^$", line) && break
+    end
+    # Recover the unindented version of the signature.
+    n = length(match(DOCSTRING_DIRECTIVE, first(output))[1])
+    b = IOBuffer()
+    for line in output[1:end-1]
+        println(b, line[(n + 1):end])
+    end
+    # The signature may contain `\` characaters, which must be unescaped.
+    signature = unescape_string(rstrip(takebuf_string(b)))
+    # Splice the correct docstring into the output after the signature.
+    if haskey(state.validdocs, signature)
+        # Push the rst text for the docstring into the output.
+        mod, (binding, typesig), docstr = state.validdocs[signature]
+        md  = Markdown.MD(Base.Docs.parsedoc(docstr).content[2:end])
+        rst = Base.Markdown.rst(md)
+        push!(output, "   .. Docstring generated from Julia source", "")
+        for line in split(rst, '\n')
+            line = isempty(line) ? "" : string(" "^3, line)
+            push!(output, rstrip(line))
         end
-        return decl, rst_text
-    else
-        if isa(md.content[1], Markdown.Code) && md.content[1].language == ""
-            decl = ".. function:: " * replace(shift!(md.content).code, "\n",
-                                              "\n              ")
+        # Consume all indented lines from the current docstring.
+        while !isempty(input)
+            line = first(input)
+            ismatch(r"^[^\s]", line) ? break : shift!(input)
         end
-        return decl, Markdown.rst(md)
+        # Track which docstrings have been found in the external docs.
+        state.documented[(binding, typesig)] = (mod, docstr, signature)
+    else
+        signature = indent(signature)
+        warn("missing docs for signature:\n\n$signature\n")
+        state.errorlevel = 1
     end
+    return output
 end
 
-# Disable by default since it is hard to eliminate false positives
-const warn_doc_between_func = "JULIA_WARN_DOC_BETWEEN_FUNC" in keys(ENV)
+# Utilities.
 
-function translate(file)
-    @assert(isfile(file))
-    ls = split(readall(file), "\n")[1:end-1]
-    doccing = false
-    func = nothing
-    mod = "Base"
-    modidx = -1
-    open(file, "w+") do io
-        has_func_doc = false
-        missing_func_doc = []
-        cur_func = ""
-        function warn_missing_func_doc()
-            if (warn_doc_between_func && has_func_doc &&
-                !isempty(missing_func_doc))
-                doc_str = join(missing_func_doc, "\n")
-                warn("Possible missing document for `$cur_func` in `$file`:")
-                info(doc_str)
-            end
-            missing_func_doc = []
-        end
-        function start_new_section()
-            warn_missing_func_doc()
-            has_func_doc = false
-        end
-        function start_func_doc(func_line)
-            warn_missing_func_doc()
-            cur_func = func_line
-            has_func_doc = true
-        end
-        function push_non_func_line(l)
-            has_func_doc || return
-            if (startswith(l, ".. data:: ") ||
-                startswith(l, ".. _") ||
-                ismatch(r"^[A-Z][a-z]* implemented", l))
-                start_new_section()
-            elseif (startswith(l, "----") ||
-                    startswith(l, "====") ||
-                    startswith(l, "~~~~"))
-                if !isempty(missing_func_doc)
-                    pop!(missing_func_doc)
-                    start_new_section()
-                end
-            end
-            has_func_doc || return
-            push!(missing_func_doc, l)
-        end
-        for (i,l) in enumerate(ls)
-            if ismatch(r"^\.\. (current)?module::", l)
-                start_new_section()
-                mod = match(r"^\.\. (current)?module:: ([\w\.]+)", l).captures[2]
-                modidx = i
-                println(io, l)
-            elseif startswith(l, ".. function::")
-                func = match(r"^\.\. function:: (@?[^\(\s\{]+)(.*)", l)
-                func == nothing && (warn("bad function $l"); continue)
-                funcname = func.captures[1]
-                full = funcname * func.captures[2]
-                if !('(' in full || '@' in full)
-                    ex = parse(full)
-                    if isa(ex, Expr)
-                        if (ex.head == :(||) || ex.head == :(&&))
-                            funcname = string(ex.head)
-                        elseif ex.head == :macrocall
-                            funcname = string(ex.args[1])
-                        end
-                    end
-                end
-                doc = nothing
-                for mdoc in getdoc(mod, funcname)
-                    trst = tryrst(mdoc, false)
-                    trst !== nothing || continue
-                    if contains(replace(trst, r"[\n ][\n ]+", " "),
-                                " " * replace(full, r"[\n ][\n ]+", " "))
-                        if doc != nothing
-                            error("duplicate $full $l")
-                        end
-                        doc = mdoc
-                    else
-                        #@show trst full
-                    end
-                end
-                if doc == nothing || torst(doc, false) == nothing
-                    info("no docs for $full in $mod")
-                    println(io, l)
-                    doccing = false
-                    start_new_section()
-                    continue
-                end
-                delete!(all_docs, doc)
-                doccing = true
-                start_func_doc(full)
-                decl, body = split_decl_rst(doc, l)
-                println(io, decl)
-                println(io)
-                println(io, "   .. Docstring generated from Julia source\n")
-                for l in split(body, "\n")
-                    ismatch(r"^\s*$", l) ? println(io) : println(io, "   ", l)
-                end
-                isrst(doc) && println(io)
-            elseif doccing && (ismatch(r"^\s+", l) || ismatch(r"^\s*$", l))
-                modidx == i-1 && println(io)
-            else
-                doccing = false
-                push_non_func_line(l)
-                println(io, l)
-            end
-        end
+function indent(str::AbstractString, indent = 4)
+    buf = IOBuffer()
+    for line in split(str, '\n')
+        println(buf, " "^indent, line)
     end
+    takebuf_string(buf)
 end
 
-for folder in ["stdlib", "manual", "devdocs"]
-    println("\nConverting $folder/\n")
-    for file in readdir("$folder")
-        translate("$folder/$file")
-    end
+function validdocstr(markdown::Base.Markdown.MD)
+    content = markdown.content
+    !isempty(content) && isa(first(content), Base.Markdown.Code)
 end
+validdocstr(other) = false
 
-exported_missing_count = 0
-unexported_missing_count = 0
-
-for (d, v) in all_docs
-    if length(v) == 2
-        val,isexported = v
-    else
-        val,isexported = v,true
-    end
-    isa(val, ObjectIdDict) && continue # No idea what these are
-    isa(val, Int) && continue # We don't document `0` as a function
-    if isexported
-        warn("Exported method missing doc for $val")
-        exported_missing_count += 1
-    else
-        info("Unexported method missing doc for $val")
-        unexported_missing_count += 1
-    end
-    # println(tryrst(d, false))
-    # # Generate todo list ;-p
-    # println("- [ ] `$v`")
 end
 
-if (exported_missing_count + unexported_missing_count) > 0
-    println()
-    warn("Missing $exported_missing_count exported doc strings")
-    info("Missing $unexported_missing_count unexported doc strings")
-end
+GenStdLib.translate(["manual", "stdlib", "devdocs"])
diff --git a/doc/index.rst b/doc/index.rst
index 7a62aeb794287..1cffce078fc20 100644
--- a/doc/index.rst
+++ b/doc/index.rst
@@ -41,10 +41,12 @@
    manual/dates
    manual/running-external-programs
    manual/calling-c-and-fortran-code
+   manual/handling-operating-system-variation
    manual/interacting-with-julia
    manual/embedding
    manual/packages
    manual/profile
+   manual/stacktraces
    manual/performance-tips
    manual/workflow-tips
    manual/style-guide
@@ -79,6 +81,7 @@
    stdlib/test
    stdlib/c
    stdlib/profile
+   stdlib/stacktraces
 
 .. _devdocs:
 
diff --git a/doc/man/julia.1 b/doc/man/julia.1
index abca45488014e..65772848c802f 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -54,7 +54,6 @@ If a Julia source file is given as a \fIprogram\fP (optionally followed by
 
 .\" This section was taken nearly verbatim from the output of `julia --help`
 .SH "COMMAND-LINE OPTIONS"
-.TP 25
 
 .TP
 -v, --version
@@ -65,13 +64,25 @@ Display version information
 Print help message
 
 .TP
--q, --quiet
-Quiet startup without banner
+-J, --sysimage <file>
+Start up with the given system image file
+
+.TP
+-precompiled={yes|no}
+Use precompiled code from system image if available
 
 .TP
 -H, --home <dir>
 Set location of julia executable
 
+.TP
+--startup-file={yes|no}
+Load ~/.juliarc.jl
+
+.TP
+--handle-signals={yes|no}
+Enable or disable Julia's default signal handlers
+
 .TP
 -e, --eval <expr>
 Evaluate <expr>
@@ -88,14 +99,6 @@ Evaluate <expr>, but don't disable interactive mode
 -L, --load <file>
 Load <file> immediately on all processors
 
-.TP
--J, --sysimage <file>
-Start up with the given system image file
-
-.TP
--C, --cpu-target <target>
-Limit usage of cpu features up to <target>
-
 .TP
 -p, --procs <n>
 Run n local processes
@@ -108,6 +111,10 @@ Run processes on hosts listed in <file>
 -i
 Force isinteractive() to be true
 
+.TP
+-q, --quiet
+Quiet startup without banner
+
 .TP
 --color={yes|no}
 Enable or disable color text
@@ -117,45 +124,57 @@ Enable or disable color text
 Load or save history
 
 .TP
---startup-file={yes|no}
-Load ~/.juliarc.jl
-
-.TP
---compile={yes|no|all}
+ --compile={yes|no|all}
 Enable or disable compiler, or request exhaustive compilation
 
 .TP
---code-coverage={none|user|all}, --code-coverage
-Count executions of source lines (omitting setting is equivalent to 'user')
-
-.TP
---track-allocation={none|user|all}, --track-allocation
-Count bytes allocated by each source line
+-C, --cpu-target <target>
+Limit usage of cpu features up to <target>
 
 .TP
 -O, --optimize
 Run time-intensive code optimizations
 
+.TP
+--inline={yes|no}
+Control whether inlining is permitted (overrides functions declared as @inline)
+
 .TP
 --check-bounds={yes|no}
 Emit bounds checks always or never (ignoring declarations)
 
 .TP
---dump-bitcode={yes|no}
-Dump bitcode for the system image (used with --build)
+--math-mode={ieee|user}
+Always use IEEE semantics for math (ignoring declarations),
+or adhere to declarations in source code
 
 .TP
 --depwarn={yes|no|error}
 Enable or disable syntax and method deprecation warnings ('error' turns warnings into errors)
 
 .TP
---inline={yes|no}
-Control whether inlining is permitted (overrides functions declared as @inline)
+ --output-o name
+Generate an object file (including system image data)
 
 .TP
---math-mode={ieee|user}
-Always use IEEE semantics for math (ignoring declarations),
-or adhere to declarations in source code
+--output-ji name
+Generate a system image data file (.ji)
+
+.TP
+--output-bc name
+Generate LLVM bitcode (.bc)
+
+.TP
+ --output-incremental=no
+Generate an incremental output file (rather than complete)
+
+.TP
+--code-coverage={none|user|all}, --code-coverage
+Count executions of source lines (omitting setting is equivalent to 'user')
+
+.TP
+--track-allocation={none|user|all}, --track-allocation
+Count bytes allocated by each source line
 
 .SH FILES
 .I ~/.juliarc.jl
diff --git a/doc/manual/arrays.rst b/doc/manual/arrays.rst
index c075d99e12396..5b9eb936ef59f 100644
--- a/doc/manual/arrays.rst
+++ b/doc/manual/arrays.rst
@@ -87,9 +87,9 @@ Function                                            Description
                                                     defaulting to the element type and dimensions of ``A`` if omitted.
 :func:`reinterpret(type, A) <reinterpret>`          an array with the same binary data as the given array, but with the
                                                     specified element type
-:func:`rand(dims) <rand>`                           `:obj:`Array` of ``Float64``\ s with random, iid[#]_ and uniformly
+:func:`rand(dims) <rand>`                           :obj:`Array` of ``Float64``\ s with random, iid[#]_ and uniformly
                                                     distributed values in the half-open interval :math:`[0, 1)`
-:func:`randn(dims) <randn>`                         `:obj:`Array` of ``Float64``\ s with random, iid and standard normally
+:func:`randn(dims) <randn>`                         :obj:`Array` of ``Float64``\ s with random, iid and standard normally
                                                     distributed random values
 :func:`eye(n) <eye>`                                ``n``-by-``n`` identity matrix
 :func:`eye(m, n) <eye>`                             ``m``-by-``n`` identity matrix
@@ -213,6 +213,40 @@ that the result is of type ``Float64`` by writing::
 
     Float64[ 0.25*x[i-1] + 0.5*x[i] + 0.25*x[i+1] for i=2:length(x)-1 ]
 
+.. _man-generator-expressions:
+
+Generator Expressions
+---------------------
+
+Comprehensions can also be written without the enclosing square brackets, producing
+an object known as a generator. This object can be iterated to produce values on
+demand, instead of allocating an array and storing them in advance
+(see <man-interfaces-iteration>).
+For example, the following expression sums a series without allocating memory::
+
+.. doctest::
+
+    julia> sum(1/n^2 for n=1:1000)
+    1.6439345666815615
+
+When writing a generator expression with multiple dimensions inside an argument
+list, parentheses are needed to separate the generator from subsequent arguments::
+
+    julia> map(tuple, 1/(i+j) for i=1:2, j=1:2, [1:4;])
+    ERROR: syntax: invalid iteration specification
+
+All comma-separated expressions after ``for`` are interpreted as ranges. Adding
+parentheses lets us add a third argument to ``map``::
+
+.. doctest::
+
+    julia> map(tuple, (1/(i+j) for i=1:2, j=1:2), [1:4;])
+    4-element Array{Any,1}:
+    (0.5,1)
+    (0.333333,2)
+    (0.333333,3)
+    (0.25,4)
+
 .. _man-array-indexing:
 
 Indexing
@@ -233,8 +267,8 @@ where each ``I_k`` may be:
 The result ``X`` generally has dimensions
 ``(length(I_1), length(I_2), ..., length(I_n))``, with location
 ``(i_1, i_2, ..., i_n)`` of ``X`` containing the value
-``A[I_1[i_1], I_2[i_2], ..., I_n[i_n]]``. Trailing dimensions
-indexed with scalars are dropped. For example, the dimensions of ``A[I, 1]`` will be
+``A[I_1[i_1], I_2[i_2], ..., I_n[i_n]]``. All dimensions indexed with scalars are
+dropped. For example, the result of ``A[2, I, 3]`` will be a vector with size
 ``(length(I),)``. Boolean vectors are first transformed with ``find``; the size of
 a dimension indexed by a boolean vector will be the number of true values in the vector.
 As a special part of this syntax, the ``end`` keyword may be used to represent the last
@@ -528,7 +562,7 @@ where elements are stored in column-major order (see additional notes in
 :ref:`man-performance-tips`). :obj:`Vector` and :obj:`Matrix` are aliases for
 the 1-d and 2-d cases. Specific operations such as scalar indexing,
 assignment, and a few other basic storage-specific operations are all
-that have to be implemented for `:obj:`Array`, so that the rest of the array
+that have to be implemented for :obj:`Array`, so that the rest of the array
 library can be implemented in a generic manner.
 
 :obj:`SubArray` is a specialization of :obj:`AbstractArray` that performs
@@ -541,7 +575,7 @@ can later be used to index the original array indirectly.
 
 :obj:`StridedVector` and :obj:`StridedMatrix` are convenient aliases defined
 to make it possible for Julia to call a wider range of BLAS and LAPACK
-functions by passing them either `:obj:`Array` or :obj:`SubArray` objects, and
+functions by passing them either :obj:`Array` or :obj:`SubArray` objects, and
 thus saving inefficiencies from memory allocation and copying.
 
 The following example computes the QR decomposition of a small section
@@ -735,7 +769,7 @@ reference.
 
 +----------------------------------------+----------------------------------+--------------------------------------------+
 | Sparse                                 | Dense                            | Description                                |
-+----------------------------------------+----------------------------------+--------------------------------------------+
++========================================+==================================+============================================+
 | :func:`spzeros(m,n) <spzeros>`         | :func:`zeros(m,n) <zeros>`       | Creates a *m*-by-*n* matrix of zeros.      |
 |                                        |                                  | (:func:`spzeros(m,n) <spzeros>` is empty.) |
 +----------------------------------------+----------------------------------+--------------------------------------------+
diff --git a/doc/manual/calling-c-and-fortran-code.rst b/doc/manual/calling-c-and-fortran-code.rst
index 0226c73f6aae4..90d965dc75186 100644
--- a/doc/manual/calling-c-and-fortran-code.rst
+++ b/doc/manual/calling-c-and-fortran-code.rst
@@ -1,5 +1,7 @@
 .. _man-calling-c-and-fortran-code:
 
+.. currentmodule:: Base
+
 ****************************
  Calling C and Fortran Code
 ****************************
@@ -11,7 +13,7 @@ and efficient to call C and Fortran functions. Julia has a "no
 boilerplate" philosophy: functions can be called directly from Julia
 without any "glue" code, code generation, or compilation — even from the
 interactive prompt. This is accomplished just by making an appropriate call
-with ``ccall`` syntax, which looks like an ordinary function call.
+with :func:`ccall` syntax, which looks like an ordinary function call.
 
 The code to be called must be available as a shared library. Most C and
 Fortran libraries ship compiled as shared libraries already, but if you
@@ -42,12 +44,12 @@ By default, Fortran compilers `generate mangled names
 <https://en.wikipedia.org/wiki/Name_mangling#Name_mangling_in_Fortran>`_
 (for example, converting function names to lowercase or uppercase,
 often appending an underscore), and so to call a Fortran function via
-``ccall`` you must pass the mangled identifier corresponding to the rule
+:func:`ccall` you must pass the mangled identifier corresponding to the rule
 followed by your Fortran compiler.  Also, when calling a Fortran
 function, all inputs must be passed by reference.
 
-Finally, you can use ``ccall`` to actually generate a call to the
-library function. Arguments to ``ccall`` are as follows:
+Finally, you can use :func:`ccall` to actually generate a call to the
+library function. Arguments to :func:`ccall` are as follows:
 
 1. (:function, "library") pair (must be a constant, but see below).
 
@@ -80,36 +82,38 @@ is that a 1-tuple must be written with a trailing comma. For
 example, to call the ``getenv`` function to get a pointer to the value
 of an environment variable, one makes a call like this::
 
-    julia> path = ccall((:getenv, "libc"), Ptr{UInt8}, (Ptr{UInt8},), "SHELL")
-    Ptr{UInt8} @0x00007fff5fbffc45
+    julia> path = ccall((:getenv, "libc"), Cstring, (Cstring,), "SHELL")
+    Cstring(@0x00007fff5fbffc45)
 
     julia> bytestring(path)
     "/bin/bash"
 
-Note that the argument type tuple must be written as ``(Ptr{UInt8},)``,
-rather than ``(Ptr{UInt8})``. This is because ``(Ptr{UInt8})`` is just
-the expression ``Ptr{UInt8}`` surrounded by parentheses, rather than
-a 1-tuple containing ``Ptr{UInt8}``::
+Note that the argument type tuple must be written as ``(Cstring,)``,
+rather than ``(Cstring)``. This is because ``(Cstring)`` is just
+the expression ``Cstring`` surrounded by parentheses, rather than
+a 1-tuple containing ``Cstring``:
+
+.. doctest::
 
-    julia> (Ptr{UInt8})
-    Ptr{UInt8}
+    julia> (Cstring)
+    Cstring
 
-    julia> (Ptr{UInt8},)
-    (Ptr{UInt8},)
+    julia> (Cstring,)
+    (Cstring,)
 
 In practice, especially when providing reusable functionality, one
-generally wraps ``ccall`` uses in Julia functions that set up arguments
+generally wraps :func:`ccall` uses in Julia functions that set up arguments
 and then check for errors in whatever manner the C or Fortran function
 indicates them, propagating to the Julia caller as exceptions. This is
 especially important since C and Fortran APIs are notoriously
 inconsistent about how they indicate error conditions. For example, the
-``getenv`` C library function is wrapped in the following Julia function
-in
+``getenv`` C library function is wrapped in the following Julia function,
+which is a simplified version of the actual definition from
 `env.jl <https://github.com/JuliaLang/julia/blob/master/base/env.jl>`_::
 
     function getenv(var::AbstractString)
       val = ccall((:getenv, "libc"),
-                  Ptr{UInt8}, (Ptr{UInt8},), var)
+                  Cstring, (Cstring,), var)
       if val == C_NULL
         error("getenv: undefined variable: ", var)
       end
@@ -148,18 +152,22 @@ C libraries to use this pattern of requiring the caller to allocate
 memory to be passed to the callee and filled in. Allocation of memory
 from Julia like this is generally accomplished by creating an
 uninitialized array and passing a pointer to its data to the C function.
+This is why we don't use the ``Cstring`` type here: as the array is
+uninitialized, it could contain NUL bytes. Converting to a ``Cstring`` as
+part of the :func:`ccall` checks for contained NUL bytes and could therefore
+throw a conversion error.
 
 Creating C-Compatible Julia Function Pointers
 ---------------------------------------------
 
-It is possible to pass Julia functions to native c-functions that accept
-function pointer arguments. For example, to match c-prototypes of the form::
+It is possible to pass Julia functions to native C functions that accept
+function pointer arguments. For example, to match C prototypes of the form::
 
     typedef returntype (*functiontype)(argumenttype,...)
 
-The function ``cfunction`` generates the c-compatible function pointer for
+The function :func:`cfunction` generates the C-compatible function pointer for
 a call to a Julia library function.
-Arguments to ``cfunction`` are as follows:
+Arguments to :func:`cfunction` are as follows:
 
 1. A Julia Function
 
@@ -194,9 +202,9 @@ In order to pass this function to C, we obtain its address using the function ``
 
     const mycompare_c = cfunction(mycompare, Cint, (Ref{Cdouble}, Ref{Cdouble}))
 
-``cfunction`` accepts three arguments: the Julia function (``mycompare``), the return
-type (``Cint``), and a tuple of the argument types, in this case to sort an array of
-``Cdouble`` (Float64) elements.
+:func:`cfunction` accepts three arguments: the Julia function (``mycompare``),
+the return type (``Cint``), and a tuple of the argument types, in this case to
+sort an array of ``Cdouble`` (``Float64``) elements.
 
 The final call to ``qsort`` looks like this::
 
@@ -222,13 +230,13 @@ to fail or produce indeterminate results on a different system.
 Note that no C header files are used anywhere in the process of calling C
 functions: you are responsible for making sure that your Julia types and
 call signatures accurately reflect those in the C header file. (The `Clang
-package` <https://github.com/ihnorton/Clang.jl> can be used to auto-generate
+package <https://github.com/ihnorton/Clang.jl>`_ can be used to auto-generate
 Julia code from a C header file.)
 
 Auto-conversion:
 ~~~~~~~~~~~~~~~~
 
-Julia automatically inserts calls to the ``convert`` function to convert
+Julia automatically inserts calls to the :func:`cconvert` function to convert
 each argument to the specified type. For example, the following call::
 
     ccall((:foo, "libfoo"), Void, (Int32, Float64), x, y)
@@ -236,16 +244,17 @@ each argument to the specified type. For example, the following call::
 will behave as if the following were written::
 
     ccall((:foo, "libfoo"), Void, (Int32, Float64),
-          Base.cconvert(Int32, Base.cconvert_gcroot(Int32, x)),
-          Base.cconvert(Float64, Base.cconvert_gcroot(Float64, y)))
-
-Note that the primary fall-back method for ``cconvert`` is::
+          Base.unsafe_convert(Int32, Base.cconvert(Int32, x)),
+          Base.unsafe_convert(Float64, Base.cconvert(Float64, y)))
 
-    cconvert(T,x) = convert(T, x)
+:func:`cconvert` normally just calls :func:`convert`, but can be defined to return
+an arbitrary new object more appropriate for passing to C. For example,
+this is used to convert an ``Array`` of objects (e.g. strings) to an
+array of pointers.
 
-and the primary fallback method for ``cconvert_gcroot`` is::
-
-    cconvert_gcroot(T,x) = x
+:func:`unsafe_convert` handles conversion to ``Ptr`` types. It is considered
+unsafe because converting an object to a native pointer can hide the object
+from the garbage collector, causing it to be freed prematurely.
 
 Type Correspondences:
 ~~~~~~~~~~~~~~~~~~~~~
@@ -302,32 +311,42 @@ Bits Types:
 
 There are several special types to be aware of, as no other type can be defined to behave the same:
 
-:Float32: Exactly corresponds to the ``float`` type in C (or ``REAL*4`` in Fortran).
-:Float64: Exactly corresponds to the ``double`` type in C (or ``REAL*8`` in Fortran).
-:Complex64: Exactly corresponds to the ``complex float`` type in C (or ``COMPLEX*8`` in Fortran).
-:Complex128: Exactly corresponds to the ``complex double`` type in C (or ``COMPLEX*16`` in Fortran).
-:Signed: Exactly corresponds to the ``signed`` type annotation in C (or any ``INTEGER`` type in Fortran). Any Julia type that is not a subtype of ``Signed`` is assumed to be unsigned.
-:Ref{T}: Behaves like a ``Ptr{T}`` that owns its memory.
-:Array{T,N}:
+``Float32``
+    Exactly corresponds to the ``float`` type in C (or ``REAL*4`` in Fortran).
+
+``Float64``
+    Exactly corresponds to the ``double`` type in C (or ``REAL*8`` in Fortran).
+
+``Complex64``
+    Exactly corresponds to the ``complex float`` type in C (or ``COMPLEX*8`` in Fortran).
+
+``Complex128``
+    Exactly corresponds to the ``complex double`` type in C (or ``COMPLEX*16`` in Fortran).
+
+``Signed``
+    Exactly corresponds to the ``signed`` type annotation in C (or any ``INTEGER`` type in Fortran). Any Julia type that is not a subtype of ``Signed`` is assumed to be unsigned.
+
+``Ref{T}``
+    Behaves like a ``Ptr{T}`` that owns its memory.
+
+``Array{T,N}``
     When an array is passed to C as a ``Ptr{T}`` argument, it is
     not reinterpret-cast: Julia requires that the element type of the
-    array matches ``T``, and then address of the first element is passed.
+    array matches ``T``, and the address of the first element is passed.
 
     Therefore, if an ``Array`` contains data in the wrong format, it will
-    have to be explicitly converted using a call such as ``int32(a)``.
+    have to be explicitly converted using a call such as ``trunc(Int32,a)``.
 
     To pass an array ``A`` as a pointer of a different type *without*
     converting the data beforehand (for example, to pass a ``Float64`` array
-    to a function that operates on uninterpreted bytes), you can either
-    declare the argument as ``Ptr{Void}`` or you can explicitly call
-    ``pointer(A)``.
+    to a function that operates on uninterpreted bytes), you can
+    declare the argument as ``Ptr{Void}``.
 
-    If an array of eltype ``Ptr{T}`` is passed as a ``Ptr{Ptr{T}}`` argument, the Julia base library
-    ``cconvert_gcroot`` function will attempt to first make a null-terminated copy of the array with
-    each element replaced by its ``cconvert`` version. This allows, for example, passing an ``argv``
+    If an array of eltype ``Ptr{T}`` is passed as a ``Ptr{Ptr{T}}`` argument,
+    :func:`Base.cconvert` will attempt to first make a null-terminated copy of the array with
+    each element replaced by its :func:`cconvert` version. This allows, for example, passing an ``argv``
     pointer array of type ``Vector{ByteString}`` to an argument of type ``Ptr{Ptr{Cchar}}``.
 
-
 On all systems we currently support, basic C/C++ value types may be
 translated to Julia types as follows. Every C type also has a corresponding
 Julia type with the same name, prefixed by C. This can help for writing portable code (and remembering that an ``int`` in C is not the same as an ``Int`` in Julia).
@@ -341,7 +360,7 @@ Julia type with the same name, prefixed by C. This can help for writing portable
 +===================================+=================+======================+===================================+
 | ``unsigned char``                 | ``CHARACTER``   | ``Cuchar``           | ``UInt8``                         |
 |                                   |                 |                      |                                   |
-| ``bool`` (`C++`)                  |                 |                      |                                   |
+| ``bool`` (C++)                    |                 |                      |                                   |
 +-----------------------------------+-----------------+----------------------+-----------------------------------+
 | ``short``                         | ``INTEGER*2``   | ``Cshort``           | ``Int16``                         |
 |                                   |                 |                      |                                   |
@@ -351,7 +370,7 @@ Julia type with the same name, prefixed by C. This can help for writing portable
 +-----------------------------------+-----------------+----------------------+-----------------------------------+
 | ``int``                           | ``INTEGER*4``   | ``Cint``             | ``Int32``                         |
 |                                   |                 |                      |                                   |
-| ``BOOL`` (`C`, typical)           | ``LOGICAL*4``   |                      |                                   |
+| ``BOOL`` (C, typical)             | ``LOGICAL*4``   |                      |                                   |
 +-----------------------------------+-----------------+----------------------+-----------------------------------+
 | ``unsigned int``                  |                 | ``Cuint``            | ``UInt32``                        |
 +-----------------------------------+-----------------+----------------------+-----------------------------------+
@@ -410,6 +429,8 @@ error if the Julia string contains any embedded NUL characters (which would caus
 truncated if the C routine treats NUL as the terminator).  If you are passing a ``char*`` to a C routine that
 does not assume NUL termination (e.g. because you pass an explicit string length), or if you know for certain that
 your Julia string does not contain NUL and want to skip the check, you can use ``Ptr{UInt8}`` as the argument type.
+``Cstring`` can also be used as the :func:`ccall` return type, but in that case it obviously does not introduce any extra
+checks and is only meant to improve readability of the call.
 
 **System-dependent:**
 
@@ -433,40 +454,55 @@ C name                  Standard Julia Alias    Julia Base Type
                                                 ``UInt16`` (Windows)
 ======================  ======================  =======
 
-`Remember`: when calling a Fortran function, all inputs must be passed by reference, so all type correspondences
-above should contain an additional ``Ptr{..}`` or ``Ref{..}`` wrapper around their type specification.
+.. note::
 
-`Warning`: For string arguments (``char*``) the Julia type should be ``Cstring`` (if NUL-terminated data is expected)
-or either ``Ptr{Cchar}`` or ``Ptr{UInt8}`` otherwise (these two pointer types have the same effect), as described above,
-not ``ASCIIString``. Similarly, for array arguments (``T[]`` or ``T*``), the Julia
-type should again be ``Ptr{T}``, not ``Vector{T}``.
+    When calling a Fortran function, all inputs must be passed by reference, so
+    all type correspondences above should contain an additional ``Ptr{..}`` or
+    ``Ref{..}`` wrapper around their type specification.
 
-`Warning`: Julia's ``Char`` type is 32 bits, which is not the same as the wide
-character type (``wchar_t`` or ``wint_t``) on all platforms.
+.. warning::
 
-`Note`: For ``wchar_t*`` arguments, the Julia type should be ``Cwstring`` (if the C routine
-expects a NUL-terminated string) or ``Ptr{Cwchar_t}`` otherwise,
-and data can be converted to/from ordinary Julia strings by the
-``wstring(s)`` function (equivalent to either ``utf16(s)`` or ``utf32(s)``
-depending upon the width of ``Cwchar_t``); this conversion will be called
-automatically for ``Cwstring`` arguments.    Note also that ASCII, UTF-8,
-UTF-16, and UTF-32 string data in Julia is internally NUL-terminated, so
-it can be passed to C functions expecting NUL-terminated data without making
-a copy (but using the ``Cwstring`` type will cause an error to be thrown
-if the string itself contains NUL characters).
+    For string arguments (``char*``) the Julia type should be ``Cstring`` (if NUL-
+    terminated data is expected) or either ``Ptr{Cchar}`` or ``Ptr{UInt8}``
+    otherwise (these two pointer types have the same effect), as described above,
+    not ``ASCIIString``. Similarly, for array arguments (``T[]`` or ``T*``), the
+    Julia type should again be ``Ptr{T}``, not ``Vector{T}``.
 
-`Note`: C functions that take an argument of the type ``char**`` can be called by using
-a ``Ptr{Ptr{UInt8}}`` type within Julia. For example,
-C functions of the form::
+.. warning::
 
-    int main(int argc, char **argv);
+    Julia's ``Char`` type is 32 bits, which is not the same as the wide character
+    type (``wchar_t`` or ``wint_t``) on all platforms.
 
-can be called via the following Julia code::
+.. note::
 
-    argv = [ "a.out", "arg1", "arg2" ]
-    ccall(:main, Int32, (Int32, Ptr{Ptr{UInt8}}), length(argv), argv)
+    For ``wchar_t*`` arguments, the Julia type should be ``Cwstring`` (if the C
+    routine expects a NUL-terminated string) or ``Ptr{Cwchar_t}`` otherwise, and
+    data can be converted to/from ordinary Julia strings by the ``wstring(s)``
+    function (equivalent to either ``utf16(s)`` or ``utf32(s)`` depending upon the
+    width of ``Cwchar_t``); this conversion will be called automatically for
+    ``Cwstring`` arguments.    Note also that ASCII, UTF-8, UTF-16, and UTF-32
+    string data in Julia is internally NUL-terminated, so it can be passed to C
+    functions expecting NUL-terminated data without making a copy (but using the
+    ``Cwstring`` type will cause an error to be thrown if the string itself
+    contains NUL characters).
 
-`Note`: A C function declared to return ``Void`` will return the value ``nothing`` in Julia.
+.. note::
+
+    C functions that take an argument of the type ``char**`` can be called by
+    using a ``Ptr{Ptr{UInt8}}`` type within Julia. For example, C functions of the
+    form::
+
+        int main(int argc, char **argv);
+
+    can be called via the following Julia code::
+
+        argv = [ "a.out", "arg1", "arg2" ]
+        ccall(:main, Int32, (Int32, Ptr{Ptr{UInt8}}), length(argv), argv)
+
+.. note::
+
+    A C function declared to return ``Void`` will return the value ``nothing`` in
+    Julia.
 
 Struct Type correspondences
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -481,7 +517,7 @@ All other types are stored as a pointer to the data.
 When mirroring a struct used by-value inside another struct in C,
 it is imperative that you do not attempt to manually copy the fields over,
 as this will not preserve the correct field alignment.
-Instead, declare an immutable isbits type and use that instead.
+Instead, declare an immutable ``isbits`` type and use that instead.
 Unnamed structs are not possible in the translation to Julia.
 
 Packed structs and union declarations are not supported by Julia.
@@ -492,7 +528,7 @@ When translating your fields to Julia, declare the Julia field to be only
 of that type.
 
 Arrays of parameters must be expanded manually, currently
-(either inline, or in an immutable helper-type). For example::
+(either inline, or in an immutable helper type). For example::
 
     in C:
     struct B {
@@ -515,8 +551,8 @@ Arrays of unknown size are not supported.
 
 In the future, some of these restrictions may be reduced or eliminated.
 
-Memory Ownership:
-~~~~~~~~~~~~~~~~~
+Memory Ownership
+~~~~~~~~~~~~~~~~
 
 **malloc/free**
 
@@ -524,33 +560,38 @@ Memory allocation and deallocation of such objects must be
 handled by calls to the appropriate cleanup routines in the libraries
 being used, just like in any C program. Do not try to free an object
 received from a C library with ``Libc.free`` in Julia, as this may result
-in the ``free`` function being called via the wrong `libc` library and
+in the ``free`` function being called via the wrong ``libc`` library and
 cause Julia to crash. The reverse (passing an object allocated in Julia
 to be freed by an external library) is equally invalid.
 
-**Ptr{T} vs. Array{T} vs. Ref{T} vs. T**
+When to use T, Ptr{T} and Ref{T}
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In Julia code wrapping calls to external C routines, ordinary (non-pointer)
+data should be declared to be of type ``T`` inside the :func:`ccall`, as they
+are passed by value.  For C code accepting pointers, ``Ref{T}`` should
+generally be used for the types of input arguments, allowing the use of
+pointers to memory managed by either Julia or C through the implicit call to
+:func:`cconvert`.  In contrast, pointers returned by the C function called
+should be declared to be of output type ``Ptr{T}``, reflecting that the memory
+pointed to is managed by C only. Pointers contained in C structs should be
+represented as fields of type ``Ptr{T}`` within the corresponding Julia
+immutable types designed to mimic the internal structure of corresponding C
+structs.
 
-The choice of type-wrapper declaration strongly depends on who allocated the memory,
-and the declared type.
-In general, use ``T`` if the memory is intended to be allocated in
-(and managed by) Julia (with type-tag).
-Use ``Ptr{T}`` if the memory is expected to be populated by ``C`` (without type-tag).
-Use ``Ref{T}`` if you have an ``isbits`` type,
-but you want to turn it into a pointer to a struct in another struct definition.
+In Julia code wrapping calls to external Fortran routines, all input arguments
+should be declared as of type ``Ref{T}``, as Fortran passes all variables by
+reference. The return type should either be ``Void`` for Fortran subroutines,
+or a ``T`` for Fortran functions returning the type ``T``.
 
-See issue #2818 for some work that needs to be done to simplify this so that Julia
-types can be used to recursively mirror c-style structs,
-without requiring as much manual management of the ``Ptr`` conversions.
-After #2818 is implemented, it will be true that an ``Vector{T}`` will be equivalent to
-an ``Ptr{Ptr{T}}``. That is currently not true, and the conversion must be explicitly.
 
 Mapping C Functions to Julia
 ----------------------------
 
-ccall/cfunction argument translation guide
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+``ccall``/``cfunction`` argument translation guide
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-For translating a ``c`` argument list to ``Julia``:
+For translating a C argument list to Julia:
 
 * ``T``, where ``T`` is one of the primitive types:
   ``char``, ``int``, ``long``, ``short``, ``float``, ``double``, ``complex``, ``enum``
@@ -558,12 +599,12 @@ For translating a ``c`` argument list to ``Julia``:
 
   + ``T``, where ``T`` is an equivalent Julia Bits Type (per the table above)
   + if ``T`` is an ``enum``, the argument type should be equivalent to ``Cint`` or ``Cuint``
-  + argument value will be copied (passed by-value)
+  + argument value will be copied (passed by value)
 
 * ``struct T`` (including typedef to a struct)
 
-  + ``T``, where ``T`` is a Julia Leaf Type
-  + argument value will be copied (passed by-value)
+  + ``T``, where ``T`` is a Julia leaf type
+  + argument value will be copied (passed by value)
 
 * ``void*``
 
@@ -575,13 +616,13 @@ For translating a ``c`` argument list to ``Julia``:
 
   + ``Any``
   + argument value must be a valid Julia object
-  + currently unsupported by cfunction
+  + currently unsupported by :func:`cfunction`
 
 * ``jl_value_t**``
 
   + ``Ref{Any}``
   + argument value must be a valid Julia object (or ``C_NULL``)
-  + currently unsupported by cfunction
+  + currently unsupported by :func:`cfunction`
 
 * ``T*``
 
@@ -591,7 +632,7 @@ For translating a ``c`` argument list to ``Julia``:
 
 * ``(T*)(...)`` (e.g. a pointer to a function)
 
-  + ``Ptr{Void}`` (you may need to use ``cfunction`` explicitly to create this pointer)
+  + ``Ptr{Void}`` (you may need to use :func:`cfunction` explicitly to create this pointer)
 
 * ``...`` (e.g. a vararg)
 
@@ -601,10 +642,10 @@ For translating a ``c`` argument list to ``Julia``:
 
   + not supported
 
-ccall/cfunction return type translation guide
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+``ccall``/``cfunction`` return type translation guide
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-For translating a ``c`` return type to ``Julia``:
+For translating a C return type to Julia:
 
 * ``void``
 
@@ -646,7 +687,6 @@ For translating a ``c`` return type to ``Julia``:
     + ``Ref{T}``, where ``T`` is the Julia type corresponding to ``T``
     + a return type of ``Ref{Any}`` is invalid, it should either be ``Any``
       (corresponding to ``jl_value_t*``) or ``Ptr{Any}`` (corresponding to ``Ptr{Any}``)
-    + currently partially unsupported by cfunction due to #2818
     + C **MUST NOT** modify the memory returned via ``Ref{T}`` if ``T`` is an ``isbits`` type
 
   + If the memory is owned by C:
@@ -655,17 +695,17 @@ For translating a ``c`` return type to ``Julia``:
 
 * ``(T*)(...)`` (e.g. a pointer to a function)
 
-  + ``Ptr{Void}`` (you may need to use ``cfunction`` explicitly to create this pointer)
+  + ``Ptr{Void}`` (you may need to use :func:`cfunction` explicitly to create this pointer)
 
 Passing Pointers for Modifying Inputs
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Because C doesn't support multiple return values,
 often C functions will take pointers to data that the function will modify.
-To accomplish this within a ``ccall``,
+To accomplish this within a :func:`ccall`,
 you need to first encapsulate the value inside an ``Ref{T}`` of the appropriate type.
 When you pass this ``Ref`` object as an argument,
-julia will automatically pass a C pointer to the encapsulated data::
+Julia will automatically pass a C pointer to the encapsulated data::
 
     width = Ref{Cint}(0)
     range = Ref{Cfloat}(0)
@@ -678,9 +718,9 @@ they act like zero-dimensional arrays.
 Special Reference Syntax for ccall (deprecated):
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    The ``&`` syntax is deprecated, use the ``Ref{T}`` argument type instead
+The ``&`` syntax is deprecated, use the ``Ref{T}`` argument type instead.
 
-A prefix ``&`` is used on an argument to ccall to indicate that a pointer
+A prefix ``&`` is used on an argument to :func:`ccall` to indicate that a pointer
 to a scalar argument should be passed instead of the scalar value itself
 (required for all Fortran function arguments, as noted above). The following
 example computes a dot product using a BLAS function.
@@ -709,14 +749,125 @@ any expression, such as ``&0`` or ``&f(x)``.
 When a scalar value is passed with ``&`` as an argument of type
 ``Ptr{T}``, the value will first be converted to type ``T``.
 
+Some Examples of C Wrappers
+---------------------------
+
+Here is a simple example of a C wrapper that returns a ``Ptr`` type::
+
+    type gsl_permutation
+    end
+
+    # The corresponding C signature is
+    #     gsl_permutation * gsl_permutation_alloc (size_t n);
+    function permutation_alloc(n::Integer)
+        output_ptr = ccall(
+            (:gsl_permutation_alloc, :libgsl), #name of C function and library
+            Ptr{gsl_permutation},              #output type
+            (Csize_t,),                        #tuple of input types
+            n                                  #name of Julia variable to pass in
+        )
+        if output_ptr==C_NULL #Could not allocate memory
+            throw(MemoryError())
+        end
+        return output_ptr
+    end
+
+The `GNU Scientific Library <https://www.gnu.org/software/gsl/>`_ (here assumed
+to be accessible through ``:libgsl``) defines an opaque pointer,
+``gsl_permutation *``, as the return type of the C function
+``gsl_permutation_alloc()``. As user code never has to look inside the
+``gsl_permutation`` struct, the corresponding Julia wrapper simply needs a new
+type declaration, ``gsl_permutation``, that has no internal fields and whose
+sole purpose is to be placed in the type parameter of a ``Ptr`` type.  The
+return type of the :func:`ccall` is declared as ``Ptr{gsl_permutation}``, since the
+memory allocated and pointed to by ``output_ptr`` is controlled by C (and not
+Julia).
+
+The input ``n`` is passed by value, and so the function's input signature is
+simply declared as ``(Csize_t,)`` without any ``Ref`` or ``Ptr`` necessary.
+(If the wrapper was calling a Fortran function instead, the corresponding
+function input signature should instead be ``(Ref{Csize_t},)``, since Fortran
+variables are passed by reference.) Furthermore, ``n`` can be any type that is
+convertable to a ``Csize_t`` integer; the :func:`ccall` implicitly calls
+:func:`Base.cconvert(Csize_t, n) <cconvert>`.
+
+
+Here is a second example wrapping the corresponding destructor::
+
+    # The corresponding C signature is
+    #     void gsl_permutation_free (gsl_permutation * p);
+    function permutation_free(p::Ref{gsl_permutation})
+        ccall(
+            (:gsl_permutation_free, :libgsl), #name of C function and library
+            Void,                             #output type
+            (Ref{gsl_permutation},),          #tuple of input types
+            p                                 #name of Julia variable to pass in
+        )
+    end
+
+Here, the input ``p`` is declared to be of type ``Ref{gsl_permutation}``,
+meaning that the memory that ``p`` points to may be managed by Julia or by C.
+A pointer to memory allocated by C should be of type ``Ptr{gsl_permutation}``,
+but it is convertable using :func:`cconvert` and therefore can be used in the
+same (covariant) context of the input argument to a :func:`ccall`. A pointer to
+memory allocated by Julia must be of type ``Ref{gsl_permutation}``, to ensure
+that the memory address pointed to is valid and that Julia's garbage collector
+manages the chunk of memory pointed to correctly. Therefore, the
+``Ref{gsl_permutation}`` declaration allows pointers managed by C or Julia to
+be used.
+
+If the C wrapper never expects the user to pass pointers to memory managed by
+Julia, then using ``p::Ptr{gsl_permutation}`` for the method signature of the
+wrapper and similarly in the :func:`ccall` is also acceptable.
+
+
+Here is a third example passing Julia arrays::
+
+    # The corresponding C signature is
+    #    int gsl_sf_bessel_Jn_array (int nmin, int nmax, double x,
+    #                                double result_array[])
+    function sf_bessel_Jn_array(nmin::Integer, nmax::Integer, x::Real)
+        if nmax<nmin throw(DomainError()) end
+        result_array = Array(Cdouble, nmax-nmin+1)
+        errorcode = ccall(
+            (:gsl_sf_bessel_Jn_array, :libgsl), #name of C function and library
+            Cint,                               #output type
+            (Cint, Cint, Cdouble, Ref{Cdouble}),#tuple of input types
+            nmin, nmax, x, result_array         #names of Julia variables to pass in
+        )
+        if errorcode!= 0 error("GSL error code $errorcode") end
+        return result_array
+    end
+
+The C function wrapped returns an integer error code; the results of the actual
+evaluation of the Bessel J function populate the Julia array ``result_array``.
+This variable can only be used with corresponding input type declaration
+``Ref{Cdouble}``, since its memory is allocated and managed by
+Julia, not C. The implicit call to :func:`Base.cconvert(Ref{Cdouble},
+result_array) <cconvert>` unpacks the Julia pointer to a Julia array data
+structure into a form understandable by C.
+
+Note that for this code to work correctly, ``result_array`` must be declared to
+be of type ``Ref{Cdouble}`` and not ``Ptr{Cdouble}``. The memory is managed by
+Julia and the ``Ref`` signature alerts Julia's garbage collector to keep
+managing the memory for ``result_array`` while the :func:`ccall` executes. If
+``Ptr{Cdouble}`` were used instead, the :func:`ccall` may still work, but
+Julia's garbage collector would not be aware that the memory declared for
+``result_array`` is being used by the external C function. As a result, the
+code may produce a memory leak if ``result_array`` never gets freed by the
+garbage collector, or if the garbage collector prematurely frees
+``result_array``, the C function may end up throwing an invalid memory access
+exception.
+
+
 
 Garbage Collection Safety
 -------------------------
-When passing data to a ccall, it is best to avoid using the ``pointer()``
+When passing data to a :func:`ccall`, it is best to avoid using the :func:`pointer`
 function. Instead define a convert method and pass the variables directly to
-the ccall. ccall automatically arranges that all of its arguments will be
+the :func:`ccall`. :func:`ccall` automatically arranges that all of its arguments will be
 preserved from garbage collection until the call returns. If a C API will
-store a reference to memory allocated by Julia, after the ccall returns, you
+store a reference to memory allocated by Julia, after the :func:`ccall` returns, you
 must arrange that the object remains visible to the garbage collector. The
 suggested way to handle this is to make a global variable of type
 ``Array{Ref,1}`` to hold these values, until the C library notifies you that
@@ -724,9 +875,9 @@ it is finished with them.
 
 Whenever you have created a pointer to Julia data, you must ensure the original data
 exists until you are done with using the pointer. Many methods in Julia such as
-``unsafe_load()`` and ``bytestring()`` make copies of data instead of taking ownership
+:func:`unsafe_load` and :func:`bytestring` make copies of data instead of taking ownership
 of the buffer, so that it is safe to free (or alter) the original data without
-affecting Julia. A notable exception is ``pointer_to_array()`` which, for performance
+affecting Julia. A notable exception is :func:`pointer_to_array` which, for performance
 reasons, shares (or can be told to take ownership of) the underlying buffer.
 
 The garbage collector does not guarantee any order of finalization. That is, if ``a``
@@ -746,7 +897,7 @@ through ``eval`` as follows::
     @eval ccall(($(string("a","b")),"lib"), ...
 
 This expression constructs a name using ``string``, then substitutes this
-name into a new ``ccall`` expression, which is then evaluated. Keep in mind that
+name into a new :func:`ccall` expression, which is then evaluated. Keep in mind that
 ``eval`` only operates at the top level, so within this expression local
 variables will not be available (unless their values are substituted with
 ``$``). For this reason, ``eval`` is typically only used to form top-level
@@ -759,10 +910,10 @@ If your usage is more dynamic, use indirect calls as described in the next secti
 Indirect Calls
 --------------
 
-The first argument to ``ccall`` can also be an expression evaluated at run time.
+The first argument to :func:`ccall` can also be an expression evaluated at run time.
 In this case, the expression must evaluate to a ``Ptr``,
 which will be used as the address of the native function to call.
-This behavior occurs when the first ``ccall`` argument contains references to non-constants,
+This behavior occurs when the first :func:`ccall` argument contains references to non-constants,
 such as local variables, function arguments, or non-constant globals.
 
 For example, you might lookup the function via ``dlsym``,
@@ -790,11 +941,11 @@ then cache it in a global variable for that session. For example::
 Calling Convention
 ------------------
 
-The second argument to ``ccall`` can optionally be a calling convention
+The second argument to :func:`ccall` can optionally be a calling convention
 specifier (immediately preceding return type). Without any specifier,
 the platform-default C calling convention is used. Other supported
 conventions are: ``stdcall``, ``cdecl``, ``fastcall``, and ``thiscall``.
-For example (from base/libc.jl) we see the same ``gethostname`` ccall as above,
+For example (from ``base/libc.jl``) we see the same ``gethostname`` :func:`ccall` as above,
 but with the correct signature for Windows::
 
     hn = Array(UInt8, 256)
@@ -809,28 +960,27 @@ Accessing Global Variables
 --------------------------
 
 Global variables exported by native libraries can be accessed by name using the
-``cglobal`` function. The arguments to ``cglobal`` are a symbol specification
-identical to that used by ``ccall``, and a type describing the value stored in
+:func:`cglobal` function. The arguments to :func:`cglobal` are a symbol specification
+identical to that used by :func:`ccall`, and a type describing the value stored in
 the variable::
 
     julia> cglobal((:errno,:libc), Int32)
     Ptr{Int32} @0x00007f418d0816b8
 
 The result is a pointer giving the address of the value. The value can be
-manipulated through this pointer using ``unsafe_load`` and ``unsafe_store``.
+manipulated through this pointer using :func:`unsafe_load` and :func:`unsafe_store`.
 
 
 Accessing Data through a Pointer
 --------------------------------
 The following methods are described as "unsafe" because a bad pointer
-or type declaration can cause Julia to terminate abruptly
-(although, that's quite alike with ccall).
+or type declaration can cause Julia to terminate abruptly.
 
 Given a ``Ptr{T}``, the contents of type ``T`` can generally be copied from
 the referenced memory into a Julia object using ``unsafe_load(ptr, [index])``.
 The index argument is optional (default is 1),
 and follows the Julia-convention of 1-based indexing.
-This function is intentionally similar to the behavior of ``getindex()`` and ``setindex!()``
+This function is intentionally similar to the behavior of :func:`getindex` and :func:`setindex!`
 (e.g. ``[]`` access syntax).
 
 The return value will be a new object initialized
@@ -845,23 +995,25 @@ count, but the new reference does) to ensure the memory is not prematurely freed
 Note that if the object was not originally allocated by Julia, the new object
 will never be finalized by Julia's garbage collector.  If the ``Ptr`` itself
 is actually a ``jl_value_t*``, it can be converted back to a Julia object
-reference by ``unsafe_pointer_to_objref(ptr)``.  (Julia values ``v``
-can be converted to ``jl_value_t*`` pointers, as ``Ptr{Void}``, by calling
-``pointer_from_objref(v)``.)
+reference by :func:`unsafe_pointer_to_objref(ptr) <unsafe_pointer_to_objref>`.
+(Julia values ``v`` can be converted to ``jl_value_t*`` pointers, as
+``Ptr{Void}``, by calling :func:`pointer_from_objref(v)
+<pointer_from_objref>`.)
 
-The reverse operation (writing data to a Ptr{T}), can be performed using
-``unsafe_store!(ptr, value, [index])``.  Currently, this is only supported
+The reverse operation (writing data to a ``Ptr{T}``), can be performed using
+:func:`unsafe_store!(ptr, value, [index]) <unsafe_store!>`.  Currently, this is only supported
 for bitstypes or other pointer-free (``isbits``) immutable types.
 
 Any operation that throws an error is probably currently unimplemented
 and should be posted as a bug so that it can be resolved.
 
 If the pointer of interest is a plain-data array (bitstype or immutable), the
-function ``pointer_to_array(ptr,dims,[own])`` may be more useful. The final
-parameter should be true if Julia should "take ownership" of the underlying
-buffer and call ``free(ptr)`` when the returned ``Array`` object is finalized.
-If the ``own`` parameter is omitted or false, the caller must ensure the
-buffer remains in existence until all access is complete.
+function :func:`pointer_to_array(ptr,dims,[own]) <pointer_to_array>` may be
+more useful. The final parameter should be true if Julia should "take
+ownership" of the underlying buffer and call ``free(ptr)`` when the returned
+``Array`` object is finalized.  If the ``own`` parameter is omitted or false,
+the caller must ensure the buffer remains in existence until all access is
+complete.
 
 Arithmetic on the ``Ptr`` type in Julia (e.g. using ``+``) does not behave the
 same as C's pointer arithmetic. Adding an integer to a ``Ptr`` in Julia always
@@ -883,7 +1035,7 @@ triggered, which you'll probably just ignore) to ``SingleAsyncWork``::
 
   cb = Base.SingleAsyncWork(data -> my_real_callback(args))
 
-The callback you pass to C should only execute a ``ccall`` to
+The callback you pass to C should only execute a :func:`ccall` to
 ``:uv_async_send``, passing ``cb.handle`` as the argument.
 
 More About Callbacks
@@ -897,33 +1049,3 @@ C++
 
 Limited support for C++ is provided by the `Cpp <https://github.com/timholy/Cpp.jl>`_,
 `Clang <https://github.com/ihnorton/Clang.jl>`_, and `Cxx <https://github.com/Keno/Cxx.jl>`_ packages.
-
-Handling Operating System Variation
------------------------------------
-
-When dealing with platform libraries, it is often necessary to provide special cases
-for various platforms. The variable ``OS_NAME`` can be used to write these special
-cases. Additionally, there are several macros intended to make this easier:
-``@windows``, ``@unix``, ``@linux``, and ``@osx``. Note that linux and osx are mutually
-exclusive subsets of unix. Their usage takes the form of a ternary conditional
-operator, as demonstrated in the following examples.
-
-Simple blocks::
-
-    ccall( (@windows? :_fopen : :fopen), ...)
-
-Complex blocks::
-
-    @linux? (
-             begin
-                 some_complicated_thing(a)
-             end
-           : begin
-                 some_different_thing(a)
-             end
-           )
-
-Chaining (parentheses optional, but recommended for readability)::
-
-    @windows? :a : (@osx? :b : :c)
-
diff --git a/doc/manual/constructors.rst b/doc/manual/constructors.rst
index 15fab79f4956d..73f4398f3b70b 100644
--- a/doc/manual/constructors.rst
+++ b/doc/manual/constructors.rst
@@ -326,11 +326,6 @@ types of the arguments given to the constructor. Here are some examples:
     ERROR: MethodError: `convert` has no method matching convert(::Type{Point{T<:Real}}, ::Int64, ::Float64)
     This may have arisen from a call to the constructor Point{T<:Real}(...),
     since type constructors fall back to convert methods.
-    Closest candidates are:
-      Point{T<:Real}(::T<:Real, !Matched::T<:Real)
-      call{T}(::Type{T}, ::Any)
-      convert{T}(::Type{T}, !Matched::T)
-     in call at essentials.jl:57
 
     ## explicit T ##
 
@@ -427,12 +422,6 @@ However, other similar calls still don't work:
     ERROR: MethodError: `convert` has no method matching convert(::Type{Point{T<:Real}}, ::Float64, ::Int64)
     This may have arisen from a call to the constructor Point{T<:Real}(...),
     since type constructors fall back to convert methods.
-    Closest candidates are:
-      Point{T<:Real}(::T<:Real, !Matched::T<:Real)
-      call{T}(::Type{T}, ::Any)
-      convert{T}(::Type{T}, !Matched::T)
-      ...
-     in call at essentials.jl:57
 
 For a much more general way of making all such calls work sensibly, see
 :ref:`man-conversion-and-promotion`. At the risk
@@ -567,26 +556,24 @@ reader should consider perusing the rest of
 `rational.jl <https://github.com/JuliaLang/julia/blob/master/base/rational.jl>`_:
 it is short, self-contained, and implements an entire basic Julia type.
 
-.. _constructors-call-and-conversion:
+.. _constructors-and-conversion:
 
-Constructors, Call, and Conversion
-----------------------------------
+Constructors and Conversion
+---------------------------
 
-Technically, constructors ``T(args...)`` in Julia are implemented by
-defining new methods ``Base.call(::Type{T}, args...)`` for the
-:func:`call` function.  That is, Julia types are not functions, but
-they can be called as if they were functions (functors) via
-call overloading, just like any other Julia object.  This also means
-that you can declare more flexible constructors, e.g. constructors for
-abstract types, by instead explicitly defining ``Base.call`` methods
-using ``function`` syntax.
+Constructors ``T(args...)`` in Julia are implemented like other
+callable objects: methods are added to their types.
+The type of a type is ``Type``, so all constructor methods are
+stored in the method table for the ``Type`` type.
+This means that you can declare more flexible constructors, e.g.
+constructors for abstract types, by explicitly defining methods
+for the appropriate types.
 
 However, in some cases you could consider adding methods to
-``Base.convert`` *instead* of defining a constructor, because defining
-a :func:`convert` method *automatically* defines a corresponding
-constructor, while the reverse is not true.  That is, defining
-``Base.convert(::Type{T}, args...) = ...`` automatically defines a
-constructor ``T(args...) = ...``.
+``Base.convert`` *instead* of defining a constructor, because Julia
+falls back to calling :func:`convert` if no matching constructor
+is found. For example, if no constructor ``T(args...) = ...`` exists
+``Base.convert(::Type{T}, args...) = ...`` is called.
 
 ``convert`` is used extensively throughout Julia whenever one type
 needs to be converted to another (e.g. in assignment, ``ccall``,
@@ -631,13 +618,13 @@ For example, when ``T`` is ``Int32``, we would like ``S`` to be ``Int64``.
 Therefore we want to avoid an interface that allows the user to construct
 instances of the type ``SummedArray{Int32,Int32}``.
 One way to do this is to provide only an outer constructor for ``SummedArray``.
-This can be done using explicit ``call`` overloading::
+This can be done using method definition by type::
 
     type SummedArray{T<:Number,S<:Number}
         data::Vector{T}
         sum::S
 
-        function call{T}(::Type{SummedArray}, a::Vector{T})
+        function (::Type{SummedArray}){T}(a::Vector{T})
             S = widen(T)
             new{T,S}(a, sum(S, a))
         end
diff --git a/doc/manual/control-flow.rst b/doc/manual/control-flow.rst
index 143f0de971bf7..fb555629c67ac 100644
--- a/doc/manual/control-flow.rst
+++ b/doc/manual/control-flow.rst
@@ -483,8 +483,8 @@ See :ref:`man-variables-and-scoping` for a detailed
 explanation of variable scope and how it works in Julia.
 
 In general, the ``for`` loop construct can iterate over any container.
-In these cases, the alternative (but fully equivalent) keyword ``in`` is
-typically used instead of ``=``, since it makes the code read more
+In these cases, the alternative (but fully equivalent) keyword ``in``
+or ``∈`` is typically used instead of ``=``, since it makes the code read more
 clearly:
 
 .. doctest::
@@ -496,7 +496,7 @@ clearly:
     4
     0
 
-    julia> for s in ["foo","bar","baz"]
+    julia> for s ∈ ["foo","bar","baz"]
              println(s)
            end
     foo
diff --git a/doc/manual/conversion-and-promotion.rst b/doc/manual/conversion-and-promotion.rst
index 89412562dc5d1..103f41fd2750e 100644
--- a/doc/manual/conversion-and-promotion.rst
+++ b/doc/manual/conversion-and-promotion.rst
@@ -97,13 +97,13 @@ requested conversion:
 .. doctest::
 
     julia> convert(AbstractFloat, "foo")
-    ERROR: MethodError: `convert` has no method matching convert(::Type{AbstractFloat}, ::ASCIIString)
+    ERROR: MethodError: Cannot `convert` an object of type ASCIIString to an object of type AbstractFloat
     This may have arisen from a call to the constructor AbstractFloat(...),
     since type constructors fall back to convert methods.
     Closest candidates are:
-      call{T}(::Type{T}, ::Any)
-      convert(::Type{AbstractFloat}, !Matched::Bool)
-      convert(::Type{AbstractFloat}, !Matched::Int8)
+      convert(::Type{AbstractFloat}, ::Bool)
+      convert(::Type{AbstractFloat}, ::Int8)
+      convert(::Type{AbstractFloat}, ::Int16)
       ...
 
 Some languages consider parsing strings as numbers or formatting
diff --git a/doc/manual/documentation.rst b/doc/manual/documentation.rst
index dfedbaa52e002..78eccc078ebbb 100644
--- a/doc/manual/documentation.rst
+++ b/doc/manual/documentation.rst
@@ -70,7 +70,7 @@ example:
     arguments, i.e. `*(x,y,z...)`.
     """
     function *(x, y)
-      # ... [implementation sold seperately] ...
+      # ... [implementation sold separately] ...
     end
 
     "When applied to strings, concatenates them."
@@ -123,6 +123,27 @@ Or for use with Julia's metaprogramming functionality:
     @doc "`add(a,b)` adds `a` and `b` together" add
     @doc "`subtract(a,b)` subtracts `b` from `a`" subtract
 
+Documentation written in non-toplevel blocks, such as ``if``, ``for``, and ``let``, are not
+automatically added to the documentation system. ``@doc`` must be used in these cases. For
+example:
+
+.. code-block:: julia
+
+    if VERSION > v"0.4"
+        "..."
+        f(x) = x
+    end
+
+will not add any documentation to ``f`` even when the condition is ``true`` and must instead
+be written as:
+
+.. code-block:: julia
+
+    if VERSION > v"0.4"
+        @doc "..." ->
+        f(x) = x
+    end
+
 Syntax Guide
 ------------
 
@@ -185,6 +206,23 @@ Adds docstring ``"..."`` to ``Method`` ``f(::Any)``.
 
 Adds docstring ``"..."`` to two ``Method``\ s, namely ``f(::Any)`` and ``f(::Any, ::Any)``.
 
+Macros
+~~~~~~
+
+.. code-block:: julia
+
+    "..."
+    macro m(x) end
+
+Adds docstring ``"..."`` to the ``@m(::Any)`` macro definition.
+
+.. code-block:: julia
+
+    "..."
+    :(@m)
+
+Adds docstring ``"..."`` to the macro named ``@m``.
+
 Types
 ~~~~~
 
@@ -224,20 +262,6 @@ Adds docstring ``"..."`` to the ``Binding`` ``A``.
 ``Binding``\ s are used to store a reference to a particular ``Symbol`` in a ``Module``
 without storing the referenced value itself.
 
-Macros
-~~~~~~
-
-.. code-block:: julia
-
-    "..."
-    macro m() end
-
-    "..."
-    :(@m)
-
-Adds docstring ``"..."`` to the ``Binding`` ``@m``. Adding documentation at the definition
-is the preferred approach.
-
 Modules
 ~~~~~~~
 
@@ -265,7 +289,7 @@ is the preferred syntax, however both are equivalent.
 
     baremodule M
 
-    import Base: call, @doc
+    import Base: @doc
 
     "..."
     f(x) = x
@@ -273,7 +297,7 @@ is the preferred syntax, however both are equivalent.
     end
 
 Documenting a ``baremodule`` by placing a docstring above the expression automatically
-imports ``call`` and ``@doc`` into the module. These imports must be done manually when the
+imports ``@doc`` into the module. These imports must be done manually when the
 module expression is not documented. Empty ``baremodule``\ s cannot be documented.
 
 Global Variables
@@ -330,10 +354,35 @@ Macro-generated code
     "..."
     @m expression
 
-Adds docstring ``"..."`` to expression generated by expanding ``@m expression``. This syntax
-is only valid if expanding ``@m`` results in a single expression that can be documented.
-This allows for functions decorated with ``@inline``, ``@noinline``, and ``@generated`` to
-be documented in the same way as other functions.
+Adds docstring ``"..."`` to expression generated by expanding ``@m expression``. This allows
+for expressions decorated with ``@inline``, ``@noinline``, ``@generated``, or any other
+macro to be documented in the same way as undecorated expressions.
+
+Macro authors should take note that only macros that generate a single expression will
+automatically support docstrings. If a macro returns a block containing multiple
+subexpressions then the subexpression that should be documented must be marked using the
+:func:`@__doc__` macro.
+
+The ``@enum`` macro makes use of ``@__doc__`` to allow for documenting ``Enum``\ s.
+Examining it's definition should serve as an example of how to use ``@__doc__`` correctly.
+
+.. function:: @__doc__(ex)
+
+   .. Docstring generated from Julia source
+
+   Low-level macro used to mark expressions returned by a macro that should be documented. If more than one expression is marked then the same docstring is applied to each expression.
+
+   .. code-block:: julia
+
+       macro example(f)
+           quote
+               $(f)() = 0
+               @__doc__ $(f)(x) = 1
+               $(f)(x, y) = 2
+           end |> esc
+       end
+
+   ``@__doc__`` has no effect when a macro that uses it is not documented.
 
 Markdown Syntax Notes
 ---------------------
diff --git a/doc/manual/embedding.rst b/doc/manual/embedding.rst
index 4c6dc3c3256fe..4e7bd23d231cd 100644
--- a/doc/manual/embedding.rst
+++ b/doc/manual/embedding.rst
@@ -29,13 +29,15 @@ We start with a simple C program that initializes Julia and calls some Julia cod
            julia time to cleanup pending write requests
            and run all finalizers
       */
-      jl_atexit_hook();
+      jl_atexit_hook(0);
       return 0;
   }
 
 In order to build this program you have to put the path to the Julia header into the include path and link against ``libjulia``. For instance, when Julia is installed to ``$JULIA_DIR``, one can compile the above test program ``test.c`` with ``gcc`` using::
 
-    gcc -o test -I$JULIA_DIR/include/julia -L$JULIA_DIR/usr/lib -ljulia test.c
+    gcc -o test -fPIC -I$JULIA_DIR/include/julia -L$JULIA_DIR/lib/julia test.c -ljulia $JULIA_DIR/lib/julia/libstdc++.so.6
+
+Then if the environment variable ``JULIA_HOME`` is set to ``$JULIA_DIR/bin``, the output ``test`` program can be executed.
 
 Alternatively, look at the ``embedding.c`` program in the Julia source tree in the ``examples/`` folder. The file ``ui/repl.c`` program is another simple example of how to set ``jl_options`` options while linking against ``libjulia``.
 
@@ -73,7 +75,7 @@ now **JULIA_INIT_DIR** which is defined by *julia-config.jl*.::
   {
      jl_init(JULIA_INIT_DIR);
      (void)jl_eval_string("println(sqrt(2.0))");
-     jl_atexit_hook();
+     jl_atexit_hook(0);
      return 0;
   }
 
diff --git a/doc/manual/faq.rst b/doc/manual/faq.rst
index 06023948b336d..36f1a94c3b8be 100644
--- a/doc/manual/faq.rst
+++ b/doc/manual/faq.rst
@@ -59,16 +59,30 @@ I passed an argument ``x`` to a function, modified it inside that function, but
 Suppose you call a function like this::
 
 	julia> x = 10
-	julia> function change_value!(y) # Create a new function
+        10
+
+	julia> function change_value!(y)
 	           y = 17
 	       end
+        change_value! (generic function with 1 method)
+
 	julia> change_value!(x)
+        17
+
 	julia> x # x is unchanged!
 	10
 
-In Julia, any function (including ``change_value!()``) can't change the binding of a local variable. If ``x`` (in the calling scope) is bound to a immutable object (like a real number), you can't modify the object; likewise, if x is bound in the calling scope to a Dict, you can't change it to be bound to an ASCIIString.
+In Julia, the binding of a variable ``x`` cannot be changed by passing
+``x`` as an argument to a function. When calling ``change_value!(x)``
+in the above example, ``y`` is a newly created variable, bound
+initially to the value of ``x``, i.e. ``10``; then ``y`` is rebound to
+the constant ``17``, while the variable ``x`` of the outer scope is
+left untouched.
 
-But here is a thing you should pay attention to: suppose ``x`` is bound to an Array (or any other mutable type). You cannot "unbind" ``x`` from this Array. But, since an Array is a *mutable* type, you can change its content. For example::
+But here is a thing you should pay attention to: suppose ``x`` is
+bound to an object of type ``Array`` (or any other *mutable* type).
+From within the function, you cannot "unbind" ``x`` from this Array,
+but you can change its content. For example::
 
 	julia> x = [1,2,3]
 	3-element Array{Int64,1}:
@@ -76,17 +90,26 @@ But here is a thing you should pay attention to: suppose ``x`` is bound to an Ar
 	2
 	3
 
-	julia> function change_array!(A) # Create a new function
+	julia> function change_array!(A)
 	           A[1] = 5
 	       end
+        change_array! (generic function with 1 method)
+
 	julia> change_array!(x)
+        5
+
 	julia> x
 	3-element Array{Int64,1}:
 	5
 	2
 	3
 
-Here we created a function ``change_array!()``, that assigns ``5`` to the first element of the Array. We passed ``x`` (which was previously bound to an Array) to the function. Notice that, after the function call, ``x`` is still bound to the same Array, but the content of that Array changed.
+Here we created a function ``change_array!()``, that assigns ``5`` to
+the first element of the passed array (bound to ``x`` at the call
+site, and bound to ``A`` within the function). Notice that, after the
+function call, ``x`` is still bound to the same array, but the content
+of that array changed: the variables ``A`` and ``x`` were distinct
+bindings refering to the same mutable ``Array`` object.
 
 
 Can I use ``using`` or ``import`` inside a function?
@@ -128,8 +151,8 @@ inside a specific function or set of functions, you have two options:
 What does the ``...`` operator do?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The two uses of the `...` operator: slurping and splatting
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The two uses of the ``...`` operator: slurping and splatting
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Many newcomers to Julia find the use of ``...`` operator confusing. Part of
 what makes the ``...`` operator confusing is that it means two different things
@@ -447,306 +470,6 @@ in the future, we could consider defaulting to checked integer arithmetic in
 Julia, but for now, we have to live with the possibility of overflow.
 
 
-.. _man-abstract-fields:
-
-How do "abstract" or ambiguous fields in types interact with the compiler?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Types can be declared without specifying the types of their fields:
-
-.. doctest::
-
-    julia> type MyAmbiguousType
-               a
-           end
-
-This allows ``a`` to be of any type. This can often be useful, but it
-does have a downside: for objects of type ``MyAmbiguousType``, the
-compiler will not be able to generate high-performance code.  The
-reason is that the compiler uses the types of objects, not their
-values, to determine how to build code. Unfortunately, very little can
-be inferred about an object of type ``MyAmbiguousType``:
-
-.. doctest::
-
-    julia> b = MyAmbiguousType("Hello")
-    MyAmbiguousType("Hello")
-
-    julia> c = MyAmbiguousType(17)
-    MyAmbiguousType(17)
-
-    julia> typeof(b)
-    MyAmbiguousType
-
-    julia> typeof(c)
-    MyAmbiguousType
-
-``b`` and ``c`` have the same type, yet their underlying
-representation of data in memory is very different. Even if you stored
-just numeric values in field ``a``, the fact that the memory
-representation of a ``UInt8`` differs from a ``Float64`` also means
-that the CPU needs to handle them using two different kinds of
-instructions.  Since the required information is not available in the
-type, such decisions have to be made at run-time. This slows
-performance.
-
-You can do better by declaring the type of ``a``. Here, we are focused
-on the case where ``a`` might be any one of several types, in which
-case the natural solution is to use parameters. For example:
-
-.. doctest::
-
-    julia> type MyType{T<:AbstractFloat}
-             a::T
-           end
-
-This is a better choice than
-
-.. doctest::
-
-    julia> type MyStillAmbiguousType
-             a::AbstractFloat
-           end
-
-because the first version specifies the type of ``a`` from the type of
-the wrapper object.  For example:
-
-.. doctest::
-
-    julia> m = MyType(3.2)
-    MyType{Float64}(3.2)
-
-    julia> t = MyStillAmbiguousType(3.2)
-    MyStillAmbiguousType(3.2)
-
-    julia> typeof(m)
-    MyType{Float64}
-
-    julia> typeof(t)
-    MyStillAmbiguousType
-
-The type of field ``a`` can be readily determined from the type of
-``m``, but not from the type of ``t``.  Indeed, in ``t`` it's possible
-to change the type of field ``a``:
-
-.. doctest::
-
-    julia> typeof(t.a)
-    Float64
-
-    julia> t.a = 4.5f0
-    4.5f0
-
-    julia> typeof(t.a)
-    Float32
-
-In contrast, once ``m`` is constructed, the type of ``m.a`` cannot
-change:
-
-.. doctest::
-
-    julia> m.a = 4.5f0
-    4.5
-
-    julia> typeof(m.a)
-    Float64
-
-The fact that the type of ``m.a`` is known from ``m``'s type---coupled
-with the fact that its type cannot change mid-function---allows the
-compiler to generate highly-optimized code for objects like ``m`` but
-not for objects like ``t``.
-
-Of course, all of this is true only if we construct ``m`` with a
-concrete type.  We can break this by explicitly constructing it with
-an abstract type:
-
-.. doctest::
-
-    julia> m = MyType{AbstractFloat}(3.2)
-    MyType{AbstractFloat}(3.2)
-
-    julia> typeof(m.a)
-    Float64
-
-    julia> m.a = 4.5f0
-    4.5f0
-
-    julia> typeof(m.a)
-    Float32
-
-For all practical purposes, such objects behave identically to those
-of ``MyStillAmbiguousType``.
-
-It's quite instructive to compare the sheer amount code generated for
-a simple function
-::
-
-    func(m::MyType) = m.a+1
-
-using
-::
-
-    code_llvm(func,(MyType{Float64},))
-    code_llvm(func,(MyType{AbstractFloat},))
-    code_llvm(func,(MyType,))
-
-For reasons of length the results are not shown here, but you may wish
-to try this yourself. Because the type is fully-specified in the first
-case, the compiler doesn't need to generate any code to resolve the
-type at run-time.  This results in shorter and faster code.
-
-
-.. _man-abstract-container-type:
-
-How should I declare "abstract container type" fields?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The same best practices that apply in the `previous section
-<#man-abstract-fields>`_ also work for container types:
-
-.. doctest::
-
-    julia> type MySimpleContainer{A<:AbstractVector}
-             a::A
-           end
-
-    julia> type MyAmbiguousContainer{T}
-             a::AbstractVector{T}
-           end
-
-For example:
-
-.. doctest::
-
-    julia> c = MySimpleContainer(1:3);
-
-    julia> typeof(c)
-    MySimpleContainer{UnitRange{Int64}}
-
-    julia> c = MySimpleContainer([1:3;]);
-
-    julia> typeof(c)
-    MySimpleContainer{Array{Int64,1}}
-
-    julia> b = MyAmbiguousContainer(1:3);
-
-    julia> typeof(b)
-    MyAmbiguousContainer{Int64}
-
-    julia> b = MyAmbiguousContainer([1:3;]);
-
-    julia> typeof(b)
-    MyAmbiguousContainer{Int64}
-
-For ``MySimpleContainer``, the object is fully-specified by its type
-and parameters, so the compiler can generate optimized functions. In
-most instances, this will probably suffice.
-
-While the compiler can now do its job perfectly well, there are cases
-where *you* might wish that your code could do different things
-depending on the *element type* of ``a``.  Usually the best way to
-achieve this is to wrap your specific operation (here, ``foo``) in a
-separate function::
-
-    function sumfoo(c::MySimpleContainer)
-        s = 0
-	for x in c.a
-	    s += foo(x)
-	end
-	s
-    end
-
-    foo(x::Integer) = x
-    foo(x::AbstractFloat) = round(x)
-
-This keeps things simple, while allowing the compiler to generate
-optimized code in all cases.
-
-However, there are cases where you may need to declare different
-versions of the outer function for different element types of
-``a``. You could do it like this::
-
-    function myfun{T<:AbstractFloat}(c::MySimpleContainer{Vector{T}})
-        ...
-    end
-    function myfun{T<:Integer}(c::MySimpleContainer{Vector{T}})
-        ...
-    end
-
-This works fine for ``Vector{T}``, but we'd also have to write
-explicit versions for ``UnitRange{T}`` or other abstract types. To
-prevent such tedium, you can use two parameters in the declaration of
-``MyContainer``::
-
-    type MyContainer{T, A<:AbstractVector}
-        a::A
-    end
-    MyContainer(v::AbstractVector) = MyContainer{eltype(v), typeof(v)}(v)
-
-    julia> b = MyContainer(1.3:5);
-
-    julia> typeof(b)
-    MyContainer{Float64,UnitRange{Float64}}
-
-Note the somewhat surprising fact that ``T`` doesn't appear in the
-declaration of field ``a``, a point that we'll return to in a moment.
-With this approach, one can write functions such as::
-
-    function myfunc{T<:Integer, A<:AbstractArray}(c::MyContainer{T,A})
-        return c.a[1]+1
-    end
-    # Note: because we can only define MyContainer for
-    # A<:AbstractArray, and any unspecified parameters are arbitrary,
-    # the previous could have been written more succinctly as
-    #     function myfunc{T<:Integer}(c::MyContainer{T})
-
-    function myfunc{T<:AbstractFloat}(c::MyContainer{T})
-        return c.a[1]+2
-    end
-
-    function myfunc{T<:Integer}(c::MyContainer{T,Vector{T}})
-        return c.a[1]+3
-    end
-
-    julia> myfunc(MyContainer(1:3))
-    2
-
-    julia> myfunc(MyContainer(1.0:3))
-    3.0
-
-    julia> myfunc(MyContainer([1:3]))
-    4
-
-As you can see, with this approach it's possible to specialize on both
-the element type ``T`` and the array type ``A``.
-
-However, there's one remaining hole: we haven't enforced that ``A``
-has element type ``T``, so it's perfectly possible to construct an
-object like this::
-
-  julia> b = MyContainer{Int64, UnitRange{Float64}}(1.3:5);
-
-  julia> typeof(b)
-  MyContainer{Int64,UnitRange{Float64}}
-
-To prevent this, we can add an inner constructor::
-
-    type MyBetterContainer{T<:Real, A<:AbstractVector}
-        a::A
-
-        MyBetterContainer(v::AbstractVector{T}) = new(v)
-    end
-    MyBetterContainer(v::AbstractVector) = MyBetterContainer{eltype(v),typeof(v)}(v)
-
-
-    julia> b = MyBetterContainer(1.3:5);
-
-    julia> typeof(b)
-    MyBetterContainer{Float64,UnitRange{Float64}}
-
-    julia> b = MyBetterContainer{Int64, UnitRange{Float64}}(1.3:5);
-    ERROR: no method MyBetterContainer(UnitRange{Float64},)
-
-The inner constructor requires that the element type of ``A`` be ``T``.
 
 .. _faq-packages:
 
@@ -871,37 +594,35 @@ is fully asynchronous.
 The following::
 
     @sync for i in 1:3
-        @async print(i, " Foo ", " Bar ")
+        @async write(STDOUT, string(i), " Foo ", " Bar ")
     end
 
 results in::
 
     123 Foo  Foo  Foo  Bar  Bar  Bar
 
-This is happening because, while ``print(i, " Foo ", " Bar ")`` is synchronous,
-internally, the writing of each argument yields to other tasks while waiting for
-that part of the I/O to complete.
+This is happening because, while the ``write`` call is synchronous, the writing of
+each argument yields to other tasks while waiting for that part of the I/O to complete.
 
-``println`` to asynchronous streams like STDOUT, TcpSockets, "locks" the stream
-during a call. Consequently changing ``print`` to ``println`` in the above example
-results in::
+``print`` and ``println`` "lock" the stream during a call. Consequently changing ``write`` to
+``println`` in the above example results in::
 
     1 Foo  Bar
     2 Foo  Bar
     3 Foo  Bar
 
-For other functions and streams, etc, you could lock your writes with a ``ReentrantLock``
-like this::
+You can lock your writes with a ``ReentrantLock`` like this::
 
     l = ReentrantLock()
     @sync for i in 1:3
         @async begin
             lock(l)
             try
-                print(i, " Foo ", " Bar ")
+                write(STDOUT, string(i), " Foo ", " Bar ")
             finally
                 unlock(l)
             end
+        end
     end
 
 
diff --git a/doc/manual/functions.rst b/doc/manual/functions.rst
index fb20e8fa967ba..10c416e6b5611 100644
--- a/doc/manual/functions.rst
+++ b/doc/manual/functions.rst
@@ -196,7 +196,7 @@ Anonymous Functions
 
 Functions in Julia are `first-class objects
 <https://en.wikipedia.org/wiki/First-class_citizen>`_: they can be assigned to
-variables, called using the standard function call syntax from the
+variables, and called using the standard function call syntax from the
 variable they have been assigned to. They can be used as arguments, and
 they can be returned as values. They can also be created anonymously,
 without being given a name, using either of these syntaxes:
@@ -204,16 +204,19 @@ without being given a name, using either of these syntaxes:
 .. doctest::
 
     julia> x -> x^2 + 2x - 1
-    (anonymous function)
+    #1 (generic function with 1 method)
 
     julia> function (x)
                x^2 + 2x - 1
            end
-    (anonymous function)
+    #2 (generic function with 1 method)
 
-This creates an unnamed function taking one argument *x* and returning the
-value of the polynomial *x*\ ^2 + 2\ *x* - 1 at that value. The primary
-use for anonymous functions is passing them to functions which take
+This creates a function taking one argument *x* and returning the
+value of the polynomial *x*\ ^2 + 2\ *x* - 1 at that value.
+Notice that the result is a generic function, but with a
+compiler-generated name based on consecutive numbering.
+
+The primary use for anonymous functions is passing them to functions which take
 other functions as arguments. A classic example is :func:`map`,
 which applies a function to each value of an array and returns a new
 array containing the resulting values:
@@ -476,25 +479,32 @@ Keyword argument default values are evaluated only when necessary
 left-to-right order. Therefore default expressions may refer to
 prior keyword arguments.
 
+The types of keyword arguments can be made explicit as follows::
+
+    function f(;x::Int64=1)
+        ###
+    end
+
 Extra keyword arguments can be collected using ``...``, as in varargs
 functions::
 
-    function f(x; y=0, args...)
+    function f(x; y=0, kwargs...)
         ###
     end
 
-Inside ``f``, ``args`` will be a collection of ``(key,value)`` tuples,
+Inside ``f``, ``kwargs`` will be a collection of ``(key,value)`` tuples,
 where each ``key`` is a symbol. Such collections can be passed as keyword
-arguments using a semicolon in a call, e.g. ``f(x, z=1; args...)``.
+arguments using a semicolon in a call, e.g. ``f(x, z=1; kwargs...)``.
 Dictionaries can also be used for this purpose.
 
-In addition, one can also pass ``(key,value)`` tuples, or any iterable
+One can also pass ``(key,value)`` tuples, or any iterable
 expression (such as a ``=>`` pair) that can be assigned to such a
 tuple, explicitly after a semicolon.  For example, ``plot(x, y;
 (:width,2))`` and ``plot(x, y; :width => 2)`` are equivalent to
 ``plot(x, y, width=2)``.  This is useful in situations where the
 keyword name is computed at runtime.
 
+.. _man-evaluation-scope-default-values:
 
 Evaluation Scope of Default Values
 ----------------------------------
diff --git a/doc/manual/getting-started.rst b/doc/manual/getting-started.rst
index 5b31ed3079383..baef4964cab0c 100644
--- a/doc/manual/getting-started.rst
+++ b/doc/manual/getting-started.rst
@@ -18,10 +18,10 @@ command line::
                    _
        _       _ _(_)_     |  A fresh approach to technical computing
       (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
-       _ _   _| |_  __ _   |  Type "help()" to list help topics
+       _ _   _| |_  __ _   |  Type "?help" for help.
       | | | | | | |/ _` |  |
-      | | |_| | | | (_| |  |  Version 0.3.0-prerelease+3690 (2014-06-16 05:11 UTC)
-     _/ |\__'_|_|_|\__'_|  |  Commit 1b73f04* (0 days old master)
+      | | |_| | | | (_| |  |  Version 0.5.0-dev+2440 (2016-02-01 02:22 UTC)
+     _/ |\__'_|_|_|\__'_|  |  Commit 2bb94d6 (11 days old master)
     |__/                   |  x86_64-apple-darwin13.1.0
 
     julia> 1 + 2
@@ -51,19 +51,22 @@ argument to the julia command::
 
 As the example implies, the following command-line arguments to julia
 are taken as command-line arguments to the program ``script.jl``, passed
-in the global constant ``ARGS``. ``ARGS`` is also set when script code
-is given using the ``-e`` option on the command line (see the ``julia``
-help output below). For example, to just print the arguments given to a
-script, you could do this::
+in the global constant ``ARGS``. The name of the script itself is passed
+in as the global ``PROGRAM_FILE``. Note that ``ARGS`` is also set when script
+code is given using the ``-e`` option on the command line (see the ``julia``
+help output below) but ``PROGRAM_FILE`` will be empty. For example, to just
+print the arguments given to a script, you could do this::
+
+    $ julia -e 'println(PROGRAM_FILE); for x in ARGS; println(x); end' foo bar
 
-    $ julia -e 'for x in ARGS; println(x); end' foo bar
     foo
     bar
 
 Or you could put that code into a script and run it::
 
-    $ echo 'for x in ARGS; println(x); end' > script.jl
+    $ echo 'println(PROGRAM_FILE); for x in ARGS; println(x); end' > script.jl
     $ julia script.jl foo bar
+    script.jl
     foo
     bar
 
@@ -112,6 +115,7 @@ those available for the ``perl`` and ``ruby`` programs::
 
      -J, --sysimage <file>     Start up with the given system image file
      --precompiled={yes|no}    Use precompiled code from system image if available
+     --compilecache={yes|no}   Enable/disable incremental precompilation of modules
      -H, --home <dir>          Set location of julia executable
      --startup-file={yes|no}   Load ~/.juliarc.jl
      -f, --no-startup          Don't load ~/.juliarc (deprecated, use --startup-file=no)
diff --git a/doc/manual/handling-operating-system-variation.rst b/doc/manual/handling-operating-system-variation.rst
new file mode 100644
index 0000000000000..aa81937a64dc6
--- /dev/null
+++ b/doc/manual/handling-operating-system-variation.rst
@@ -0,0 +1,38 @@
+.. _man-handling-operating-system-variation:
+
+*************************************
+ Handling Operating System Variation
+*************************************
+
+When dealing with platform libraries, it is often necessary to provide special cases
+for various platforms. The variable ``OS_NAME`` can be used to write these special
+cases. There are several macros intended to make this easier: ``@windows_only``,
+``@unix_only``, ``@linux_only``, and ``@osx_only``. These may be used as follows::
+
+    @windows_only begin
+        some_complicated_thing(a)
+    end
+
+Note that ``@linux_only`` and ``@osx_only`` are mutually exclusive subsets of ``@unix_only``\ . (This
+similarly applies to ``@unix``\ .)
+Additionally, there are:``@windows``, ``@unix``, ``@linux``, and ``@osx``. Their usage takes
+the form of a ternary conditional operator, as demonstrated in the following examples.
+
+Simple blocks::
+
+    ccall( (@windows? :_fopen : :fopen), ...)
+
+Complex blocks::
+
+    @linux? (
+             begin
+                 some_complicated_thing(a)
+             end
+           : begin
+                 some_different_thing(a)
+             end
+           )
+
+Chaining (parentheses optional, but recommended for readability)::
+
+    @windows? :a : (@osx? :b : :c)
diff --git a/doc/manual/index.rst b/doc/manual/index.rst
index 960ee6f387d65..415b9e30bd0ae 100644
--- a/doc/manual/index.rst
+++ b/doc/manual/index.rst
@@ -32,9 +32,11 @@
    interacting-with-julia
    running-external-programs
    calling-c-and-fortran-code
+   handling-operating-system-variation
    embedding
    packages
    profile
+   stacktraces
    performance-tips
    style-guide
    faq
diff --git a/doc/manual/integers-and-floating-point-numbers.rst b/doc/manual/integers-and-floating-point-numbers.rst
index 0394600d259cd..cbbd1c1b10823 100644
--- a/doc/manual/integers-and-floating-point-numbers.rst
+++ b/doc/manual/integers-and-floating-point-numbers.rst
@@ -30,7 +30,7 @@ The following are Julia's primitive numeric types:
 
 ================  =======  ==============  ============== ==================
 Type              Signed?  Number of bits  Smallest value Largest value
-----------------  -------  --------------  -------------- ------------------
+================  =======  ==============  ============== ==================
 :class:`Int8`        ✓         8            -2^7             2^7 - 1
 :class:`UInt8`                 8             0               2^8 - 1
 :class:`Int16`       ✓         16           -2^15            2^15 - 1
@@ -48,7 +48,7 @@ Type              Signed?  Number of bits  Smallest value Largest value
 
 ================ ========= ==============
 Type             Precision Number of bits
----------------- --------- --------------
+================ ========= ==============
 :class:`Float16` half_          16
 :class:`Float32` single_        32
 :class:`Float64` double_        64
@@ -512,7 +512,7 @@ presented in the `IEEE 754 standard <https://en.wikipedia.org/wiki/IEEE_754-2008
     julia> 1.1 + 0.1
     1.2000000000000002
 
-    julia> with_rounding(Float64,RoundDown) do
+    julia> setrounding(Float64,RoundDown) do
            1.1 + 0.1
            end
     1.2
@@ -619,26 +619,25 @@ However, type promotion between the primitive types above and
 
 The default precision (in number of bits of the significand) and
 rounding mode of :class:`BigFloat` operations can be changed globally
-by calling :func:`set_bigfloat_precision` and
-:func:`set_rounding`, and all further calculations will take
+by calling :func:`setprecision` and
+:func:`setrounding`, and all further calculations will take
 these changes in account.  Alternatively, the precision or the
 rounding can be changed only within the execution of a particular
-block of code by :func:`with_bigfloat_precision` or
-:func:`with_rounding`:
+block of code by using the same functions with a ``do`` block:
 
 .. doctest::
 
-    julia> with_rounding(BigFloat,RoundUp) do
+    julia> setrounding(BigFloat, RoundUp) do
            BigFloat(1) + parse(BigFloat, "0.1")
            end
     1.100000000000000000000000000000000000000000000000000000000000000000000000000003
 
-    julia> with_rounding(BigFloat,RoundDown) do
+    julia> setrounding(BigFloat, RoundDown) do
            BigFloat(1) + parse(BigFloat, "0.1")
            end
     1.099999999999999999999999999999999999999999999999999999999999999999999999999986
 
-    julia> with_bigfloat_precision(40) do
+    julia> setprecision(40) do
            BigFloat(1) + parse(BigFloat, "0.1")
            end
     1.1000000000004
@@ -698,20 +697,10 @@ imply multiplication:
 .. doctest::
 
     julia> (x-1)(x+1)
-    ERROR: MethodError: `call` has no method matching call(::Int64, ::Int64)
-    Closest candidates are:
-      Union(!Matched::Any...)
-      BoundsError()
-      BoundsError(!Matched::Any...)
-      ...
+    ERROR: MethodError: `Int64` has no method matching Int64(::Int64)
 
     julia> x(x+1)
-    ERROR: MethodError: `call` has no method matching call(::Int64, ::Int64)
-    Closest candidates are:
-      Union(!Matched::Any...)
-      BoundsError()
-      BoundsError(!Matched::Any...)
-      ...
+    ERROR: MethodError: `Int64` has no method matching Int64(::Int64)
 
 Both expressions are interpreted as function application: any
 expression that is not a numeric literal, when immediately followed by a
@@ -755,7 +744,7 @@ specified type or the type of a given variable.
 
 ====================== =====================================================
 Function               Description
----------------------- -----------------------------------------------------
+====================== =====================================================
 :func:`zero(x) <zero>` Literal zero of type ``x`` or type of variable ``x``
 :func:`one(x) <one>`   Literal one of type ``x`` or type of variable ``x``
 ====================== =====================================================
@@ -778,4 +767,3 @@ Examples:
 
     julia> one(BigFloat)
     1.000000000000000000000000000000000000000000000000000000000000000000000000000000
-
diff --git a/doc/manual/interacting-with-julia.rst b/doc/manual/interacting-with-julia.rst
index 95fd9fba82cc8..dc06060970fc2 100644
--- a/doc/manual/interacting-with-julia.rst
+++ b/doc/manual/interacting-with-julia.rst
@@ -229,3 +229,26 @@ and get a list of LaTeX matches as well::
     \hbar             \hermitconjmatrix  \hkswarow          \hookrightarrow    \hspace
 
 A full list of tab-completions can be found in the :ref:`man-unicode-input` section of the manual.
+
+
+Customizing Colors
+~~~~~~~~~~~~~~~~~~
+
+The colors used by Julia and the REPL can be customized, as well. To change the color of the Julia
+prompt you can add something like the following to your ``juliarc.jl`` file::
+
+    Base.active_repl.prompt_color = Base.text_colors[:cyan]
+
+The available color keys in ``Base.text_colors`` are ``:black``, ``:red``, ``:green``, ``:yellow``,
+``:blue``, ``:magenta``, ``:cyan``, ``:white``, ``:normal``, and ``:bold``. Similarly, you can
+change the colors for the help and shell prompts and input and answer text by setting the
+appropriate member of ``Base.active_repl`` (respectively, ``help_color``, ``shell_color``,
+``input_color``, and ``answer_color``). For the latter two, be sure that the ``envcolors`` member
+is also set to false.
+
+You can also customize the color used to render warning and informational messages by
+setting the appropriate environment variable. For instance, to render warning messages in yellow and
+informational messages in cyan you can add the following to your ``juliarc.jl`` file::
+
+    ENV["JULIA_WARN_COLOR"] = :yellow
+    ENV["JULIA_INFO_COLOR"] = :cyan
diff --git a/doc/manual/interfaces.rst b/doc/manual/interfaces.rst
index 94b4dbd14702f..0a21a402cd0dd 100644
--- a/doc/manual/interfaces.rst
+++ b/doc/manual/interfaces.rst
@@ -151,7 +151,7 @@ Abstract Arrays
 Methods to implement                                                                                    Brief description
 ========================================================== ============================================ =======================================================================================
 :func:`size(A) <size>`                                                                                  Returns a tuple containing the dimensions of A
-:func:`Base.linearindexing(Type) <Base.linearindexing>`                                                 Returns either ``Base.LinearFast()`` or ``Base.LinearSlow``. See the description below.
+:func:`Base.linearindexing(Type) <Base.linearindexing>`                                                 Returns either ``Base.LinearFast()`` or ``Base.LinearSlow()``. See the description below.
 :func:`getindex(A, i::Int) <getindex>`                                                                  (if ``LinearFast``) Linear scalar indexing
 :func:`getindex(A, i1::Int, ..., iN::Int) <getindex>`                                                   (if ``LinearSlow``, where ``N = ndims(A)``) N-dimensional scalar indexing
 :func:`setindex!(A, v, i::Int) <getindex>`                                                              (if ``LinearFast``) Scalar indexed assignment
@@ -256,7 +256,7 @@ Notice that this is a ``LinearSlow`` array, so we must manually define :func:`ge
      2.0  5.0  8.0
      3.0  6.0  9.0
 
-Since the ``SparseArray`` is mutable, we were able to override :func:`similar`.  This means that when a base function needs to return an array, it's able to return a new ``SparseArray``:
+The result of indexing an ``AbstractArray`` can itself be an array (for instance when indexing by a ``Range``). The ``AbstractArray`` fallback methods use :func:`similar` to allocate an ``Array`` of the appropriate size and element type, which is filled in using the basic indexing method described above. However, when implementing an array wrapper you often want the result to be wrapped as well:
 
 .. doctest::
 
@@ -265,6 +265,16 @@ Since the ``SparseArray`` is mutable, we were able to override :func:`similar`.
      1.0  4.0  7.0
      2.0  5.0  8.0
 
+In this example it is accomplished by defining ``Base.similar{T}(A::SparseArray, ::Type{T}, dims::Dims)`` to create the appropriate wrapped array. For this to work it's important that ``SparseArray`` is mutable (supports ``setindex!``). :func:`similar` is also used to allocate result arrays for arithmetic on ``AbstractArrays``, for instance:
+
+.. doctest::
+
+    julia> A + 4
+    3x3 SparseArray{Float64,2}:
+     5.0   8.0  11.0
+     6.0   9.0  12.0
+     7.0  10.0  13.0
+
 In addition to all the iterable and indexable methods from above, these types can also interact with each other and use all of the methods defined in the standard library for ``AbstractArrays``:
 
 .. doctest::
diff --git a/doc/manual/linear-algebra.rst b/doc/manual/linear-algebra.rst
index 9a227b6ebe121..47f93ef8c51b2 100644
--- a/doc/manual/linear-algebra.rst
+++ b/doc/manual/linear-algebra.rst
@@ -61,7 +61,7 @@ Elementary operations
 +-------------------------+-------+-------+-------+-------+--------------------------------+
 | Matrix type             | ``+`` | ``-`` | ``*`` | ``\`` | Other functions with           |
 |                         |       |       |       |       | optimized methods              |
-+-------------------------+-------+-------+-------+-------+--------------------------------+
++=========================+=======+=======+=======+=======+================================+
 | :class:`Hermitian`      |       |       |       |   MV  | :func:`inv`,                   |
 |                         |       |       |       |       | :func:`sqrtm`, :func:`expm`    |
 +-------------------------+-------+-------+-------+-------+--------------------------------+
@@ -126,5 +126,5 @@ Legend:
 
 The uniform scaling operator
 ----------------------------
-A :class:`UniformScaling` operator represents a scalar times the identity operator, ``λ*I``. The identity operator  :class:`I` is defined as a constant and is an instance of :class:`UniformScaling`. The size of these operators are generic and match the other matrix in the binary operations :obj:`+`, :obj:`-`, :obj:`*` and :obj:`\\`. For ``A+I`` and ``A-I`` this means that ``A`` must be square. Multiplication with the identity operator :class: `I` is a noop (except for checking that the scaling factor is one) and therefore almost without overhead.
+A :class:`UniformScaling` operator represents a scalar times the identity operator, ``λ*I``. The identity operator  :class:`I` is defined as a constant and is an instance of :class:`UniformScaling`. The size of these operators are generic and match the other matrix in the binary operations :obj:`+`, :obj:`-`, :obj:`*` and :obj:`\\`. For ``A+I`` and ``A-I`` this means that ``A`` must be square. Multiplication with the identity operator :class:`I` is a noop (except for checking that the scaling factor is one) and therefore almost without overhead.
 
diff --git a/doc/manual/mathematical-operations.rst b/doc/manual/mathematical-operations.rst
index baef2c8eb527d..fe8ee11f527b9 100644
--- a/doc/manual/mathematical-operations.rst
+++ b/doc/manual/mathematical-operations.rst
@@ -271,8 +271,8 @@ that Julia does them correctly.
 For other types, :func:`isequal` defaults to calling :func:`==`, so if you want to
 define equality for your own types then you only need to add a :func:`==`
 method.  If you define your own equality function, you should probably
-define a corresponding :func:`hash` method to ensure that `isequal(x,y)`
-implies `hash(x) == hash(y)`.
+define a corresponding :func:`hash` method to ensure that ``isequal(x,y)``
+implies ``hash(x) == hash(y)``.
 
 Chaining comparisons
 ~~~~~~~~~~~~~~~~~~~~
@@ -347,6 +347,73 @@ Control flow      ``&&`` followed by ``||`` followed by ``?``
 Assignments       ``= += -= *= /= //= \= ^= ÷= %= |= &= $= <<= >>= >>>=`` and ``.+= .-= .*= ./= .//= .\= .^= .÷= .%=``
 ================= =============================================================================================
 
+.. _man-numerical-conversions:
+
+Numerical Conversions
+---------------------
+
+Julia supports three forms of numerical conversion, which differ in their
+handling of inexact conversions.
+
+- The notation ``T(x)`` or ``convert(T,x)`` converts ``x`` to a value of type ``T``.
+
+  -  If ``T`` is a floating-point type, the result is the nearest representable
+     value, which could be positive or negative infinity.
+
+  -  If ``T`` is an integer type, an ``InexactError`` is raised if ``x``
+     is not representable by ``T``.
+
+
+- ``x % T`` converts an integer ``x`` to a value of integer type ``T``
+  congruent to ``x`` modulo ``2^n``, where ``n`` is the number of bits in ``T``.
+  In other words, the binary representation is truncated to fit.
+
+- The :ref:`man-rounding-functions` take a type ``T`` as an optional argument.
+  For example, ``round(Int,x)`` is a shorthand for ``Int(round(x))``.
+
+The following examples show the different forms.
+
+.. doctest::
+
+    julia> Int8(127)
+    127
+
+    julia> Int8(128)
+    ERROR: InexactError()
+     in call at ./essentials.jl:58
+     in eval at ./boot.jl:263
+
+    julia> Int8(127.0)
+    127
+
+    julia> Int8(3.14)
+    ERROR: InexactError()
+     in call at ./essentials.jl:58
+     in eval at ./boot.jl:263
+
+    julia> Int8(128.0)
+    ERROR: InexactError()
+     in call at ./essentials.jl:58
+     in eval at ./boot.jl:263
+
+    julia> 127 % Int8
+    127
+
+    julia> 128 % Int8
+    -128
+
+    julia> round(Int8,127.4)
+    127
+
+    julia> round(Int8,127.6)
+    ERROR: InexactError()
+     in trunc at ./float.jl:357
+     in round at ./float.jl:177
+     in eval at ./boot.jl:263
+
+See :ref:`man-conversion-and-promotion` for how to define your own
+conversions and promotions.
+
 .. _man-elementary-functions:
 
 Elementary Functions
@@ -358,6 +425,8 @@ class of numerical values as permit sensible definitions, including
 integers, floating-point numbers, rationals, and complexes, wherever
 such definitions make sense.
 
+.. _man-rounding-functions:
+
 Rounding functions
 ~~~~~~~~~~~~~~~~~~
 
diff --git a/doc/manual/metaprogramming.rst b/doc/manual/metaprogramming.rst
index ba690d5e7ca47..0b193eb099d27 100644
--- a/doc/manual/metaprogramming.rst
+++ b/doc/manual/metaprogramming.rst
@@ -242,7 +242,7 @@ Julia syntax. As an alternative, Julia allows "splicing" or interpolation
 of literals or expressions into quoted expressions. Interpolation is
 indicated by the ``$`` prefix.
 
-In this example, the literal value of `a` is interpolated:
+In this example, the literal value of ``a`` is interpolated:
 
 .. doctest::
 
@@ -535,7 +535,7 @@ Building an advanced macro
 Here is a simplified definition of Julia's :obj:`@assert` macro::
 
     macro assert(ex)
-        return :($ex ? nothing : error("Assertion failed: ", $(string(ex))))
+        return :( $ex ? nothing : throw(AssertionError($(string(ex)))) )
     end
 
 This macro can be used like this:
@@ -550,8 +550,8 @@ This macro can be used like this:
 In place of the written syntax, the macro call is expanded at parse time to
 its returned result. This is equivalent to writing::
 
-    1==1.0 ? nothing : error("Assertion failed: ", "1==1.0")
-    1==0 ? nothing : error("Assertion failed: ", "1==0")
+    1==1.0 ? nothing : throw(AssertionError("1==1.0"))
+    1==0 ? nothing : throw(AssertionError("1==0"))
 
 That is, in the first call, the expression ``:(1==1.0)`` is spliced into
 the test condition slot, while the value of ``string(:(1==1.0))`` is
@@ -572,8 +572,8 @@ ellipses following the last argument::
 
     macro assert(ex, msgs...)
         msg_body = isempty(msgs) ? ex : msgs[1]
-        msg = string("assertion failed: ", msg_body)
-        return :($ex ? nothing : error($msg))
+        msg = string(msg_body)
+        return :($ex ? nothing : throw(AssertionError($msg)))
     end
 
 Now :obj:`@assert` has two modes of operation, depending upon the number of
@@ -961,7 +961,7 @@ function is generated is really an implementation detail; it *might* be only
 once, but it *might* also be more often. As a consequence, you should
 *never* write a generated function with side effects - when, and how often,
 the side effects occur is undefined. (This is true for macros too - and just
-like for macros, the use of `eval` in a generated function is a sign that
+like for macros, the use of :func:`eval` in a generated function is a sign that
 you're doing something the wrong way.)
 
 The example generated function ``foo`` above did not do anything a normal
@@ -1017,12 +1017,12 @@ These examples are hopefully helpful to illustrate how generated functions
 work, both in the definition end and at the call site; however, *don't
 copy them*, for the following reasons:
 
-* the `foo` function has side-effects, and it is undefined exactly when,
+* the ``foo`` function has side-effects, and it is undefined exactly when,
   how often or how many times these side-effects will occur
-* the `bar` function solves a problem that is better solved with multiple
-  dispatch - defining `bar(x) = x` and `bar(x::Integer) = x^2` will do
+* the ``bar`` function solves a problem that is better solved with multiple
+  dispatch - defining ``bar(x) = x`` and ``bar(x::Integer) = x^2`` will do
   the same thing, but it is both simpler and faster.
-* the `baz` function is pathologically insane
+* the ``baz`` function is pathologically insane
 
 Instead, now that we have a better understanding for how generated functions
 work, let's use them to build some more advanced functionality...
@@ -1036,7 +1036,7 @@ indices - in other words, to calculate the index ``i`` that can be used to
 index into an array ``A`` using ``A[i]``, instead of ``A[x,y,z,...]``. One
 possible implementation is the following::
 
-    function sub2ind_loop(dims::NTuple{N}, I::Integer...)
+    function sub2ind_loop{N}(dims::NTuple{N}, I::Integer...)
         ind = I[N] - 1
         for i = N-1:-1:1
             ind = I[i]-1 + dims[i]*ind
diff --git a/doc/manual/methods.rst b/doc/manual/methods.rst
index ac7898ee55305..9b6dd768228d1 100644
--- a/doc/manual/methods.rst
+++ b/doc/manual/methods.rst
@@ -54,7 +54,7 @@ for structuring and organizing programs.
 
 .. [#] In C++ or Java, for example, in a method call like
   ``obj.meth(arg1,arg2)``, the object obj "receives" the method call and is
-  implicitly passed to the method via the ``this`` keyword, rather then as an
+  implicitly passed to the method via the ``this`` keyword, rather than as an
   explicit method argument. When the current ``this`` object is the receiver of a
   method call, it can be omitted altogether, writing just ``meth(arg1,arg2)``,
   with ``this`` implied as the receiving object.
@@ -585,30 +585,41 @@ In particular, they do not participate in method dispatch. Methods are
 dispatched based only on positional arguments, with keyword arguments processed
 after the matching method is identified.
 
-Call overloading and function-like objects
-------------------------------------------
+Function-like objects
+---------------------
 
-For any arbitrary Julia object ``x`` other than ``Function`` objects
-(defined via ``function`` syntax), ``x(args...)`` is equivalent to
-``call(x, args...)``, where :func:`call` is a generic function in
-the Julia ``Base`` module.   By adding new methods to ``call``, you
-can add a function-call syntax to arbitrary Julia types.   (Such
-"callable" objects are sometimes called "functors.")
+Methods are associated with types, so it is possible to make any arbitrary
+Julia object "callable" by adding methods to its type.
+(Such "callable" objects are sometimes called "functors.")
 
-For example, if you want to make ``x(arg)`` equivalent to ``x * arg`` for
-``x::Number``, you can define::
+For example, you can define a type that stores the coefficients of a
+polynomial, but behaves like a function evaluating the polynomial::
 
-    Base.call(x::Number, arg) = x * arg
+    immutable Polynomial{R}
+        coeffs::Vector{R}
+    end
+
+    function (p::Polynomial)(x)
+        v = p.coeffs[end]
+        for i = (length(p.coeffs)-1):-1:1
+            v = v*x + p.coeffs[i]
+        end
+        return v
+    end
 
-at which point you can do::
+Notice that the function is specified by type instead of by name.
+In the function body, ``p`` will refer to the object that was called.
+A ``Polynomial`` can be used as follows::
 
-    x = 7
-    x(10)
+    julia> p = Polynomial([1,10,100])
+    Polynomial{Int64}([1,10,100])
 
-to get ``70``.
+    julia> p(3)
+    931
 
-``call`` overloading is also used extensively for type constructors in
-Julia, discussed :ref:`later in the manual <constructors-call-and-conversion>`.
+This mechanism is also the key to how type constructors and closures
+(inner functions that refer to their surrounding environment) work
+in Julia, discussed :ref:`later in the manual <constructors-and-conversion>`.
 
 Empty generic functions
 -----------------------
diff --git a/doc/manual/modules.rst b/doc/manual/modules.rst
index 6b988f50d80ad..e8f8ca26462a8 100644
--- a/doc/manual/modules.rst
+++ b/doc/manual/modules.rst
@@ -6,12 +6,14 @@
 
 .. index:: module, baremodule, using, import, export, importall
 
-Modules in Julia are separate global variable workspaces. They are
-delimited syntactically, inside ``module Name ... end``. Modules allow
-you to create top-level definitions without worrying about name conflicts
-when your code is used together with somebody else's. Within a module, you
-can control which names from other modules are visible (via importing),
-and specify which of your names are intended to be public (via exporting).
+Modules in Julia are separate variable workspaces, i.e. they introduce
+a new global scope. They are delimited syntactically, inside ``module
+Name ... end``. Modules allow you to create top-level definitions (aka
+global variables) without worrying about name conflicts when your code
+is used together with somebody else's. Within a module, you can
+control which names from other modules are visible (via importing),
+and specify which of your names are intended to be public (via
+exporting).
 
 The following example demonstrates the major features of modules. It is
 not meant to be run, but is shown for illustrative purposes::
@@ -160,10 +162,8 @@ contain ``using Base``, since this is needed in the vast majority of cases.
 Default top-level definitions and bare modules
 ----------------------------------------------
 
-In addition to ``using Base``, modules also perform ``import Base.call`` by
-default, to facilitate adding constructors to new types.
-A new module also automatically contains a definition of the ``eval`` function,
-which evaluates expressions within the context of that module.
+In addition to ``using Base``, modules also automatically contain a definition
+of the ``eval`` function, which evaluates expressions within the context of that module.
 
 If these default definitions are not wanted, modules can be defined using the
 keyword ``baremodule`` instead (note: ``Core`` is still imported, as per above).
@@ -173,8 +173,6 @@ In terms of ``baremodule``, a standard ``module`` looks like this::
 
     using Base
 
-    import Base.call
-
     eval(x) = Core.eval(Mod, x)
     eval(m,x) = Core.eval(m, x)
 
@@ -282,6 +280,10 @@ therein.  If you know that it is *not* safe to precompile your module
 throw an error (and thereby prevent the module from being imported by
 any other precompiled module).
 
+``__precompile__()`` should *not* be used in a module unless all of its
+dependencies are also using ``__precompile__()``. Failure to do so can result
+in a runtime error when loading the module.
+
 In order to make your module work with precompilation,
 however, you may need to change your module to explicitly separate any
 initialization steps that must occur at *runtime* from steps that can
@@ -354,7 +356,7 @@ not a standalone interpreter that also generates compiled code.
 
 Other known potential failure scenarios include:
 
-1. Global counters (for example, for attempting to unique identifying objects)
+1. Global counters (for example, for attempting to uniquely identify objects)
    Consider the following code snippet::
 
     type UniquedById
@@ -419,3 +421,9 @@ A few other points to be aware of:
 
 4. WeakRef objects and finalizers are not currently handled properly by the serializer
    (this will be fixed in an upcoming release).
+
+It is sometimes helpful during module development to turn off incremental precompilation.
+The command line flag ``--compilecache={yes|no}`` enables you to toggle module precompilation on and off.
+When Julia is started with ``--compilecache=no`` the serialized modules in the compile cache are ignored when loading modules and module dependencies.
+``Base.compilecache()`` can still be called manually and it will respect ``__precompile__()`` directives for the module.
+The state of this command line flag is passed to ``Pkg.build()`` to disable automatic precompilation triggering when installing, updating, and explicitly building packages.
diff --git a/doc/manual/networking-and-streams.rst b/doc/manual/networking-and-streams.rst
index 82e534428304a..31eb0ba56c905 100644
--- a/doc/manual/networking-and-streams.rst
+++ b/doc/manual/networking-and-streams.rst
@@ -16,18 +16,24 @@ functionality.
 Basic Stream I/O
 ----------------
 
-All Julia streams expose at least a :func:`read` and a :func:`write` method, taking the stream as their first argument, e.g.::
+All Julia streams expose at least a :func:`read` and a :func:`write` method,
+taking the stream as their first argument, e.g.::
 
-    julia> write(STDOUT,"Hello World")
+    julia> write(STDOUT,"Hello World");  # suppress return value 11 with ;
     Hello World
 
     julia> read(STDIN,Char)
 
     '\n'
 
-Note that I pressed enter again so that Julia would read the newline. Now, as you can see from this example,
+Note that :func:`write` returns 11, the number of bytes (in ``"Hello World"``) written to :const:`STDOUT`,
+but this return value is suppressed with the ``;``.
+
+Here Enter was pressed again so that Julia would read the newline. Now, as you can see from this example,
 :func:`write` takes the data to write as its second argument, while :func:`read` takes the type of the
-data to be read as the second argument. For example, to read a simple byte array, we could do::
+data to be read as the second argument.
+
+For example, to read a simple byte array, we could do::
 
     julia> x = zeros(UInt8,4)
     4-element Array{UInt8,1}:
@@ -47,7 +53,7 @@ data to be read as the second argument. For example, to read a simple byte array
 However, since this is slightly cumbersome, there are several convenience methods provided. For example, we could have written the
 above as::
 
-    julia> readbytes(STDIN,4)
+    julia> read(STDIN,4)
     abcd
     4-element Array{UInt8,1}:
      0x61
@@ -80,18 +86,27 @@ or :func:`read` if you wanted to read by character instead::
 Text I/O
 --------
 
-Note that the write method mentioned above operates on binary streams. In particular, values do not get converted to any canonical text
+Note that the :func:`write` method mentioned above operates on binary streams.
+In particular, values do not get converted to any canonical text
 representation but are written out as is::
 
-    julia> write(STDOUT,0x61)
+    julia> write(STDOUT,0x61);  # suppress return value 1 with ;
     a
 
+Note that ``a`` is written to :const:`STDOUT` by the :func:`write` function and
+that the returned value is ``1`` (since ``0x61`` is one byte).
+
 For text I/O, use the :func:`print` or :func:`show` methods, depending on your needs (see the standard library reference for a detailed discussion of
 the difference between the two)::
 
     julia> print(STDOUT,0x61)
     97
 
+IO Output Contextual Properties
+-------------------------------
+
+Sometimes IO output can benefit from the ability to pass contextual information into show methods. The ``IOContext`` object provides this framework for associating arbitrary metadata with an IO object. For example, ``showlimited`` adds a hinting parameter to the IO object that the invoked show method should print a shorter output (if applicable).
+
 Working with Files
 ------------------
 
@@ -127,7 +142,7 @@ as its first argument and filename as its second, opens the file, calls the func
 an argument, and then closes it again. For example, given a function::
 
     function read_and_capitalize(f::IOStream)
-        return uppercase(readall(f))
+        return uppercase(readstring(f))
     end
 
 You can call::
@@ -141,7 +156,7 @@ To avoid even having to define a named function, you can use the ``do`` syntax,
 function on the fly::
 
     julia> open("hello.txt") do f
-              uppercase(readall(f))
+              uppercase(readstring(f))
            end
     "HELLO AGAIN."
 
@@ -169,19 +184,19 @@ specified port (2000) in this case. The same function may also be used to
 create various other kinds of servers::
 
     julia> listen(2000) # Listens on localhost:2000 (IPv4)
-    TcpServer(active)
+    TCPServer(active)
 
     julia> listen(ip"127.0.0.1",2000) # Equivalent to the first
-    TcpServer(active)
+    TCPServer(active)
 
     julia> listen(ip"::1",2000) # Listens on localhost:2000 (IPv6)
-    TcpServer(active)
+    TCPServer(active)
 
     julia> listen(IPv4(0),2001) # Listens on port 2001 on all IPv4 interfaces
-    TcpServer(active)
+    TCPServer(active)
 
     julia> listen(IPv6(0),2001) # Listens on port 2001 on all IPv6 interfaces
-    TcpServer(active)
+    TCPServer(active)
 
     julia> listen("testsocket") # Listens on a domain socket/named pipe
     PipeServer(active)
@@ -198,7 +213,7 @@ should be able to pass the same arguments to :func:`connect` as you did to liste
 establish the connection. So let's try that out (after having created the server above)::
 
     julia> connect(2000)
-    TcpSocket(open, 0 bytes waiting)
+    TCPSocket(open, 0 bytes waiting)
 
     julia> Hello World
 
@@ -218,7 +233,7 @@ A great strength of Julia is that since the API is exposed synchronously even th
     Task
 
     julia> clientside=connect(2001)
-    TcpSocket(open, 0 bytes waiting)
+    TCPSocket(open, 0 bytes waiting)
 
     julia> @async while true
               write(STDOUT,readline(clientside))
@@ -240,7 +255,7 @@ given by the ``host`` parameter on the port given by the port parameter. It
 allows you to do things like::
 
     julia> connect("google.com",80)
-    TcpSocket(open, 0 bytes waiting)
+    TCPSocket(open, 0 bytes waiting)
 
 At the base of this functionality is :func:`getaddrinfo`, which will do the appropriate address resolution::
 
diff --git a/doc/manual/noteworthy-differences.rst b/doc/manual/noteworthy-differences.rst
index 82ebc7973c380..c53d037f1d92a 100644
--- a/doc/manual/noteworthy-differences.rst
+++ b/doc/manual/noteworthy-differences.rst
@@ -98,6 +98,8 @@ some noteworthy differences that may trip up Julia users accustomed to MATLAB:
   ``ans`` is not set when Julia code is run in non-interactive mode.
 - Julia's ``type``\ s do not support dynamically adding fields at runtime,
   unlike MATLAB's ``class``\ es. Instead, use a :obj:`Dict`.
+- In Julia each module has its own global scope/namespace, whereas in
+  Matlab there is just one global scope.
 
 Noteworthy differences from R
 -----------------------------
@@ -252,6 +254,11 @@ Noteworthy differences from Python
   major (C-ordered) by default. To get optimal performance when looping over
   arrays, the order of the loops should be reversed in Julia relative to NumPy
   (see relevant section of :ref:`man-performance-tips`).
+- Julia's updating operators (e.g. ``+=``, ``-=``, ...) are *not in-place*
+  whereas NumPy's are. This means ``A = ones(4); B = A; B += 3`` doesn't change
+  values in ``A``, it rather rebinds the name ``B`` to the result of the right-
+  hand side ``B = B + 3``, which is a new array. Use ``B[:] += 3``, explicit loops,
+  or ``InplaceOps.jl``.
 - Julia evaluates default values of function arguments every time the method is
   invoked, unlike in Python where the default values are evaluated only once
   when the function is defined. For example, the function ``f(x=rand()) = x``
@@ -269,7 +276,9 @@ Noteworthy differences from C/C++
   See the Julia documentation for the syntax for array construction (it has changed between versions).
 - In Julia, indexing of arrays, strings, etc. is 1-based not 0-based.
 - Julia arrays are assigned by reference. After ``A=B``, changing elements of
-  ``B`` will modify ``A`` as well.
+  ``B`` will modify ``A`` as well. Updating operators like ``+=`` do not operate
+  in-place, they are equivalent to ``A = A + B`` which rebinds the left-hand
+  side to the result of the right-hand side expression.
 - Julia arrays are column major (Fortran ordered) whereas C/C++ arrays are row
   major ordered by default. To get optimal performance when looping over
   arrays, the order of the loops should be reversed in Julia relative to C/C++
@@ -300,7 +309,7 @@ Noteworthy differences from C/C++
   characters without quoting it like ``"\""``
   String literals can have values of other variables or expressions interpolated into them,
   indicated by ``$variablename`` or ``$(expression)``, which evaluates the variable name or the expression in the context of the function.
-- ``//`` indicates a ``Rational`` number, and not a single-line comment (which is # in Julia)
+- ``//`` indicates a ``Rational`` number, and not a single-line comment (which is ``#`` in Julia)
 - ``#=`` indicates the start of a multiline comment, and ``=#`` ends it.
 - Functions in Julia return values from their last expression(s) or the ``return``
   keyword.  Multiple values can be returned from functions and assigned as tuples, e.g.
diff --git a/doc/manual/packages.rst b/doc/manual/packages.rst
index 2202987b396d6..d4b231c466a15 100644
--- a/doc/manual/packages.rst
+++ b/doc/manual/packages.rst
@@ -130,10 +130,12 @@ Once again, this is equivalent to editing the ``REQUIRE`` file to remove the lin
 While :func:`Pkg.add` and :func:`Pkg.rm` are convenient for adding and removing requirements for a single package, when you want to add or remove multiple packages, you can call :func:`Pkg.edit` to manually change the contents of ``REQUIRE`` and then update your packages accordingly.
 :func:`Pkg.edit` does not roll back the contents of ``REQUIRE`` if :func:`Pkg.resolve` fails – rather, you have to run :func:`Pkg.edit` again to fix the files contents yourself.
 
-Because the package manager uses git internally to manage the package git repositories, users may run into protocol issues (if behind a firewall, for example), when running :func:`Pkg.add`. The following command can be run from the command line to tell git to use 'https' instead of the 'git' protocol when cloning repositories::
+Because the package manager uses git internally to manage the package git repositories, users may run into protocol issues (if behind a firewall, for example), when running :func:`Pkg.add`. By default, all GitHub-hosted packages wil be accessed via 'https'; this default can be modified by calling :func:`Pkg.setprotocol!`.  The following command can be run from the command line in order to tell git to use 'https' instead of the 'git' protocol when cloning all repositories, wherever they are hosted::
 
     git config --global url."https://".insteadOf git://
 
+However, this change will be system-wide and thus the use of :func:`Pkg.setprotocol!` is preferable.
+
 Offline Installation of Packages
 --------------------------------
 
@@ -143,7 +145,7 @@ same operating system and environment.
 
 :func:`Pkg.add` does the following within the package root directory:
 
-1. Adds the name of the package to ``INSTALLED``.
+1. Adds the name of the package to ``REQUIRE``.
 2. Downloads the package to ``.cache``, then copies the package to the package root directory.
 3. Recursively performs step 2 against all the packages listed in the package's ``REQUIRE`` file.
 4. Runs :func:`Pkg.build`
@@ -351,6 +353,7 @@ where ``USERNAME`` is your actual GitHub user name.
 Once you do this, the package manager knows your GitHub user name and can configure things accordingly.
 You should also `upload <https://github.com/settings/ssh>`_ your public SSH key to GitHub and set up an `SSH agent <http://linux.die.net/man/1/ssh-agent>`_ on your development machine so that you can push changes with minimal hassle.
 In the future, we will make this system extensible and support other common git hosting options like `BitBucket <https://bitbucket.org>`_ and allow developers to choose their favorite.
+Since the package development functions has been moved to the `PkgDev <https://github.com/JuliaLang/PkgDev.jl>`_ package, you need to run ``Pkg.add("PkgDev"); import PkgDev`` to access the functions starting with ``PkgDev.`` in the document below.
 
 Making changes to an existing package
 -------------------------------------
@@ -370,9 +373,35 @@ want to make (this is your *commit message*), and then hit "Propose
 file change."  Your changes will be submitted for consideration by the
 package owner(s) and collaborators.
 
+For larger documentation changes---and especially ones that you expect
+to have to update in response to feedback---you might find it easier
+to use the procedure for code changes described below.
+
 Code changes
 ~~~~~~~~~~~~
 
+Executive summary
+^^^^^^^^^^^^^^^^^
+
+Here we assume you've already set up git on your local machine and
+have a GitHub account (see above).  Let's imagine you're fixing a bug
+in the Images package::
+
+  Pkg.checkout("Images")           # check out the master branch
+  <here, make sure your bug is still a bug and hasn't been fixed already>
+  cd(Pkg.dir("Images"))
+  ;git checkout -b myfixes         # create a branch for your changes
+  <edit code>                      # be sure to add a test for your bug
+  Pkg.test("Images")               # make sure everything works now
+  ;git commit -a -m "Fix foo by calling bar"   # write a descriptive message
+  Pkg.submit("Images")
+
+The last line will present you with a link to submit a pull request
+to incorporate your changes.
+
+Detailed description
+^^^^^^^^^^^^^^^^^^^^
+
 If you want to fix a bug or add new functionality, you want to be able
 to test your changes before you submit them for consideration. You
 also need to have an easy way to update your proposal in response to
@@ -386,7 +415,7 @@ changes to a publicly-visible location, your own online *fork* of
 the package (hosted on your own personal GitHub account).
 
 Let's assume you already have the ``Foo`` package installed.  In the
-description below, anything starting with ``Pkg.`` is meant to be
+description below, anything starting with ``Pkg.`` or ``PkgDev.`` is meant to be
 typed at the Julia prompt; anything starting with ``git`` is meant to
 be typed in :ref:`julia's shell mode <man-shell-mode>` (or using the
 shell that comes with your operating system).  Within Julia, you can
@@ -450,7 +479,7 @@ are several possible approaches, here is one that is widely used:
 - Commit your changes: see `<http://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository>`_.
 
 - Submit your changes: From the Julia prompt, type
-  :func:`Pkg.submit("Foo") <Pkg.submit>`. This will push your changes to your
+  :func:`PkgDev.submit("Foo") <PkgDev.submit>`. This will push your changes to your
   GitHub fork, creating it if it doesn't already exist. (If you encounter an
   error, :ref:`make sure you've set up your SSH keys <man-pkg-dev-setup>`.)
   Julia will then give you a hyperlink; open that link, edit the message, and
@@ -570,7 +599,7 @@ going to have to do a *force push*:
   it with ``git remote add myfork
   https://github.com/myaccount/Foo.jl.git``, where the URL comes from
   the "clone URL" on your GitHub fork's page.
-- Force-push to your fork with ``git push myfork +fixbar``. The `+`
+- Force-push to your fork with ``git push myfork +fixbar``. The ``+``
   indicates that this should replace the ``fixbar`` branch found at
   ``myfork``.
 
@@ -626,59 +655,60 @@ Here are some guidelines to follow in naming your package:
 1. Avoid jargon. In particular, avoid acronyms unless there is minimal
    possibility of confusion.
 
-  * It's ok to say ``USA`` if you're talking about the USA.
+   * It's ok to say ``USA`` if you're talking about the USA.
 
-  * It's not ok to say ``PMA``, even if you're talking about positive mental
-    attitude.
+   * It's not ok to say ``PMA``, even if you're talking about positive mental
+     attitude.
 
 2. Avoid using ``Julia`` in your package name.
 
-  * It is usually clear from context and to your users that the package is a
-    Julia package.
-  * Having Julia in the name can imply that the package is connected to, or
-    endorsed by, contributors to the Julia language itself.
+   * It is usually clear from context and to your users that the package is a
+     Julia package.
+
+   * Having Julia in the name can imply that the package is connected to, or
+     endorsed by, contributors to the Julia language itself.
 
 3. Packages that provide most of their functionality in association with a new
    type should have pluralized names.
 
-  * ``DataFrames`` provides the ``DataFrame`` type.
+   * ``DataFrames`` provides the ``DataFrame`` type.
 
-  * ``BloomFilters`` provides the ``BloomFilter`` type.
+   * ``BloomFilters`` provides the ``BloomFilter`` type.
 
-  * In contrast, ``JuliaParser`` provides no new type, but instead new
-    functionality in the ``JuliaParser.parse()`` function.
+   * In contrast, ``JuliaParser`` provides no new type, but instead new
+     functionality in the ``JuliaParser.parse()`` function.
 
 4. Err on the side of clarity, even if clarity seems long-winded to you.
 
-  * ``RandomMatrices`` is a less ambiguous name than ``RndMat`` or ``RMT``,
-    even though the latter are shorter.
+   * ``RandomMatrices`` is a less ambiguous name than ``RndMat`` or ``RMT``,
+     even though the latter are shorter.
 
 5. A less systematic name may suit a package that implements one of several
    possible approaches to its domain.
 
-  * Julia does not have a single comprehensive plotting package. Instead,
-    ``Gadfly``, ``PyPlot``, ``Winston`` and other packages each implement a
-    unique approach based on a particular design philosophy.
+   * Julia does not have a single comprehensive plotting package. Instead,
+     ``Gadfly``, ``PyPlot``, ``Winston`` and other packages each implement a
+     unique approach based on a particular design philosophy.
 
-  * In contrast, ``SortingAlgorithms`` provides a consistent interface to use
-    many well-established sorting algorithms.
+   * In contrast, ``SortingAlgorithms`` provides a consistent interface to use
+     many well-established sorting algorithms.
 
 6. Packages that wrap external libraries or programs should be named after
    those libraries or programs.
 
-  * ``CPLEX.jl`` wraps the ``CPLEX`` library, which can be identified easily in
-    a web search.
+   * ``CPLEX.jl`` wraps the ``CPLEX`` library, which can be identified easily in
+     a web search.
 
-  * ``MATLAB.jl`` provides an interface to call the MATLAB engine from within Julia.
+   * ``MATLAB.jl`` provides an interface to call the MATLAB engine from within Julia.
 
 Generating the package
 ~~~~~~~~~~~~~~~~~~~~~~
 
 Suppose you want to create a new Julia package called ``FooBar``.  To get started, do
-:func:`Pkg.generate(pkg,license) <Pkg.generate>` where ``pkg`` is the new package name and ``license`` is the
+:func:`PkgDev.generate(pkg,license) <PkgDev.generate>` where ``pkg`` is the new package name and ``license`` is the
 name of a license that the package generator knows about::
 
-    julia> Pkg.generate("FooBar","MIT")
+    julia> PkgDev.generate("FooBar","MIT")
     INFO: Initializing FooBar repo: /Users/stefan/.julia/v0.4/FooBar
     INFO: Origin: git://github.com/StefanKarpinski/FooBar.jl.git
     INFO: Generating LICENSE.md
@@ -724,7 +754,7 @@ indicated by ``"BSD"``, and version 2.0 of the Apache Software License, indicate
 different license, you can ask us to add it to the package generator, or just pick one of these three and then modify the
 ``~/.julia/v0.4/PACKAGE/LICENSE.md`` file after it has been generated.
 
-If you created a GitHub account and configured git to know about it, :func:`Pkg.generate` will set an appropriate origin URL
+If you created a GitHub account and configured git to know about it, :func:`PkgDev.generate` will set an appropriate origin URL
 for you.  It will also automatically generate a ``.travis.yml`` file for using the `Travis <https://travis-ci.org>`_ automated
 testing service, and an ``appveyor.yml`` file for using `AppVeyor <http://appveyor.com>`_.  You will have to enable testing on
 the Travis and AppVeyor websites for your package repository, but once you've done that, it will already have working tests.
@@ -752,9 +782,9 @@ Tagging and Publishing Your Package
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Once you've decided that ``FooBar`` is ready to be registered as an official package, you can add it to your local copy
-of ``METADATA`` using :func:`Pkg.register`::
+of ``METADATA`` using :func:`PkgDev.register`::
 
-    julia> Pkg.register("FooBar")
+    julia> PkgDev.register("FooBar")
     INFO: Registering FooBar at git://github.com/StefanKarpinski/FooBar.jl.git
     INFO: Committing METADATA for FooBar
 
@@ -777,10 +807,10 @@ This creates a commit in the ``~/.julia/v0.4/METADATA`` repo::
     +git://github.com/StefanKarpinski/FooBar.jl.git
 
 This commit is only locally visible, however.  To make it visible to the Julia community, you need to merge your
-local ``METADATA`` upstream into the official repo.  The :func:`Pkg.publish` command will fork the ``METADATA`` repository
+local ``METADATA`` upstream into the official repo.  The :func:`PkgDev.publish` command will fork the ``METADATA`` repository
 on GitHub, push your changes to your fork, and open a pull request::
 
-    julia> Pkg.publish()
+    julia> PkgDev.publish()
     INFO: Validating METADATA
     INFO: No new package versions to publish
     INFO: Submitting METADATA changes
@@ -792,25 +822,25 @@ on GitHub, push your changes to your fork, and open a pull request::
 
 .. tip::
 
-    If :func:`Pkg.publish` fails with error::
+    If :func:`PkgDev.publish` fails with error::
 
         ERROR: key not found: "token"
 
     then you may have encountered an issue from using the GitHub API on
     multiple systems. The solution is to delete the "Julia Package Manager"
     personal access token `from your Github account
-    <https://github.com/settings/applications>`_ and try again.
+    <https://github.com/settings/tokens>`_ and try again.
 
-    Other failures may require you to circumvent :func:`Pkg.publish` by
+    Other failures may require you to circumvent :func:`PkgDev.publish` by
     `creating a pull request on GitHub
     <https://help.github.com/articles/creating-a-pull-request>`_.
     See: :ref:`man-manual-publish` below.
 
 Once the package URL for ``FooBar`` is registered in the official ``METADATA`` repo, people know where
 to clone the package from, but there still aren't any registered versions available. You can tag and
-register it with the :func:`Pkg.tag` command::
+register it with the :func:`PkgDev.tag` command::
 
-    julia> Pkg.tag("FooBar")
+    julia> PkgDev.tag("FooBar")
     INFO: Tagging FooBar v0.0.1
     INFO: Committing METADATA for FooBar
 
@@ -836,7 +866,7 @@ It also creates a new version entry in your local ``METADATA`` repo for ``FooBar
     @@ -0,0 +1 @@
     +84b8e266dae6de30ab9703150b3bf771ec7b6285
 
-The :func:`Pkg.tag` command takes an optional second argument that is either an explicit version number object
+The :func:`PkgDev.tag` command takes an optional second argument that is either an explicit version number object
 like ``v"0.0.1"`` or one of the symbols ``:patch``, ``:minor`` or ``:major``.  These increment the patch, minor
 or major version number of your package intelligently.
 
@@ -846,11 +876,11 @@ strongly recommended that you complete this process, regardless if your package
 As a general rule, packages should be tagged ``0.0.1`` first. Since Julia itself hasn't achieved ``1.0`` status, it's best to
 be conservative in your package's tagged versions.
 
-As with :func:`Pkg.register`, these changes to ``METADATA`` aren't available to anyone else until they've been included upstream.
-Again, use the :func:`Pkg.publish` command, which first makes sure that individual package repos have been tagged, pushes them
+As with :func:`PkgDev.register`, these changes to ``METADATA`` aren't available to anyone else until they've been included upstream.
+Again, use the :func:`PkgDev.publish` command, which first makes sure that individual package repos have been tagged, pushes them
 if they haven't already been, and then opens a pull request to ``METADATA``::
 
-    julia> Pkg.publish()
+    julia> PkgDev.publish()
     INFO: Validating METADATA
     INFO: Pushing FooBar permanent tags: v0.0.1
     INFO: Submitting METADATA changes
@@ -863,9 +893,9 @@ if they haven't already been, and then opens a pull request to ``METADATA``::
 .. _man-manual-publish:
 
 Publishing METADATA manually
-============================
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-If :func:`Pkg.publish` fails you can follow these instructions to
+If :func:`PkgDev.publish` fails you can follow these instructions to
 manually publish your package.
 
 By "forking" the main METADATA repository, you can create a
@@ -932,7 +962,7 @@ For example, the line::
     Distributions 0.1
 
 is satisfied by any version of ``Distributions`` greater than or equal to ``0.1.0``.
-Suffixing a version with `-` allows any pre-release versions as well. For example::
+Suffixing a version with ``-`` allows any pre-release versions as well. For example::
 
     Distributions 0.1-
 
diff --git a/doc/manual/parallel-computing.rst b/doc/manual/parallel-computing.rst
index 305ce9a6dbaa2..4f19f1f6ae115 100644
--- a/doc/manual/parallel-computing.rst
+++ b/doc/manual/parallel-computing.rst
@@ -34,12 +34,18 @@ references* and *remote calls*. A remote reference is an object that can
 be used from any process to refer to an object stored on a particular
 process. A remote call is a request by one process to call a certain
 function on certain arguments on another (possibly the same) process.
-A remote call returns a remote reference to its result. Remote calls
+
+Remote references come in two flavors -``Future`` and ``RemoteChannel``.
+
+A remote call returns a ``Future`` to its result. Remote calls
 return immediately; the process that made the call proceeds to its
 next operation while the remote call happens somewhere else. You can
-wait for a remote call to finish by calling :func:`wait` on its remote
-reference, and you can obtain the full value of the result using
-:func:`fetch`. You can store a value to a remote reference using :func:`put!`.
+wait for a remote call to finish by calling :func:`wait` on the returned
+`Future`, and you can obtain the full value of the result using
+:func:`fetch`.
+
+On the other hand ``RemoteRefs`` are rewritable. For example, multiple processes
+can co-ordinate their processing by referencing the same remote ``Channel``\ .
 
 Let's try this out. Starting with ``julia -p n`` provides ``n`` worker
 processes on the local machine. Generally it makes sense for ``n`` to
@@ -49,32 +55,29 @@ equal the number of CPU cores on the machine.
 
     $ ./julia -p 2
 
-    julia> r = remotecall(2, rand, 2, 2)
-    RemoteRef(2,1,5)
-
-    julia> fetch(r)
-    2x2 Float64 Array:
-     0.60401   0.501111
-     0.174572  0.157411
+    julia> r = remotecall(rand, 2, 2, 2)
+    Future(2,1,3,Nullable{Any}())
 
     julia> s = @spawnat 2 1 .+ fetch(r)
-    RemoteRef(2,1,7)
+    Future(2,1,6,Nullable{Any}())
 
     julia> fetch(s)
     2x2 Float64 Array:
      1.60401  1.50111
      1.17457  1.15741
 
-The first argument to :func:`remotecall` is the index of the process
-that will do the work. Most parallel programming in Julia does not
-reference specific processes or the number of processes available,
-but :func:`remotecall` is considered a low-level interface providing
-finer control. The second argument to :func:`remotecall` is the function
-to call, and the remaining arguments will be passed to this
-function. As you can see, in the first line we asked process 2 to
+The first argument to :func:`remotecall` is the function to call.
+Most parallel programming in Julia does not reference specific processes
+or the number of processes available, but :func:`remotecall` is
+considered a low-level interface providing finer control. The second
+argument to :func:`remotecall` is the index of the process
+that will do the work, and the remaining arguments will be passed
+to the function being called.
+
+As you can see, in the first line we asked process 2 to
 construct a 2-by-2 random matrix, and in the second line we asked it
 to add 1 to it. The result of both calculations is available in the
-two remote references, ``r`` and ``s``. The :obj:`@spawnat` macro
+two futures, ``r`` and ``s``. The :obj:`@spawnat` macro
 evaluates the expression in the second argument on the process
 specified by the first argument.
 
@@ -86,22 +89,21 @@ but is more efficient.
 
 ::
 
-    julia> remotecall_fetch(2, getindex, r, 1, 1)
+    julia> remotecall_fetch(getindex, 2, r, 1, 1)
     0.10824216411304866
 
 Remember that :func:`getindex(r,1,1) <getindex>` is :ref:`equivalent <man-array-indexing>` to
-``r[1,1]``, so this call fetches the first element of the remote
-reference ``r``.
+``r[1,1]``, so this call fetches the first element of the future ``r``.
 
 The syntax of :func:`remotecall` is not especially convenient. The macro
 :obj:`@spawn` makes things easier. It operates on an expression rather than
 a function, and picks where to do the operation for you::
 
     julia> r = @spawn rand(2,2)
-    RemoteRef(1,1,0)
+    Future(2,1,4,Nullable{Any}())
 
     julia> s = @spawn 1 .+ fetch(r)
-    RemoteRef(1,1,1)
+    Future(3,1,5,Nullable{Any}())
 
     julia> fetch(s)
     1.10824216411304866 1.13798233877923116
@@ -117,6 +119,11 @@ process that owns ``r``, so the :func:`fetch` will be a no-op.
 as a :ref:`macro <man-macros>`. It is possible to define your
 own such constructs.)
 
+An important thing to remember is that, once fetched, a ``Future`` will cache its value
+locally. Further ``fetch`` calls do not entail a network hop. Once all referencing Futures
+have fetched, the remote stored value is deleted.
+
+
 .. _man-parallel-computing-code-availability:
 
 Code Availability and Loading Packages
@@ -134,13 +141,10 @@ type the following into the Julia prompt::
      0.153756  0.368514
      1.15119   0.918912
 
-    julia> @spawn rand2(2,2)
-    RemoteRef(1,1,1)
+    julia> fetch(@spawn rand2(2,2))
+    ERROR: On worker 2:
+    function rand2 not defined on process 2
 
-    julia> @spawn rand2(2,2)
-    RemoteRef(2,1,2)
-
-    julia> exception on 2: in anonymous: rand2 not defined
 
 Process 1 knew about the function ``rand2``, but process 2 did not.
 
@@ -169,7 +173,7 @@ Starting julia with ``julia -p 2``, you can use this to verify the following:
 - ``using DummyModule`` causes the module to be loaded on all processes; however, the module is brought into scope only on the one executing the statement.
 - As long as ``DummyModule`` is loaded on process 2, commands like ::
 
-    rr = RemoteRef(2)
+    rr = RemoteChannel(2)
     put!(rr, MyType(7))
 
   allow you to store an object of type ``MyType`` on process 2 even if ``DummyModule`` is not in scope on process 2.
@@ -179,7 +183,7 @@ For example, :obj:`@everywhere` can also be used to directly define a function o
 
     julia> @everywhere id = myid()
 
-    julia> remotecall_fetch(2, ()->id)
+    julia> remotecall_fetch(()->id, 2)
     2
 
 A file can also be preloaded on multiple processes at startup, and a driver script can be used to drive the computation::
@@ -195,16 +199,16 @@ considered to be all processes other than process 1.
 
 The base Julia installation has in-built support for two types of clusters:
 
-    - A local cluster specified with the ``-p`` option as shown above.
+- A local cluster specified with the ``-p`` option as shown above.
 
-    - A cluster spanning machines using the ``--machinefile`` option. This uses a passwordless
-      ``ssh`` login to start julia worker processes (from the same path as the current host)
-      on the specified machines.
+- A cluster spanning machines using the ``--machinefile`` option. This uses a passwordless
+  ``ssh`` login to start julia worker processes (from the same path as the current host)
+  on the specified machines.
 
 Functions :func:`addprocs`, :func:`rmprocs`, :func:`workers`, and others are available as a programmatic means of
 adding, removing and querying the processes in a cluster.
 
-Note that workers do not run a `.juliarc.jl` startup script, nor do they synchronize their global state
+Note that workers do not run a ``.juliarc.jl`` startup script, nor do they synchronize their global state
 (such as global variables, new method definitions, and loaded modules) with any of the other running processes.
 
 Other types of clusters can be supported by writing your own custom
@@ -328,10 +332,13 @@ For example, the following code will not work as intended::
 
 However, this code will not initialize all of ``a``, since each
 process will have a separate copy of it. Parallel for loops like these
-must be avoided. Fortunately, distributed arrays can be used to get
-around this limitation (see the
-`DistributedArrays.jl <https://github.com/JuliaParallel/DistributedArrays.jl>`_
-package).
+must be avoided. Fortunately,  `Shared Arrays <#shared-arrays>`_
+can be used to get around this limitation::
+
+    a = SharedArray(Float64,10)
+    @parallel for i=1:10
+      a[i] = i
+    end
 
 Using "outside" variables in parallel loops is perfectly reasonable if
 the variables are read-only::
@@ -346,9 +353,9 @@ vector ``a`` shared by all processes.
 
 As you could see, the reduction operator can be omitted if it is not needed.
 In that case, the loop executes asynchronously, i.e. it spawns independent
-tasks on all available workers and returns an array of :class:`RemoteRef`
+tasks on all available workers and returns an array of :class:`Future`
 immediately without waiting for completion.
-The caller can wait for the :class:`RemoteRef` completions at a later
+The caller can wait for the :class:`Future` completions at a later
 point by calling :func:`fetch` on them, or wait for completion at the end of the
 loop by prefixing it with :obj:`@sync`, like ``@sync @parallel for``.
 
@@ -359,7 +366,7 @@ called *parallel map*, implemented in Julia as the :func:`pmap` function.
 For example, we could compute the singular values of several large
 random matrices in parallel as follows::
 
-    M = {rand(1000,1000) for i=1:10}
+    M = Matrix{Float64}[rand(1000,1000) for i=1:10]
     pmap(svd, M)
 
 Julia's :func:`pmap` is designed for the case where each function call does
@@ -395,7 +402,7 @@ they finish their current tasks.
 As an example, consider computing the singular values of matrices of
 different sizes::
 
-    M = {rand(800,800), rand(600,600), rand(800,800), rand(600,600)}
+    M = Matrix{Float64}[rand(800,800), rand(600,600), rand(800,800), rand(600,600)]
     pmap(svd, M)
 
 If one process handles both 800x800 matrices and another handles both
@@ -447,7 +454,7 @@ points: in this case, when :func:`remotecall_fetch` is called.
 Channels
 --------
 Channels provide for a fast means of inter-task communication. A
-``Channel(T::Type, n::Int)`` is a shared queue of maximum length ``n``
+``Channel{T}(n::Int)`` is a shared queue of maximum length ``n``
 holding objects of type ``T``. Multiple readers can read off the channel
 via ``fetch`` and ``take!``. Multiple writers can add to the channel via
 ``put!``. ``isready`` tests for the presence of any object in
@@ -462,30 +469,67 @@ variable takes on all values added to the channel. An empty, closed channel
 causes the ``for`` loop to terminate.
 
 
-RemoteRefs and AbstractChannels
--------------------------------
+Remote references and AbstractChannels
+--------------------------------------
 
-A ``RemoteRef`` is a proxy for an implementation of an ``AbstractChannel``
+Remote references always refer to an implementation of an ``AbstractChannel``
 
 A concrete implementation of an ``AbstractChannel`` (like ``Channel``), is required
-to implement ``put!``, ``take!``, ``fetch``, ``isready`` and ``wait``. The remote object
-referred to by a ``RemoteRef()`` or ``RemoteRef(pid)`` is stored in a ``Channel{Any}(1)``,
-i.e., a channel of size 1 capable of holding objects of ``Any`` type.
+to implement ``put!``\ , ``take!``\ , ``fetch``\ , ``isready`` and ``wait``\ . The remote object
+referred to by a ``Future`` is stored in a ``Channel{Any}(1)``\ , i.e., a channel of size 1
+capable of holding objects of ``Any`` type.
 
-Methods ``put!``, ``take!``, ``fetch``, ``isready`` and ``wait`` on a ``RemoteRef`` are proxied onto
-the backing store on the remote process.
+``RemoteChannel``\ , which is rewritable, can point to any type and size of channels, or any other
+implementation of an ``AbstractChannel``\ .
 
-The constructor ``RemoteRef(f::Function, pid)`` allows us to construct references to channels holding
+The constructor ``RemoteChannel(f::Function, pid)`` allows us to construct references to channels holding
 more than one value of a specific type. ``f()`` is a function executed on ``pid`` and it must return
-an ``AbstractChannel``.
+an ``AbstractChannel``\ .
 
-For example, ``RemoteRef(()->Channel{Int}(10), pid)``, will return a reference to a channel of type ``Int``
-and size 10.
+For example, ``RemoteChannel(()->Channel{Int}(10), pid)``\ , will return a reference to a channel of type ``Int``
+and size 10. The channel exists on worker ``pid``\ .
 
-``RemoteRef`` can thus be used to refer to user implemented ``AbstractChannel`` objects. A simple
+Methods ``put!``\ , ``take!``\ , ``fetch``\ , ``isready`` and ``wait`` on a ``RemoteChannel`` are proxied onto
+the backing store on the remote process.
+
+``RemoteChannel`` can thus be used to refer to user implemented ``AbstractChannel`` objects. A simple
 example of this is provided in ``examples/dictchannel.jl`` which uses a dictionary as its remote store.
 
 
+Remote References and Distributed Garbage Collection
+----------------------------------------------------
+
+Objects referred to by remote references can be freed only when *all* held references in the cluster
+are deleted.
+
+The node where the value is stored keeps track of which of the workers have a reference to it.
+Every time a ``RemoteChannel`` or a (unfetched) ``Future`` is serialized to a worker, the node pointed
+to by the reference is notified. And every time a ``RemoteChannel`` or a (unfetched) ``Future``
+is garbage collected locally, the node owning the value is again notified.
+
+The notifications are done via sending of "tracking" messages - an "add reference" message when
+a reference is serialized to a different process and a "delete reference" message when a reference
+is locally garbage collected.
+
+Since ``Future``\ s are write-once and cached locally, the act of ``fetch``\ ing a ``Future`` also updates
+reference tracking information on the node owning the value.
+
+The node which owns the value frees it once all references to it are cleared.
+
+With ``Future``\ s, serializing an already fetched ``Future`` to a different node also sends the value
+since the original remote store may have collected the value by this time.
+
+It is important to note that *when* an object is locally garbage collected depends
+on the size of the object and the current memory pressure in the system.
+
+In case of remote references, the size of the local reference object is quite small, while the value
+stored on the remote node may be quite large. Since the local object may not be collected immediately, it is
+a good practice to explicitly call ``finalize`` on local instances of a ``RemoteChannel``, or on unfetched
+``Future``\ s. Since calling ``fetch`` on a ``Future`` also removes its reference from the remote store, this
+is not required on fetched ``Future``\ s. Explicitly calling ``finalize`` results in an immediate message sent to
+the remote node to go ahead and remove its reference to the value.
+
+
 Shared Arrays
 -------------
 
@@ -565,7 +609,7 @@ be careful not to set up conflicts.  For example::
   @sync begin
       for p in procs(S)
           @async begin
-              remotecall_wait(p, fill!, S, p)
+              remotecall_wait(fill!, p, S, p)
           end
       end
   end
@@ -634,7 +678,7 @@ and one that delegates in chunks::
    function advection_shared!(q, u)
        @sync begin
            for p in procs(q)
-               @async remotecall_wait(p, advection_shared_chunk!, q, u)
+               @async remotecall_wait(advection_shared_chunk!, p, q, u)
            end
        end
        q
@@ -687,9 +731,10 @@ A julia cluster has the following characteristics:
 - All processes can directly communicate with each other.
 
 Connections between workers (using the in-built TCP/IP transport) is established in the following manner:
+
 - :func:`addprocs` is called on the master process with a :obj:`ClusterManager` object
 - :func:`addprocs` calls the appropriate :func:`launch` method which spawns
-required number of worker processes on appropriate machines
+  required number of worker processes on appropriate machines
 - Each worker starts listening on a free port and writes out its host, port information to :const:`STDOUT`
 - The cluster manager captures the stdout's of each worker and makes it available to the master process
 - The master process parses this information and sets up TCP/IP connections to each worker
@@ -725,7 +770,6 @@ Thus, a minimal cluster manager would need to:
         ...
     end
 
-
 As an example let us see how the :class:`LocalManager`, the manager responsible for
 starting workers on the same host, is implemented::
 
@@ -743,10 +787,10 @@ starting workers on the same host, is implemented::
 
 The :func:`launch` method takes the following arguments:
 
-    - ``manager::ClusterManager`` - the cluster manager :func:`addprocs` is called with
-    - ``params::Dict`` - all the keyword arguments passed to :func:`addprocs`
-    - ``launched::Array`` - the array to append one or more ``WorkerConfig`` objects to
-    - ``c::Condition`` - the condition variable to be notified as and when workers are launched
+- ``manager::ClusterManager`` - the cluster manager :func:`addprocs` is called with
+- ``params::Dict`` - all the keyword arguments passed to :func:`addprocs`
+- ``launched::Array`` - the array to append one or more ``WorkerConfig`` objects to
+- ``c::Condition`` - the condition variable to be notified as and when workers are launched
 
 The :func:`launch` method is called asynchronously in a separate task. The termination of this task
 signals that all requested workers have been launched. Hence the :func:`launch` function MUST exit as soon
@@ -765,31 +809,31 @@ before using any of the parallel constructs
 For every worker launched, the :func:`launch` method must add a :class:`WorkerConfig`
 object (with appropriate fields initialized) to ``launched`` ::
 
- type WorkerConfig
-     # Common fields relevant to all cluster managers
-     io::Nullable{IO}
-     host::Nullable{AbstractString}
-     port::Nullable{Integer}
+    type WorkerConfig
+        # Common fields relevant to all cluster managers
+        io::Nullable{IO}
+        host::Nullable{AbstractString}
+        port::Nullable{Integer}
 
-     # Used when launching additional workers at a host
-     count::Nullable{Union{Int, Symbol}}
-     exename::Nullable{AbstractString}
-     exeflags::Nullable{Cmd}
+        # Used when launching additional workers at a host
+        count::Nullable{Union{Int, Symbol}}
+        exename::Nullable{AbstractString}
+        exeflags::Nullable{Cmd}
 
-     # External cluster managers can use this to store information at a per-worker level
-     # Can be a dict if multiple fields need to be stored.
-     userdata::Nullable{Any}
+        # External cluster managers can use this to store information at a per-worker level
+        # Can be a dict if multiple fields need to be stored.
+        userdata::Nullable{Any}
 
-     # SSHManager / SSH tunnel connections to workers
-     tunnel::Nullable{Bool}
-     bind_addr::Nullable{AbstractString}
-     sshflags::Nullable{Cmd}
-     max_parallel::Nullable{Integer}
+        # SSHManager / SSH tunnel connections to workers
+        tunnel::Nullable{Bool}
+        bind_addr::Nullable{AbstractString}
+        sshflags::Nullable{Cmd}
+        max_parallel::Nullable{Integer}
 
-     connect_at::Nullable{Any}
+        connect_at::Nullable{Any}
 
-     .....
- end
+        .....
+    end
 
 Most of the fields in :class:`WorkerConfig` are used by the inbuilt managers.
 Custom cluster managers would typically specify only ``io`` or ``host`` / ``port``:
@@ -817,12 +861,12 @@ required to connect to the workers from the master process.
 ``manage(manager::FooManager, id::Integer, config::WorkerConfig, op::Symbol)`` is called at different
 times during the worker's lifetime with appropriate ``op`` values:
 
-      - with ``:register``/``:deregister`` when a worker is added / removed
-        from the Julia worker pool.
-      - with ``:interrupt`` when ``interrupt(workers)`` is called. The
-        :class:`ClusterManager` should signal the appropriate worker with an
-        interrupt signal.
-      - with ``:finalize`` for cleanup purposes.
+- with ``:register``/``:deregister`` when a worker is added / removed
+  from the Julia worker pool.
+- with ``:interrupt`` when ``interrupt(workers)`` is called. The
+  :class:`ClusterManager` should signal the appropriate worker with an
+  interrupt signal.
+- with ``:finalize`` for cleanup purposes.
 
 
 Cluster Managers with custom transports
@@ -832,12 +876,12 @@ Replacing the default TCP/IP all-to-all socket connections with a custom transpo
 Each julia process has as many communication tasks as the workers it is connected to. For example, consider a julia cluster of
 32 processes in a all-to-all mesh network:
 
-    - Each julia process thus has 31 communication tasks
-    - Each task handles all incoming messages from a single remote worker in a message processing loop
-    - The message processing loop waits on an ``AsyncStream`` object - for example, a TCP socket in the default implementation, reads an entire
-      message, processes it and waits for the next one
-    - Sending messages to a process is done directly from any julia task - not just communication tasks - again, via the appropriate
-      ``AsyncStream`` object
+- Each julia process thus has 31 communication tasks
+- Each task handles all incoming messages from a single remote worker in a message processing loop
+- The message processing loop waits on an ``AsyncStream`` object - for example, a TCP socket in the default implementation, reads an entire
+  message, processes it and waits for the next one
+- Sending messages to a process is done directly from any julia task - not just communication tasks - again, via the appropriate
+  ``AsyncStream`` object
 
 Replacing the default transport involves the new implementation to setup connections to remote workers, and to provide appropriate
 ``AsyncStream`` objects that the message processing loops can wait on. The manager specific callbacks to be implemented are::
@@ -858,15 +902,15 @@ Note: The julia processes are still all *logically* connected to each other - an
 awareness of 0MQ being used as the transport layer.
 
 When using custom transports:
-    - julia workers must NOT be started with ``--worker``. Starting with ``--worker`` will result in the newly launched
-      workers defaulting to the TCP/IP socket transport implementation
-    - For every incoming logical connection with a worker, ``Base.process_messages(rd::AsyncStream, wr::AsyncStream)`` must be called.
-      This launches a new task that handles reading and writing of messages from/to the worker represented by the ``AsyncStream`` objects
-    - ``init_worker(manager::FooManager)`` MUST be called as part of worker process initializaton
-    - Field ``connect_at::Any`` in :class:`WorkerConfig` can be set by the cluster manager when ``launch`` is called. The value of
-      this field is passed in in all ``connect`` callbacks. Typically, it carries information on *how to connect* to a worker. For example,
-      the TCP/IP socket transport uses this field to specify the ``(host, port)`` tuple at which to connect to a worker
 
+- julia workers must NOT be started with ``--worker``. Starting with ``--worker`` will result in the newly launched
+  workers defaulting to the TCP/IP socket transport implementation
+- For every incoming logical connection with a worker, ``Base.process_messages(rd::AsyncStream, wr::AsyncStream)`` must be called.
+  This launches a new task that handles reading and writing of messages from/to the worker represented by the ``AsyncStream`` objects
+- ``init_worker(manager::FooManager)`` MUST be called as part of worker process initializaton
+- Field ``connect_at::Any`` in :class:`WorkerConfig` can be set by the cluster manager when ``launch`` is called. The value of
+  this field is passed in in all ``connect`` callbacks. Typically, it carries information on *how to connect* to a worker. For example,
+  the TCP/IP socket transport uses this field to specify the ``(host, port)`` tuple at which to connect to a worker
 
 ``kill(manager, pid, config)`` is called to remove a worker from the cluster.
 On the master process, the corresponding ``AsyncStream`` objects must be closed by the implementation to ensure proper cleanup. The default
@@ -880,14 +924,14 @@ Specifying network topology (Experimental)
 
 Keyword argument ``topology`` to ``addprocs`` is used to specify how the workers must be connected to each other:
 
-    - ``:all_to_all`` : is the default, where all workers are connected to each other.
+- ``:all_to_all`` : is the default, where all workers are connected to each other.
 
-    - ``:master_slave`` : only the driver process, i.e. pid 1 has connections to the workers.
+- ``:master_slave`` : only the driver process, i.e. pid 1 has connections to the workers.
 
-    - ``:custom`` : the ``launch`` method of the cluster manager specifes the connection topology.
-      Fields ``ident`` and ``connect_idents`` in ``WorkerConfig`` are used to specify the  same.
-      ``connect_idents`` is a list of ``ClusterManager`` provided identifiers to workers that worker
-      with identified by ``ident`` must connect to.
+- ``:custom`` : the ``launch`` method of the cluster manager specifes the connection topology.
+  Fields ``ident`` and ``connect_idents`` in ``WorkerConfig`` are used to specify the  same.
+  ``connect_idents`` is a list of ``ClusterManager`` provided identifiers to workers that worker
+  with identified by ``ident`` must connect to.
 
 Currently sending a message between unconnected workers results in an error. This behaviour, as also the
 functionality and interface should be considered experimental in nature and may change in future releases.
diff --git a/doc/manual/performance-tips.rst b/doc/manual/performance-tips.rst
index df033f3182fc8..bc15e0d489ab5 100644
--- a/doc/manual/performance-tips.rst
+++ b/doc/manual/performance-tips.rst
@@ -166,6 +166,10 @@ that can be manipulated efficiently.
 
 See also the discussion under :ref:`man-parametric-types`.
 
+
+
+
+
 Type declarations
 -----------------
 
@@ -176,25 +180,312 @@ arguments, local variables, and expressions.
 However, there are a few specific instances where declarations are
 helpful.
 
-Declare specific types for fields of composite types
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+.. _man-abstract-fields:
+
+Avoid fields with abstract type
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Types can be declared without specifying the types of their fields:
+
+.. doctest::
+
+    julia> type MyAmbiguousType
+               a
+           end
+
+This allows ``a`` to be of any type. This can often be useful, but it
+does have a downside: for objects of type ``MyAmbiguousType``, the
+compiler will not be able to generate high-performance code.  The
+reason is that the compiler uses the types of objects, not their
+values, to determine how to build code. Unfortunately, very little can
+be inferred about an object of type ``MyAmbiguousType``:
+
+.. doctest::
+
+    julia> b = MyAmbiguousType("Hello")
+    MyAmbiguousType("Hello")
+
+    julia> c = MyAmbiguousType(17)
+    MyAmbiguousType(17)
+
+    julia> typeof(b)
+    MyAmbiguousType
+
+    julia> typeof(c)
+    MyAmbiguousType
+
+``b`` and ``c`` have the same type, yet their underlying
+representation of data in memory is very different. Even if you stored
+just numeric values in field ``a``, the fact that the memory
+representation of a ``UInt8`` differs from a ``Float64`` also means
+that the CPU needs to handle them using two different kinds of
+instructions.  Since the required information is not available in the
+type, such decisions have to be made at run-time. This slows
+performance.
+
+You can do better by declaring the type of ``a``. Here, we are focused
+on the case where ``a`` might be any one of several types, in which
+case the natural solution is to use parameters. For example:
+
+.. doctest::
+
+    julia> type MyType{T<:AbstractFloat}
+             a::T
+           end
+
+This is a better choice than
+
+.. doctest::
+
+    julia> type MyStillAmbiguousType
+             a::AbstractFloat
+           end
+
+because the first version specifies the type of ``a`` from the type of
+the wrapper object.  For example:
+
+.. doctest::
+
+    julia> m = MyType(3.2)
+    MyType{Float64}(3.2)
+
+    julia> t = MyStillAmbiguousType(3.2)
+    MyStillAmbiguousType(3.2)
+
+    julia> typeof(m)
+    MyType{Float64}
+
+    julia> typeof(t)
+    MyStillAmbiguousType
+
+The type of field ``a`` can be readily determined from the type of
+``m``, but not from the type of ``t``.  Indeed, in ``t`` it's possible
+to change the type of field ``a``:
+
+.. doctest::
+
+    julia> typeof(t.a)
+    Float64
+
+    julia> t.a = 4.5f0
+    4.5f0
+
+    julia> typeof(t.a)
+    Float32
+
+In contrast, once ``m`` is constructed, the type of ``m.a`` cannot
+change:
+
+.. doctest::
+
+    julia> m.a = 4.5f0
+    4.5
+
+    julia> typeof(m.a)
+    Float64
+
+The fact that the type of ``m.a`` is known from ``m``'s type---coupled
+with the fact that its type cannot change mid-function---allows the
+compiler to generate highly-optimized code for objects like ``m`` but
+not for objects like ``t``.
+
+Of course, all of this is true only if we construct ``m`` with a
+concrete type.  We can break this by explicitly constructing it with
+an abstract type:
+
+.. doctest::
+
+    julia> m = MyType{AbstractFloat}(3.2)
+    MyType{AbstractFloat}(3.2)
+
+    julia> typeof(m.a)
+    Float64
+
+    julia> m.a = 4.5f0
+    4.5f0
+
+    julia> typeof(m.a)
+    Float32
+
+For all practical purposes, such objects behave identically to those
+of ``MyStillAmbiguousType``.
+
+It's quite instructive to compare the sheer amount code generated for
+a simple function
+::
+
+    func(m::MyType) = m.a+1
+
+using
+::
+
+    code_llvm(func,(MyType{Float64},))
+    code_llvm(func,(MyType{AbstractFloat},))
+    code_llvm(func,(MyType,))
+
+For reasons of length the results are not shown here, but you may wish
+to try this yourself. Because the type is fully-specified in the first
+case, the compiler doesn't need to generate any code to resolve the
+type at run-time.  This results in shorter and faster code.
+
+
+.. _man-abstract-container-type:
+
+Avoid fields with abstract containers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The same best practices also work for container types:
+
+.. doctest::
+
+    julia> type MySimpleContainer{A<:AbstractVector}
+             a::A
+           end
+
+    julia> type MyAmbiguousContainer{T}
+             a::AbstractVector{T}
+           end
+
+For example:
+
+.. doctest::
+
+    julia> c = MySimpleContainer(1:3);
+
+    julia> typeof(c)
+    MySimpleContainer{UnitRange{Int64}}
+
+    julia> c = MySimpleContainer([1:3;]);
+
+    julia> typeof(c)
+    MySimpleContainer{Array{Int64,1}}
+
+    julia> b = MyAmbiguousContainer(1:3);
+
+    julia> typeof(b)
+    MyAmbiguousContainer{Int64}
+
+    julia> b = MyAmbiguousContainer([1:3;]);
+
+    julia> typeof(b)
+    MyAmbiguousContainer{Int64}
+
+For ``MySimpleContainer``, the object is fully-specified by its type
+and parameters, so the compiler can generate optimized functions. In
+most instances, this will probably suffice.
+
+While the compiler can now do its job perfectly well, there are cases
+where *you* might wish that your code could do different things
+depending on the *element type* of ``a``.  Usually the best way to
+achieve this is to wrap your specific operation (here, ``foo``) in a
+separate function::
+
+    function sumfoo(c::MySimpleContainer)
+        s = 0
+    for x in c.a
+        s += foo(x)
+    end
+    s
+    end
+
+    foo(x::Integer) = x
+    foo(x::AbstractFloat) = round(x)
+
+This keeps things simple, while allowing the compiler to generate
+optimized code in all cases.
 
-Given a user-defined type like the following::
+However, there are cases where you may need to declare different
+versions of the outer function for different element types of
+``a``. You could do it like this::
 
-    type Foo
-        field
+    function myfun{T<:AbstractFloat}(c::MySimpleContainer{Vector{T}})
+        ...
+    end
+    function myfun{T<:Integer}(c::MySimpleContainer{Vector{T}})
+        ...
+    end
+
+This works fine for ``Vector{T}``, but we'd also have to write
+explicit versions for ``UnitRange{T}`` or other abstract types. To
+prevent such tedium, you can use two parameters in the declaration of
+``MyContainer``::
+
+    type MyContainer{T, A<:AbstractVector}
+        a::A
+    end
+    MyContainer(v::AbstractVector) = MyContainer{eltype(v), typeof(v)}(v)
+
+    julia> b = MyContainer(1.3:5);
+
+    julia> typeof(b)
+    MyContainer{Float64,UnitRange{Float64}}
+
+Note the somewhat surprising fact that ``T`` doesn't appear in the
+declaration of field ``a``, a point that we'll return to in a moment.
+With this approach, one can write functions such as::
+
+    function myfunc{T<:Integer, A<:AbstractArray}(c::MyContainer{T,A})
+        return c.a[1]+1
+    end
+    # Note: because we can only define MyContainer for
+    # A<:AbstractArray, and any unspecified parameters are arbitrary,
+    # the previous could have been written more succinctly as
+    #     function myfunc{T<:Integer}(c::MyContainer{T})
+
+    function myfunc{T<:AbstractFloat}(c::MyContainer{T})
+        return c.a[1]+2
+    end
+
+    function myfunc{T<:Integer}(c::MyContainer{T,Vector{T}})
+        return c.a[1]+3
     end
 
-the compiler will not generally know the type of ``foo.field``, since it
-might be modified at any time to refer to a value of a different type.
-It will help to declare the most specific type possible, such as
-``field::Float64`` or ``field::Array{Int64,1}``.
+    julia> myfunc(MyContainer(1:3))
+    2
+
+    julia> myfunc(MyContainer(1.0:3))
+    3.0
+
+    julia> myfunc(MyContainer([1:3]))
+    4
+
+As you can see, with this approach it's possible to specialize on both
+the element type ``T`` and the array type ``A``.
+
+However, there's one remaining hole: we haven't enforced that ``A``
+has element type ``T``, so it's perfectly possible to construct an
+object like this::
+
+  julia> b = MyContainer{Int64, UnitRange{Float64}}(1.3:5);
+
+  julia> typeof(b)
+  MyContainer{Int64,UnitRange{Float64}}
+
+To prevent this, we can add an inner constructor::
+
+    type MyBetterContainer{T<:Real, A<:AbstractVector}
+        a::A
+
+        MyBetterContainer(v::AbstractVector{T}) = new(v)
+    end
+    MyBetterContainer(v::AbstractVector) = MyBetterContainer{eltype(v),typeof(v)}(v)
+
+
+    julia> b = MyBetterContainer(1.3:5);
+
+    julia> typeof(b)
+    MyBetterContainer{Float64,UnitRange{Float64}}
+
+    julia> b = MyBetterContainer{Int64, UnitRange{Float64}}(1.3:5);
+    ERROR: no method MyBetterContainer(UnitRange{Float64},)
+
+The inner constructor requires that the element type of ``A`` be ``T``.
 
 Annotate values taken from untyped locations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 It is often convenient to work with data structures that may contain
-values of any type, such as the original ``Foo`` type above, or cell
+values of any type, such as cell
 arrays (arrays of type ``Array{Any}``). But, if you're using one of
 these structures and happen to know the type of an element, it helps to
 share this knowledge with the compiler::
diff --git a/doc/manual/running-external-programs.rst b/doc/manual/running-external-programs.rst
index dbbe88bbbbb08..20b5b86440bfa 100644
--- a/doc/manual/running-external-programs.rst
+++ b/doc/manual/running-external-programs.rst
@@ -42,12 +42,12 @@ The ``hello`` is the output of the ``echo`` command, sent to :const:`STDOUT`.
 The run method itself returns ``nothing``, and throws an :exc:`ErrorException`
 if the external command fails to run successfully.
 
-If you want to read the output of the external command, :func:`readall`
+If you want to read the output of the external command, :func:`readstring`
 can be used instead:
 
 .. doctest::
 
-    julia> a=readall(`echo hello`)
+    julia> a=readstring(`echo hello`)
     "hello\n"
 
     julia> (chomp(a)) == "hello"
@@ -257,7 +257,7 @@ This expression invokes the ``echo`` command with three words as
 arguments: "hello", "\|", and "sort". The result is that a single line
 is printed: "hello \| sort". Inside of backticks, a "\|" is just a
 literal pipe character. How, then, does one construct a pipeline?
-Instead of using "\|" inside of backticks, one uses :func:`pipe`:
+Instead of using "\|" inside of backticks, one uses :func:`pipeline`:
 
 .. doctest::
 
@@ -314,7 +314,7 @@ When reading and writing to both ends of a pipeline from a single process,
 it is important to avoid forcing the kernel to buffer all of the data.
 
 For example, when reading all of the output from a command,
-call ``readall(out)``, not ``wait(process)``, since the former
+call ``readstring(out)``, not ``wait(process)``, since the former
 will actively consume all of the data written by the process,
 whereas the latter will attempt to store the data in the kernel's
 buffers while waiting for a reader to be connected.
@@ -323,7 +323,7 @@ Another common solution is to separate the reader and writer
 of the pipeline into separate Tasks::
 
      writer = @async writeall(process, "data")
-     reader = @async do_compute(readall(process))
+     reader = @async do_compute(readstring(process))
      wait(process)
      fetch(reader)
 
diff --git a/doc/manual/stacktraces.rst b/doc/manual/stacktraces.rst
new file mode 100644
index 0000000000000..878b2a40af5ac
--- /dev/null
+++ b/doc/manual/stacktraces.rst
@@ -0,0 +1,254 @@
+.. _man-stacktraces:
+
+.. currentmodule:: Base
+
+************
+Stack Traces
+************
+
+The :mod:`StackTraces` module provides simple stack traces that are both human readable and
+easy to use programmatically.
+
+Viewing a stack trace
+---------------------
+
+The primary function used to obtain a stack trace is :func:`stacktrace`::
+
+    julia> stacktrace()
+    3-element Array{StackFrame,1}:
+     eval at boot.jl:265
+     [inlined code from REPL.jl:3] eval_user_input at REPL.jl:62
+     [inlined code from REPL.jl:92] anonymous at task.jl:63
+
+Calling :func:`stacktrace` returns a vector of :obj:`StackFrame` s. For ease of use, the
+alias :obj:`StackTrace` can be used in place of ``Vector{StackFrame}``. (Examples with
+``...`` indicate that output may vary depending on how the code is run.)
+
+.. doctest::
+
+    julia> example() = stacktrace()
+    example (generic function with 1 method)
+
+    julia> example()
+    ...-element Array{StackFrame,1}:
+     example at none:1
+     eval at boot.jl:265
+     ...
+
+    julia> @noinline child() = stacktrace()
+    child (generic function with 1 method)
+
+    julia> @noinline parent() = child()
+    parent (generic function with 1 method)
+
+    julia> grandparent() = parent()
+    grandparent (generic function with 1 method)
+
+    julia> grandparent()
+    ...-element Array{StackFrame,1}:
+     child at none:1
+     parent at none:1
+     grandparent at none:1
+     eval at boot.jl:265
+     ...
+
+Note that when calling :func:`stacktrace` you'll typically see a frame with
+``eval at boot.jl``. When calling :func:`stacktrace` from the REPL you'll also have a few
+extra frames in the stack from ``REPL.jl``, usually looking something like this::
+
+    julia> example() = stacktrace()
+    example (generic function with 1 method)
+
+    julia> example()
+    4-element Array{StackFrame,1}:
+     example at none:1
+     eval at boot.jl:265
+     [inlined code from REPL.jl:3] eval_user_input at REPL.jl:62
+     [inlined code from REPL.jl:92] anonymous at task.jl:63
+
+Extracting useful information
+-----------------------------
+
+Each :obj:`StackFrame` contains the function name, file name, line number, file and line
+information for inlined functions, a flag indicating whether it is a C function (by default
+C functions do not appear in the stack trace), and an integer representation of the pointer
+returned by :func:`backtrace`:
+
+.. doctest::
+
+    julia> top_frame = stacktrace()[1]
+    eval at boot.jl:265
+
+    julia> top_frame.func
+    :eval
+
+    julia> top_frame.file
+    symbol("./boot.jl")
+
+    julia> top_frame.line
+    265
+
+    julia> top_frame.inlined_file
+    symbol("")
+
+    julia> top_frame.inlined_line
+    -1
+
+    julia> top_frame.from_c
+    false
+
+::
+
+    julia> top_frame.pointer
+    13203085684
+
+This makes stack trace information available programmatically for logging, error handling,
+and more.
+
+Error handling
+--------------
+
+While having easy access to information about the current state of the callstack can be
+helpful in many places, the most obvious application is in error handling and debugging.
+
+.. doctest::
+
+    julia> @noinline bad_function() = undeclared_variable
+    bad_function (generic function with 1 method)
+
+    julia> @noinline example() = try
+               bad_function()
+           catch
+               stacktrace()
+           end
+    example (generic function with 1 method)
+
+    julia> example()
+    ...-element Array{StackFrame,1}:
+     example at none:4
+     eval at boot.jl:265
+     ...
+
+You may notice that in the example above the first stack frame points points at line 4,
+where :func:`stacktrace` is called, rather than line 2, where `bad_function` is called, and
+``bad_function``'s frame is missing entirely. This is understandable, given that
+:func:`stacktrace` is called from the context of the `catch`. While in this example it's
+fairly easy to find the actual source of the error, in complex cases tracking down the
+source of the error becomes nontrivial.
+
+This can be remedied by calling :func:`catch_stacktrace` instead of :func:`stacktrace`.
+Instead of returning callstack information for the current context, :func:`catch_stacktrace`
+returns stack information for the context of the most recent exception:
+
+.. doctest::
+
+    julia> @noinline bad_function() = undeclared_variable
+    bad_function (generic function with 1 method)
+
+    julia> @noinline example() = try
+               bad_function()
+           catch
+               catch_stacktrace()
+           end
+    example (generic function with 1 method)
+
+    julia> example()
+    ...-element Array{StackFrame,1}:
+     bad_function at none:1
+     example at none:2
+     eval at boot.jl:265
+     ...
+
+Notice that the stack trace now indicates the appropriate line number and the missing frame.
+
+.. doctest::
+
+    julia> @noinline child() = error("Whoops!")
+    child (generic function with 1 method)
+
+    julia> @noinline parent() = child()
+    parent (generic function with 1 method)
+
+    julia> @noinline function grandparent()
+               try
+                   parent()
+               catch err
+                   println("ERROR: ", err.msg)
+                   catch_stacktrace()
+               end
+           end
+    grandparent (generic function with 1 method)
+
+    julia> grandparent()
+    ERROR: Whoops!
+    ...-element Array{StackFrame,1}:
+     child at none:1
+     parent at none:1
+     grandparent at none:3
+     eval at boot.jl:265
+     ...
+
+Comparison with :func:`backtrace`
+---------------------------------
+
+A call to :func:`backtrace` returns a vector of ``Ptr{Void}``, which may then be passed into
+:func:`stacktrace` for translation::
+
+    julia> trace = backtrace()
+    15-element Array{Ptr{Void},1}:
+     Ptr{Void} @0x000000010527895e
+     Ptr{Void} @0x0000000309bf6220
+     Ptr{Void} @0x0000000309bf61a0
+     Ptr{Void} @0x00000001052733b4
+     Ptr{Void} @0x0000000105271a0e
+     Ptr{Void} @0x000000010527189d
+     Ptr{Void} @0x0000000105272e6d
+     Ptr{Void} @0x0000000105272cef
+     Ptr{Void} @0x0000000105285b88
+     Ptr{Void} @0x000000010526b50e
+     Ptr{Void} @0x000000010663cc28
+     Ptr{Void} @0x0000000309bbc20f
+     Ptr{Void} @0x0000000309bbbde7
+     Ptr{Void} @0x0000000309bb0262
+     Ptr{Void} @0x000000010527980e
+
+    julia> stacktrace(trace)
+    4-element Array{StackFrame,1}:
+     backtrace at error.jl:26
+     eval at boot.jl:265
+     [inlined code from REPL.jl:3] eval_user_input at REPL.jl:62
+     [inlined code from REPL.jl:92] anonymous at task.jl:63
+
+Notice that the vector returned by :func:`backtrace` had 15 pointers, while the vector returned by :func:`stacktrace` only has 3. This is because, by default, :func:`stacktrace` removes any lower-level C functions from the stack. If you want to include stack frames from C calls, you can do it like this::
+
+    julia> stacktrace(stack, true)
+    15-element Array{StackFrame,1}:
+     [inlined code from task.c:651] rec_backtrace at task.c:711
+     backtrace at error.jl:26
+     jlcall_backtrace_23146 at :-1
+     [inlined code from interpreter.c:55] jl_apply at interpreter.c:65
+     eval at interpreter.c:214
+     eval at interpreter.c:220
+     eval_body at interpreter.c:601
+     jl_toplevel_eval_body at interpreter.c:534
+     jl_toplevel_eval_flex at toplevel.c:525
+     jl_toplevel_eval_in_warn at builtins.c:590
+     eval at boot.jl:265
+     [inlined code from REPL.jl:3] eval_user_input at REPL.jl:62
+     jlcall_eval_user_input_22658 at :-1
+     [inlined code from REPL.jl:92] anonymous at task.jl:63
+     [inlined code from julia.h:1352] jl_apply at task.c:246
+
+Individual pointers returned by :func:`backtrace` can be translated into :obj:`StackFrame` s
+by passing them into :func:`StackTraces.lookup`:
+
+.. doctest::
+
+    julia> pointer = backtrace()[1]
+    Ptr{Void} @0x...
+
+    julia> frame = StackTraces.lookup(pointer)
+    [inlined code from task.c:663] rec_backtrace at task.c:723
+
+    julia> println("The top frame is from $(frame.func)!")
+    The top frame is from rec_backtrace!
diff --git a/doc/manual/strings.rst b/doc/manual/strings.rst
index aea78005454c7..d348332311e7f 100644
--- a/doc/manual/strings.rst
+++ b/doc/manual/strings.rst
@@ -439,6 +439,55 @@ backslash:
     julia> print("I have \$100 in my account.\n")
     I have $100 in my account.
 
+Triple-Quoted String Literals
+-----------------------------
+
+When strings are created using triple-quotes (``"""..."""``) they have some
+special behavior that can be useful for creating longer blocks of text. First,
+if the opening ``"""`` is followed by a newline, the newline is stripped from
+the resulting string.
+
+::
+
+    """hello"""
+
+is equivalent to
+
+::
+
+    """
+    hello"""
+
+but
+
+::
+
+    """
+
+    hello"""
+
+will contain a literal newline at the beginning. Trailing whitespace is left
+unaltered. They can contain ``"`` symbols without escaping. Triple-quoted strings
+are also dedented to the level of the least-indented line. This is useful for
+defining strings within code that is indented. For example:
+
+.. doctest::
+
+    julia> str = """
+               Hello,
+               world.
+             """
+    "  Hello,\n  world.\n"
+
+In this case the final (empty) line before the closing ``"""`` sets the
+indentation level.
+
+Note that line breaks in literal strings, whether single- or triple-quoted,
+result in a newline (LF) character ``\n`` in the string, even if your
+editor uses a carriage return ``\r`` (CR) or CRLF combination to end lines.
+To include a CR in a string, use an explicit escape ``\r``; for example,
+you can enter the literal string ``"a CRLF line ending\r\n"``.
+
 Common Operations
 -----------------
 
@@ -647,7 +696,7 @@ You can extract the following info from a :obj:`RegexMatch` object:
 For when a capture doesn't match, instead of a substring, ``m.captures``
 contains ``nothing`` in that position, and ``m.offsets`` has a zero
 offset (recall that indices in Julia are 1-based, so a zero offset into
-a string is invalid). Here's is a pair of somewhat contrived examples::
+a string is invalid). Here is a pair of somewhat contrived examples::
 
     julia> m = match(r"(a|b)(c)?(d)", "acd")
     RegexMatch("acd", 1="a", 2="c", 3="d")
@@ -700,7 +749,7 @@ use destructuring syntax to bind them to local variables::
 Captures can also be accessed by indexing the :obj:`RegexMatch` object
 with the number or name of the capture group::
 
-    julia> m=match(r"(?P<hour>\d+):(?P<minute>\d+)","12:45")
+    julia> m=match(r"(?<hour>\d+):(?<minute>\d+)","12:45")
     RegexMatch("12:45", hour="12", minute="45")
     julia> m[:minute]
     "45"
@@ -708,12 +757,12 @@ with the number or name of the capture group::
     "45"
 
 Captures can be referenced in a substitution string when using :func:`replace`
-by using ``\n`` to refer to the `n`th capture group and prefixing the
+by using ``\n`` to refer to the nth capture group and prefixing the
 subsitution string with ``s``. Capture group 0 refers to the entire match object.
 Named capture groups can be referenced in the substitution with ``g<groupname>``.
 For example::
 
-    julia> replace("first second", r"(\w+) (?P<agroup>\w+)", s"\g<agroup> \1")
+    julia> replace("first second", r"(\w+) (?<agroup>\w+)", s"\g<agroup> \1")
     julia> "second first"
 
 Numbered capture groups can also be referenced as ``\g<n>`` for disambiguation,
@@ -892,7 +941,7 @@ would only run with stable ``0.2`` versions, and exclude such versions as
 ``0.2`` versions, the lower bound check should be modified like this: ``v"0.2-"
 <= VERSION``.
 
-Another non-standard version specification extension allows to use a trailing
+Another non-standard version specification extension allows one to use a trailing
 ``+`` to express an upper limit on build versions, e.g.  ``VERSION >
 "v"0.2-rc1+"`` can be used to mean any version above ``0.2-rc1`` and any of its
 builds: it will return ``false`` for version ``v"0.2-rc1+win64"`` and ``true``
diff --git a/doc/manual/style-guide.rst b/doc/manual/style-guide.rst
index 43a2d68baf2a2..98dc69800a6f1 100644
--- a/doc/manual/style-guide.rst
+++ b/doc/manual/style-guide.rst
@@ -92,8 +92,8 @@ might be better to force the caller to decide how non-integers should
 be converted (e.g. floor or ceiling). Another issue is that declaring
 more specific types leaves more "space" for future method definitions.
 
-Append `!` to names of functions that modify their arguments
-------------------------------------------------------------
+Append ``!`` to names of functions that modify their arguments
+--------------------------------------------------------------
 
 Instead of::
 
diff --git a/doc/manual/types.rst b/doc/manual/types.rst
index 8429e96136fe1..96eabe8b547eb 100644
--- a/doc/manual/types.rst
+++ b/doc/manual/types.rst
@@ -343,7 +343,7 @@ In mainstream
 object oriented languages, such as C++, Java, Python and Ruby, composite
 types also have named functions associated with them, and the
 combination is called an "object". In purer object-oriented languages,
-such as Python and Ruby, all values are objects whether they are
+such as Ruby or Smalltalk, all values are objects whether they are
 composites or not. In less pure object oriented languages, including C++
 and Java, some values, such as integers and floating-point values, are
 not objects, while instances of user-defined composite types are true
@@ -684,8 +684,8 @@ subtypes of each other:
 
 This last point is very important:
 
-    **Even though** ``Float64 <: Real`` **we DO NOT have**
-    ``Point{Float64} <: Point{Real}``\ **.**
+- **Even though** ``Float64 <: Real`` **we DO NOT have**
+  ``Point{Float64} <: Point{Real}``\ **.**
 
 In other words, in the parlance of type theory, Julia's type parameters
 are *invariant*, rather than being covariant (or even contravariant).
@@ -711,6 +711,21 @@ pointers to individually allocated :obj:`Real` objects — which may well be
 complex objects, which are declared to be implementations of the
 :obj:`Real` abstract type.
 
+Since ``Point{Float64}`` is not a subtype of ``Point{Real}``, the following method can't be applied to arguments of type ``Point{Float64}``::
+
+    function norm(p::Point{Real})
+       sqrt(p.x^2 + p.y^2)
+    end
+
+The correct way to define a method that accepts all arguments of type ``Point{T}`` where ``T`` is a subtype of ``Real`` is::
+
+    function norm{T<:Real}(p::Point{T})
+       sqrt(p.x^2 + p.y^2)
+    end
+
+More examples will be discussed later in :ref:`man-methods`.
+
+
 How does one construct a ``Point`` object? It is possible to define
 custom constructors for composite types, which will be discussed in
 detail in :ref:`man-constructors`, but in the absence of any
@@ -740,21 +755,11 @@ each field:
     ERROR: MethodError: `convert` has no method matching convert(::Type{Point{Float64}}, ::Float64)
     This may have arisen from a call to the constructor Point{Float64}(...),
     since type constructors fall back to convert methods.
-    Closest candidates are:
-      Point{T}(::Any, !Matched::Any)
-      call{T}(::Type{T}, ::Any)
-      convert{T}(::Type{T}, !Matched::T)
-     in call at essentials.jl:56
 
     julia> Point{Float64}(1.0,2.0,3.0)
     ERROR: MethodError: `convert` has no method matching convert(::Type{Point{Float64}}, ::Float64, ::Float64, ::Float64)
     This may have arisen from a call to the constructor Point{Float64}(...),
     since type constructors fall back to convert methods.
-    Closest candidates are:
-      Point{T}(::Any, ::Any)
-      call{T}(::Type{T}, ::Any)
-      convert{T}(::Type{T}, !Matched::T)
-     in call at essentials.jl:57
 
 Only one default constructor is generated for parametric types, since
 overriding it is not possible. This constructor accepts any arguments
@@ -790,11 +795,6 @@ isn't the case, the constructor will fail with a :exc:`MethodError`:
     ERROR: MethodError: `convert` has no method matching convert(::Type{Point{T}}, ::Int64, ::Float64)
     This may have arisen from a call to the constructor Point{T}(...),
     since type constructors fall back to convert methods.
-    Closest candidates are:
-      Point{T}(::T, !Matched::T)
-      call{T}(::Type{T}, ::Any)
-      convert{T}(::Type{T}, !Matched::T)
-     in call at essentials.jl:57
 
 Constructor methods to appropriately handle such mixed cases can be
 defined, but that will not be discussed until later on in
@@ -1213,29 +1213,29 @@ As it happens, types are all composite values and thus all have a type of
 
 :obj:`DataType` is its own type.
 
-Another operation that applies to some types is :func:`super`, which
+Another operation that applies to some types is :func:`supertype`, which
 reveals a type's supertype.
 Only declared types (:obj:`DataType`) have unambiguous supertypes:
 
 .. doctest::
 
-    julia> super(Float64)
+    julia> supertype(Float64)
     AbstractFloat
 
-    julia> super(Number)
+    julia> supertype(Number)
     Any
 
-    julia> super(AbstractString)
+    julia> supertype(AbstractString)
     Any
 
-    julia> super(Any)
+    julia> supertype(Any)
     Any
 
-If you apply :func:`super` to other type objects (or non-type objects), a
+If you apply :func:`supertype` to other type objects (or non-type objects), a
 :exc:`MethodError` is raised::
 
-    julia> super(Union{Float64,Int64})
-    ERROR: `super` has no method matching super(::Type{Union{Float64,Int64}})
+    julia> supertype(Union{Float64,Int64})
+    ERROR: `supertype` has no method matching supertype(::Type{Union{Float64,Int64}})
 
 "Value types"
 -------------
@@ -1283,7 +1283,7 @@ minimal interface designed to ensure that interactions with missing values
 are safe. At present, the interface consists of four possible interactions:
 
 - Construct a :obj:`Nullable` object.
-- Check if an :obj:`Nullable` object has a missing value.
+- Check if a :obj:`Nullable` object has a missing value.
 - Access the value of a :obj:`Nullable` object with a guarantee that a
   :exc:`NullException` will be thrown if the object's value is missing.
 - Access the value of a :obj:`Nullable` object with a guarantee that a default
@@ -1324,8 +1324,8 @@ Note the core distinction between these two ways of constructing a :obj:`Nullabl
 object: in one style, you provide a type, ``T``, as a function parameter; in
 the other style, you provide a single value of type ``T`` as an argument.
 
-Checking if an :obj:`Nullable` object has a value
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Checking if a :obj:`Nullable` object has a value
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can check if a :obj:`Nullable` object has any value using :func:`isnull`:
 
@@ -1337,10 +1337,10 @@ You can check if a :obj:`Nullable` object has any value using :func:`isnull`:
     julia> isnull(Nullable(0.0))
     false
 
-Safely accessing the value of an :obj:`Nullable` object
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Safely accessing the value of a :obj:`Nullable` object
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-You can safely access the value of an :obj:`Nullable` object using :func:`get`:
+You can safely access the value of a :obj:`Nullable` object using :func:`get`:
 
 .. doctest::
 
diff --git a/doc/manual/variables-and-scoping.rst b/doc/manual/variables-and-scoping.rst
index 6d36b09f55d5e..1579f83346c1c 100644
--- a/doc/manual/variables-and-scoping.rst
+++ b/doc/manual/variables-and-scoping.rst
@@ -6,234 +6,386 @@
  Scope of Variables
 ********************
 
-The *scope* of a variable is the region of code within which a variable
-is visible. Variable scoping helps avoid variable naming conflicts. The
-concept is intuitive: two functions can both have arguments called ``x``
-without the two ``x``'s referring to the same thing. Similarly there are
-many other cases where different blocks of code can use the same name
-without referring to the same thing. The rules for when the same
-variable name does or doesn't refer to the same thing are called scope
-rules; this section spells them out in detail.
+The *scope* of a variable is the region of code within which a
+variable is visible. Variable scoping helps avoid variable naming
+conflicts. The concept is intuitive: two functions can both have
+arguments called ``x`` without the two ``x``'s referring to the same
+thing. Similarly there are many other cases where different blocks of
+code can use the same name without referring to the same thing. The
+rules for when the same variable name does or doesn't refer to the
+same thing are called scope rules; this section spells them out in
+detail.
 
 Certain constructs in the language introduce *scope blocks*, which are
 regions of code that are eligible to be the scope of some set of
-variables. The scope of a variable cannot be an arbitrary set of source
-lines; instead, it will always line up with one of these blocks.
-The constructs introducing such blocks are:
-
--  ``function`` bodies (:ref:`either syntax <man-functions>`)
--  ``while`` loops
--  ``for`` loops
--  ``try`` blocks
--  ``catch`` blocks
--  ``finally`` blocks
--  ``let`` blocks
--  ``type`` blocks.
-
-Notably missing from this list are
-:ref:`begin blocks <man-compound-expressions>` and :ref:`if blocks <man-conditional-evaluation>`, which do
-*not* introduce new scope blocks.
-
-Certain constructs introduce new variables into the current innermost
-scope. When a variable is introduced into a scope, it is also inherited
-by all inner scopes unless one of those inner scopes explicitly
-overrides it.
+variables. The scope of a variable cannot be an arbitrary set of
+source lines; instead, it will always line up with one of these
+blocks.  There are two main types of scopes in Julia, *global scope*
+and *local scope*, the latter can be nested.  The constructs
+introducing scope blocks are:
+
+.. _man-scope-table:
+
++--------------------------------+----------------------------------------------------------------------------------+
+| Scope name                     | block/construct introducing this kind of scope                                   |
++================================+==================================================================================+
+| :ref:`global <man-global>`     | | module, baremodule, at interactive prompt (REPL)                               |
++--------------------------------+------------------------------+---------------------------------------------------+
+| :ref:`local <man-local-scope>` | :ref:`soft <man-soft-scope>` | | for, while, list-comprehensions,                |
+|                                |                              |   try-catch-finally, let                          |
+|                                +------------------------------+---------------------------------------------------+
+|                                | :ref:`hard <man-hard-scope>` | | functions (either syntax, anonymous & do-blocks)|
+|                                |                              | | type, immutable, macro                          |
++--------------------------------+------------------------------+---------------------------------------------------+
+
+Notably missing from this table are :ref:`begin blocks
+<man-compound-expressions>` and :ref:`if blocks
+<man-conditional-evaluation>`, which do *not* introduce new scope
+blocks.  All three types of scopes follow somewhat different rules
+which will be explained below as well as some extra rules for
+certain blocks.
 
 Julia uses `lexical scoping <https://en.wikipedia.org/wiki/Scope_%28computer_science%29#Lexical_scoping_vs._dynamic_scoping>`_,
 meaning that a function's scope does not inherit from its caller's
 scope, but from the scope in which the function was defined.
-For example, in the following code the ``x`` inside ``foo`` is found
-in the global scope (and if no global variable ``x`` existed, an
-undefined variable error would be raised)::
+For example, in the following code the ``x`` inside ``foo`` is refers
+to the ``x`` in the global scope of its module ``Bar``::
 
-    function foo()
-      x
+    module Bar
+    x = 1
+    foo() = x
     end
 
-    function bar()
-      x = 1
-      foo()
-    end
+and not a ``x`` in the scope where ``foo`` is used::
 
-    x = 2
+    julia> import Bar
 
-    julia> bar()
-    2
+    julia> x = -1;
 
-If ``foo`` is instead defined inside ``bar``, then it accesses
-the local ``x`` present in that function::
+    julia> Bar.foo()
+    1
 
-    function bar()
-      function foo()
-        x
-      end
-      x = 1
-      foo()
+Thus *lexical scope* means that the scope of variables can be inferred
+from the source code alone.
+
+.. _man-global:
+
+Global Scope
+------------
+
+*Each module introduces a new global scope*, separate from the global
+scope of all other modules; there is no all-encompassing global scope.
+Modules can introduce variables of other modules into their scope
+through the :ref:`using or import <man-modules>` statements or through
+qualified access using the dot-notation, i.e. each module is a
+so-called *namespace*.  Note that variable bindings can only be
+changed within their global scope and not from an outside module. ::
+
+    module A
+    a = 1 # a global in A's scope
     end
 
-    x = 2
+    module B
+    # b = a # would error as B's global scope is separate from A's
+        module C
+        c = 2
+        end
+    b = C.c # can access the namespace of a nested global scope
+            # through a qualified access
+    import A # makes module A available
+    d = A.a
+    # A.a = 2 # would error with: "ERROR: cannot assign variables in other modules"
+    end
 
-    julia> bar()
-    1
+Note that the interactive prompt (aka REPL) is in the global scope of
+the module ``Main``.
 
-The constructs that introduce new variables into the current scope
-are as follows:
-
--  A declaration ``local x`` or ``const x`` introduces a new local variable.
--  A declaration ``global x`` makes ``x`` in the current scope and inner
-   scopes refer to the global variable of that name.
--  A function's arguments are introduced as new local variables into the
-   function's body scope.
--  An assignment ``x = y`` introduces a new local variable ``x`` only if
-   ``x`` is neither declared global nor introduced as local
-   by any enclosing scope before *or after* the current line of code.
-
-In the following example, there is only one ``x`` assigned both inside
-and outside the ``for`` loop::
-
-    function foo(n)
-      x = 0
-      for i = 1:n
-        x = x + 1
-      end
-      x
+.. _man-local-scope:
+
+Local Scope
+-----------
+
+A new local scope is introduced by most code-blocks, see above
+:ref:`table <man-scope-table>` for a complete list.  A local scope
+*usually* inherits all the variables from its parent scope, both for
+reading and writing.  There are two subtypes of local scopes, hard and
+soft, with slightly different rules concerning what variables are
+inherited.  Unlike global scopes, local scopes are not namespaces,
+thus variables in an inner scope cannot be retrieved from the parent
+scope through some sort of qualified access.
+
+The following rules and examples pertain to both hard and soft local
+scopes.  A newly introduced variable in a local scope does not
+back-propagate to its parent scope.  For example, here the ``z`` is not
+introduced into the top-level scope::
+
+    for i=1:10
+        z = i
     end
 
-    julia> foo(10)
-    10
+    julia> z
+    ERROR: UndefVarError: z not defined
+
+(Note, in this and all following examples it is assumed that their
+top-level is a global scope with a clean workspace, for instance a
+newly started REPL.)
 
-In the next example, the loop has a separate ``x`` and the function
-always returns zero::
+Inside a local scope a variable can be forced to be a local variable
+using the ``local`` keyword::
 
-    function foo(n)
-      x = 0
-      for i = 1:n
+    x = 0
+    for i=1:10
         local x
-        x = i
-      end
-      x
+        x = i + 1
     end
 
-    julia> foo(10)
+    julia> x
     0
 
-In this example, an ``x`` exists only inside the loop, and the function
-encounters an undefined variable error on its last line (unless there is
-a global variable ``x``)::
+Inside a local scope a new global variable can be defined using the
+keyword ``global``::
 
-    function foo(n)
-      for i = 1:n
-        x = i
-      end
-      x
+    for i=1:10
+        global z
+        z = i
     end
 
-    julia> foo(10)
-    in foo: x not defined
-
-A variable that is not assigned to or otherwise introduced locally
-defaults to global, so this function would return the value of the
-global ``x`` if there were such a variable, or produce an error if no such
-global existed. As a consequence, the only way to assign to a global
-variable inside a non-top-level scope is to explicitly declare the
-variable as global within some scope, since otherwise the assignment
-would introduce a new local rather than assigning to the global. This
-rule works out well in practice, since the vast majority of variables
-assigned inside functions are intended to be local variables, and using
-global variables should be the exception rather than the rule,
-and assigning new values to them even more so.
-
-One last example shows that an outer assignment introducing ``x`` need
-not come before an inner usage::
-
-    function foo(n)
-      f = y -> n + x + y
-      x = 1
-      f(2)
+    julia> z
+    10
+
+..
+   However, there is no keyword to introduce a new local variable into a
+   parent local scope.
+
+The location of both the ``local`` and ``global`` keywords within the
+scope block is irrelevant.  The following is equivalent to the last
+example (although stylistically worse)::
+
+    for i=1:10
+        z = i
+        global z
     end
 
-    julia> foo(10)
-    13
+    julia> z
+    10
 
-This behavior may seem slightly odd for a normal variable, but allows
-for named functions — which are just normal variables holding function
-objects — to be used before they are defined. This allows functions to
-be defined in whatever order is intuitive and convenient, rather than
-forcing bottom up ordering or requiring forward declarations, both of
-which one typically sees in C programs. As an example, here is an
-inefficient, mutually recursive way to test if positive integers are
-even or odd::
+Multiple global or local definitions can be on one line and can also
+be paired with assignments::
 
-    even(n) = n == 0 ? true  :  odd(n-1)
-    odd(n)  = n == 0 ? false : even(n-1)
+    for i=1:10
+        global x=i, y, z
+        local a=4, b , c=1
+    end
 
-    julia> even(3)
-    false
 
-    julia> odd(3)
-    true
+.. _man-soft-scope:
 
-Julia provides built-in, efficient functions to test for oddness and evenness
-called :func:`iseven` and :func:`isodd` so the above definitions should only be
-taken as examples.
+Soft Local Scope
+^^^^^^^^^^^^^^^^
 
-Since functions can be used before they are defined, as long as they are
-defined by the time they are actually called, no syntax for forward
-declarations is necessary, and definitions can be ordered arbitrarily.
+  In a soft local scope, all variables are inherited from its parent
+  scope unless a variable is specifically marked with the keyword
+  ``local``.
 
-At the interactive prompt, variable scope works the same way as anywhere
-else. The prompt behaves as if there is scope block wrapped around
-everything you type, except that this scope block is identified with the
-global scope. This is especially evident in the case of assignments:
+Soft local scopes are introduced by for-loops, while-loops,
+list-comprehensions, try-catch-finally-blocks, and let-blocks.  There
+are some extra rules for :ref:`let-blocks <man-let-blocks>` and for
+:ref:`for-loops and list-comprehensions <man-for-loops-scope>`.
 
-.. doctest::
+In the following example the ``x`` and ``y`` refer always to the same
+variables as the soft local scope inherits both read and write
+variables::
 
-    julia> for i = 1:1; y = 10; end
+    x,y = 0, 1
+    for i = 1:10
+        x = i + y + 1
+    end
 
-    julia> y
-    ERROR: UndefVarError: y not defined
+    julia> x
+    11
 
-    julia> y = 0
-    0
+Within soft scopes, the `global` keyword is never necessary, although
+allowed.  The only case when it would change the semantics is
+(currently) a syntax error::
 
-    julia> for i = 1:1; y = 10; end
+    let
+        local x = 2
+        let
+            global x = 3
+        end
+    end
 
-    julia> y
-    10
+    # ERROR: syntax: `global x`: x is local variable in the enclosing scope
 
-In the former case, ``y`` only exists inside of the ``for`` loop. In the
-latter case, an outer ``y`` has been introduced and so is inherited
-within the loop. Due to the special identification of the prompt's scope
-block with the global scope, it is not necessary to declare ``global y``
-inside the loop. However, in code not entered into the interactive
-prompt this declaration would be necessary in order to modify a global
-variable.
+.. _man-hard-scope:
 
-Multiple variables can be declared global using the following syntax::
+Hard Local Scope
+^^^^^^^^^^^^^^^^
 
+Hard local scopes are introduced by function definitions (in all their
+forms), type & immutable-blocks and macro-definitions.
+
+   In a hard local scope, all variables are inherited from its parent
+   scope unless:
+
+   - an assignment would result in a modified *global* variable, or
+   - a variable is specifically marked with the keyword ``local``.
+
+Thus global variables are only inherited for reading but not for
+writing::
+
+    x,y = 1,2
     function foo()
-        global x=1, y="bar", z=3
+        x = 2 # assignment introduces a new local
+        return x + y # y refers to the global
     end
 
     julia> foo()
-    3
+    4
 
     julia> x
     1
 
-    julia> y
-    "bar"
+An explicit ``global`` is needed to assign to a global variable::
 
-    julia> z
-    3
+    x = 1
+    function foo()
+        global x = 2
+    end
+    foo()
+
+    julia> x
+    2
+
+Note that *nested functions* can behave differently to functions
+defined in the global scope as they can modify their parent scope's
+*local* variables::
+
+    x,y = 1,2
+    function foo()
+        x = 2 # introduces a new local
+        function bar()
+            x = 10 # modifies the parent's x
+            return x+y # y is global
+        end
+        return bar() + x # 12 + 10 (x is modified in call of bar())
+    end
+
+    julia> foo()
+    22  # (x,y unchanged)
+
+The distinction between inheriting global and local variables for
+assignment can lead to some slight differences between functions
+defined in local vs. global scopes.  Consider the modification of the
+last example by moving ``bar`` to the global scope::
+
+    x,y = 1,2
+    function bar()
+        x = 10 # local
+        return x+y
+    end
+    function foo()
+        x = 2 # local
+        return bar() + x # 12 + 2 (x is not modified)
+    end
+
+    julia> foo()
+    14 # as x is not modified anymore.
+       # (x,y unchanged)
+
+Note that above subtlety does not pertain to type and macro
+definitions as they can only appear at the global scope.
+There are special scoping rules concerning the evaluation of default
+and keyword function arguments which are described in the
+:ref:`Function section <man-evaluation-scope-default-values>`.
+
+
+An assignment introducing a variable used inside a function, type or
+macro definition need not come before its inner usage:
+
+.. doctest::
+
+    julia> f = y -> x + y
+    (anonymous function)
+
+    julia> f(3)
+    ERROR: UndefVarError: x not defined
+     in anonymous at none:1
+
+    julia> x = 1
+    1
+
+    julia> f(3)
+    4
+
+This behavior may seem slightly odd for a normal variable, but allows
+for named functions — which are just normal variables holding function
+objects — to be used before they are defined. This allows functions to
+be defined in whatever order is intuitive and convenient, rather than
+forcing bottom up ordering or requiring forward declarations, as long
+as they are defined by the time they are actually called.  As an
+example, here is an inefficient, mutually recursive way to test if
+positive integers are even or odd::
+
+    even(n) = n == 0 ? true  :  odd(n-1)
+    odd(n)  = n == 0 ? false : even(n-1)
+
+    julia> even(3)
+    false
+
+    julia> odd(3)
+    true
+
+Julia provides built-in, efficient functions to test for oddness and evenness
+called :func:`iseven` and :func:`isodd` so the above definitions should only be
+taken as examples.
+
+Hard vs. Soft Local Scope
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Blocks which introduce a soft local scope, such as loops, are
+generally used to manipulate the variables in their parent scope.
+Thus their default is to fully access all variables in their parent
+scope.
+
+Conversely, the code inside blocks which introduce a hard local scope
+(function, type and macro definitions) can be executed at any place in
+a program.  Remotely changing the state of global variables in other
+modules should be done with care and thus this is an opt-in feature
+requiring the ``global`` keyword.
+
+The reason to allow *modifying local* variables of parent scopes in
+nested functions is to allow constructing `closures
+<https://en.wikipedia.org/wiki/Closure_%28computer_programming%29>`_
+which have a private state, for instance the ``state`` variable in the
+following example::
+
+    let
+        state = 0
+        global counter
+        counter() = state += 1
+    end
+
+    julia> counter()
+    1
+
+    julia> counter()
+    2
+
+See also the closures in the examples in the next two sections.
+
+.. _man-let-blocks:
+
+Let Blocks
+^^^^^^^^^^
 
-The ``let`` statement provides a different way to introduce variables.
 Unlike assignments to local variables, ``let`` statements allocate new
-variable bindings each time they run. An assignment modifies an existing
-value location, and ``let`` creates new locations. This difference is
-usually not important, and is only detectable in the case of variables
-that outlive their scope via closures. The ``let`` syntax accepts a
-comma-separated series of assignments and variable names::
+variable bindings each time they run. An assignment modifies an
+existing value location, and ``let`` creates new locations. This
+difference is usually not important, and is only detectable in the
+case of variables that outlive their scope via closures. The ``let``
+syntax accepts a comma-separated series of assignments and variable
+names::
 
     let var1 = value1, var2, var3 = value3
         code
@@ -245,7 +397,7 @@ has been introduced. Therefore it makes sense to write something like
 ``let x = x`` since the two ``x`` variables are distinct and have separate
 storage. Here is an example where the behavior of ``let`` is needed::
 
-    Fs = cell(2)
+    Fs = Array(Any,2)
     i = 1
     while i <= 2
       Fs[i] = ()->i
@@ -263,7 +415,7 @@ However, it is always the same variable ``i``, so the two closures
 behave identically. We can use ``let`` to create a new binding for
 ``i``::
 
-    Fs = cell(2)
+    Fs = Array(Any,2)
     i = 1
     while i <= 2
       let i = i
@@ -296,15 +448,21 @@ block without creating any new bindings:
 Since ``let`` introduces a new scope block, the inner local ``x``
 is a different variable than the outer local ``x``.
 
+
+.. _man-for-loops-scope:
+
 For Loops and Comprehensions
-----------------------------
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 
-``for`` loops and :ref:`comprehensions <comprehensions>` have a special
-additional behavior: any new variables introduced in their body scopes are
-freshly allocated for each loop iteration. Therefore these constructs are
-similar to ``while`` loops with ``let`` blocks inside::
+``for`` loops and :ref:`comprehensions <comprehensions>` have the
+following behavior: any new variables introduced in their body scopes
+are freshly allocated for each loop iteration.  This is in contrast to
+``while`` loops which reuse the variables for all
+iterations. Therefore these constructs are similar to ``while`` loops
+with ``let`` blocks inside::
 
-    Fs = cell(2)
+    Fs = Array(Any,2)
     for i = 1:2
         Fs[i] = ()->i
     end
@@ -315,7 +473,7 @@ similar to ``while`` loops with ``let`` blocks inside::
     julia> Fs[2]()
     2
 
-``for`` loops will reuse existing variables for iteration::
+``for`` loops will reuse existing variables for its iteration variable::
 
     i = 0
     for i = 1:3
diff --git a/doc/manual/variables.rst b/doc/manual/variables.rst
index a347f6789676d..c2d374de36094 100644
--- a/doc/manual/variables.rst
+++ b/doc/manual/variables.rst
@@ -142,7 +142,7 @@ adopt the following conventions:
 - Names of variables are in lower case.
 - Word separation can be indicated by underscores (``'_'``), but use of
   underscores is discouraged unless the name would be hard to read otherwise.
-- Names of ``Type``\ s begin with a capital letter and word separation is
+- Names of ``Type``\ s and ``Module``\ s begin with a capital letter and word separation is
   shown with upper camel case instead of underscores.
 - Names of ``function``\ s and ``macro``\s are in lower case, without
   underscores.
diff --git a/doc/manual/workflow-tips.rst b/doc/manual/workflow-tips.rst
index 0068f836545b6..874d6a5daae79 100644
--- a/doc/manual/workflow-tips.rst
+++ b/doc/manual/workflow-tips.rst
@@ -21,48 +21,48 @@ The most basic Julia workflows involve using a text editor in
 conjunction with the ``julia`` command line. A common pattern includes
 the following elements:
 
- - **Put code under development in a temporary module.** Create a file,
-   say ``Tmp.jl``, and include within it ::
+- **Put code under development in a temporary module.** Create a file,
+  say ``Tmp.jl``, and include within it ::
 
-       module Tmp
+      module Tmp
 
-       <your definitions here>
+      <your definitions here>
 
-       end
+      end
 
- - **Put your test code in another file.** Create another file, say
-   ``tst.jl``, which begins with ::
+- **Put your test code in another file.** Create another file, say
+  ``tst.jl``, which begins with ::
 
-       import Tmp
+      import Tmp
 
-   and includes tests for the contents of ``Tmp``. The value of using
-   :obj:`import` versus :obj:`using` is that you can call :obj:`reload`
-   ``("Tmp")`` instead of having to restart the REPL when your
-   definitions change. Of course, the cost is the need to prepend
-   ``Tmp.`` to uses of names defined in your module. (You can lower that
-   cost by keeping your module name short.)
+  and includes tests for the contents of ``Tmp``. The value of using
+  :obj:`import` versus :obj:`using` is that you can call :obj:`reload`
+  ``("Tmp")`` instead of having to restart the REPL when your
+  definitions change. Of course, the cost is the need to prepend
+  ``Tmp.`` to uses of names defined in your module. (You can lower that
+  cost by keeping your module name short.)
 
-   Alternatively, you can wrap the contents of your test file in a
-   module, as ::
+  Alternatively, you can wrap the contents of your test file in a
+  module, as ::
 
-       module Tst
-           using Tmp
+      module Tst
+          using Tmp
 
-           <scratch work>
+          <scratch work>
 
-       end
+      end
 
-   The advantage is that you can now do :obj:`using` ``Tmp`` in your
-   test code and can therefore avoid prepending ``Tmp.`` everywhere.
-   The disadvantage is that code can no longer be selectively copied
-   to the REPL without some tweaking.
+  The advantage is that you can now do :obj:`using` ``Tmp`` in your
+  test code and can therefore avoid prepending ``Tmp.`` everywhere.
+  The disadvantage is that code can no longer be selectively copied
+  to the REPL without some tweaking.
 
- - **Lather. Rinse. Repeat.** Explore ideas at the ``julia`` command
-   prompt. Save good ideas in ``tst.jl``. Occasionally
-   restart the REPL, issuing ::
+- **Lather. Rinse. Repeat.** Explore ideas at the ``julia`` command
+  prompt. Save good ideas in ``tst.jl``. Occasionally
+  restart the REPL, issuing ::
 
-       reload("Tmp")
-       include("tst.jl")
+      reload("Tmp")
+      include("tst.jl")
 
 Simplify initialization
 ~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/doc/requirements.txt b/doc/requirements.txt
index e471f48715431..effc1bdd35f6b 100644
--- a/doc/requirements.txt
+++ b/doc/requirements.txt
@@ -1,2 +1,2 @@
--e git+https://github.com/JuliaLang/JuliaDoc.git@85c83a5c4ecd1716e0aa858d73322cc2058bc7b1#egg=JuliaDoc
+-e git+https://github.com/JuliaLang/JuliaDoc.git@fe343066983b33e6451c441bbe99a91d97a7e095#egg=JuliaDoc
 -e git+https://github.com/snide/sphinx_rtd_theme.git@21e875d3a53ce897089ad690d897252f6063349d#egg=sphinx_rtd_theme
diff --git a/doc/stdlib/arrays.rst b/doc/stdlib/arrays.rst
index 3f855a4301564..1764117ffec5c 100644
--- a/doc/stdlib/arrays.rst
+++ b/doc/stdlib/arrays.rst
@@ -13,7 +13,7 @@ Basic functions
 
    .. Docstring generated from Julia source
 
-   Returns the number of dimensions of ``A``
+   Returns the number of dimensions of ``A``\ .
 
 .. function:: size(A, [dim...])
 
@@ -51,31 +51,30 @@ Basic functions
 
    Example for a sparse 2-d array:
 
-   .. code-block:: julia
+   .. doctest::
 
-       julia> A = sprand(2, 3, 0.5)
-       2x3 sparse matrix with 4 Float64 entries:
-           [1, 1]  =  0.598888
-           [1, 2]  =  0.0230247
-           [1, 3]  =  0.486499
-           [2, 3]  =  0.809041
+       julia> A = sparse([1, 1, 2], [1, 3, 1], [1, 2, -5])
+       2x3 sparse matrix with 3 Int64 entries:
+               [1, 1]  =  1
+               [2, 1]  =  -5
+               [1, 3]  =  2
 
        julia> for iter in eachindex(A)
-                  @show iter.I_1, iter.I_2
+                  @show iter.I[1], iter.I[2]
                   @show A[iter]
               end
-       (iter.I_1,iter.I_2) = (1,1)
-       A[iter] = 0.5988881393454597
-       (iter.I_1,iter.I_2) = (2,1)
-       A[iter] = 0.0
-       (iter.I_1,iter.I_2) = (1,2)
-       A[iter] = 0.02302469881746183
-       (iter.I_1,iter.I_2) = (2,2)
-       A[iter] = 0.0
-       (iter.I_1,iter.I_2) = (1,3)
-       A[iter] = 0.4864987874354343
-       (iter.I_1,iter.I_2) = (2,3)
-       A[iter] = 0.8090413606455655
+       (iter.I[1],iter.I[2]) = (1,1)
+       A[iter] = 1
+       (iter.I[1],iter.I[2]) = (2,1)
+       A[iter] = -5
+       (iter.I[1],iter.I[2]) = (1,2)
+       A[iter] = 0
+       (iter.I[1],iter.I[2]) = (2,2)
+       A[iter] = 0
+       (iter.I[1],iter.I[2]) = (1,3)
+       A[iter] = 2
+       (iter.I[1],iter.I[2]) = (2,3)
+       A[iter] = 0
 
    If you supply more than one ``AbstractArray`` argument, ``eachindex`` will create an iterable object that is fast for all arguments (a ``UnitRange`` if all inputs have fast linear indexing, a CartesianRange otherwise).  If the arrays have different sizes and/or dimensionalities, ``eachindex`` returns an iterable that spans the largest range along each dimension.
 
@@ -101,7 +100,7 @@ Basic functions
 
    .. Docstring generated from Julia source
 
-   Convert an array to its complex conjugate in-place
+   Convert an array to its complex conjugate in-place.
 
 .. function:: stride(A, k)
 
@@ -113,7 +112,7 @@ Basic functions
 
    .. Docstring generated from Julia source
 
-   Returns a tuple of the memory strides in each dimension
+   Returns a tuple of the memory strides in each dimension.
 
 .. function:: ind2sub(dims, index) -> subscripts
 
@@ -127,13 +126,19 @@ Basic functions
 
    .. Docstring generated from Julia source
 
-   Returns a tuple of subscripts into array ``a`` corresponding to the linear index ``index``
+   Returns a tuple of subscripts into array ``a`` corresponding to the linear index ``index``\ .
 
 .. function:: sub2ind(dims, i, j, k...) -> index
 
    .. Docstring generated from Julia source
 
-   The inverse of ``ind2sub``\ , returns the linear index corresponding to the provided subscripts
+   The inverse of ``ind2sub``\ , returns the linear index corresponding to the provided subscripts.
+
+.. function:: LinAlg.checksquare(A)
+
+   .. Docstring generated from Julia source
+
+   Check that a matrix is square, then return its common dimension. For multiple arguments, return a vector.
 
 Constructors
 ------------
@@ -148,7 +153,7 @@ Constructors
 
    .. Docstring generated from Julia source
 
-   Construct a 1-d array of the specified type. This is usually called with the syntax ``Type[]``. Element values can be specified using ``Type[a,b,c,...]``.
+   Construct a 1-d array of the specified type. This is usually called with the syntax ``Type[]``\ . Element values can be specified using ``Type[a,b,c,...]``\ .
 
 .. function:: cell(dims)
 
@@ -184,13 +189,13 @@ Constructors
 
    .. Docstring generated from Julia source
 
-   Create a ``BitArray`` with all values set to ``true``
+   Create a ``BitArray`` with all values set to ``true``\ .
 
 .. function:: falses(dims)
 
    .. Docstring generated from Julia source
 
-   Create a ``BitArray`` with all values set to ``false``
+   Create a ``BitArray`` with all values set to ``false``\ .
 
 .. function:: fill(x, dims)
 
@@ -256,13 +261,13 @@ Constructors
 
    .. Docstring generated from Julia source
 
-   ``n``\ -by-``n`` identity matrix
+   ``n``\ -by-``n`` identity matrix.
 
 .. function:: eye(m, n)
 
    .. Docstring generated from Julia source
 
-   ``m``\ -by-``n`` identity matrix
+   ``m``\ -by-``n`` identity matrix.
 
 .. function:: eye(A)
 
@@ -270,7 +275,7 @@ Constructors
 
    Constructs an identity matrix of the same dimensions and type as ``A``\ .
 
-.. function:: linspace(start, stop, n=100)
+.. function:: linspace(start, stop, n=50)
 
    .. Docstring generated from Julia source
 
@@ -324,25 +329,25 @@ Indexing, Assignment, and Concatenation
 
    .. Docstring generated from Julia source
 
-   Returns a subset of array ``A`` as specified by ``inds``, where each ``ind`` may be an ``Int``, a ``Range``, or a ``Vector``. See the manual section on :ref:`array indexing <man-array-indexing>` for details.
+   Returns a subset of array ``A`` as specified by ``inds``\ , where each ``ind`` may be an ``Int``\ , a ``Range``\ , or a ``Vector``\ . See the manual section on :ref:`array indexing <man-array-indexing>` for details.
 
 .. function:: sub(A, inds...)
 
    .. Docstring generated from Julia source
 
-   Like :func:`getindex`, but returns a view into the parent array ``A`` with the given indices instead of making a copy.  Calling :func:`getindex` or :func:`setindex!` on the returned :obj:`SubArray` computes the indices to the parent array on the fly without checking bounds.
+   Like :func:`getindex`\ , but returns a view into the parent array ``A`` with the given indices instead of making a copy.  Calling :func:`getindex` or :func:`setindex!` on the returned :obj:`SubArray` computes the indices to the parent array on the fly without checking bounds.
 
 .. function:: parent(A)
 
    .. Docstring generated from Julia source
 
-   Returns the "parent array" of an array view type (e.g., ``SubArray``\ ), or the array itself if it is not a view
+   Returns the "parent array" of an array view type (e.g., ``SubArray``\ ), or the array itself if it is not a view.
 
 .. function:: parentindexes(A)
 
    .. Docstring generated from Julia source
 
-   From an array view ``A``\ , returns the corresponding indexes in the parent
+   From an array view ``A``\ , returns the corresponding indexes in the parent.
 
 .. function:: slicedim(A, d, i)
 
@@ -354,7 +359,7 @@ Indexing, Assignment, and Concatenation
 
    .. Docstring generated from Julia source
 
-   Returns a view of array ``A`` with the given indices like :func:`sub`, but drops all dimensions indexed with scalars.
+   Returns a view of array ``A`` with the given indices like :func:`sub`\ , but drops all dimensions indexed with scalars.
 
 .. function:: setindex!(A, X, inds...)
 
@@ -378,25 +383,52 @@ Indexing, Assignment, and Concatenation
 
    .. Docstring generated from Julia source
 
-   Concatenate the input arrays along the specified dimensions in the iterable ``dims``\ . For dimensions not in ``dims``\ , all input arrays should have the same size, which will also be the size of the output array along that dimension. For dimensions in ``dims``\ , the size of the output array is the sum of the sizes of the input arrays along that dimension. If ``dims`` is a single number, the different arrays are tightly stacked along that dimension. If ``dims`` is an iterable containing several dimensions, this allows to construct block diagonal matrices and their higher-dimensional analogues by simultaneously increasing several dimensions for every new input array and putting zero blocks elsewhere. For example, ``cat([1,2], matrices...)`` builds a block diagonal matrix, i.e. a block matrix with ``matrices[1]``\ , ``matrices[2]``\ , ... as diagonal blocks and matching zero blocks away from the diagonal.
+   Concatenate the input arrays along the specified dimensions in the iterable ``dims``\ . For dimensions not in ``dims``\ , all input arrays should have the same size, which will also be the size of the output array along that dimension. For dimensions in ``dims``\ , the size of the output array is the sum of the sizes of the input arrays along that dimension. If ``dims`` is a single number, the different arrays are tightly stacked along that dimension. If ``dims`` is an iterable containing several dimensions, this allows one to construct block diagonal matrices and their higher-dimensional analogues by simultaneously increasing several dimensions for every new input array and putting zero blocks elsewhere. For example, ``cat([1,2], matrices...)`` builds a block diagonal matrix, i.e. a block matrix with ``matrices[1]``\ , ``matrices[2]``\ , ... as diagonal blocks and matching zero blocks away from the diagonal.
 
 .. function:: vcat(A...)
 
    .. Docstring generated from Julia source
 
-   Concatenate along dimension 1
+   Concatenate along dimension 1.
 
 .. function:: hcat(A...)
 
    .. Docstring generated from Julia source
 
-   Concatenate along dimension 2
+   Concatenate along dimension 2.
 
 .. function:: hvcat(rows::Tuple{Vararg{Int}}, values...)
 
    .. Docstring generated from Julia source
 
-   Horizontal and vertical concatenation in one call. This function is called for block matrix syntax. The first argument specifies the number of arguments to concatenate in each block row. For example, ``[a b;c d e]`` calls ``hvcat((2,3),a,b,c,d,e)``\ .
+   Horizontal and vertical concatenation in one call. This function is called for block matrix syntax. The first argument specifies the number of arguments to concatenate in each block row.
+
+   .. doctest::
+
+       julia> a, b, c, d, e, f = 1, 2, 3, 4, 5, 6
+       (1,2,3,4,5,6)
+
+       julia> [a b c; d e f]
+       2x3 Array{Int64,2}:
+        1  2  3
+        4  5  6
+
+       julia> hvcat((3,3), a,b,c,d,e,f)
+       2x3 Array{Int64,2}:
+        1  2  3
+        4  5  6
+
+       julia> [a b;c d; e f]
+       3x2 Array{Int64,2}:
+        1  2
+        3  4
+        5  6
+
+       julia> hvcat((2,2,2), a,b,c,d,e,f)
+       3x2 Array{Int64,2}:
+        1  2
+        3  4
+        5  6
 
    If the first argument is a single integer ``n``\ , then all block rows are assumed to have ``n`` block columns.
 
@@ -518,7 +550,7 @@ Indexing, Assignment, and Concatenation
 
    .. Docstring generated from Julia source
 
-   Like :func:`permutedims`, except the inverse of the given permutation is applied.
+   Like :func:`permutedims`\ , except the inverse of the given permutation is applied.
 
 .. function:: permutedims!(dest, src, perm)
 
@@ -575,10 +607,7 @@ Array functions
 
    .. Docstring generated from Julia source
 
-   Cumulative product along a dimension ``dim`` (defaults to 1).
-   See also :func:`cumprod!` to use a preallocated output array,
-   both for performance and to control the precision of the
-   output (e.g. to avoid overflow).
+   Cumulative product along a dimension ``dim`` (defaults to 1). See also :func:`cumprod!` to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow).
 
 .. function:: cumprod!(B, A, [dim])
 
@@ -590,10 +619,7 @@ Array functions
 
    .. Docstring generated from Julia source
 
-   Cumulative sum along a dimension ``dim`` (defaults to 1).
-   See also :func:`cumsum!` to use a preallocated output array,
-   both for performance and to control the precision of the
-   output (e.g. to avoid overflow).
+   Cumulative sum along a dimension ``dim`` (defaults to 1). See also :func:`cumsum!` to use a preallocated output array, both for performance and to control the precision of the output (e.g. to avoid overflow).
 
 .. function:: cumsum!(B, A, [dim])
 
@@ -696,36 +722,17 @@ Array functions
 Combinatorics
 -------------
 
-.. function:: nthperm(v, k)
-
-   .. Docstring generated from Julia source
-
-   Compute the kth lexicographic permutation of a vector.
-
-.. function:: nthperm(p)
-
-   .. Docstring generated from Julia source
-
-   Return the ``k`` that generated permutation ``p``\ . Note that ``nthperm(nthperm([1:n], k)) == k`` for ``1 <= k <= factorial(n)``\ .
-
-.. function:: nthperm!(v, k)
-
-   .. Docstring generated from Julia source
-
-   In-place version of :func:`nthperm`.
-
 .. function:: randperm([rng,] n)
 
    .. Docstring generated from Julia source
 
-   Construct a random permutation of length ``n``. The optional ``rng`` argument
-   specifies a random number generator, see :ref:`Random Numbers <random-numbers>`.
+   Construct a random permutation of length ``n``\ . The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`\ .
 
 .. function:: invperm(v)
 
    .. Docstring generated from Julia source
 
-   Return the inverse permutation of v.
+   Return the inverse permutation of ``v``
 
 .. function:: isperm(v) -> Bool
 
@@ -745,29 +752,25 @@ Combinatorics
 
    .. Docstring generated from Julia source
 
-   Like permute!, but the inverse of the given permutation is applied.
+   Like ``permute!``\ , but the inverse of the given permutation is applied.
 
 .. function:: randcycle([rng,] n)
 
    .. Docstring generated from Julia source
 
-   Construct a random cyclic permutation of length ``n``. The optional ``rng``
-   argument specifies a random number generator, see :ref:`Random Numbers
-   <random-numbers>`.
+   Construct a random cyclic permutation of length ``n``\ . The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`\ .
 
 .. function:: shuffle([rng,] v)
 
    .. Docstring generated from Julia source
 
-   Return a randomly permuted copy of ``v``. The optional ``rng`` argument
-   specifies a random number generator, see :ref:`Random Numbers
-   <random-numbers>`.
+   Return a randomly permuted copy of ``v``\ . The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`\ .
 
 .. function:: shuffle!([rng,] v)
 
    .. Docstring generated from Julia source
 
-   In-place version of :func:`shuffle`.
+   In-place version of :func:`shuffle`\ .
 
 .. function:: reverse(v [, start=1 [, stop=length(v) ]] )
 
@@ -785,43 +788,7 @@ Combinatorics
 
    .. Docstring generated from Julia source
 
-   In-place version of :func:`reverse`.
-
-.. function:: combinations(array, n)
-
-   .. Docstring generated from Julia source
-
-   Generate all combinations of ``n`` elements from an indexable object. Because the number of combinations can be very large, this function returns an iterator object. Use ``collect(combinations(array,n))`` to get an array of all combinations.
-
-.. function:: permutations(array)
-
-   .. Docstring generated from Julia source
-
-   Generate all permutations of an indexable object. Because the number of permutations can be very large, this function returns an iterator object. Use ``collect(permutations(array))`` to get an array of all permutations.
-
-.. function:: partitions(n)
-
-   .. Docstring generated from Julia source
-
-   Generate all integer arrays that sum to ``n``\ . Because the number of partitions can be very large, this function returns an iterator object. Use ``collect(partitions(n))`` to get an array of all partitions. The number of partitions to generate can be efficiently computed using ``length(partitions(n))``\ .
-
-.. function:: partitions(n, m)
-
-   .. Docstring generated from Julia source
-
-   Generate all arrays of ``m`` integers that sum to ``n``\ . Because the number of partitions can be very large, this function returns an iterator object. Use ``collect(partitions(n,m))`` to get an array of all partitions. The number of partitions to generate can be efficiently computed using ``length(partitions(n,m))``\ .
-
-.. function:: partitions(array)
-
-   .. Docstring generated from Julia source
-
-   Generate all set partitions of the elements of an array, represented as arrays of arrays. Because the number of partitions can be very large, this function returns an iterator object. Use ``collect(partitions(array))`` to get an array of all partitions. The number of partitions to generate can be efficiently computed using ``length(partitions(array))``\ .
-
-.. function:: partitions(array, m)
-
-   .. Docstring generated from Julia source
-
-   Generate all set partitions of the elements of an array into exactly m subsets, represented as arrays of arrays. Because the number of partitions can be very large, this function returns an iterator object. Use ``collect(partitions(array,m))`` to get an array of all partitions. The number of partitions into m subsets is equal to the Stirling number of the second kind and can be efficiently computed using ``length(partitions(array,m))``\ .
+   In-place version of :func:`reverse`\ .
 
 BitArrays
 ---------
@@ -830,19 +797,19 @@ BitArrays
 
    .. Docstring generated from Julia source
 
-   Converts a numeric array to a packed boolean array
+   Converts a numeric array to a packed boolean array.
 
 .. function:: bitunpack(B::BitArray{N}) -> Array{Bool,N}
 
    .. Docstring generated from Julia source
 
-   Converts a packed boolean array to an array of booleans
+   Converts a packed boolean array to an array of booleans.
 
 .. function:: flipbits!(B::BitArray{N}) -> BitArray{N}
 
    .. Docstring generated from Julia source
 
-   Performs a bitwise not operation on ``B``. See :ref:`~ operator <~>`.
+   Performs a bitwise not operation on ``B``\ . See :ref:`~ operator <~>`\ .
 
 .. function:: rol!(dest::BitArray{1}, src::BitArray{1}, i::Integer) -> BitArray{1}
 
@@ -882,28 +849,31 @@ BitArrays
 
 .. _stdlib-sparse:
 
-Sparse Matrices
----------------
+Sparse Vectors and Matrices
+---------------------------
 
-Sparse matrices support much of the same set of operations as dense matrices. The following functions are specific to sparse matrices.
+Sparse vectors and matrices largely support the same set of operations as their
+dense counterparts. The following functions are specific to sparse arrays.
 
-.. function:: sparse(I,J,V,[m,n,combine])
+.. function:: sparse(I, J, V,[ m, n, combine])
 
    .. Docstring generated from Julia source
 
-   Create a sparse matrix ``S`` of dimensions ``m x n`` such that ``S[I[k], J[k]] = V[k]``\ . The ``combine`` function is used to combine duplicates. If ``m`` and ``n`` are not specified, they are set to ``maximum(I)`` and ``maximum(J)`` respectively. If the ``combine`` function is not supplied, duplicates are added by default. All elements of ``I`` must satisfy ``1 <= I[k] <= m``\ , and all elements of ``J`` must satisfy ``1 <= J[k] <= n``\ .
+   Create a sparse matrix ``S`` of dimensions ``m x n`` such that ``S[I[k], J[k]] = V[k]``\ . The ``combine`` function is used to combine duplicates. If ``m`` and ``n`` are not specified, they are set to ``maximum(I)`` and ``maximum(J)`` respectively. If the ``combine`` function is not supplied, ``combine`` defaults to ``+`` unless the elements of ``V`` are Booleans in which case ``combine`` defaults to ``|``\ . All elements of ``I`` must satisfy ``1 <= I[k] <= m``\ , and all elements of ``J`` must satisfy ``1 <= J[k] <= n``\ . Numerical zeros in (``I``\ , ``J``\ , ``V``\ ) are retained as structural nonzeros; to drop numerical zeros, use ``dropzeros!``\ .
+
+   For additional documentation and an expert driver, see ``Base.SparseArrays.sparse!``\ .
 
 .. function:: sparsevec(I, V, [m, combine])
 
    .. Docstring generated from Julia source
 
-   Create a sparse matrix ``S`` of size ``m x 1`` such that ``S[I[k]] = V[k]``\ . Duplicates are combined using the ``combine`` function, which defaults to ``+`` if it is not provided. In julia, sparse vectors are really just sparse matrices with one column. Given Julia's Compressed Sparse Columns (CSC) storage format, a sparse column matrix with one column is sparse, whereas a sparse row matrix with one row ends up being dense.
+   Create a sparse vector ``S`` of length ``m`` such that ``S[I[k]] = V[k]``\ . Duplicates are combined using the ``combine`` function, which defaults to ``+`` if no ``combine`` argument is provided, unless the elements of ``V`` are Booleans in which case ``combine`` defaults to ``|``\ .
 
 .. function:: sparsevec(D::Dict, [m])
 
    .. Docstring generated from Julia source
 
-   Create a sparse matrix of size ``m x 1`` where the row values are keys from the dictionary, and the nonzero values are the values from the dictionary.
+   Create a sparse vector of length ``m`` where the nonzero indices are keys from the dictionary, and the nonzero values are the values from the dictionary.
 
 .. function:: issparse(S)
 
@@ -921,61 +891,67 @@ Sparse matrices support much of the same set of operations as dense matrices. Th
 
    .. Docstring generated from Julia source
 
-   Convert a dense vector ``A`` into a sparse matrix of size ``m x 1``\ . In julia, sparse vectors are really just sparse matrices with one column.
+   Convert a vector ``A`` into a sparse vector of length ``m``\ .
 
 .. function:: full(S)
 
    .. Docstring generated from Julia source
 
-   Convert a sparse matrix ``S`` into a dense matrix.
+   Convert a sparse matrix or vector ``S`` into a dense matrix or vector.
 
 .. function:: nnz(A)
 
    .. Docstring generated from Julia source
 
-   Returns the number of stored (filled) elements in a sparse matrix.
+   Returns the number of stored (filled) elements in a sparse array.
 
-.. function:: spzeros(m,n)
+.. function:: spzeros([type,]m[,n])
 
    .. Docstring generated from Julia source
 
-   Create a sparse matrix of size ``m x n``\ . This sparse matrix will not contain any nonzero values. No storage will be allocated for nonzero values during construction.
+   Create a sparse vector of length ``m`` or sparse matrix of size ``m x n``\ . This sparse array will not contain any nonzero values. No storage will be allocated for nonzero values during construction. The type defaults to ``Float64`` if not specified.
 
 .. function:: spones(S)
 
    .. Docstring generated from Julia source
 
-   Create a sparse matrix with the same structure as that of ``S``\ , but with every nonzero element having the value ``1.0``\ .
+   Create a sparse array with the same structure as that of ``S``\ , but with every nonzero element having the value ``1.0``\ .
+
+.. function:: speye([type,]m[,n])
+
+   .. Docstring generated from Julia source
+
+   Create a sparse identity matrix of size ``m x m``\ . When ``n`` is supplied, create a sparse identity matrix of size ``m x n``\ . The type defaults to ``Float64`` if not specified.
 
-.. function:: speye(type,m[,n])
+.. function:: speye(S)
 
    .. Docstring generated from Julia source
 
-   Create a sparse identity matrix of specified type of size ``m x m``\ . In case ``n`` is supplied, create a sparse identity matrix of size ``m x n``\ .
+   Create a sparse identity matrix with the same structure as that of  ``S``\ .
 
 .. function:: spdiagm(B, d[, m, n])
 
    .. Docstring generated from Julia source
 
-   Construct a sparse diagonal matrix. ``B`` is a tuple of vectors containing the diagonals and ``d`` is a tuple containing the positions of the diagonals. In the case the input contains only one diagonaly, ``B`` can be a vector (instead of a tuple) and ``d`` can be the diagonal position (instead of a tuple), defaulting to 0 (diagonal). Optionally, ``m`` and ``n`` specify the size of the resulting sparse matrix.
+   Construct a sparse diagonal matrix. ``B`` is a tuple of vectors containing the diagonals and ``d`` is a tuple containing the positions of the diagonals. In the case the input contains only one diagonal, ``B`` can be a vector (instead of a tuple) and ``d`` can be the diagonal position (instead of a tuple), defaulting to 0 (diagonal). Optionally, ``m`` and ``n`` specify the size of the resulting sparse matrix.
 
-.. function:: sprand([rng,] m,n,p [,rfn])
+.. function:: sprand([rng],m,[n],p::AbstractFloat,[rfn])
 
    .. Docstring generated from Julia source
 
-   Create a random ``m`` by ``n`` sparse matrix, in which the probability of any element being nonzero is independently given by ``p`` (and hence the mean density of nonzeros is also exactly ``p``). Nonzero values are sampled from the distribution specified by ``rfn``. The uniform distribution is used in case ``rfn`` is not specified. The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`.
+   Create a random length ``m`` sparse vector or ``m`` by ``n`` sparse matrix, in which the probability of any element being nonzero is independently given by ``p`` (and hence the mean density of nonzeros is also exactly ``p``\ ). Nonzero values are sampled from the distribution specified by ``rfn``\ . The uniform distribution is used in case ``rfn`` is not specified. The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`\ .
 
-.. function:: sprandn(m,n,p)
+.. function:: sprandn(m[,n],p::AbstractFloat)
 
    .. Docstring generated from Julia source
 
-   Create a random ``m`` by ``n`` sparse matrix with the specified (independent) probability ``p`` of any entry being nonzero, where nonzero values are sampled from the normal distribution.
+   Create a random sparse vector of length ``m`` or sparse matrix of size ``m`` by ``n`` with the specified (independent) probability ``p`` of any entry being nonzero, where nonzero values are sampled from the normal distribution.
 
-.. function:: sprandbool(m,n,p)
+.. function:: sprandbool(m[,n],p)
 
    .. Docstring generated from Julia source
 
-   Create a random ``m`` by ``n`` sparse boolean matrix with the specified (independent) probability ``p`` of any entry being ``true``\ .
+   Create a random ``m`` by ``n`` sparse boolean matrix or length ``m`` sparse boolean vector with the specified (independent) probability ``p`` of any entry being ``true``\ .
 
 .. function:: etree(A[, post])
 
@@ -987,21 +963,21 @@ Sparse matrices support much of the same set of operations as dense matrices. Th
 
    .. Docstring generated from Julia source
 
-   Return the symmetric permutation of ``A``\ , which is ``A[p,p]``\ . ``A`` should be symmetric and sparse, where only the upper triangular part of the matrix is stored. This algorithm ignores the lower triangular part of the matrix. Only the upper triangular part of the result is returned as well.
+   Return the symmetric permutation of ``A``\ , which is ``A[p,p]``\ . ``A`` should be symmetric, sparse, and only contain nonzeros in the upper triangular part of the matrix is stored. This algorithm ignores the lower triangular part of the matrix. Only the upper triangular part of the result is returned.
 
 .. function:: nonzeros(A)
 
    .. Docstring generated from Julia source
 
-   Return a vector of the structural nonzero values in sparse matrix ``A``\ . This includes zeros that are explicitly stored in the sparse matrix. The returned vector points directly to the internal nonzero storage of ``A``\ , and any modifications to the returned vector will mutate ``A`` as well. See ``rowvals(A)`` and ``nzrange(A, col)``\ .
+   Return a vector of the structural nonzero values in sparse array ``A``\ . This includes zeros that are explicitly stored in the sparse array. The returned vector points directly to the internal nonzero storage of ``A``\ , and any modifications to the returned vector will mutate ``A`` as well. See ``rowvals(A)`` and ``nzrange(A, col)``\ .
 
-.. function:: rowvals(A)
+.. function:: rowvals(A::SparseMatrixCSC)
 
    .. Docstring generated from Julia source
 
-   Return a vector of the row indices of ``A``\ , and any modifications to the returned vector will mutate ``A`` as well. Given the internal storage format of sparse matrices, providing access to how the row indices are stored internally can be useful in conjuction with iterating over structural nonzero values. See ``nonzeros(A)`` and ``nzrange(A, col)``\ .
+   Return a vector of the row indices of ``A``\ . Any modifications to the returned vector will mutate ``A`` as well. Providing access to how the row indices are stored internally can be useful in conjunction with iterating over structural nonzero values. See also ``nonzeros(A)`` and ``nzrange(A, col)``\ .
 
-.. function:: nzrange(A, col)
+.. function:: nzrange(A::SparseMatrixCSC, col)
 
    .. Docstring generated from Julia source
 
diff --git a/doc/stdlib/base.rst b/doc/stdlib/base.rst
index 931f92c2d2b0d..afcc79fe74124 100644
--- a/doc/stdlib/base.rst
+++ b/doc/stdlib/base.rst
@@ -30,7 +30,7 @@ Getting Around
 
    .. Docstring generated from Julia source
 
-   Quit the program indicating that the processes completed successfully. This function calls ``exit(0)`` (see :func:`exit`).
+   Quit the program indicating that the processes completed successfully. This function calls ``exit(0)`` (see :func:`exit`\ ).
 
 .. function:: atexit(f)
 
@@ -64,11 +64,11 @@ Getting Around
 
    Compute the amount of memory used by all unique objects reachable from the argument. Keyword argument ``exclude`` specifies a type of objects to exclude from the traversal.
 
-.. function:: edit(file::AbstractString, [line])
+.. function:: edit(path::AbstractString, [line])
 
    .. Docstring generated from Julia source
 
-   Edit a file optionally providing a line number to edit at. Returns to the julia prompt when you quit the editor.
+   Edit a file or directory optionally providing a line number to edit the file at. Returns to the julia prompt when you quit the editor.
 
 .. function:: edit(function, [types])
 
@@ -126,13 +126,13 @@ Getting Around
 
    Loads a source files, in the context of the ``Main`` module, on every active node, searching standard locations for files. ``require`` is considered a top-level operation, so it sets the current ``include`` path but does not use it to search for files (see help for ``include``\ ). This function is typically used to load library code, and is implicitly called by ``using`` to load packages.
 
-   When searching for files, ``require`` first looks in the current working directory, then looks for package code under ``Pkg.dir()``\ , then tries paths in the global array ``LOAD_PATH``\ .
+   When searching for files, ``require`` first looks for package code under ``Pkg.dir()``\ , then tries paths in the global array ``LOAD_PATH``\ .
 
 .. function:: Base.compilecache(module::ByteString)
 
    .. Docstring generated from Julia source
 
-   Creates a precompiled cache file for module (see help for ``require``) and all of its dependencies. This can be used to reduce package load times. Cache files are stored in ``LOAD_CACHE_PATH[1]``, which defaults to ``~/.julia/lib/VERSION``. See :ref:`Module initialization and precompilation <man-modules-initialization-precompilation>` for important notes.
+   Creates a precompiled cache file for module (see help for ``require``\ ) and all of its dependencies. This can be used to reduce package load times. Cache files are stored in ``LOAD_CACHE_PATH[1]``\ , which defaults to ``~/.julia/lib/VERSION``\ . See :ref:`Module initialization and precompilation <man-modules-initialization-precompilation>` for important notes.
 
 .. function:: __precompile__(isprecompilable::Bool=true)
 
@@ -142,6 +142,8 @@ Getting Around
 
    If a module or file is *not* safely precompilable, it should call ``__precompile__(false)`` in order to throw an error if Julia attempts to precompile it.
 
+   ``__precompile__()`` should *not* be used in a module unless all of its dependencies are also using ``__precompile__()``\ . Failure to do so can result in a runtime error when loading the module.
+
 .. function:: include(path::AbstractString)
 
    .. Docstring generated from Julia source
@@ -166,7 +168,7 @@ Getting Around
 
    .. Docstring generated from Julia source
 
-   Search through all documention for a string, ignoring case.
+   Search through all documentation for a string, ignoring case.
 
 .. function:: which(f, types)
 
@@ -306,7 +308,7 @@ All Objects
 
    Get a unique integer id for ``x``\ . ``object_id(x)==object_id(y)`` if and only if ``is(x,y)``\ .
 
-.. function:: hash(x[, h])
+.. function:: hash(x[, h::UInt])
 
    .. Docstring generated from Julia source
 
@@ -342,47 +344,46 @@ All Objects
 
    While it isn't normally necessary, user-defined types can override the default ``deepcopy`` behavior by defining a specialized version of the function ``deepcopy_internal(x::T, dict::ObjectIdDict)`` (which shouldn't otherwise be used), where ``T`` is the type to be specialized for, and ``dict`` keeps track of objects copied so far within the recursion. Within the definition, ``deepcopy_internal`` should be used in place of ``deepcopy``\ , and the ``dict`` variable should be updated as appropriate before returning.
 
-.. function:: isdefined([object,] index | symbol)
+.. function:: isdefined([m::Module,] s::Symbol)
+              isdefined(object, s::Symbol)
+              isdefined(a::AbstractArray, index::Int)
 
    .. Docstring generated from Julia source
 
-   Tests whether an assignable location is defined. The arguments can be an array and index, a composite object and field name (as a symbol), or a module and a symbol. With a single symbol argument, tests whether a global variable with that name is defined in ``current_module()``\ .
+   Tests whether an assignable location is defined. The arguments can be a module and a symbol, a composite object and field name (as a symbol), or an array and index. With a single symbol argument, tests whether a global variable with that name is defined in ``current_module()``\ .
 
 .. function:: convert(T, x)
 
    .. Docstring generated from Julia source
 
-   Convert ``x`` to a value of type ``T``.
+   Convert ``x`` to a value of type ``T``\ .
 
-   If ``T`` is an ``Integer`` type, an :exc:`InexactError` will be raised if
-   ``x`` is not representable by ``T``, for example if ``x`` is not
-   integer-valued, or is outside the range supported by ``T``.
+   If ``T`` is an ``Integer`` type, an :exc:`InexactError` will be raised if ``x`` is not representable by ``T``\ , for example if ``x`` is not integer-valued, or is outside the range supported by ``T``\ .
 
    .. doctest::
 
-      julia> convert(Int, 3.0)
-      3
+       julia> convert(Int, 3.0)
+       3
 
-      julia> convert(Int, 3.5)
-      ERROR: InexactError()
-       in convert at int.jl:209
+       julia> convert(Int, 3.5)
+       ERROR: InexactError()
+        in convert at int.jl:209
 
-   If ``T`` is a :obj:`AbstractFloat` or :obj:`Rational` type, then it will return
-   the closest value to ``x`` representable by ``T``.
+   If ``T`` is a :obj:`AbstractFloat` or :obj:`Rational` type, then it will return the closest value to ``x`` representable by ``T``\ .
 
    .. doctest::
 
-      julia> x = 1/3
-      0.3333333333333333
+       julia> x = 1/3
+       0.3333333333333333
 
-      julia> convert(Float32, x)
-      0.33333334f0
+       julia> convert(Float32, x)
+       0.33333334f0
 
-      julia> convert(Rational{Int32}, x)
-      1//3
+       julia> convert(Rational{Int32}, x)
+       1//3
 
-      julia> convert(Rational{Int64}, x)
-      6004799503160661//18014398509481984
+       julia> convert(Rational{Int64}, x)
+       6004799503160661//18014398509481984
 
 .. function:: promote(xs...)
 
@@ -396,11 +397,11 @@ All Objects
 
    Convert ``y`` to the type of ``x`` (``convert(typeof(x), y)``\ ).
 
-.. function:: widen(type | x)
+.. function:: widen(x)
 
    .. Docstring generated from Julia source
 
-   If the argument is a type, return a "larger" type (for numeric types, this will be a type with at least as much range and precision as the argument, and usually more). Otherwise the argument ``x`` is converted to ``widen(typeof(x))``\ .
+   If ``x`` is a type, return a "larger" type (for numeric types, this will be a type with at least as much range and precision as the argument, and usually more). Otherwise ``x`` is converted to ``widen(typeof(x))``\ .
 
    .. doctest::
 
@@ -419,7 +420,7 @@ All Objects
 Types
 -----
 
-.. function:: super(T::DataType)
+.. function:: supertype(T::DataType)
 
    .. Docstring generated from Julia source
 
@@ -521,30 +522,30 @@ Types
 
    Assign ``x`` to a named field in ``value`` of composite type. The syntax ``a.b = c`` calls ``setfield!(a, :b, c)``\ , and the syntax ``a.(b) = c`` calls ``setfield!(a, b, c)``\ .
 
-.. function:: fieldoffsets(type)
+.. function:: fieldoffset(type, i)
 
    .. Docstring generated from Julia source
 
-   The byte offset of each field of a type relative to the data start. For example, we could use it in the following manner to summarize information about a struct type:
+   The byte offset of field ``i`` of a type relative to the data start. For example, we could use it in the following manner to summarize information about a struct type:
 
    .. doctest::
 
-       julia> structinfo(T) = [zip(fieldoffsets(T),fieldnames(T),T.types)...];
-
-       julia> structinfo(StatStruct)
-       12-element Array{Tuple{Int64,Symbol,DataType},1}:
-        (0,:device,UInt64)
-        (8,:inode,UInt64)
-        (16,:mode,UInt64)
-        (24,:nlink,Int64)
-        (32,:uid,UInt64)
-        (40,:gid,UInt64)
-        (48,:rdev,UInt64)
-        (56,:size,Int64)
-        (64,:blksize,Int64)
-        (72,:blocks,Int64)
-        (80,:mtime,Float64)
-        (88,:ctime,Float64)
+       julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:nfields(T)];
+
+       julia> structinfo(Base.Filesystem.StatStruct)
+       12-element Array{Tuple{UInt64,Symbol,Type{_}},1}:
+        (0x0000000000000000,:device,UInt64)
+        (0x0000000000000008,:inode,UInt64)
+        (0x0000000000000010,:mode,UInt64)
+        (0x0000000000000018,:nlink,Int64)
+        (0x0000000000000020,:uid,UInt64)
+        (0x0000000000000028,:gid,UInt64)
+        (0x0000000000000030,:rdev,UInt64)
+        (0x0000000000000038,:size,Int64)
+        (0x0000000000000040,:blksize,Int64)
+        (0x0000000000000048,:blocks,Int64)
+        (0x0000000000000050,:mtime,Float64)
+        (0x0000000000000058,:ctime,Float64)
 
 .. function:: fieldtype(T, name::Symbol | index::Int)
 
@@ -556,8 +557,7 @@ Types
 
    .. Docstring generated from Julia source
 
-   Return ``true`` iff value ``v`` is immutable.  See :ref:`man-immutable-composite-types` for a discussion of immutability.
-   Note that this function works on values, so if you give it a type, it will tell you that a value of ``DataType`` is mutable.
+   Return ``true`` iff value ``v`` is immutable.  See :ref:`man-immutable-composite-types` for a discussion of immutability. Note that this function works on values, so if you give it a type, it will tell you that a value of ``DataType`` is mutable.
 
 .. function:: isbits(T)
 
@@ -601,17 +601,17 @@ Types
 
    .. Docstring generated from Julia source
 
-   Create an :obj:`Enum` type with name ``EnumName`` and enum member values of ``EnumValue1`` and ``EnumValue2`` with optional assigned values of ``x`` and ``y``, respectively. ``EnumName`` can be used just like other types and enum member values as regular values, such as
+   Create an :obj:`Enum` type with name ``EnumName`` and enum member values of ``EnumValue1`` and ``EnumValue2`` with optional assigned values of ``x`` and ``y``\ , respectively. ``EnumName`` can be used just like other types and enum member values as regular values, such as
 
    .. doctest::
 
-      julia> @enum FRUIT apple=1 orange=2 kiwi=3
+       julia> @enum FRUIT apple=1 orange=2 kiwi=3
 
-      julia> f(x::FRUIT) = "I'm a FRUIT with value: $(Int(x))"
-      f (generic function with 1 method)
+       julia> f(x::FRUIT) = "I'm a FRUIT with value: $(Int(x))"
+       f (generic function with 1 method)
 
-      julia> f(apple)
-      "I'm a FRUIT with value: 1"
+       julia> f(apple)
+       "I'm a FRUIT with value: 1"
 
 .. function:: instances(T::Type)
 
@@ -630,8 +630,8 @@ Generic Functions
 
    .. doctest::
 
-   	julia> method_exists(length, Tuple{Array})
-   	true
+       julia> method_exists(length, Tuple{Array})
+       true
 
 .. function:: applicable(f, args...) -> Bool
 
@@ -699,8 +699,7 @@ Syntax
 
    .. Docstring generated from Julia source
 
-   Only valid in the context of an ``Expr`` returned from a macro. Prevents the macro hygiene pass from turning embedded variables into gensym variables. See the :ref:`man-macros`
-   section of the Metaprogramming chapter of the manual for more details and examples.
+   Only valid in the context of an ``Expr`` returned from a macro. Prevents the macro hygiene pass from turning embedded variables into gensym variables. See the :ref:`man-macros` section of the Metaprogramming chapter of the manual for more details and examples.
 
 .. function:: gensym([tag])
 
@@ -739,15 +738,13 @@ Nullables
 
    .. Docstring generated from Julia source
 
-   Attempt to access the value of the ``Nullable`` object, ``x``. Returns the
-   value if it is present; otherwise, throws a ``NullException``.
+   Attempt to access the value of the ``Nullable`` object, ``x``\ . Returns the value if it is present; otherwise, throws a ``NullException``\ .
 
 .. function:: get(x, y)
 
    .. Docstring generated from Julia source
 
-   Attempt to access the value of the ``Nullable{T}`` object, ``x``. Returns
-   the value if it is present; otherwise, returns ``convert(T, y)``.
+   Attempt to access the value of the ``Nullable{T}`` object, ``x``\ . Returns the value if it is present; otherwise, returns ``convert(T, y)``\ .
 
 .. function:: isnull(x)
 
@@ -773,7 +770,7 @@ System
 .. data:: DevNull
 
    Used in a stream redirect to discard all data written to it. Essentially equivalent to /dev/null on Unix or NUL on Windows.
-   Usage: ``run(`cat test.txt` |> DevNull)``
+   Usage: ``run(pipeline(`cat test.txt`, DevNull))``
 
 .. function:: success(command)
 
@@ -799,27 +796,6 @@ System
 
    Send a signal to a process. The default is to terminate the process.
 
-.. function:: open(command, mode::AbstractString="r", stdio=DevNull)
-
-   .. Docstring generated from Julia source
-
-   Start running ``command`` asynchronously, and return a tuple
-   ``(stream,process)``.  If ``mode`` is ``"r"``, then ``stream``
-   reads from the process's standard output and ``stdio`` optionally
-   specifies the process's standard input stream.  If ``mode`` is
-   ``"w"``, then ``stream`` writes to the process's standard input
-   and ``stdio`` optionally specifies the process's standard output
-   stream.
-
-.. function:: open(f::Function, command, mode::AbstractString="r", stdio=DevNull)
-
-   .. Docstring generated from Julia source
-
-   Similar to ``open(command, mode, stdio)``, but calls ``f(stream)``
-   on the resulting read or write stream, then closes the stream
-   and waits for the process to complete.  Returns the value returned
-   by ``f``.
-
 .. function:: Sys.set_process_title(title::AbstractString)
 
    .. Docstring generated from Julia source
@@ -850,6 +826,26 @@ System
 
    Mark a command object so that it will be run in a new process group, allowing it to outlive the julia process, and not have Ctrl-C interrupts passed to it.
 
+.. function:: Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide,
+                            env, dir)
+
+   .. Docstring generated from Julia source
+
+   Construct a new ``Cmd`` object, representing an external program and arguments, from ``cmd``\ , while changing the settings of the optional keyword arguments:
+
+   * ``ignorestatus::Bool``\ : If ``true`` (defaults to ``false``\ ), then the ``Cmd``   will not throw an error if the return code is nonzero.
+   * ``detach::Bool``\ : If ``true`` (defaults to ``false``\ ), then the ``Cmd`` will be   run in a new process group, allowing it to outlive the ``julia`` process   and not have Ctrl-C passed to it.
+   * ``windows_verbatim::Bool``\ : If ``true`` (defaults to ``false``\ ), then on Windows   the ``Cmd`` will send a command-line string to the process with no quoting   or escaping of arguments, even arguments containing spaces.  (On Windows,   arguments are sent to a program as a single "command-line" string, and   programs are responsible for parsing it into arguments.  By default,   empty arguments and arguments with spaces or tabs are quoted with double   quotes ``"`` in the command line, and ``\`` or ``"`` are preceded by backslashes.   ``windows_verbatim=true`` is useful for launching programs that parse their   command line in nonstandard ways.)  Has no effect on non-Windows systems.
+   * ``windows_hide::Bool``\ : If ``true`` (defaults to ``false``\ ), then on Windows no   new console window is displayed when the ``Cmd`` is executed.  This has   no effect if a console is already open or on non-Windows systems.
+   * ``env``\ : Set environment variables to use when running the ``Cmd``\ .  ``env``   is either a dictionary mapping strings to strings, an array   of strings of the form ``"var=val"``\ , an array or tuple of ``"var"=>val``   pairs, or ``nothing``\ .  In order to modify (rather than replace)   the existing environment, create ``env`` by ``copy(ENV)`` and then   set ``env["var"]=val`` as desired.
+   * ``dir::AbstractString``\ : Specify a working directory for the command (instead   of the current directory).
+
+   For any keywords that are not specified, the current settings from ``cmd`` are used.   Normally, to create a ``Cmd`` object in the first place, one uses backticks, e.g.
+
+   .. code-block:: julia
+
+       Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)
+
 .. function:: setenv(command, env; dir=working_dir)
 
    .. Docstring generated from Julia source
@@ -872,9 +868,11 @@ System
 
    **Examples**:
 
-     * ``run(pipeline(`ls`, `grep xyz`))``
-     * ``run(pipeline(`ls`, "out.txt"))``
-     * ``run(pipeline("out.txt", `grep xyz`))``
+   .. code-block:: julia
+
+       run(pipeline(`ls`, `grep xyz`))
+       run(pipeline(`ls`, "out.txt"))
+       run(pipeline("out.txt", `grep xyz`))
 
 .. function:: pipeline(command; stdin, stdout, stderr, append=false)
 
@@ -884,8 +882,10 @@ System
 
    **Examples**:
 
-     * ``run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))``
-     * ``run(pipeline(`update`, stdout="log.txt", append=true))``
+   .. code-block:: julia
+
+       run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
+       run(pipeline(`update`, stdout="log.txt", append=true))
 
 .. function:: gethostname() -> AbstractString
 
@@ -893,11 +893,11 @@ System
 
    Get the local machine's host name.
 
-.. function:: getipaddr() -> AbstractString
+.. function:: getipaddr() -> IPAddr
 
    .. Docstring generated from Julia source
 
-   Get the IP address of the local machine, as a string of the form "x.x.x.x".
+   Get the IP address of the local machine.
 
 .. function:: getpid() -> Int32
 
@@ -921,19 +921,19 @@ System
 
    .. Docstring generated from Julia source
 
-   Set a timer to be read by the next call to :func:`toc` or :func:`toq`. The macro call ``@time expr`` can also be used to time evaluation.
+   Set a timer to be read by the next call to :func:`toc` or :func:`toq`\ . The macro call ``@time expr`` can also be used to time evaluation.
 
 .. function:: toc()
 
    .. Docstring generated from Julia source
 
-   Print and return the time elapsed since the last :func:`tic`.
+   Print and return the time elapsed since the last :func:`tic`\ .
 
 .. function:: toq()
 
    .. Docstring generated from Julia source
 
-   Return, but do not print, the time elapsed since the last :func:`tic`.
+   Return, but do not print, the time elapsed since the last :func:`tic`\ .
 
 .. function:: @time
 
@@ -979,25 +979,49 @@ System
 
    .. Docstring generated from Julia source
 
-   Given ``@unix? a : b``\ , do ``a`` on Unix systems (including Linux and OS X) and ``b`` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
+   Given ``@unix? a : b``\ , do ``a`` on Unix systems (including Linux and OS X) and ``b`` elsewhere. See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
+
+.. function:: @unix_only
+
+   .. Docstring generated from Julia source
+
+   A macro that evaluates the given expression only on Unix systems (including Linux and OS X). See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
 
 .. function:: @osx
 
    .. Docstring generated from Julia source
 
-   Given ``@osx? a : b``\ , do ``a`` on OS X and ``b`` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
+   Given ``@osx? a : b``\ , do ``a`` on OS X and ``b`` elsewhere. See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
+
+.. function:: @osx_only
+
+   .. Docstring generated from Julia source
+
+   A macro that evaluates the given expression only on OS X systems. See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
 
 .. function:: @linux
 
    .. Docstring generated from Julia source
 
-   Given ``@linux? a : b``\ , do ``a`` on Linux and ``b`` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
+   Given ``@linux? a : b``\ , do ``a`` on Linux and ``b`` elsewhere. See documentation :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
+
+.. function:: @linux_only
+
+   .. Docstring generated from Julia source
+
+   A macro that evaluates the given expression only on Linux systems. See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
 
 .. function:: @windows
 
    .. Docstring generated from Julia source
 
-   Given ``@windows? a : b``\ , do ``a`` on Windows and ``b`` elsewhere. See documentation for Handling Platform Variations in the Calling C and Fortran Code section of the manual.
+   Given ``@windows? a : b``\ , do ``a`` on Windows and ``b`` elsewhere. See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
+
+.. function:: @windows_only
+
+   .. Docstring generated from Julia source
+
+   A macro that evaluates the given expression only on Windows systems. See documentation in :ref:`Handling Operating System Variation <man-handling-operating-system-variation>`\ .
 
 Errors
 ------
@@ -1006,13 +1030,13 @@ Errors
 
    .. Docstring generated from Julia source
 
-   Raise an ``ErrorException`` with the given message
+   Raise an ``ErrorException`` with the given message.
 
 .. function:: throw(e)
 
    .. Docstring generated from Julia source
 
-   Throw an object as an exception
+   Throw an object as an exception.
 
 .. function:: rethrow([e])
 
@@ -1054,7 +1078,7 @@ Errors
 
    .. Docstring generated from Julia source
 
-   The asserted condition did not evalutate to ``true``\ . Optional argument ``msg`` is a descriptive error string.
+   The asserted condition did not evaluate to ``true``\ . Optional argument ``msg`` is a descriptive error string.
 
 .. function:: BoundsError([a],[i])
 
@@ -1254,17 +1278,17 @@ Reflection
 
    Get an array of the fields of a ``DataType``\ .
 
-.. function:: isconst([m::Module], s::Symbol) -> Bool
+.. function:: fieldname(x::DataType, i)
 
    .. Docstring generated from Julia source
 
-   Determine whether a global is declared ``const`` in a given ``Module``\ . The default ``Module`` argument is ``current_module()``\ .
+   Get the name of field ``i`` of a ``DataType``\ .
 
-.. function:: isgeneric(f::Function) -> Bool
+.. function:: isconst([m::Module], s::Symbol) -> Bool
 
    .. Docstring generated from Julia source
 
-   Determine whether a ``Function`` is generic.
+   Determine whether a global is declared ``const`` in a given ``Module``\ . The default ``Module`` argument is ``current_module()``\ .
 
 .. function:: function_name(f::Function) -> Symbol
 
@@ -1357,7 +1381,7 @@ Internals
 
    .. Docstring generated from Julia source
 
-   Prints the LLVM bitcodes generated for running the method matching the given generic function and type signature to :const:`STDOUT`.
+   Prints the LLVM bitcodes generated for running the method matching the given generic function and type signature to :const:`STDOUT`\ .
 
    All metadata and dbg.* calls are removed from the printed bitcode. Use code_llvm_raw for the full IR.
 
@@ -1371,7 +1395,7 @@ Internals
 
    .. Docstring generated from Julia source
 
-   Prints the native assembly instructions generated for running the method matching the given generic function and type signature to STDOUT.
+   Prints the native assembly instructions generated for running the method matching the given generic function and type signature to ``STDOUT``\ .
 
 .. function:: @code_native
 
diff --git a/doc/stdlib/c.rst b/doc/stdlib/c.rst
index bbb70d6051307..33d161413e711 100644
--- a/doc/stdlib/c.rst
+++ b/doc/stdlib/c.rst
@@ -233,10 +233,6 @@
 
    Equivalent to the native ``ptrdiff_t`` c-type (Int)
 
-.. data:: Coff_t
-
-   Equivalent to the native ``off_t`` c-type
-
 .. data:: Cwchar_t
 
    Equivalent to the native ``wchar_t`` c-type (Int32)
@@ -248,3 +244,23 @@
 .. data:: Cdouble
 
    Equivalent to the native ``double`` c-type (Float64)
+
+****************
+ LLVM Interface
+****************
+
+.. function:: llvmcall(IR::String, ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
+              llvmcall((declarations::String, IR::String), ReturnType, (ArgumentType1, ...), ArgumentValue1, ...)
+
+   .. Docstring generated from Julia source
+
+   Call LLVM IR string in the first argument. Similar to an LLVM function ``define`` block, arguments are available as consecutive unnamed SSA variables (%0, %1, etc.).
+
+   The optional declarations string contains external functions declarations that are necessary for llvm to compile the IR string. Multiple declarations can be passed in by separating them with line breaks.
+
+   Note that the argument type tuple must be a literal tuple, and not a tuple-valued variable or expression.
+
+   Each ``ArgumentValue`` to ``llvmcall`` will be converted to the corresponding ``ArgumentType``\ , by automatic insertion of calls to ``unsafe_convert(ArgumentType, cconvert(ArgumentType, ArgumentValue))``\ . (see also the documentation for each of these functions for further details). In most cases, this simply results in a call to ``convert(ArgumentType, ArgumentValue)``\ .
+
+   See ``test/llvmcall.jl`` for usage examples.
+
diff --git a/doc/stdlib/collections.rst b/doc/stdlib/collections.rst
index ab19b3c0997ec..5edb9ef2bae79 100644
--- a/doc/stdlib/collections.rst
+++ b/doc/stdlib/collections.rst
@@ -33,19 +33,19 @@ type.
 
    .. Docstring generated from Julia source
 
-   Get initial iteration state for an iterable object
+   Get initial iteration state for an iterable object.
 
 .. function:: done(iter, state) -> Bool
 
    .. Docstring generated from Julia source
 
-   Test whether we are done iterating
+   Test whether we are done iterating.
 
 .. function:: next(iter, state) -> item, state
 
    .. Docstring generated from Julia source
 
-   For a given iterable object and iteration state, return the current item and the next iteration state
+   For a given iterable object and iteration state, return the current item and the next iteration state.
 
 .. function:: zip(iters...)
 
@@ -53,7 +53,7 @@ type.
 
    For a set of iterable objects, returns an iterable of tuples, where the ``i``\ th tuple contains the ``i``\ th component of each input iterable.
 
-   Note that :func:`zip` is its own inverse: ``collect(zip(zip(a...)...)) == collect(a)``.
+   Note that :func:`zip` is its own inverse: ``collect(zip(zip(a...)...)) == collect(a)``\ .
 
 .. function:: enumerate(iter)
 
@@ -189,13 +189,7 @@ Iterable Collections
 
    .. Docstring generated from Julia source
 
-   Determine whether an item is in the given collection, in the sense that it is
-   ``==`` to one of the values generated by iterating over the collection.
-   Some collections need a slightly different definition; for example :obj:`Set`\ s
-   check whether the item :func:`isequal` to one of the elements. :obj:`Dict`\ s look for
-   ``(key,value)`` pairs, and the key is compared using :func:`isequal`. To test
-   for the presence of a key in a dictionary, use :func:`haskey` or
-   ``k in keys(dict)``.
+   Determine whether an item is in the given collection, in the sense that it is ``==`` to one of the values generated by iterating over the collection. Some collections need a slightly different definition; for example :obj:`Set`\ s check whether the item :func:`isequal` to one of the elements. :obj:`Dict`\ s look for ``(key,value)`` pairs, and the key is compared using :func:`isequal`\ . To test for the presence of a key in a dictionary, use :func:`haskey` or ``k in keys(dict)``\ .
 
 .. function:: eltype(type)
 
@@ -213,7 +207,7 @@ Iterable Collections
 
    .. Docstring generated from Julia source
 
-   Returns the indices of elements in collection ``a`` that appear in collection ``b``
+   Returns the indices of elements in collection ``a`` that appear in collection ``b``\ .
 
 .. function:: unique(itr[, dim])
 
@@ -221,6 +215,12 @@ Iterable Collections
 
    Returns an array containing only the unique elements of the iterable ``itr``\ , in the order that the first of each set of equivalent elements originally appears. If ``dim`` is specified, returns unique regions of the array ``itr`` along ``dim``\ .
 
+.. function:: unique(f, itr)
+
+   .. Docstring generated from Julia source
+
+   Returns an array containing one value from ``itr`` for each unique value produced by ``f`` applied to elements of ``itr``\ .
+
 .. function:: reduce(op, v0, itr)
 
    .. Docstring generated from Julia source
@@ -243,31 +243,25 @@ Iterable Collections
 
    .. Docstring generated from Julia source
 
-   Like :func:`reduce`, but with guaranteed left associativity. ``v0``
-   will be used exactly once.
+   Like :func:`reduce`\ , but with guaranteed left associativity. ``v0`` will be used exactly once.
 
 .. function:: foldl(op, itr)
 
    .. Docstring generated from Julia source
 
-   Like ``foldl(op, v0, itr)``, but using the first element of ``itr``
-   as ``v0``. In general, this cannot be used with empty collections
-   (see ``reduce(op, itr)``).
+   Like ``foldl(op, v0, itr)``\ , but using the first element of ``itr`` as ``v0``\ . In general, this cannot be used with empty collections (see ``reduce(op, itr)``\ ).
 
 .. function:: foldr(op, v0, itr)
 
    .. Docstring generated from Julia source
 
-   Like :func:`reduce`, but with guaranteed right associativity. ``v0``
-   will be used exactly once.
+   Like :func:`reduce`\ , but with guaranteed right associativity. ``v0`` will be used exactly once.
 
 .. function:: foldr(op, itr)
 
    .. Docstring generated from Julia source
 
-   Like ``foldr(op, v0, itr)``, but using the last element of ``itr``
-   as ``v0``. In general, this cannot be used with empty collections
-   (see ``reduce(op, itr)``).
+   Like ``foldr(op, v0, itr)``\ , but using the last element of ``itr`` as ``v0``\ . In general, this cannot be used with empty collections (see ``reduce(op, itr)``\ ).
 
 .. function:: maximum(itr)
 
@@ -347,6 +341,18 @@ Iterable Collections
 
    For an array input, returns the value and index of the minimum over the given dimensions.
 
+.. function:: findmax!(rval, rind, A, [init=true]) -> (maxval, index)
+
+   .. Docstring generated from Julia source
+
+   Find the maximum of ``A`` and the corresponding linear index along singleton dimensions of ``rval`` and ``rind``\ , and store the results in ``rval`` and ``rind``\ .
+
+.. function:: findmin!(rval, rind, A, [init=true]) -> (minval, index)
+
+   .. Docstring generated from Julia source
+
+   Find the minimum of ``A`` and the corresponding linear index along singleton dimensions of ``rval`` and ``rind``\ , and store the results in ``rval`` and ``rind``\ .
+
 .. function:: maxabs(itr)
 
    .. Docstring generated from Julia source
@@ -520,6 +526,12 @@ Iterable Collections
        julia> all(i->(4<=i<=6), [4,5,6])
        true
 
+.. function:: foreach(f, c...) -> Void
+
+   .. Docstring generated from Julia source
+
+   Call function ``f`` on each element of iterable ``c``\ . For multiple iterable arguments, ``f`` is called elementwise. ``foreach`` should be used instead of ``map`` when the results of ``f`` are not needed, for example in ``foreach(println, array)``\ .
+
 .. function:: map(f, c...) -> collection
 
    .. Docstring generated from Julia source
@@ -544,93 +556,70 @@ Iterable Collections
 
    .. Docstring generated from Julia source
 
-   In-place version of :func:`map`.
+   In-place version of :func:`map`\ .
 
 .. function:: map!(function, destination, collection...)
 
    .. Docstring generated from Julia source
 
-   Like :func:`map`, but stores the result in ``destination`` rather than a
-   new collection. ``destination`` must be at least as large as the first
-   collection.
+   Like :func:`map`\ , but stores the result in ``destination`` rather than a new collection. ``destination`` must be at least as large as the first collection.
 
 .. function:: mapreduce(f, op, v0, itr)
 
    .. Docstring generated from Julia source
 
-   Apply function ``f`` to each element in ``itr``, and then reduce
-   the result using the binary function ``op``. ``v0`` must be a
-   neutral element for ``op`` that will be returned for empty
-   collections. It is unspecified whether ``v0`` is used for non-empty
-   collections.
+   Apply function ``f`` to each element in ``itr``\ , and then reduce the result using the binary function ``op``\ . ``v0`` must be a neutral element for ``op`` that will be returned for empty collections. It is unspecified whether ``v0`` is used for non-empty collections.
 
-   :func:`mapreduce` is functionally equivalent to calling ``reduce(op,
-   v0, map(f, itr))``, but will in general execute faster since no
-   intermediate collection needs to be created. See documentation for
-   :func:`reduce` and :func:`map`.
+   :func:`mapreduce` is functionally equivalent to calling ``reduce(op, v0, map(f, itr))``\ , but will in general execute faster since no intermediate collection needs to be created. See documentation for :func:`reduce` and :func:`map`\ .
 
    .. doctest::
 
-      julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
-      14
+       julia> mapreduce(x->x^2, +, [1:3;]) # == 1 + 4 + 9
+       14
 
-   The associativity of the reduction is implementation-dependent.
-   Additionally, some implementations may reuse the return value of
-   ``f`` for elements that appear multiple times in ``itr``.
-   Use :func:`mapfoldl` or :func:`mapfoldr` instead for guaranteed
-   left or right associativity and invocation of ``f`` for every value.
+   The associativity of the reduction is implementation-dependent. Additionally, some implementations may reuse the return value of ``f`` for elements that appear multiple times in ``itr``\ . Use :func:`mapfoldl` or :func:`mapfoldr` instead for guaranteed left or right associativity and invocation of ``f`` for every value.
 
 .. function:: mapreduce(f, op, itr)
 
    .. Docstring generated from Julia source
 
-   Like ``mapreduce(f, op, v0, itr)``. In general, this cannot be used
-   with empty collections (see ``reduce(op, itr)``).
+   Like ``mapreduce(f, op, v0, itr)``\ . In general, this cannot be used with empty collections (see ``reduce(op, itr)``\ ).
 
 .. function:: mapfoldl(f, op, v0, itr)
 
    .. Docstring generated from Julia source
 
-   Like :func:`mapreduce`, but with guaranteed left associativity. ``v0``
-   will be used exactly once.
+   Like :func:`mapreduce`\ , but with guaranteed left associativity. ``v0`` will be used exactly once.
 
 .. function:: mapfoldl(f, op, itr)
 
    .. Docstring generated from Julia source
 
-   Like ``mapfoldl(f, op, v0, itr)``, but using the first element of
-   ``itr`` as ``v0``. In general, this cannot be used with empty
-   collections (see ``reduce(op, itr)``).
+   Like ``mapfoldl(f, op, v0, itr)``\ , but using the first element of ``itr`` as ``v0``\ . In general, this cannot be used with empty collections (see ``reduce(op, itr)``\ ).
 
 .. function:: mapfoldr(f, op, v0, itr)
 
    .. Docstring generated from Julia source
 
-   Like :func:`mapreduce`, but with guaranteed right associativity. ``v0``
-   will be used exactly once.
+   Like :func:`mapreduce`\ , but with guaranteed right associativity. ``v0`` will be used exactly once.
 
 .. function:: mapfoldr(f, op, itr)
 
    .. Docstring generated from Julia source
 
-   Like ``mapfoldr(f, op, v0, itr)``, but using the first element of
-   ``itr`` as ``v0``. In general, this cannot be used with empty
-   collections (see ``reduce(op, itr)``).
+   Like ``mapfoldr(f, op, v0, itr)``\ , but using the first element of ``itr`` as ``v0``\ . In general, this cannot be used with empty collections (see ``reduce(op, itr)``\ ).
 
 .. function:: first(coll)
 
    .. Docstring generated from Julia source
 
-   Get the first element of an iterable collection. Returns the start point of a :obj:`Range`
-   even if it is empty.
+   Get the first element of an iterable collection. Returns the start point of a :obj:`Range` even if it is empty.
 
 .. function:: last(coll)
 
    .. Docstring generated from Julia source
 
-   Get the last element of an ordered collection, if it can be computed in O(1) time.
-   This is accomplished by calling :func:`endof` to get the last index.
-   Returns the end point of a :obj:`Range` even if it is empty.
+   Get the last element of an ordered collection, if it can be computed in O(1) time. This is accomplished by calling :func:`endof` to get the last index. Returns the end point of a :obj:`Range` even if it is empty.
 
 .. function:: step(r)
 
@@ -657,7 +646,7 @@ Iterable Collections
 
    .. Docstring generated from Julia source
 
-   Determine whether every element of ``a`` is also in ``b``, using :func:`in`.
+   Determine whether every element of ``a`` is also in ``b``\ , using :func:`in`\ .
 
 .. function:: filter(function, collection)
 
@@ -678,9 +667,7 @@ Indexable Collections
 
    .. Docstring generated from Julia source
 
-   Retrieve the value(s) stored at the given key or index within a collection.
-   The syntax ``a[i,j,...]`` is converted by the compiler to
-   ``getindex(a, i, j, ...)``.
+   Retrieve the value(s) stored at the given key or index within a collection. The syntax ``a[i,j,...]`` is converted by the compiler to ``getindex(a, i, j, ...)``\ .
 
 .. function:: setindex!(collection, value, key...)
 
@@ -727,26 +714,25 @@ Given a dictionary ``D``, the syntax ``D[x]`` returns the value of key ``x`` (if
 
    .. Docstring generated from Julia source
 
-   ``Dict{K,V}()`` constructs a hash table with keys of type ``K`` and values of type ``V``.
+   ``Dict{K,V}()`` constructs a hash table with keys of type ``K`` and values of type ``V``\ .
 
-   Given a single iterable argument, constructs a :obj:`Dict` whose key-value pairs
-   are taken from 2-tuples ``(key,value)`` generated by the argument.
+   Given a single iterable argument, constructs a :obj:`Dict` whose key-value pairs are taken from 2-tuples ``(key,value)`` generated by the argument.
 
    .. doctest::
 
-     julia> Dict([("A", 1), ("B", 2)])
-     Dict{ASCIIString,Int64} with 2 entries:
-       "B" => 2
-       "A" => 1
+       julia> Dict([("A", 1), ("B", 2)])
+       Dict{ASCIIString,Int64} with 2 entries:
+         "B" => 2
+         "A" => 1
 
    Alternatively, a sequence of pair arguments may be passed.
 
    .. doctest::
 
-     julia> Dict("A"=>1, "B"=>2)
-     Dict{ASCIIString,Int64} with 2 entries:
-       "B" => 2
-       "A" => 1
+       julia> Dict("A"=>1, "B"=>2)
+       Dict{ASCIIString,Int64} with 2 entries:
+         "B" => 2
+         "A" => 1
 
 .. function:: haskey(collection, key) -> Bool
 
@@ -764,14 +750,16 @@ Given a dictionary ``D``, the syntax ``D[x]`` returns the value of key ``x`` (if
 
    .. Docstring generated from Julia source
 
-   Return the value stored for the given key, or if no mapping for the key is present, return ``f()``.  Use :func:`get!` to also store the default value in the dictionary.
+   Return the value stored for the given key, or if no mapping for the key is present, return ``f()``\ .  Use :func:`get!` to also store the default value in the dictionary.
+
+   This is intended to be called using ``do`` block syntax
 
-   This is intended to be called using ``do`` block syntax::
+   .. code-block:: julia
 
-     get(dict, key) do
-         # default value calculated here
-         time()
-     end
+       get(dict, key) do
+           # default value calculated here
+           time()
+       end
 
 .. function:: get!(collection, key, default)
 
@@ -858,7 +846,7 @@ Given a dictionary ``D``, the syntax ``D[x]`` returns the value of key ``x`` (if
 
    .. Docstring generated from Julia source
 
-   Update collection with pairs from the other collections
+   Update collection with pairs from the other collections.
 
 .. function:: sizehint!(s, n)
 
@@ -866,17 +854,17 @@ Given a dictionary ``D``, the syntax ``D[x]`` returns the value of key ``x`` (if
 
    Suggest that collection ``s`` reserve capacity for at least ``n`` elements. This can improve performance.
 
-.. function:: keytype(collection)
+.. function:: keytype(type)
 
    .. Docstring generated from Julia source
 
-   For associative collection types, this will be the type of the Key, This is not defined for non-associative collections
+   Get the key type of an associative collection type. Behaves similarly to ``eltype``\ .
 
-.. function:: valtype(collection)
+.. function:: valtype(type)
 
    .. Docstring generated from Julia source
 
-   For associative collection types, this will be the type of the Value, This is not defined for non-associative collections
+   Get the value type of an associative collection type. Behaves similarly to ``eltype``\ .
 
 Fully implemented by:
 
@@ -899,18 +887,13 @@ Set-Like Collections
 
    .. Docstring generated from Julia source
 
-   Construct a :obj:`Set` of the values generated by the given iterable object, or an empty set.
-   Should be used instead of :obj:`IntSet` for sparse integer sets, or for sets of arbitrary objects.
+   Construct a :obj:`Set` of the values generated by the given iterable object, or an empty set. Should be used instead of :obj:`IntSet` for sparse integer sets, or for sets of arbitrary objects.
 
 .. function:: IntSet([itr])
 
    .. Docstring generated from Julia source
 
-   Construct a sorted set of positive ``Int``\ s generated by the given iterable
-   object, or an empty set. Implemented as a bit string, and therefore designed
-   for dense integer sets. Only ``Int``\ s greater than 0 can be stored. If the
-   set will be sparse (for example holding a few very large integers), use
-   :obj:`Set` instead.
+   Construct a sorted set of positive ``Int``\ s generated by the given iterable object, or an empty set. Implemented as a bit string, and therefore designed for dense integer sets. Only ``Int``\ s greater than 0 can be stored. If the set will be sparse (for example holding a few very large integers), use :obj:`Set` instead.
 
 .. function:: union(s1,s2...)
               ∪(s1,s2...)
@@ -972,7 +955,7 @@ Set-Like Collections
 
    .. Docstring generated from Julia source
 
-   Returns the set-complement of :obj:`IntSet` ``s``.
+   Returns the set-complement of :obj:`IntSet` ``s``\ .
 
 .. function:: complement!(s)
 
@@ -991,7 +974,7 @@ Set-Like Collections
 
    .. Docstring generated from Julia source
 
-   Return ``true`` if ``A`` is a subset of or equal to ``S``.
+   Return ``true`` if ``A`` is a subset of or equal to ``S``\ .
 
 Fully implemented by:
 
@@ -1009,23 +992,20 @@ Dequeues
 
    .. Docstring generated from Julia source
 
-   Insert one or more ``items`` at the end of ``collection``.
+   Insert one or more ``items`` at the end of ``collection``\ .
 
    .. doctest::
 
-     julia> push!([1, 2, 3], 4, 5, 6)
-     6-element Array{Int64,1}:
-      1
-      2
-      3
-      4
-      5
-      6
+       julia> push!([1, 2, 3], 4, 5, 6)
+       6-element Array{Int64,1}:
+        1
+        2
+        3
+        4
+        5
+        6
 
-   Use :func:`append!` to add all the elements of another collection to
-   ``collection``.
-   The result of the preceding example is equivalent to
-   ``append!([1, 2, 3], [4, 5, 6])``.
+   Use :func:`append!` to add all the elements of another collection to ``collection``\ . The result of the preceding example is equivalent to ``append!([1, 2, 3], [4, 5, 6])``\ .
 
 .. function:: pop!(collection) -> item
 
@@ -1251,31 +1231,28 @@ Dequeues
 
    .. Docstring generated from Julia source
 
-   Add the elements of ``collection2`` to the end of ``collection``.
+   Add the elements of ``collection2`` to the end of ``collection``\ .
 
    .. doctest::
 
-      julia> append!([1],[2,3])
-      3-element Array{Int64,1}:
-       1
-       2
-       3
+       julia> append!([1],[2,3])
+       3-element Array{Int64,1}:
+        1
+        2
+        3
 
    .. doctest::
 
-      julia> append!([1, 2, 3], [4, 5, 6])
-      6-element Array{Int64,1}:
-       1
-       2
-       3
-       4
-       5
-       6
+       julia> append!([1, 2, 3], [4, 5, 6])
+       6-element Array{Int64,1}:
+        1
+        2
+        3
+        4
+        5
+        6
 
-   Use :func:`push!` to add individual items to ``collection`` which are not
-   already themselves in another collection.
-   The result is of the preceding example is equivalent to
-   ``push!([1, 2, 3], 4, 5, 6)``.
+   Use :func:`push!` to add individual items to ``collection`` which are not already themselves in another collection. The result is of the preceding example is equivalent to ``push!([1, 2, 3], 4, 5, 6)``\ .
 
 .. function:: prepend!(collection, items) -> collection
 
@@ -1310,9 +1287,9 @@ changed efficiently.
 
    .. Docstring generated from Julia source
 
-   Construct a new :obj:`PriorityQueue`, with keys of type ``K`` and values/priorites of
-   type ``V``. If an order is not given, the priority queue is min-ordered using
-   the default comparison for ``V``.
+   Construct a new :obj:`PriorityQueue`\ , with keys of type ``K`` and values/priorites of type ``V``\ . If an order is not given, the priority queue is min-ordered using the default comparison for ``V``\ .
+
+   A ``PriorityQueue`` acts like a ``Dict``\ , mapping values to their priorities, with the addition of a ``dequeue!`` function to remove the lowest priority element.
 
 .. function:: enqueue!(pq, k, v)
 
@@ -1335,7 +1312,7 @@ changed efficiently.
 :obj:`PriorityQueue` also behaves similarly to a :obj:`Dict` in that keys can be
 inserted and priorities accessed or changed using indexing notation.
 
-  .. doctest::
+.. doctest::
 
     julia> # Julia code
            pq = Collections.PriorityQueue();
@@ -1366,19 +1343,19 @@ is used, so that elements popped from the heap are given in ascending order.
 
    .. Docstring generated from Julia source
 
-   Return a new vector in binary heap order, optionally using the given ordering.
+   Returns a new vector in binary heap order, optionally using the given ordering.
 
 .. function:: heapify!(v, [ord])
 
    .. Docstring generated from Julia source
 
-   In-place :func:`heapify`.
+   In-place :func:`heapify`\ .
 
 .. function:: isheap(v, [ord])
 
    .. Docstring generated from Julia source
 
-   Return ``true`` iff an array is heap-ordered according to the given order.
+   Return ``true`` if an array is heap-ordered according to the given order.
 
 .. function:: heappush!(v, x, [ord])
 
diff --git a/doc/stdlib/constants.rst b/doc/stdlib/constants.rst
index 2577ce6fbb5ca..2ee60422d030a 100644
--- a/doc/stdlib/constants.rst
+++ b/doc/stdlib/constants.rst
@@ -14,6 +14,11 @@ Constants
    A symbol representing the name of the operating system. Possible values
    are ``:Linux``, ``:Darwin`` (OS X), or ``:Windows``.
 
+.. data:: PROGRAM_FILE
+
+   A string containing the script name passed to Julia from the command line. Note that the
+   script name remains unchanged from within included files. Alternatively see :data:`@__FILE__`.
+
 .. data:: ARGS
 
    An array of the command line arguments passed to Julia, as strings.
diff --git a/doc/stdlib/dates.rst b/doc/stdlib/dates.rst
index 01f3ee10f2996..55956b32a0583 100644
--- a/doc/stdlib/dates.rst
+++ b/doc/stdlib/dates.rst
@@ -25,7 +25,7 @@ Dates and Time Types
 
 .. data:: UTInstant{T}
 
-   The ``UTInstant`` represents a machine timeline based on `UT` time (1 day = one revolution of the earth). The ``T`` is a ``Period`` parameter that indicates the resolution or precision of the instant.
+   The ``UTInstant`` represents a machine timeline based on UT time (1 day = one revolution of the earth). The ``T`` is a ``Period`` parameter that indicates the resolution or precision of the instant.
 
 .. data:: TimeType
 
@@ -43,66 +43,69 @@ Dates Functions
 ---------------
 
 All Dates functions are defined in the ``Dates`` module; note that only the ``Date``, ``DateTime``, and ``now`` functions are exported;
-to use all other ``Dates`` functions, you'll need to prefix each function call with an explicit ``Dates.``, e.g. ``Dates.dayofweek(dt)``;
-alternatively, you could call ``using Dates`` to bring all exported functions into ``Main`` to be used without the ``Dates.`` prefix.
+to use all other ``Dates`` functions, you'll need to prefix each function call with an explicit ``Dates.``, e.g. ``Dates.dayofweek(dt)``.
+Alternatively, you can write ``using Base.Dates`` to bring all exported functions into ``Main`` to be used without the ``Dates.`` prefix.
 
 
 .. function:: DateTime(y, [m, d, h, mi, s, ms]) -> DateTime
 
    .. Docstring generated from Julia source
 
-   Construct a ``DateTime`` type by parts. Arguments must be convertible to ``Int64``.
+   Construct a ``DateTime`` type by parts. Arguments must be convertible to ``Int64``\ .
 
 .. function:: DateTime(periods::Period...) -> DateTime
 
    .. Docstring generated from Julia source
 
-   Constuct a ``DateTime`` type by ``Period`` type parts. Arguments may be in any order.
-   DateTime parts not provided will default to the value of ``Dates.default(period)``.
+   Construct a ``DateTime`` type by ``Period`` type parts. Arguments may be in any order. DateTime parts not provided will default to the value of ``Dates.default(period)``\ .
 
 .. function:: DateTime(f::Function, y[, m, d, h, mi, s]; step=Day(1), negate=false, limit=10000) -> DateTime
 
    .. Docstring generated from Julia source
 
-   Create a ``DateTime`` through the adjuster API. The starting point will be constructed from the
-   provided ``y, m, d...`` arguments, and will be adjusted until ``f::Function`` returns ``true``. The step size in
-   adjusting can be provided manually through the ``step`` keyword. If ``negate=true``, then the adjusting
-   will stop when ``f::Function`` returns ``false`` instead of ``true``. ``limit`` provides a limit to
-   the max number of iterations the adjustment API will pursue before throwing an error (in the case that ``f::Function`` is never satisfied).
+   Create a ``DateTime`` through the adjuster API. The starting point will be constructed from the provided ``y, m, d...`` arguments, and will be adjusted until ``f::Function`` returns ``true``\ . The step size in adjusting can be provided manually through the ``step`` keyword. If ``negate=true``\ , then the adjusting will stop when ``f::Function`` returns ``false`` instead of ``true``\ . ``limit`` provides a limit to the max number of iterations the adjustment API will pursue before throwing an error (in the case that ``f::Function`` is never satisfied).
 
 .. function:: DateTime(dt::Date) -> DateTime
 
    .. Docstring generated from Julia source
 
-   Converts a ``Date`` type to a ``DateTime``.
-   The hour, minute, second, and millisecond parts of the new ``DateTime`` are assumed to be zero.
+   Converts a ``Date`` type to a ``DateTime``\ . The hour, minute, second, and millisecond parts of the new ``DateTime`` are assumed to be zero.
 
 .. function:: DateTime(dt::AbstractString, format::AbstractString; locale="english") -> DateTime
 
    .. Docstring generated from Julia source
 
-   Construct a ``DateTime`` type by parsing the ``dt`` date string following the pattern given in
-   the ``format`` string. The following codes can be used for constructing format strings:
-
-   =============== ========= ===============================================================
-   Code            Matches    Comment
-   --------------- --------- ---------------------------------------------------------------
-   ``y``           1996, 96  Returns year of 1996, 0096
-   ``m``           1, 01     Matches 1 or 2-digit months
-   ``u``           Jan       Matches abbreviated months according to the ``locale`` keyword
-   ``U``           January   Matches full month names according to the ``locale`` keyword
-   ``d``           1, 01     Matches 1 or 2-digit days
-   ``H``           00        Matches hours
-   ``M``           00        Matches minutes
-   ``S``           00        Matches seconds
-   ``s``           .500      Matches milliseconds
-   ``e``           Mon, Tues Matches abbreviated days of the week
-   ``E``           Monday    Matches full name days of the week
-   ``yyyymmdd``    19960101  Matches fixed-width year, month, and day
-   =============== ========= ===============================================================
-
-   All characters not listed above are treated as delimiters between date and time slots.
-   So a ``dt`` string of "1996-01-15T00:00:00.0" would have a ``format`` string like "y-m-dTH:M:S.s".
+   Construct a ``DateTime`` type by parsing the ``dt`` date string following the pattern given in the ``format`` string. The following codes can be used for constructing format strings:
+
+   +--------------+-----------+----------------------------------------------------------------+
+   | Code         | Matches   | Comment                                                        |
+   +==============+===========+================================================================+
+   | ``y``        | 1996, 96  | Returns year of 1996, 0096                                     |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``m``        | 1, 01     | Matches 1 or 2-digit months                                    |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``u``        | Jan       | Matches abbreviated months according to the ``locale`` keyword |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``U``        | January   | Matches full month names according to the ``locale`` keyword   |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``d``        | 1, 01     | Matches 1 or 2-digit days                                      |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``H``        | 00        | Matches hours                                                  |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``M``        | 00        | Matches minutes                                                |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``S``        | 00        | Matches seconds                                                |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``s``        | .500      | Matches milliseconds                                           |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``e``        | Mon, Tues | Matches abbreviated days of the week                           |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``E``        | Monday    | Matches full name days of the week                             |
+   +--------------+-----------+----------------------------------------------------------------+
+   | ``yyyymmdd`` | 19960101  | Matches fixed-width year, month, and day                       |
+   +--------------+-----------+----------------------------------------------------------------+
+
+   All characters not listed above are treated as delimiters between date and time slots. So a ``dt`` string of "1996-01-15T00:00:00.0" would have a ``format`` string like "y-m-dTH:M:S.s".
 
 .. function:: Dates.DateFormat(format::AbstractString) -> DateFormat
 
@@ -114,7 +117,7 @@ alternatively, you could call ``using Dates`` to bring all exported functions in
 
    .. Docstring generated from Julia source
 
-   Similar form as above for parsing a ``DateTime``, but passes a ``DateFormat`` object instead of a raw formatting string. It is more efficient if similarly formatted date strings will be parsed repeatedly to first create a ``DateFormat`` object then use this method for parsing.
+   Similar form as above for parsing a ``DateTime``\ , but passes a ``DateFormat`` object instead of a raw formatting string. It is more efficient if similarly formatted date strings will be parsed repeatedly to first create a ``DateFormat`` object then use this method for parsing.
 
 .. function:: Date(y, [m, d]) -> Date
 
@@ -126,7 +129,7 @@ alternatively, you could call ``using Dates`` to bring all exported functions in
 
    .. Docstring generated from Julia source
 
-   Constuct a ``Date`` type by ``Period`` type parts. Arguments may be in any order. ``Date`` parts not provided will default to the value of ``Dates.default(period)``\ .
+   Construct a ``Date`` type by ``Period`` type parts. Arguments may be in any order. ``Date`` parts not provided will default to the value of ``Dates.default(period)``\ .
 
 .. function:: Date(f::Function, y[, m]; step=Day(1), negate=false, limit=10000) -> Date
 
@@ -306,8 +309,7 @@ Adjuster Functions
 
    .. Docstring generated from Julia source
 
-   Truncates the value of ``dt`` according to the provided ``Period`` type.
-   E.g. if ``dt`` is ``1996-01-01T12:30:00``, then ``trunc(dt,Day) == 1996-01-01T00:00:00``.
+   Truncates the value of ``dt`` according to the provided ``Period`` type. E.g. if ``dt`` is ``1996-01-01T12:30:00``\ , then ``trunc(dt,Day) == 1996-01-01T00:00:00``\ .
 
 .. function:: firstdayofweek(dt::TimeType) -> TimeType
 
@@ -434,34 +436,31 @@ Conversion Functions
 
    .. Docstring generated from Julia source
 
-   Takes the number of seconds since unix epoch ``1970-01-01T00:00:00``
-   and converts to the corresponding ``DateTime``.
+   Takes the number of seconds since unix epoch ``1970-01-01T00:00:00`` and converts to the corresponding ``DateTime``\ .
 
 .. function:: datetime2unix(dt::DateTime) -> Float64
 
    .. Docstring generated from Julia source
 
-   Takes the given ``DateTime`` and returns the number of seconds since the unix epoch as a ``Float64``\ .
+   Takes the given ``DateTime`` and returns the number of seconds since the unix epoch ``1970-01-01T00:00:00`` as a ``Float64``\ .
 
 .. function:: julian2datetime(julian_days) -> DateTime
 
    .. Docstring generated from Julia source
 
-   Takes the number of Julian calendar days since epoch
-   ``-4713-11-24T12:00:00`` and returns the corresponding ``DateTime``.
+   Takes the number of Julian calendar days since epoch ``-4713-11-24T12:00:00`` and returns the corresponding ``DateTime``\ .
 
 .. function:: datetime2julian(dt::DateTime) -> Float64
 
    .. Docstring generated from Julia source
 
-   Takes the given ``DateTime`` and returns the number of Julian calendar days since the julian epoch as a ``Float64``\ .
+   Takes the given ``DateTime`` and returns the number of Julian calendar days since the julian epoch ``-4713-11-24T12:00:00`` as a ``Float64``\ .
 
 .. function:: rata2datetime(days) -> DateTime
 
    .. Docstring generated from Julia source
 
-   Takes the number of Rata Die days since epoch ``0000-12-31T00:00:00``
-   and returns the corresponding ``DateTime``.
+   Takes the number of Rata Die days since epoch ``0000-12-31T00:00:00`` and returns the corresponding ``DateTime``\ .
 
 .. function:: datetime2rata(dt::TimeType) -> Int64
 
@@ -476,7 +475,7 @@ Days of the Week:
 
 =============== ========= =============
 Variable        Abbr.     Value (Int)
---------------- --------- -------------
+=============== ========= =============
 ``Monday``      ``Mon``   1
 ``Tuesday``     ``Tue``   2
 ``Wednesday``   ``Wed``   3
@@ -490,7 +489,7 @@ Months of the Year:
 
 =============== ========= =============
 Variable        Abbr.     Value (Int)
---------------- --------- -------------
+=============== ========= =============
 ``January``     ``Jan``   1
 ``February``    ``Feb``   2
 ``March``       ``Mar``   3
diff --git a/doc/stdlib/file.rst b/doc/stdlib/file.rst
index c3be7218ca012..4b6f2cf9814a1 100644
--- a/doc/stdlib/file.rst
+++ b/doc/stdlib/file.rst
@@ -28,17 +28,36 @@
 
    Returns the files and directories in the directory ``dir`` (or the current working directory if not given).
 
+.. function:: walkdir(dir; topdown=true, follow_symlinks=false, onerror=throw)
+
+   .. Docstring generated from Julia source
+
+   The walkdir method return an iterator that walks the directory tree of a directory. The iterator returns a tuple containing ``(rootpath, dirs, files)``\ . The directory tree can be traversed top-down or bottom-up. If walkdir encounters a SystemError it will raise the error. A custom error handling function can be provided through ``onerror`` keyword argument, the function is called with a SystemError as argument.
+
+   .. code-block:: julia
+
+       for (root, dirs, files) in walkdir(".")
+           println("Directories in $root")
+           for dir in dirs
+               println(joinpath(root, dir)) # path to directories
+           end
+           println("Files in $root")
+           for file in files
+               println(joinpath(root, file)) # path to files
+           end
+       end
+
 .. function:: mkdir(path, [mode])
 
    .. Docstring generated from Julia source
 
-   Make a new directory with name ``path`` and permissions ``mode``\ . ``mode`` defaults to 0o777, modified by the current file creation mask.
+   Make a new directory with name ``path`` and permissions ``mode``\ . ``mode`` defaults to ``0o777``\ , modified by the current file creation mask.
 
 .. function:: mkpath(path, [mode])
 
    .. Docstring generated from Julia source
 
-   Create all directories in the given ``path``\ , with permissions ``mode``\ . ``mode`` defaults to 0o777, modified by the current file creation mask.
+   Create all directories in the given ``path``\ , with permissions ``mode``\ . ``mode`` defaults to ``0o777``\ , modified by the current file creation mask.
 
 .. function:: symlink(target, link)
 
@@ -56,11 +75,17 @@
 
    Returns the value of a symbolic link ``path``\ .
 
-.. function:: chmod(path, mode)
+.. function:: chmod(path, mode; recursive=false)
 
    .. Docstring generated from Julia source
 
-   Change the permissions mode of ``path`` to ``mode``\ . Only integer ``mode``\ s (e.g. 0o777) are currently supported.
+   Change the permissions mode of ``path`` to ``mode``\ . Only integer ``mode``\ s (e.g. ``0o777``\ ) are currently supported. If ``recursive=true`` and the path is a directory all permissions in that directory will be recursively changed.
+
+.. function:: chown(path, owner, group=-1)
+
+   .. Docstring generated from Julia source
+
+   Change the owner and/or group of ``path`` to ``owner`` and/or ``group``\ . If the value entered for ``owner`` or ``group`` is ``-1`` the corresponding ID will not change. Only integer ``owner``\ s and ``group``\ s are currently supported.
 
 .. function:: stat(file)
 
@@ -68,20 +93,33 @@
 
    Returns a structure whose fields contain information about the file. The fields of the structure are:
 
-   ========= ======================================================================
-    size      The size (in bytes) of the file
-    device    ID of the device that contains the file
-    inode     The inode number of the file
-    mode      The protection mode of the file
-    nlink     The number of hard links to the file
-    uid       The user id of the owner of the file
-    gid       The group id of the file owner
-    rdev      If this file refers to a device, the ID of the device it refers to
-    blksize   The file-system preferred block size for the file
-    blocks    The number of such blocks allocated
-    mtime     Unix timestamp of when the file was last modified
-    ctime     Unix timestamp of when the file was created
-   ========= ======================================================================
+   +---------+--------------------------------------------------------------------+
+   | Name    | Description                                                        |
+   +=========+====================================================================+
+   | size    | The size (in bytes) of the file                                    |
+   +---------+--------------------------------------------------------------------+
+   | device  | ID of the device that contains the file                            |
+   +---------+--------------------------------------------------------------------+
+   | inode   | The inode number of the file                                       |
+   +---------+--------------------------------------------------------------------+
+   | mode    | The protection mode of the file                                    |
+   +---------+--------------------------------------------------------------------+
+   | nlink   | The number of hard links to the file                               |
+   +---------+--------------------------------------------------------------------+
+   | uid     | The user id of the owner of the file                               |
+   +---------+--------------------------------------------------------------------+
+   | gid     | The group id of the file owner                                     |
+   +---------+--------------------------------------------------------------------+
+   | rdev    | If this file refers to a device, the ID of the device it refers to |
+   +---------+--------------------------------------------------------------------+
+   | blksize | The file-system preferred block size for the file                  |
+   +---------+--------------------------------------------------------------------+
+   | blocks  | The number of such blocks allocated                                |
+   +---------+--------------------------------------------------------------------+
+   | mtime   | Unix timestamp of when the file was last modified                  |
+   +---------+--------------------------------------------------------------------+
+   | ctime   | Unix timestamp of when the file was created                        |
+   +---------+--------------------------------------------------------------------+
 
 .. function:: lstat(file)
 
@@ -99,7 +137,7 @@
 
    .. Docstring generated from Julia source
 
-   Equivalent to ``stat(file).mtime``
+   Equivalent to ``stat(file).mtime``\ .
 
 .. function:: filemode(file)
 
@@ -111,7 +149,7 @@
 
    .. Docstring generated from Julia source
 
-   Equivalent to ``stat(file).size``
+   Equivalent to ``stat(file).size``\ .
 
 .. function:: uperm(file)
 
@@ -119,19 +157,23 @@
 
    Gets the permissions of the owner of the file as a bitfield of
 
-   ==== =====================
-    01   Execute Permission
-    02   Write Permission
-    04   Read Permission
-   ==== =====================
+   +-------+--------------------+
+   | Value | Description        |
+   +=======+====================+
+   | 01    | Execute Permission |
+   +-------+--------------------+
+   | 02    | Write Permission   |
+   +-------+--------------------+
+   | 04    | Read Permission    |
+   +-------+--------------------+
 
-   For allowed arguments, see ``stat``.
+   For allowed arguments, see ``stat``\ .
 
 .. function:: gperm(file)
 
    .. Docstring generated from Julia source
 
-   Like uperm but gets the permissions of the group owning the file
+   Like uperm but gets the permissions of the group owning the file.
 
 .. function:: operm(file)
 
@@ -159,11 +201,11 @@
 
    Move the file, link, or directory from ``src`` to ``dst``\ . ``remove_destination=true`` will first remove an existing ``dst``\ .
 
-.. function:: rm(path::AbstractString; recursive=false)
+.. function:: rm(path::AbstractString; force=false, recursive=false)
 
    .. Docstring generated from Julia source
 
-   Delete the file, link, or empty directory at the given path. If ``recursive=true`` is passed and the path is a directory, then all contents are removed recursively.
+   Delete the file, link, or empty directory at the given path. If ``force=true`` is passed, a non-existing path is not treated as error. If ``recursive=true`` is passed and the path is a directory, then all contents are removed recursively.
 
 .. function:: touch(path::AbstractString)
 
@@ -225,12 +267,6 @@
 
    Returns ``true`` if ``path`` is a directory, ``false`` otherwise.
 
-.. function:: isexecutable(path) -> Bool
-
-   .. Docstring generated from Julia source
-
-   Returns ``true`` if the current user has permission to execute ``path``\ , ``false`` otherwise.
-
 .. function:: isfifo(path) -> Bool
 
    .. Docstring generated from Julia source
@@ -261,12 +297,6 @@
 
    Returns ``true`` if ``path`` is a valid filesystem path, ``false`` otherwise.
 
-.. function:: isreadable(path) -> Bool
-
-   .. Docstring generated from Julia source
-
-   Returns ``true`` if the current user has permission to read ``path``\ , ``false`` otherwise.
-
 .. function:: issetgid(path) -> Bool
 
    .. Docstring generated from Julia source
@@ -291,12 +321,6 @@
 
    Returns ``true`` if ``path`` has the sticky bit set, ``false`` otherwise.
 
-.. function:: iswritable(path) -> Bool
-
-   .. Docstring generated from Julia source
-
-   Returns ``true`` if the current user has permission to write to ``path``\ , ``false`` otherwise.
-
 .. function:: homedir() -> AbstractString
 
    .. Docstring generated from Julia source
@@ -319,7 +343,7 @@
 
    .. Docstring generated from Julia source
 
-   ``@__FILE__`` expands to a string with the absolute path and file name of the script being run. Returns ``nothing`` if run from a REPL or an empty string if evaluated by ``julia -e <expr>``\ .
+   ``@__FILE__`` expands to a string with the absolute file path of the file containing the macro. Returns ``nothing`` if run from a REPL or an empty string if evaluated by ``julia -e <expr>``\ . Alternatively see :data:`PROGRAM_FILE`\ .
 
 .. function:: @__LINE__ -> Int
 
diff --git a/doc/stdlib/io-network.rst b/doc/stdlib/io-network.rst
index f273319517e74..1dcf068b1910e 100644
--- a/doc/stdlib/io-network.rst
+++ b/doc/stdlib/io-network.rst
@@ -19,27 +19,45 @@ General I/O
 
    Global variable referring to the standard input stream.
 
-.. function:: open(file_name, [read, write, create, truncate, append]) -> IOStream
+.. function:: open(filename, [read, write, create, truncate, append]) -> IOStream
 
    .. Docstring generated from Julia source
 
    Open a file in a mode specified by five boolean arguments. The default is to open files for reading only. Returns a stream for accessing the file.
 
-.. function:: open(file_name, [mode]) -> IOStream
+.. function:: open(filename, [mode]) -> IOStream
 
    .. Docstring generated from Julia source
 
-   Alternate syntax for open, where a string-based mode specifier is used instead of the five booleans. The values of ``mode`` correspond to those from ``fopen(3)`` or Perl ``open``, and are equivalent to setting the following boolean groups:
+   Alternate syntax for open, where a string-based mode specifier is used instead of the five booleans. The values of ``mode`` correspond to those from ``fopen(3)`` or Perl ``open``\ , and are equivalent to setting the following boolean groups:
 
-   ==== =================================
-    r    read
-    r+   read, write
-    w    write, create, truncate
-    w+   read, write, create, truncate
-    a    write, create, append
-    a+   read, write, create, append
-   ==== =================================
+   +------+-------------------------------+
+   | Mode | Description                   |
+   +======+===============================+
+   | r    | read                          |
+   +------+-------------------------------+
+   | r+   | read, write                   |
+   +------+-------------------------------+
+   | w    | write, create, truncate       |
+   +------+-------------------------------+
+   | w+   | read, write, create, truncate |
+   +------+-------------------------------+
+   | a    | write, create, append         |
+   +------+-------------------------------+
+   | a+   | read, write, create, append   |
+   +------+-------------------------------+
 
+.. function:: open(command, mode::AbstractString="r", stdio=DevNull)
+
+   .. Docstring generated from Julia source
+
+   Start running ``command`` asynchronously, and return a tuple ``(stream,process)``\ .  If ``mode`` is ``"r"``\ , then ``stream`` reads from the process's standard output and ``stdio`` optionally specifies the process's standard input stream.  If ``mode`` is ``"w"``\ , then ``stream`` writes to the process's standard input and ``stdio`` optionally specifies the process's standard output stream.
+
+.. function:: open(f::Function, command, mode::AbstractString="r", stdio=DevNull)
+
+   .. Docstring generated from Julia source
+
+   Similar to ``open(command, mode, stdio)``\ , but calls ``f(stream)`` on the resulting read or write stream, then closes the stream and waits for the process to complete.  Returns the value returned by ``f``\ .
 
 .. function:: open(f::Function, args...)
 
@@ -47,7 +65,7 @@ General I/O
 
    Apply the function ``f`` to the result of ``open(args...)`` and close the resulting file descriptor upon completion.
 
-   **Example**: ``open(readall, "file.txt")``
+   **Example**: ``open(readstring, "file.txt")``
 
 .. function:: IOBuffer() -> IOBuffer
 
@@ -65,7 +83,7 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   Create a read-only IOBuffer on the data underlying the given string
+   Create a read-only IOBuffer on the data underlying the given string.
 
 .. function:: IOBuffer([data,],[readable,writable,[maxsize]])
 
@@ -77,7 +95,7 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   Obtain the contents of an ``IOBuffer`` as an array, without copying. Afterwards, the IOBuffer is reset to its initial state.
+   Obtain the contents of an ``IOBuffer`` as an array, without copying. Afterwards, the ``IOBuffer`` is reset to its initial state.
 
 .. function:: takebuf_string(b::IOBuffer)
 
@@ -103,46 +121,77 @@ General I/O
 
    Close an I/O stream. Performs a ``flush`` first.
 
-.. function:: write(stream, x)
+.. function:: write(stream::IO, x)
+              write(filename::AbstractString, x)
 
    .. Docstring generated from Julia source
 
-   Write the canonical binary representation of a value to the given stream.
+   Write the canonical binary representation of a value to the given I/O stream or file. Returns the number of bytes written into the stream.
+
+   You can write multiple values with the same :func:``write`` call. i.e. the following are equivalent:
 
-.. function:: read(stream, type)
+   .. code-block:: julia
+
+       write(stream, x, y...)
+       write(stream, x) + write(stream, y...)
+
+.. function:: read(stream::IO, T)
 
    .. Docstring generated from Julia source
 
-   Read a value of the given type from a stream, in canonical binary representation.
+   Read a single value of type ``T`` from ``stream``\ , in canonical binary representation.
 
-.. function:: read(stream, type, dims)
+.. function:: read(stream::IO, T, dims)
 
    .. Docstring generated from Julia source
 
-   Read a series of values of the given type from a stream, in canonical binary representation. ``dims`` is either a tuple or a series of integer arguments specifying the size of ``Array`` to return.
+   Read a series of values of type ``T`` from ``stream``\ , in canonical binary representation. ``dims`` is either a tuple or a series of integer arguments specifying the size of the ``Array{T}`` to return.
 
-.. function:: read!(stream, array::Array)
+.. function:: read!(stream::IO, array::Union{Array, BitArray})
+              read!(filename::AbstractString, array::Union{Array, BitArray})
 
    .. Docstring generated from Julia source
 
-   Read binary data from a stream, filling in the argument ``array``\ .
+   Read binary data from an I/O stream or file, filling in ``array``\ .
 
-.. function:: readbytes!(stream, b::Vector{UInt8}, nb=length(b); all=true)
+.. function:: readbytes!(stream::IO, b::AbstractVector{UInt8}, nb=length(b); all=true)
 
    .. Docstring generated from Julia source
 
-   Read at most ``nb`` bytes from the stream into ``b``\ , returning the number of bytes read (increasing the size of ``b`` as needed).
+   Read at most ``nb`` bytes from ``stream`` into ``b``\ , returning the number of bytes read. The size of ``b`` will be increased if needed (i.e. if ``nb`` is greater than ``length(b)`` and enough bytes could be read), but it will never be decreased.
 
-   See ``readbytes`` for a description of the ``all`` option.
+   See ``read`` for a description of the ``all`` option.
 
-.. function:: readbytes(stream, nb=typemax(Int); all=true)
+.. function:: read(stream::IO, nb=typemax(Int); all=true)
 
    .. Docstring generated from Julia source
 
-   Read at most ``nb`` bytes from the stream, returning a ``Vector{UInt8}`` of the bytes read.
+   Read at most ``nb`` bytes from ``stream``\ , returning a ``Vector{UInt8}`` of the bytes read.
 
    If ``all`` is ``true`` (the default), this function will block repeatedly trying to read all requested bytes, until an error or end-of-file occurs. If ``all`` is ``false``\ , at most one ``read`` call is performed, and the amount of data returned is device-dependent. Note that not all stream types support the ``all`` option.
 
+.. function:: read(filename::AbstractString, args...)
+
+   .. Docstring generated from Julia source
+
+   Open a file and read its contents. ``args`` is passed to ``read``\ : this is equivalent to ``open(io->read(io, args...), filename)``\ .
+
+.. function:: unsafe_read(io, ref, nbytes)
+
+   .. Docstring generated from Julia source
+
+   Copy nbytes from the IO stream object into ref (converted to a pointer).
+
+   It is recommended that IO subtypes override the exact method signature below to provide more efficient implementations: ``unsafe_read(s::IO, p::Ptr{UInt8}, n::UInt)``
+
+.. function:: unsafe_write(io, ref, nbytes)
+
+   .. Docstring generated from Julia source
+
+   Copy nbytes from ref (converted to a pointer) into the IO stream object.
+
+   It is recommended that IO subtypes override the exact method signature below to provide more efficient implementations: ``unsafe_write(s::IO, p::Ptr{UInt8}, n::UInt)``
+
 .. function:: position(s)
 
    .. Docstring generated from Julia source
@@ -177,28 +226,25 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   Add a mark at the current position of stream ``s``.  Returns the marked position.
+   Add a mark at the current position of stream ``s``\ . Returns the marked position.
 
-   See also :func:`unmark`, :func:`reset`, :func:`ismarked`
+   See also :func:`unmark`\ , :func:`reset`\ , :func:`ismarked`\ .
 
 .. function:: unmark(s)
 
    .. Docstring generated from Julia source
 
-   Remove a mark from stream ``s``.
-   Returns ``true`` if the stream was marked, ``false`` otherwise.
+   Remove a mark from stream ``s``\ . Returns ``true`` if the stream was marked, ``false`` otherwise.
 
-   See also :func:`mark`, :func:`reset`, :func:`ismarked`
+   See also :func:`mark`\ , :func:`reset`\ , :func:`ismarked`\ .
 
 .. function:: reset(s)
 
    .. Docstring generated from Julia source
 
-   Reset a stream ``s`` to a previously marked position, and remove the mark.
-   Returns the previously marked position.
-   Throws an error if the stream is not marked.
+   Reset a stream ``s`` to a previously marked position, and remove the mark. Returns the previously marked position. Throws an error if the stream is not marked.
 
-   See also :func:`mark`, :func:`unmark`, :func:`ismarked`
+   See also :func:`mark`\ , :func:`unmark`\ , :func:`ismarked`\ .
 
 .. function:: ismarked(s)
 
@@ -206,7 +252,7 @@ General I/O
 
    Returns ``true`` if stream ``s`` is marked.
 
-   See also :func:`mark`, :func:`unmark`, :func:`reset`
+   See also :func:`mark`\ , :func:`unmark`\ , :func:`reset`\ .
 
 .. function:: eof(stream) -> Bool
 
@@ -220,6 +266,18 @@ General I/O
 
    Determine whether a stream is read-only.
 
+.. function:: iswritable(io) -> Bool
+
+   .. Docstring generated from Julia source
+
+   Returns ``true`` if the specified IO object is writable (if that can be determined).
+
+.. function:: isreadable(io) -> Bool
+
+   .. Docstring generated from Julia source
+
+   Returns ``true`` if the specified IO object is readable (if that can be determined).
+
 .. function:: isopen(object) -> Bool
 
    .. Docstring generated from Julia source
@@ -230,7 +288,7 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   Write an arbitrary value to a stream in an opaque format, such that it can be read back by ``deserialize``\ . The read-back value will be as identical as possible to the original. In general, this process will not work if the reading and writing are done by different versions of Julia, or an instance of Julia with a different system image.
+   Write an arbitrary value to a stream in an opaque format, such that it can be read back by ``deserialize``\ . The read-back value will be as identical as possible to the original. In general, this process will not work if the reading and writing are done by different versions of Julia, or an instance of Julia with a different system image. ``Ptr`` values are serialized as all-zero bit patterns (``NULL``\ ).
 
 .. function:: deserialize(stream)
 
@@ -248,7 +306,7 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   General unescaping of traditional C and Unicode escape sequences. Reverse of :func:`print_escaped`.
+   General unescaping of traditional C and Unicode escape sequences. Reverse of :func:`print_escaped`\ .
 
 .. function:: print_joined(io, items, delim, [last])
 
@@ -272,19 +330,19 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   Create a pipe to which all C and Julia level STDOUT output will be redirected. Returns a tuple (rd,wr) representing the pipe ends. Data written to STDOUT may now be read from the rd end of the pipe. The wr end is given for convenience in case the old STDOUT object was cached by the user and needs to be replaced elsewhere.
+   Create a pipe to which all C and Julia level ``STDOUT`` output will be redirected. Returns a tuple ``(rd,wr)`` representing the pipe ends. Data written to ``STDOUT`` may now be read from the rd end of the pipe. The wr end is given for convenience in case the old ``STDOUT`` object was cached by the user and needs to be replaced elsewhere.
 
 .. function:: redirect_stdout(stream)
 
    .. Docstring generated from Julia source
 
-   Replace STDOUT by stream for all C and julia level output to STDOUT. Note that ``stream`` must be a TTY, a Pipe or a TcpSocket.
+   Replace ``STDOUT`` by stream for all C and julia level output to ``STDOUT``\ . Note that ``stream`` must be a TTY, a ``Pipe`` or a ``TCPSocket``\ .
 
 .. function:: redirect_stderr([stream])
 
    .. Docstring generated from Julia source
 
-   Like redirect_stdout, but for STDERR
+   Like ``redirect_stdout``\ , but for ``STDERR``\ .
 
 .. function:: redirect_stdin([stream])
 
@@ -296,13 +354,13 @@ General I/O
 
    .. Docstring generated from Julia source
 
-   Read the entirety of ``x`` as a string but remove trailing newlines. Equivalent to ``chomp(readall(x))``\ .
+   Read the entirety of ``x`` as a string but remove trailing newlines. Equivalent to ``chomp(readstring(x))``\ .
 
 .. function:: truncate(file,n)
 
    .. Docstring generated from Julia source
 
-   Resize the file or buffer given by the first argument to exactly ``n`` bytes, filling previously unallocated space with '\\0' if the file or buffer is grown
+   Resize the file or buffer given by the first argument to exactly ``n`` bytes, filling previously unallocated space with '\\0' if the file or buffer is grown.
 
 .. function:: skipchars(stream, predicate; linecomment::Char)
 
@@ -334,6 +392,29 @@ General I/O
 
    Read all available data on the stream, blocking the task only if no data is available. The result is a ``Vector{UInt8,1}``\ .
 
+.. function:: IOContext{<:IO} <: IO
+
+   .. Docstring generated from Julia source
+
+   IOContext provides a mechanism for passing output-configuration keyword arguments through arbitrary show methods.
+
+   In short, it is an immutable Dictionary that is a subclass of IO.
+
+   .. code-block:: julia
+
+       IOContext(io::IO, KV::Pair)
+
+   Create a new entry in the IO Dictionary for the key => value pair
+
+   * use ``(key => value) in dict`` to see if this particular combination is in the properties set
+   * use ``get(dict, key, default)`` to retrieve the most recent value for a particular key
+
+   .. code-block:: julia
+
+       IOContext(io::IO, context::IOContext)
+
+   Create a IOContext that wraps an alternate IO but inherits the keyword arguments from the context
+
 Text I/O
 --------
 
@@ -347,7 +428,7 @@ Text I/O
 
    .. Docstring generated from Julia source
 
-   Show a more compact representation of a value. This is used for printing array elements. If a new type has a different compact representation, it should overload ``showcompact(io, x)`` where the first argument is a stream.
+   Show a more compact representation of a value. This is used for printing array elements. If a new type has a different compact representation, it should test ``Base.limit_output(io)`` in its normal ``show`` method.
 
 .. function:: showall(x)
 
@@ -359,7 +440,9 @@ Text I/O
 
    .. Docstring generated from Julia source
 
-   Return a string giving a brief description of a value. By default returns ``string(typeof(x))``\ . For arrays, returns strings like "2x2 Float64 Array".
+   Return a string giving a brief description of a value. By default returns ``string(typeof(x))``\ , e.g. ``Int64``\ .
+
+   For arrays, returns a string of size and type info, e.g. ``10-element Array{Int64,1}``\ .
 
 .. function:: print(x)
 
@@ -371,13 +454,15 @@ Text I/O
 
    .. Docstring generated from Julia source
 
-   Print (using :func:`print`) ``x`` followed by a newline.
+   Print (using :func:`print`\ ) ``x`` followed by a newline.
 
 .. function:: print_with_color(color::Symbol, [io], strings...)
 
    .. Docstring generated from Julia source
 
-   Print strings in a color specified as a symbol, for example ``:red`` or ``:blue``\ .
+   Print strings in a color specified as a symbol.
+
+   ``color`` may take any of the values ``:normal``\ , ``:bold``\ , ``:black``\ , ``:blue``\ , ``:cyan``\ , ``:green``\ , ``:magenta``\ , ``:red``\ , ``:white``\ , or  ``:yellow``\ .
 
 .. function:: info(msg)
 
@@ -434,41 +519,40 @@ Text I/O
 
    Show all structure of a value, including all fields of objects.
 
-.. function:: readall(stream::IO)
-
-   .. Docstring generated from Julia source
-
-   Read the entire contents of an I/O stream as a string.
-
-.. function:: readall(filename::AbstractString)
+.. function:: readstring(stream::IO)
+              readstring(filename::AbstractString)
 
    .. Docstring generated from Julia source
 
-   Open ``filename``\ , read the entire contents as a string, then close the file. Equivalent to ``open(readall, filename)``\ .
+   Read the entire contents of an I/O stream or a file as a string. The text is assumed to be encoded in UTF-8.
 
-.. function:: readline(stream=STDIN)
+.. function:: readline(stream::IO=STDIN)
+              readline(filename::AbstractString)
 
    .. Docstring generated from Julia source
 
-   Read a single line of text, including a trailing newline character (if one is reached before the end of the input), from the given ``stream`` (defaults to ``STDIN``\ ),
+   Read a single line of text, including a trailing newline character (if one is reached before the end of the input), from the given I/O stream or file (defaults to ``STDIN``\ ). When reading from a file, the text is assumed to be encoded in UTF-8.
 
-.. function:: readuntil(stream, delim)
+.. function:: readuntil(stream::IO, delim)
+              readuntil(filename::AbstractString, delim)
 
    .. Docstring generated from Julia source
 
-   Read a string, up to and including the given delimiter byte.
+   Read a string from an I/O stream or a file, up to and including the given delimiter byte. The text is assumed to be encoded in UTF-8.
 
-.. function:: readlines(stream)
+.. function:: readlines(stream::IO)
+              readlines(filename::AbstractString)
 
    .. Docstring generated from Julia source
 
-   Read all lines as an array.
+   Read all lines of an I/O stream or a file as a vector of strings. The text is assumed to be encoded in UTF-8.
 
-.. function:: eachline(stream)
+.. function:: eachline(stream::IO)
+              eachline(filename::AbstractString)
 
    .. Docstring generated from Julia source
 
-   Create an iterable object that will yield each line from a stream.
+   Create an iterable object that will yield each line from an I/O stream or a file. The text is assumed to be encoded in UTF-8.
 
 .. function:: readdlm(source, delim::Char, T::Type, eol::Char; header=false, skipstart=0, skipblanks=true, use_mmap, ignore_invalid_chars=false, quotes=true, dims, comments=true, comment_char='#')
 
@@ -565,6 +649,18 @@ Text I/O
 
    Decodes the base64-encoded ``string`` and returns a ``Vector{UInt8}`` of the decoded bytes.
 
+.. function:: displaysize(io) -> (lines, columns)
+
+   .. Docstring generated from Julia source
+
+   Return the nominal size of the screen that may be used for rendering output to this io object
+
+.. function:: limit_output(io) -> Bool
+
+   .. Docstring generated from Julia source
+
+   Output hinting for identifying contexts where the user requested a compact output
+
 Multimedia I/O
 --------------
 
@@ -704,7 +800,7 @@ Memory-mapped I/O
    Create an ``IO``\ -like object for creating zeroed-out mmapped-memory that is not tied to a file for use in ``Mmap.mmap``\ . Used by ``SharedArray`` for creating shared memory arrays.
 
 .. function:: Mmap.mmap(io::Union{IOStream,AbstractString,Mmap.AnonymousMmap}[, type::Type{Array{T,N}}, dims, offset]; grow::Bool=true, shared::Bool=true)
-              Mmap.mmap(type::Type{Array{T,N}}, dims)
+                     Mmap.mmap(type::Type{Array{T,N}}, dims)
 
    .. Docstring generated from Julia source
 
@@ -714,48 +810,50 @@ Memory-mapped I/O
 
    ``dims`` is a tuple or single ``Integer`` specifying the size or length of the array.
 
-   The file is passed via the stream argument, either as an open ``IOStream`` or filename string.  When you initialize the stream, use ``"r"`` for a "read-only" array, and ``"w+"`` to create a new array used to write values to disk.
+   The file is passed via the stream argument, either as an open ``IOStream`` or filename string. When you initialize the stream, use ``"r"`` for a "read-only" array, and ``"w+"`` to create a new array used to write values to disk.
 
-   If no ``type`` argument is specified, the default is ``Vector{UInt8}``.
+   If no ``type`` argument is specified, the default is ``Vector{UInt8}``\ .
 
-   Optionally, you can specify an offset (in bytes) if, for example, you want to skip over a header in the file. The default value for the offset is the current stream position for an ``IOStream``.
+   Optionally, you can specify an offset (in bytes) if, for example, you want to skip over a header in the file. The default value for the offset is the current stream position for an ``IOStream``\ .
 
-   The ``grow`` keyword argument specifies whether the disk file should be grown to accomodate the requested size of array (if the total file size is < requested array size). Write privileges are required to grow the file.
+   The ``grow`` keyword argument specifies whether the disk file should be grown to accommodate the requested size of array (if the total file size is < requested array size). Write privileges are required to grow the file.
 
    The ``shared`` keyword argument specifies whether the resulting ``Array`` and changes made to it will be visible to other processes mapping the same file.
 
-   For example, the following code::
+   For example, the following code
+
+   .. code-block:: julia
 
-      # Create a file for mmapping
-      # (you could alternatively use mmap to do this step, too)
-      A = rand(1:20, 5, 30)
-      s = open("/tmp/mmap.bin", "w+")
-      # We'll write the dimensions of the array as the first two Ints in the file
-      write(s, size(A,1))
-      write(s, size(A,2))
-      # Now write the data
-      write(s, A)
-      close(s)
+       # Create a file for mmapping
+       # (you could alternatively use mmap to do this step, too)
+       A = rand(1:20, 5, 30)
+       s = open("/tmp/mmap.bin", "w+")
+       # We'll write the dimensions of the array as the first two Ints in the file
+       write(s, size(A,1))
+       write(s, size(A,2))
+       # Now write the data
+       write(s, A)
+       close(s)
 
-      # Test by reading it back in
-      s = open("/tmp/mmap.bin")   # default is read-only
-      m = read(s, Int)
-      n = read(s, Int)
-      A2 = Mmap.mmap(s, Matrix{Int}, (m,n))
+       # Test by reading it back in
+       s = open("/tmp/mmap.bin")   # default is read-only
+       m = read(s, Int)
+       n = read(s, Int)
+       A2 = Mmap.mmap(s, Matrix{Int}, (m,n))
 
-   creates a ``m``-by-``n`` ``Matrix{Int}``, linked to the file associated with stream ``s``.
+   creates a ``m``\ -by-``n`` ``Matrix{Int}``\ , linked to the file associated with stream ``s``\ .
 
-   A more portable file would need to encode the word size---32 bit or 64 bit---and endianness information in the header. In practice, consider encoding binary data using standard formats like HDF5 (which can be used with memory-mapping).
+   A more portable file would need to encode the word size – 32 bit or 64 bit – and endianness information in the header. In practice, consider encoding binary data using standard formats like HDF5 (which can be used with memory-mapping).
 
 .. function:: Mmap.mmap(io, BitArray, [dims, offset])
 
    .. Docstring generated from Julia source
 
-   Create a ``BitArray`` whose values are linked to a file, using memory-mapping; it has the same purpose, works in the same way, and has the same arguments, as :func:`mmap`, but the byte representation is different.
+   Create a ``BitArray`` whose values are linked to a file, using memory-mapping; it has the same purpose, works in the same way, and has the same arguments, as :func:`mmap`\ , but the byte representation is different.
 
-   **Example**:  ``B = Mmap.mmap(s, BitArray, (25,30000))``
+   **Example**: ``B = Mmap.mmap(s, BitArray, (25,30000))``
 
-   This would create a 25-by-30000 ``BitArray``, linked to the file associated with stream ``s``.
+   This would create a 25-by-30000 ``BitArray``\ , linked to the file associated with stream ``s``\ .
 
 .. function:: Mmap.sync!(array)
 
@@ -766,19 +864,19 @@ Memory-mapped I/O
 Network I/O
 -----------
 
-.. function:: connect([host],port) -> TcpSocket
+.. function:: connect([host],port) -> TCPSocket
 
    .. Docstring generated from Julia source
 
-   Connect to the host ``host`` on port ``port``
+   Connect to the host ``host`` on port ``port``\ .
 
 .. function:: connect(path) -> PipeEndpoint
 
    .. Docstring generated from Julia source
 
-   Connect to the Named Pipe / Domain Socket at ``path``
+   Connect to the Named Pipe / Domain Socket at ``path``\ .
 
-.. function:: listen([addr,]port) -> TcpServer
+.. function:: listen([addr,]port) -> TCPServer
 
    .. Docstring generated from Julia source
 
@@ -788,7 +886,7 @@ Network I/O
 
    .. Docstring generated from Julia source
 
-   Create and listen on a Named Pipe / Domain Socket
+   Create and listen on a Named Pipe / Domain Socket.
 
 .. function:: getaddrinfo(host)
 
@@ -796,17 +894,17 @@ Network I/O
 
    Gets the IP address of the ``host`` (may have to do a DNS lookup)
 
-.. function:: parseip(addr)
+.. function:: getsockname(sock::Union{TCPServer, TCPSocket}) -> (IPAddr,UInt16)
 
    .. Docstring generated from Julia source
 
-   Parse a string specifying an IPv4 or IPv6 ip address.
+   Get the IP address and the port that the given TCP socket is connected to (or bound to, in the case of TCPServer).
 
 .. function:: IPv4(host::Integer) -> IPv4
 
    .. Docstring generated from Julia source
 
-   Returns IPv4 object from ip address formatted as Integer
+   Returns IPv4 object from ip address formatted as Integer.
 
 .. function:: IPv6(host::Integer) -> IPv6
 
@@ -826,11 +924,11 @@ Network I/O
 
    Accepts a connection on the given server and returns a connection to the client. An uninitialized client stream may be provided, in which case it will be used instead of creating a new stream.
 
-.. function:: listenany(port_hint) -> (UInt16,TcpServer)
+.. function:: listenany(port_hint) -> (UInt16,TCPServer)
 
    .. Docstring generated from Julia source
 
-   Create a TcpServer on any port, using hint as a starting point. Returns a tuple of the actual port that the server was created on and the server itself.
+   Create a ``TCPServer`` on any port, using hint as a starting point. Returns a tuple of the actual port that the server was created on and the server itself.
 
 .. function:: poll_fd(fd, timeout_s::Real; readable=false, writable=false)
 
@@ -862,11 +960,11 @@ Network I/O
 
    This behavior of this function varies slightly across platforms. See <https://nodejs.org/api/fs.html#fs_caveats> for more detailed information.
 
-.. function:: bind(socket::Union{UDPSocket, TCPSocket}, host::IPv4, port::Integer)
+.. function:: bind(socket::Union{UDPSocket, TCPSocket}, host::IPAddr, port::Integer; ipv6only=false)
 
    .. Docstring generated from Julia source
 
-   Bind ``socket`` to the given ``host:port``\ . Note that ``0.0.0.0`` will listen on all devices.
+   Bind ``socket`` to the given ``host:port``\ . Note that ``0.0.0.0`` will listen on all devices. ``ipv6only`` parameter disables dual stack mode. If it's ``true``\ , only IPv6 stack is created.
 
 .. function:: send(socket::UDPSocket, host::IPv4, port::Integer, msg)
 
diff --git a/doc/stdlib/libc.rst b/doc/stdlib/libc.rst
index ba36122b74065..2da60ec943b7b 100644
--- a/doc/stdlib/libc.rst
+++ b/doc/stdlib/libc.rst
@@ -46,10 +46,14 @@
 
 .. function:: GetLastError()
 
+   .. Docstring generated from Julia source
+
    Call the Win32 ``GetLastError`` function [only available on Windows].
 
 .. function:: FormatMessage(n=GetLastError())
 
+   .. Docstring generated from Julia source
+
    Convert a Win32 system call error code to a descriptive string [only available on Windows].
 
 .. function:: time(t::TmStruct)
@@ -86,9 +90,9 @@
 
    .. Docstring generated from Julia source
 
-   Forces synchronization of the :func:`mmap`\ ped memory region from ``ptr`` to ``ptr+len``. Flags defaults to ``MS_SYNC``, but can be a combination of ``MS_ASYNC``, ``MS_SYNC``, or ``MS_INVALIDATE``. See your platform man page for specifics. The flags argument is not valid on Windows.
+   Forces synchronization of the :func:`mmap`\ ped memory region from ``ptr`` to ``ptr+len``\ . Flags defaults to ``MS_SYNC``\ , but can be a combination of ``MS_ASYNC``\ , ``MS_SYNC``\ , or ``MS_INVALIDATE``\ . See your platform man page for specifics. The flags argument is not valid on Windows.
 
-   You may not need to call ``msync``, because synchronization is performed at intervals automatically by the operating system. However, you can call this directly if, for example, you are concerned about losing the result of a long-running calculation.
+   You may not need to call ``msync``\ , because synchronization is performed at intervals automatically by the operating system. However, you can call this directly if, for example, you are concerned about losing the result of a long-running calculation.
 
 .. data:: MS_ASYNC
 
diff --git a/doc/stdlib/libdl.rst b/doc/stdlib/libdl.rst
index a7a5f24dd4a5f..f0de5bc935fe2 100644
--- a/doc/stdlib/libdl.rst
+++ b/doc/stdlib/libdl.rst
@@ -16,7 +16,7 @@
 
    .. Docstring generated from Julia source
 
-   Similar to :func:`dlopen`, except returns a ``NULL`` pointer instead of raising errors.
+   Similar to :func:`dlopen`\ , except returns a ``NULL`` pointer instead of raising errors.
 
 .. data:: RTLD_DEEPBIND
 
@@ -60,7 +60,7 @@
 
    .. Docstring generated from Julia source
 
-   Look up a symbol from a shared library handle, silently return NULL pointer on lookup failure.
+   Look up a symbol from a shared library handle, silently return ``NULL`` pointer on lookup failure.
 
 .. function:: dlclose(handle)
 
@@ -68,6 +68,10 @@
 
    Close shared library referenced by handle.
 
+.. data:: dlext
+
+   File extension for dynamic libraries (e.g. dll, dylib, so) on the current platform.
+
 .. function:: find_library(names, locations)
 
    .. Docstring generated from Julia source
diff --git a/doc/stdlib/linalg.rst b/doc/stdlib/linalg.rst
index a04a057f69c88..db31625bfa247 100644
--- a/doc/stdlib/linalg.rst
+++ b/doc/stdlib/linalg.rst
@@ -17,13 +17,13 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Matrix multiplication
+   Matrix multiplication.
 
 .. function:: \\(A, B)
 
    .. Docstring generated from Julia source
 
-   Matrix division using a polyalgorithm. For input matrices ``A`` and ``B``, the result ``X`` is such that ``A*X == B`` when ``A`` is square.  The solver that is used depends upon the structure of ``A``.  A direct solver is used for upper or lower triangular ``A``.  For Hermitian ``A`` (equivalent to symmetric ``A`` for non-complex ``A``) the ``BunchKaufman`` factorization is used.  Otherwise an LU factorization is used. For rectangular ``A`` the result is the minimum-norm least squares solution computed by a pivoted QR factorization of ``A`` and a rank estimate of ``A`` based on the R factor.
+   Matrix division using a polyalgorithm. For input matrices ``A`` and ``B``\ , the result ``X`` is such that ``A*X == B`` when ``A`` is square.  The solver that is used depends upon the structure of ``A``\ .  A direct solver is used for upper or lower triangular ``A``\ .  For Hermitian ``A`` (equivalent to symmetric ``A`` for non-complex ``A``\ ) the ``BunchKaufman`` factorization is used. Otherwise an LU factorization is used. For rectangular ``A`` the result is the minimum-norm least squares solution computed by a pivoted QR factorization of ``A`` and a rank estimate of ``A`` based on the R factor.
 
    When ``A`` is sparse, a similar polyalgorithm is used. For indefinite matrices, the ``LDLt`` factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.
 
@@ -57,7 +57,7 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Reconstruct the matrix ``A`` from the factorization ``F=factorize(A)``.
+   Reconstruct the matrix ``A`` from the factorization ``F=factorize(A)``\ .
 
 .. function:: lu(A) -> L, U, p
 
@@ -65,79 +65,192 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    Compute the LU factorization of ``A``\ , such that ``A[p,:] = L*U``\ .
 
-.. function:: lufact(A [,pivot=Val{true}]) -> F
+.. function:: lufact(A [,pivot=Val{true}]) -> F::LU
 
    .. Docstring generated from Julia source
 
-   Compute the LU factorization of ``A``. The return type of ``F`` depends on the type of ``A``. In most cases, if ``A`` is a subtype ``S`` of AbstractMatrix with an element type ``T`` supporting ``+``, ``-``, ``*`` and ``/`` the return type is ``LU{T,S{T}}``. If pivoting is chosen (default) the element type should also support ``abs`` and ``<``. When ``A`` is sparse and have element of type ``Float32``, ``Float64``, ``Complex{Float32}``, or ``Complex{Float64}`` the return type is ``UmfpackLU``. Some examples are shown in the table below.
+   Compute the LU factorization of ``A``\ .
 
-      ======================= ========================= ========================================
-      Type of input ``A``     Type of output ``F``      Relationship between ``F`` and ``A``
-      ----------------------- ------------------------- ----------------------------------------
-      :func:`Matrix`           ``LU``                   ``F[:L]*F[:U] == A[F[:p], :]``
-      :func:`Tridiagonal`      ``LU{T,Tridiagonal{T}}`` ``F[:L]*F[:U] == A[F[:p], :]``
-      :func:`SparseMatrixCSC`  ``UmfpackLU``            ``F[:L]*F[:U] == (F[:Rs] .* A)[F[:p], F[:q]]``
-      ======================= ========================= ========================================
+   In most cases, if ``A`` is a subtype ``S`` of ``AbstractMatrix{T}`` with an element type ``T`` supporting ``+``\ , ``-``\ , ``*`` and ``/``\ , the return type is ``LU{T,S{T}}``\ . If pivoting is chosen (default) the element type should also support ``abs`` and ``<``\ .
 
    The individual components of the factorization ``F`` can be accessed by indexing:
 
-      =========== ======================================= ====== ======================== =============
-      Component   Description                             ``LU`` ``LU{T,Tridiagonal{T}}`` ``UmfpackLU``
-      ----------- --------------------------------------- ------ ------------------------ -------------
-      ``F[:L]``   ``L`` (lower triangular) part of ``LU``    ✓            ✓                        ✓
-      ``F[:U]``   ``U`` (upper triangular) part of ``LU``    ✓            ✓                        ✓
-      ``F[:p]``   (right) permutation ``Vector``             ✓            ✓                        ✓
-      ``F[:P]``   (right) permutation ``Matrix``             ✓            ✓
-      ``F[:q]``   left permutation ``Vector``                                                      ✓
-      ``F[:Rs]``  ``Vector`` of scaling factors                                                    ✓
-      ``F[:(:)]`` ``(L,U,p,q,Rs)`` components                                                      ✓
-      =========== ======================================= ====== ======================== =============
-
-      ================== ====== ======================== =============
-      Supported function ``LU`` ``LU{T,Tridiagonal{T}}`` ``UmfpackLU``
-      ------------------ ------ ------------------------ -------------
-           ``/``            ✓
-           ``\``            ✓                       ✓             ✓
-           ``cond``         ✓                                     ✓
-           ``det``          ✓                       ✓             ✓
-           ``logdet``       ✓                       ✓
-           ``logabsdet``    ✓                       ✓
-           ``size``         ✓                       ✓
-      ================== ====== ======================== =============
+   +-----------+-----------------------------------------+
+   | Component | Description                             |
+   +===========+=========================================+
+   | ``F[:L]`` | ``L`` (lower triangular) part of ``LU`` |
+   +-----------+-----------------------------------------+
+   | ``F[:U]`` | ``U`` (upper triangular) part of ``LU`` |
+   +-----------+-----------------------------------------+
+   | ``F[:p]`` | (right) permutation ``Vector``          |
+   +-----------+-----------------------------------------+
+   | ``F[:P]`` | (right) permutation ``Matrix``          |
+   +-----------+-----------------------------------------+
+
+   The relationship between ``F`` and ``A`` is
+
+   ``F[:L]*F[:U] == A[F[:p], :]``
+
+   ``F`` further supports the following functions:
+
+   +--------------------+--------+--------------------------+
+   | Supported function | ``LU`` | ``LU{T,Tridiagonal{T}}`` |
+   +====================+========+==========================+
+   | :func:`/`          | ✓      |                          |
+   +--------------------+--------+--------------------------+
+   | :func:`\\`         | ✓      | ✓                        |
+   +--------------------+--------+--------------------------+
+   | :func:`cond`       | ✓      |                          |
+   +--------------------+--------+--------------------------+
+   | :func:`det`        | ✓      | ✓                        |
+   +--------------------+--------+--------------------------+
+   | :func:`logdet`     | ✓      | ✓                        |
+   +--------------------+--------+--------------------------+
+   | :func:`logabsdet`  | ✓      | ✓                        |
+   +--------------------+--------+--------------------------+
+   | :func:`size`       | ✓      | ✓                        |
+   +--------------------+--------+--------------------------+
+
+.. function:: lufact(A::SparseMatrixCSC) -> F::UmfpackLU
+
+   .. Docstring generated from Julia source
+
+   Compute the LU factorization of a sparse matrix ``A``\ .
+
+   For sparse ``A`` with real or complex element type, the return type of ``F`` is ``UmfpackLU{Tv, Ti}``\ , with ``Tv`` = ``Float64`` or ``Complex128`` respectively and ``Ti`` is an integer type (``Int32`` or ``Int64``\ ).
+
+   The individual components of the factorization ``F`` can be accessed by indexing:
+
+   +-------------+-----------------------------------------+
+   | Component   | Description                             |
+   +=============+=========================================+
+   | ``F[:L]``   | ``L`` (lower triangular) part of ``LU`` |
+   +-------------+-----------------------------------------+
+   | ``F[:U]``   | ``U`` (upper triangular) part of ``LU`` |
+   +-------------+-----------------------------------------+
+   | ``F[:p]``   | right permutation ``Vector``            |
+   +-------------+-----------------------------------------+
+   | ``F[:q]``   | left permutation ``Vector``             |
+   +-------------+-----------------------------------------+
+   | ``F[:Rs]``  | ``Vector`` of scaling factors           |
+   +-------------+-----------------------------------------+
+   | ``F[:(:)]`` | ``(L,U,p,q,Rs)`` components             |
+   +-------------+-----------------------------------------+
+
+   The relation between ``F`` and ``A`` is
+
+   ``F[:L]*F[:U] == (F[:Rs] .* A)[F[:p], F[:q]]``
+
+   ``F`` further supports the following functions:
+
+   * :func:`\\`
+   * :func:`cond`
+   * :func:`det`
+
+   ** Implementation note **
+
+   ``lufact(A::SparseMatrixCSC)`` uses the UMFPACK library that is part of SuiteSparse. As this library only supports sparse matrices with ``Float64`` or ``Complex128`` elements, ``lufact`` converts ``A`` into a copy that is of type ``SparseMatrixCSC{Float64}`` or ``SparseMatrixCSC{Complex128}`` as appropriate.
 
 .. function:: lufact!(A) -> LU
 
    .. Docstring generated from Julia source
 
-   ``lufact!`` is the same as :func:`lufact`, but saves space by overwriting the input ``A``, instead of creating a copy.  For sparse ``A`` the ``nzval`` field is not overwritten but the index fields, ``colptr`` and ``rowval`` are decremented in place, converting from 1-based indices to 0-based indices.
+   ``lufact!`` is the same as :func:`lufact`\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.  For sparse ``A`` the ``nzval`` field is not overwritten but the index fields, ``colptr`` and ``rowval`` are decremented in place, converting from 1-based indices to 0-based indices.
+
+.. function:: chol(A::AbstractMatrix) -> U
+
+   .. Docstring generated from Julia source
+
+   Compute the Cholesky factorization of a positive definite matrix ``A`` and return the UpperTriangular matrix ``U`` such that ``A = U'U``\ .
+
+.. function:: chol(x::Number) -> y
+
+   .. Docstring generated from Julia source
+
+   Compute the square root of a non-negative number ``x``\ .
 
-.. function:: chol(A, [LU]) -> F
+.. function:: cholfact(A::StridedMatrix, uplo::Symbol, Val{false}) -> Cholesky
 
    .. Docstring generated from Julia source
 
-   Compute the Cholesky factorization of a symmetric positive definite matrix ``A`` and return the matrix ``F``\ . If ``LU`` is ``Val{:U}`` (Upper), ``F`` is of type ``UpperTriangular`` and ``A = F'*F``\ . If ``LU`` is ``Val{:L}`` (Lower), ``F`` is of type ``LowerTriangular`` and ``A = F*F'``\ . ``LU`` defaults to ``Val{:U}``\ .
+   Compute the Cholesky factorization of a dense symmetric positive definite matrix ``A`` and return a ``Cholesky`` factorization. The ``uplo`` argument may be ``:L`` for using the lower part or ``:U`` for the upper part of ``A``\ . The default is to use ``:U``\ . The triangular Cholesky factor can be obtained from the factorization ``F`` with: ``F[:L]`` and ``F[:U]``\ . The following functions are available for ``Cholesky`` objects: ``size``\ , ``, ``inv``\ , ``det``\ . A ``PosDefException`` exception is thrown in case the matrix is not positive definite.
 
-.. function:: cholfact(A, [LU=:U[,pivot=Val{false}]][;tol=-1.0]) -> Cholesky
+.. function:: cholfact(A::StridedMatrix, uplo::Symbol, Val{true}; tol = 0.0) -> CholeskyPivoted
 
    .. Docstring generated from Julia source
 
-   Compute the Cholesky factorization of a dense symmetric positive (semi)definite matrix ``A`` and return either a ``Cholesky`` if ``pivot==Val{false}`` or ``CholeskyPivoted`` if ``pivot==Val{true}``\ . ``LU`` may be ``:L`` for using the lower part or ``:U`` for the upper part. The default is to use ``:U``\ . The triangular matrix can be obtained from the factorization ``F`` with: ``F[:L]`` and ``F[:U]``\ . The following functions are available for ``Cholesky`` objects: ``size``\ , ``\``\ , ``inv``\ , ``det``\ . For ``CholeskyPivoted`` there is also defined a ``rank``\ . If ``pivot==Val{false}`` a ``PosDefException`` exception is thrown in case the matrix is not positive definite. The argument ``tol`` determines the tolerance for determining the rank. For negative values, the tolerance is the machine precision.
+   Compute the pivoted Cholesky factorization of a dense symmetric positive semi-definite matrix ``A`` and return a ``CholeskyPivoted`` factorization. The ``uplo`` argument may be ``:L`` for using the lower part or ``:U`` for the upper part of ``A``\ . The default is to use ``:U``\ . The triangular Cholesky factor can be obtained from the factorization ``F`` with: ``F[:L]`` and ``F[:U]``\ . The following functions are available for ``PivotedCholesky`` objects: ``size``\ , ``, ``inv``\ , ``det``\ , and ``rank``\ . The argument ``tol`` determines the tolerance for determining the rank. For negative values, the tolerance is the machine precision.
 
-.. function:: cholfact(A; shift=0, perm=Int[]) -> CHOLMOD.Factor
+.. function:: cholfact(::Union{SparseMatrixCSC{<:Real},SparseMatrixCSC{Complex{<:Real}},
+                  Symmetric{<:Real,SparseMatrixCSC{<:Real,
+                  SuiteSparse_long}},Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},
+                  SuiteSparse_long}}}; shift = 0.0, perm=Int[]) -> CHOLMOD.Factor
 
    .. Docstring generated from Julia source
 
-   Compute the Cholesky factorization of a sparse positive definite matrix ``A``\ . A fill-reducing permutation is used. ``F = cholfact(A)`` is most frequently used to solve systems of equations with ``F\b``\ , but also the methods ``diag``\ , ``det``\ , ``logdet`` are defined for ``F``\ . You can also extract individual factors from ``F``\ , using ``F[:L]``\ . However, since pivoting is on by default, the factorization is internally represented as ``A == P'*L*L'*P`` with a permutation matrix ``P``\ ; using just ``L`` without accounting for ``P`` will give incorrect answers. To include the effects of permutation, it's typically preferable to extact "combined" factors like ``PtL = F[:PtL]`` (the equivalent of ``P'*L``\ ) and ``LtP = F[:UP]`` (the equivalent of ``L'*P``\ ).
+   Compute the Cholesky factorization of a sparse positive definite matrix ``A``\ . A fill-reducing permutation is used. ``F = cholfact(A)`` is most frequently used to solve systems of equations with ``F``\ , but also the methods ``diag``\ , ``det``\ , ``logdet`` are defined for ``F``\ . You can also extract individual factors from ``F``\ , using ``F[:L]``\ . However, since pivoting is on by default, the factorization is internally represented as ``A == P'*L*L'*P`` with a permutation matrix ``P``\ ; using just ``L`` without accounting for ``P`` will give incorrect answers. To include the effects of permutation, it's typically preferable to extact "combined" factors like ``PtL = F[:PtL]`` (the equivalent of ``P'*L``\ ) and ``LtP = F[:UP]`` (the equivalent of ``L'*P``\ ).
 
    Setting optional ``shift`` keyword argument computes the factorization of ``A+shift*I`` instead of ``A``\ . If the ``perm`` argument is nonempty, it should be a permutation of ``1:size(A,1)`` giving the ordering to use (instead of CHOLMOD's default AMD ordering).
 
-   The function calls the C library CHOLMOD and many other functions from the library are wrapped but not exported.
+   ** Note **
+
+   This method uses the CHOLMOD library from SuiteSparse, which only supports doubles or complex doubles. Input matrices not of those element types will be converted to ``SparseMatrixCSC{Float64}`` or ``SparseMatrixCSC{Complex128}`` as appropriate.
+
+   Many other functions from CHOLMOD are wrapped but not exported from the ``Base.SparseArrays.CHOLMOD`` module.
+
+.. function:: cholfact!(F::Factor, A::Union{SparseMatrixCSC{<:Real},
+                  SparseMatrixCSC{Complex{<:Real}},
+                  Symmetric{<:Real,SparseMatrixCSC{<:Real,SuiteSparse_long}},
+                  Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},SuiteSparse_long}}};
+                  shift = 0.0) -> CHOLMOD.Factor
+
+   .. Docstring generated from Julia source
+
+   Compute the Cholesky (:math:`LL'`\ ) factorization of ``A``\ , reusing the symbolic factorization ``F``\ .
 
-.. function:: cholfact!(A [,LU=:U [,pivot=Val{false}]][;tol=-1.0]) -> Cholesky
+   ** Note **
+
+   This method uses the CHOLMOD library from SuiteSparse, which only supports doubles or complex doubles. Input matrices not of those element types will be converted to ``SparseMatrixCSC{Float64}`` or ``SparseMatrixCSC{Complex128}`` as appropriate.
+
+.. function:: cholfact!(A::StridedMatrix, uplo::Symbol, Val{false}) -> Cholesky
+
+   .. Docstring generated from Julia source
+
+   The same as ``cholfact``\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
+
+.. function:: cholfact!(A::StridedMatrix, uplo::Symbol, Val{true}) -> PivotedCholesky
+
+   .. Docstring generated from Julia source
+
+   The same as ``cholfact``\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
+
+.. currentmodule:: Base.LinAlg
+
+.. function:: lowrankupdate(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+   .. Docstring generated from Julia source
+
+   Update a Cholesky factorization ``C`` with the vector ``v``\ . If ``A = C[:U]'C[:U]`` then ``CC = cholfact(C[:U]'C[:U] + v*v')`` but the computation of ``CC`` only uses ``O(n^2)`` operations.
+
+.. function:: lowrankdowndate(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+   .. Docstring generated from Julia source
+
+   Downdate a Cholesky factorization ``C`` with the vector ``v``\ . If ``A = C[:U]'C[:U]`` then ``CC = cholfact(C[:U]'C[:U] - v*v')`` but the computation of ``CC`` only uses ``O(n^2)`` operations.
+
+.. function:: lowrankupdate!(C::Cholesky, v::StridedVector) -> CC::Cholesky
+
+   .. Docstring generated from Julia source
+
+   Update a Cholesky factorization ``C`` with the vector ``v``\ . If ``A = C[:U]'C[:U]`` then ``CC = cholfact(C[:U]'C[:U] + v*v')`` but the computation of ``CC`` only uses ``O(n^2)`` operations. The input factorization ``C`` is updated in place such that on exit ``C == CC``\ . The vector ``v`` is destroyed during the computation.
+
+.. function:: lowrankdowndate!(C::Cholesky, v::StridedVector) -> CC::Cholesky
 
    .. Docstring generated from Julia source
 
-   ``cholfact!`` is the same as :func:`cholfact`, but saves space by overwriting the input ``A``, instead of creating a copy. ``cholfact!`` can also reuse the symbolic factorization from a different matrix ``F`` with the same structure when used as: ``cholfact!(F::CholmodFactor, A)``.
+   Downdate a Cholesky factorization ``C`` with the vector ``v``\ . If ``A = C[:U]'C[:U]`` then ``CC = cholfact(C[:U]'C[:U] - v*v')`` but the computation of ``CC`` only uses ``O(n^2)`` operations. The input factorization ``C`` is updated in place such that on exit ``C == CC``\ . The vector ``v`` is destroyed during the computation.
+
+.. currentmodule:: Base
 
 .. function:: ldltfact(::SymTridiagonal) -> LDLt
 
@@ -145,15 +258,80 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    Compute an ``LDLt`` factorization of a real symmetric tridiagonal matrix such that ``A = L*Diagonal(d)*L'`` where ``L`` is a unit lower triangular matrix and ``d`` is a vector. The main use of an ``LDLt`` factorization ``F = ldltfact(A)`` is to solve the linear system of equations ``Ax = b`` with ``F\b``\ .
 
-.. function:: ldltfact(::Union{SparseMatrixCSC,Symmetric{Float64,SparseMatrixCSC{Flaot64,SuiteSparse_long}},Hermitian{Complex{Float64},SparseMatrixCSC{Complex{Float64},SuiteSparse_long}}}; shift=0, perm=Int[]) -> CHOLMOD.Factor
+.. function:: ldltfact(::Union{SparseMatrixCSC{<:Real},SparseMatrixCSC{Complex{<:Real}},
+                  Symmetric{<:Real,SparseMatrixCSC{<:Real,SuiteSparse_long}},
+                  Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},SuiteSparse_long}}};
+                  shift = 0.0, perm=Int[]) -> CHOLMOD.Factor
 
    .. Docstring generated from Julia source
 
-   Compute the ``LDLt`` factorization of a sparse symmetric or Hermitian matrix. A fill-reducing permutation is used. ``F = ldltfact(A)`` is most frequently used to solve systems of equations ``A*x = b`` with ``F\b``\ , but also the methods ``diag``\ , ``det``\ , ``logdet`` are defined for ``F``\ . You can also extract individual factors from ``F``\ , using ``F[:L]``\ . However, since pivoting is on by default, the factorization is internally represented as ``A == P'*L*D*L'*P`` with a permutation matrix ``P``\ ; using just ``L`` without accounting for ``P`` will give incorrect answers. To include the effects of permutation, it's typically preferable to extact "combined" factors like ``PtL = F[:PtL]`` (the equivalent of ``P'*L``\ ) and ``LtP = F[:UP]`` (the equivalent of ``L'*P``\ ). The complete list of supported factors is ``:L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP``\ .
+   Compute the :math:`LDL'` factorization of a sparse symmetric or Hermitian matrix. A fill-reducing permutation is used. ``F = ldltfact(A)`` is most frequently used to solve systems of equations ``A*x = b`` with ``F``\ . The returned factorization object ``F`` also supports the methods ``diag``\ , ``det``\ , and ``logdet``\ . You can extract individual factors from ``F`` using ``F[:L]``\ . However, since pivoting is on by default, the factorization is internally represented as ``A == P'*L*D*L'*P`` with a permutation matrix ``P``\ ; using just ``L`` without accounting for ``P`` will give incorrect answers. To include the effects of permutation, it's typically preferable to extact "combined" factors like ``PtL = F[:PtL]`` (the equivalent of ``P'*L``\ ) and ``LtP = F[:UP]`` (the equivalent of ``L'*P``\ ). The complete list of supported factors is ``:L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP``\ .
 
    Setting optional ``shift`` keyword argument computes the factorization of ``A+shift*I`` instead of ``A``\ . If the ``perm`` argument is nonempty, it should be a permutation of ``1:size(A,1)`` giving the ordering to use (instead of CHOLMOD's default AMD ordering).
 
-   The function calls the C library CHOLMOD and many other functions from the library are wrapped but not exported.
+   ** Note **
+
+   This method uses the CHOLMOD library from SuiteSparse, which only supports doubles or complex doubles. Input matrices not of those element types will be converted to ``SparseMatrixCSC{Float64}`` or ``SparseMatrixCSC{Complex128}`` as appropriate.
+
+   Many other functions from CHOLMOD are wrapped but not exported from the ``Base.SparseArrays.CHOLMOD`` module.
+
+.. function:: ldltfact!(F::Factor, A::Union{SparseMatrixCSC{<:Real},
+                  SparseMatrixCSC{Complex{<:Real}},
+                  Symmetric{<:Real,SparseMatrixCSC{<:Real,SuiteSparse_long}},
+                  Hermitian{Complex{<:Real},SparseMatrixCSC{Complex{<:Real},SuiteSparse_long}}};
+                  shift = 0.0) -> CHOLMOD.Factor
+
+   .. Docstring generated from Julia source
+
+   Compute the :math:`LDL'` factorization of ``A``\ , reusing the symbolic factorization ``F``\ .
+
+   ** Note **
+
+   This method uses the CHOLMOD library from SuiteSparse, which only supports doubles or complex doubles. Input matrices not of those element types will be converted to ``SparseMatrixCSC{Float64}`` or ``SparseMatrixCSC{Complex128}`` as appropriate.
+
+.. function:: ldltfact!(::SymTridiagonal) -> LDLt
+
+   .. Docstring generated from Julia source
+
+   Same as ``ldltfact``\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
+
+.. function:: qr(v::AbstractVector)
+
+   .. Docstring generated from Julia source
+
+   Computes the polar decomposition of a vector.
+
+   Input:
+
+   * ``v::AbstractVector`` - vector to normalize
+
+   Outputs:
+
+   * ``w`` - A unit vector in the direction of ``v``
+   * ``r`` - The norm of ``v``
+
+   See also:
+
+   ``normalize``\ , ``normalize!``\ , ``LinAlg.qr!``
+
+.. function:: LinAlg.qr!(v::AbstractVector)
+
+   .. Docstring generated from Julia source
+
+   Computes the polar decomposition of a vector. Instead of returning a new vector as ``qr(v::AbstractVector)``\ , this function mutates the input vector ``v`` in place.
+
+   Input:
+
+   * ``v::AbstractVector`` - vector to normalize
+
+   Outputs:
+
+   * ``w`` - A unit vector in the direction of ``v`` (This is a mutation of ``v``\ ).
+   * ``r`` - The norm of ``v``
+
+   See also:
+
+   ``normalize``\ , ``normalize!``\ , ``qr``
 
 .. function:: qr(A [,pivot=Val{false}][;thin=true]) -> Q, R, [p]
 
@@ -165,145 +343,134 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Computes the QR factorization of ``A``. The return type of ``F`` depends on the element type of ``A`` and whether pivoting is specified (with ``pivot==Val{true}``).
+   Computes the QR factorization of ``A``\ . The return type of ``F`` depends on the element type of ``A`` and whether pivoting is specified (with ``pivot==Val{true}``\ ).
 
-      ================ ================= ============== =====================================
-      Return type      ``eltype(A)``     ``pivot``      Relationship between ``F`` and ``A``
-      ---------------- ----------------- -------------- -------------------------------------
-      ``QR``           not ``BlasFloat`` either          ``A==F[:Q]*F[:R]``
-      ``QRCompactWY``  ``BlasFloat``     ``Val{false}``  ``A==F[:Q]*F[:R]``
-      ``QRPivoted``    ``BlasFloat``     ``Val{true}``   ``A[:,F[:p]]==F[:Q]*F[:R]``
-      ================ ================= ============== =====================================
+   +-----------------+-------------------+----------------+--------------------------------------+
+   | Return type     | ``eltype(A)``     | ``pivot``      | Relationship between ``F`` and ``A`` |
+   +=================+===================+================+======================================+
+   | ``QR``          | not ``BlasFloat`` | either         | ``A==F[:Q]*F[:R]``                   |
+   +-----------------+-------------------+----------------+--------------------------------------+
+   | ``QRCompactWY`` | ``BlasFloat``     | ``Val{false}`` | ``A==F[:Q]*F[:R]``                   |
+   +-----------------+-------------------+----------------+--------------------------------------+
+   | ``QRPivoted``   | ``BlasFloat``     | ``Val{true}``  | ``A[:,F[:p]]==F[:Q]*F[:R]``          |
+   +-----------------+-------------------+----------------+--------------------------------------+
 
-   ``BlasFloat`` refers to any of: ``Float32``, ``Float64``, ``Complex64`` or ``Complex128``.
+   ``BlasFloat`` refers to any of: ``Float32``\ , ``Float64``\ , ``Complex64`` or ``Complex128``\ .
 
    The individual components of the factorization ``F`` can be accessed by indexing:
 
-      =========== ============================================= ================== ===================== ==================
-      Component   Description                                   ``QR``             ``QRCompactWY``       ``QRPivoted``
-      ----------- --------------------------------------------- ------------------ --------------------- ------------------
-      ``F[:Q]``   ``Q`` (orthogonal/unitary) part of ``QR``      ✓ (``QRPackedQ``)  ✓ (``QRCompactWYQ``)  ✓ (``QRPackedQ``)
-      ``F[:R]``   ``R`` (upper right triangular) part of ``QR``  ✓                  ✓                     ✓
-      ``F[:p]``   pivot ``Vector``                                                                        ✓
-      ``F[:P]``   (pivot) permutation ``Matrix``                                                          ✓
-      =========== ============================================= ================== ===================== ==================
+   +-----------+-----------------------------------------------+---------------------+------------------------+---------------------+
+   | Component | Description                                   | ``QR``              | ``QRCompactWY``        | ``QRPivoted``       |
+   +===========+===============================================+=====================+========================+=====================+
+   | ``F[:Q]`` | ``Q`` (orthogonal/unitary) part of ``QR``     | ✓ (``QRPackedQ``\ ) | ✓ (``QRCompactWYQ``\ ) | ✓ (``QRPackedQ``\ ) |
+   +-----------+-----------------------------------------------+---------------------+------------------------+---------------------+
+   | ``F[:R]`` | ``R`` (upper right triangular) part of ``QR`` | ✓                   | ✓                      | ✓                   |
+   +-----------+-----------------------------------------------+---------------------+------------------------+---------------------+
+   | ``F[:p]`` | pivot ``Vector``                              |                     |                        | ✓                   |
+   +-----------+-----------------------------------------------+---------------------+------------------------+---------------------+
+   | ``F[:P]`` | (pivot) permutation ``Matrix``                |                     |                        | ✓                   |
+   +-----------+-----------------------------------------------+---------------------+------------------------+---------------------+
+
+   The following functions are available for the ``QR`` objects: ``size``\ , ``\``\ . When ``A`` is rectangular, ``\`` will return a least squares solution and if the solution is not unique, the one with smallest norm is returned.
 
-   The following functions are available for the ``QR`` objects: ``size``, ``\``. When ``A`` is rectangular, ``\`` will return a least squares solution and if the solution is not unique, the one with smallest norm is returned.
+   Multiplication with respect to either thin or full ``Q`` is allowed, i.e. both ``F[:Q]*F[:R]`` and ``F[:Q]*A`` are supported. A ``Q`` matrix can be converted into a regular matrix with :func:`full` which has a named argument ``thin``\ .
 
-   Multiplication with respect to either thin or full ``Q`` is allowed, i.e. both ``F[:Q]*F[:R]`` and ``F[:Q]*A`` are supported. A ``Q`` matrix can be converted into a regular matrix with :func:`full` which has a named argument ``thin``.
+   **note**
 
-   .. note::
+   ``qrfact`` returns multiple types because LAPACK uses several representations that minimize the memory storage requirements of products of Householder elementary reflectors, so that the ``Q`` and ``R`` matrices can be stored compactly rather as two separate dense matrices.
 
-      ``qrfact`` returns multiple types because LAPACK uses several representations that minimize the memory storage requirements of products of Householder elementary reflectors, so that the ``Q`` and ``R`` matrices can be stored compactly rather as two separate dense matrices.
+   The data contained in ``QR`` or ``QRPivoted`` can be used to construct the ``QRPackedQ`` type, which is a compact representation of the rotation matrix:
 
-      The data contained in ``QR`` or ``QRPivoted`` can be used to construct the ``QRPackedQ`` type, which is a compact representation of the rotation matrix:
+   .. math::
 
-         .. math::
+       Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T)
 
-            Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T)
+   where :math:`\tau_i` is the scale factor and :math:`v_i` is the projection vector associated with the :math:`i^{th}` Householder elementary reflector.
 
-      where :math:`\tau_i` is the scale factor and :math:`v_i` is the projection vector associated with the :math:`i^{th}` Householder elementary reflector.
+   The data contained in ``QRCompactWY`` can be used to construct the ``QRCompactWYQ`` type, which is a compact representation of the rotation matrix
 
-      The data contained in ``QRCompactWY`` can be used to construct the ``QRCompactWYQ`` type, which is a compact representation of the rotation matrix
+   .. math::
 
-         .. math::
+       Q = I + Y T Y^T
 
-            Q = I + Y T Y^T
+   where ``Y`` is :math:`m \times r` lower trapezoidal and ``T`` is :math:`r \times r` upper triangular. The *compact WY* representation [Schreiber1989]_ is not to be confused with the older, *WY* representation [Bischof1987]_. (The LAPACK documentation uses ``V`` in lieu of ``Y``\ .)
 
-      where ``Y`` is :math:`m \times r` lower trapezoidal and ``T`` is :math:`r \times r` upper triangular. The *compact WY* representation [Schreiber1989]_ is not to be confused with the older, *WY* representation [Bischof1987]_. (The LAPACK documentation uses ``V`` in lieu of ``Y``.)
+   .. [Bischof1987] C Bischof and C Van Loan, "The WY representation for products of Householder matrices", SIAM J Sci Stat Comput 8 (1987), s2-s13. `doi:10.1137/0908009 <http://dx.doi.org/10.1137/0908009>`_
 
-   .. [Bischof1987] C Bischof and C Van Loan, "The WY representation for products
-      of Householder matrices", SIAM J Sci Stat Comput 8 (1987), s2-s13.
-      `doi:10.1137/0908009 <http://dx.doi.org/10.1137/0908009>`_
-   .. [Schreiber1989] R Schreiber and C Van Loan, "A storage-efficient WY
-      representation for products of Householder transformations",
-      SIAM J Sci Stat Comput 10 (1989), 53-57.
-      `doi:10.1137/0910005 <http://dx.doi.org/10.1137/0910005>`_
+   .. [Schreiber1989] R Schreiber and C Van Loan, "A storage-efficient WY representation for products of Householder transformations", SIAM J Sci Stat Comput 10 (1989), 53-57. `doi:10.1137/0910005 <http://dx.doi.org/10.1137/0910005>`_
 
 .. function:: qrfact(A) -> SPQR.Factorization
 
    .. Docstring generated from Julia source
 
-   Compute the QR factorization of a sparse matrix ``A``. A fill-reducing permutation is used. The main application of this type is to solve least squares problems with ``\``. The function calls the C library SPQR and a few additional functions from the library are wrapped but not exported.
+   Compute the QR factorization of a sparse matrix ``A``\ . A fill-reducing permutation is used. The main application of this type is to solve least squares problems with ``\``\ . The function calls the C library SPQR and a few additional functions from the library are wrapped but not exported.
 
 .. function:: qrfact!(A [,pivot=Val{false}])
 
    .. Docstring generated from Julia source
 
-   ``qrfact!`` is the same as :func:`qrfact` when ``A`` is a subtype of ``StridedMatrix``, but saves space by overwriting the input ``A``, instead of creating a copy.
+   ``qrfact!`` is the same as :func:`qrfact` when ``A`` is a subtype of ``StridedMatrix``\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
 
 .. function:: full(QRCompactWYQ[, thin=true]) -> Matrix
 
    .. Docstring generated from Julia source
 
-   Converts an orthogonal or unitary matrix stored as a ``QRCompactWYQ``
-   object, i.e. in the compact WY format [Bischof1987]_, to a dense matrix.
+   Converts an orthogonal or unitary matrix stored as a ``QRCompactWYQ`` object, i.e. in the compact WY format [Bischof1987]_, to a dense matrix.
 
-   Optionally takes a ``thin`` Boolean argument, which if ``true`` omits the
-   columns that span the rows of ``R`` in the QR factorization that are zero.
-   The resulting matrix is the ``Q`` in a thin QR factorization (sometimes
-   called the reduced QR factorization).  If ``false``, returns a ``Q`` that
-   spans all rows of ``R`` in its corresponding QR factorization.
+   Optionally takes a ``thin`` Boolean argument, which if ``true`` omits the columns that span the rows of ``R`` in the QR factorization that are zero. The resulting matrix is the ``Q`` in a thin QR factorization (sometimes called the reduced QR factorization). If ``false``\ , returns a ``Q`` that spans all rows of ``R`` in its corresponding QR factorization.
 
 .. function:: bkfact(A) -> BunchKaufman
 
    .. Docstring generated from Julia source
 
-   Compute the Bunch-Kaufman [Bunch1977]_ factorization of a real symmetric or complex Hermitian matrix ``A`` and return a ``BunchKaufman`` object. The following functions are available for ``BunchKaufman`` objects: ``size``, ``\``, ``inv``, ``issym``, ``ishermitian``.
+   Compute the Bunch-Kaufman [Bunch1977]_ factorization of a real symmetric or complex Hermitian matrix ``A`` and return a ``BunchKaufman`` object. The following functions are available for ``BunchKaufman`` objects: ``size``\ , ``\``\ , ``inv``\ , ``issymmetric``\ , ``ishermitian``\ .
 
-   .. [Bunch1977] J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. `url <http://www.ams.org/journals/mcom/1977-31-137/S0025-5718-1977-0428694-0>`_.
+   .. [Bunch1977] J R Bunch and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. `url <http://www.ams.org/journals/mcom/1977-31-137/S0025-5718-1977-0428694-0>`_\ .
 
 .. function:: bkfact!(A) -> BunchKaufman
 
    .. Docstring generated from Julia source
 
-   ``bkfact!`` is the same as :func:`bkfact`, but saves space by overwriting the input ``A``, instead of creating a copy.
+   ``bkfact!`` is the same as :func:`bkfact`\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
 
 .. function:: eig(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> D, V
 
    .. Docstring generated from Julia source
 
-   Computes eigenvalues and eigenvectors of ``A``. See :func:`eigfact` for
-   details on the ``balance`` keyword argument.
+   Computes eigenvalues and eigenvectors of ``A``\ . See :func:`eigfact` for details on the ``balance`` keyword argument.
 
    .. doctest::
 
-      julia> eig([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
-      ([1.0,3.0,18.0],
-      3x3 Array{Float64,2}:
-       1.0  0.0  0.0
-       0.0  1.0  0.0
-       0.0  0.0  1.0)
+       julia> eig([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
+       ([1.0,3.0,18.0],
+       3x3 Array{Float64,2}:
+        1.0  0.0  0.0
+        0.0  1.0  0.0
+        0.0  0.0  1.0)
 
-   ``eig`` is a wrapper around :func:`eigfact`, extracting all parts of the
-   factorization to a tuple; where possible, using :func:`eigfact` is
-   recommended.
+   ``eig`` is a wrapper around :func:`eigfact`\ , extracting all parts of the factorization to a tuple; where possible, using :func:`eigfact` is recommended.
 
 .. function:: eig(A, B) -> D, V
 
    .. Docstring generated from Julia source
 
-   Computes generalized eigenvalues and vectors of ``A`` with respect to ``B``.
+   Computes generalized eigenvalues and vectors of ``A`` with respect to ``B``\ .
 
-   ``eig`` is a wrapper around :func:`eigfact`, extracting all parts of the
-   factorization to a tuple; where possible, using :func:`eigfact` is
-   recommended.
+   ``eig`` is a wrapper around :func:`eigfact`\ , extracting all parts of the factorization to a tuple; where possible, using :func:`eigfact` is recommended.
 
-.. function:: eigvals(A,[irange,][vl,][vu])
+.. function:: eigvals(A,[irange,][vl,][vu]) -> values
 
    .. Docstring generated from Julia source
 
-   Returns the eigenvalues of ``A``. If ``A`` is :class:`Symmetric`,
-   :class:`Hermitian` or :class:`SymTridiagonal`, it is possible to calculate
-   only a subset of the eigenvalues by specifying either a :class:`UnitRange`
-   ``irange`` covering indices of the sorted eigenvalues, or a pair ``vl`` and
-   ``vu`` for the lower and upper boundaries of the eigenvalues.
+   Returns the eigenvalues of ``A``\ . If ``A`` is ``Symmetric``\ , ``Hermitian`` or ``SymTridiagonal``\ , it is possible to calculate only a subset of the eigenvalues by specifying either a ``UnitRange`` ``irange`` covering indices of the sorted eigenvalues, or a pair ``vl`` and ``vu`` for the lower and upper boundaries of the eigenvalues.
+
+   For general non-symmetric matrices it is possible to specify how the matrix is balanced before the eigenvector calculation. The option ``permute=true`` permutes the matrix to become closer to upper triangular, and ``scale=true`` scales the matrix by its diagonal elements to make rows and columns moreequal in norm. The default is ``true`` for both options.
+
+.. function:: eigvals!(A,[irange,][vl,][vu]) -> values
+
+   .. Docstring generated from Julia source
 
-   For general non-symmetric matrices it is possible to specify how the matrix
-   is balanced before the eigenvector calculation. The option ``permute=true``
-   permutes the matrix to become closer to upper triangular, and ``scale=true``
-   scales the matrix by its diagonal elements to make rows and columns more
-   equal in norm. The default is ``true`` for both options.
+   Same as ``eigvals``\ , but saves space by overwriting the input ``A`` (and ``B``\ ), instead of creating a copy.
 
 .. function:: eigmax(A)
 
@@ -321,162 +488,159 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Returns a matrix ``M`` whose columns are the eigenvectors of ``A``.
-   (The ``k``\ th eigenvector can be obtained from the slice ``M[:, k]``.)
-   The ``permute`` and ``scale`` keywords are the same as for :func:`eigfact`.
+   Returns a matrix ``M`` whose columns are the eigenvectors of ``A``\ . (The ``k``\ th eigenvector can be obtained from the slice ``M[:, k]``\ .) The ``permute`` and ``scale`` keywords are the same as for :func:`eigfact`\ .
 
-   For :class:`SymTridiagonal` matrices, if the optional vector of eigenvalues
-   ``eigvals`` is specified, returns the specific corresponding eigenvectors.
+   For :class:`SymTridiagonal` matrices, if the optional vector of eigenvalues ``eigvals`` is specified, returns the specific corresponding eigenvectors.
 
 .. function:: eigfact(A,[irange,][vl,][vu,][permute=true,][scale=true]) -> Eigen
 
    .. Docstring generated from Julia source
 
-   Computes the eigenvalue decomposition of ``A``, returning an ``Eigen``
-   factorization object ``F`` which contains the eigenvalues in ``F[:values]``
-   and the eigenvectors in the columns of the matrix ``F[:vectors]``.
-   (The ``k``\ th eigenvector can be obtained from the slice ``F[:vectors][:, k]``.)
+   Computes the eigenvalue decomposition of ``A``\ , returning an ``Eigen`` factorization object ``F`` which contains the eigenvalues in ``F[:values]`` and the eigenvectors in the columns of the matrix ``F[:vectors]``\ . (The ``k``\ th eigenvector can be obtained from the slice ``F[:vectors][:, k]``\ .)
 
-   The following functions are available for ``Eigen`` objects: ``inv``,
-   ``det``.
+   The following functions are available for ``Eigen`` objects: ``inv``\ , ``det``\ .
 
-   If ``A`` is :class:`Symmetric`, :class:`Hermitian` or :class:`SymTridiagonal`,
-   it is possible to calculate only a subset of the eigenvalues by specifying
-   either a :class:`UnitRange` ``irange`` covering indices of the sorted
-   eigenvalues or a pair ``vl`` and ``vu`` for the lower and upper boundaries
-   of the eigenvalues.
+   If ``A`` is :class:`Symmetric`\ , :class:`Hermitian` or :class:`SymTridiagonal`\ , it is possible to calculate only a subset of the eigenvalues by specifying either a :class:`UnitRange` ``irange`` covering indices of the sorted eigenvalues or a pair ``vl`` and ``vu`` for the lower and upper boundaries of the eigenvalues.
 
-   For general nonsymmetric matrices it is possible to specify how the matrix
-   is balanced before the eigenvector calculation. The option ``permute=true``
-   permutes the matrix to become closer to upper triangular, and ``scale=true``
-   scales the matrix by its diagonal elements to make rows and columns more
-   equal in norm. The default is ``true`` for both options.
+   For general nonsymmetric matrices it is possible to specify how the matrix is balanced before the eigenvector calculation. The option ``permute=true`` permutes the matrix to become closer to upper triangular, and ``scale=true`` scales the matrix by its diagonal elements to make rows and columns more equal in norm. The default is ``true`` for both options.
 
 .. function:: eigfact(A, B) -> GeneralizedEigen
 
    .. Docstring generated from Julia source
 
-   Computes the generalized eigenvalue decomposition of ``A`` and ``B``,
-   returning a ``GeneralizedEigen`` factorization object ``F`` which contains
-   the generalized eigenvalues in ``F[:values]`` and the generalized
-   eigenvectors in the columns of the matrix ``F[:vectors]``. (The ``k``\ th
-   generalized eigenvector can be obtained from the slice ``F[:vectors][:,
-   k]``.)
+   Computes the generalized eigenvalue decomposition of ``A`` and ``B``\ , returning a ``GeneralizedEigen`` factorization object ``F`` which contains the generalized eigenvalues in ``F[:values]`` and the generalized eigenvectors in the columns of the matrix ``F[:vectors]``\ . (The ``k``\ th generalized eigenvector can be obtained from the slice ``F[:vectors][:, k]``\ .)
 
 .. function:: eigfact!(A, [B])
 
    .. Docstring generated from Julia source
 
-   Same as :func:`eigfact`, but saves space by overwriting the input ``A`` (and
-   ``B``), instead of creating a copy.
+   Same as :func:`eigfact`\ , but saves space by overwriting the input ``A`` (and ``B``\ ), instead of creating a copy.
 
 .. function:: hessfact(A)
 
    .. Docstring generated from Julia source
 
-   Compute the Hessenberg decomposition of ``A`` and return a ``Hessenberg`` object. If ``F`` is the factorization object, the unitary matrix can be accessed with ``F[:Q]`` and the Hessenberg matrix with ``F[:H]``. When ``Q`` is extracted, the resulting type is the ``HessenbergQ`` object, and may be converted to a regular matrix with :func:`full`.
+   Compute the Hessenberg decomposition of ``A`` and return a ``Hessenberg`` object. If ``F`` is the factorization object, the unitary matrix can be accessed with ``F[:Q]`` and the Hessenberg matrix with ``F[:H]``\ . When ``Q`` is extracted, the resulting type is the ``HessenbergQ`` object, and may be converted to a regular matrix with :func:`full`\ .
 
 .. function:: hessfact!(A)
 
    .. Docstring generated from Julia source
 
-   ``hessfact!`` is the same as :func:`hessfact`, but saves space by overwriting the input ``A``, instead of creating a copy.
+   ``hessfact!`` is the same as :func:`hessfact`\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
 
-.. function:: schurfact(A) -> Schur
+.. function:: schurfact(A::StridedMatrix) -> F::Schur
 
    .. Docstring generated from Julia source
 
-   Computes the Schur factorization of the matrix ``A``\ . The (quasi) triangular Schur factor can be obtained from the ``Schur`` object ``F`` with either ``F[:Schur]`` or ``F[:T]`` and the unitary/orthogonal Schur vectors can be obtained with ``F[:vectors]`` or ``F[:Z]`` such that ``A=F[:vectors]*F[:Schur]*F[:vectors]'``\ . The eigenvalues of ``A`` can be obtained with ``F[:values]``\ .
+   Computes the Schur factorization of the matrix ``A``\ . The (quasi) triangular Schur factor can be obtained from the ``Schur`` object ``F`` with either ``F[:Schur]`` or ``F[:T]`` and the orthogonal/unitary Schur vectors can be obtained with ``F[:vectors]`` or ``F[:Z]`` such that ``A = F[:vectors]*F[:Schur]*F[:vectors]'``\ . The eigenvalues of ``A`` can be obtained with ``F[:values]``\ .
 
-.. function:: schurfact!(A)
+.. function:: schurfact!(A::StridedMatrix) -> F::Schur
 
    .. Docstring generated from Julia source
 
-   Computes the Schur factorization of ``A``, overwriting ``A`` in the process. See :func:`schurfact`
+   Same as ``schurfact`` but uses the input argument as workspace.
 
-.. function:: schur(A) -> Schur[:T], Schur[:Z], Schur[:values]
+.. function:: schur(A::StridedMatrix) -> T::Matrix, Z::Matrix, λ::Vector
 
    .. Docstring generated from Julia source
 
-   See :func:`schurfact`
+   Computes the Schur factorization of the matrix ``A``\ . The methods return the (quasi) triangular Schur factor ``T`` and the orthogonal/unitary Schur vectors ``Z`` such that ``A = Z*T*Z'``\ . The eigenvalues of ``A`` are returned in the vector ``λ``\ .
 
-.. function:: ordschur(Q, T, select) -> Schur
+   See ``schurfact``\ .
+
+.. function:: ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
 
    .. Docstring generated from Julia source
 
-   Reorders the Schur factorization of a real matrix ``A=Q*T*Q'`` according to the logical array ``select`` returning a Schur object ``F``. The selected eigenvalues appear in the leading diagonal of ``F[:Schur]`` and the the corresponding leading columns of ``F[:vectors]`` form an orthonormal basis of the corresponding right invariant subspace. A complex conjugate pair of eigenvalues must be either both included or excluded via ``select``.
+   Reorders the Schur factorization ``F`` of a matrix ``A = Z*T*Z'`` according to the logical array ``select`` returning the reordered factorization ``F`` object. The selected eigenvalues appear in the leading diagonal of ``F[:Schur]`` and the the corresponding leading columns of ``F[:vectors]`` form an orthogonal/unitary basis of the corresponding right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be either both included or both excluded via ``select``\ .
 
-.. function:: ordschur!(Q, T, select) -> Schur
+.. function:: ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
 
    .. Docstring generated from Julia source
 
-   Reorders the Schur factorization of a real matrix ``A=Q*T*Q'``, overwriting ``Q`` and ``T`` in the process. See :func:`ordschur`
+   Same as ``ordschur`` but overwrites the factorization ``F``\ .
 
-.. function:: ordschur(S, select) -> Schur
+.. function:: ordschur(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector
 
    .. Docstring generated from Julia source
 
-   Reorders the Schur factorization ``S`` of type ``Schur``.
+   Reorders the Schur factorization of a real matrix ``A = Z*T*Z'`` according to the logical array ``select`` returning the reordered matrices ``T`` and ``Z`` as well as the vector of eigenvalues ``λ``\ . The selected eigenvalues appear in the leading diagonal of ``T`` and the the corresponding leading columns of ``Z`` form an orthogonal/unitary basis of the corresponding right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be either both included or both excluded via ``select``\ .
 
-.. function:: ordschur!(S, select) -> Schur
+.. function:: ordschur!(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector
 
    .. Docstring generated from Julia source
 
-   Reorders the Schur factorization ``S`` of type ``Schur``, overwriting ``S`` in the process. See :func:`ordschur`
+   Same as ``ordschur`` but overwrites the input arguments.
 
-.. function:: schurfact(A, B) -> GeneralizedSchur
+.. function:: schurfact(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur
 
    .. Docstring generated from Julia source
 
    Computes the Generalized Schur (or QZ) factorization of the matrices ``A`` and ``B``\ . The (quasi) triangular Schur factors can be obtained from the ``Schur`` object ``F`` with ``F[:S]`` and ``F[:T]``\ , the left unitary/orthogonal Schur vectors can be obtained with ``F[:left]`` or ``F[:Q]`` and the right unitary/orthogonal Schur vectors can be obtained with ``F[:right]`` or ``F[:Z]`` such that ``A=F[:left]*F[:S]*F[:right]'`` and ``B=F[:left]*F[:T]*F[:right]'``\ . The generalized eigenvalues of ``A`` and ``B`` can be obtained with ``F[:alpha]./F[:beta]``\ .
 
-.. function:: schur(A,B) -> GeneralizedSchur[:S], GeneralizedSchur[:T], GeneralizedSchur[:Q], GeneralizedSchur[:Z]
+.. function:: schurfact!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur
+
+   .. Docstring generated from Julia source
+
+   Same as ``schurfact`` but uses the input matrices ``A`` and ``B`` as workspace.
+
+.. function:: ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur
 
    .. Docstring generated from Julia source
 
-   See :func:`schurfact`
+   Reorders the Generalized Schur factorization ``F`` of a matrix pair ``(A, B) = (Q*S*Z', Q*T*Z')`` according to the logical array ``select`` and returns a GeneralizedSchur object ``F``\ . The selected eigenvalues appear in the leading diagonal of both ``F[:S]`` and ``F[:T]``\ , and the left and right orthogonal/unitary Schur vectors are also reordered such that ``(A, B) = F[:Q]*(F[:S], F[:T])*F[:Z]'`` still holds and the generalized eigenvalues of ``A`` and ``B`` can still be obtained with ``F[:alpha]./F[:beta]``\ .
 
-.. function:: ordschur(S, T, Q, Z, select) -> GeneralizedSchur
+.. function:: ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur
 
    .. Docstring generated from Julia source
 
-   Reorders the Generalized Schur factorization of a matrix ``(A, B) = (Q*S*Z^{H}, Q*T*Z^{H})`` according to the logical array ``select`` and returns a GeneralizedSchur object ``GS``.  The selected eigenvalues appear in the leading diagonal of both ``(GS[:S], GS[:T])`` and the left and right unitary/orthogonal Schur vectors are also reordered such that ``(A, B) = GS[:Q]*(GS[:S], GS[:T])*GS[:Z]^{H}`` still holds and the generalized eigenvalues of ``A`` and ``B`` can still be obtained with ``GS[:alpha]./GS[:beta]``.
+   Same as ``ordschur`` but overwrites the factorization ``F``\ .
 
-.. function:: ordschur!(S, T, Q, Z, select) -> GeneralizedSchur
+.. function:: ordschur(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector
 
    .. Docstring generated from Julia source
 
-   Reorders the Generalized Schur factorization of a matrix by overwriting the matrices ``(S, T, Q, Z)`` in the process.  See :func:`ordschur`.
+   Reorders the Generalized Schur factorization of a matrix pair ``(A, B) = (Q*S*Z', Q*T*Z')`` according to the logical array ``select`` and returns the matrices ``S``\ , ``T``\ , ``Q``\ , ``Z`` and vectors ``α`` and ``β``\ .  The selected eigenvalues appear in the leading diagonal of both ``S`` and ``T``\ , and the left and right unitary/orthogonal Schur vectors are also reordered such that ``(A, B) = Q*(S, T)*Z'`` still holds and the generalized eigenvalues of ``A`` and ``B`` can still be obtained with ``α./β``\ .
 
-.. function:: ordschur(GS, select) -> GeneralizedSchur
+.. function:: ordschur!(S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, select) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector
 
    .. Docstring generated from Julia source
 
-   Reorders the Generalized Schur factorization of a Generalized Schur object.  See :func:`ordschur`.
+   Same as ``ordschur`` but overwrites the factorization the input arguments.
 
-.. function:: ordschur!(GS, select) -> GeneralizedSchur
+.. function:: schur(A::StridedMatrix, B::StridedMatrix) -> S::StridedMatrix, T::StridedMatrix, Q::StridedMatrix, Z::StridedMatrix, α::Vector, β::Vector
 
    .. Docstring generated from Julia source
 
-   Reorders the Generalized Schur factorization of a Generalized Schur object by overwriting the object with the new factorization.  See :func:`ordschur`.
+   See ``schurfact``\ .
 
 .. function:: svdfact(A, [thin=true]) -> SVD
 
    .. Docstring generated from Julia source
 
-   Compute the Singular Value Decomposition (SVD) of ``A`` and return an ``SVD`` object. ``U``\ , ``S``\ , ``V`` and ``Vt`` can be obtained from the factorization ``F`` with ``F[:U]``\ , ``F[:S]``\ , ``F[:V]`` and ``F[:Vt]``\ , such that ``A = U*diagm(S)*Vt``\ . If ``thin`` is ``true``\ , an economy mode decomposition is returned. The algorithm produces ``Vt`` and hence ``Vt`` is more efficient to extract than ``V``\ . The default is to produce a thin decomposition.
+   Compute the singular value decomposition (SVD) of ``A`` and return an ``SVD`` object.
+
+   ``U``\ , ``S``\ , ``V`` and ``Vt`` can be obtained from the factorization ``F`` with ``F[:U]``\ , ``F[:S]``\ , ``F[:V]`` and ``F[:Vt]``\ , such that ``A = U*diagm(S)*Vt``\ . The algorithm produces ``Vt`` and hence ``Vt`` is more efficient to extract than ``V``\ .
+
+   If ``thin=true`` (default), a thin SVD is returned. For a :math:`M \times N` matrix ``A``\ , ``U`` is :math:`M \times M` for a full SVD (``thin=false``\ ) and :math:`M \times \min(M, N)` for a thin SVD.
 
 .. function:: svdfact!(A, [thin=true]) -> SVD
 
    .. Docstring generated from Julia source
 
-   ``svdfact!`` is the same as :func:`svdfact`, but saves space by overwriting the input ``A``, instead of creating a copy. If ``thin`` is ``true``, an economy mode decomposition is returned. The default is to produce a thin decomposition.
+   ``svdfact!`` is the same as :func:`svdfact`\ , but saves space by overwriting the input ``A``\ , instead of creating a copy.
+
+   If ``thin=true`` (default), a thin SVD is returned. For a :math:`M \times N` matrix ``A``\ , ``U`` is :math:`M \times M` for a full SVD (``thin=false``\ ) and :math:`M \times \min(M, N)` for a thin SVD.
 
 .. function:: svd(A, [thin=true]) -> U, S, V
 
    .. Docstring generated from Julia source
 
-   Wrapper around ``svdfact`` extracting all parts the factorization to a tuple. Direct use of ``svdfact`` is therefore generally more efficient. Computes the SVD of ``A``\ , returning ``U``\ , vector ``S``\ , and ``V`` such that ``A == U*diagm(S)*V'``\ . If ``thin`` is ``true``\ , an economy mode decomposition is returned. The default is to produce a thin decomposition.
+   Computes the SVD of ``A``\ , returning ``U``\ , vector ``S``\ , and ``V`` such that ``A == U*diagm(S)*V'``\ .
+
+   If ``thin=true`` (default), a thin SVD is returned. For a :math:`M \times N` matrix ``A``\ , ``U`` is :math:`M \times M` for a full SVD (``thin=false``\ ) and :math:`M \times \min(M, N)` for a thin SVD.
+
+   ``svd`` is a wrapper around :func:`svdfact(A)`\ , extracting all parts of the ``SVD`` factorization to a tuple. Direct use of ``svdfact`` is therefore more efficient.
 
 .. function:: svdvals(A)
 
@@ -488,25 +652,110 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Returns the singular values of ``A``\ , while saving space by overwriting the input.
+   Returns the singular values of ``A``\ , saving space by overwriting the input.
 
 .. function:: svdfact(A, B) -> GeneralizedSVD
 
    .. Docstring generated from Julia source
 
-   Compute the generalized SVD of ``A`` and ``B``\ , returning a ``GeneralizedSVD`` Factorization object ``F``\ , such that ``A = F[:U]*F[:D1]*F[:R0]*F[:Q]'`` and ``B = F[:V]*F[:D2]*F[:R0]*F[:Q]'``\ .
+   Compute the generalized SVD of ``A`` and ``B``\ , returning a ``GeneralizedSVD`` factorization object ``F``\ , such that ``A = F[:U]*F[:D1]*F[:R0]*F[:Q]'`` and ``B = F[:V]*F[:D2]*F[:R0]*F[:Q]'``\ .
+
+   For an M-by-N matrix ``A`` and P-by-N matrix ``B``\ ,
+
+   * ``F[:U]`` is a M-by-M orthogonal matrix,
+   * ``F[:V]`` is a P-by-P orthogonal matrix,
+   * ``F[:Q]`` is a N-by-N orthogonal matrix,
+   * ``F[:R0]`` is a (K+L)-by-N matrix whose rightmost (K+L)-by-(K+L) block is            nonsingular upper block triangular,
+   * ``F[:D1]`` is a M-by-(K+L) diagonal matrix with 1s in the first K entries,
+   * ``F[:D2]`` is a P-by-(K+L) matrix whose top right L-by-L block is diagonal,
+
+   ``K+L`` is the effective numerical rank of the matrix ``[A; B]``\ .
+
+   The entries of ``F[:D1]`` and ``F[:D2]`` are related, as explained in the LAPACK documentation for the `generalized SVD <http://www.netlib.org/lapack/lug/node36.html>`_ and the `xGGSVD3 <http://www.netlib.org/lapack/explore-html/d6/db3/dggsvd3_8f.html>`_ routine which is called underneath (in LAPACK 3.6.0 and newer).
 
 .. function:: svd(A, B) -> U, V, Q, D1, D2, R0
 
    .. Docstring generated from Julia source
 
-   Wrapper around ``svdfact`` extracting all parts the factorization to a tuple. Direct use of ``svdfact`` is therefore generally more efficient. The function returns the generalized SVD of ``A`` and ``B``\ , returning ``U``\ , ``V``\ , ``Q``\ , ``D1``\ , ``D2``\ , and ``R0`` such that ``A = U*D1*R0*Q'`` and ``B = V*D2*R0*Q'``\ .
+   Wrapper around :func:`svdfact(A, B)` extracting all parts of the factorization to a tuple. Direct use of ``svdfact`` is therefore generally more efficient. The function returns the generalized SVD of ``A`` and ``B``\ , returning ``U``\ , ``V``\ , ``Q``\ , ``D1``\ , ``D2``\ , and ``R0`` such that ``A = U*D1*R0*Q'`` and ``B = V*D2*R0*Q'``\ .
 
 .. function:: svdvals(A, B)
 
    .. Docstring generated from Julia source
 
-   Return only the singular values from the generalized singular value decomposition of ``A`` and ``B``\ .
+   Return the generalized singular values from the generalized singular value decomposition of ``A`` and ``B``\ .
+
+.. function:: LinAlg.Givens(i1,i2,c,s) -> G
+
+   .. Docstring generated from Julia source
+
+   A Givens rotation linear operator. The fields ``c`` and ``s`` represent the cosine and sine of the rotation angle, respectively. The ``Givens`` type supports left multiplication ``G*A`` and conjugated transpose right multiplication ``A*G'``\ . The type doesn't have a ``size`` and can therefore be multiplied with matrices of arbitrary size as long as ``i2<=size(A,2)`` for ``G*A`` or ``i2<=size(A,1)`` for ``A*G'``\ .
+
+   See also: :func:`givens`
+
+.. function:: givens{T}(f::T, g::T, i1::Integer, i2::Integer) -> (G::Givens, r::T)
+
+   .. Docstring generated from Julia source
+
+   Computes the Givens rotation ``G`` and scalar ``r`` such that for any vector ``x`` where
+
+   .. code-block:: julia
+
+       x[i1] = f
+       x[i2] = g
+
+   the result of the multiplication
+
+   .. code-block:: julia
+
+       y = G*x
+
+   has the property that
+
+   .. code-block:: julia
+
+       y[i1] = r
+       y[i2] = 0
+
+   See also: :class:`LinAlg.Givens`
+
+.. function:: givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)
+
+   .. Docstring generated from Julia source
+
+   Computes the Givens rotation ``G`` and scalar ``r`` such that the result of the multiplication
+
+   .. code-block:: julia
+
+       B = G*x
+
+   has the property that
+
+   .. code-block:: julia
+
+       B[i1] = r
+       B[i2] = 0
+
+   See also: :class:`LinAlg.Givens`
+
+.. function:: givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)
+
+   .. Docstring generated from Julia source
+
+   Computes the Givens rotation ``G`` and scalar ``r`` such that the result of the multiplication
+
+   .. code-block:: julia
+
+       B = G*A
+
+   has the property that
+
+   .. code-block:: julia
+
+       B[i1,j] = r
+       B[i2,j] = 0
+
+   See also: :class:`LinAlg.Givens`
 
 .. function:: triu(M)
 
@@ -574,49 +823,32 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    Construct a diagonal matrix and place ``v`` on the ``k``\ th diagonal.
 
-.. function:: scale(A, b)
-              scale(b, A)
-
-   .. Docstring generated from Julia source
-
-   Scale an array ``A`` by a scalar ``b``\ , returning a new array.
-
-   If ``A`` is a matrix and ``b`` is a vector, then ``scale(A,b)`` scales each column ``i`` of ``A`` by ``b[i]`` (similar to ``A*diagm(b)``\ ), while ``scale(b,A)`` scales each row ``i`` of ``A`` by ``b[i]`` (similar to ``diagm(b)*A``\ ), returning a new array.
-
-   Note: for large ``A``\ , ``scale`` can be much faster than ``A .* b`` or ``b .* A``\ , due to the use of BLAS.
-
 .. function:: scale!(A, b)
               scale!(b, A)
 
    .. Docstring generated from Julia source
 
-   Scale an array ``A`` by a scalar ``b``, similar to :func:`scale` but
-   overwriting ``A`` in-place.
+   Scale an array ``A`` by a scalar ``b`` overwriting ``A`` in-place.
 
-   If ``A`` is a matrix and ``b`` is a vector, then ``scale!(A,b)``
-   scales each column ``i`` of ``A`` by ``b[i]`` (similar to
-   ``A*diagm(b)``), while ``scale!(b,A)`` scales each row ``i`` of
-   ``A`` by ``b[i]`` (similar to ``diagm(b)*A``), again operating in-place
-   on ``A``.
+   If ``A`` is a matrix and ``b`` is a vector, then ``scale!(A,b)`` scales each column ``i`` of ``A`` by ``b[i]`` (similar to ``A*Diagonal(b)``\ ), while ``scale!(b,A)`` scales each row ``i`` of ``A`` by ``b[i]`` (similar to ``Diagonal(b)*A``\ ), again operating in-place on ``A``\ .
 
 .. function:: Tridiagonal(dl, d, du)
 
    .. Docstring generated from Julia source
 
-   Construct a tridiagonal matrix from the lower diagonal, diagonal, and upper diagonal, respectively.  The result is of type ``Tridiagonal`` and provides efficient specialized linear solvers, but may be converted into a regular matrix with :func:`full`.
+   Construct a tridiagonal matrix from the lower diagonal, diagonal, and upper diagonal, respectively.  The result is of type ``Tridiagonal`` and provides efficient specialized linear solvers, but may be converted into a regular matrix with :func:`full`\ .
 
 .. function:: Bidiagonal(dv, ev, isupper)
 
    .. Docstring generated from Julia source
 
-   Constructs an upper (``isupper=true``) or lower (``isupper=false``) bidiagonal matrix
-   using the given diagonal (``dv``) and off-diagonal (``ev``) vectors.  The result is of type ``Bidiagonal`` and provides efficient specialized linear solvers, but may be converted into a regular matrix with :func:`full`.
+   Constructs an upper (``isupper=true``\ ) or lower (``isupper=false``\ ) bidiagonal matrix using the given diagonal (``dv``\ ) and off-diagonal (``ev``\ ) vectors.  The result is of type ``Bidiagonal`` and provides efficient specialized linear solvers, but may be converted into a regular matrix with :func:`full`\ .
 
 .. function:: SymTridiagonal(d, du)
 
    .. Docstring generated from Julia source
 
-   Construct a real symmetric tridiagonal matrix from the diagonal and upper diagonal, respectively. The result is of type ``SymTridiagonal`` and provides efficient specialized eigensolvers, but may be converted into a regular matrix with :func:`full`.
+   Construct a real symmetric tridiagonal matrix from the diagonal and upper diagonal, respectively. The result is of type ``SymTridiagonal`` and provides efficient specialized eigensolvers, but may be converted into a regular matrix with :func:`full`\ .
 
 .. function:: rank(M)
 
@@ -628,11 +860,11 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Compute the ``p``-norm of a vector or the operator norm of a matrix ``A``, defaulting to the ``p=2``-norm.
+   Compute the ``p``\ -norm of a vector or the operator norm of a matrix ``A``\ , defaulting to the ``p=2``\ -norm.
 
-   For vectors, ``p`` can assume any numeric value (even though not all values produce a mathematically valid vector norm). In particular, ``norm(A, Inf)`` returns the largest value in ``abs(A)``, whereas ``norm(A, -Inf)`` returns the smallest.
+   For vectors, ``p`` can assume any numeric value (even though not all values produce a mathematically valid vector norm). In particular, ``norm(A, Inf)`` returns the largest value in ``abs(A)``\ , whereas ``norm(A, -Inf)`` returns the smallest.
 
-   For matrices, the matrix norm induced by the vector ``p``-norm is used, where valid values of ``p`` are ``1``, ``2``, or ``Inf``. (Note that for sparse matrices, ``p=2`` is currently not implemented.) Use :func:`vecnorm` to compute the Frobenius norm.
+   For matrices, the matrix norm induced by the vector ``p``\ -norm is used, where valid values of ``p`` are ``1``\ , ``2``\ , or ``Inf``\ . (Note that for sparse matrices, ``p=2`` is currently not implemented.) Use :func:`vecnorm` to compute the Frobenius norm.
 
 .. function:: vecnorm(A, [p])
 
@@ -642,6 +874,44 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    For example, if ``A`` is a matrix and ``p=2``\ , then this is equivalent to the Frobenius norm.
 
+.. function:: normalize!(v, [p=2])
+
+   .. Docstring generated from Julia source
+
+   Normalize the vector ``v`` in-place with respect to the ``p``\ -norm.
+
+   Inputs:
+
+   * ``v::AbstractVector`` - vector to be normalized
+   * ``p::Real`` - The ``p``\ -norm to normalize with respect to. Default: 2
+
+   Output:
+
+   * ``v`` - A unit vector being the input vector, rescaled to have norm 1.         The input vector is modified in-place.
+
+   See also:
+
+   ``normalize``\ , ``qr``
+
+.. function:: normalize(v, [p=2])
+
+   .. Docstring generated from Julia source
+
+   Normalize the vector ``v`` with respect to the ``p``\ -norm.
+
+   Inputs:
+
+   * ``v::AbstractVector`` - vector to be normalized
+   * ``p::Real`` - The ``p``\ -norm to normalize with respect to. Default: 2
+
+   Output:
+
+   * ``v`` - A unit vector being a copy of the input vector, scaled to have norm 1
+
+   See also:
+
+   ``normalize!``\ , ``qr``
+
 .. function:: cond(M, [p])
 
    .. Docstring generated from Julia source
@@ -665,13 +935,13 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Matrix trace
+   Matrix trace.
 
 .. function:: det(M)
 
    .. Docstring generated from Julia source
 
-   Matrix determinant
+   Matrix determinant.
 
 .. function:: logdet(M)
 
@@ -689,7 +959,7 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Matrix inverse
+   Matrix inverse.
 
 .. function:: pinv(M[, tol])
 
@@ -697,32 +967,19 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    Computes the Moore-Penrose pseudoinverse.
 
-   For matrices ``M`` with floating point elements, it is convenient to compute
-   the pseudoinverse by inverting only singular values above a given threshold,
-   ``tol``.
-
-   The optimal choice of ``tol`` varies both with the value of ``M``
-   and the intended application of the pseudoinverse. The default value of
-   ``tol`` is ``eps(real(float(one(eltype(M)))))*maximum(size(A))``,
-   which is essentially machine epsilon for the real part of a matrix element
-   multiplied by the larger matrix dimension.
-   For inverting dense ill-conditioned matrices in a least-squares sense,
-   ``tol = sqrt(eps(real(float(one(eltype(M))))))`` is recommended.
-
-   For more information, see [8859]_, [B96]_, [S84]_, [KY88]_.
-
-   .. [8859] Issue 8859, "Fix least squares", https://github.com/JuliaLang/julia/pull/8859
-   .. [B96] Åke Björck, "Numerical Methods for Least Squares Problems",
-      SIAM Press, Philadelphia, 1996, "Other Titles in Applied Mathematics", Vol. 51.
-      `doi:10.1137/1.9781611971484 <http://epubs.siam.org/doi/book/10.1137/1.9781611971484>`_
-   .. [S84] G. W. Stewart, "Rank Degeneracy", SIAM Journal on
-      Scientific and Statistical Computing, 5(2), 1984, 403-413.
-      `doi:10.1137/0905030 <http://epubs.siam.org/doi/abs/10.1137/0905030>`_
-   .. [KY88] Konstantinos Konstantinides and Kung Yao, "Statistical analysis
-      of effective singular values in matrix rank determination", IEEE
-      Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988,
-      757-763.
-      `doi:10.1109/29.1585 <http://dx.doi.org/10.1109/29.1585>`_
+   For matrices ``M`` with floating point elements, it is convenient to compute the pseudoinverse by inverting only singular values above a given threshold, ``tol``\ .
+
+   The optimal choice of ``tol`` varies both with the value of ``M`` and the intended application of the pseudoinverse. The default value of ``tol`` is ``eps(real(float(one(eltype(M)))))*maximum(size(A))``\ , which is essentially machine epsilon for the real part of a matrix element multiplied by the larger matrix dimension. For inverting dense ill-conditioned matrices in a least-squares sense, ``tol = sqrt(eps(real(float(one(eltype(M))))))`` is recommended.
+
+   For more information, see [issue8859]_, [B96]_, [S84]_, [KY88]_.
+
+   .. [issue8859] Issue 8859, "Fix least squares", https://github.com/JuliaLang/julia/pull/8859
+
+   .. [B96] Åke Björck, "Numerical Methods for Least Squares Problems",  SIAM Press, Philadelphia, 1996, "Other Titles in Applied Mathematics", Vol. 51. `doi:10.1137/1.9781611971484 <http://epubs.siam.org/doi/book/10.1137/1.9781611971484>`_
+
+   .. [S84] G. W. Stewart, "Rank Degeneracy", SIAM Journal on Scientific and Statistical Computing, 5(2), 1984, 403-413. `doi:10.1137/0905030 <http://epubs.siam.org/doi/abs/10.1137/0905030>`_
+
+   .. [KY88] Konstantinos Konstantinides and Kung Yao, "Statistical analysis of effective singular values in matrix rank determination", IEEE Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988, 757-763. `doi:10.1109/29.1585 <http://dx.doi.org/10.1109/29.1585>`_
 
 .. function:: nullspace(M)
 
@@ -764,12 +1021,12 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. code-block:: julia
 
-          using PyPlot
-          x = [1.0:12.0;]
-          y = [5.5, 6.3, 7.6, 8.8, 10.9, 11.79, 13.48, 15.02, 17.77, 20.81, 22.0, 22.99]
-          a, b = linreg(x, y)          # Linear regression
-          plot(x, y, "o")              # Plot (x, y) points
-          plot(x, [a+b*i for i in x])  # Plot line determined by linear regression
+       using PyPlot
+       x = [1.0:12.0;]
+       y = [5.5, 6.3, 7.6, 8.8, 10.9, 11.79, 13.48, 15.02, 17.77, 20.81, 22.0, 22.99]
+       a, b = linreg(x, y)          # Linear regression
+       plot(x, y, "o")              # Plot (x, y) points
+       plot(x, [a+b*i for i in x])  # Plot line determined by linear regression
 
 .. function:: linreg(x, y, w)
 
@@ -781,47 +1038,37 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Compute the matrix exponential of ``A``, defined by
+   Compute the matrix exponential of ``A``\ , defined by
 
    .. math::
-      e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.
 
-   For symmetric or Hermitian ``A``, an eigendecomposition (:func:`eigfact`) is used, otherwise the scaling and squaring algorithm (see [H05]_) is chosen.
+       e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.
+
+   For symmetric or Hermitian ``A``\ , an eigendecomposition (:func:`eigfact`\ ) is used, otherwise the scaling and squaring algorithm (see [H05]_) is chosen.
 
-   .. [H05] Nicholas J. Higham, "The squaring and scaling method for the matrix
-      exponential revisited", SIAM Journal on Matrix Analysis and Applications,
-      26(4), 2005, 1179-1193.
-      `doi:10.1137/090768539 <http://dx.doi.org/10.1137/090768539>`_
+   .. [H05] Nicholas J. Higham, "The squaring and scaling method for the matrix exponential revisited", SIAM Journal on Matrix Analysis and Applications, 26(4), 2005, 1179-1193. `doi:10.1137/090768539 <http://dx.doi.org/10.1137/090768539>`_
 
-.. function:: logm(A)
+.. function:: logm(A::StridedMatrix)
 
    .. Docstring generated from Julia source
 
-   If ``A`` has no negative real eigenvalue, compute the principal matrix logarithm of ``A``, i.e. the unique matrix :math:`X` such that :math:`e^X = A` and :math:`-\pi < Im(\lambda) < \pi` for all the eigenvalues :math:`\lambda` of :math:`X`. If ``A`` has nonpositive eigenvalues, a warning is printed and whenever possible a nonprincipal matrix function is returned.
+   If ``A`` has no negative real eigenvalue, compute the principal matrix logarithm of ``A``\ , i.e. the unique matrix :math:`X` such that :math:`e^X = A` and :math:`-\pi < Im(\lambda) < \pi` for all the eigenvalues :math:`\lambda` of :math:`X`\ . If ``A`` has nonpositive eigenvalues, a nonprincipal matrix function is returned whenever possible.
 
-   If ``A`` is symmetric or Hermitian, its eigendecomposition (:func:`eigfact`) is used, if ``A`` is triangular an improved version of the inverse scaling and squaring method is employed (see [AH12]_ and [AHR13]_). For general matrices, the complex Schur form (:func:`schur`) is computed and the triangular algorithm is used on the triangular factor.
+   If ``A`` is symmetric or Hermitian, its eigendecomposition (:func:`eigfact`\ ) is used, if ``A`` is triangular an improved version of the inverse scaling and squaring method is employed (see [AH12]_ and [AHR13]_). For general matrices, the complex Schur form (:func:`schur`\ ) is computed and the triangular algorithm is used on the triangular factor.
 
-   .. [AH12] Awad H. Al-Mohy and Nicholas J. Higham, "Improved inverse  scaling
-      and squaring algorithms for the matrix logarithm", SIAM Journal on
-      Scientific Computing, 34(4), 2012, C153-C169.
-      `doi:10.1137/110852553 <http://dx.doi.org/10.1137/110852553>`_
-   .. [AHR13] Awad H. Al-Mohy, Nicholas J. Higham and Samuel D. Relton,
-      "Computing the Fréchet derivative of the matrix logarithm and estimating
-      the condition number", SIAM Journal on Scientific Computing, 35(4), 2013,
-      C394-C410.
-      `doi:10.1137/120885991 <http://dx.doi.org/10.1137/120885991>`_
+   .. [AH12] Awad H. Al-Mohy and Nicholas J. Higham, "Improved inverse  scaling and squaring algorithms for the matrix logarithm", SIAM Journal on Scientific Computing, 34(4), 2012, C153-C169. `doi:10.1137/110852553 <http://dx.doi.org/10.1137/110852553>`_
+
+   .. [AHR13] Awad H. Al-Mohy, Nicholas J. Higham and Samuel D. Relton, "Computing the Fréchet derivative of the matrix logarithm and estimating the condition number", SIAM Journal on Scientific Computing, 35(4), 2013, C394-C410. `doi:10.1137/120885991 <http://dx.doi.org/10.1137/120885991>`_
 
 .. function:: sqrtm(A)
 
    .. Docstring generated from Julia source
 
-   If ``A`` has no negative real eigenvalues, compute the principal matrix square root of ``A``, that is the unique matrix :math:`X` with eigenvalues having positive real part such that :math:`X^2 = A`. Otherwise, a nonprincipal square root is returned.
+   If ``A`` has no negative real eigenvalues, compute the principal matrix square root of ``A``\ , that is the unique matrix :math:`X` with eigenvalues having positive real part such that :math:`X^2 = A`\ . Otherwise, a nonprincipal square root is returned.
 
-   If ``A`` is symmetric or Hermitian, its eigendecomposition (:func:`eigfact`) is used to compute the square root. Otherwise, the square root is determined by means of the Björck-Hammarling method, which computes the complex Schur form (:func:`schur`) and then the complex square root of the triangular factor.
+   If ``A`` is symmetric or Hermitian, its eigendecomposition (:func:`eigfact`\ ) is used to compute the square root. Otherwise, the square root is determined by means of the Björck-Hammarling method, which computes the complex Schur form (:func:`schur`\ ) and then the complex square root of the triangular factor.
 
-   .. [BH83] Åke Björck and Sven Hammarling, "A Schur method for the square root
-      of a matrix", Linear Algebra and its Applications, 52-53, 1983, 127-140.
-      `doi:10.1016/0024-3795(83)80010-X <http://dx.doi.org/10.1016/0024-3795(83)80010-X>`_
+   .. [BH83] Åke Björck and Sven Hammarling, "A Schur method for the square root of a matrix", Linear Algebra and its Applications, 52-53, 1983, 127-140. `doi:10.1016/0024-3795(83)80010-X <http://dx.doi.org/10.1016/0024-3795(83)80010-X>`_
 
 .. function:: lyap(A, C)
 
@@ -835,7 +1082,7 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    Computes the solution ``X`` to the Sylvester equation ``AX + XB + C = 0``\ , where ``A``\ , ``B`` and ``C`` have compatible dimensions and ``A`` and ``-B`` have no eigenvalues with equal real part.
 
-.. function:: issym(A) -> Bool
+.. function:: issymmetric(A) -> Bool
 
    .. Docstring generated from Julia source
 
@@ -901,76 +1148,158 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    Conjugate transpose array ``src`` and store the result in the preallocated array ``dest``\ , which should have a size corresponding to ``(size(src,2),size(src,1))``\ . No in-place transposition is supported and unexpected results will happen if ``src`` and ``dest`` have overlapping memory regions.
 
-.. function:: eigs(A, [B,]; nev=6, which="LM", tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
+.. function:: eigs(A; nev=6, ncv=max(20,2*nev+1), which="LM", tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
+
+   .. Docstring generated from Julia source
+
+   Computes eigenvalues ``d`` of ``A`` using implicitly restarted Lanczos or Arnoldi iterations for real symmetric or general nonsymmetric matrices respectively.
+
+   The following keyword arguments are supported:
+
+   * ``nev``\ : Number of eigenvalues
+   * ``ncv``\ : Number of Krylov vectors used in the computation; should satisfy ``nev+1 <= ncv <= n``   for real symmetric problems and ``nev+2 <= ncv <= n`` for other problems, where ``n`` is the   size of the input matrix ``A``\ . The default is ``ncv = max(20,2*nev+1)``\ . Note that these   restrictions limit the input matrix ``A`` to be of dimension at least 2.
+   * ``which``\ : type of eigenvalues to compute. See the note below.
+
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``which`` | type of eigenvalues                                                                                                         |
+   +===========+=============================================================================================================================+
+   | ``:LM``   | eigenvalues of largest magnitude (default)                                                                                  |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:SM``   | eigenvalues of smallest magnitude                                                                                           |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:LR``   | eigenvalues of largest real part                                                                                            |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:SR``   | eigenvalues of smallest real part                                                                                           |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:LI``   | eigenvalues of largest imaginary part (nonsymmetric or complex ``A`` only)                                                  |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:SI``   | eigenvalues of smallest imaginary part (nonsymmetric or complex ``A`` only)                                                 |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:BE``   | compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric ``A`` only) |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+
+   * ``tol``\ : parameter defining the relative tolerance for convergence of Ritz values (eigenvalue estimates).      A Ritz value :math:`θ` is considered converged when its associated residual      is less than or equal to the product of ``tol`` and :math:`max(ɛ^{2/3}, |θ|)`\ ,      where ``ɛ = eps(real(eltype(A)))/2`` is LAPACK's machine epsilon.      The residual associated with :math:`θ` and its corresponding Ritz vector :math:`v`      is defined as the norm :math:`||Av - vθ||`\ .      The specified value of ``tol`` should be positive; otherwise, it is ignored      and :math:`ɛ` is used instead.      Default: :math:`ɛ`\ .
+
+   * ``maxiter``\ : Maximum number of iterations (default = 300)
+   * ``sigma``\ : Specifies the level shift used in inverse iteration. If ``nothing`` (default),   defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to ``sigma``   using shift and invert iterations.
+   * ``ritzvec``\ : Returns the Ritz vectors ``v`` (eigenvectors) if ``true``
+   * ``v0``\ : starting vector from which to start the iterations
+
+   ``eigs`` returns the ``nev`` requested eigenvalues in ``d``\ , the corresponding Ritz vectors ``v`` (only if ``ritzvec=true``\ ), the number of converged eigenvalues ``nconv``\ , the number of iterations ``niter`` and the number of matrix vector multiplications ``nmult``\ , as well as the final residual vector ``resid``\ .
+
+   **note**
+
+   The ``sigma`` and ``which`` keywords interact: the description of eigenvalues searched for by ``which`` do _not_ necessarily refer to the eigenvalues of ``A``\ , but rather the linear operator constructed by the specification of the iteration mode implied by ``sigma``\ .
+
+   +-----------------+------------------------------------+------------------------------------+
+   | ``sigma``       | iteration mode                     | ``which`` refers to eigenvalues of |
+   +=================+====================================+====================================+
+   | ``nothing``     | ordinary (forward)                 | :math:`A`                          |
+   +-----------------+------------------------------------+------------------------------------+
+   | real or complex | inverse with level shift ``sigma`` | :math:`(A - \sigma I )^{-1}`       |
+   +-----------------+------------------------------------+------------------------------------+
+
+   **note**
+
+   Although ``tol`` has a default value, the best choice depends strongly on the matrix ``A``\ . We recommend that users _always_ specify a value for ``tol`` which suits their specific needs.
+
+   For details of how the errors in the computed eigenvalues are estimated, see:
+
+   * B. N. Parlett, "The Symmetric Eigenvalue Problem", SIAM: Philadelphia, 2/e   (1998), Ch. 13.2, "Accessing Accuracy in Lanczos Problems", pp. 290-292 ff.
+   * R. B. Lehoucq and D. C. Sorensen, "Deflation Techniques for an Implicitly   Restarted Arnoldi Iteration", SIAM Journal on Matrix Analysis and   Applications (1996), 17(4), 789–821.  doi:10.1137/S0895479895281484
+
+.. function:: eigs(A, B; nev=6, ncv=max(20,2*nev+1), which="LM", tol=0.0, maxiter=300, sigma=nothing, ritzvec=true, v0=zeros((0,))) -> (d,[v,],nconv,niter,nmult,resid)
 
    .. Docstring generated from Julia source
 
-   Computes eigenvalues ``d`` of ``A`` using Lanczos or Arnoldi iterations for
-   real symmetric or general nonsymmetric matrices respectively. If ``B`` is
-   provided, the generalized eigenproblem is solved.
+   Computes generalized eigenvalues ``d`` of ``A`` and ``B`` using implicitly restarted Lanczos or Arnoldi iterations for real symmetric or general nonsymmetric matrices respectively.
 
    The following keyword arguments are supported:
-    * ``nev``: Number of eigenvalues
-    * ``ncv``: Number of Krylov vectors used in the computation; should satisfy ``nev+1 <= ncv <= n`` for real symmetric problems and ``nev+2 <= ncv <= n`` for other problems, where ``n`` is the size of the input matrix ``A``. The default is ``ncv = max(20,2*nev+1)``.
 
-       Note that these restrictions limit the input matrix ``A`` to be of dimension at least 2.
-    * ``which``: type of eigenvalues to compute. See the note below.
+   * ``nev``\ : Number of eigenvalues
+   * ``ncv``\ : Number of Krylov vectors used in the computation; should satisfy ``nev+1 <= ncv <= n``   for real symmetric problems and ``nev+2 <= ncv <= n`` for other problems, where ``n`` is the   size of the input matrices ``A`` and ``B``\ . The default is ``ncv = max(20,2*nev+1)``\ . Note that   these restrictions limit the input matrix ``A`` to be of dimension at least 2.
+   * ``which``\ : type of eigenvalues to compute. See the note below.
+
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``which`` | type of eigenvalues                                                                                                         |
+   +===========+=============================================================================================================================+
+   | ``:LM``   | eigenvalues of largest magnitude (default)                                                                                  |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:SM``   | eigenvalues of smallest magnitude                                                                                           |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:LR``   | eigenvalues of largest real part                                                                                            |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:SR``   | eigenvalues of smallest real part                                                                                           |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:LI``   | eigenvalues of largest imaginary part (nonsymmetric or complex ``A`` only)                                                  |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:SI``   | eigenvalues of smallest imaginary part (nonsymmetric or complex ``A`` only)                                                 |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
+   | ``:BE``   | compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric ``A`` only) |
+   +-----------+-----------------------------------------------------------------------------------------------------------------------------+
 
-      ========= ======================================================================================================================
-      ``which`` type of eigenvalues
-      --------- ----------------------------------------------------------------------------------------------------------------------
-      ``:LM``   eigenvalues of largest magnitude (default)
-      ``:SM``   eigenvalues of smallest magnitude
-      ``:LR``   eigenvalues of largest real part
-      ``:SR``   eigenvalues of smallest real part
-      ``:LI``   eigenvalues of largest imaginary part (nonsymmetric or complex ``A`` only)
-      ``:SI``   eigenvalues of smallest imaginary part (nonsymmetric or complex ``A`` only)
-      ``:BE``   compute half of the eigenvalues from each end of the spectrum, biased in favor of the high end. (real symmetric ``A`` only)
-      ========= ======================================================================================================================
+   * ``tol``\ : relative tolerance used in the convergence criterion for eigenvalues, similar to      ``tol`` in the :func:`eigs` method for the ordinary eigenvalue      problem, but effectively for the eigenvalues of :math:`B^{-1} A` instead of :math:`A`\ .      See the documentation for the ordinary eigenvalue problem in      :func:`eigs` and the accompanying note about ``tol``\ .
+   * ``maxiter``\ : Maximum number of iterations (default = 300)
+   * ``sigma``\ : Specifies the level shift used in inverse iteration. If ``nothing`` (default),   defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to ``sigma``   using shift and invert iterations.
+   * ``ritzvec``\ : Returns the Ritz vectors ``v`` (eigenvectors) if ``true``
+   * ``v0``\ : starting vector from which to start the iterations
 
-    * ``tol``: tolerance (:math:`tol \le 0.0` defaults to ``DLAMCH('EPS')``)
-    * ``maxiter``: Maximum number of iterations (default = 300)
-    * ``sigma``: Specifies the level shift used in inverse iteration. If ``nothing`` (default), defaults to ordinary (forward) iterations. Otherwise, find eigenvalues close to ``sigma`` using shift and invert iterations.
-    * ``ritzvec``: Returns the Ritz vectors ``v`` (eigenvectors) if ``true``
-    * ``v0``: starting vector from which to start the iterations
+   ``eigs`` returns the ``nev`` requested eigenvalues in ``d``\ , the corresponding Ritz vectors ``v`` (only if ``ritzvec=true``\ ), the number of converged eigenvalues ``nconv``\ , the number of iterations ``niter`` and the number of matrix vector multiplications ``nmult``\ , as well as the final residual vector ``resid``\ .
 
-   ``eigs`` returns the ``nev`` requested eigenvalues in ``d``, the corresponding Ritz vectors ``v`` (only if ``ritzvec=true``), the number of converged eigenvalues ``nconv``, the number of iterations ``niter`` and the number of matrix vector multiplications ``nmult``, as well as the final residual vector ``resid``.
+   **note**
 
-   .. note:: The ``sigma`` and ``which`` keywords interact: the description of eigenvalues searched for by ``which`` do _not_ necessarily refer to the eigenvalues of ``A``, but rather the linear operator constructed by the specification of the iteration mode implied by ``sigma``.
+   The ``sigma`` and ``which`` keywords interact: the description of eigenvalues searched for by ``which`` do _not_ necessarily refer to the eigenvalue problem :math:`Av = Bv\lambda`\ , but rather the linear operator constructed by the specification of the iteration mode implied by ``sigma``\ .
 
-      =============== ================================== ==================================
-      ``sigma``       iteration mode                     ``which`` refers to eigenvalues of
-      --------------- ---------------------------------- ----------------------------------
-      ``nothing``     ordinary (forward)                 :math:`A`
-      real or complex inverse with level shift ``sigma`` :math:`(A - \sigma I )^{-1}`
-      =============== ================================== ==================================
+   +-----------------+------------------------------------+--------------------------------------+
+   | ``sigma``       | iteration mode                     | ``which`` refers to the problem      |
+   +=================+====================================+======================================+
+   | ``nothing``     | ordinary (forward)                 | :math:`Av = Bv\lambda`               |
+   +-----------------+------------------------------------+--------------------------------------+
+   | real or complex | inverse with level shift ``sigma`` | :math:`(A - \sigma B )^{-1}B = v\nu` |
+   +-----------------+------------------------------------+--------------------------------------+
 
-.. function:: svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000) -> (left_sv, s, right_sv, nconv, niter, nmult, resid)
+.. function:: svds(A; nsv=6, ritzvec=true, tol=0.0, maxiter=1000) -> ([left_sv,] s, [right_sv,] nconv, niter, nmult, resid)
 
    .. Docstring generated from Julia source
 
-   ``svds`` computes largest singular values ``s`` of ``A`` using Lanczos or Arnoldi iterations.
-   Uses :func:`eigs` underneath.
+   Computes the largest singular values ``s`` of ``A`` using implicitly restarted Lanczos iterations derived from :func:`eigs`\ .
 
-   Inputs are:
-    * ``A``: Linear operator. It can either subtype of ``AbstractArray`` (e.g., sparse matrix) or duck typed. For duck typing ``A`` has to support ``size(A)``, ``eltype(A)``, ``A * vector`` and ``A' * vector``.
-    * ``nsv``: Number of singular values.
-    * ``ritzvec``: Whether to return the left and right singular vectors ``left_sv`` and ``right_sv``, default is ``true``. If ``false`` the singular vectors are omitted from the output.
-    * ``tol``: tolerance, see :func:`eigs`.
-    * ``maxiter``: Maximum number of iterations, see :func:`eigs`.
+   **Inputs**
 
-   **Example**::
+   * ``A``\ : Linear operator whose singular values are desired. ``A`` may be represented   as a subtype of ``AbstractArray``\ , e.g., a sparse matrix, or any other type   supporting the four methods ``size(A)``\ , ``eltype(A)``\ , ``A * vector``\ , and   ``A' * vector``\ .
+   * ``nsv``\ : Number of singular values.
+   * ``ritzvec``\ : If ``true``\ , return the left and right singular vectors ``left_sv`` and ``right_sv``\ .    If ``false``\ , omit the singular vectors. Default: ``true``\ .
+   * ``tol``\ : tolerance, see :func:`eigs`\ .
+   * ``maxiter``\ : Maximum number of iterations, see :func:`eigs`\ .
 
-      X = sprand(10, 5, 0.2)
-      svds(X, nsv = 2)
+   **Outputs**
+
+   * ``left_sv``\ : Left singular vectors (only if ``ritzvec = true``\ ).
+   * ``s``\ : A vector of length ``nsv`` containing the requested singular values.
+   * ``right_sv``\ : Right singular vectors (only if ``ritzvec = true``\ ).
+   * ``nconv``\ : Number of converged singular values.
+   * ``niter``\ : Number of iterations.
+   * ``nmult``\ : Number of matrix–vector products used.
+   * ``resid``\ : Final residual vector.
+
+   **Example**
+
+   .. code-block:: julia
+
+       X = sprand(10, 5, 0.2)
+       svds(X, nsv = 2)
+
+   **Implementation note**
+
+   ``svds(A)`` is formally equivalent to calling ``eigs`` to perform implicitly restarted Lanczos tridiagonalization on the Hermitian matrix :math:`\begin{pmatrix} 0 & A^\prime \\ A & 0 \end{pmatrix}`\ , whose eigenvalues are plus and minus the singular values of :math:`A`\ .
 
 .. function:: peakflops(n; parallel=false)
 
    .. Docstring generated from Julia source
 
-   ``peakflops`` computes the peak flop rate of the computer by using double precision :func:`Base.LinAlg.BLAS.gemm!`. By default, if no arguments are specified, it multiplies a matrix of size ``n x n``, where ``n = 2000``. If the underlying BLAS is using multiple threads, higher flop rates are realized. The number of BLAS threads can be set with ``blas_set_num_threads(n)``.
+   ``peakflops`` computes the peak flop rate of the computer by using double precision :func:`Base.LinAlg.BLAS.gemm!`\ . By default, if no arguments are specified, it multiplies a matrix of size ``n x n``\ , where ``n = 2000``\ . If the underlying BLAS is using multiple threads, higher flop rates are realized. The number of BLAS threads can be set with ``blas_set_num_threads(n)``\ .
 
-   If the keyword argument ``parallel`` is set to ``true``, ``peakflops`` is run in parallel on all the worker processors. The flop rate of the entire parallel computer is returned. When running in parallel, only 1 BLAS thread is used. The argument ``n`` still refers to the size of the problem that is solved on each processor.
+   If the keyword argument ``parallel`` is set to ``true``\ , ``peakflops`` is run in parallel on all the worker processors. The flop rate of the entire parallel computer is returned. When running in parallel, only 1 BLAS thread is used. The argument ``n`` still refers to the size of the problem that is solved on each processor.
 
 BLAS Functions
 --------------
@@ -1020,7 +1349,7 @@ Usually a function has 4 methods defined, one each for ``Float64``,
 
    .. Docstring generated from Julia source
 
-   sum of the absolute values of the first ``n`` elements of array ``X`` with stride ``incx``\ .
+   Sum of the absolute values of the first ``n`` elements of array ``X`` with stride ``incx``\ .
 
 .. function:: axpy!(a, X, Y)
 
@@ -1249,3 +1578,630 @@ Usually a function has 4 methods defined, one each for ``Float64``,
 .. data:: I
 
    An object of type ``UniformScaling``, representing an identity matrix of any size.
+
+LAPACK Functions
+----------------
+
+.. module:: Base.LinAlg.LAPACK
+
+:mod:`Base.LinAlg.LAPACK` provides wrappers for some of the LAPACK functions for
+linear algebra.  Those functions that overwrite one of the input
+arrays have names ending in ``'!'``.
+
+Usually a function has 4 methods defined, one each for ``Float64``,
+``Float32``, ``Complex128`` and ``Complex64`` arrays.
+
+Note that the LAPACK API provided by Julia can and will change in the future. Since
+this API is not user-facing, there is no commitment to support/deprecate this specific
+set of functions in future releases.
+
+.. currentmodule:: Base.LinAlg.LAPACK
+
+.. function:: gbtrf!(kl, ku, m, AB) -> (AB, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Compute the LU factorization of a banded matrix ``AB``\ . ``kl`` is the first subdiagonal containing a nonzero band, ``ku`` is the last superdiagonal containing one, and ``m`` is the first dimension of the matrix ``AB``\ . Returns the LU factorization in-place and ``ipiv``\ , the vector of pivots used.
+
+.. function:: gbtrs!(trans, kl, ku, m, AB, ipiv, B)
+
+   .. Docstring generated from Julia source
+
+   Solve the equation ``AB * X = B``\ . ``trans`` determines the orientation of ``AB``\ . It may be ``N`` (no transpose), ``T`` (transpose), or ``C`` (conjugate transpose). ``kl`` is the first subdiagonal containing a nonzero band, ``ku`` is the last superdiagonal containing one, and ``m`` is the first dimension of the matrix ``AB``\ . ``ipiv`` is the vector of pivots returned from ``gbtrf!``\ . Returns the vector or matrix ``X``\ , overwriting ``B`` in-place.
+
+.. function:: gebal!(job, A) -> (ilo, ihi, scale)
+
+   .. Docstring generated from Julia source
+
+   Balance the matrix ``A`` before computing its eigensystem or Schur factorization. ``job`` can be one of ``N`` (``A`` will not be permuted or scaled), ``P`` (``A`` will only be permuted), ``S`` (``A`` will only be scaled), or ``B`` (``A`` will be both permuted and scaled). Modifies ``A`` in-place and returns ``ilo``\ , ``ihi``\ , and ``scale``\ . If permuting was turned on, ``A[i,j] = 0`` if ``j > i`` and ``1 < j < ilo`` or ``j > ihi``\ . ``scale`` contains information about the scaling/permutations performed.
+
+.. function:: gebak!(job, side, ilo, ihi, scale, V)
+
+   .. Docstring generated from Julia source
+
+   Transform the eigenvectors ``V`` of a matrix balanced using ``gebal!`` to the unscaled/unpermuted eigenvectors of the original matrix. Modifies ``V`` in-place. ``side`` can be ``L`` (left eigenvectors are transformed) or ``R`` (right eigenvectors are transformed).
+
+.. function:: gebrd!(A) -> (A, d, e, tauq, taup)
+
+   .. Docstring generated from Julia source
+
+   Reduce ``A`` in-place to bidiagonal form ``A = QBP'``\ . Returns ``A``\ , containing the bidiagonal matrix ``B``\ ; ``d``\ , containing the diagonal elements of ``B``\ ; ``e``\ , containing the off-diagonal elements of ``B``\ ; ``tauq``\ , containing the elementary reflectors representing ``Q``\ ; and ``taup``\ , containing the elementary reflectors representing ``P``\ .
+
+.. function:: gelqf!(A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``LQ`` factorization of ``A``\ , ``A = LQ``\ . ``tau`` contains scalars which parameterize the elementary reflectors of the factorization. ``tau`` must have length greater than or equal to the smallest dimension of ``A``\ .
+
+   Returns ``A`` and ``tau`` modified in-place.
+
+.. function:: gelqf!(A) -> (A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``LQ`` factorization of ``A``\ , ``A = LQ``\ .
+
+   Returns ``A``\ , modified in-place, and ``tau``\ , which contains scalars which parameterize the elementary reflectors of the factorization.
+
+.. function:: geqlf!(A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``QL`` factorization of ``A``\ , ``A = QL``\ . ``tau`` contains scalars which parameterize the elementary reflectors of the factorization. ``tau`` must have length greater than or equal to the smallest dimension of ``A``\ .
+
+   Returns ``A`` and ``tau`` modified in-place.
+
+.. function:: geqlf!(A) -> (A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``QL`` factorization of ``A``\ , ``A = QL``\ .
+
+   Returns ``A``\ , modified in-place, and ``tau``\ , which contains scalars which parameterize the elementary reflectors of the factorization.
+
+.. function:: geqrf!(A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``QR`` factorization of ``A``\ , ``A = QR``\ . ``tau`` contains scalars which parameterize the elementary reflectors of the factorization. ``tau`` must have length greater than or equal to the smallest dimension of ``A``\ .
+
+   Returns ``A`` and ``tau`` modified in-place.
+
+.. function:: geqrf!(A) -> (A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``QR`` factorization of ``A``\ , ``A = QR``\ .
+
+   Returns ``A``\ , modified in-place, and ``tau``\ , which contains scalars which parameterize the elementary reflectors of the factorization.
+
+.. function:: geqp3!(A, jpvt, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the pivoted ``QR`` factorization of ``A``\ , ``AP = QR`` using BLAS level 3. ``P`` is a pivoting matrix, represented by ``jpvt``\ . ``tau`` stores the elementary reflectors. ``jpvt`` must have length length greater than or equal to ``n`` if ``A`` is an ``(m x n)`` matrix. ``tau`` must have length greater than or equal to the smallest dimension of ``A``\ .
+
+   ``A``\ , ``jpvt``\ , and ``tau`` are modified in-place.
+
+.. function:: geqp3!(A, jpvt) -> (A, jpvt, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the pivoted ``QR`` factorization of ``A``\ , ``AP = QR`` using BLAS level 3. ``P`` is a pivoting matrix, represented by ``jpvt``\ . ``jpvt`` must have length greater than or equal to ``n`` if ``A`` is an ``(m x n)`` matrix.
+
+   Returns ``A`` and ``jpvt``\ , modified in-place, and ``tau``\ , which stores the elementary reflectors.
+
+.. function:: geqp3!(A) -> (A, jpvt, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the pivoted ``QR`` factorization of ``A``\ , ``AP = QR`` using BLAS level 3.
+
+   Returns ``A``\ , modified in-place, ``jpvt``\ , which represents the pivoting matrix ``P``\ , and ``tau``\ , which stores the elementary reflectors.
+
+.. function:: gerqf!(A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``RQ`` factorization of ``A``\ , ``A = RQ``\ . ``tau`` contains scalars which parameterize the elementary reflectors of the factorization. ``tau`` must have length greater than or equal to the smallest dimension of ``A``\ .
+
+   Returns ``A`` and ``tau`` modified in-place.
+
+.. function:: gerqf!(A) -> (A, tau)
+
+   .. Docstring generated from Julia source
+
+   Compute the ``RQ`` factorization of ``A``\ , ``A = RQ``\ .
+
+   Returns ``A``\ , modified in-place, and ``tau``\ , which contains scalars which parameterize the elementary reflectors of the factorization.
+
+.. function:: geqrt!(A, T)
+
+   .. Docstring generated from Julia source
+
+   Compute the blocked ``QR`` factorization of ``A``\ , ``A = QR``\ . ``T`` contains upper triangular block reflectors which parameterize the elementary reflectors of the factorization. The first dimension of ``T`` sets the block size and it must be between 1 and ``n``\ . The second dimension of ``T`` must equal the smallest dimension of ``A``\ .
+
+   Returns ``A`` and ``T`` modified in-place.
+
+.. function:: geqrt!(A, nb) -> (A, T)
+
+   .. Docstring generated from Julia source
+
+   Compute the blocked ``QR`` factorization of ``A``\ , ``A = QR``\ . ``nb`` sets the block size and it must be between 1 and ``n``\ , the second dimension of ``A``\ .
+
+   Returns ``A``\ , modified in-place, and ``T``\ , which contains upper triangular block reflectors which parameterize the elementary reflectors of the factorization.
+
+.. function:: geqrt3!(A, T)
+
+   .. Docstring generated from Julia source
+
+   Recursively computes the blocked ``QR`` factorization of ``A``\ , ``A = QR``\ . ``T`` contains upper triangular block reflectors which parameterize the elementary reflectors of the factorization.  The first dimension of ``T`` sets the block size and it must be between 1 and ``n``\ . The second dimension of ``T`` must equal the smallest dimension of ``A``\ .
+
+   Returns ``A`` and ``T`` modified in-place.
+
+.. function:: geqrt3!(A) -> (A, T)
+
+   .. Docstring generated from Julia source
+
+   Recursively computes the blocked ``QR`` factorization of ``A``\ , ``A = QR``\ .
+
+   Returns ``A``\ , modified in-place, and ``T``\ , which contains upper triangular block reflectors which parameterize the elementary reflectors of the factorization.
+
+.. function:: getrf!(A) -> (A, ipiv, info)
+
+   .. Docstring generated from Julia source
+
+   Compute the pivoted ``LU`` factorization of ``A``\ , ``A = LU``\ .
+
+   Returns ``A``\ , modified in-place, ``ipiv``\ , the pivoting information, and an ``info`` code which indicates success (``info = 0``\ ), a singular value in ``U`` (``info = i``\ , in which case ``U[i,i]`` is singular), or an error code (``info < 0``\ ).
+
+.. function:: tzrzf!(A) -> (A, tau)
+
+   .. Docstring generated from Julia source
+
+   Transforms the upper trapezoidal matrix ``A`` to upper triangular form in-place. Returns ``A`` and ``tau``\ , the scalar parameters for the elementary reflectors of the transformation.
+
+.. function:: ormrz!(side, trans, A, tau, C)
+
+   .. Docstring generated from Julia source
+
+   Multiplies the matrix ``C`` by ``Q`` from the transformation supplied by ``tzrzf!``\ . Depending on ``side`` or ``trans`` the multiplication can be left-sided (``side = L, Q*C``\ ) or right-sided (``side = R, C*Q``\ ) and ``Q`` can be unmodified (``trans = N``\ ), transposed (``trans = T``\ ), or conjugate transposed (``trans = C``\ ). Returns matrix ``C`` which is modified in-place with the result of the multiplication.
+
+.. function:: gels!(trans, A, B) -> (F, B, ssr)
+
+   .. Docstring generated from Julia source
+
+   Solves the linear equation ``A * X = B``\ , ``A.' * X =B``\ , or ``A' * X = B`` using a QR or LQ factorization. Modifies the matrix/vector ``B`` in place with the solution. ``A`` is overwritten with its ``QR`` or ``LQ`` factorization. ``trans`` may be one of ``N`` (no modification), ``T`` (transpose), or ``C`` (conjugate transpose). ``gels!`` searches for the minimum norm/least squares solution. ``A`` may be under or over determined. The solution is returned in ``B``\ .
+
+.. function:: gesv!(A, B) -> (B, A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Solves the linear equation ``A * X = B`` where ``A`` is a square matrix using the ``LU`` factorization of ``A``\ . ``A`` is overwritten with its ``LU`` factorization and ``B`` is overwritten with the solution ``X``\ . ``ipiv`` contains the pivoting information for the ``LU`` factorization of ``A``\ .
+
+.. function:: getrs!(trans, A, ipiv, B)
+
+   .. Docstring generated from Julia source
+
+   Solves the linear equation ``A * X = B``\ , ``A.' * X =B``\ , or ``A' * X = B`` for square ``A``\ . Modifies the matrix/vector ``B`` in place with the solution. ``A`` is the ``LU`` factorization from ``getrf!``\ , with ``ipiv`` the pivoting information. ``trans`` may be one of ``N`` (no modification), ``T`` (transpose), or ``C`` (conjugate transpose).
+
+.. function:: getri!(A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Computes the inverse of ``A``\ , using its ``LU`` factorization found by ``getrf!``\ . ``ipiv`` is the pivot information output and ``A`` contains the ``LU`` factorization of ``getrf!``\ . ``A`` is overwritten with its inverse.
+
+.. function:: gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)
+
+   .. Docstring generated from Julia source
+
+   Solves the linear equation ``A * X = B`` (``trans = N``\ ), ``A.' * X =B`` (``trans = T``\ ), or ``A' * X = B`` (``trans = C``\ ) using the ``LU`` factorization of ``A``\ . ``fact`` may be ``E``\ , in which case ``A`` will be equilibrated and copied to ``AF``\ ; ``F``\ , in which case ``AF`` and ``ipiv`` from a previous ``LU`` factorization are inputs; or ``N``\ , in which case ``A`` will be copied to ``AF`` and then factored. If ``fact = F``\ , ``equed`` may be ``N``\ , meaning ``A`` has not been equilibrated; ``R``\ , meaning ``A`` was multiplied by ``diagm(R)`` from the left; ``C``\ , meaning ``A`` was multiplied by ``diagm(C)`` from the right; or ``B``\ , meaning ``A`` was multiplied by ``diagm(R)`` from the left and ``diagm(C)`` from the right. If ``fact = F`` and ``equed = R`` or ``B`` the elements of ``R`` must all be positive. If ``fact = F`` and ``equed = C`` or ``B`` the elements of ``C`` must all be positive.
+
+   Returns the solution ``X``\ ; ``equed``\ , which is an output if ``fact`` is not ``N``\ , and describes the equilibration that was performed; ``R``\ , the row equilibration diagonal; ``C``\ , the column equilibration diagonal; ``B``\ , which may be overwritten with its equilibrated form ``diagm(R)*B`` (if ``trans = N`` and ``equed = R,B``\ ) or ``diagm(C)*B`` (if ``trans = T,C`` and ``equed = C,B``\ ); ``rcond``\ , the reciprocal condition number of ``A`` after equilbrating; ``ferr``\ , the forward error bound for each solution vector in ``X``\ ; ``berr``\ , the forward error bound for each solution vector in ``X``\ ; and ``work``\ , the reciprocal pivot growth factor.
+
+.. function:: gesvx!(A, B)
+
+   .. Docstring generated from Julia source
+
+   The no-equilibration, no-transpose simplification of ``gesvx!``\ .
+
+.. function:: gelsd!(A, B, rcond) -> (B, rnk)
+
+   .. Docstring generated from Julia source
+
+   Computes the least norm solution of ``A * X = B`` by finding the ``SVD`` factorization of ``A``\ , then dividing-and-conquering the problem. ``B`` is overwritten with the solution ``X``\ . Singular values below ``rcond`` will be treated as zero. Returns the solution in ``B`` and the effective rank of ``A`` in ``rnk``\ .
+
+.. function:: gelsy!(A, B, rcond) -> (B, rnk)
+
+   .. Docstring generated from Julia source
+
+   Computes the least norm solution of ``A * X = B`` by finding the full ``QR`` factorization of ``A``\ , then dividing-and-conquering the problem. ``B`` is overwritten with the solution ``X``\ . Singular values below ``rcond`` will be treated as zero. Returns the solution in ``B`` and the effective rank of ``A`` in ``rnk``\ .
+
+.. function:: gglse!(A, c, B, d) -> (X,res)
+
+   .. Docstring generated from Julia source
+
+   Solves the equation ``A * x = c`` where ``x`` is subject to the equality constraint ``B * x = d``\ . Uses the formula ``||c - A*x||^2 = 0`` to solve. Returns ``X`` and the residual sum-of-squares.
+
+.. function:: geev!(jobvl, jobvr, A) -> (W, VL, VR)
+
+   .. Docstring generated from Julia source
+
+   Finds the eigensystem of ``A``\ . If ``jobvl = N``\ , the left eigenvectors of ``A`` aren't computed. If ``jobvr = N``\ , the right eigenvectors of ``A`` aren't computed. If ``jobvl = V`` or ``jobvr = V``\ , the corresponding eigenvectors are computed. Returns the eigenvalues in ``W``\ , the right eigenvectors in ``VR``\ , and the left eigenvectors in ``VL``\ .
+
+.. function:: gesdd!(job, A) -> (U, S, VT)
+
+   .. Docstring generated from Julia source
+
+   Finds the singular value decomposition of ``A``\ , ``A = U * S * V'``\ , using a divide and conquer approach. If ``job = A``\ , all the columns of ``U`` and the rows of ``V'`` are computed. If ``job = N``\ , no columns of ``U`` or rows of ``V'`` are computed. If ``job = O``\ , ``A`` is overwritten with the columns of (thin) ``U`` and the rows of (thin) ``V'``\ . If ``job = S``\ , the columns of (thin) ``U`` and the rows of (thin) ``V'`` are computed and returned separately.
+
+.. function:: gesvd!(jobu, jobvt, A) -> (U, S, VT)
+
+   .. Docstring generated from Julia source
+
+   Finds the singular value decomposition of ``A``\ , ``A = U * S * V'``\ . If ``jobu = A``\ , all the columns of ``U`` are computed. If ``jobvt = A`` all the rows of ``V'`` are computed. If ``jobu = N``\ , no columns of ``U`` are computed. If ``jobvt = N`` no rows of ``V'`` are computed. If ``jobu = O``\ , ``A`` is overwritten with the columns of (thin) ``U``\ . If ``jobvt = O``\ , ``A`` is overwritten with the rows of (thin) ``V'``\ . If ``jobu = S``\ , the columns of (thin) ``U`` are computed and returned separately. If ``jobvt = S`` the rows of (thin) ``V'`` are computed and returned separately. ``jobu`` and ``jobvt`` can't both be ``O``\ .
+
+   Returns ``U``\ , ``S``\ , and ``Vt``\ , where ``S`` are the singular values of ``A``\ .
+
+.. function:: ggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)
+
+   .. Docstring generated from Julia source
+
+   Finds the generalized singular value decomposition of ``A`` and ``B``\ , ``U'*A*Q = D1*R`` and ``V'*B*Q = D2*R``\ . ``D1`` has ``alpha`` on its diagonal and ``D2`` has ``beta`` on its diagonal. If ``jobu = U``\ , the orthogonal/unitary matrix ``U`` is computed. If ``jobv = V`` the orthogonal/unitary matrix ``V`` is computed. If ``jobq = Q``\ , the orthogonal/unitary matrix ``Q`` is computed. If ``jobu``\ , ``jobv`` or ``jobq`` is ``N``\ , that matrix is not computed. This function is only available in LAPACK versions prior to 3.6.0.
+
+.. function:: ggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)
+
+   .. Docstring generated from Julia source
+
+   Finds the generalized singular value decomposition of ``A`` and ``B``\ , ``U'*A*Q = D1*R`` and ``V'*B*Q = D2*R``\ . ``D1`` has ``alpha`` on its diagonal and ``D2`` has ``beta`` on its diagonal. If ``jobu = U``\ , the orthogonal/unitary matrix ``U`` is computed. If ``jobv = V`` the orthogonal/unitary matrix ``V`` is computed. If ``jobq = Q``\ , the orthogonal/unitary matrix ``Q`` is computed. If ``jobu``\ , ``jobv``\ , or ``jobq`` is ``N``\ , that matrix is not computed. This function requires LAPACK 3.6.0.
+
+.. function:: geevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)
+
+   .. Docstring generated from Julia source
+
+   Finds the eigensystem of ``A`` with matrix balancing. If ``jobvl = N``\ , the left eigenvectors of ``A`` aren't computed. If ``jobvr = N``\ , the right eigenvectors of ``A`` aren't computed. If ``jobvl = V`` or ``jobvr = V``\ , the corresponding eigenvectors are computed. If ``balanc = N``\ , no balancing is performed. If ``balanc = P``\ , ``A`` is permuted but not scaled. If ``balanc = S``\ , ``A`` is scaled but not permuted. If ``balanc = B``\ , ``A`` is permuted and scaled. If ``sense = N``\ , no reciprocal condition numbers are computed. If ``sense = E``\ , reciprocal condition numbers are computed for the eigenvalues only. If ``sense = V``\ , reciprocal condition numbers are computed for the right eigenvectors only. If ``sense = B``\ , reciprocal condition numbers are computed for the right eigenvectors and the eigenvectors. If ``sense = E,B``\ , the right and left eigenvectors must be computed.
+
+.. function:: ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)
+
+   .. Docstring generated from Julia source
+
+   Finds the generalized eigendecomposition of ``A`` and ``B``\ . If ``jobvl = N``\ , the left eigenvectors aren't computed. If ``jobvr = N``\ , the right eigenvectors aren't computed. If ``jobvl = V`` or ``jobvr = V``\ , the corresponding eigenvectors are computed.
+
+.. function:: gtsv!(dl, d, du, B)
+
+   .. Docstring generated from Julia source
+
+   Solves the equation ``A * X = B`` where ``A`` is a tridiagonal matrix with ``dl`` on the subdiagonal, ``d`` on the diagonal, and ``du`` on the superdiagonal.
+
+   Overwrites ``B`` with the solution ``X`` and returns it.
+
+.. function:: gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Finds the ``LU`` factorization of a tridiagonal matrix with ``dl`` on the subdiagonal, ``d`` on the diagonal, and ``du`` on the superdiagonal.
+
+   Modifies ``dl``\ , ``d``\ , and ``du`` in-place and returns them and the second superdiagonal ``du2`` and the pivoting vector ``ipiv``\ .
+
+.. function:: gttrs!(trans, dl, d, du, du2, ipiv, B)
+
+   .. Docstring generated from Julia source
+
+   Solves the equation ``A * X = B`` (``trans = N``\ ), ``A.' * X = B`` (``trans = T``\ ), or ``A' * X = B`` (``trans = C``\ ) using the ``LU`` factorization computed by ``gttrf!``\ . ``B`` is overwritten with the solution ``X``\ .
+
+.. function:: orglq!(A, tau, k = length(tau))
+
+   .. Docstring generated from Julia source
+
+   Explicitly finds the matrix ``Q`` of a ``LQ`` factorization after calling ``gelqf!`` on ``A``\ . Uses the output of ``gelqf!``\ . ``A`` is overwritten by ``Q``\ .
+
+.. function:: orgqr!(A, tau, k = length(tau))
+
+   .. Docstring generated from Julia source
+
+   Explicitly finds the matrix ``Q`` of a ``QR`` factorization after calling ``geqrf!`` on ``A``\ . Uses the output of ``geqrf!``\ . ``A`` is overwritten by ``Q``\ .
+
+.. function:: orgql!(A, tau, k = length(tau))
+
+   .. Docstring generated from Julia source
+
+   Explicitly finds the matrix ``Q`` of a ``QL`` factorization after calling ``geqlf!`` on ``A``\ . Uses the output of ``geqlf!``\ . ``A`` is overwritten by ``Q``\ .
+
+.. function:: orgrq!(A, tau, k = length(tau))
+
+   .. Docstring generated from Julia source
+
+   Explicitly finds the matrix ``Q`` of a ``RQ`` factorization after calling ``gerqf!`` on ``A``\ . Uses the output of ``gerqf!``\ . ``A`` is overwritten by ``Q``\ .
+
+.. function:: ormlq!(side, trans, A, tau, C)
+
+   .. Docstring generated from Julia source
+
+   Computes ``Q * C`` (``trans = N``\ ), ``Q.' * C`` (``trans = T``\ ), ``Q' * C`` (``trans = C``\ ) for ``side = L`` or the equivalent right-sided multiplication for ``side = R`` using ``Q`` from a ``LQ`` factorization of ``A`` computed using ``gelqf!``\ . ``C`` is overwritten.
+
+.. function:: ormqr!(side, trans, A, tau, C)
+
+   .. Docstring generated from Julia source
+
+   Computes ``Q * C`` (``trans = N``\ ), ``Q.' * C`` (``trans = T``\ ), ``Q' * C`` (``trans = C``\ ) for ``side = L`` or the equivalent right-sided multiplication for ``side = R`` using ``Q`` from a ``QR`` factorization of ``A`` computed using ``geqrf!``\ . ``C`` is overwritten.
+
+.. function:: ormql!(side, trans, A, tau, C)
+
+   .. Docstring generated from Julia source
+
+   Computes ``Q * C`` (``trans = N``\ ), ``Q.' * C`` (``trans = T``\ ), ``Q' * C`` (``trans = C``\ ) for ``side = L`` or the equivalent right-sided multiplication for ``side = R`` using ``Q`` from a ``QL`` factorization of ``A`` computed using ``geqlf!``\ . ``C`` is overwritten.
+
+.. function:: ormrq!(side, trans, A, tau, C)
+
+   .. Docstring generated from Julia source
+
+   Computes ``Q * C`` (``trans = N``\ ), ``Q.' * C`` (``trans = T``\ ), ``Q' * C`` (``trans = C``\ ) for ``side = L`` or the equivalent right-sided multiplication for ``side = R`` using ``Q`` from a ``RQ`` factorization of ``A`` computed using ``gerqf!``\ . ``C`` is overwritten.
+
+.. function:: gemqrt!(side, trans, V, T, C)
+
+   .. Docstring generated from Julia source
+
+   Computes ``Q * C`` (``trans = N``\ ), ``Q.' * C`` (``trans = T``\ ), ``Q' * C`` (``trans = C``\ ) for ``side = L`` or the equivalent right-sided multiplication for ``side = R`` using ``Q`` from a ``QR`` factorization of ``A`` computed using ``geqrt!``\ . ``C`` is overwritten.
+
+.. function:: posv!(uplo, A, B) -> (A, B)
+
+   .. Docstring generated from Julia source
+
+   Finds the solution to ``A * X = B`` where ``A`` is a symmetric or Hermitian positive definite matrix. If ``uplo = U`` the upper Cholesky decomposition of ``A`` is computed. If ``uplo = L`` the lower Cholesky decomposition of ``A`` is computed. ``A`` is overwritten by its Cholesky decomposition. ``B`` is overwritten with the solution ``X``\ .
+
+.. function:: potrf!(uplo, A)
+
+   .. Docstring generated from Julia source
+
+   Computes the Cholesky (upper if ``uplo = U``\ , lower if ``uplo = L``\ ) decomposition of positive-definite matrix ``A``\ . ``A`` is overwritten and returned with an info code.
+
+.. function:: potri!(uplo, A)
+
+   .. Docstring generated from Julia source
+
+   Computes the inverse of positive-definite matrix ``A`` after calling ``potrf!`` to find its (upper if ``uplo = U``\ , lower if ``uplo = L``\ ) Cholesky decomposition.
+
+   ``A`` is overwritten by its inverse and returned.
+
+.. function:: potrs!(uplo, A, B)
+
+   .. Docstring generated from Julia source
+
+   Finds the solution to ``A * X = B`` where ``A`` is a symmetric or Hermitian positive definite matrix whose Cholesky decomposition was computed by ``potrf!``\ . If ``uplo = U`` the upper Cholesky decomposition of ``A`` was computed. If ``uplo = L`` the lower Cholesky decomposition of ``A`` was computed. ``B`` is overwritten with the solution ``X``\ .
+
+.. function:: pstrf!(uplo, A, tol) -> (A, piv, rank, info)
+
+   .. Docstring generated from Julia source
+
+   Computes the (upper if ``uplo = U``\ , lower if ``uplo = L``\ ) pivoted Cholesky decomposition of positive-definite matrix ``A`` with a user-set tolerance ``tol``\ . ``A`` is overwritten by its Cholesky decomposition.
+
+   Returns ``A``\ , the pivots ``piv``\ , the rank of ``A``\ , and an ``info`` code. If ``info = 0``\ , the factorization succeeded. If ``info = i > 0 `, then `A`` is indefinite or rank-deficient.
+
+.. function:: ptsv!(D, E, B)
+
+   .. Docstring generated from Julia source
+
+   Solves ``A * X = B`` for positive-definite tridiagonal ``A``\ . ``D`` is the diagonal of ``A`` and ``E`` is the off-diagonal. ``B`` is overwritten with the solution ``X`` and returned.
+
+.. function:: pttrf!(D, E)
+
+   .. Docstring generated from Julia source
+
+   Computes the LDLt factorization of a positive-definite tridiagonal matrix with ``D`` as diagonal and ``E`` as off-diagonal. ``D`` and ``E`` are overwritten and returned.
+
+.. function:: pttrs!(D, E, B)
+
+   .. Docstring generated from Julia source
+
+   Solves ``A * X = B`` for positive-definite tridiagonal ``A`` with diagonal ``D`` and off-diagonal ``E`` after computing ``A``\ 's LDLt factorization using ``pttrf!``\ . ``B`` is overwritten with the solution ``X``\ .
+
+.. function:: trtri!(uplo, diag, A)
+
+   .. Docstring generated from Julia source
+
+   Finds the inverse of (upper if ``uplo = U``\ , lower if ``uplo = L``\ ) triangular matrix ``A``\ . If ``diag = N``\ , ``A`` has non-unit diagonal elements. If ``diag = U``\ , all diagonal elements of ``A`` are one. ``A`` is overwritten with its inverse.
+
+.. function:: trtrs!(uplo, trans, diag, A, B)
+
+   .. Docstring generated from Julia source
+
+   Solves ``A * X = B`` (``trans = N``\ ), ``A.' * X = B`` (``trans = T``\ ), or ``A' * X = B`` (``trans = C``\ ) for (upper if ``uplo = U``\ , lower if ``uplo = L``\ ) triangular matrix ``A``\ . If ``diag = N``\ , ``A`` has non-unit diagonal elements. If ``diag = U``\ , all diagonal elements of ``A`` are one. ``B`` is overwritten with the solution ``X``\ .
+
+.. function:: trcon!(norm, uplo, diag, A)
+
+   .. Docstring generated from Julia source
+
+   Finds the reciprocal condition number of (upper if ``uplo = U``\ , lower if ``uplo = L``\ ) triangular matrix ``A``\ . If ``diag = N``\ , ``A`` has non-unit diagonal elements. If ``diag = U``\ , all diagonal elements of ``A`` are one. If ``norm = I``\ , the condition number is found in the infinity norm. If ``norm = O`` or ``1``\ , the condition number is found in the one norm.
+
+.. function:: trevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))
+
+   .. Docstring generated from Julia source
+
+   Finds the eigensystem of an upper triangular matrix ``T``\ . If ``side = R``\ , the right eigenvectors are computed. If ``side = L``\ , the left eigenvectors are computed. If ``side = B``\ , both sets are computed. If ``howmny = A``\ , all eigenvectors are found. If ``howmny = B``\ , all eigenvectors are found and backtransformed using ``VL`` and ``VR``\ . If ``howmny = S``\ , only the eigenvectors corresponding to the values in ``select`` are computed.
+
+.. function:: trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)
+
+   .. Docstring generated from Julia source
+
+   Estimates the error in the solution to ``A * X = B`` (``trans = N``\ ), ``A.' * X = B`` (``trans = T``\ ), ``A' * X = B`` (``trans = C``\ ) for ``side = L``\ , or the equivalent equations a right-handed ``side = R`` ``X * A`` after computing ``X`` using ``trtrs!``\ . If ``uplo = U``\ , ``A`` is upper triangular. If ``uplo = L``\ , ``A`` is lower triangular. If ``diag = N``\ , ``A`` has non-unit diagonal elements. If ``diag = U``\ , all diagonal elements of ``A`` are one. ``Ferr`` and ``Berr`` are optional inputs. ``Ferr`` is the forward error and ``Berr`` is the backward error, each component-wise.
+
+.. function:: stev!(job, dv, ev) -> (dv, Zmat)
+
+   .. Docstring generated from Julia source
+
+   Computes the eigensystem for a symmetric tridiagonal matrix with ``dv`` as diagonal and ``ev`` as off-diagonal. If ``job = N`` only the eigenvalues are found and returned in ``dv``\ . If ``job = V`` then the eigenvectors are also found and returned in ``Zmat``\ .
+
+.. function:: stebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)
+
+   .. Docstring generated from Julia source
+
+   Computes the eigenvalues for a symmetric tridiagonal matrix with ``dv`` as diagonal and ``ev`` as off-diagonal. If ``range = A``\ , all the eigenvalues are found. If ``range = V``\ , the eigenvalues in the half-open interval ``(vl, vu]`` are found. If ``range = I``\ , the eigenvalues with indices between ``il`` and ``iu`` are found. If ``order = B``\ , eigvalues are ordered within a block. If ``order = E``\ , they are ordered across all the blocks. ``abstol`` can be set as a tolerance for convergence.
+
+.. function:: stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)
+
+   .. Docstring generated from Julia source
+
+   Computes the eigenvalues (``jobz = N``\ ) or eigenvalues and eigenvectors (``jobz = V``\ ) for a symmetric tridiagonal matrix with ``dv`` as diagonal and ``ev`` as off-diagonal. If ``range = A``\ , all the eigenvalues are found. If ``range = V``\ , the eigenvalues in the half-open interval ``(vl, vu]`` are found. If ``range = I``\ , the eigenvalues with indices between ``il`` and ``iu`` are found. The eigenvalues are returned in ``w`` and the eigenvectors in ``Z``\ .
+
+.. function:: stein!(dv, ev_in, w_in, iblock_in, isplit_in)
+
+   .. Docstring generated from Julia source
+
+   Computes the eigenvectors for a symmetric tridiagonal matrix with ``dv`` as diagonal and ``ev_in`` as off-diagonal. ``w_in`` specifies the input eigenvalues for which to find corresponding eigenvectors. ``iblock_in`` specifies the submatrices corresponding to the eigenvalues in ``w_in``\ . ``isplit_in`` specifies the splitting points between the submatrix blocks.
+
+.. function:: syconv!(uplo, A, ipiv) -> (A, work)
+
+   .. Docstring generated from Julia source
+
+   Converts a symmetric matrix ``A`` (which has been factorized into a triangular matrix) into two matrices ``L`` and ``D``\ . If ``uplo = U``\ , ``A`` is upper triangular. If ``uplo = L``\ , it is lower triangular. ``ipiv`` is the pivot vector from the triangular factorization. ``A`` is overwritten by ``L`` and ``D``\ .
+
+.. function:: sysv!(uplo, A, B) -> (B, A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Finds the solution to ``A * X = B`` for symmetric matrix ``A``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored. ``B`` is overwritten by the solution ``X``\ . ``A`` is overwritten by its Bunch-Kaufman factorization. ``ipiv`` contains pivoting information about the factorization.
+
+.. function:: sytrf!(uplo, A) -> (A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Computes the Bunch-Kaufman factorization of a symmetric matrix ``A``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored.
+
+   Returns ``A``\ , overwritten by the factorization, and a pivot vector ``ipiv``\ .
+
+.. function:: sytri!(uplo, A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Computes the inverse of a symmetric matrix ``A`` using the results of ``sytrf!``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored. ``A`` is overwritten by its inverse.
+
+.. function:: sytrs!(uplo, A, ipiv, B)
+
+   .. Docstring generated from Julia source
+
+   Solves the equation ``A * X = B`` for a symmetric matrix ``A`` using the results of ``sytrf!``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored. ``B`` is overwritten by the solution ``X``\ .
+
+.. function:: hesv!(uplo, A, B) -> (B, A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Finds the solution to ``A * X = B`` for Hermitian matrix ``A``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored. ``B`` is overwritten by the solution ``X``\ . ``A`` is overwritten by its Bunch-Kaufman factorization. ``ipiv`` contains pivoting information about the factorization.
+
+.. function:: hetrf!(uplo, A) -> (A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Computes the Bunch-Kaufman factorization of a Hermitian matrix ``A``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored.
+
+   Returns ``A``\ , overwritten by the factorization, and a pivot vector.
+
+.. function:: hetri!(uplo, A, ipiv)
+
+   .. Docstring generated from Julia source
+
+   Computes the inverse of a Hermitian matrix ``A`` using the results of ``sytrf!``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored. ``A`` is overwritten by its inverse.
+
+.. function:: hetrs!(uplo, A, ipiv, B)
+
+   .. Docstring generated from Julia source
+
+   Solves the equation ``A * X = B`` for a Hermitian matrix ``A`` using the results of ``sytrf!``\ . If ``uplo = U``\ , the upper half of ``A`` is stored. If ``uplo = L``\ , the lower half is stored. ``B`` is overwritten by the solution ``X``\ .
+
+.. function:: syev!(jobz, uplo, A)
+
+   .. Docstring generated from Julia source
+
+   Finds the eigenvalues (``jobz = N``\ ) or eigenvalues and eigenvectors (``jobz = V``\ ) of a symmetric matrix ``A``\ . If ``uplo = U``\ , the upper triangle of ``A`` is used. If ``uplo = L``\ , the lower triangle of ``A`` is used.
+
+.. function:: syevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)
+
+   .. Docstring generated from Julia source
+
+   Finds the eigenvalues (``jobz = N``\ ) or eigenvalues and eigenvectors (``jobz = V``\ ) of a symmetric matrix ``A``\ . If ``uplo = U``\ , the upper triangle of ``A`` is used. If ``uplo = L``\ , the lower triangle of ``A`` is used. If ``range = A``\ , all the eigenvalues are found. If ``range = V``\ , the eigenvalues in the half-open interval ``(vl, vu]`` are found. If ``range = I``\ , the eigenvalues with indices between ``il`` and ``iu`` are found. ``abstol`` can be set as a tolerance for convergence.
+
+   The eigenvalues are returned in ``W`` and the eigenvectors in ``Z``\ .
+
+.. function:: sygvd!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (w, A, B)
+
+   .. Docstring generated from Julia source
+
+   Finds the generalized eigenvalues (``jobz = N``\ ) or eigenvalues and eigenvectors (``jobz = V``\ ) of a symmetric matrix ``A`` and symmetric positive-definite matrix ``B``\ . If ``uplo = U``\ , the upper triangles of ``A`` and ``B`` are used. If ``uplo = L``\ , the lower triangles of ``A`` and ``B`` are used. If ``itype = 1``\ , the problem to solve is ``A * x = lambda * B * x``\ . If ``itype = 2``\ , the problem to solve is ``A * B * x = lambda * x``\ . If ``itype = 3``\ , the problem to solve is ``B * A * x = lambda * x``\ .
+
+.. function:: bdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)
+
+   .. Docstring generated from Julia source
+
+   Computes the singular value decomposition of a bidiagonal matrix with ``d`` on the diagonal and ``e_`` on the off-diagonal. If ``uplo = U``\ , ``e_`` is the superdiagonal. If ``uplo = L``\ , ``e_`` is the subdiagonal. Can optionally also compute the product ``Q' * C``\ .
+
+   Returns the singular values in ``d``\ , and the matrix ``C`` overwritten with ``Q' * C``\ .
+
+.. function:: bdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)
+
+   .. Docstring generated from Julia source
+
+   Computes the singular value decomposition of a bidiagonal matrix with ``d`` on the diagonal and ``e_`` on the off-diagonal using a divide and conqueq method. If ``uplo = U``\ , ``e_`` is the superdiagonal. If ``uplo = L``\ , ``e_`` is the subdiagonal. If ``compq = N``\ , only the singular values are found. If ``compq = I``\ , the singular values and vectors are found. If ``compq = P``\ , the singular values and vectors are found in compact form. Only works for real types.
+
+   Returns the singular values in ``d``\ , and if ``compq = P``\ , the compact singular vectors in ``iq``\ .
+
+.. function:: gecon!(normtype, A, anorm)
+
+   .. Docstring generated from Julia source
+
+   Finds the reciprocal condition number of matrix ``A``\ . If ``normtype = I``\ , the condition number is found in the infinity norm. If ``normtype = O`` or ``1``\ , the condition number is found in the one norm. ``A`` must be the result of ``getrf!`` and ``anorm`` is the norm of ``A`` in the relevant norm.
+
+.. function:: gehrd!(ilo, ihi, A) -> (A, tau)
+
+   .. Docstring generated from Julia source
+
+   Converts a matrix ``A`` to Hessenberg form. If ``A`` is balanced with ``gebal!`` then ``ilo`` and ``ihi`` are the outputs of ``gebal!``\ . Otherwise they should be ``ilo = 1`` and ``ihi = size(A,2)``\ . ``tau`` contains the elementary reflectors of the factorization.
+
+.. function:: orghr!(ilo, ihi, A, tau)
+
+   .. Docstring generated from Julia source
+
+   Explicitly finds ``Q``\ , the orthogonal/unitary matrix from ``gehrd!``\ . ``ilo``\ , ``ihi``\ , ``A``\ , and ``tau`` must correspond to the input/output to ``gehrd!``\ .
+
+.. function:: gees!(jobvs, A) -> (A, vs, w)
+
+   .. Docstring generated from Julia source
+
+   Computes the eigenvalues (``jobvs = N``\ ) or the eigenvalues and Schur vectors (``jobvs = V``\ ) of matrix ``A``\ . ``A`` is overwritten by its Schur form.
+
+   Returns ``A``\ , ``vs`` containing the Schur vectors, and ``w``\ , containing the eigenvalues.
+
+.. function:: gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)
+
+   .. Docstring generated from Julia source
+
+   Computes the generalized eigenvalues, generalized Schur form, left Schur vectors (``jobsvl = V``\ ), or right Schur vectors (``jobvsr = V``\ ) of ``A`` and ``B``\ .
+
+   The generalized eigenvalues are returned in ``alpha`` and ``beta``\ . The left Schur vectors are returned in ``vsl`` and the right Schur vectors are returned in ``vsr``\ .
+
+.. function:: trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
+
+   .. Docstring generated from Julia source
+
+   Reorder the Schur factorization of a matrix. If ``compq = V``\ , the Schur vectors ``Q`` are reordered. If ``compq = N`` they are not modified. ``ifst`` and ``ilst`` specify the reordering of the vectors.
+
+.. function:: trsen!(compq, job, select, T, Q) -> (T, Q, w)
+
+   .. Docstring generated from Julia source
+
+   Reorder the Schur factorization of a matrix and optionally finds reciprocal condition numbers. If ``job = N``\ , no condition numbers are found. If ``job = E``\ , only the condition number for this cluster of eigenvalues is found. If ``job = V``\ , only the condition number for the invariant subspace is found. If ``job = B`` then the condition numbers for the cluster and subspace are found. If ``compq = V`` the Schur vectors ``Q`` are updated. If ``compq = N`` the Schur vectors are not modified. ``select`` determines which eigenvalues are in the cluster.
+
+   Returns ``T``\ , ``Q``\ , and reordered eigenvalues in ``w``\ .
+
+.. function:: tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)
+
+   .. Docstring generated from Julia source
+
+   Reorders the vectors of a generalized Schur decomposition. ``select`` specifices the eigenvalues in each cluster.
+
+.. function:: trsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)
+
+   .. Docstring generated from Julia source
+
+   Solves the Sylvester matrix equation ``A * X +/- X * B = scale*C`` where ``A`` and ``B`` are both quasi-upper triangular. If ``transa = N``\ , ``A`` is not modified. If ``transa = T``\ , ``A`` is transposed. If ``transa = C``\ , ``A`` is conjugate transposed. Similarly for ``transb`` and ``B``\ . If ``isgn = 1``\ , the equation ``A * X + X * B = scale * C`` is solved. If ``isgn = -1``\ , the equation ``A * X - X * B = scale * C`` is solved.
+
+   Returns ``X`` (overwriting ``C``\ ) and ``scale``\ .
+
diff --git a/doc/stdlib/math.rst b/doc/stdlib/math.rst
index 52390aca95797..8ef6304948105 100644
--- a/doc/stdlib/math.rst
+++ b/doc/stdlib/math.rst
@@ -48,8 +48,7 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   Left division operator: multiplication of ``y`` by the inverse of ``x`` on the left.
-   Gives floating-point results for integer arguments.
+   Left division operator: multiplication of ``y`` by the inverse of ``x`` on the left. Gives floating-point results for integer arguments.
 
 .. _^:
 .. function:: ^(x, y)
@@ -135,7 +134,11 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   Modulus after division, returning in the range [0,``y``\ ), if ``y`` is positive, or (``y``\ ,0] if ``y`` is negative.
+   Modulus after flooring division, returning in the range [0,``y``\ ), if ``y`` is positive, or (``y``\ ,0] if ``y`` is negative.
+
+   .. code-block:: julia
+
+       x == fld(x,y)*y + mod(x,y)
 
 .. function:: mod2pi(x)
 
@@ -152,11 +155,15 @@ Mathematical Operators
 
    Remainder from Euclidean division, returning a value of the same sign as ``x``\ , and smaller in magnitude than ``y``\ . This value is always exact.
 
+   .. code-block:: julia
+
+       x == div(x,y)*y + rem(x,y)
+
 .. function:: divrem(x, y)
 
    .. Docstring generated from Julia source
 
-   The quotient and remainder from Euclidean division. Equivalent to ``(x÷y, x%y)``\ .
+   The quotient and remainder from Euclidean division. Equivalent to ``(div(x,y), rem(x,y))`` or ``(x÷y, x%y)``\ .
 
 .. function:: fldmod(x, y)
 
@@ -164,17 +171,34 @@ Mathematical Operators
 
    The floored quotient and modulus after division. Equivalent to ``(fld(x,y), mod(x,y))``\ .
 
-.. function:: mod1(x,m)
+.. function:: fld1(x, y)
 
    .. Docstring generated from Julia source
 
-   Modulus after division, returning in the range (0,m]
+   Flooring division, returning a value consistent with ``mod1(x,y)``
 
-.. function:: rem1(x,m)
+   .. code-block:: julia
+
+       x == fld(x,y)*y + mod(x,y)
+       x == (fld1(x,y)-1)*y + mod1(x,y)
+
+.. function:: mod1(x, y)
 
    .. Docstring generated from Julia source
 
-   Remainder after division, returning in the range (0,m]
+   Modulus after flooring division, returning a value in the range ``(0, y]``\ .
+
+.. function:: fldmod1(x, y)
+
+   .. Docstring generated from Julia source
+
+   Return ``(fld1(x,y), mod1(x,y))``\ .
+
+.. function:: rem1(x, y)
+
+   .. Docstring generated from Julia source
+
+   (Deprecated.) Remainder after division, returning in the range ``(0, y]``\ .
 
 .. _//:
 .. function:: //(num, den)
@@ -193,42 +217,93 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   Numerator of the rational representation of ``x``
+   Numerator of the rational representation of ``x``\ .
 
 .. function:: den(x)
 
    .. Docstring generated from Julia source
 
-   Denominator of the rational representation of ``x``
+   Denominator of the rational representation of ``x``\ .
 
 .. _<<:
 .. function:: <<(x, n)
 
    .. Docstring generated from Julia source
 
-   Left bit shift operator.
+   Left bit shift operator, ``x << n``\ . The result is ``x`` shifted left by ``n`` bits, where ``n >= 0``\ , filling with ``0``\ s. This is equivalent to ``x * 2^n``\ .
+
+   .. doctest::
+
+       julia> Int8(3) << 2
+       12
+
+       julia> bits(Int8(3))
+       "00000011"
+
+       julia> bits(Int8(12))
+       "00001100"
+
+   See also :func:`>>`\ , :func:`>>>`\ .
 
 .. _>>:
 .. function:: >>(x, n)
 
    .. Docstring generated from Julia source
 
-   Right bit shift operator, preserving the sign of ``x``\ .
+   Right bit shift operator, ``x >> n``\ . The result is ``x`` shifted right by ``n`` bits, where ``n >= 0``\ , filling with ``0``\ s if ``x >= 0``\ , ``1``\ s if ``x < 0``\ , preserving the sign of ``x``\ . This is equivalent to ``fld(x, 2^n)``\ .
+
+   .. doctest::
+
+       julia> Int8(13) >> 2
+       3
+
+       julia> bits(Int8(13))
+       "00001101"
+
+       julia> bits(Int8(3))
+       "00000011"
+
+       julia> Int8(-14) >> 2
+       -4
+
+       julia> bits(Int8(-14))
+       "11110010"
+
+       julia> bits(Int8(-4))
+       "11111100"
+
+   See also :func:`>>>`\ , :func:`<<`\ .
 
 .. _>>>:
 .. function:: >>>(x, n)
 
    .. Docstring generated from Julia source
 
-   Unsigned right bit shift operator.
+   Unsigned right bit shift operator, ``x >>> n``\ . The result is ``x`` shifted right by ``n`` bits, where ``n >= 0``\ , filling with ``0``\ s.
+
+   For ``Unsigned`` integer types, this is eqivalent to :func:`>>`\ . For ``Signed`` integer types, this is equivalent to ``(unsigned(x) >> n) % typeof(x)``\ .
+
+   .. doctest::
+
+       julia> Int8(-14) >>> 2
+       60
+
+       julia> bits(Int8(-14))
+       "11110010"
+
+       julia> bits(Int8(60))
+       "00111100"
+
+   ``BigInt``\ s are treated as if having infinite size, so no filling is required and this is equivalent to :func:`>>`\ .
+
+   See also :func:`>>`\ , :func:`<<`\ .
 
 .. _\::
-.. function:: \:(start, [step], stop)
+.. function:: :(start, [step], stop)
 
    .. Docstring generated from Julia source
 
-   Range operator. ``a:b`` constructs a range from ``a`` to ``b`` with a step size of 1, and ``a:s:b`` is similar but uses a step size of ``s``. These syntaxes call the function ``colon``.
-   The colon is also used in indexing to select whole dimensions.
+   Range operator. ``a:b`` constructs a range from ``a`` to ``b`` with a step size of 1, and ``a:s:b`` is similar but uses a step size of ``s``\ . These syntaxes call the function ``colon``\ . The colon is also used in indexing to select whole dimensions.
 
 .. function:: colon(start, [step], stop)
 
@@ -269,7 +344,7 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   See the :func:`is` operator
+   See the :func:`is` operator.
 
 .. _!==:
 .. function:: !==(x, y)
@@ -277,7 +352,7 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   Equivalent to ``!is(x, y)``
+   Equivalent to ``!is(x, y)``\ .
 
 .. _<:
 .. function:: <(x, y)
@@ -365,73 +440,73 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   Bitwise not
+   Bitwise not.
 
 .. _&:
 .. function:: &(x, y)
 
    .. Docstring generated from Julia source
 
-   Bitwise and
+   Bitwise and.
 
 .. _|:
 .. function:: |(x, y)
 
    .. Docstring generated from Julia source
 
-   Bitwise or
+   Bitwise or.
 
 .. _$:
 .. function:: $(x, y)
 
    .. Docstring generated from Julia source
 
-   Bitwise exclusive or
+   Bitwise exclusive or.
 
 .. _!:
 .. function:: !(x)
 
    .. Docstring generated from Julia source
 
-   Boolean not
+   Boolean not.
 
 .. _&&:
 .. function:: x && y
 
    .. Docstring generated from Julia source
 
-   Short-circuiting boolean AND
+   Short-circuiting boolean AND.
 
 .. _||:
 .. function:: x || y
 
    .. Docstring generated from Julia source
 
-   Short-circuiting boolean OR
+   Short-circuiting boolean OR.
 
 .. function:: A_ldiv_Bc(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``A \ Bᴴ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`A` \\ :math:`Bᴴ`\ .
 
 .. function:: A_ldiv_Bt(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``A \ Bᵀ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`A` \\ :math:`Bᵀ`\ .
 
 .. function:: A_mul_B!(Y, A, B) -> Y
 
    .. Docstring generated from Julia source
 
-   Calculates the matrix-matrix or matrix-vector product ``A * B`` and stores the result in ``Y``\ , overwriting the existing value of ``Y``\ .
+   Calculates the matrix-matrix or matrix-vector product :math:`A⋅B` and stores the result in ``Y``\ , overwriting the existing value of ``Y``\ . Note that ``Y`` must not be aliased with either ``A`` or ``B``\ .
 
    .. doctest::
 
-       julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; A_mul_B!(B, A, B);
+       julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); A_mul_B!(Y, A, B);
 
-       julia> B
+       julia> Y
        2x2 Array{Float64,2}:
         3.0  3.0
         7.0  7.0
@@ -440,97 +515,97 @@ Mathematical Operators
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``A Bᴴ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`A⋅Bᴴ`\ .
 
 .. function:: A_mul_Bt(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``A Bᵀ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`A⋅Bᵀ`\ .
 
 .. function:: A_rdiv_Bc(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``A / Bᴴ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`A / Bᴴ`\ .
 
 .. function:: A_rdiv_Bt(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``A / Bᵀ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`A / Bᵀ`\ .
 
 .. function:: Ac_ldiv_B(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᴴ \ B``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᴴ` \\ :math:`B`\ .
 
 .. function:: Ac_ldiv_Bc(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᴴ \ Bᴴ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᴴ` \\ :math:`Bᴴ`\ .
 
 .. function:: Ac_mul_B(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᴴ B``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᴴ⋅B`\ .
 
 .. function:: Ac_mul_Bc(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᴴ Bᴴ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᴴ Bᴴ`\ .
 
 .. function:: Ac_rdiv_B(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᴴ / B``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᴴ / B`\ .
 
 .. function:: Ac_rdiv_Bc(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᴴ \ Bᴴ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᴴ / Bᴴ`\ .
 
 .. function:: At_ldiv_B(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᵀ \ B``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᵀ` \\ :math:`B`\ .
 
 .. function:: At_ldiv_Bt(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᵀ \ Bᵀ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᵀ` \\ :math:`Bᵀ`\ .
 
 .. function:: At_mul_B(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᵀ B``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᵀ⋅B`\ .
 
 .. function:: At_mul_Bt(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᵀ Bᵀ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᵀ⋅Bᵀ`\ .
 
 .. function:: At_rdiv_B(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᵀ / B``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᵀ / B`\ .
 
 .. function:: At_rdiv_Bt(A, B)
 
    .. Docstring generated from Julia source
 
-   For matrices or vectors ``A`` and ``B``\ , calculates ``Aᵀ / Bᵀ``
+   For matrices or vectors :math:`A` and :math:`B`\ , calculates :math:`Aᵀ / Bᵀ`\ .
 
 Mathematical Functions
 ----------------------
@@ -551,19 +626,19 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute sine of ``x``\ , where ``x`` is in radians
+   Compute sine of ``x``\ , where ``x`` is in radians.
 
 .. function:: cos(x)
 
    .. Docstring generated from Julia source
 
-   Compute cosine of ``x``\ , where ``x`` is in radians
+   Compute cosine of ``x``\ , where ``x`` is in radians.
 
 .. function:: tan(x)
 
    .. Docstring generated from Julia source
 
-   Compute tangent of ``x``\ , where ``x`` is in radians
+   Compute tangent of ``x``\ , where ``x`` is in radians.
 
 .. function:: sind(x)
 
@@ -575,13 +650,13 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute cosine of ``x``\ , where ``x`` is in degrees
+   Compute cosine of ``x``\ , where ``x`` is in degrees.
 
 .. function:: tand(x)
 
    .. Docstring generated from Julia source
 
-   Compute tangent of ``x``\ , where ``x`` is in degrees
+   Compute tangent of ``x``\ , where ``x`` is in degrees.
 
 .. function:: sinpi(x)
 
@@ -599,25 +674,25 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute hyperbolic sine of ``x``
+   Compute hyperbolic sine of ``x``\ .
 
 .. function:: cosh(x)
 
    .. Docstring generated from Julia source
 
-   Compute hyperbolic cosine of ``x``
+   Compute hyperbolic cosine of ``x``\ .
 
 .. function:: tanh(x)
 
    .. Docstring generated from Julia source
 
-   Compute hyperbolic tangent of ``x``
+   Compute hyperbolic tangent of ``x``\ .
 
 .. function:: asin(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse sine of ``x``\ , where the output is in radians
+   Compute the inverse sine of ``x``\ , where the output is in radians.
 
 .. function:: acos(x)
 
@@ -629,7 +704,7 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the inverse tangent of ``x``\ , where the output is in radians
+   Compute the inverse tangent of ``x``\ , where the output is in radians.
 
 .. function:: atan2(y, x)
 
@@ -641,61 +716,61 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the inverse sine of ``x``\ , where the output is in degrees
+   Compute the inverse sine of ``x``\ , where the output is in degrees.
 
 .. function:: acosd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse cosine of ``x``\ , where the output is in degrees
+   Compute the inverse cosine of ``x``\ , where the output is in degrees.
 
 .. function:: atand(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse tangent of ``x``\ , where the output is in degrees
+   Compute the inverse tangent of ``x``\ , where the output is in degrees.
 
 .. function:: sec(x)
 
    .. Docstring generated from Julia source
 
-   Compute the secant of ``x``\ , where ``x`` is in radians
+   Compute the secant of ``x``\ , where ``x`` is in radians.
 
 .. function:: csc(x)
 
    .. Docstring generated from Julia source
 
-   Compute the cosecant of ``x``\ , where ``x`` is in radians
+   Compute the cosecant of ``x``\ , where ``x`` is in radians.
 
 .. function:: cot(x)
 
    .. Docstring generated from Julia source
 
-   Compute the cotangent of ``x``\ , where ``x`` is in radians
+   Compute the cotangent of ``x``\ , where ``x`` is in radians.
 
 .. function:: secd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the secant of ``x``\ , where ``x`` is in degrees
+   Compute the secant of ``x``\ , where ``x`` is in degrees.
 
 .. function:: cscd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the cosecant of ``x``\ , where ``x`` is in degrees
+   Compute the cosecant of ``x``\ , where ``x`` is in degrees.
 
 .. function:: cotd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the cotangent of ``x``\ , where ``x`` is in degrees
+   Compute the cotangent of ``x``\ , where ``x`` is in degrees.
 
 .. function:: asec(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse secant of ``x``\ , where the output is in radians
+   Compute the inverse secant of ``x``\ , where the output is in radians.
 
 .. function:: acsc(x)
 
@@ -707,25 +782,25 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the inverse cotangent of ``x``\ , where the output is in radians
+   Compute the inverse cotangent of ``x``\ , where the output is in radians.
 
 .. function:: asecd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse secant of ``x``\ , where the output is in degrees
+   Compute the inverse secant of ``x``\ , where the output is in degrees.
 
 .. function:: acscd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse cosecant of ``x``\ , where the output is in degrees
+   Compute the inverse cosecant of ``x``\ , where the output is in degrees.
 
 .. function:: acotd(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse cotangent of ``x``\ , where the output is in degrees
+   Compute the inverse cotangent of ``x``\ , where the output is in degrees.
 
 .. function:: sech(x)
 
@@ -737,49 +812,49 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the hyperbolic cosecant of ``x``
+   Compute the hyperbolic cosecant of ``x``\ .
 
 .. function:: coth(x)
 
    .. Docstring generated from Julia source
 
-   Compute the hyperbolic cotangent of ``x``
+   Compute the hyperbolic cotangent of ``x``\ .
 
 .. function:: asinh(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse hyperbolic sine of ``x``
+   Compute the inverse hyperbolic sine of ``x``\ .
 
 .. function:: acosh(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse hyperbolic cosine of ``x``
+   Compute the inverse hyperbolic cosine of ``x``\ .
 
 .. function:: atanh(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse hyperbolic tangent of ``x``
+   Compute the inverse hyperbolic tangent of ``x``\ .
 
 .. function:: asech(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse hyperbolic secant of ``x``
+   Compute the inverse hyperbolic secant of ``x``\ .
 
 .. function:: acsch(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse hyperbolic cosecant of ``x``
+   Compute the inverse hyperbolic cosecant of ``x``\ .
 
 .. function:: acoth(x)
 
    .. Docstring generated from Julia source
 
-   Compute the inverse hyperbolic cotangent of ``x``
+   Compute the inverse hyperbolic cotangent of ``x``\ .
 
 .. function:: sinc(x)
 
@@ -797,19 +872,19 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Convert ``x`` from degrees to radians
+   Convert ``x`` from degrees to radians.
 
 .. function:: rad2deg(x)
 
    .. Docstring generated from Julia source
 
-   Convert ``x`` from radians to degrees
+   Convert ``x`` from radians to degrees.
 
 .. function:: hypot(x, y)
 
    .. Docstring generated from Julia source
 
-   Compute the :math:`\sqrt{x^2+y^2}` avoiding overflow and underflow
+   Compute the :math:`\sqrt{x^2+y^2}` avoiding overflow and underflow.
 
 .. function:: log(x)
 
@@ -891,60 +966,50 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   ``round(x)`` rounds ``x`` to an integer value according to the default
-   rounding mode (see :func:`get_rounding`), returning a value of the same type as
-   ``x``. By default (:obj:`RoundNearest`), this will round to the nearest
-   integer, with ties (fractional values of 0.5) being rounded to the even
-   integer.
+   ``round(x)`` rounds ``x`` to an integer value according to the default rounding mode (see :func:`rounding`\ ), returning a value of the same type as ``x``\ . By default (:obj:`RoundNearest`\ ), this will round to the nearest integer, with ties (fractional values of 0.5) being rounded to the even integer.
 
    .. doctest::
 
-      julia> round(1.7)
-      2.0
+       julia> round(1.7)
+       2.0
 
-      julia> round(1.5)
-      2.0
+       julia> round(1.5)
+       2.0
 
-      julia> round(2.5)
-      2.0
+       julia> round(2.5)
+       2.0
 
    The optional :obj:`RoundingMode` argument will change how the number gets rounded.
 
-   ``round(T, x, [r::RoundingMode])`` converts the result to type ``T``, throwing an
-   :exc:`InexactError` if the value is not representable.
+   ``round(T, x, [r::RoundingMode])`` converts the result to type ``T``\ , throwing an :exc:`InexactError` if the value is not representable.
 
-   ``round(x, digits)`` rounds to the specified number of digits after the
-   decimal place (or before if negative). ``round(x, digits, base)`` rounds
-   using a base other than 10.
+   ``round(x, digits)`` rounds to the specified number of digits after the decimal place (or before if negative). ``round(x, digits, base)`` rounds using a base other than 10.
 
    .. doctest::
 
-      julia> round(pi, 2)
-      3.14
+       julia> round(pi, 2)
+       3.14
 
-      julia> round(pi, 3, 2)
-      3.125
+       julia> round(pi, 3, 2)
+       3.125
 
-   .. note::
+   **note**
 
-      Rounding to specified digits in bases other than 2 can be inexact when
-      operating on binary floating point numbers. For example, the ``Float64``
-      value represented by ``1.15`` is actually *less* than 1.15, yet will be
-      rounded to 1.2.
+   Rounding to specified digits in bases other than 2 can be inexact when operating on binary floating point numbers. For example, the ``Float64`` value represented by ``1.15`` is actually *less* than 1.15, yet will be rounded to 1.2.
 
-      .. doctest::
+   .. doctest::
 
-         julia> x = 1.15
-         1.15
+       julia> x = 1.15
+       1.15
 
-         julia> @sprintf "%.20f" x
-         "1.14999999999999991118"
+       julia> @sprintf "%.20f" x
+       "1.14999999999999991118"
 
-         julia> x < 115//100
-         true
+       julia> x < 115//100
+       true
 
-         julia> round(x, 1)
-         1.2
+       julia> round(x, 1)
+       1.2
 
 .. data:: RoundingMode
 
@@ -988,46 +1053,37 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Returns the nearest integral value of the same type as the complex-valued
-   ``z`` to ``z``, breaking ties using the specified :obj:`RoundingMode`\ s.
-   The first :obj:`RoundingMode` is used for rounding the real components while
-   the second is used for rounding the imaginary components.
+   Returns the nearest integral value of the same type as the complex-valued ``z`` to ``z``\ , breaking ties using the specified :obj:`RoundingMode`\ s. The first :obj:`RoundingMode` is used for rounding the real components while the second is used for rounding the imaginary components.
 
 .. function:: ceil([T,] x, [digits, [base]])
 
    .. Docstring generated from Julia source
 
-   ``ceil(x)`` returns the nearest integral value of the same type as ``x``
-   that is greater than or equal to ``x``.
+   ``ceil(x)`` returns the nearest integral value of the same type as ``x`` that is greater than or equal to ``x``\ .
 
-   ``ceil(T, x)`` converts the result to type ``T``, throwing an
-   ``InexactError`` if the value is not representable.
+   ``ceil(T, x)`` converts the result to type ``T``\ , throwing an ``InexactError`` if the value is not representable.
 
-   ``digits`` and ``base`` work as for :func:`round`.
+   ``digits`` and ``base`` work as for :func:`round`\ .
 
 .. function:: floor([T,] x, [digits, [base]])
 
    .. Docstring generated from Julia source
 
-   ``floor(x)`` returns the nearest integral value of the same type as ``x``
-   that is less than or equal to ``x``.
+   ``floor(x)`` returns the nearest integral value of the same type as ``x`` that is less than or equal to ``x``\ .
 
-   ``floor(T, x)`` converts the result to type ``T``, throwing an
-   ``InexactError`` if the value is not representable.
+   ``floor(T, x)`` converts the result to type ``T``\ , throwing an ``InexactError`` if the value is not representable.
 
-   ``digits`` and ``base`` work as for :func:`round`.
+   ``digits`` and ``base`` work as for :func:`round`\ .
 
 .. function:: trunc([T,] x, [digits, [base]])
 
    .. Docstring generated from Julia source
 
-   ``trunc(x)`` returns the nearest integral value of the same type as ``x`` whose absolute
-   value is less than or equal to ``x``.
+   ``trunc(x)`` returns the nearest integral value of the same type as ``x`` whose absolute value is less than or equal to ``x``\ .
 
-   ``trunc(T, x)`` converts the result to type ``T``, throwing an
-   ``InexactError`` if the value is not representable.
+   ``trunc(T, x)`` converts the result to type ``T``\ , throwing an ``InexactError`` if the value is not representable.
 
-   ``digits`` and ``base`` work as for :func:`round`.
+   ``digits`` and ``base`` work as for :func:`round`\ .
 
 .. function:: unsafe_trunc(T, x)
 
@@ -1057,8 +1113,7 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Return ``(min(x,y), max(x,y))``.
-   See also: :func:`extrema` that returns ``(minimum(x), maximum(x))``
+   Return ``(min(x,y), max(x,y))``\ . See also: :func:`extrema` that returns ``(minimum(x), maximum(x))``\ .
 
 .. function:: clamp(x, lo, hi)
 
@@ -1070,13 +1125,95 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Absolute value of ``x``
+   The absolute value of ``x``\ .
+
+   When ``abs`` is applied to signed integers, overflow may occur, resulting in the return of a negative value. This overflow occurs only when ``abs`` is applied to the minimum representable value of a signed integer. That is, when ``x == typemin(typeof(x))``\ , ``abs(x) == x < 0``\ , not ``-x`` as might be expected.
+
+.. function:: Base.checked_abs(x)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``abs(x)``\ , checking for overflow errors where applicable. For example, standard two's complement signed integers (e.g. ``Int``\ ) cannot represent ``abs(typemin(Int))``\ , thus leading to an overflow.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_neg(x)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``-x``\ , checking for overflow errors where applicable. For example, standard two's complement signed integers (e.g. ``Int``\ ) cannot represent ``-typemin(Int)``\ , thus leading to an overflow.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_add(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``x+y``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_sub(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``x-y``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_mul(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``x*y``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_div(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``div(x,y)``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_rem(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``x%y``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_fld(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``fld(x,y)``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_mod(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``mod(x,y)``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
+
+.. function:: Base.checked_cld(x, y)
+
+   .. Docstring generated from Julia source
+
+   Calculates ``cld(x,y)``\ , checking for overflow errors where applicable.
+
+   The overflow protection may impose a perceptible performance penalty.
 
 .. function:: abs2(x)
 
    .. Docstring generated from Julia source
 
-   Squared absolute value of ``x``
+   Squared absolute value of ``x``\ .
 
 .. function:: copysign(x, y)
 
@@ -1136,7 +1273,7 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the scaled complementary error function of ``x``\ , defined by :math:`e^{x^2} \operatorname{erfc}(x)`\ .  Note also that :math:`\operatorname{erfcx}(-ix)` computes the Faddeeva function :math:`w(x)`\ .
+   Compute the scaled complementary error function of ``x``\ , defined by :math:`e^{x^2} \operatorname{erfc}(x)`\ . Note also that :math:`\operatorname{erfcx}(-ix)` computes the Faddeeva function :math:`w(x)`\ .
 
 .. function:: erfi(x)
 
@@ -1166,31 +1303,31 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Return the real part of the complex number ``z``
+   Return the real part of the complex number ``z``\ .
 
 .. function:: imag(z)
 
    .. Docstring generated from Julia source
 
-   Return the imaginary part of the complex number ``z``
+   Return the imaginary part of the complex number ``z``\ .
 
 .. function:: reim(z)
 
    .. Docstring generated from Julia source
 
-   Return both the real and imaginary parts of the complex number ``z``
+   Return both the real and imaginary parts of the complex number ``z``\ .
 
 .. function:: conj(z)
 
    .. Docstring generated from Julia source
 
-   Compute the complex conjugate of a complex number ``z``
+   Compute the complex conjugate of a complex number ``z``\ .
 
 .. function:: angle(z)
 
    .. Docstring generated from Julia source
 
-   Compute the phase angle in radians of a complex number ``z``
+   Compute the phase angle in radians of a complex number ``z``\ .
 
 .. function:: cis(z)
 
@@ -1202,24 +1339,19 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Number of ways to choose ``k`` out of ``n`` items
+   Number of ways to choose ``k`` out of ``n`` items.
 
 .. function:: factorial(n)
 
    .. Docstring generated from Julia source
 
-   Factorial of ``n``.  If ``n`` is an :obj:`Integer`, the factorial
-   is computed as an integer (promoted to at least 64 bits).  Note
-   that this may overflow if ``n`` is not small, but you can use
-   ``factorial(big(n))`` to compute the result exactly in arbitrary
-   precision.  If ``n`` is not an ``Integer``, ``factorial(n)`` is
-   equivalent to :func:`gamma(n+1) <gamma>`.
+   Factorial of ``n``\ .  If ``n`` is an :obj:`Integer`\ , the factorial is computed as an integer (promoted to at least 64 bits).  Note that this may overflow if ``n`` is not small, but you can use ``factorial(big(n))`` to compute the result exactly in arbitrary precision. If ``n`` is not an ``Integer``\ , ``factorial(n)`` is equivalent to :func:`gamma(n+1) <gamma>`\ .
 
 .. function:: factorial(n,k)
 
    .. Docstring generated from Julia source
 
-   Compute ``factorial(n)/factorial(k)``
+   Compute ``factorial(n)/factorial(k)``\ .
 
 .. function:: factor(n) -> Dict
 
@@ -1250,27 +1382,27 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Computes the greatest common (positive) divisor of ``x`` and ``y`` and their Bézout coefficients, i.e. the integer coefficients ``u`` and ``v`` that satisfy :math:`ux+vy = d = gcd(x,y)`.
+   Computes the greatest common (positive) divisor of ``x`` and ``y`` and their Bézout coefficients, i.e. the integer coefficients ``u`` and ``v`` that satisfy :math:`ux+vy = d = gcd(x,y)`\ .
 
    .. doctest::
 
-      julia> gcdx(12, 42)
-      (6,-3,1)
+       julia> gcdx(12, 42)
+       (6,-3,1)
 
    .. doctest::
 
-      julia> gcdx(240, 46)
-      (2,-9,47)
+       julia> gcdx(240, 46)
+       (2,-9,47)
 
-   .. note::
+   **note**
 
-      Bézout coefficients are *not* uniquely defined. ``gcdx`` returns the minimal Bézout coefficients that are computed by the extended Euclid algorithm. (Ref: D. Knuth, TAoCP, 2/e, p. 325, Algorithm X.) These coefficients ``u`` and ``v`` are minimal in the sense that :math:`|u| < |\frac y d` and :math:`|v| < |\frac x d`. Furthermore, the signs of ``u`` and ``v`` are chosen so that ``d`` is positive.
+   Bézout coefficients are *not* uniquely defined. ``gcdx`` returns the minimal Bézout coefficients that are computed by the extended Euclid algorithm. (Ref: D. Knuth, TAoCP, 2/e, p. 325, Algorithm X.) These coefficients ``u`` and ``v`` are minimal in the sense that :math:`|u| < |\frac y d` and :math:`|v| < |\frac x d`\ . Furthermore, the signs of ``u`` and ``v`` are chosen so that ``d`` is positive.
 
 .. function:: ispow2(n) -> Bool
 
    .. Docstring generated from Julia source
 
-   Test whether ``n`` is a power of two
+   Test whether ``n`` is a power of two.
 
 .. function:: nextpow2(n)
 
@@ -1302,11 +1434,13 @@ Mathematical Functions
 
    Next integer not less than ``n`` that can be written as :math:`\prod k_i^{p_i}` for integers :math:`p_1`\ , :math:`p_2`\ , etc.
 
-.. function:: prevprod([k_1,k_2,...], n)
+   For a list of integers i1, i2, i3, find the smallest
 
-   .. Docstring generated from Julia source
+   .. code-block:: julia
+
+       i1^n1 * i2^n2 * i3^n3 >= x
 
-   Previous integer not greater than ``n`` that can be written as :math:`\prod k_i^{p_i}` for integers :math:`p_1`\ , :math:`p_2`\ , etc.
+   for integer n1, n2, n3
 
 .. function:: invmod(x,m)
 
@@ -1324,15 +1458,13 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the gamma function of ``x``
+   Compute the gamma function of ``x``\ .
 
 .. function:: lgamma(x)
 
    .. Docstring generated from Julia source
 
-   Compute the logarithm of the absolute value of :func:`gamma` for
-   :obj:`Real` ``x``, while for :obj:`Complex` ``x`` it computes the
-   logarithm of ``gamma(x)``.
+   Compute the logarithm of the absolute value of :func:`gamma` for :obj:`Real` ``x``\ , while for :obj:`Complex` ``x`` it computes the logarithm of ``gamma(x)``\ .
 
 .. function:: lfact(x)
 
@@ -1356,7 +1488,7 @@ Mathematical Functions
 
    .. Docstring generated from Julia source
 
-   Compute the trigamma function of ``x`` (the logarithmic second derivative of ``gamma(x)``\ )
+   Compute the trigamma function of ``x`` (the logarithmic second derivative of ``gamma(x)``\ ).
 
 .. function:: polygamma(m, x)
 
@@ -1587,7 +1719,7 @@ Statistics
 
    .. Docstring generated from Julia source
 
-   Compute the sample variance of a vector or array ``v``\ , optionally along dimensions in ``region``\ . The algorithm will return an estimator of the generative distribution's variance under the assumption that each entry of ``v`` is an IID drawn from that generative distribution. This computation is equivalent to calculating ``sum((v - mean(v)).^2) / (length(v) - 1)``\ . Note: Julia does not ignore ``NaN`` values in the computation. For applications requiring the handling of missing data, the ``DataArray`` package is recommended.
+   Compute the sample variance of a vector or array ``v``\ , optionally along dimensions in ``region``\ . The algorithm will return an estimator of the generative distribution's variance under the assumption that each entry of ``v`` is an IID drawn from that generative distribution. This computation is equivalent to calculating ``sumabs2(v - mean(v)) / (length(v) - 1)``\ . Note: Julia does not ignore ``NaN`` values in the computation. For applications requiring the handling of missing data, the ``DataArray`` package is recommended.
 
 .. function:: varm(v, m)
 
@@ -1673,47 +1805,77 @@ Statistics
 
    Compute the midpoints of the bins with edges ``e``\ . The result is a vector/range of length ``length(e) - 1``\ . Note: Julia does not ignore ``NaN`` values in the computation.
 
-.. function:: quantile(v, ps)
+.. function:: quantile(v, p; sorted=false)
+
+   .. Docstring generated from Julia source
+
+   Compute the quantile(s) of a vector ``v`` at a specified probability or vector ``p``\ . The keyword argument ``sorted`` indicates whether ``v`` can be assumed to be sorted.
+
+   The ``p`` should be on the interval [0,1], and ``v`` should not have any ``NaN`` values.
+
+   Quantiles are computed via linear interpolation between the points ``((k-1)/(n-1), v[k])``\ , for ``k = 1:n`` where ``n = length(v)``\ . This corresponds to Definition 7 of Hyndman and Fan (1996), and is the same as the R default.
+
+   * Hyndman, R.J and Fan, Y. (1996) "Sample Quantiles in Statistical Packages",   *The American Statistician*, Vol. 50, No. 4, pp. 361-365
+
+.. function:: quantile!([q, ] v, p; sorted=false)
+
+   .. Docstring generated from Julia source
+
+   Compute the quantile(s) of a vector ``v`` at the probabilities ``p``\ , with optional output into array ``q`` (if not provided, a new output array is created). The keyword argument ``sorted`` indicates whether ``v`` can be assumed to be sorted; if ``false`` (the default), then the elements of ``v`` may be partially sorted.
+
+   The elements of ``p`` should be on the interval [0,1], and ``v`` should not have any ``NaN`` values.
+
+   Quantiles are computed via linear interpolation between the points ``((k-1)/(n-1), v[k])``\ , for ``k = 1:n`` where ``n = length(v)``\ . This corresponds to Definition 7 of Hyndman and Fan (1996), and is the same as the R default.
+
+   * Hyndman, R.J and Fan, Y. (1996) "Sample Quantiles in Statistical Packages",   *The American Statistician*, Vol. 50, No. 4, pp. 361-365
+
+.. function:: cov(x[, corrected=true])
 
    .. Docstring generated from Julia source
 
-   Compute the quantiles of a vector ``v`` at a specified set of probability values ``ps``\ . Note: Julia does not ignore ``NaN`` values in the computation.
+   Compute the variance of the vector ``x``\ . If ``corrected`` is ``true`` (the default) then the sum is scaled with ``n-1`` wheares the sum is scaled with ``n`` if ``corrected`` is ``false`` where ``n = length(x)``\ .
 
-.. function:: quantile(v, p)
+.. function:: cov(X[, vardim=1, corrected=true])
 
    .. Docstring generated from Julia source
 
-   Compute the quantile of a vector ``v`` at the probability ``p``\ . Note: Julia does not ignore ``NaN`` values in the computation.
+   Compute the covariance matrix of the matrix ``X`` along the dimension ``vardim``\ . If ``corrected`` is ``true`` (the default) then the sum is scaled with ``n-1`` wheares the sum is scaled with ``n`` if ``corrected`` is ``false`` where ``n = size(X, vardim)``\ .
 
-.. function:: quantile!(v, p)
+.. function:: cov(x, y[, corrected=true])
 
    .. Docstring generated from Julia source
 
-   Like ``quantile``\ , but overwrites the input vector.
+   Compute the covariance between the vectors ``x`` and ``y``\ . If ``corrected`` is ``true`` (the default) then the sum is scaled with ``n-1`` wheares the sum is scaled with ``n`` if ``corrected`` is ``false`` where ``n = length(x) = length(y)``\ .
 
-.. function:: cov(v1[, v2][, vardim=1, corrected=true, mean=nothing])
+.. function:: cov(X, Y[, vardim=1, corrected=true])
 
    .. Docstring generated from Julia source
 
-   Compute the Pearson covariance between the vector(s) in ``v1`` and ``v2``\ . Here, ``v1`` and ``v2`` can be either vectors or matrices.
+   Compute the covariance between the vectors or matrices ``X`` and ``Y`` along the dimension ``vardim``\ . If ``corrected`` is ``true`` (the default) then the sum is scaled with ``n-1`` wheares the sum is scaled with ``n`` if ``corrected`` is ``false`` where ``n = size(X, vardim) = size(Y, vardim)``\ .
+
+.. function:: cor(x)
+
+   .. Docstring generated from Julia source
 
-   This function accepts three keyword arguments:
+   Return the number one.
 
-     *   ``vardim``\ : the dimension of variables. When ``vardim = 1``\ , variables are considered in columns while observations in rows; when ``vardim = 2``\ , variables are in rows while observations in columns. By default, it is set to ``1``\ .
-     *   ``corrected``\ : whether to apply Bessel's correction (divide by ``n-1`` instead of ``n``\ ). By default, it is set to ``true``\ .
-     *   ``mean``\ : allow users to supply mean values that are known. By default, it is set to ``nothing``\ , which indicates that the mean(s) are unknown, and the function will compute the mean. Users can use ``mean=0`` to indicate that the input data are centered, and hence there's no need to subtract the mean.
+.. function:: cor(X[, vardim=1])
 
-   The size of the result depends on the size of ``v1`` and ``v2``\ . When both ``v1`` and ``v2`` are vectors, it returns the covariance between them as a scalar. When either one is a matrix, it returns a covariance matrix of size ``(n1, n2)``\ , where ``n1`` and ``n2`` are the numbers of slices in ``v1`` and ``v2``\ , which depend on the setting of ``vardim``\ .
+   .. Docstring generated from Julia source
 
-   Note: ``v2`` can be omitted, which indicates ``v2 = v1``\ .
+   Compute the Pearson correlation matrix of the matrix ``X`` along the dimension ``vardim``\ .
 
-.. function:: cor(v1[, v2][, vardim=1, mean=nothing])
+.. function:: cor(x, y)
 
    .. Docstring generated from Julia source
 
-   Compute the Pearson correlation between the vector(s) in ``v1`` and ``v2``\ .
+   Compute the Pearson correlation between the vectors ``x`` and ``y``\ .
+
+.. function:: cor(X, Y[, vardim=1])
+
+   .. Docstring generated from Julia source
 
-   Users can use the keyword argument ``vardim`` to specify the variable dimension, and ``mean`` to supply pre-computed mean values.
+   Compute the Pearson correlation between the vectors or matrices ``X`` and ``Y`` along the dimension ``vardim``\ .
 
 Signal Processing
 -----------------
@@ -1728,7 +1890,7 @@ multi-threading. Use ``FFTW.set_num_threads(np)`` to use ``np`` threads.
 
    .. Docstring generated from Julia source
 
-   Performs a multidimensional FFT of the array ``A``\ .  The optional ``dims`` argument specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along.  Most efficient if the size of ``A`` along the transformed dimensions is a product of small primes; see ``nextprod()``\ .  See also ``plan_fft()`` for even greater efficiency.
+   Performs a multidimensional FFT of the array ``A``\ . The optional ``dims`` argument specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along. Most efficient if the size of ``A`` along the transformed dimensions is a product of small primes; see ``nextprod()``\ . See also ``plan_fft()`` for even greater efficiency.
 
    A one-dimensional FFT computes the one-dimensional discrete Fourier transform (DFT) as defined by
 
@@ -1747,8 +1909,7 @@ multi-threading. Use ``FFTW.set_num_threads(np)`` to use ``np`` threads.
 
    .. Docstring generated from Julia source
 
-   Same as :func:`fft`, but operates in-place on ``A``,
-   which must be an array of complex floating-point numbers.
+   Same as :func:`fft`\ , but operates in-place on ``A``\ , which must be an array of complex floating-point numbers.
 
 .. function:: ifft(A [, dims])
 
@@ -1770,227 +1931,153 @@ multi-threading. Use ``FFTW.set_num_threads(np)`` to use ``np`` threads.
 
    .. Docstring generated from Julia source
 
-   Same as :func:`ifft`, but operates in-place on ``A``.
+   Same as :func:`ifft`\ , but operates in-place on ``A``\ .
 
 .. function:: bfft(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Similar to :func:`ifft`, but computes an unnormalized inverse (backward)
-   transform, which must be divided by the product of the sizes of the
-   transformed dimensions in order to obtain the inverse. (This is slightly
-   more efficient than :func:`ifft` because it omits a scaling step, which in
-   some applications can be combined with other computational steps elsewhere.)
+   Similar to :func:`ifft`\ , but computes an unnormalized inverse (backward) transform, which must be divided by the product of the sizes of the transformed dimensions in order to obtain the inverse. (This is slightly more efficient than :func:`ifft` because it omits a scaling step, which in some applications can be combined with other computational steps elsewhere.)
 
    .. math::
 
-      \operatorname{BDFT}(A)[k] = \operatorname{length}(A) \operatorname{IDFT}(A)[k]
+       \operatorname{BDFT}(A)[k] = \operatorname{length}(A) \operatorname{IDFT}(A)[k]
 
 .. function:: bfft!(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Same as :func:`bfft`, but operates in-place on ``A``.
+   Same as :func:`bfft`\ , but operates in-place on ``A``\ .
 
 .. function:: plan_fft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized FFT along given dimensions (``dims``) of arrays
-   matching the shape and type of ``A``.  (The first two arguments have
-   the same meaning as for :func:`fft`.)  Returns an object ``P`` which
-   represents the linear operator computed by the FFT, and which contains
-   all of the information needed to compute ``fft(A, dims)`` quickly.
-
-   To apply ``P`` to an array ``A``, use ``P * A``; in general, the
-   syntax for applying plans is much like that of matrices.  (A plan
-   can only be applied to arrays of the same size as the ``A`` for
-   which the plan was created.)  You can also apply a plan with a
-   preallocated output array ``Â`` by calling ``A_mul_B!(Â, plan,
-   A)``.  You can compute the inverse-transform plan by ``inv(P)`` and
-   apply the inverse plan with ``P \ Â`` (the inverse plan is cached
-   and reused for subsequent calls to ``inv`` or ``\``), and apply the
-   inverse plan to a pre-allocated output array ``A`` with
-   ``A_ldiv_B!(A, P, Â)``.
-
-   The ``flags`` argument is a bitwise-or of FFTW planner flags, defaulting
-   to ``FFTW.ESTIMATE``.  e.g. passing ``FFTW.MEASURE`` or ``FFTW.PATIENT``
-   will instead spend several seconds (or more) benchmarking different
-   possible FFT algorithms and picking the fastest one; see the FFTW manual
-   for more information on planner flags.  The optional ``timelimit`` argument
-   specifies a rough upper bound on the allowed planning time, in seconds.
-   Passing ``FFTW.MEASURE`` or ``FFTW.PATIENT`` may cause the input array ``A``
-   to be overwritten with zeros during plan creation.
-
-   :func:`plan_fft!` is the same as :func:`plan_fft` but creates a plan
-   that operates in-place on its argument (which must be an array of
-   complex floating-point numbers).  :func:`plan_ifft` and so on
-   are similar but produce plans that perform the equivalent of
-   the inverse transforms :func:`ifft` and so on.
+   Pre-plan an optimized FFT along given dimensions (``dims``\ ) of arrays matching the shape and type of ``A``\ .  (The first two arguments have the same meaning as for :func:`fft`\ .) Returns an object ``P`` which represents the linear operator computed by the FFT, and which contains all of the information needed to compute ``fft(A, dims)`` quickly.
+
+   To apply ``P`` to an array ``A``\ , use ``P * A``\ ; in general, the syntax for applying plans is much like that of matrices.  (A plan can only be applied to arrays of the same size as the ``A`` for which the plan was created.)  You can also apply a plan with a preallocated output array ``Â`` by calling ``A_mul_B!(Â, plan, A)``\ .  You can compute the inverse-transform plan by ``inv(P)`` and apply the inverse plan with ``P \ Â`` (the inverse plan is cached and reused for subsequent calls to ``inv`` or ``\``\ ), and apply the inverse plan to a pre-allocated output array ``A`` with ``A_ldiv_B!(A, P, Â)``\ .
+
+   The ``flags`` argument is a bitwise-or of FFTW planner flags, defaulting to ``FFTW.ESTIMATE``\ . e.g. passing ``FFTW.MEASURE`` or ``FFTW.PATIENT`` will instead spend several seconds (or more) benchmarking different possible FFT algorithms and picking the fastest one; see the FFTW manual for more information on planner flags.  The optional ``timelimit`` argument specifies a rough upper bound on the allowed planning time, in seconds. Passing ``FFTW.MEASURE`` or ``FFTW.PATIENT`` may cause the input array ``A`` to be overwritten with zeros during plan creation.
+
+   :func:`plan_fft!` is the same as :func:`plan_fft` but creates a plan that operates in-place on its argument (which must be an array of complex floating-point numbers). :func:`plan_ifft` and so on are similar but produce plans that perform the equivalent of the inverse transforms :func:`ifft` and so on.
 
 .. function:: plan_ifft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_fft`, but produces a plan that performs inverse transforms
-   :func:`ifft`.
+   Same as :func:`plan_fft`\ , but produces a plan that performs inverse transforms :func:`ifft`\ .
 
 .. function:: plan_bfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_fft`, but produces a plan that performs an unnormalized
-   backwards transform :func:`bfft`.
+   Same as :func:`plan_fft`\ , but produces a plan that performs an unnormalized backwards transform :func:`bfft`\ .
 
 .. function:: plan_fft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_fft`, but operates in-place on ``A``.
+   Same as :func:`plan_fft`\ , but operates in-place on ``A``\ .
 
 .. function:: plan_ifft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_ifft`, but operates in-place on ``A``.
+   Same as :func:`plan_ifft`\ , but operates in-place on ``A``\ .
 
 .. function:: plan_bfft!(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_bfft`, but operates in-place on ``A``.
+   Same as :func:`plan_bfft`\ , but operates in-place on ``A``\ .
 
 .. function:: rfft(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Multidimensional FFT of a real array ``A``, exploiting the fact that
-   the transform has conjugate symmetry in order to save roughly half
-   the computational time and storage costs compared with :func:`fft`.
-   If ``A`` has size ``(n_1, ..., n_d)``, the result has size
-   ``(div(n_1,2)+1, ..., n_d)``.
+   Multidimensional FFT of a real array ``A``\ , exploiting the fact that the transform has conjugate symmetry in order to save roughly half the computational time and storage costs compared with :func:`fft`\ . If ``A`` has size ``(n_1, ..., n_d)``\ , the result has size ``(div(n_1,2)+1, ..., n_d)``\ .
 
-   The optional ``dims`` argument specifies an iterable subset of one or
-   more dimensions of ``A`` to transform, similar to :func:`fft`.  Instead
-   of (roughly) halving the first dimension of ``A`` in the result, the
-   ``dims[1]`` dimension is (roughly) halved in the same way.
+   The optional ``dims`` argument specifies an iterable subset of one or more dimensions of ``A`` to transform, similar to :func:`fft`\ . Instead of (roughly) halving the first dimension of ``A`` in the result, the ``dims[1]`` dimension is (roughly) halved in the same way.
 
 .. function:: irfft(A, d [, dims])
 
    .. Docstring generated from Julia source
 
-   Inverse of :func:`rfft`: for a complex array ``A``, gives the
-   corresponding real array whose FFT yields ``A`` in the first half.
-   As for :func:`rfft`, ``dims`` is an optional subset of dimensions
-   to transform, defaulting to ``1:ndims(A)``.
+   Inverse of :func:`rfft`\ : for a complex array ``A``\ , gives the corresponding real array whose FFT yields ``A`` in the first half. As for :func:`rfft`\ , ``dims`` is an optional subset of dimensions to transform, defaulting to ``1:ndims(A)``\ .
 
-   ``d`` is the length of the transformed real array along the ``dims[1]``
-   dimension, which must satisfy ``div(d,2)+1 == size(A,dims[1])``.
-   (This parameter cannot be inferred from ``size(A)`` since both
-   ``2*size(A,dims[1])-2`` as well as ``2*size(A,dims[1])-1`` are valid sizes
-   for the transformed real array.)
+   ``d`` is the length of the transformed real array along the ``dims[1]`` dimension, which must satisfy ``div(d,2)+1 == size(A,dims[1])``\ . (This parameter cannot be inferred from ``size(A)`` since both ``2*size(A,dims[1])-2`` as well as ``2*size(A,dims[1])-1`` are valid sizes for the transformed real array.)
 
 .. function:: brfft(A, d [, dims])
 
    .. Docstring generated from Julia source
 
-   Similar to :func:`irfft` but computes an unnormalized inverse transform
-   (similar to :func:`bfft`), which must be divided by the product
-   of the sizes of the transformed dimensions (of the real output array)
-   in order to obtain the inverse transform.
+   Similar to :func:`irfft` but computes an unnormalized inverse transform (similar to :func:`bfft`\ ), which must be divided by the product of the sizes of the transformed dimensions (of the real output array) in order to obtain the inverse transform.
 
 .. function:: plan_rfft(A [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized real-input FFT, similar to :func:`plan_fft`
-   except for :func:`rfft` instead of :func:`fft`.  The first two
-   arguments, and the size of the transformed result, are the same as
-   for :func:`rfft`.
+   Pre-plan an optimized real-input FFT, similar to :func:`plan_fft` except for :func:`rfft` instead of :func:`fft`\ . The first two arguments, and the size of the transformed result, are the same as for :func:`rfft`\ .
 
 .. function:: plan_brfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized real-input unnormalized transform, similar to
-   :func:`plan_rfft` except for :func:`brfft` instead of :func:`rfft`.
-   The first two arguments and the size of the transformed result, are
-   the same as for :func:`brfft`.
+   Pre-plan an optimized real-input unnormalized transform, similar to :func:`plan_rfft` except for :func:`brfft` instead of :func:`rfft`\ . The first two arguments and the size of the transformed result, are the same as for :func:`brfft`\ .
 
 .. function:: plan_irfft(A, d [, dims]; flags=FFTW.ESTIMATE;  timelimit=Inf)
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized inverse real-input FFT, similar to :func:`plan_rfft`
-   except for :func:`irfft` and :func:`brfft`, respectively.  The first
-   three arguments have the same meaning as for :func:`irfft`.
+   Pre-plan an optimized inverse real-input FFT, similar to :func:`plan_rfft` except for :func:`irfft` and :func:`brfft`\ , respectively. The first three arguments have the same meaning as for :func:`irfft`\ .
 
 .. function:: dct(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Performs a multidimensional type-II discrete cosine transform (DCT)
-   of the array ``A``, using the unitary normalization of the DCT.
-   The optional ``dims`` argument specifies an iterable subset of
-   dimensions (e.g. an integer, range, tuple, or array) to transform
-   along.  Most efficient if the size of ``A`` along the transformed
-   dimensions is a product of small primes; see :func:`nextprod`.  See
-   also :func:`plan_dct` for even greater efficiency.
+   Performs a multidimensional type-II discrete cosine transform (DCT) of the array ``A``\ , using the unitary normalization of the DCT. The optional ``dims`` argument specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along.  Most efficient if the size of ``A`` along the transformed dimensions is a product of small primes; see :func:`nextprod`\ . See also :func:`plan_dct` for even greater efficiency.
 
 .. function:: dct!(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Same as :func:`dct!`, except that it operates in-place
-   on ``A``, which must be an array of real or complex floating-point
-   values.
+   Same as :func:`dct!`\ , except that it operates in-place on ``A``\ , which must be an array of real or complex floating-point values.
 
 .. function:: idct(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Computes the multidimensional inverse discrete cosine transform (DCT)
-   of the array ``A`` (technically, a type-III DCT with the unitary
-   normalization).
-   The optional ``dims`` argument specifies an iterable subset of
-   dimensions (e.g. an integer, range, tuple, or array) to transform
-   along.  Most efficient if the size of ``A`` along the transformed
-   dimensions is a product of small primes; see :func:`nextprod`.  See
-   also :func:`plan_idct` for even greater efficiency.
+   Computes the multidimensional inverse discrete cosine transform (DCT) of the array ``A`` (technically, a type-III DCT with the unitary normalization). The optional ``dims`` argument specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along.  Most efficient if the size of ``A`` along the transformed dimensions is a product of small primes; see :func:`nextprod`\ .  See also :func:`plan_idct` for even greater efficiency.
 
 .. function:: idct!(A [, dims])
 
    .. Docstring generated from Julia source
 
-   Same as :func:`idct!`, but operates in-place on ``A``.
+   Same as :func:`idct!`\ , but operates in-place on ``A``\ .
 
 .. function:: plan_dct(A [, dims [, flags [, timelimit]]])
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized discrete cosine transform (DCT), similar to
-   :func:`plan_fft` except producing a function that computes :func:`dct`.
-   The first two arguments have the same meaning as for :func:`dct`.
+   Pre-plan an optimized discrete cosine transform (DCT), similar to :func:`plan_fft` except producing a function that computes :func:`dct`\ . The first two arguments have the same meaning as for :func:`dct`\ .
 
 .. function:: plan_dct!(A [, dims [, flags [, timelimit]]])
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_dct`, but operates in-place on ``A``.
+   Same as :func:`plan_dct`\ , but operates in-place on ``A``\ .
 
 .. function:: plan_idct(A [, dims [, flags [, timelimit]]])
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized inverse discrete cosine transform (DCT), similar to
-   :func:`plan_fft` except producing a function that computes :func:`idct`.
-   The first two arguments have the same meaning as for :func:`idct`.
+   Pre-plan an optimized inverse discrete cosine transform (DCT), similar to :func:`plan_fft` except producing a function that computes :func:`idct`\ . The first two arguments have the same meaning as for :func:`idct`\ .
 
 .. function:: plan_idct!(A [, dims [, flags [, timelimit]]])
 
    .. Docstring generated from Julia source
 
-   Same as :func:`plan_idct`, but operates in-place on ``A``.
+   Same as :func:`plan_idct`\ , but operates in-place on ``A``\ .
 
 .. function:: fftshift(x)
 
@@ -2020,8 +2107,7 @@ multi-threading. Use ``FFTW.set_num_threads(np)`` to use ``np`` threads.
 
    .. Docstring generated from Julia source
 
-   Same as :func:`filt` but writes the result into the ``out`` argument,
-   which may alias the input ``x`` to modify it in-place.
+   Same as :func:`filt` but writes the result into the ``out`` argument, which may alias the input ``x`` to modify it in-place.
 
 .. function:: deconv(b,a)
 
@@ -2039,13 +2125,13 @@ multi-threading. Use ``FFTW.set_num_threads(np)`` to use ``np`` threads.
 
    .. Docstring generated from Julia source
 
-   2-D convolution of the matrix ``A`` with the 2-D separable kernel generated by the vectors ``u`` and ``v``\ . Uses 2-D FFT algorithm
+   2-D convolution of the matrix ``A`` with the 2-D separable kernel generated by the vectors ``u`` and ``v``\ . Uses 2-D FFT algorithm.
 
 .. function:: conv2(B,A)
 
    .. Docstring generated from Julia source
 
-   2-D convolution of the matrix ``B`` with the matrix ``A``\ . Uses 2-D FFT algorithm
+   2-D convolution of the matrix ``B`` with the matrix ``A``\ . Uses 2-D FFT algorithm.
 
 .. function:: xcorr(u,v)
 
@@ -2061,24 +2147,9 @@ The following functions are defined within the ``Base.FFTW`` module.
 
    .. Docstring generated from Julia source
 
-   Performs a multidimensional real-input/real-output (r2r) transform
-   of type ``kind`` of the array ``A``, as defined in the FFTW manual.
-   ``kind`` specifies either a discrete cosine transform of various types
-   (``FFTW.REDFT00``, ``FFTW.REDFT01``, ``FFTW.REDFT10``, or
-   ``FFTW.REDFT11``), a discrete sine transform of various types
-   (``FFTW.RODFT00``, ``FFTW.RODFT01``, ``FFTW.RODFT10``, or
-   ``FFTW.RODFT11``), a real-input DFT with halfcomplex-format output
-   (``FFTW.R2HC`` and its inverse ``FFTW.HC2R``), or a discrete
-   Hartley transform (``FFTW.DHT``).  The ``kind`` argument may be
-   an array or tuple in order to specify different transform types
-   along the different dimensions of ``A``; ``kind[end]`` is used
-   for any unspecified dimensions.  See the FFTW manual for precise
-   definitions of these transform types, at http://www.fftw.org/doc.
+   Performs a multidimensional real-input/real-output (r2r) transform of type ``kind`` of the array ``A``\ , as defined in the FFTW manual. ``kind`` specifies either a discrete cosine transform of various types (``FFTW.REDFT00``\ , ``FFTW.REDFT01``\ , ``FFTW.REDFT10``\ , or ``FFTW.REDFT11``\ ), a discrete sine transform of various types (``FFTW.RODFT00``\ , ``FFTW.RODFT01``\ , ``FFTW.RODFT10``\ , or ``FFTW.RODFT11``\ ), a real-input DFT with halfcomplex-format output (``FFTW.R2HC`` and its inverse ``FFTW.HC2R``\ ), or a discrete Hartley transform (``FFTW.DHT``\ ).  The ``kind`` argument may be an array or tuple in order to specify different transform types along the different dimensions of ``A``\ ; ``kind[end]`` is used for any unspecified dimensions.  See the FFTW manual for precise definitions of these transform types, at http://www.fftw.org/doc.
 
-   The optional ``dims`` argument specifies an iterable subset of
-   dimensions (e.g. an integer, range, tuple, or array) to transform
-   along. ``kind[i]`` is then the transform type for ``dims[i]``,
-   with ``kind[end]`` being used for ``i > length(kind)``.
+   The optional ``dims`` argument specifies an iterable subset of dimensions (e.g. an integer, range, tuple, or array) to transform along. ``kind[i]`` is then the transform type for ``dims[i]``\ , with ``kind[end]`` being used for ``i > length(kind)``\ .
 
    See also :func:`plan_r2r` to pre-plan optimized r2r transforms.
 
@@ -2086,22 +2157,19 @@ The following functions are defined within the ``Base.FFTW`` module.
 
    .. Docstring generated from Julia source
 
-   Same as :func:`r2r`, but operates in-place on ``A``, which must be
-   an array of real or complex floating-point numbers.
+   Same as :func:`r2r`\ , but operates in-place on ``A``\ , which must be an array of real or complex floating-point numbers.
 
 .. function:: plan_r2r(A, kind [, dims [, flags [, timelimit]]])
 
    .. Docstring generated from Julia source
 
-   Pre-plan an optimized r2r transform, similar to :func:`Base.plan_fft`
-   except that the transforms (and the first three arguments)
-   correspond to :func:`r2r` and :func:`r2r!`, respectively.
+   Pre-plan an optimized r2r transform, similar to :func:`Base.plan_fft` except that the transforms (and the first three arguments) correspond to :func:`r2r` and :func:`r2r!`\ , respectively.
 
 .. function:: plan_r2r!(A, kind [, dims [, flags [, timelimit]]])
 
    .. Docstring generated from Julia source
 
-   Similar to :func:`Base.plan_fft`, but corresponds to :func:`r2r!`.
+   Similar to :func:`Base.plan_fft`\ , but corresponds to :func:`r2r!`\ .
 
 .. currentmodule:: Base
 
diff --git a/doc/stdlib/numbers.rst b/doc/stdlib/numbers.rst
index ca5fe33b7bd7b..7bbbbe81fd347 100644
--- a/doc/stdlib/numbers.rst
+++ b/doc/stdlib/numbers.rst
@@ -42,11 +42,11 @@ Data Formats
 
    Convert an integer to a string in the given base, optionally specifying a number of digits to pad to. The base can be specified as either an integer, or as a ``UInt8`` array of character values to use as digit symbols.
 
-.. function:: digits(n, [base], [pad])
+.. function:: digits([T], n, [base], [pad])
 
    .. Docstring generated from Julia source
 
-   Returns an array of the digits of ``n`` in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indexes, such that ``n == sum([digits[k]*base^(k-1) for k=1:length(digits)])``\ .
+   Returns an array with element type ``T`` (default ``Int``\ ) of the digits of ``n`` in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indexes, such that ``n == sum([digits[k]*base^(k-1) for k=1:length(digits)])``\ .
 
 .. function:: digits!(array, n, [base])
 
@@ -126,19 +126,19 @@ Data Formats
 
    .. Docstring generated from Julia source
 
-   Byte-swap an integer
+   Byte-swap an integer.
 
 .. function:: num2hex(f)
 
    .. Docstring generated from Julia source
 
-   Get a hexadecimal string of the binary representation of a floating point number
+   Get a hexadecimal string of the binary representation of a floating point number.
 
 .. function:: hex2num(str)
 
    .. Docstring generated from Julia source
 
-   Convert a hexadecimal string to the floating point number it represents
+   Convert a hexadecimal string to the floating point number it represents.
 
 .. function:: hex2bytes(s::ASCIIString)
 
@@ -223,7 +223,7 @@ General Number Functions and Constants
 
    .. Docstring generated from Julia source
 
-   Test whether a floating point number is subnormal
+   Test whether a floating point number is subnormal.
 
 .. function:: isfinite(f) -> Bool
 
@@ -235,19 +235,19 @@ General Number Functions and Constants
 
    .. Docstring generated from Julia source
 
-   Test whether a number is infinite
+   Test whether a number is infinite.
 
 .. function:: isnan(f) -> Bool
 
    .. Docstring generated from Julia source
 
-   Test whether a floating point number is not a number (NaN)
+   Test whether a floating point number is not a number (NaN).
 
 .. function:: inf(f)
 
    .. Docstring generated from Julia source
 
-   Returns positive infinity of the floating point type ``f`` or of the same floating point type as ``f``
+   Returns positive infinity of the floating point type ``f`` or of the same floating point type as ``f``\ .
 
 .. function:: nan(f)
 
@@ -259,13 +259,13 @@ General Number Functions and Constants
 
    .. Docstring generated from Julia source
 
-   Get the next floating point number in lexicographic order
+   Get the next floating point number in lexicographic order.
 
 .. function:: prevfloat(f) -> AbstractFloat
 
    .. Docstring generated from Julia source
 
-   Get the previous floating point number in lexicographic order
+   Get the previous floating point number in lexicographic order.
 
 .. function:: isinteger(x) -> Bool
 
@@ -277,7 +277,7 @@ General Number Functions and Constants
 
    .. Docstring generated from Julia source
 
-   Test whether ``x`` or all its elements are numerically equal to some real number
+   Test whether ``x`` or all its elements are numerically equal to some real number.
 
 .. function:: Float32(x [, mode::RoundingMode])
 
@@ -293,7 +293,7 @@ General Number Functions and Constants
        julia> Float32(1/3, RoundUp)
        0.33333334f0
 
-   See ``get_rounding`` for available rounding modes.
+   See ``rounding`` for available rounding modes.
 
 .. function:: Float64(x [, mode::RoundingMode])
 
@@ -309,65 +309,49 @@ General Number Functions and Constants
        julia> Float64(pi, RoundUp)
        3.1415926535897936
 
-   See ``get_rounding`` for available rounding modes.
+   See ``rounding`` for available rounding modes.
 
 .. function:: BigInt(x)
 
    .. Docstring generated from Julia source
 
-   Create an arbitrary precision integer. ``x`` may be an ``Int`` (or anything
-   that can be converted to an ``Int``).  The usual mathematical operators are
-   defined for this type, and results are promoted to a ``BigInt``.
+   Create an arbitrary precision integer. ``x`` may be an ``Int`` (or anything that can be converted to an ``Int``\ ).  The usual mathematical operators are defined for this type, and results are promoted to a ``BigInt``\ .
 
-   Instances can be constructed from strings via :func:`parse`, or using the
-   ``big`` string literal.
+   Instances can be constructed from strings via :func:`parse`\ , or using the ``big`` string literal.
 
 .. function:: BigFloat(x)
 
    .. Docstring generated from Julia source
 
-   Create an arbitrary precision floating point number. ``x`` may be
-   an ``Integer``, a ``Float64`` or a ``BigInt``. The
-   usual mathematical operators are defined for this type, and results
-   are promoted to a ``BigFloat``.
+   Create an arbitrary precision floating point number. ``x`` may be an ``Integer``\ , a ``Float64`` or a ``BigInt``\ . The usual mathematical operators are defined for this type, and results are promoted to a ``BigFloat``\ .
 
-   Note that because decimal literals are converted to floating point numbers
-   when parsed, ``BigFloat(2.1)`` may not yield what you expect. You may instead
-   prefer to initialize constants from strings via :func:`parse`, or using the
-   ``big`` string literal.
+   Note that because decimal literals are converted to floating point numbers when parsed, ``BigFloat(2.1)`` may not yield what you expect. You may instead prefer to initialize constants from strings via :func:`parse`\ , or using the ``big`` string literal.
 
    .. doctest::
 
-      julia> BigFloat(2.1)
-      2.100000000000000088817841970012523233890533447265625000000000000000000000000000
+       julia> BigFloat(2.1)
+       2.100000000000000088817841970012523233890533447265625000000000000000000000000000
 
-      julia> big"2.1"
-      2.099999999999999999999999999999999999999999999999999999999999999999999999999986
+       julia> big"2.1"
+       2.099999999999999999999999999999999999999999999999999999999999999999999999999986
 
-.. function:: get_rounding(T)
+.. function:: rounding(T)
 
    .. Docstring generated from Julia source
 
-   Get the current floating point rounding mode for type ``T``, controlling
-   the rounding of basic arithmetic functions (:func:`+`, :func:`-`,
-   :func:`*`, :func:`/` and :func:`sqrt`) and type conversion.
+   Get the current floating point rounding mode for type ``T``\ , controlling the rounding of basic arithmetic functions (:func:`+`\ , :func:`-`\ , :func:`*`\ , :func:`/` and :func:`sqrt`\ ) and type conversion.
 
-   Valid modes are ``RoundNearest``, ``RoundToZero``, ``RoundUp``,
-   ``RoundDown``, and ``RoundFromZero`` (``BigFloat`` only).
+   Valid modes are ``RoundNearest``\ , ``RoundToZero``\ , ``RoundUp``\ , ``RoundDown``\ , and ``RoundFromZero`` (``BigFloat`` only).
 
-.. function:: set_rounding(T, mode)
+.. function:: setrounding(T, mode)
 
    .. Docstring generated from Julia source
 
-   Set the rounding mode of floating point type ``T``, controlling the
-   rounding of basic arithmetic functions (:func:`+`, :func:`-`, :func:`*`,
-   :func:`/` and :func:`sqrt`) and type conversion.
+   Set the rounding mode of floating point type ``T``\ , controlling the rounding of basic arithmetic functions (:func:`+`\ , :func:`-`\ , :func:`*`\ , :func:`/` and :func:`sqrt`\ ) and type conversion.
 
-   Note that this may affect other types, for instance changing the rounding
-   mode of ``Float64`` will change the rounding mode of ``Float32``. See
-   ``get_rounding`` for available modes
+   Note that this may affect other types, for instance changing the rounding mode of ``Float64`` will change the rounding mode of ``Float32``\ . See ``rounding`` for available modes
 
-.. function:: with_rounding(f::Function, T, mode)
+.. function:: setrounding(f::Function, T, mode)
 
    .. Docstring generated from Julia source
 
@@ -375,12 +359,12 @@ General Number Functions and Constants
 
    .. code-block:: julia
 
-       old = get_rounding(T)
-       set_rounding(T, mode)
+       old = rounding(T)
+       setrounding(T, mode)
        f()
-       set_rounding(T, old)
+       setrounding(T, old)
 
-   See ``get_rounding`` for available rounding modes.
+   See ``rounding`` for available rounding modes.
 
 .. function:: get_zero_subnormals() -> Bool
 
@@ -537,30 +521,32 @@ The ``BigFloat`` type implements arbitrary-precision floating-point arithmetic u
 
    Get the precision of a floating point number, as defined by the effective number of bits in the mantissa.
 
-.. function:: get_bigfloat_precision()
+.. function:: precision(BigFloat)
 
    .. Docstring generated from Julia source
 
    Get the precision (in bits) currently used for ``BigFloat`` arithmetic.
 
-.. function:: set_bigfloat_precision(x::Int64)
+.. function:: setprecision([T=BigFloat,] precision::Int)
 
    .. Docstring generated from Julia source
 
-   Set the precision (in bits) to be used to ``BigFloat`` arithmetic.
+   Set the precision (in bits) to be used for ``T`` arithmetic.
 
-.. function:: with_bigfloat_precision(f::Function,precision::Integer)
+.. function:: setprecision(f::Function, [T=BigFloat,] precision::Integer)
 
    .. Docstring generated from Julia source
 
-   Change the ``BigFloat`` arithmetic precision (in bits) for the duration of ``f``\ . It is logically equivalent to:
+   Change the ``T`` arithmetic precision (in bits) for the duration of ``f``\ . It is logically equivalent to:
 
    .. code-block:: julia
 
-       old = get_bigfloat_precision()
-       set_bigfloat_precision(precision)
+       old = precision(BigFloat)
+       setprecision(BigFloat, precision)
        f()
-       set_bigfloat_precision(old)
+       setprecision(BigFloat, old)
+
+   Often used as ``setprecision(T, precision) do ... end``
 
 .. _random-numbers:
 
@@ -605,8 +591,8 @@ As ``BigInt`` represents unbounded integers, the interval must be specified (e.g
 
    Pick a random element or array of random elements from the set of values specified by ``S``\ ; ``S`` can be
 
-     * an indexable collection (for example ``1:n`` or ``['x','y','z']``\ ), or
-     * a type: the set of values to pick from is then equivalent to ``typemin(S):typemax(S)`` for integers (this is not applicable to ``BigInt``\ ), and to :math:`[0, 1)` for floating point numbers;
+   * an indexable collection (for example ``1:n`` or ``['x','y','z']``\ ), or
+   * a type: the set of values to pick from is then equivalent to ``typemin(S):typemax(S)`` for   integers (this is not applicable to ``BigInt``\ ), and to :math:`[0, 1)` for floating point numbers;
 
    ``S`` defaults to ``Float64``\ .
 
diff --git a/doc/stdlib/parallel.rst b/doc/stdlib/parallel.rst
index 6075736808aa8..2174c42b99bca 100644
--- a/doc/stdlib/parallel.rst
+++ b/doc/stdlib/parallel.rst
@@ -97,7 +97,7 @@ Tasks
 
    .. Docstring generated from Julia source
 
-   Wrap an expression in a ``Task`` and add it to the scheduler's queue.
+   Wrap an expression in a ``Task`` and add it to the local machine's scheduler queue.
 
 .. function:: @task
 
@@ -137,8 +137,8 @@ Tasks
 
    Other constructors:
 
-     * ``Channel()`` - equivalent to ``Channel{Any}(32)``
-     * ``Channel(sz::Int)`` equivalent to ``Channel{Any}(sz)``
+   * ``Channel()`` - equivalent to ``Channel{Any}(32)``
+   * ``Channel(sz::Int)`` equivalent to ``Channel{Any}(sz)``
 
 General Parallel Computing Support
 ----------------------------------
@@ -147,8 +147,7 @@ General Parallel Computing Support
 
    .. Docstring generated from Julia source
 
-   Launches workers using the in-built ``LocalManager`` which only launches workers on the local host.
-   This can be used to take advantage of multiple cores. ``addprocs(4)`` will add 4 processes on the local machine.
+   Launches workers using the in-built ``LocalManager`` which only launches workers on the local host. This can be used to take advantage of multiple cores. ``addprocs(4)`` will add 4 processes on the local machine.
 
 .. function:: addprocs() -> List of process identifiers
 
@@ -156,48 +155,51 @@ General Parallel Computing Support
 
    Equivalent to ``addprocs(CPU_CORES)``
 
-   Note that workers do not run a `.juliarc.jl` startup script, nor do they synchronize their global state
-   (such as global variables, new method definitions, and loaded modules) with any of the other running processes.
+   Note that workers do not run a ``.juliarc.jl`` startup script, nor do they synchronize their global state (such as global variables, new method definitions, and loaded modules) with any of the other running processes.
 
-.. function:: addprocs(machines; tunnel=false, sshflags=``, max_parallel=10, exeflags=``) -> List of process identifiers
+.. function:: addprocs(machines; keyword_args...) -> List of process identifiers
 
    .. Docstring generated from Julia source
 
-   Add processes on remote machines via SSH.
-   Requires julia to be installed in the same location on each node, or to be available via a shared file system.
+   Add processes on remote machines via SSH. Requires julia to be installed in the same location on each node, or to be available via a shared file system.
 
    ``machines`` is a vector of machine specifications.  Worker are started for each specification.
 
-   A machine specification is either a string ``machine_spec`` or a tuple - ``(machine_spec, count)``
+   A machine specification is either a string ``machine_spec`` or a tuple - ``(machine_spec, count)``\ .
 
-   ``machine_spec`` is a string of the form ``[user@]host[:port] [bind_addr[:port]]``. ``user`` defaults
-   to current user, ``port`` to the standard ssh port. If ``[bind_addr[:port]]`` is specified, other
-   workers will connect to this worker at the specified ``bind_addr`` and ``port``.
-
-   ``count`` is the number of workers to be launched on the specified host. If specified as ``:auto``
-   it will launch as many workers as the number of cores on the specific host.
+   ``machine_spec`` is a string of the form ``[user@]host[:port] [bind_addr[:port]]``\ . ``user`` defaults to current user, ``port`` to the standard ssh port. If ``[bind_addr[:port]]`` is specified, other workers will connect to this worker at the specified ``bind_addr`` and ``port``\ .
 
+   ``count`` is the number of workers to be launched on the specified host. If specified as ``:auto`` it will launch as many workers as the number of cores on the specific host.
 
    Keyword arguments:
 
-   ``tunnel`` : if ``true`` then SSH tunneling will be used to connect to the worker from the master process.
+   * ``tunnel``\ : if ``true`` then SSH tunneling will be used to connect to the worker from the             master process. Default is ``false``\ .
+
+   * ``sshflags``\ : specifies additional ssh options, e.g.
+
+   .. code-block:: julia
+
+       sshflags=`-i /home/foo/bar.pem`
 
-   ``sshflags`` : specifies additional ssh options, e.g. :literal:`sshflags=\`-i /home/foo/bar.pem\`` .
+   * ``max_parallel``\ : specifies the maximum number of workers connected to in parallel at a host.                   Defaults to 10.
 
-   ``max_parallel`` : specifies the maximum number of workers connected to in parallel at a host. Defaults to 10.
+   * ``dir``\ : specifies the working directory on the workers. Defaults to the host's current          directory (as found by ``pwd()``\ )
 
-   ``dir`` :  specifies the working directory on the workers. Defaults to the host's current directory (as found by ``pwd()``)
+   * ``exename``\ : name of the julia executable. Defaults to ``"$JULIA_HOME/julia"`` or              ``"$JULIA_HOME/julia-debug"`` as the case may be.
 
-   ``exename`` :  name of the julia executable. Defaults to "$JULIA_HOME/julia" or "$JULIA_HOME/julia-debug" as the case may be.
+   * ``exeflags``\ : additional flags passed to the worker processes.
 
-   ``exeflags`` :  additional flags passed to the worker processes.
+   * ``topology``\ : Specifies how the workers connect to each other. Sending a message             between unconnected workers results in an error.
+
+   * ``topology=:all_to_all``  :  All processes are connected to each other.                       This is the default.
+
+   * ``topology=:master_slave``  :  Only the driver process, i.e. pid 1 connects to the                         workers. The workers do not connect to each other.
+
+   * ``topology=:custom``  :  The ``launch`` method of the cluster manager specifes the                   connection topology via fields ``ident`` and ``connect_idents`` in                   ``WorkerConfig``\ . A worker with a cluster manager identity ``ident``                   will connect to all workers specified in ``connect_idents``\ .
 
    Environment variables :
 
-   If the master process fails to establish a connection with a newly launched worker within 60.0 seconds,
-   the worker treats it a fatal situation and terminates. This timeout can be controlled via environment
-   variable ``JULIA_WORKER_TIMEOUT``. The value of ``JULIA_WORKER_TIMEOUT`` on the master process, specifies
-   the number of seconds a newly launched worker waits for connection establishment.
+   If the master process fails to establish a connection with a newly launched worker within 60.0 seconds, the worker treats it a fatal situation and terminates. This timeout can be controlled via environment variable ``JULIA_WORKER_TIMEOUT``\ . The value of ``JULIA_WORKER_TIMEOUT`` on the master process, specifies the number of seconds a newly launched worker waits for connection establishment.
 
 .. function:: addprocs(manager::ClusterManager; kwargs...) -> List of process identifiers
 
@@ -205,10 +207,9 @@ General Parallel Computing Support
 
    Launches worker processes via the specified cluster manager.
 
-   For example Beowulf clusters are  supported via a custom cluster manager implemented in package ``ClusterManagers``.
+   For example Beowulf clusters are  supported via a custom cluster manager implemented in package ``ClusterManagers``\ .
 
-   The number of seconds a newly launched worker waits for connection establishment from the master can be
-   specified via variable ``JULIA_WORKER_TIMEOUT`` in the worker process's environment. Relevant only when using TCP/IP as transport.
+   The number of seconds a newly launched worker waits for connection establishment from the master can be specified via variable ``JULIA_WORKER_TIMEOUT`` in the worker process's environment. Relevant only when using TCP/IP as transport.
 
 .. function:: nprocs()
 
@@ -256,19 +257,47 @@ General Parallel Computing Support
 
    .. Docstring generated from Julia source
 
-   Transform collections ``lsts`` by applying ``f`` to each element in parallel.
-   (Note that ``f`` must be made available to all worker processes; see :ref:`Code Availability and Loading Packages <man-parallel-computing-code-availability>` for details.)
-   If ``nprocs() > 1``, the calling process will be dedicated to assigning tasks.
-   All other available processes will be used as parallel workers, or on the processes specified by ``pids``.
+   Transform collections ``lsts`` by applying ``f`` to each element in parallel. (Note that ``f`` must be made available to all worker processes; see :ref:`Code Availability and Loading Packages <man-parallel-computing-code-availability>` for details.) If ``nprocs() > 1``\ , the calling process will be dedicated to assigning tasks. All other available processes will be used as parallel workers, or on the processes specified by ``pids``\ .
 
-   If ``err_retry`` is ``true``, it retries a failed application of ``f`` on a different worker.
-   If ``err_stop`` is ``true``, it takes precedence over the value of ``err_retry`` and ``pmap`` stops execution on the first error.
+   If ``err_retry`` is ``true``\ , it retries a failed application of ``f`` on a different worker. If ``err_stop`` is ``true``\ , it takes precedence over the value of ``err_retry`` and ``pmap`` stops execution on the first error.
 
-.. function:: remotecall(id, func, args...)
+.. function:: remotecall(func, id, args...)
 
    .. Docstring generated from Julia source
 
-   Call a function asynchronously on the given arguments on the specified process. Returns a ``RemoteRef``\ .
+   Call a function asynchronously on the given arguments on the specified process. Returns a ``Future``\ .
+
+.. function:: Future()
+
+   .. Docstring generated from Julia source
+
+   Create a ``Future`` on the local machine.
+
+.. function:: Future(n)
+
+   .. Docstring generated from Julia source
+
+   Create a ``Future`` on process ``n``\ .
+
+.. function:: RemoteChannel()
+
+   .. Docstring generated from Julia source
+
+   Make an reference to a ``Channel{Any}(1)`` on the local machine.
+
+.. function:: RemoteChannel(n)
+
+   .. Docstring generated from Julia source
+
+   Make an reference to a ``Channel{Any}(1)`` on process ``n``\ .
+
+.. function:: RemoteChannel(f::Function, pid)
+
+   .. Docstring generated from Julia source
+
+   Create references to remote channels of a specific size and type. ``f()`` is a function that when executed on ``pid`` must return an implementation of an ``AbstractChannel``\ .
+
+   For example, ``RemoteChannel(()->Channel{Int}(10), pid)``\ , will return a reference to a channel of type ``Int`` and size 10 on ``pid``\ .
 
 .. function:: wait([x])
 
@@ -276,14 +305,15 @@ General Parallel Computing Support
 
    Block the current task until some event occurs, depending on the type of the argument:
 
-     * ``RemoteRef``\ : Wait for a value to become available for the specified remote reference.
-     * ``Channel``\ : Wait for a value to be appended to the channel.
-     * ``Condition``\ : Wait for ``notify`` on a condition.
-     * ``Process``\ : Wait for a process or process chain to exit. The ``exitcode`` field of a process can be used to determine success or failure.
-     * ``Task``\ : Wait for a ``Task`` to finish, returning its result value. If the task fails with an exception, the exception is propagated (re-thrown in the task that called ``wait``\ ).
-     * ``RawFD``\ : Wait for changes on a file descriptor (see ``poll_fd`` for keyword arguments and return code)
+   * ``RemoteChannel`` : Wait for a value to become available on the specified remote channel.
+   * ``Future`` : Wait for a value to become available for the specified future.
+   * ``Channel``\ : Wait for a value to be appended to the channel.
+   * ``Condition``\ : Wait for ``notify`` on a condition.
+   * ``Process``\ : Wait for a process or process chain to exit. The ``exitcode`` field of a process   can be used to determine success or failure.
+   * ``Task``\ : Wait for a ``Task`` to finish, returning its result value. If the task fails with an   exception, the exception is propagated (re-thrown in the task that called ``wait``\ ).
+   * ``RawFD``\ : Wait for changes on a file descriptor (see ``poll_fd`` for keyword arguments and return code)
 
-   If no argument is passed, the task blocks for an undefined period. If the task's state is set to ``:waiting``\ , it can only be restarted by an explicit call to ``schedule`` or ``yieldto``\ . If the task's state is ``:runnable``\ , it might be restarted unpredictably.
+   If no argument is passed, the task blocks for an undefined period. A task can only be restarted by an explicit call to ``schedule`` or ``yieldto``\ .
 
    Often ``wait`` is called within a ``while`` loop to ensure a waited-for condition is met before proceeding.
 
@@ -293,26 +323,33 @@ General Parallel Computing Support
 
    Waits and fetches a value from ``x`` depending on the type of ``x``\ . Does not remove the item fetched:
 
-     * ``RemoteRef``\ : Wait for and get the value of a remote reference. If the remote value is an exception, throws a ``RemoteException`` which captures the remote exception and backtrace.
-     * ``Channel`` : Wait for and get the first available item from the channel.
+   * ``Future``\ : Wait for and get the value of a Future. The fetched value is cached locally.   Further calls to ``fetch`` on the same reference return the cached value. If the remote value   is an exception, throws a ``RemoteException`` which captures the remote exception and backtrace.
+   * ``RemoteChannel``\ : Wait for and get the value of a remote reference. Exceptions raised are   same as for a ``Future`` .
+   * ``Channel`` : Wait for and get the first available item from the channel.
 
-.. function:: remotecall_wait(id, func, args...)
+.. function:: remotecall_wait(func, id, args...)
 
    .. Docstring generated from Julia source
 
    Perform ``wait(remotecall(...))`` in one message.
 
-.. function:: remotecall_fetch(id, func, args...)
+.. function:: remotecall_fetch(func, id, args...)
 
    .. Docstring generated from Julia source
 
    Perform ``fetch(remotecall(...))`` in one message. Any remote exceptions are captured in a ``RemoteException`` and thrown.
 
-.. function:: put!(RemoteRef, value)
+.. function:: put!(RemoteChannel, value)
+
+   .. Docstring generated from Julia source
+
+   Store a value to the remote channel. If the channel is full, blocks until space is available. Returns its first argument.
+
+.. function:: put!(Future, value)
 
    .. Docstring generated from Julia source
 
-   Store a value to a remote reference. Implements "shared queue of length 1" semantics: if a value is already present, blocks until the value is removed with ``take!``\ . Returns its first argument.
+   Store a value to a future. Future's are write-once remote references. A ``put!`` on an already set ``Future`` throws an Exception. All asynchronous remote calls return ``Future``\ s and set the value to the return value of the call upon completion.
 
 .. function:: put!(Channel, value)
 
@@ -320,11 +357,11 @@ General Parallel Computing Support
 
    Appends an item to the channel. Blocks if the channel is full.
 
-.. function:: take!(RemoteRef)
+.. function:: take!(RemoteChannel)
 
    .. Docstring generated from Julia source
 
-   Fetch the value of a remote reference, removing it so that the reference is empty again.
+   Fetch a value from a remote channel, also removing it in the processs.
 
 .. function:: take!(Channel)
 
@@ -332,40 +369,34 @@ General Parallel Computing Support
 
    Removes and returns a value from a ``Channel``\ . Blocks till data is available.
 
-.. function:: isready(r::RemoteRef)
+.. function:: isready(r::RemoteChannel)
 
    .. Docstring generated from Julia source
 
-   Determine whether a ``RemoteRef`` has a value stored to it. Note that this function can cause race conditions, since by the time you receive its result it may no longer be true. It is recommended that this function only be used on a ``RemoteRef`` that is assigned once.
+   Determine whether a ``RemoteChannel`` has a value stored to it. Note that this function can cause race conditions, since by the time you receive its result it may no longer be true. However, it can be safely used on a ``Future`` since they are assigned only once.
 
-   If the argument ``RemoteRef`` is owned by a different node, this call will block to wait for the answer. It is recommended to wait for ``r`` in a separate task instead, or to use a local ``RemoteRef`` as a proxy:
-
-   .. code-block:: julia
-
-       rr = RemoteRef()
-       @async put!(rr, remotecall_fetch(p, long_computation))
-       isready(rr)  # will not block
-
-.. function:: close(Channel)
+.. function:: isready(r::Future)
 
    .. Docstring generated from Julia source
 
-   Closes a channel. An exception is thrown by:
-
-     * ``put!`` on a closed channel.
-     * ``take!`` and ``fetch`` on an empty, closed channel.
+   Determine whether a ``Future`` has a value stored to it.
 
-.. function:: RemoteRef()
+   If the argument ``Future`` is owned by a different node, this call will block to wait for the answer. It is recommended to wait for ``r`` in a separate task instead, or to use a local ``Channel`` as a proxy:
 
-   .. Docstring generated from Julia source
+   .. code-block:: julia
 
-   Make an uninitialized remote reference on the local machine.
+       c = Channel(1)
+       @async put!(c, remotecall_fetch(long_computation, p))
+       isready(c)  # will not block
 
-.. function:: RemoteRef(n)
+.. function:: close(Channel)
 
    .. Docstring generated from Julia source
 
-   Make an uninitialized remote reference on process ``n``\ .
+   Closes a channel. An exception is thrown by:
+
+   * ``put!`` on a closed channel.
+   * ``take!`` and ``fetch`` on an empty, closed channel.
 
 .. function:: timedwait(testcb::Function, secs::Float64; pollint::Float64=0.1)
 
@@ -377,13 +408,13 @@ General Parallel Computing Support
 
    .. Docstring generated from Julia source
 
-   Creates a closure around an expression and runs it on an automatically-chosen process, returning a ``RemoteRef`` to the result.
+   Creates a closure around an expression and runs it on an automatically-chosen process, returning a ``Future`` to the result.
 
 .. function:: @spawnat
 
    .. Docstring generated from Julia source
 
-   Accepts two arguments, ``p`` and an expression. A closure is created around the expression and run asynchronously on process ``p``\ . Returns a ``RemoteRef`` to the result.
+   Accepts two arguments, ``p`` and an expression. A closure is created around the expression and run asynchronously on process ``p``\ . Returns a ``Future`` to the result.
 
 .. function:: @fetch
 
@@ -401,7 +432,7 @@ General Parallel Computing Support
 
    .. Docstring generated from Julia source
 
-   Wraps an expression in a closure and schedules it to run on the local machine. Also adds it to the set of items that the nearest enclosing ``@sync`` waits for.
+   Like ``@schedule``\ , ``@async`` wraps an expression in a ``Task`` and adds it to the local machine's scheduler queue. Additionally it adds the task to the set of items that the nearest enclosing ``@sync`` waits for. ``@async`` also wraps the expression in a ``let x=x, y=y, ...`` block to create a new scope with copies of all variables referenced in the expression.
 
 .. function:: @sync
 
@@ -437,8 +468,26 @@ General Parallel Computing Support
 
    Execute an expression on all processes. Errors on any of the processes are collected into a ``CompositeException`` and thrown.
 
-Shared Arrays (Experimental, UNIX-only feature)
------------------------------------------------
+.. function:: Base.remoteref_id(r::AbstractRemoteRef) -> (whence, id)
+
+   .. Docstring generated from Julia source
+
+   A low-level API which returns the unique identifying tuple for a remote reference. A reference id is a tuple of two elements - pid where the reference was created from and a one-up number from that node.
+
+.. function:: Base.channel_from_id(refid) -> c
+
+   .. Docstring generated from Julia source
+
+   A low-level API which returns the backing AbstractChannel for an id returned by ``remoteref_id``\ . The call is valid only on the node where the backing channel exists.
+
+.. function:: Base.worker_id_from_socket(s::IO) -> pid
+
+   .. Docstring generated from Julia source
+
+   A low-level API which given a ``IO`` connection, returns the pid of the worker it is connected to. This is useful when writing custom ``serialize`` methods for a type, which optimizes the data written out depending on the receiving process id.
+
+Shared Arrays
+-------------
 
 .. function:: SharedArray(T::Type, dims::NTuple; init=false, pids=Int[])
 
@@ -450,17 +499,33 @@ Shared Arrays (Experimental, UNIX-only feature)
 
    If an ``init`` function of the type ``initfn(S::SharedArray)`` is specified, it is called on all the participating workers.
 
+.. function:: SharedArray(filename::AbstractString, T::Type, dims::NTuple, [offset=0]; mode=nothing, init=false, pids=Int[])
+
+   .. Docstring generated from Julia source
+
+   Construct a ``SharedArray`` backed by the file ``filename``\ , with element type ``T`` (must be a ``bitstype``\ ) and size ``dims``\ , across the processes specified by ``pids`` - all of which have to be on the same host. This file is mmapped into the host memory, with the following consequences:
+
+   * The array data must be represented in binary format (e.g., an ASCII   format like CSV cannot be supported)
+
+   * Any changes you make to the array values (e.g., ``A[3] = 0``\ ) will   also change the values on disk
+
+   If ``pids`` is left unspecified, the shared array will be mapped across all processes on the current host, including the master. But, ``localindexes`` and ``indexpids`` will only refer to worker processes. This facilitates work distribution code to use workers for actual computation with the master process acting as a driver.
+
+   ``mode`` must be one of ``"r"``\ , ``"r+"``\ , ``"w+"``\ , or ``"a+"``\ , and defaults to ``"r+"`` if the file specified by ``filename`` already exists, or ``"w+"`` if not. If an ``init`` function of the type ``initfn(S::SharedArray)`` is specified, it is called on all the participating workers. You cannot specify an ``init`` function if the file is not writable.
+
+   ``offset`` allows you to skip the specified number of bytes at the beginning of the file.
+
 .. function:: procs(S::SharedArray)
 
    .. Docstring generated from Julia source
 
-   Get the vector of processes that have mapped the shared array
+   Get the vector of processes that have mapped the shared array.
 
 .. function:: sdata(S::SharedArray)
 
    .. Docstring generated from Julia source
 
-   Returns the actual ``Array`` object backing ``S``
+   Returns the actual ``Array`` object backing ``S``\ .
 
 .. function:: indexpids(S::SharedArray)
 
@@ -468,12 +533,21 @@ Shared Arrays (Experimental, UNIX-only feature)
 
    Returns the index of the current worker into the ``pids`` vector, i.e., the list of workers mapping the SharedArray
 
+.. function:: localindexes(S::SharedArray)
+
+   .. Docstring generated from Julia source
+
+   Returns a range describing the "default" indexes to be handled by the current process.  This range should be interpreted in the sense of linear indexing, i.e., as a sub-range of ``1:length(S)``\ .  In multi-process contexts, returns an empty range in the parent process (or any process for which ``indexpids`` returns 0).
+
+   It's worth emphasizing that ``localindexes`` exists purely as a convenience, and you can partition work on the array among workers any way you wish.  For a SharedArray, all indexes should be equally fast for each worker process.
+
 Cluster Manager Interface
 -------------------------
-    This interface provides a mechanism to launch and manage Julia workers on different cluster environments.
-    LocalManager, for launching additional workers on the same host and SSHManager, for launching on remote
-    hosts via ssh are present in Base. TCP/IP sockets are used to connect and transport messages
-    between processes. It is possible for Cluster Managers to provide a different transport.
+
+This interface provides a mechanism to launch and manage Julia workers on different cluster environments.
+LocalManager, for launching additional workers on the same host and SSHManager, for launching on remote
+hosts via ssh are present in Base. TCP/IP sockets are used to connect and transport messages
+between processes. It is possible for Cluster Managers to provide a different transport.
 
 .. function:: launch(manager::FooManager, params::Dict, launched::Vector{WorkerConfig}, launch_ntfy::Condition)
 
@@ -485,15 +559,11 @@ Cluster Manager Interface
 
    .. Docstring generated from Julia source
 
-   Implemented by cluster managers. It is called on the master process, during a worker's lifetime,
-   with appropriate ``op`` values:
+   Implemented by cluster managers. It is called on the master process, during a worker's lifetime, with appropriate ``op`` values:
 
-       - with ``:register``/``:deregister`` when a worker is added / removed
-         from the Julia worker pool.
-       - with ``:interrupt`` when ``interrupt(workers)`` is called. The
-         :class:`ClusterManager` should signal the appropriate worker with an
-         interrupt signal.
-       - with ``:finalize`` for cleanup purposes.
+   * with ``:register``\ /``:deregister`` when a worker is added / removed from the Julia worker pool.
+   * with ``:interrupt`` when ``interrupt(workers)`` is called. The :class:`ClusterManager`   should signal the appropriate worker with an interrupt signal.
+   * with ``:finalize`` for cleanup purposes.
 
 .. function:: kill(manager::FooManager, pid::Int, config::WorkerConfig)
 
diff --git a/doc/stdlib/pkg.rst b/doc/stdlib/pkg.rst
index 28c2d8262d8de..6c9f36ab8b12c 100644
--- a/doc/stdlib/pkg.rst
+++ b/doc/stdlib/pkg.rst
@@ -7,11 +7,13 @@
 All package manager functions are defined in the ``Pkg`` module. None of the ``Pkg`` module's functions are exported;
 to use them, you'll need to prefix each function call with an explicit ``Pkg.``, e.g. ``Pkg.status()`` or ``Pkg.dir()``.
 
+Functions for package development (e.g. ``tag``, ``publish``, etc.) have been moved to the `PkgDev <https://github.com/JuliaLang/PkgDev.jl>`_ package. See `PkgDev README <https://github.com/JuliaLang/PkgDev.jl/blob/master/README.md#usage>`_ for the documentation of those functions.
+
 .. function:: dir() -> AbstractString
 
    .. Docstring generated from Julia source
 
-   Returns the absolute path of the package directory. This defaults to ``joinpath(homedir(),".julia","v$(VERSION.major).$(VERSION.minor)")`` on all platforms (i.e. ``~/.julia/v0.4`` in UNIX shell syntax). If the ``JULIA_PKGDIR`` environment variable is set, then that path is used in the returned value as ``joinpath(ENV["JULIA_PKGDIR"],"v$(VERSION.major).$(VERSION.minor)")``\ . If ``JULIA_PKGDIR`` is a relative path, it is interpreted relative to whatever the current working directory is.
+   Returns the absolute path of the package directory. This defaults to ``joinpath(homedir(),".julia","v$(VERSION.major).$(VERSION.minor)")`` on all platforms (i.e. ``~/.julia/v0.5`` in UNIX shell syntax). If the ``JULIA_PKGDIR`` environment variable is set, then that path is used in the returned value as ``joinpath(ENV["JULIA_PKGDIR"],"v$(VERSION.major).$(VERSION.minor)")``\ . If ``JULIA_PKGDIR`` is a relative path, it is interpreted relative to whatever the current working directory is.
 
 .. function:: dir(names...) -> AbstractString
 
@@ -53,7 +55,7 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
 
    .. Docstring generated from Julia source
 
-   Clone a package directly from the git URL ``url``\ . The package does not need to be a registered in ``Pkg.dir("METADATA")``\ . The package repo is cloned by the name ``pkg`` if provided; if not provided, ``pkg`` is determined automatically from ``url``\ .
+   Clone a package directly from the git URL ``url``\ . The package does not need to be registered in ``Pkg.dir("METADATA")``\ . The package repo is cloned by the name ``pkg`` if provided; if not provided, ``pkg`` is determined automatically from ``url``\ .
 
 .. function:: clone(pkg)
 
@@ -61,6 +63,12 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
 
    If ``pkg`` has a URL registered in ``Pkg.dir("METADATA")``\ , clone it from that URL on the default branch. The package does not need to have any registered versions.
 
+.. function:: setprotocol!(proto)
+
+   .. Docstring generated from Julia source
+
+   Set the protocol used to access GitHub-hosted packages. Defaults to 'https', with a blank ``proto`` delegating the choice to the package developer.
+
 .. function:: available() -> Vector{ASCIIString}
 
    .. Docstring generated from Julia source
@@ -95,13 +103,13 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
 
    .. Docstring generated from Julia source
 
-   Update package the metadata repo – kept in ``Pkg.dir("METADATA")`` – then update any fixed packages that can safely be pulled from their origin; then call ``Pkg.resolve()`` to determine a new optimal set of packages versions.
+   Update the metadata repo – kept in ``Pkg.dir("METADATA")`` – then update any fixed packages that can safely be pulled from their origin; then call ``Pkg.resolve()`` to determine a new optimal set of packages versions.
 
-.. function:: checkout(pkg, [branch="master"])
+.. function:: checkout(pkg, [branch="master"]; merge=true, pull=true)
 
    .. Docstring generated from Julia source
 
-   Checkout the ``Pkg.dir(pkg)`` repo to the branch ``branch``\ . Defaults to checking out the "master" branch. To go back to using the newest compatible released version, use ``Pkg.free(pkg)``
+   Checkout the ``Pkg.dir(pkg)`` repo to the branch ``branch``\ . Defaults to checking out the "master" branch. To go back to using the newest compatible released version, use ``Pkg.free(pkg)``\ . Changes are merged (fast-forward only) if the keyword argument ``merge == true``\ , and the latest version is pulled from the upstream repo if ``pull == true``\ .
 
 .. function:: pin(pkg)
 
@@ -135,30 +143,6 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
 
    Run the build script in ``deps/build.jl`` for each package in ``pkgs`` and all of their dependencies in depth-first recursive order. This is called automatically by ``Pkg.resolve()`` on all installed or updated packages.
 
-.. function:: generate(pkg,license)
-
-   .. Docstring generated from Julia source
-
-   Generate a new package named ``pkg`` with one of these license keys: ``"MIT"``\ , ``"BSD"`` or ``"ASL"``\ . If you want to make a package with a different license, you can edit it afterwards. Generate creates a git repo at ``Pkg.dir(pkg)`` for the package and inside it ``LICENSE.md``\ , ``README.md``\ , ``REQUIRE``\ , the julia entrypoint ``$pkg/src/$pkg.jl``\ , and Travis and AppVeyor CI configuration files ``.travis.yml`` and ``appveyor.yml``\ .
-
-.. function:: register(pkg, [url])
-
-   .. Docstring generated from Julia source
-
-   Register ``pkg`` at the git URL ``url``\ , defaulting to the configured origin URL of the git repo ``Pkg.dir(pkg)``\ .
-
-.. function:: tag(pkg, [ver, [commit]])
-
-   .. Docstring generated from Julia source
-
-   Tag ``commit`` as version ``ver`` of package ``pkg`` and create a version entry in ``METADATA``\ . If not provided, ``commit`` defaults to the current commit of the ``pkg`` repo. If ``ver`` is one of the symbols ``:patch``\ , ``:minor``\ , ``:major`` the next patch, minor or major version is used. If ``ver`` is not provided, it defaults to ``:patch``\ .
-
-.. function:: publish()
-
-   .. Docstring generated from Julia source
-
-   For each new package version tagged in ``METADATA`` not already published, make sure that the tagged package commits have been pushed to the repo at the registered URL for the package and if they all have, open a pull request to ``METADATA``\ .
-
 .. function:: test()
 
    .. Docstring generated from Julia source
diff --git a/doc/stdlib/profile.rst b/doc/stdlib/profile.rst
index 4e55cea5351d9..1ebe73407e40b 100644
--- a/doc/stdlib/profile.rst
+++ b/doc/stdlib/profile.rst
@@ -24,26 +24,19 @@ The methods in :mod:`Base.Profile` are not exported and need to be called e.g. a
 
    Clear any existing backtraces from the internal buffer.
 
-.. function:: print([io::IO = STDOUT,] [data::Vector]; format = :tree, C = false, combine = true, cols = tty_cols())
+.. function:: print([io::IO = STDOUT,] [data::Vector]; format = :tree, C = false, combine = true, maxdepth = typemax(Int), sortedby = :filefuncline)
 
    .. Docstring generated from Julia source
 
-   Prints profiling results to ``io`` (by default, ``STDOUT``). If you
-   do not supply a ``data`` vector, the internal buffer of accumulated
-   backtraces will be used.  ``format`` can be ``:tree`` or
-   ``:flat``. If ``C==true``, backtraces from C and Fortran code are
-   shown. ``combine==true`` merges instruction pointers that
-   correspond to the same line of code.  ``cols`` controls the width
-   of the display.
+   Prints profiling results to ``io`` (by default, ``STDOUT``\ ). If you do not supply a ``data`` vector, the internal buffer of accumulated backtraces will be used. ``format`` can be ``:tree`` or ``:flat``\ . If ``C==true``\ , backtraces from C and Fortran code are shown. ``combine==true`` merges instruction pointers that correspond to the same line of code. ``maxdepth`` can be used to limit the depth of printing in ``:tree`` format, while ``sortedby`` can be used to control the order in ``:flat`` format (``:filefuncline`` sorts by the source line, whereas ``:count`` sorts in order of number of collected samples).
 
-.. function:: print([io::IO = STDOUT,] data::Vector, lidict::Dict; format = :tree, combine = true, cols = tty_cols())
+.. function:: print([io::IO = STDOUT,] data::Vector, lidict::Dict; kwargs)
 
    .. Docstring generated from Julia source
 
-   Prints profiling results to ``io``. This variant is used to examine
-   results exported by a previous call to :func:`retrieve`.
-   Supply the vector ``data`` of backtraces and a dictionary
-   ``lidict`` of line information.
+   Prints profiling results to ``io``\ . This variant is used to examine results exported by a previous call to :func:`retrieve`\ . Supply the vector ``data`` of backtraces and a dictionary ``lidict`` of line information.
+
+   See ``Profile.print([io], data)`` for an explanation of the valid keyword arguments.
 
 .. function:: init(; n::Integer, delay::Float64)
 
@@ -55,13 +48,7 @@ The methods in :mod:`Base.Profile` are not exported and need to be called e.g. a
 
    .. Docstring generated from Julia source
 
-   Returns a reference to the internal buffer of backtraces. Note that
-   subsequent operations, like :func:`clear`, can affect
-   ``data`` unless you first make a copy. Note that the values in
-   ``data`` have meaning only on this machine in the current session,
-   because it depends on the exact memory addresses used in
-   JIT-compiling. This function is primarily for internal use;
-   :func:`retrieve` may be a better choice for most users.
+   Returns a reference to the internal buffer of backtraces. Note that subsequent operations, like :func:`clear`\ , can affect ``data`` unless you first make a copy. Note that the values in ``data`` have meaning only on this machine in the current session, because it depends on the exact memory addresses used in JIT-compiling. This function is primarily for internal use; :func:`retrieve` may be a better choice for most users.
 
 .. function:: retrieve() -> data, lidict
 
@@ -69,26 +56,15 @@ The methods in :mod:`Base.Profile` are not exported and need to be called e.g. a
 
    "Exports" profiling results in a portable format, returning the set of all backtraces (``data``\ ) and a dictionary that maps the (session-specific) instruction pointers in ``data`` to ``LineInfo`` values that store the file name, function name, and line number. This function allows you to save profiling results for future analysis.
 
-.. function:: callers(funcname, [data, lidict], [filename=<filename>], [linerange=<start:stop>]) -> Vector{Tuple{count, linfo}}
+.. function:: callers(funcname, [data, lidict], [filename=<filename>], [linerange=<start:stop>]) -> Vector{Tuple{count, lineinfo}}
 
    .. Docstring generated from Julia source
 
-   Given a previous profiling run, determine who called a particular
-   function. Supplying the filename (and optionally, range of line
-   numbers over which the function is defined) allows you to
-   disambiguate an overloaded method. The returned value is a vector
-   containing a count of the number of calls and line information
-   about the caller.  One can optionally supply backtrace data
-   obtained from :func:`retrieve`; otherwise, the current internal profile
-   buffer is used.
+   Given a previous profiling run, determine who called a particular function. Supplying the filename (and optionally, range of line numbers over which the function is defined) allows you to disambiguate an overloaded method. The returned value is a vector containing a count of the number of calls and line information about the caller. One can optionally supply backtrace ``data`` obtained from :func:`retrieve`\ ; otherwise, the current internal profile buffer is used.
 
 .. function:: clear_malloc_data()
 
    .. Docstring generated from Julia source
 
-   Clears any stored memory allocation data when running julia with
-   ``--track-allocation``.  Execute the command(s) you want to test
-   (to force JIT-compilation), then call :func:`clear_malloc_data`.
-   Then execute your command(s) again, quit Julia, and examine the
-   resulting ``*.mem`` files.
+   Clears any stored memory allocation data when running julia with ``--track-allocation``\ . Execute the command(s) you want to test (to force JIT-compilation), then call :func:`clear_malloc_data`\ . Then execute your command(s) again, quit Julia, and examine the resulting ``*.mem`` files.
 
diff --git a/doc/stdlib/punctuation.rst b/doc/stdlib/punctuation.rst
index 42f987213ccbd..dbabd1ddea7e8 100644
--- a/doc/stdlib/punctuation.rst
+++ b/doc/stdlib/punctuation.rst
@@ -4,46 +4,45 @@
 
 Extended documentation for mathematical symbols & functions is :ref:`here <mathematical-operators>`.
 
-   =========   ================================================
-   symbol      meaning
-   =========   ================================================
-   ``@m``      invoke macro ``m``; followed by space-separated expressions
-   ``!``       prefix "not" operator
-   ``a!( )``   at the end of a function name, `!` indicates that a function modifies its argument(s)
-   ``#``       begin single line comment
-   ``#=``      begin multi-line comment (these are nestable)
-   ``=#``      end multi-line comment
-   ``$``       bitwise xor operator, string and expression interpolation
-   ``%``       remainder operator
-   ``^``       exponent operator
-   ``&``       bitwise and
-   ``&&``      short-circuiting boolean and
-   ``|``       bitwise or
-   ``||``      short-circuiting boolean or
-   ``*``       multiply, or matrix multiply
-   ``()``      the empty tuple
-   ``~``       bitwise not operator
-   ``\``       backslash operator
-   ``'``       complex transpose operator A\ :sup:`H`
-   ``a[]``     array indexing
-   ``[,]``     vertical concatenation
-   ``[;]``     also vertical concatenation
-   ``[  ]``    with space-separated expressions, horizontal concatenation
-   ``T{ }``    parametric type instantiation
-   ``{  }``    construct a cell array (deprecated in 0.4 in favor of ``Any[]``)
-   ``;``       statement separator
-   ``,``       separate function arguments or tuple components
-   ``?``       3-argument conditional operator (conditional ? if_true : if_false)
-   ``""``      delimit string literals
-   ``''``      delimit character literals
-   ``` ```     delimit external process (command) specifications
-   ``...``     splice arguments into a function call or declare a varargs function or type
-   ``.``       access named fields in objects or names inside modules, also prefixes elementwise operators
-   ``a:b``     range a, a+1, a+2, ..., b
-   ``a:s:b``   range a, a+s, a+2s, ..., b
-   ``:``       index an entire dimension (1:end)
-   ``::``      type annotation, depending on context
-   ``:( )``    quoted expression
-   ``:a``      symbol a
-   =========   ================================================
-
+=========   ================================================
+symbol      meaning
+=========   ================================================
+``@m``      invoke macro ``m``; followed by space-separated expressions
+``!``       prefix "not" operator
+``a!( )``   at the end of a function name, ``!`` indicates that a function modifies its argument(s)
+``#``       begin single line comment
+``#=``      begin multi-line comment (these are nestable)
+``=#``      end multi-line comment
+``$``       bitwise xor operator, string and expression interpolation
+``%``       remainder operator
+``^``       exponent operator
+``&``       bitwise and
+``&&``      short-circuiting boolean and
+``|``       bitwise or
+``||``      short-circuiting boolean or
+``*``       multiply, or matrix multiply
+``()``      the empty tuple
+``~``       bitwise not operator
+``\``       backslash operator
+``'``       complex transpose operator A\ :sup:`H`
+``a[]``     array indexing
+``[,]``     vertical concatenation
+``[;]``     also vertical concatenation
+``[  ]``    with space-separated expressions, horizontal concatenation
+``T{ }``    parametric type instantiation
+``{  }``    construct a cell array (deprecated in 0.4 in favor of ``Any[]``)
+``;``       statement separator
+``,``       separate function arguments or tuple components
+``?``       3-argument conditional operator (conditional ? if_true : if_false)
+``""``      delimit string literals
+``''``      delimit character literals
+``` ```     delimit external process (command) specifications
+``...``     splice arguments into a function call or declare a varargs function or type
+``.``       access named fields in objects or names inside modules, also prefixes elementwise operators
+``a:b``     range a, a+1, a+2, ..., b
+``a:s:b``   range a, a+s, a+2s, ..., b
+``:``       index an entire dimension (1:end)
+``::``      type annotation, depending on context
+``:( )``    quoted expression
+``:a``      symbol a
+=========   ================================================
diff --git a/doc/stdlib/sort.rst b/doc/stdlib/sort.rst
index 05d7fb308fe85..60ab3e1aa15be 100644
--- a/doc/stdlib/sort.rst
+++ b/doc/stdlib/sort.rst
@@ -138,24 +138,17 @@ Sorting Functions
 
    .. Docstring generated from Julia source
 
-   Return a permutation vector of indices of ``v`` that puts it in sorted order.
-   Specify ``alg`` to choose a particular sorting algorithm (see Sorting Algorithms).
-   ``MergeSort`` is used by default, and since it is stable, the resulting permutation
-   will be the lexicographically first one that puts the input array into sorted order –
-   i.e. indices of equal elements appear in ascending order. If you choose a non-stable
-   sorting algorithm such as ``QuickSort``, a different permutation that puts the array
-   into order may be returned. The order is specified using the same keywords as ``sort!``.
+   Return a permutation vector of indices of ``v`` that puts it in sorted order. Specify ``alg`` to choose a particular sorting algorithm (see Sorting Algorithms). ``MergeSort`` is used by default, and since it is stable, the resulting permutation will be the lexicographically first one that puts the input array into sorted order – i.e. indices of equal elements appear in ascending order. If you choose a non-stable sorting algorithm such as ``QuickSort``\ , a different permutation that puts the array into order may be returned. The order is specified using the same keywords as ``sort!``\ .
 
-   See also :func:`sortperm!`
+   See also :func:`sortperm!`\ .
 
 .. function:: sortperm!(ix, v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false,] [initialized=false])
 
    .. Docstring generated from Julia source
 
-   Like ``sortperm``, but accepts a preallocated index vector ``ix``.  If ``initialized`` is ``false``
-   (the default), ix is initialized to contain the values ``1:length(v)``.
+   Like ``sortperm``\ , but accepts a preallocated index vector ``ix``\ .  If ``initialized`` is ``false`` (the default), ix is initialized to contain the values ``1:length(v)``\ .
 
-   See also :func:`sortperm`
+   See also :func:`sortperm`\ .
 
 .. function:: sortrows(A, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
 
diff --git a/doc/stdlib/stacktraces.rst b/doc/stdlib/stacktraces.rst
new file mode 100644
index 0000000000000..22ceccbc70ed9
--- /dev/null
+++ b/doc/stdlib/stacktraces.rst
@@ -0,0 +1,71 @@
+.. module:: StackTraces
+
+.. _stdlib-stacktraces:
+
+*************
+ StackTraces
+*************
+
+.. currentmodule:: Base
+
+.. data:: StackFrame
+
+    Stack information representing execution context, with the following fields:
+
+    ``func::Symbol``
+        the name of the function containing the execution context
+
+    ``outer_linfo::Nullable{LambdaInfo}``
+        the LambdaInfo containing the execution context (if it could be found)
+
+    ``file::Symbol``
+        the path to the file containing the execution context
+
+    ``line::Int``
+        the line number in the file containing the execution context
+
+    ``inlined_file::Symbol``
+        the path to the file containing the context for inlined code
+
+    ``inlined_line::Int``
+        the line number in the file containing the context for inlined code
+
+    ``from_c::Bool``
+        true if the code is from C
+
+    ``pointer::Int64``
+        representation of the pointer to the execution context as returned by ``backtrace``
+
+.. data:: StackTrace
+
+    An alias for ``Vector{StackFrame}`` provided for convenience; returned by calls to
+    ``stacktrace`` and ``catch_stacktrace``.
+
+.. function:: stacktrace([trace::Vector{Ptr{Void}},] [c_funcs::Bool=false]) -> StackTrace
+
+   .. Docstring generated from Julia source
+
+   Returns a stack trace in the form of a vector of ``StackFrame``\ s. (By default stacktrace doesn't return C functions, but this can be enabled.) When called without specifying a trace, ``stacktrace`` first calls ``backtrace``\ .
+
+.. function:: catch_stacktrace([c_funcs::Bool=false]) -> StackTrace
+
+   .. Docstring generated from Julia source
+
+   Returns the stack trace for the most recent error thrown, rather than the current execution context.
+
+.. currentmodule:: Base.StackTraces
+
+The following methods and types in :mod:`Base.StackTraces` are not exported and need to be called e.g. as ``StackTraces.lookup(ptr)``.
+
+.. function:: lookup(pointer::Union{Ptr{Void}, UInt}) -> StackFrame
+
+   .. Docstring generated from Julia source
+
+   Given a pointer to an execution context (usually generated by a call to ``backtrace``\ ), looks up stack frame context information.
+
+.. function:: remove_frames!(stack::StackTrace, name::Symbol)
+
+   .. Docstring generated from Julia source
+
+   Takes a ``StackTrace`` (a vector of ``StackFrames``\ ) and a function name (a ``Symbol``\ ) and removes the ``StackFrame`` specified by the function name from the ``StackTrace`` (also removing all frames above the specified function). Primarily used to remove ``StackTraces`` functions from the ``StackTrace`` prior to returning it.
+
diff --git a/doc/stdlib/strings.rst b/doc/stdlib/strings.rst
index cdefe2f971b6f..a5ea3aaef8754 100644
--- a/doc/stdlib/strings.rst
+++ b/doc/stdlib/strings.rst
@@ -104,10 +104,10 @@
 
    Construct a regex, such as ``r"^[a-z]*$"``\ . The regex also accepts one or more flags, listed after the ending quote, to change its behaviour:
 
-     * ``i`` enables case-insensitive matching
-     * ``m`` treats the ``^`` and ``$`` tokens as matching the start and     and end of individual lines, as opposed to the whole string.
-     * ``s`` allows the ``.`` modifier to match newlines.
-     * ``x`` enables "comment mode": whitespace is enabled except when     escaped with ``\``\ , and ``#`` is treated as starting a comment.
+   * ``i`` enables case-insensitive matching
+   * ``m`` treats the ``^`` and ``$`` tokens as matching the start and end of individual lines, as   opposed to the whole string.
+   * ``s`` allows the ``.`` modifier to match newlines.
+   * ``x`` enables "comment mode": whitespace is enabled except when escaped with ``\``\ , and ``#``   is treated as starting a comment.
 
    For example, this regex has all three flags enabled:
 
@@ -136,16 +136,16 @@
 
    Alternatively, finer control and additional transformations may be be obtained by calling ``normalize_string(s; keywords...)``\ , where any number of the following boolean keywords options (which all default to ``false`` except for ``compose``\ ) are specified:
 
-     * ``compose=false``\ : do not perform canonical composition
-     * ``decompose=true``\ : do canonical decomposition instead of canonical composition (``compose=true`` is ignored if present)
-     * ``compat=true``\ : compatibility equivalents are canonicalized
-     * ``casefold=true``\ : perform Unicode case folding, e.g. for case-insensitive string comparison
-     * ``newline2lf=true``\ , ``newline2ls=true``\ , or ``newline2ps=true``\ : convert various newline sequences (LF, CRLF, CR, NEL) into a linefeed (LF), line-separation (LS), or paragraph-separation (PS) character, respectively
-     * ``stripmark=true``\ : strip diacritical marks (e.g. accents)
-     * ``stripignore=true``\ : strip Unicode's "default ignorable" characters (e.g. the soft hyphen or the left-to-right marker)
-     * ``stripcc=true``\ : strip control characters; horizontal tabs and form feeds are converted to spaces; newlines are also converted to spaces unless a newline-conversion flag was specified
-     * ``rejectna=true``\ : throw an error if unassigned code points are found
-     * ``stable=true``\ : enforce Unicode Versioning Stability
+   * ``compose=false``\ : do not perform canonical composition
+   * ``decompose=true``\ : do canonical decomposition instead of canonical composition (``compose=true``   is ignored if present)
+   * ``compat=true``\ : compatibility equivalents are canonicalized
+   * ``casefold=true``\ : perform Unicode case folding, e.g. for case-insensitive string comparison
+   * ``newline2lf=true``\ , ``newline2ls=true``\ , or ``newline2ps=true``\ : convert various newline sequences   (LF, CRLF, CR, NEL) into a linefeed (LF), line-separation (LS), or paragraph-separation (PS)   character, respectively
+   * ``stripmark=true``\ : strip diacritical marks (e.g. accents)
+   * ``stripignore=true``\ : strip Unicode's "default ignorable" characters (e.g. the soft hyphen   or the left-to-right marker)
+   * ``stripcc=true``\ : strip control characters; horizontal tabs and form feeds are converted to   spaces; newlines are also converted to spaces unless a newline-conversion flag was specified
+   * ``rejectna=true``\ : throw an error if unassigned code points are found
+   * ``stable=true``\ : enforce Unicode Versioning Stability
 
    For example, NFKC corresponds to the options ``compose=true, compat=true, stable=true``\ .
 
@@ -171,7 +171,7 @@
 
    .. Docstring generated from Julia source
 
-   Tells whether index ``i`` is valid for the given string
+   Tells whether index ``i`` is valid for the given string.
 
 .. function:: is_assigned_char(c) -> Bool
 
@@ -253,7 +253,7 @@
 
    .. Docstring generated from Julia source
 
-   Reverses a string
+   Reverses a string.
 
 .. function:: replace(string, pat, r[, n])
 
@@ -291,17 +291,17 @@
 
    Return ``string`` with any trailing whitespace removed. If ``chars`` (a character, or vector or set of characters) is provided, instead remove characters contained in it.
 
-.. function:: startswith(string, prefix | chars)
+.. function:: startswith(string, prefix)
 
    .. Docstring generated from Julia source
 
-   Returns ``true`` if ``string`` starts with ``prefix``\ . If the second argument is a vector or set of characters, tests whether the first character of ``string`` belongs to that set.
+   Returns ``true`` if ``string`` starts with ``prefix``\ . If ``prefix`` is a vector or set of characters, tests whether the first character of ``string`` belongs to that set.
 
-.. function:: endswith(string, suffix | chars)
+.. function:: endswith(string, suffix)
 
    .. Docstring generated from Julia source
 
-   Returns ``true`` if ``string`` ends with ``suffix``\ . If the second argument is a vector or set of characters, tests whether the last character of ``string`` belongs to that set.
+   Returns ``true`` if ``string`` ends with ``suffix``\ . If ``suffix`` is a vector or set of characters, tests whether the last character of ``string`` belongs to that set.
 
 .. function:: uppercase(string)
 
@@ -331,7 +331,11 @@
 
    .. Docstring generated from Julia source
 
-   Join an array of ``strings`` into a single string, inserting the given delimiter between adjacent strings. If ``last`` is given, it will be used instead of ``delim`` between the last two strings. For example, ``join(["apples", "bananas", "pineapples"], ", ", " and ") == "apples, bananas and pineapples"``\ .
+   Join an array of ``strings`` into a single string, inserting the given delimiter between adjacent strings. If ``last`` is given, it will be used instead of ``delim`` between the last two strings. For example
+
+   .. code-block:: julia
+
+       join(["apples", "bananas", "pineapples"], ", ", " and ") == "apples, bananas and pineapples"
 
    ``strings`` can be any iterable over elements ``x`` which are convertible to strings via ``print(io::IOBuffer, x)``\ .
 
@@ -375,9 +379,7 @@
 
    .. Docstring generated from Julia source
 
-   Create a random ASCII string of length ``len``, consisting of upper- and
-   lower-case letters and the digits 0-9. The optional ``rng`` argument
-   specifies a random number generator, see :ref:`Random Numbers <random-numbers>`.
+   Create a random ASCII string of length ``len``\ , consisting of upper- and lower-case letters and the digits 0-9. The optional ``rng`` argument specifies a random number generator, see :ref:`Random Numbers <random-numbers>`\ .
 
 .. function:: charwidth(c)
 
@@ -485,7 +487,7 @@
 
    .. Docstring generated from Julia source
 
-   General unescaping of traditional C and Unicode escape sequences. Reverse of :func:`escape_string`. See also :func:`print_unescaped`.
+   General unescaping of traditional C and Unicode escape sequences. Reverse of :func:`escape_string`\ . See also :func:`print_unescaped`\ .
 
 .. function:: utf16(s)
 
diff --git a/doc/stdlib/test.rst b/doc/stdlib/test.rst
index cfd9bf56358da..b2e17e2638295 100644
--- a/doc/stdlib/test.rst
+++ b/doc/stdlib/test.rst
@@ -1,6 +1,6 @@
-*****************************
- Unit and Functional Testing
-*****************************
+**************
+ Unit Testing
+**************
 
 Testing Base Julia
 ------------------
@@ -20,64 +20,185 @@ binary install, you can run the test suite using ``Base.runtests()``.
 
 .. module:: Base.Test
 
-Test Framework
---------------
+Basic Unit Tests
+----------------
 
-The ``Test`` module contains macros and functions related to testing.
-A default handler is provided to run the tests, and a custom one can be
-provided by the user by using the :func:`registerhandler` function.
+The ``Base.Test`` module provides simple *unit testing* functionality.
+Unit testing is a way to see if your code is correct by checking that
+the results are what you expect. It can be helpful to ensure your code
+still works after you make changes, and can be used when developing as
+a way of specifying the behaviors your code should have when complete.
 
-To use the default handler, the macro :func:`@test` can be used directly::
+Simple unit testing can be performed with the :func:`@test` and
+:func:`@test_throws` macros:
 
-  julia> using Base.Test
+.. function:: @test ex
 
-  julia> @test 1 == 1
+   .. Docstring generated from Julia source
 
-  julia> @test 1 == 0
-  ERROR: test failed: 1 == 0
-   in error at error.jl:21
-   in default_handler at test.jl:19
-   in do_test at test.jl:39
+   Tests that the expression ``ex`` evaluates to ``true``\ . Returns a ``Pass`` ``Result`` if it does, a ``Fail`` ``Result`` if it is ``false``\ , and an ``Error`` ``Result`` if it could not be evaluated.
 
-  julia> @test error("This is what happens when a test fails")
-  ERROR: test error during error("This is what happens when a test fails")
-  This is what happens when a test fails
-   in error at error.jl:21
-   in anonymous at test.jl:62
-   in do_test at test.jl:37
+.. function:: @test_throws extype ex
 
-As seen in the examples above, failures or errors will print the abstract
-syntax tree of the expression in question.
+   .. Docstring generated from Julia source
 
-Another macro is provided to check if the given expression throws an exception of type ``extype``,
-:func:`@test_throws`::
+   Tests that the expression ``ex`` throws an exception of type ``extype``\ .
 
-  julia> @test_throws ErrorException error("An error")
-  ErrorException("An error")
+For example, suppose we want to check our new function ``foo(x)`` works
+as expected::
 
-  julia> @test_throws BoundsError error("An error")
-  ERROR: test failed: error("An error")
-   in error at error.jl:21
-   in default_handler at test.jl:19
-   in do_test_throws at test.jl:55
+    julia> using Base.Test
 
-  julia> @test_throws DomainError throw(DomainError())
-  DomainError()
+    julia> foo(x) = length(x)^2
+    foo (generic function with 1 method)
 
-  julia> @test_throws DomainError throw(EOFError())
-  ERROR: test failed: throw(EOFError())
-   in error at error.jl:21
-   in default_handler at test.jl:19
-   in do_test_throws at test.jl:55
+If the condition is true, a ``Pass`` is returned::
+
+    julia> @test foo("bar") == 9
+    Test Passed
+      Expression: foo("bar") == 9
+       Evaluated: 9 == 9
+
+    julia> @test foo("fizz") >= 10
+    Test Passed
+      Expression: foo("fizz") >= 10
+       Evaluated: 16 >= 10
+
+If the condition is false, then a ``Fail`` is returned and an
+exception is thrown::
+
+    julia> @test foo("f") == 20
+    Test Failed
+      Expression: foo("f") == 20
+       Evaluated: 1 == 20
+    ERROR: There was an error during testing
+     in record at test.jl:268
+     in do_test at test.jl:191
+
+If the condition could not be evaluated because an exception was thrown,
+which occurs in this case because :func:`length` is not defined for
+symbols, an ``Error`` object is returned and an exception is thrown::
+
+    julia> @test foo(:cat) == 1
+    Error During Test
+      Test threw an exception of type MethodError
+      Expression: foo(:cat) == 1
+      MethodError: `length` has no method matching length(::Symbol)
+       in foo at none:1
+       in anonymous at test.jl:159
+       in do_test at test.jl:180
+    ERROR: There was an error during testing
+     in record at test.jl:268
+     in do_test at test.jl:191
+
+If we expect that evaluating an expression *should* throw an exception,
+then we can use :func:`@test_throws` to check this occurs::
+
+    julia> @test_throws MethodError foo(:cat)
+    Test Passed
+      Expression: foo(:cat)
+       Evaluated: MethodError
+
+
+Working with Test Sets
+----------------------
+
+Typically a large of number of tests are used to make sure functions
+work correctly over a range of inputs. In the event a test fails, the
+default behavior is to throw an exception immediately. However, it is
+normally preferable to run the rest of the tests first to get a
+better picture of how many errors there are in the code being tested.
+
+The :func:`@testset` macro can be used to group tests into *sets*.
+All the tests in a test set will be run, and at the end of the test set
+a summary will be printed. If any of the tests failed, or could not be
+evaluated due to an error, the test set will then throw a ``TestSetException``.
+
+.. function:: @testset [CustomTestSet] [option=val  ...] ["description"] begin ... end
+              @testset [CustomTestSet] [option=val  ...] ["description $v"] for v in (...) ... end
+              @testset [CustomTestSet] [option=val  ...] ["description $v, $w"] for v in (...), w in (...) ... end
 
+   .. Docstring generated from Julia source
 
-As floating-point values can be imprecise, you can perform approximate
-equality checks using either ``@test a ≈ b`` (where ``≈``, typed via
-tab completion of ``\approx``, is the ``isapprox`` function) or use
-the macros ``@test_approx_eq`` macro (which differs from ``isapprox``
-in that it treats NaN values as equal and has a smaller default
-tolerance) or ``@test_approx_eq_eps`` (which takes an extra argument
-indicating the relative tolerance)::
+   Starts a new test set, or multiple test sets if a ``for`` loop is provided.
+
+   If no custom testset type is given it defaults to creating a ``DefaultTestSet``\ . ``DefaultTestSet`` records all the results and, and if there are any ``Fail``\ s or ``Error``\ s, throws an exception at the end of the top-level (non-nested) test set, along with a summary of the test results.
+
+   Any custom testset type (subtype of ``AbstractTestSet``\ ) can be given and it will also be used for any nested ``@testset`` invocations. The given options are only applied to the test set where they are given. The default test set type does not take any options.
+
+   The description string accepts interpolation from the loop indices. If no description is provided, one is constructed based on the variables.
+
+   By default the ``@testset`` macro will return the testset object itself, though this behavior can be customized in other testset types. If a ``for`` loop is used then the macro collects and returns a list of the return values of the ``finish`` method, which by default will return a list of the testset objects used in each iteration.
+
+We can put our tests for the ``foo(x)`` function in a test set::
+
+    julia> @testset "Foo Tests" begin
+               @test foo("a")   == 1
+               @test foo("ab")  == 4
+               @test foo("abc") == 9
+           end
+    Test Summary: | Pass  Total
+    Foo Tests     |    3      3
+
+Test sets can all also be nested::
+
+    julia> @testset "Foo Tests" begin
+               @testset "Animals" begin
+                   @test foo("cat") == 9
+                   @test foo("dog") == foo("cat")
+               end
+               @testset "Arrays $i" for i in 1:3
+                   @test foo(zeros(i)) == i^2
+                   @test foo(ones(i)) == i^2
+               end
+           end
+    Test Summary: | Pass  Total
+    Foo Tests     |    8      8
+
+In the event that a nested test set has no failures, as happened here,
+it will be hidden in the summary. If we do have a test failure, only
+the details for the failed test sets will be shown::
+
+    julia> @testset "Foo Tests" begin
+               @testset "Animals" begin
+                   @testset "Felines" begin
+                       @test foo("cat") == 9
+                   end
+                   @testset "Canines" begin
+                       @test foo("dog") == 9
+                   end
+               end
+               @testset "Arrays" begin
+                   @test foo(zeros(2)) == 4
+                   @test foo(ones(4)) == 15
+               end
+           end
+
+    Arrays: Test Failed
+      Expression: foo(ones(4)) == 15
+       Evaluated: 16 == 15
+     in record at test.jl:297
+     in do_test at test.jl:191
+    Test Summary: | Pass  Fail  Total
+    Foo Tests     |    3     1      4
+      Animals     |    2            2
+      Arrays      |    1     1      2
+    ERROR: Some tests did not pass: 3 passed, 1 failed, 0 errored.
+     in finish at test.jl:362
+
+
+Other Test Macros
+-----------------
+
+As calculations on floating-point values can be imprecise, you can
+perform approximate equality checks using either ``@test a ≈ b``
+(where ``≈``, typed via tab completion of ``\approx``,
+is the :func:`isapprox` function) or use :func:`isapprox` directly.
+
+An alternative is the ``@test_approx_eq`` macro (which differs from
+``isapprox`` in that it treats NaN values as equal and has a smaller
+default tolerance) or ``@test_approx_eq_eps`` (which takes an extra
+argument indicating the relative tolerance)::
 
   julia> @test 1 ≈ 0.999999999
 
@@ -107,77 +228,93 @@ indicating the relative tolerance)::
    in error at error.jl:22
    in test_approx_eq at test.jl:68
 
-Handlers
---------
-
-A handler is a function defined for three kinds of arguments: ``Success``, ``Failure``, ``Error``::
-
-  # An example definition of a test handler
-  test_handler(r::Success) = nothing
-  test_handler(r::Failure) = error("test failed: $(r.expr)")
-  test_handler(r::Error)   = rethrow(r)
+Note that these macros will fail immediately, and are not compatible
+with :func:`@testset`, so using ``@test isapprox`` is encouraged when
+writing new tests.
 
-A different handler can be used for a block (with :func:`with_handler`)::
+.. function:: @test_approx_eq(a, b)
 
-  julia> using Base.Test
+   .. Docstring generated from Julia source
 
-  julia> custom_handler(r::Test.Success) = println("Success on $(r.expr)")
-  custom_handler (generic function with 1 method)
+   Test two floating point numbers ``a`` and ``b`` for equality taking in account small numerical errors.
 
-  julia> custom_handler(r::Test.Failure) = error("Error on custom handler: $(r.expr)")
-  custom_handler (generic function with 2 methods)
+.. function:: @test_approx_eq_eps(a, b, tol)
 
-  julia> custom_handler(r::Test.Error) = rethrow(r)
-  custom_handler (generic function with 3 methods)
+   .. Docstring generated from Julia source
 
-  julia> Test.with_handler(custom_handler) do
-           @test 1 == 1
-           @test 1 != 1
-         end
-  Success on :((1==1))
-  ERROR: Error on custom handler: :((1!=1))
-   in error at error.jl:21
-   in custom_handler at none:1
-   in do_test at test.jl:39
-   in anonymous at no file:3
-   in task_local_storage at task.jl:28
-   in with_handler at test.jl:24
+   Test two floating point numbers ``a`` and ``b`` for equality taking in account a margin of tolerance given by ``tol``\ .
 
-The ``Success`` and ``Failure`` types include an additonal field, ``resultexpr``, which is a partially evaluated expression. For example, in a comparison it will contain an expression with the left and right sides evaluated.
+Creating Custom ``AbstractTestSet`` Types
+-----------------------------------------
 
-Macros
-------
+Packages can create their own ``AbstractTestSet`` subtypes by implementing the
+``record`` and ``finish`` methods. The subtype should have a one-argument
+constructor taking a description string, with any options passed in as keyword
+arguments.
 
-.. function:: @test(ex)
+.. function:: record(ts::AbstractTestSet, res::Result)
 
    .. Docstring generated from Julia source
 
-   Test the expression ``ex`` and calls the current handler to handle the result.
+   Record a result to a testset. This function is called by the ``@testset`` infrastructure each time a contained ``@test`` macro completes, and is given the test result (which could be an ``Error``\ ). This will also be called with an ``Error`` if an exception is thrown inside the test block but outside of a ``@test`` context.
 
-.. function:: @test_throws(extype, ex)
+.. function:: finish(ts::AbstractTestSet)
 
    .. Docstring generated from Julia source
 
-   Test that the expression ``ex`` throws an exception of type ``extype`` and calls the current handler to handle the result.
+   Do any final processing necessary for the given testset. This is called by the ``@testset`` infrastructure after a test block executes. One common use for this function is to record the testset to the parent's results list, using ``get_testset``\ .
 
-.. function:: @test_approx_eq(a, b)
+``Base.Test`` takes responsibility for maintaining a stack of nested testsets as
+they are executed, but any result accumulation is the responsibility of the
+``AbstractTestSet`` subtype. You can access this stack with the ``get_testset`` and
+``get_testset_depth`` methods. Note that these functions are not exported.
 
-   .. Docstring generated from Julia source
-
-   Test two floating point numbers ``a`` and ``b`` for equality taking in account small numerical errors.
-
-.. function:: @test_approx_eq_eps(a, b, tol)
+.. function:: get_testset()
 
    .. Docstring generated from Julia source
 
-   Test two floating point numbers ``a`` and ``b`` for equality taking in account a margin of tolerance given by ``tol``\ .
-
-Functions
----------
+   Retrieve the active test set from the task's local storage. If no test set is active, use the fallback default test set.
 
-.. function:: with_handler(f, handler)
+.. function:: get_testset_depth()
 
    .. Docstring generated from Julia source
 
-   Run the function ``f`` using the ``handler`` as the handler.
-
+   Returns the number of active test sets, not including the defaut test set
+
+``Base.Test`` also makes sure that nested ``@testset`` invocations use the same
+``AbstractTestSet`` subtype as their parent unless it is set explicitly. It does
+not propagate any properties of the testset option inheritance behavior can be
+implemented by packages using the stack infrastructure that ``Base.Test``
+provides.
+
+Defining a basic ``AbstractTestSet`` subtype might look like::
+
+    import Base.Test: record, finish
+    using Base.Test: AbstractTestSet, Result, Pass, Fail, Error
+    using Base.Test: get_testset_depth, get_testset
+    immutable CustomTestSet <: Base.Test.AbstractTestSet
+        description::AbstractString
+        foo::Int
+        results::Vector
+        # constructor takes a description string and options keyword arguments
+        CustomTestSet(desc; foo=1) = new(desc, foo, [])
+    end
+
+    record(ts::CustomTestSet, child::AbstractTestSet) = push!(ts.results, child)
+    record(ts::CustomTestSet, res::Result) = push!(ts.results, res)
+    function finish(ts::CustomTestSet)
+        # just record if we're not the top-level parent
+        if get_testset_depth() > 0
+            record(get_testset(), ts)
+        end
+        ts
+    end
+
+And using that testset looks like::
+
+    @testset CustomTestSet foo=4 "custom testset inner 2" begin
+        # this testset should inherit the type, but not the argument.
+        @testset "custom testset inner" begin
+            @test true
+        end
+    end
diff --git a/examples/clustermanager/simple/test_simple.jl b/examples/clustermanager/simple/test_simple.jl
index 42268d58514af..faca7e168fc98 100644
--- a/examples/clustermanager/simple/test_simple.jl
+++ b/examples/clustermanager/simple/test_simple.jl
@@ -5,7 +5,7 @@ include(cmanpath)
 
 npids = addprocs(UnixDomainCM(2))
 assert(length(npids) == 2)
-test_pids = [remotecall_fetch(x, myid) for x in npids]
+test_pids = [remotecall_fetch(myid, x) for x in npids]
 assert(npids == test_pids)
 rmprocs(npids; waitfor=1.0)
 
diff --git a/examples/embedding.c b/examples/embedding.c
index 12acbb049b4d0..34a7e42290841 100644
--- a/examples/embedding.c
+++ b/examples/embedding.c
@@ -99,6 +99,7 @@ int main()
         }
     }
 
-    jl_atexit_hook();
-    return 0;
+    int ret = 0;
+    jl_atexit_hook(ret);
+    return ret;
 }
diff --git a/examples/hpl.jl b/examples/hpl.jl
index 463da04d76c00..e67c085452716 100644
--- a/examples/hpl.jl
+++ b/examples/hpl.jl
@@ -251,15 +251,15 @@ function hpl_par2(A::Matrix, b::Vector)
     for i = 1:nB
         #println("C=$(convert(Array, C))") #####
         ##panel factorization
-        panel_p = remotecall_fetch(C.pmap[i], panel_factor_par2, C, i, n)
+        panel_p = remotecall_fetch(panel_factor_par2, C.pmap[i], C, i, n)
 
         ## Apply permutation from pivoting
         for j = (i+1):nB
-           depend[i,j] = remotecall(C.pmap[j], permute, C, i, j, panel_p, n, false)
+           depend[i,j] = remotecall(permute, C.pmap[j], C, i, j, panel_p, n, false)
         end
         ## Special case for last column
         if i == nB
-           depend[nB,nB] = remotecall(C.pmap[nB], permute, C, i, nB+1, panel_p, n, true)
+           depend[nB,nB] = remotecall(permute, C.pmap[nB], C, i, nB+1, panel_p, n, true)
         end
 
         ##Trailing updates
@@ -276,13 +276,13 @@ function hpl_par2(A::Matrix, b::Vector)
 
         for j=(i+1):nB
             dep = depend[i,j]
-            depend[j,i] = remotecall(C.pmap[j], trailing_update_par2, C, L_II, C_KI, i, j, n, false, dep)
+            depend[j,i] = remotecall(trailing_update_par2, C.pmap[j], C, L_II, C_KI, i, j, n, false, dep)
         end
 
         ## Special case for last column
         if i == nB
             dep = depend[nB,nB]
-            remotecall_fetch(C.pmap[nB], trailing_update_par2, C, L_II, C_KI, i, nB+1, n, true, dep)
+            remotecall_fetch(trailing_update_par2, C.pmap[nB], C, L_II, C_KI, i, nB+1, n, true, dep)
         else
             #enforce dependencies for nonspecial case
             for j=(i+1):nB
diff --git a/examples/juliatypes.jl b/examples/juliatypes.jl
index ba04b3bdc0521..c0a07bfde5ea8 100644
--- a/examples/juliatypes.jl
+++ b/examples/juliatypes.jl
@@ -134,7 +134,7 @@ inst(t::TagT) = t
 inst(t::UnionAllT, param) = subst(t.T, Dict{Any,Any}(t.var => param))
 inst(t::UnionAllT, param, rest...) = inst(inst(t,param), rest...)
 
-super(t::TagT) = t.name===TupleName ? AnyT : inst(t.name.super, t.params...)
+supertype(t::TagT) = t.name===TupleName ? AnyT : inst(t.name.super, t.params...)
 
 extend(d::Dict, k, v) = (x = copy(d); x[k]=v; x)
 
@@ -260,7 +260,7 @@ function issub(a::TagT, b::TagT, env)
     b === AnyT && return true
     a === AnyT && return false
     if a.name !== b.name
-        return issub(super(a), b, env)
+        return issub(supertype(a), b, env)
     end
     if a.name === TupleName
         va, vb = a.vararg, b.vararg
diff --git a/examples/lru.jl b/examples/lru.jl
index 789f269036df8..cc8958ef015e8 100644
--- a/examples/lru.jl
+++ b/examples/lru.jl
@@ -58,7 +58,6 @@ BoundedLRU() = BoundedLRU{Any, Any}()
 
 isempty(lru::LRU) = isempty(lru.q)
 length(lru::LRU) = length(lru.q)
-haskey(lru::LRU, key) = haskey(lru.ht, key)
 
 ## associative ##
 
diff --git a/examples/typetree.jl b/examples/typetree.jl
index 6f88d6b3f5300..ebbaf52395c20 100644
--- a/examples/typetree.jl
+++ b/examples/typetree.jl
@@ -59,7 +59,7 @@ function store_type(sname::AbstractString, t::TypeConstructor)
 end
 
 function store_type(sname::AbstractString, t::DataType)
-    suptype = super(t)
+    suptype = supertype(t)
     subtypes = (suptype != t) ? store_type(typ_name(suptype), suptype) : types_tree
     tnode = add_ttnode(subtypes, sname, t)
     return tnode.subtypes
@@ -71,7 +71,7 @@ function store_type(sname::AbstractString, t::Tuple)
 end
 
 function store_type(sname::AbstractString, t)
-    suptype = super(t)
+    suptype = supertype(t)
     subtypes = (suptype != t) ? store_type(typ_name(suptype), suptype) : types_tree
     tnode = add_ttnode(subtypes, sname, t)
     return tnode.subtypes
diff --git a/examples/wordcount.jl b/examples/wordcount.jl
index c2f0e9d2a775e..601ffc3321a60 100644
--- a/examples/wordcount.jl
+++ b/examples/wordcount.jl
@@ -75,9 +75,7 @@ end
 function wordcount_files(result_file,inputs...)
     text = ""
     for file in inputs
-        open(file) do f
-            text *= readall(f)
-        end
+        text *= readstring(file)
     end
     wc = parallel_wordcount(text)
     open(result_file,"w") do f
diff --git a/src/APInt-C.cpp b/src/APInt-C.cpp
new file mode 100644
index 0000000000000..86674db41eca2
--- /dev/null
+++ b/src/APInt-C.cpp
@@ -0,0 +1,534 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#include "llvm-version.h"
+#include <llvm/ADT/APInt.h>
+#include <llvm/ADT/APFloat.h>
+#include <llvm/Support/MathExtras.h>
+
+#include "APInt-C.h"
+#include "julia.h"
+
+using namespace llvm;
+
+#ifdef LLVM39
+inline uint64_t RoundUpToAlignment(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
+    return alignTo(Value, Align, Skew);
+}
+#endif
+
+/* create "APInt s" from "integerPart *ps" */
+#define CREATE(s) \
+    APInt s; \
+    if ((numbits % integerPartWidth) != 0) { \
+        /* use LLT_ALIGN to round the memory area up to the nearest integerPart-sized chunk */ \
+        unsigned nbytes = RoundUpToAlignment(numbits, integerPartWidth) / host_char_bit; \
+        integerPart *data_a64 = (integerPart*)alloca(nbytes); \
+        /* TODO: this memcpy assumes little-endian,
+         * for big-endian, need to align the copy to the other end */ \
+        memcpy(data_a64, p##s, RoundUpToAlignment(numbits, host_char_bit) / host_char_bit); \
+        s = APInt(numbits, makeArrayRef(data_a64, nbytes / sizeof(integerPart))); \
+    } \
+    else { \
+        s = APInt(numbits, makeArrayRef(p##s, numbits / integerPartWidth)); \
+    }
+
+/* assign to "integerPart *pr" from "APInt a" */
+#define ASSIGN(r, a) \
+    if (numbits <= 8) \
+        *(uint8_t*)p##r = a.getZExtValue(); \
+    else if (numbits <= 16) \
+        *(uint16_t*)p##r = a.getZExtValue(); \
+    else if (numbits <= 32) \
+        *(uint32_t*)p##r = a.getZExtValue(); \
+    else if (numbits <= 64) \
+        *(uint64_t*)p##r = a.getZExtValue(); \
+    else \
+        memcpy(p##r, a.getRawData(), RoundUpToAlignment(numbits, host_char_bit) / host_char_bit); \
+
+extern "C" JL_DLLEXPORT
+void LLVMNeg(unsigned numbits, integerPart *pa, integerPart *pr) {
+    APInt z(numbits, 0);
+    CREATE(a)
+    z -= a;
+    ASSIGN(r, z)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMAdd(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a += b;
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMSub(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a -= b;
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMMul(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a *= b;
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMSDiv(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.sdiv(b);
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMUDiv(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.udiv(b);
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMSRem(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.srem(b);
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMURem(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.urem(b);
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMICmpEQ(unsigned numbits, integerPart *pa, integerPart *pb) {
+    CREATE(a)
+    CREATE(b)
+    return a.eq(b);
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMICmpNE(unsigned numbits, integerPart *pa, integerPart *pb) {
+    CREATE(a)
+    CREATE(b)
+    return a.ne(b);
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMICmpSLT(unsigned numbits, integerPart *pa, integerPart *pb) {
+    CREATE(a)
+    CREATE(b)
+    return a.slt(b);
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMICmpULT(unsigned numbits, integerPart *pa, integerPart *pb) {
+    CREATE(a)
+    CREATE(b)
+    return a.ult(b);
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMICmpSLE(unsigned numbits, integerPart *pa, integerPart *pb) {
+    CREATE(a)
+    CREATE(b)
+    return a.sle(b);
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMICmpULE(unsigned numbits, integerPart *pa, integerPart *pb) {
+    CREATE(a)
+    CREATE(b)
+    return a.ule(b);
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMAnd(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a &= b;
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMOr(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a |= b;
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMXor(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a ^= b;
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMShl(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.shl(b);
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMLShr(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.lshr(b);
+    ASSIGN(r, a)
+}
+extern "C" JL_DLLEXPORT
+void LLVMAShr(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.ashr(b);
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMFlipAllBits(unsigned numbits, integerPart *pa, integerPart *pr) {
+    CREATE(a)
+    a.flipAllBits();
+    ASSIGN(r, a)
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMAdd_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.uadd_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMAdd_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.sadd_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMSub_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.usub_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMSub_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.ssub_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMMul_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.smul_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMMul_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.umul_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMDiv_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    bool Overflow;
+    a = a.sdiv_ov(b, Overflow);
+    ASSIGN(r, a)
+    return Overflow;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMDiv_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.udiv(b);
+    ASSIGN(r, a)
+    // unsigned division cannot overflow
+    return false;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMRem_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.srem(b);
+    ASSIGN(r, a)
+    // signed remainder cannot overflow
+    return false;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMRem_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    a = a.urem(b);
+    ASSIGN(r, a)
+    // unsigned remainder cannot overflow
+    return false;
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMByteSwap(unsigned numbits, integerPart *pa, integerPart *pr) {
+    CREATE(a)
+    a = a.byteSwap();
+    ASSIGN(r, a)
+}
+
+void LLVMFPtoInt(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr, bool isSigned, bool *isExact) {
+    double Val;
+    if (numbits == 32)
+        Val = *(float*)pa;
+    else if (numbits == 64)
+        Val = *(double*)pa;
+    else
+        jl_error("FPtoSI: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    if (onumbits <= 64) { // fast-path, if possible
+        if (isSigned) {
+            int64_t ia = Val;
+            memcpy(pr, &ia, onumbytes); // TODO: assumes little-endian
+            if (isExact) {
+                // check whether the conversion was lossless
+                int64_t ia2 = ia < 0 ? -1 : 0;
+                memcpy(&ia2, pr, onumbytes);
+                *isExact = (Val == (double)ia2 && ia == ia2);
+            }
+        }
+        else {
+            uint64_t ia = Val;
+            memcpy(pr, &ia, onumbytes); // TODO: assumes little-endian
+            if (isExact) {
+                // check whether the conversion was lossless
+                uint64_t ia2 = 0;
+                memcpy(&ia2, pr, onumbytes);
+                *isExact = (Val == (double)ia2 && ia == ia2);
+            }
+        }
+    }
+    else {
+        APFloat a(Val);
+        bool isVeryExact;
+        APFloat::roundingMode rounding_mode = APFloat::rmNearestTiesToEven;
+        unsigned nbytes = RoundUpToAlignment(onumbits, integerPartWidth) / host_char_bit;
+        integerPart *parts = (integerPart*)alloca(nbytes);
+        APFloat::opStatus status = a.convertToInteger(parts, onumbits, isSigned, rounding_mode, &isVeryExact);
+        memcpy(pr, parts, onumbytes);
+        if (isExact)
+            *isExact = (status == APFloat::opOK);
+    }
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMFPtoSI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    LLVMFPtoInt(numbits, pa, onumbits, pr, true, NULL);
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMFPtoUI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    LLVMFPtoInt(numbits, pa, onumbits, pr, false, NULL);
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMFPtoSI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    bool isExact;
+    LLVMFPtoInt(numbits, pa, onumbits, pr, true, &isExact);
+    return isExact;
+}
+
+extern "C" JL_DLLEXPORT
+int LLVMFPtoUI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    bool isExact;
+    LLVMFPtoInt(numbits, pa, onumbits, pr, false, &isExact);
+    return isExact;
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMSItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    CREATE(a)
+    double val = a.roundToDouble(true);
+    if (onumbits == 32)
+        *(float*)pr = val;
+    else if (onumbits == 64)
+        *(double*)pr = val;
+    else
+        jl_error("SItoFP: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMUItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    CREATE(a)
+    double val = a.roundToDouble(false);
+    if (onumbits == 32)
+        *(float*)pr = val;
+    else if (onumbits == 64)
+        *(double*)pr = val;
+    else
+        jl_error("UItoFP: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMSExt(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    assert(inumbits < onumbits);
+    unsigned inumbytes = RoundUpToAlignment(inumbits, host_char_bit) / host_char_bit;
+    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    int bits = (0 - inumbits) % host_char_bit;
+    int signbit = (inumbits - 1) % host_char_bit;
+    int sign = ((unsigned char*)pa)[inumbytes - 1] & (1 << signbit) ? -1 : 0;
+    // copy over the input bytes
+    memcpy(pr, pa, inumbytes);
+    if (bits) {
+        // sign-extend the partial byte
+        ((signed char*)pr)[inumbytes - 1] = ((signed char*)pa)[inumbytes - 1] << bits >> bits;
+    }
+    // sign-extend the rest of the bytes
+    memset((char*)pr + inumbytes, sign, onumbytes - inumbytes);
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMZExt(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    assert(inumbits < onumbits);
+    unsigned inumbytes = RoundUpToAlignment(inumbits, host_char_bit) / host_char_bit;
+    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    int bits = (0 - inumbits) % host_char_bit;
+    // copy over the input bytes
+    memcpy(pr, pa, inumbytes);
+    if (bits) {
+        // zero the remaining bits of the partial byte
+        ((unsigned char*)pr)[inumbytes - 1] = ((unsigned char*)pa)[inumbytes - 1] << bits >> bits;
+    }
+    // zero-extend the rest of the bytes
+    memset((char*)pr + inumbytes, 0, onumbytes - inumbytes);
+}
+
+extern "C" JL_DLLEXPORT
+void LLVMTrunc(unsigned inumbits, integerPart *pa, unsigned onumbits, integerPart *pr) {
+    assert(inumbits > onumbits);
+    unsigned onumbytes = RoundUpToAlignment(onumbits, host_char_bit) / host_char_bit;
+    memcpy(pr, pa, onumbytes);
+}
+
+extern "C" JL_DLLEXPORT
+unsigned countTrailingZeros_8(uint8_t Val) {
+#ifdef LLVM35
+    return countTrailingZeros(Val);
+#else
+    return CountTrailingZeros_32(Val);
+#endif
+}
+
+extern "C" JL_DLLEXPORT
+unsigned countTrailingZeros_16(uint16_t Val) {
+#ifdef LLVM35
+    return countTrailingZeros(Val);
+#else
+    return CountTrailingZeros_32(Val);
+#endif
+}
+
+extern "C" JL_DLLEXPORT
+unsigned countTrailingZeros_32(uint32_t Val) {
+#ifdef LLVM35
+    return countTrailingZeros(Val);
+#else
+    return CountTrailingZeros_32(Val);
+#endif
+}
+
+extern "C" JL_DLLEXPORT
+unsigned countTrailingZeros_64(uint64_t Val) {
+#ifdef LLVM35
+    return countTrailingZeros(Val);
+#else
+    return CountTrailingZeros_64(Val);
+#endif
+}
+
+extern "C" JL_DLLEXPORT
+void jl_LLVMSMod(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    CREATE(a)
+    CREATE(b)
+    APInt r = a.srem(b);
+    if (a.isNegative() != b.isNegative()) {
+        r = (b + r).srem(b);
+    }
+    ASSIGN(r, r)
+}
+
+extern "C" JL_DLLEXPORT
+void jl_LLVMFlipSign(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr) {
+    unsigned numbytes = RoundUpToAlignment(numbits, host_char_bit) / host_char_bit;
+    int signbit = (numbits - 1) % host_char_bit;
+    int sign = ((unsigned char*)pa)[numbytes - 1] & (1 << signbit) ? -1 : 0;
+    if (sign)
+        LLVMNeg(numbits, pa, pr);
+    else
+        memcpy(pr, pa,  numbytes);
+}
+
+extern "C" JL_DLLEXPORT
+unsigned LLVMCountPopulation(unsigned numbits, integerPart *pa) {
+    CREATE(a)
+    return a.countPopulation();
+}
+
+extern "C" JL_DLLEXPORT
+unsigned LLVMCountTrailingOnes(unsigned numbits, integerPart *pa) {
+    CREATE(a)
+    return a.countTrailingOnes();
+}
+
+extern "C" JL_DLLEXPORT
+unsigned LLVMCountTrailingZeros(unsigned numbits, integerPart *pa) {
+    CREATE(a)
+    return a.countTrailingZeros();
+}
+
+extern "C" JL_DLLEXPORT
+unsigned LLVMCountLeadingOnes(unsigned numbits, integerPart *pa) {
+    CREATE(a)
+    return a.countLeadingOnes();
+}
+
+extern "C" JL_DLLEXPORT
+unsigned LLVMCountLeadingZeros(unsigned numbits, integerPart *pa) {
+    CREATE(a)
+    return a.countLeadingZeros();
+}
diff --git a/src/APInt-C.h b/src/APInt-C.h
new file mode 100644
index 0000000000000..af0a778ddfc5e
--- /dev/null
+++ b/src/APInt-C.h
@@ -0,0 +1,89 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#ifndef APINT_C_H
+#define APINT_C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "dtypes.h"
+
+#ifdef LLVM_VERSION_MAJOR
+using llvm::integerPart;
+#else
+typedef void integerPart;
+#endif
+
+JL_DLLEXPORT void LLVMNeg(unsigned numbits, integerPart *pa, integerPart *pr);
+JL_DLLEXPORT void LLVMByteSwap(unsigned numbits, integerPart *pa, integerPart *pr);
+
+JL_DLLEXPORT void LLVMAdd(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMSub(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMMul(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMSDiv(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMUDiv(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMSRem(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMURem(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+
+JL_DLLEXPORT void LLVMAnd(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMOr(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMXor(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMShl(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMLShr(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMAShr(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void LLVMFlipAllBits(unsigned numbits, integerPart *pa, integerPart *pr);
+
+JL_DLLEXPORT int LLVMICmpEQ(unsigned numbits, integerPart *pa, integerPart *pr);
+JL_DLLEXPORT int LLVMICmpNE(unsigned numbits, integerPart *pa, integerPart *pb);
+JL_DLLEXPORT int LLVMICmpSLT(unsigned numbits, integerPart *pa, integerPart *pb);
+JL_DLLEXPORT int LLVMICmpULT(unsigned numbits, integerPart *pa, integerPart *pb);
+JL_DLLEXPORT int LLVMICmpSLE(unsigned numbits, integerPart *pa, integerPart *pb);
+JL_DLLEXPORT int LLVMICmpULE(unsigned numbits, integerPart *pa, integerPart *pb);
+
+JL_DLLEXPORT int LLVMAdd_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMAdd_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMSub_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMSub_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMMul_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMMul_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMDiv_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMDiv_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMRem_sov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT int LLVMRem_uov(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+
+JL_DLLEXPORT unsigned LLVMCountPopulation(unsigned numbits, integerPart *pa);
+JL_DLLEXPORT unsigned LLVMCountTrailingOnes(unsigned numbits, integerPart *pa);
+JL_DLLEXPORT unsigned LLVMCountTrailingZeros(unsigned numbits, integerPart *pa);
+JL_DLLEXPORT unsigned LLVMCountLeadingOnes(unsigned numbits, integerPart *pa);
+JL_DLLEXPORT unsigned LLVMCountLeadingZeros(unsigned numbits, integerPart *pa);
+
+JL_DLLEXPORT void LLVMFPtoSI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMFPtoUI(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMSItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMUItoFP(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMSExt(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMZExt(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT void LLVMTrunc(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+
+JL_DLLEXPORT int LLVMFPtoSI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+JL_DLLEXPORT int LLVMFPtoUI_exact(unsigned numbits, integerPart *pa, unsigned onumbits, integerPart *pr);
+
+JL_DLLEXPORT void jl_LLVMSMod(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+JL_DLLEXPORT void jl_LLVMFlipSign(unsigned numbits, integerPart *pa, integerPart *pb, integerPart *pr);
+
+JL_DLLEXPORT unsigned countTrailingZeros_8(uint8_t Val);
+JL_DLLEXPORT unsigned countTrailingZeros_16(uint16_t Val);
+JL_DLLEXPORT unsigned countTrailingZeros_32(uint32_t Val);
+JL_DLLEXPORT unsigned countTrailingZeros_64(uint64_t Val);
+
+//uint8_t getSwappedBytes_8(uint8_t Value); // no-op
+//uint16_t getSwappedBytes_16(uint16_t Value);
+//uint32_t getSwappedBytes_32(uint32_t Value);
+//uint64_t getSwappedBytes_64(uint64_t Value);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/Makefile b/src/Makefile
index f33e562c58d40..4cc180fdc9bbc 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,4 +1,6 @@
-JULIAHOME = $(abspath ..)
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/..)
+BUILDDIR := .
 include $(JULIAHOME)/deps/Versions.make
 include $(JULIAHOME)/Make.inc
 
@@ -6,42 +8,62 @@ override CFLAGS += $(JCFLAGS)
 override CXXFLAGS += $(JCXXFLAGS)
 override CPPFLAGS += $(JCPPFLAGS)
 
-BUILDDIR ?= .
+# -I BUILDDIR comes before -I SRCDIR so that the user can override <options.h> on a per-build-directory basis
+#  for gcc/clang, suggested content is:
+#  #include_next <options.h>
+#  #define ARGUMENT_TO_OVERRIDE 1
+FLAGS := \
+	-D_GNU_SOURCE -I$(BUILDDIR) -I$(SRCDIR) \
+	-I$(SRCDIR)/flisp -I$(SRCDIR)/support \
+	-I$(LIBUV_INC) -I$(build_includedir) -DLIBRARY_EXPORTS \
+	-I$(JULIAHOME)/deps/valgrind
+ifneq ($(USEMSVC), 1)
+FLAGS += -Wall -Wno-strict-aliasing -fno-omit-frame-pointer -fvisibility=hidden -fno-common \
+		 -Wpointer-arith -Wundef
+override CFLAGS += -Wold-style-definition -Wstrict-prototypes -Wc++-compat
+endif
 
-SRCS = \
-	jltypes gf ast builtins module codegen disasm debuginfo interpreter \
+
+SRCS := \
+	jltypes gf ast builtins module interpreter \
 	alloc dlload sys init task array dump toplevel jl_uv jlapi signal-handling \
-	llvm-simdloop simplevector
+	simplevector APInt-C runtime_intrinsics runtime_ccall \
+	threadgroup threading
 
-HEADERS = julia.h julia_internal.h julia_version.h options.h $(wildcard support/*.h) $(LIBUV_INC)/uv.h
+ifeq ($(JULIAGC),MARKSWEEP)
+SRCS += gc
+endif
 
-FLAGS = \
-	-D_GNU_SOURCE -Iflisp -Isupport \
-	-I$(call exec,$(LLVM_CONFIG) --includedir) \
-	-I$(LIBUV_INC) -I$(build_includedir) -DLIBRARY_EXPORTS \
-	-I$(BUILDDIR) -I$(JULIAHOME)/deps/valgrind
-ifneq ($(USEMSVC), 1)
-FLAGS += -Wall -Wno-strict-aliasing -fno-omit-frame-pointer -fvisibility=hidden -fno-common
+ifeq ($(JULIACODEGEN),LLVM)
+SRCS += codegen disasm debuginfo llvm-simdloop llvm-gcroot
+FLAGS += -I$(shell $(LLVM_CONFIG_HOST) --includedir)
+LLVM_LIBS := all
+else
+SRCS += anticodegen
+LLVM_LIBS := support
 endif
 
+HEADERS := $(addprefix $(SRCDIR)/,julia.h julia_threads.h julia_internal.h options.h) $(BUILDDIR)/julia_version.h $(wildcard $(SRCDIR)/support/*.h) $(LIBUV_INC)/uv.h
+
 # In LLVM < 3.4, --ldflags includes both options and libraries, so use it both before and after --libs
 # In LLVM >= 3.4, --ldflags has only options, and --system-libs has the libraries.
-LLVMLINK = $(call exec,$(LLVM_CONFIG) --ldflags) $(call exec,$(LLVM_CONFIG) --libs) $(call exec,$(LLVM_CONFIG) --ldflags) $(call exec,$(LLVM_CONFIG) --system-libs 2> /dev/null)
-ifeq ($(USE_LLVM_SHLIB),1)
+ifneq ($(USE_LLVM_SHLIB),1)
+LLVMLINK := $(shell $(LLVM_CONFIG_HOST) --ldflags) $(shell $(LLVM_CONFIG_HOST) --libs $(LLVM_LIBS)) $(shell $(LLVM_CONFIG_HOST) --ldflags) $(shell $(LLVM_CONFIG_HOST) --system-libs 2> /dev/null)
+else
 ifeq ($(LLVM_USE_CMAKE),1)
-LLVMLINK = $(call exec,$(LLVM_CONFIG) --ldflags) -lLLVM
+LLVMLINK := $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM
 else
-LLVMLINK = $(call exec,$(LLVM_CONFIG) --ldflags) -lLLVM-$(call exec,$(LLVM_CONFIG) --version)
+LLVMLINK := $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM-$(shell $(LLVM_CONFIG_HOST) --version)
 endif
 FLAGS += -DLLVM_SHLIB
 endif
 
-COMMON_LIBS = -L$(build_shlibdir) -L$(build_libdir) $(LIBUV) $(LIBUTF8PROC) $(NO_WHOLE_ARCHIVE) $(LLVMLINK) $(OSLIBS)
-DEBUG_LIBS = $(WHOLE_ARCHIVE) $(BUILDDIR)/flisp/libflisp-debug.a $(WHOLE_ARCHIVE) $(BUILDDIR)/support/libsupport-debug.a $(COMMON_LIBS)
-RELEASE_LIBS = $(WHOLE_ARCHIVE) $(BUILDDIR)/flisp/libflisp.a $(WHOLE_ARCHIVE) $(BUILDDIR)/support/libsupport.a $(COMMON_LIBS)
+COMMON_LIBS := -L$(build_shlibdir) -L$(build_libdir) $(LIBUV) $(LIBUTF8PROC) $(NO_WHOLE_ARCHIVE) $(LLVMLINK) $(OSLIBS)
+DEBUG_LIBS := $(WHOLE_ARCHIVE) $(BUILDDIR)/flisp/libflisp-debug.a $(WHOLE_ARCHIVE) $(BUILDDIR)/support/libsupport-debug.a $(COMMON_LIBS)
+RELEASE_LIBS := $(WHOLE_ARCHIVE) $(BUILDDIR)/flisp/libflisp.a $(WHOLE_ARCHIVE) $(BUILDDIR)/support/libsupport.a $(COMMON_LIBS)
 
-OBJS = $(SRCS:%=$(BUILDDIR)/%.o)
-DOBJS = $(SRCS:%=$(BUILDDIR)/%.dbg.obj)
+OBJS := $(SRCS:%=$(BUILDDIR)/%.o)
+DOBJS := $(SRCS:%=$(BUILDDIR)/%.dbg.obj)
 DEBUGFLAGS += $(FLAGS)
 SHIPFLAGS += $(FLAGS)
 
@@ -49,20 +71,12 @@ SHIPFLAGS += $(FLAGS)
 SHIPFLAGS += "-DJL_SYSTEM_IMAGE_PATH=\"$(build_private_libdir_rel)/sys.$(SHLIB_EXT)\""
 DEBUGFLAGS += "-DJL_SYSTEM_IMAGE_PATH=\"$(build_private_libdir_rel)/sys-debug.$(SHLIB_EXT)\""
 
-ifeq ($(JULIAGC),MARKSWEEP)
-SRCS += gc
-endif
-
-ifeq ($(USE_COPY_STACKS),1)
-JCFLAGS += -DCOPY_STACKS
-endif
-
-FLISP_EXECUTABLE_debug = $(BUILDDIR)/flisp/flisp-debug
-FLISP_EXECUTABLE_release = $(BUILDDIR)/flisp/flisp
+FLISP_EXECUTABLE_debug := $(BUILDDIR)/flisp/flisp-debug
+FLISP_EXECUTABLE_release := $(BUILDDIR)/flisp/flisp
 ifeq ($(OS),WINNT)
-FLISP_EXECUTABLE = $(FLISP_EXECUTABLE_release)
+FLISP_EXECUTABLE := $(FLISP_EXECUTABLE_release)
 else
-FLISP_EXECUTABLE = $(FLISP_EXECUTABLE_$(JULIA_BUILD_MODE))
+FLISP_EXECUTABLE := $(FLISP_EXECUTABLE_$(JULIA_BUILD_MODE))
 endif
 
 default: $(JULIA_BUILD_MODE) # contains either "debug" or "release"
@@ -71,46 +85,62 @@ all: debug release
 release debug: %: libjulia-%
 
 $(BUILDDIR):
-	mkdir $(BUILDDIR)
+	mkdir -p $(BUILDDIR)
 
-$(BUILDDIR)/%.o: %.c $(HEADERS) | $(BUILDDIR)
+LLVM_CONFIG_ABSOLUTE := $(shell which $(LLVM_CONFIG))
+
+# source file rules
+$(BUILDDIR)/%.o: $(SRCDIR)/%.c $(HEADERS) | $(BUILDDIR)
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(SHIPFLAGS) $(DISABLE_ASSERTIONS) -c $< -o $@)
-$(BUILDDIR)/%.dbg.obj: %.c $(HEADERS) | $(BUILDDIR)
+$(BUILDDIR)/%.dbg.obj: $(SRCDIR)/%.c $(HEADERS) | $(BUILDDIR)
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(DEBUGFLAGS) -c $< -o $@)
-$(BUILDDIR)/%.o: %.cpp $(HEADERS) $(shell which $(LLVM_CONFIG)) | $(BUILDDIR)
-	@$(call PRINT_CC, $(CXX) $(call exec,$(LLVM_CONFIG) --cxxflags) $(CPPFLAGS) $(CXXFLAGS) $(SHIPFLAGS) -c $< -o $@)
-$(BUILDDIR)/%.dbg.obj: %.cpp $(HEADERS) $(shell which $(LLVM_CONFIG)) | $(BUILDDIR)
-	@$(call PRINT_CC, $(CXX) $(call exec,$(LLVM_CONFIG) --cxxflags) $(CPPFLAGS) $(CXXFLAGS) $(DEBUGFLAGS) -c $< -o $@)
-
-$(BUILDDIR)/julia_flisp.boot.inc: $(BUILDDIR)/julia_flisp.boot $(FLISP_EXECUTABLE)
-	@$(call PRINT_FLISP, $(call spawn,$(FLISP_EXECUTABLE)) ./bin2hex.scm < $< > $@)
-
-export julia_flisp_boot=$(BUILDDIR)/julia_flisp.boot
-$(julia_flisp_boot): julia-parser.scm julia-syntax.scm \
-	match.scm utils.scm jlfrontend.scm mk_julia_flisp_boot.scm $(FLISP_EXECUTABLE)
-	@$(call PRINT_FLISP, $(call spawn,$(FLISP_EXECUTABLE)) ./mk_julia_flisp_boot.scm)
-
-$(BUILDDIR)/ast.o $(BUILDDIR)/ast.dbg.obj: $(BUILDDIR)/julia_flisp.boot.inc flisp/*.h
-$(BUILDDIR)/codegen.o $(BUILDDIR)/codegen.dbg.obj: intrinsics.cpp cgutils.cpp ccall.cpp abi_*.cpp
-$(BUILDDIR)/builtins.o $(BUILDDIR)/builtins.dbg.obj: table.c
-$(BUILDDIR)/gc.o $(BUILDDIR)/gc.dbg.obj: gc-debug.c
-$(BUILDDIR)/signal-handling.o $(BUILDDIR)/signal-handling.dbg.obj: signals-*.c
-
-$(BUILDDIR)/support/libsupport.a: support/*.h support/*.c
-	$(MAKE) -C support BUILDDIR='$(abspath $(BUILDDIR)/support)'
-
-$(BUILDDIR)/support/libsupport-debug.a: support/*.h support/*.c
-	$(MAKE) -C support debug BUILDDIR='$(abspath $(BUILDDIR)/support)'
+$(BUILDDIR)/%.o: $(SRCDIR)/%.cpp $(SRCDIR)/llvm-version.h $(HEADERS) $(LLVM_CONFIG_ABSOLUTE) | $(BUILDDIR)
+	@$(call PRINT_CC, $(CXX) $(shell $(LLVM_CONFIG_HOST) --cxxflags) $(CPPFLAGS) $(CXXFLAGS) $(SHIPFLAGS) -c $< -o $@)
+$(BUILDDIR)/%.dbg.obj: $(SRCDIR)/%.cpp $(SRCDIR)/llvm-version.h $(HEADERS) $(LLVM_CONFIG_ABSOLUTE) | $(BUILDDIR)
+	@$(call PRINT_CC, $(CXX) $(shell $(LLVM_CONFIG_HOST) --cxxflags) $(CPPFLAGS) $(CXXFLAGS) $(DEBUGFLAGS) -c $< -o $@)
+
+libccalltest: $(build_shlibdir)/libccalltest.$(SHLIB_EXT)
+$(build_shlibdir)/libccalltest.$(SHLIB_EXT): $(SRCDIR)/ccalltest.c
+	@$(call PRINT_CC, $(CC) $(CFLAGS) $(CPPFLAGS) $(DEBUGFLAGS) -O3 $< $(fPIC) -shared -o $@ $(LDFLAGS))
+
+julia_flisp.boot.inc.phony: $(BUILDDIR)/julia_flisp.boot.inc
+
+$(BUILDDIR)/julia_flisp.boot.inc: $(BUILDDIR)/julia_flisp.boot $(FLISP_EXECUTABLE_release)
+	@$(call PRINT_FLISP, $(call spawn,$(FLISP_EXECUTABLE_release)) $(call cygpath_w,$(SRCDIR)/bin2hex.scm) < $< > $@)
+
+$(BUILDDIR)/julia_flisp.boot: $(addprefix $(SRCDIR)/,jlfrontend.scm \
+		julia-parser.scm julia-syntax.scm match.scm utils.scm ast.scm macroexpand.scm mk_julia_flisp_boot.scm) \
+		$(FLISP_EXECUTABLE_release)
+	@$(call PRINT_FLISP, $(call spawn,$(FLISP_EXECUTABLE_release)) \
+		$(call cygpath_w,$(SRCDIR)/mk_julia_flisp_boot.scm) $(call cygpath_w,$(dir $<)) $(notdir $<) $(call cygpath_w,$@))
+
+# additional dependency links
+$(BUILDDIR)/ast.o $(BUILDDIR)/ast.dbg.obj: $(BUILDDIR)/julia_flisp.boot.inc $(SRCDIR)/flisp/*.h
+$(BUILDDIR)/codegen.o $(BUILDDIR)/codegen.dbg.obj: $(addprefix $(SRCDIR)/,intrinsics.cpp intrinsics.h cgutils.cpp ccall.cpp jitlayers.cpp abi_*.cpp)
+$(BUILDDIR)/anticodegen.o $(BUILDDIR)/anticodegen.dbg.obj: $(SRCDIR)/intrinsics.h
+$(BUILDDIR)/builtins.o $(BUILDDIR)/builtins.dbg.obj: $(SRCDIR)/table.c
+$(BUILDDIR)/gc.o $(BUILDDIR)/gc.dbg.obj: $(SRCDIR)/gc-debug.c
+$(BUILDDIR)/signal-handling.o $(BUILDDIR)/signal-handling.dbg.obj: $(addprefix $(SRCDIR)/,signals-*.c)
+$(BUILDDIR)/dump.o $(BUILDDIR)/dump.dbg.obj: $(addprefix $(SRCDIR)/,common_symbols1.inc common_symbols2.inc)
+$(addprefix $(BUILDDIR)/,threading.o threading.dbg.obj gc.o gc.dbg.obj init.c init.dbg.obj task.o task.dbg.obj): $(addprefix $(SRCDIR)/,threading.h threadgroup.h)
+$(addprefix $(BUILDDIR)/,APInt-C.o APInt-C.dbg.obj runtime_intrinsics.o runtime_intrinsics.dbg.obj): $(SRCDIR)/APInt-C.h
+
+# archive library file rules
+$(BUILDDIR)/support/libsupport.a: $(SRCDIR)/support/*.h $(SRCDIR)/support/*.c
+	$(MAKE) -C $(SRCDIR)/support BUILDDIR='$(abspath $(BUILDDIR)/support)'
+
+$(BUILDDIR)/support/libsupport-debug.a: $(SRCDIR)/support/*.h $(SRCDIR)/support/*.c
+	$(MAKE) -C $(SRCDIR)/support debug BUILDDIR='$(abspath $(BUILDDIR)/support)'
 
 $(FLISP_EXECUTABLE_release): $(BUILDDIR)/flisp/libflisp.a
-$(BUILDDIR)/flisp/libflisp.a: flisp/*.h flisp/*.c $(BUILDDIR)/support/libsupport.a
-	$(MAKE) -C flisp BUILDDIR='$(abspath $(BUILDDIR)/flisp)'
+$(BUILDDIR)/flisp/libflisp.a: $(addprefix $(SRCDIR)/,flisp/*.h flisp/*.c) $(BUILDDIR)/support/libsupport.a
+	$(MAKE) -C $(SRCDIR)/flisp BUILDDIR='$(abspath $(BUILDDIR)/flisp)'
 
 $(FLISP_EXECUTABLE_debug): $(BUILDDIR)/flisp/libflisp-debug.a
-$(BUILDDIR)/flisp/libflisp-debug.a: flisp/*.h flisp/*.c $(BUILDDIR)/support/libsupport-debug.a
-	$(MAKE) -C flisp debug BUILDDIR='$(abspath $(BUILDDIR)/flisp)'
+$(BUILDDIR)/flisp/libflisp-debug.a: $(addprefix $(SRCDIR)/,flisp/*.h flisp/*.c) $(BUILDDIR)/support/libsupport-debug.a
+	$(MAKE) -C $(SRCDIR)/flisp debug BUILDDIR='$(abspath $(BUILDDIR)/flisp)'
 
-julia_version.h: ../VERSION
+$(BUILDDIR)/julia_version.h: $(JULIAHOME)/VERSION
 	@echo "// This is an autogenerated header file" > $@.$(JULIA_BUILD_MODE).tmp
 	@echo "#ifndef JULIA_VERSION_H" >> $@.$(JULIA_BUILD_MODE).tmp
 	@echo "#define JULIA_VERSION_H" >> $@.$(JULIA_BUILD_MODE).tmp
@@ -132,22 +162,22 @@ else
 CXXLD = $(LD) -dll -export:jl_setjmp -export:jl_longjmp
 endif
 
-$(build_shlibdir)/libjulia-debug.$(SHLIB_EXT): julia.expmap $(DOBJS) $(BUILDDIR)/flisp/libflisp-debug.a $(BUILDDIR)/support/libsupport-debug.a $(LIBUV)
+$(build_shlibdir)/libjulia-debug.$(SHLIB_EXT): $(SRCDIR)/julia.expmap $(DOBJS) $(BUILDDIR)/flisp/libflisp-debug.a $(BUILDDIR)/support/libsupport-debug.a $(LIBUV)
 	@$(call PRINT_LINK, $(CXXLD) $(CXXFLAGS) $(CXXLDFLAGS) $(DEBUGFLAGS) $(DOBJS) $(RPATH_ORIGIN) -o $@ $(LDFLAGS) $(JLIBLDFLAGS) $(DEBUG_LIBS))
 	$(INSTALL_NAME_CMD)libjulia-debug.$(SHLIB_EXT) $@
 	$(DSYMUTIL) $@
-$(BUILDDIR)/libjulia-debug.a: julia.expmap $(DOBJS) $(BUILDDIR)/flisp/libflisp-debug.a $(BUILDDIR)/support/libsupport-debug.a
+$(BUILDDIR)/libjulia-debug.a: $(SRCDIR)/julia.expmap $(DOBJS) $(BUILDDIR)/flisp/libflisp-debug.a $(BUILDDIR)/support/libsupport-debug.a
 	rm -f $@
 	@$(call PRINT_LINK, ar -rcs $@ $(DOBJS))
 libjulia-debug: $(build_shlibdir)/libjulia-debug.$(SHLIB_EXT)
 
 ifeq ($(SHLIB_EXT), so)
-  SONAME = -Wl,-soname=libjulia.so
+  SONAME := -Wl,-soname=libjulia.so
 else
-  SONAME =
+  SONAME :=
 endif
 
-$(build_shlibdir)/libjulia.$(SHLIB_EXT): julia.expmap $(OBJS) $(BUILDDIR)/flisp/libflisp.a $(BUILDDIR)/support/libsupport.a $(LIBUV)
+$(build_shlibdir)/libjulia.$(SHLIB_EXT): $(SRCDIR)/julia.expmap $(OBJS) $(BUILDDIR)/flisp/libflisp.a $(BUILDDIR)/support/libsupport.a $(LIBUV)
 	@$(call PRINT_LINK, $(CXXLD) $(CXXFLAGS) $(CXXLDFLAGS) $(SHIPFLAGS) $(OBJS) $(RPATH_ORIGIN) -o $@ $(LDFLAGS) $(JLIBLDFLAGS) $(RELEASE_LIBS) $(SONAME)) $(CXXLDFLAGS)
 	$(INSTALL_NAME_CMD)libjulia.$(SHLIB_EXT) $@
 	$(DSYMUTIL) $@
@@ -157,18 +187,18 @@ $(BUILDDIR)/libjulia.a: julia.expmap $(OBJS) $(BUILDDIR)/flisp/libflisp.a $(BUIL
 libjulia-release: $(build_shlibdir)/libjulia.$(SHLIB_EXT)
 
 clean:
-	-rm -f $(build_shlibdir)/libjulia*
+	-rm -fr $(build_shlibdir)/libjulia* $(build_shlibdir)/libccalltest*
 	-rm -f $(BUILDDIR)/julia_flisp.boot $(BUILDDIR)/julia_flisp.boot.inc
-	-rm -f $(BUILDDIR)/*.dbg.obj $(BUILDDIR)/*.o *~ $(BUILDDIR)/*.$(SHLIB_EXT) $(BUILDDIR)/*.a *#
+	-rm -f $(BUILDDIR)/*.dbg.obj $(BUILDDIR)/*.o $(BUILDDIR)/*.$(SHLIB_EXT) $(BUILDDIR)/*.a
 	-rm -f $(BUILDDIR)/julia_version.h
 
 clean-flisp:
-	-$(MAKE) -C flisp clean BUILDDIR='$(abspath $(BUILDDIR)/flisp)'
+	-$(MAKE) -C $(SRCDIR)/flisp clean BUILDDIR='$(abspath $(BUILDDIR)/flisp)'
 
 clean-support:
-	-$(MAKE) -C support clean BUILDDIR='$(abspath $(BUILDDIR)/support)'
+	-$(MAKE) -C $(SRCDIR)/support clean BUILDDIR='$(abspath $(BUILDDIR)/support)'
 
 
 cleanall: clean clean-flisp clean-support
 
-.PHONY: debug release clean cleanall clean-*
+.PHONY: default all debug release clean cleanall clean-* libccalltest julia_flisp.boot.inc.phony
diff --git a/src/Windows.mk b/src/Windows.mk
index b6c8e8dde0467..39d252e7039fe 100644
--- a/src/Windows.mk
+++ b/src/Windows.mk
@@ -46,7 +46,7 @@ LIB = $(LIB);C:\Program Files\llvm\lib\Debug
 LIB = $(LIB);C:\Program Files\llvm\lib\Release
 !endif
 
-CFLAGS = $(CFLAGS) -DCOPY_STACKS -D_CRT_SECURE_NO_WARNINGS
+CFLAGS = $(CFLAGS) -D_CRT_SECURE_NO_WARNINGS
 CFLAGS = $(CFLAGS) -DJL_SYSTEM_IMAGE_PATH=\"../lib/julia/sys.ji\" -DLIBRARY_EXPORTS
 
 LIBWINDOWS = \
diff --git a/src/abi_aarch64.cpp b/src/abi_aarch64.cpp
new file mode 100644
index 0000000000000..b71328d274e9b
--- /dev/null
+++ b/src/abi_aarch64.cpp
@@ -0,0 +1,336 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+//===----------------------------------------------------------------------===//
+//
+// The ABI implementation used for AArch64 targets.
+//
+//===----------------------------------------------------------------------===//
+//
+// The Procedure Call Standard can be found here:
+// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055b/IHI0055B_aapcs64.pdf
+//
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+typedef bool AbiState;
+static const AbiState default_abi_state = 0;
+
+static Type *get_llvm_fptype(jl_datatype_t *dt)
+{
+    // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
+    if (dt->mutabl || jl_datatype_nfields(dt) != 0)
+        return NULL;
+    Type *lltype;
+    // Check size first since it's cheaper.
+    switch (dt->size) {
+    case 2:
+        lltype = T_float16;
+        break;
+    case 4:
+        lltype = T_float32;
+        break;
+    case 8:
+        lltype = T_float64;
+        break;
+    case 16:
+        lltype = T_float128;
+        break;
+    default:
+        return NULL;
+    }
+    return jl_is_floattype((jl_value_t*)dt) ? lltype : NULL;
+}
+
+struct ElementType {
+    Type *type;
+    size_t sz;
+    ElementType() : type(nullptr), sz(0) {};
+};
+
+// Whether a type is a homogeneous floating-point aggregates (HFA) or a
+// homogeneous short-vector aggregates (HVA). Returns the element type.
+// We only handle HFA of HP, SP, DP and QP here since these are the only ones we
+// have (no vectors).
+// An Homogeneous Aggregate is a Composite Type where all of the Fundamental
+// Data Types of the members that compose the type are the same.
+// Note that it is the fundamental types that are important and not the member
+// types.
+static bool isHFAorHVA(jl_datatype_t *dt, size_t dsz, size_t &nele, ElementType &ele)
+{
+    // Assume:
+    //     dt is a pointerfree type, (all members are isbits)
+    //     dsz == dt->size > 0
+    //     0 <= nele <= 3
+
+    // We ignore zero sized member here. This isn't really consistent with
+    // GCC for zero-sized array members. GCC seems to treat structs with
+    // zero sized array members as non-HFA and non-HVA. Clang (3.7 and 3.8)
+    // handles this slightly differently.
+    // Ref https://llvm.org/bugs/show_bug.cgi?id=26162
+    while (size_t nfields = jl_datatype_nfields(dt)) {
+        // For composite types, find the first non zero sized member
+        size_t i;
+        size_t fieldsz;
+        for (i = 0;i < nfields;i++) {
+            if ((fieldsz = jl_field_size(dt, i))) {
+                break;
+            }
+        }
+        assert(i < nfields);
+        // If there's only one non zero sized member, try again on this member
+        if (fieldsz == dsz) {
+            dt = (jl_datatype_t*)jl_field_type(dt, i);
+            continue;
+        }
+        // Otherwise, process each members
+        for (;i < nfields;i++) {
+            size_t fieldsz = jl_field_size(dt, i);
+            if (fieldsz == 0)
+                continue;
+            jl_datatype_t *fieldtype = (jl_datatype_t*)jl_field_type(dt, i);
+            // Check element count.
+            // This needs to be done after the zero size member check
+            if (nele > 3 || !isHFAorHVA(fieldtype, fieldsz, nele, ele)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // For bitstypes
+    if (ele.sz && dsz != ele.sz)
+        return false;
+    Type *new_type = get_llvm_fptype(dt);
+    if (new_type && (!ele.type || ele.type == new_type)) {
+        ele.type = new_type;
+        ele.sz = dsz;
+        nele++;
+        return true;
+    }
+    return false;
+}
+
+static Type *isHFAorHVA(jl_datatype_t *dt, size_t &nele)
+{
+    // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
+
+    // An Homogeneous Floating-point Aggregate (HFA) is an Homogeneous Aggregate
+    // with a Fundamental Data Type that is a Floating-Point type and at most
+    // four uniquely addressable members.
+    // An Homogeneous Short-Vector Aggregate (HVA) is an Homogeneous Aggregate
+    // with a Fundamental Data Type that is a Short-Vector type and at most four
+    // uniquely addressable members.
+    // Maximum HFA and HVA size is 64 bytes (4 x fp128 or 16bytes vector)
+    size_t dsz = dt->size;
+    if (dsz > 64 || !dt->pointerfree || dt->haspadding)
+        return NULL;
+    nele = 0;
+    ElementType eltype;
+    if (isHFAorHVA(dt, dsz, nele, eltype))
+        return eltype.type;
+    return NULL;
+}
+
+void needPassByRef(AbiState*, jl_value_t *ty, bool *byRef, bool*)
+{
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+    // B.2
+    //   If the argument type is an HFA or an HVA, then the argument is used
+    //   unmodified.
+    size_t size;
+    if (isHFAorHVA(dt, size))
+        return;
+    // B.3
+    //   If the argument type is a Composite Type that is larger than 16 bytes,
+    //   then the argument is copied to memory allocated by the caller and the
+    //   argument is replaced by a pointer to the copy.
+    // We only check for the total size and not whether it is a composite type
+    // since there's no corresponding C type and we just treat such large
+    // bitstype as a composite type of the right size.
+    *byRef = dt->size > 16;
+    // B.4
+    //   If the argument type is a Composite Type then the size of the argument
+    //   is rounded up to the nearest multiple of 8 bytes.
+}
+
+bool need_private_copy(jl_value_t*, bool)
+{
+    return false;
+}
+
+// Determine which kind of register the argument will be passed in and
+// if the argument has to be passed on stack (including by reference).
+//
+// If the argument should be passed in SIMD and floating-point registers,
+// we may need to rewrite the argument types to [n x ftype].
+// If the argument should be passed in general purpose registers, we may need
+// to rewrite the argument types to [n x i64].
+//
+// If the argument has to be passed on stack, we need to use sret.
+//
+// All the out parameters should be default to `false`.
+static Type *classify_arg(jl_value_t *ty, bool *fpreg, bool *onstack,
+                          size_t *rewrite_len)
+{
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+
+    // Based on section 5.4 C of the Procedure Call Standard
+    // C.1
+    //   If the argument is a Half-, Single-, Double- or Quad- precision
+    //   Floating-point or Short Vector Type and the NSRN is less than 8, then
+    //   the argument is allocated to the least significant bits of register
+    //   v[NSRN]. The NSRN is incremented by one. The argument has now been
+    //   allocated.
+    // Note that this is missing QP float as well as short vector types since we
+    // don't really have those types.
+    if (get_llvm_fptype(dt)) {
+        *fpreg = true;
+        return NULL;
+    }
+
+    // C.2
+    //   If the argument is an HFA or an HVA and there are sufficient
+    //   unallocated SIMD and Floating-point registers (NSRN + number of
+    //   members <= 8), then the argument is allocated to SIMD and
+    //   Floating-point Registers (with one register per member of the HFA
+    //   or HVA). The NSRN is incremented by the number of registers used.
+    //   The argument has now been allocated.
+    if (Type *eltype = isHFAorHVA(dt, *rewrite_len)) {
+        assert(*rewrite_len > 0 && *rewrite_len <= 4);
+        // HFA and HVA have <= 4 members
+        *fpreg = true;
+        // Rewrite to [n x eltype] where n is the number of fundamental types.
+        return eltype;
+    }
+
+    // Check if the argument needs to be passed by reference. This should be
+    // done before starting step C but we do this here to avoid checking for
+    // HFA and HVA twice. We don't check whether it is a composite type.
+    // See `needPassByRef` above.
+    if (dt->size > 16) {
+        *onstack = true;
+        return NULL;
+    }
+
+    // C.3
+    //   If the argument is an HFA or an HVA then the NSRN is set to 8 and the
+    //   size of the argument is rounded up to the nearest multiple of 8 bytes.
+    // C.4
+    //   If the argument is an HFA, an HVA, a Quad-precision Floating-point or
+    //   Short Vector Type then the NSAA is rounded up to the larger of 8 or
+    //   the Natural Alignment of the argument’s type.
+    // C.5
+    //   If the argument is a Half- or Single- precision Floating Point type,
+    //   then the size of the argument is set to 8 bytes. The effect is as if
+    //   the argument had been copied to the least significant bits of a 64-bit
+    //   register and the remaining bits filled with unspecified values.
+    // C.6
+    //   If the argument is an HFA, an HVA, a Half-, Single-, Double- or
+    //   Quad- precision Floating-point or Short Vector Type, then the argument
+    //   is copied to memory at the adjusted NSAA. The NSAA is incremented
+    //   by the size of the argument. The argument has now been allocated.
+    // <already included in the C.2 case above>
+    // C.7
+    //   If the argument is an Integral or Pointer Type, the size of the
+    //   argument is less than or equal to 8 bytes and the NGRN is less than 8,
+    //   the argument is copied to the least significant bits in x[NGRN].
+    //   The NGRN is incremented by one. The argument has now been allocated.
+    // Here we treat any bitstype of the right size as integers or pointers
+    // This is needed for types like Cstring which should be treated as
+    // pointers. We don't need to worry about floating points here since they
+    // are handled above.
+    if (jl_is_immutable(dt) && jl_datatype_nfields(dt) == 0 &&
+        (dt->size == 1 || dt->size == 2 || dt->size == 4 ||
+         dt->size == 8 || dt->size == 16))
+        return NULL;
+
+    // C.8
+    //   If the argument has an alignment of 16 then the NGRN is rounded up to
+    //   the next even number.
+    // C.9
+    //   If the argument is an Integral Type, the size of the argument is equal
+    //   to 16 and the NGRN is less than 7, the argument is copied to x[NGRN]
+    //   and x[NGRN+1]. x[NGRN] shall contain the lower addressed double-word
+    //   of the memory representation of the argument. The NGRN is incremented
+    //   by two. The argument has now been allocated.
+    // <merged into C.7 above>
+    // C.10
+    //   If the argument is a Composite Type and the size in double-words of
+    //   the argument is not more than 8 minus NGRN, then the argument is
+    //   copied into consecutive general-purpose registers, starting at x[NGRN].
+    //   The argument is passed as though it had been loaded into the registers
+    //   from a double-word-aligned address with an appropriate sequence of LDR
+    //   instructions loading consecutive registers from memory (the contents of
+    //   any unused parts of the registers are unspecified by this standard).
+    //   The NGRN is incremented by the number of registers used. The argument
+    //   has now been allocated.
+    // We don't check for composite types here since the ones that have
+    // corresponding C types are already handled and we just treat the ones
+    // with weird size as a black box composite type.
+    // The type can fit in 8 x 8 bytes since it is handled by
+    // need_pass_by_ref otherwise.
+    // 0-size types (Void) won't be rewritten and that is what we want
+    assert(dt->size <= 16); // Should be pass by reference otherwise
+    *rewrite_len = (dt->size + 7) >> 3;
+    // Rewrite to [n x Int64] where n is the **size in dword**
+    return dt->size ? T_int64 : NULL;
+
+    // C.11
+    //   The NGRN is set to 8.
+    // C.12
+    //   The NSAA is rounded up to the larger of 8 or the Natural Alignment
+    //   of the argument’s type.
+    // C.13
+    //   If the argument is a composite type then the argument is copied to
+    //   memory at the adjusted NSAA. The NSAA is incremented by the size of
+    //   the argument. The argument has now been allocated.
+    // <handled by C.10 above>
+    // C.14
+    //   If the size of the argument is less than 8 bytes then the size of the
+    //   argument is set to 8 bytes. The effect is as if the argument was
+    //   copied to the least significant bits of a 64-bit register and the
+    //   remaining bits filled with unspecified values.
+    // C.15
+    //   The argument is copied to memory at the adjusted NSAA. The NSAA is
+    //   incremented by the size of the argument. The argument has now been
+    //   allocated.
+    // <handled by C.10 above>
+}
+
+bool use_sret(AbiState*, jl_value_t *ty)
+{
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    // Section 5.5
+    // If the type, T, of the result of a function is such that
+    //
+    //     void func(T arg)
+    //
+    // would require that arg be passed as a value in a register (or set of
+    // registers) according to the rules in section 5.4 Parameter Passing,
+    // then the result is returned in the same registers as would be used for
+    // such an argument.
+    bool fpreg = false;
+    bool onstack = false;
+    size_t rewrite_len = 0;
+    classify_arg(ty, &fpreg, &onstack, &rewrite_len);
+    return onstack;
+}
+
+Type *preferred_llvm_type(jl_value_t *ty, bool)
+{
+    if (!jl_is_datatype(ty) || jl_is_abstracttype(ty))
+        return NULL;
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+    if (Type *fptype = get_llvm_fptype(dt))
+        return fptype;
+    bool fpreg = false;
+    bool onstack = false;
+    size_t rewrite_len = 0;
+    if (Type *rewrite_ty = classify_arg(ty, &fpreg, &onstack, &rewrite_len))
+        return ArrayType::get(rewrite_ty, rewrite_len);
+    return NULL;
+}
+
+}
diff --git a/src/abi_arm.cpp b/src/abi_arm.cpp
new file mode 100644
index 0000000000000..10be75a94e6ed
--- /dev/null
+++ b/src/abi_arm.cpp
@@ -0,0 +1,300 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+//===----------------------------------------------------------------------===//
+//
+// The ABI implementation used for ARM targets.
+//
+//===----------------------------------------------------------------------===//
+//
+// The Procedure Call Standard can be found here:
+// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042f/IHI0042F_aapcs.pdf
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __ARM_EABI__
+#  error "the Julia ARM ABI implementation only supports EABI"
+#endif
+
+#ifndef __ARM_PCS_VFP
+#  error "the Julia ARM ABI implementation requires VFP support"
+#endif
+
+namespace {
+
+typedef bool AbiState;
+AbiState default_abi_state = 0;
+
+void needPassByRef(AbiState *state,jl_value_t *ty, bool *byRef, bool *inReg)
+{
+    return;
+}
+
+bool need_private_copy(jl_value_t *ty, bool byRef)
+{
+    return false;
+}
+
+static Type *get_llvm_fptype(jl_datatype_t *dt)
+{
+    // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
+    if (dt->mutabl || jl_datatype_nfields(dt) != 0)
+        return NULL;
+    Type *lltype;
+    // Check size first since it's cheaper.
+    switch (dt->size) {
+    case 2:
+        lltype = T_float16;
+        break;
+    case 4:
+        lltype = T_float32;
+        break;
+    case 8:
+        lltype = T_float64;
+        break;
+    default:
+        return NULL;
+    }
+    return jl_is_floattype((jl_value_t*)dt) ? lltype : NULL;
+}
+
+static size_t isLegalHA(jl_datatype_t *dt, Type *&base);
+
+// Check whether a type contained by a candidate homogeneous aggregate is valid
+// fundamental type.
+//
+// Returns the corresponding LLVM type.
+static Type *isLegalHAType(jl_datatype_t *dt)
+{
+    // single- or double-precision floating-point type
+    if (Type *fp = get_llvm_fptype(dt))
+        return fp;
+
+    // NOT SUPPORTED: 64- or 128-bit containerized vectors
+
+    return NULL;
+}
+
+// Check whether a type is a legal homogeneous aggregate.
+// Returns the number of fundamental members.
+//
+// Legality of the HA is determined by a nonzero return value.
+// In case of a non-legal HA, the value of 'base' is undefined.
+static size_t isLegalHA(jl_datatype_t *dt, Type *&base)
+{
+    // Homogeneous aggregates are only used for VFP registers,
+    // so use that definition of legality (section 6.1.2.1)
+
+    if (jl_is_structtype(dt)) {
+        // Fast path checks before descending the type hierarchy
+        // (4 x 128b vector == 64B max size)
+        if (dt->size > 64 || !dt->pointerfree || dt->haspadding)
+            return 0;
+
+        base = NULL;
+        size_t total_members = 0;
+
+        size_t parent_members = jl_datatype_nfields(dt);
+        for (size_t i = 0; i < parent_members; ++i) {
+            jl_datatype_t *fdt = (jl_datatype_t*)jl_field_type(dt,i);
+
+            Type *T = isLegalHAType(fdt);
+            if (T)
+                total_members++;
+            else if (size_t field_members = isLegalHA(fdt, T))
+                // recursive application (expanding nested composite types)
+                total_members += field_members;
+            else
+                return 0;
+
+            if (!base)
+                base = T;
+            else if (base != T)
+                return 0;
+        }
+
+        // ... with one to four Elements.
+        if (total_members < 1 || total_members > 4)
+            return 0;
+
+        return total_members;
+    }
+
+    return 0;
+}
+
+// Determine if an argument can be passed through a coprocessor register.
+//
+// All the out parameters should be default to `false`.
+static void classify_cprc(jl_datatype_t *dt, bool *vfp)
+{
+    // Based on section 6.1 of the Procedure Call Standard
+
+    // VFP: 6.1.2.1
+    // - A half-precision floating-point type.
+    // - A single-precision floating-point type.
+    // - A double-precision floating-point type.
+    if (get_llvm_fptype(dt)) {
+        *vfp = true;
+        return;
+    }
+
+    // NOT SUPPORTED: A 64-bit or 128-bit containerized vector type.
+
+    // - A Homogeneous Aggregate
+    Type *base = NULL;
+    if (isLegalHA(dt, base)) {
+        *vfp = true;
+        return;
+    }
+}
+
+static void classify_return_arg(jl_value_t *ty, bool *reg,
+                                bool *onstack, bool *need_rewrite)
+{
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+
+    // Based on section 5.4 of the Procedure Call Standard
+
+    // VFP standard variant: see 6.1.2.2
+    //   Any result whose type would satisfy the conditions for a VFP CPRC is
+    //   returned in the appropriate number of consecutive VFP registers
+    //   starting with the lowest numbered register (s0, d0, q0).
+    classify_cprc(dt, reg);
+    if (*reg)
+        return;
+
+    // - A Half-precision Floating Point Type is returned in the least
+    //   significant 16 bits of r0.
+    if (dt == jl_float16_type) {
+        *reg = true;
+        return;
+    }
+
+    // - A Fundamental Data Type that is smaller than 4 bytes is zero- or
+    //   sign-extended to a word and returned in r0.
+    // - A double-word sized Fundamental Data Type (e.g., long long, double and
+    //   64-bit containerized vectors) is returned in r0 and r1.
+    // - A word-sized Fundamental Data Type (eg., int, float) is returned in r0.
+    // NOTE: assuming "fundamental type" == jl_is_bitstype, might need exact def
+    if (jl_is_bitstype(dt) && dt->size <= 8) {
+        *reg = true;
+        return;
+    }
+
+    // If we ever support containerized vectors on an ARMv7 without VFP,
+    // these can be returned in r0-r3 as well.
+
+    // NOTE: we don't check for jl_is_structtype below, because at this point
+    //       everything will be rewritten to look like a composite aggregate
+    *need_rewrite = true;
+
+    // - A Composite Type not larger than 4 bytes is returned in r0. The format
+    //   is as if the result had been stored in memory at a word-aligned address
+    //   and then loaded into r0 with an LDR instruction. Any bits in r0 that
+    //   lie outside the bounds of the result have unspecified values.
+    // - A Composite Type larger than 4 bytes, or whose size cannot be
+    //   determined statically by both caller and callee, is stored in memory at
+    //   an address passed as an extra argument when the function was called
+    //   (§5.5, rule A.4). The memory to be used for the result may be modified
+    //   at any point during the function call.
+    if (dt->size <= 4)
+        *reg = true;
+    else
+        *onstack = true;
+}
+
+bool use_sret(AbiState *state, jl_value_t *ty)
+{
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+
+    bool reg = false;
+    bool onstack = false;
+    bool need_rewrite = false;
+    classify_return_arg(ty, &reg, &onstack, &need_rewrite);
+
+    return onstack;
+}
+
+// Determine which kind of register the argument will be passed in and
+// if the argument has to be passed on stack (including by reference).
+//
+// If the argument should be passed in SIMD and floating-point registers,
+// we may need to rewrite the argument types to [n x ftype].
+// If the argument should be passed in general purpose registers, we may need
+// to rewrite the argument types to [n x i64].
+//
+// If the argument has to be passed on stack, we need to use sret.
+//
+// All the out parameters should be default to `false`.
+static void classify_arg(jl_value_t *ty, bool *reg,
+                         bool *onstack, bool *need_rewrite)
+{
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+
+    // Based on section 5.5 of the Procedure Call Standard
+
+    // C.1.cp
+    //   If the argument is a CPRC and there are sufficient unallocated
+    //   co-processor registers of the appropriate class, the argument is
+    //   allocated to co-processor registers.
+    classify_cprc(dt, reg);
+    if (*reg)
+        return;
+
+    // Handle fundamental types
+    if (jl_is_bitstype(dt) && dt->size <= 8) {
+        *reg = true;
+        return;
+    }
+
+    *need_rewrite = true;
+}
+
+Type *preferred_llvm_type(jl_value_t *ty, bool isret)
+{
+    if (!jl_is_datatype(ty) || jl_is_abstracttype(ty))
+        return NULL;
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+
+    if (Type *fptype = get_llvm_fptype(dt))
+        return fptype;
+
+    bool reg = false;
+    bool onstack = false;
+    bool need_rewrite = false;
+    if (isret)
+        classify_return_arg(ty, &reg, &onstack, &need_rewrite);
+    else
+        classify_arg(ty, &reg, &onstack, &need_rewrite);
+
+    if (!need_rewrite)
+        return NULL;
+
+    // Based on section 4 of the Procedure Call Standard
+
+    // If some type is illegal and needs to be rewritten,
+    // represent it as an aggregate composite type.
+
+    // 4.3.1: aggregates
+    // - The alignment of an aggregate shall be the alignment of its
+    //   most-aligned component.
+    // - The size of an aggregate shall be the smallest multiple of its
+    //   alignment that is sufficient to hold all of its members when they are
+    //   laid out according to these rules.
+    // 5.5 B.5
+    //   For a Composite Type, the alignment of the copy will have 4-byte
+    //   alignment if its natural alignment is <= 4 and 8-byte alignment if
+    //   its natural alignment is >= 8
+    size_t align = dt->alignment;
+    if (align < 4)
+        align = 4;
+    if (align > 8)
+        align = 8;
+
+    Type *T = Type::getIntNTy(getGlobalContext(), align*8);
+    return ArrayType::get(T, (dt->size + align - 1) / align);
+}
+
+}
diff --git a/src/abi_win32.cpp b/src/abi_win32.cpp
index 24069dc6f5bca..5fa6b7fa42adf 100644
--- a/src/abi_win32.cpp
+++ b/src/abi_win32.cpp
@@ -42,34 +42,34 @@ AbiState default_abi_state = 0;
 
 bool use_sret(AbiState *state, jl_value_t *ty)
 {
-    if (!jl_is_datatype(ty) || jl_is_abstracttype(ty) || jl_is_cpointer_type(ty) || jl_is_array_type(ty))
-        return false;
-    size_t size = jl_datatype_size(ty);
-    if (size <= 8)
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+    // Use sret if the size of the argument is not one of 1, 2, 4, 8 bytes
+    // This covers the special case of Complex64
+    size_t size = dt->size;
+    if (size == 1 || size == 2 || size == 4 || size == 8)
         return false;
     return true;
 }
 
 void needPassByRef(AbiState *state, jl_value_t *ty, bool *byRef, bool *inReg)
 {
-    if (!jl_is_datatype(ty) || jl_is_abstracttype(ty) || jl_is_cpointer_type(ty) || jl_is_array_type(ty))
-        return;
-    size_t size = jl_datatype_size(ty);
-    if (size <= 8)
-        return;
-    *byRef = true;
+    // Assume jl_is_datatype(ty) && !jl_is_abstracttype(ty)
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+    // Use pass by reference for all structs
+    *byRef = dt->nfields > 0;
 }
 
 Type *preferred_llvm_type(jl_value_t *ty, bool isret)
 {
-    if (!isret)
+    // Arguments are either scalar or passed by value
+    if (!isret || !jl_is_datatype(ty) || jl_is_abstracttype(ty))
         return NULL;
-    if (!jl_is_datatype(ty) || jl_is_abstracttype(ty) || jl_is_cpointer_type(ty) || jl_is_array_type(ty))
+    jl_datatype_t *dt = (jl_datatype_t*)ty;
+    // rewrite integer sized (non-sret) struct to the corresponding integer
+    if (!dt->nfields || use_sret(NULL, ty))
         return NULL;
-    size_t size = jl_datatype_size(ty);
-    if (size > 0 && size <= 8 && !jl_is_bitstype(ty))
-        return Type::getIntNTy(getGlobalContext(), size*8);
-    return NULL;
+    return Type::getIntNTy(getGlobalContext(), dt->size * 8);
 }
 
 bool need_private_copy(jl_value_t *ty, bool byRef)
diff --git a/src/abi_x86_64.cpp b/src/abi_x86_64.cpp
index 08aac96aa52cc..af2596f5b24a6 100644
--- a/src/abi_x86_64.cpp
+++ b/src/abi_x86_64.cpp
@@ -51,12 +51,14 @@ struct Classification {
     bool isMemory;
     ArgClass classes[2];
 
-    Classification() : isMemory(false) {
+    Classification() : isMemory(false)
+    {
         classes[0] = NoClass;
         classes[1] = NoClass;
     }
 
-    void addField(unsigned offset, ArgClass cl) {
+    void addField(unsigned offset, ArgClass cl)
+    {
         if (isMemory)
             return;
 
@@ -77,7 +79,8 @@ struct Classification {
         }
     }
 
-    static ArgClass merge(ArgClass accum, ArgClass cl) {
+    static ArgClass merge(ArgClass accum, ArgClass cl)
+    {
         if (accum == cl)
             return accum;
         if (accum == NoClass)
@@ -103,7 +106,8 @@ struct Classification {
         // make sure other half knows about it too:
         accum.addField(offset+16, ComplexX87);
     } */
-void classifyType(Classification& accum, jl_value_t* ty, uint64_t offset) {
+void classifyType(Classification& accum, jl_value_t *ty, uint64_t offset)
+{
     // Floating point types
     if (ty == (jl_value_t*)jl_float64_type || ty == (jl_value_t*)jl_float32_type) {
         accum.addField(offset, Sse);
@@ -133,7 +137,8 @@ void classifyType(Classification& accum, jl_value_t* ty, uint64_t offset) {
     else if (jl_datatype_size(ty) <= 16) {
         size_t i;
         for (i = 0; i < jl_datatype_nfields(ty); ++i) {
-            classifyType(accum, jl_field_type(ty,i), offset + jl_field_offset(ty,i));
+            classifyType(accum, jl_field_type((jl_datatype_t*)ty,i),
+                         offset + jl_field_offset((jl_datatype_t*)ty,i));
         }
     }
     else {
@@ -141,7 +146,8 @@ void classifyType(Classification& accum, jl_value_t* ty, uint64_t offset) {
     }
 }
 
-Classification classify(jl_value_t* ty) {
+Classification classify(jl_value_t *ty)
+{
     Classification cl;
     classifyType(cl, ty, 0);
     return cl;
diff --git a/src/alloc.c b/src/alloc.c
index 522bbba61d5d0..69ebce3e634b5 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -14,16 +14,12 @@
 extern "C" {
 #endif
 
-DLLEXPORT jl_value_t *jl_true;
-DLLEXPORT jl_value_t *jl_false;
+JL_DLLEXPORT jl_value_t *jl_true;
+JL_DLLEXPORT jl_value_t *jl_false;
 
 jl_tvar_t     *jl_typetype_tvar;
 jl_datatype_t *jl_typetype_type;
 jl_value_t    *jl_ANY_flag;
-jl_datatype_t *jl_function_type;
-jl_datatype_t *jl_box_type;
-jl_value_t *jl_box_any_type;
-jl_typename_t *jl_box_typename;
 
 jl_datatype_t *jl_typector_type;
 
@@ -32,7 +28,6 @@ jl_typename_t *jl_array_typename;
 jl_value_t *jl_array_uint8_type;
 jl_value_t *jl_array_any_type=NULL;
 jl_value_t *jl_array_symbol_type;
-jl_function_t *jl_bottom_func;
 jl_datatype_t *jl_weakref_type;
 jl_datatype_t *jl_ascii_string_type;
 jl_datatype_t *jl_utf8_string_type;
@@ -66,11 +61,11 @@ jl_value_t *jl_stackovf_exception;
 #ifdef SEGV_EXCEPTION
 jl_value_t *jl_segv_exception;
 #endif
-DLLEXPORT jl_value_t *jl_diverror_exception;
-DLLEXPORT jl_value_t *jl_domain_exception;
-DLLEXPORT jl_value_t *jl_overflow_exception;
-DLLEXPORT jl_value_t *jl_inexact_exception;
-DLLEXPORT jl_value_t *jl_undefref_exception;
+JL_DLLEXPORT jl_value_t *jl_diverror_exception;
+JL_DLLEXPORT jl_value_t *jl_domain_exception;
+JL_DLLEXPORT jl_value_t *jl_overflow_exception;
+JL_DLLEXPORT jl_value_t *jl_inexact_exception;
+JL_DLLEXPORT jl_value_t *jl_undefref_exception;
 jl_value_t *jl_interrupt_exception;
 jl_datatype_t *jl_boundserror_type;
 jl_value_t *jl_memory_exception;
@@ -88,22 +83,23 @@ jl_sym_t *goto_sym;    jl_sym_t *goto_ifnot_sym;
 jl_sym_t *label_sym;   jl_sym_t *return_sym;
 jl_sym_t *lambda_sym;  jl_sym_t *assign_sym;
 jl_sym_t *null_sym;    jl_sym_t *body_sym;
-jl_sym_t *macro_sym;   jl_sym_t *method_sym;
+jl_sym_t *method_sym;
 jl_sym_t *enter_sym;   jl_sym_t *leave_sym;
 jl_sym_t *exc_sym;     jl_sym_t *error_sym;
-jl_sym_t *static_typeof_sym; jl_sym_t *kw_sym;
+jl_sym_t *static_typeof_sym;
 jl_sym_t *new_sym;     jl_sym_t *using_sym;
 jl_sym_t *const_sym;   jl_sym_t *thunk_sym;
 jl_sym_t *anonymous_sym;  jl_sym_t *underscore_sym;
 jl_sym_t *abstracttype_sym; jl_sym_t *bitstype_sym;
 jl_sym_t *compositetype_sym; jl_sym_t *type_goto_sym;
-jl_sym_t *global_sym; jl_sym_t *tuple_sym;
+jl_sym_t *global_sym; jl_sym_t *list_sym;
 jl_sym_t *dot_sym;    jl_sym_t *newvar_sym;
-jl_sym_t *boundscheck_sym; jl_sym_t *copyast_sym;
-jl_sym_t *fastmath_sym;
-jl_sym_t *simdloop_sym; jl_sym_t *meta_sym;
-jl_sym_t *arrow_sym;  jl_sym_t *inert_sym;
-jl_sym_t *vararg_sym;
+jl_sym_t *boundscheck_sym; jl_sym_t *inbounds_sym;
+jl_sym_t *copyast_sym; jl_sym_t *fastmath_sym;
+jl_sym_t *pure_sym; jl_sym_t *simdloop_sym;
+jl_sym_t *meta_sym;
+jl_sym_t *inert_sym; jl_sym_t *vararg_sym;
+jl_sym_t *unused_sym; jl_sym_t *stknew_sym;
 
 typedef struct {
     int64_t a;
@@ -153,31 +149,12 @@ static jl_value_t *jl_new_bits_internal(jl_value_t *dt, void *data, size_t *len)
     return v;
 }
 
-jl_value_t *jl_new_bits(jl_value_t *bt, void *data)
+JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *bt, void *data)
 {
     size_t len = 0;
     return jl_new_bits_internal(bt, data, &len);
 }
 
-// run time version of pointerref intrinsic
-DLLEXPORT jl_value_t *jl_pointerref(jl_value_t *p, jl_value_t *i)
-{
-    JL_TYPECHK(pointerref, pointer, p);
-    JL_TYPECHK(pointerref, long, i);
-    jl_value_t *ety = jl_tparam0(jl_typeof(p));
-    if (ety == (jl_value_t*)jl_any_type) {
-        jl_value_t **pp = (jl_value_t**)(jl_unbox_long(p) + (jl_unbox_long(i)-1)*sizeof(void*));
-        return *pp;
-    }
-    else {
-        if (!jl_is_datatype(ety))
-            jl_error("pointerref: invalid pointer");
-        size_t nb = LLT_ALIGN(jl_datatype_size(ety), ((jl_datatype_t*)ety)->alignment);
-        char *pp = (char*)jl_unbox_long(p) + (jl_unbox_long(i)-1)*nb;
-        return jl_new_bits(ety, pp);
-    }
-}
-
 void jl_assign_bits(void *dest, jl_value_t *bits)
 {
     size_t nb = jl_datatype_size(jl_typeof(bits));
@@ -192,28 +169,7 @@ void jl_assign_bits(void *dest, jl_value_t *bits)
     }
 }
 
-// run time version of pointerset intrinsic
-DLLEXPORT void jl_pointerset(jl_value_t *p, jl_value_t *x, jl_value_t *i)
-{
-    JL_TYPECHK(pointerset, pointer, p);
-    JL_TYPECHK(pointerset, long, i);
-    jl_value_t *ety = jl_tparam0(jl_typeof(p));
-    if (ety == (jl_value_t*)jl_any_type) {
-        jl_value_t **pp = (jl_value_t**)(jl_unbox_long(p) + (jl_unbox_long(i)-1)*sizeof(void*));
-        *pp = x;
-    }
-    else {
-        if (!jl_is_datatype(ety))
-            jl_error("pointerset: invalid pointer");
-        size_t nb = LLT_ALIGN(jl_datatype_size(ety), ((jl_datatype_t*)ety)->alignment);
-        char *pp = (char*)jl_unbox_long(p) + (jl_unbox_long(i)-1)*nb;
-        if (jl_typeof(x) != ety)
-            jl_error("pointerset: type mismatch in assign");
-        jl_assign_bits(pp, x);
-    }
-}
-
-int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err)
+JL_DLLEXPORT int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err)
 {
     jl_svec_t *fn = t->name->names;
     for(size_t i=0; i < jl_svec_len(fn); i++) {
@@ -222,11 +178,12 @@ int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err)
         }
     }
     if (err)
-        jl_errorf("type %s has no field %s", t->name->name->name, fld->name);
+        jl_errorf("type %s has no field %s", jl_symbol_name(t->name->name),
+                  jl_symbol_name(fld));
     return -1;
 }
 
-jl_value_t *jl_get_nth_field(jl_value_t *v, size_t i)
+JL_DLLEXPORT jl_value_t *jl_get_nth_field(jl_value_t *v, size_t i)
 {
     jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
     assert(i < jl_datatype_nfields(st));
@@ -237,7 +194,7 @@ jl_value_t *jl_get_nth_field(jl_value_t *v, size_t i)
     return jl_new_bits(jl_field_type(st,i), (char*)v + offs);
 }
 
-jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i)
+JL_DLLEXPORT jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i)
 {
     jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
     if (i >= jl_datatype_nfields(st))
@@ -252,7 +209,7 @@ jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i)
     return jl_new_bits(jl_field_type(st,i), (char*)v + offs);
 }
 
-void jl_set_nth_field(jl_value_t *v, size_t i, jl_value_t *rhs)
+JL_DLLEXPORT void jl_set_nth_field(jl_value_t *v, size_t i, jl_value_t *rhs)
 {
     jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
     size_t offs = jl_field_offset(st,i);
@@ -265,7 +222,7 @@ void jl_set_nth_field(jl_value_t *v, size_t i, jl_value_t *rhs)
     }
 }
 
-int jl_field_isdefined(jl_value_t *v, size_t i)
+JL_DLLEXPORT int jl_field_isdefined(jl_value_t *v, size_t i)
 {
     jl_datatype_t *st = (jl_datatype_t*)jl_typeof(v);
     size_t offs = jl_field_offset(st,i);
@@ -275,7 +232,7 @@ int jl_field_isdefined(jl_value_t *v, size_t i)
     return 1;
 }
 
-DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...)
+JL_DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...)
 {
     if (type->instance != NULL) return type->instance;
     va_list args;
@@ -289,7 +246,8 @@ DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...)
     return jv;
 }
 
-DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uint32_t na)
+JL_DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args,
+                                        uint32_t na)
 {
     if (type->instance != NULL) return type->instance;
     size_t nf = jl_datatype_nfields(type);
@@ -298,13 +256,14 @@ DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uin
         jl_set_nth_field(jv, i, args[i]);
     }
     for(size_t i=na; i < nf; i++) {
-        if (type->fields[i].isptr)
+        if (jl_field_isptr(type, i)) {
             *(jl_value_t**)((char*)jl_data_ptr(jv)+jl_field_offset(type,i)) = NULL;
+        }
     }
     return jv;
 }
 
-DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type)
+JL_DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type)
 {
     if (type->instance != NULL) return type->instance;
     jl_value_t *jv = newstruct(type);
@@ -313,44 +272,26 @@ DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type)
     return jv;
 }
 
-DLLEXPORT jl_function_t *jl_new_closure(jl_fptr_t fptr, jl_value_t *env,
-                                        jl_lambda_info_t *linfo)
-{
-    jl_function_t *f = (jl_function_t*)jl_gc_alloc_3w(); assert(NWORDS(sizeof(jl_function_t))==3);
-    jl_set_typeof(f, jl_function_type);
-    f->fptr = (fptr!=NULL ? fptr : linfo->fptr);
-    f->env = env;
-    f->linfo = linfo;
-    return f;
-}
-
-DLLEXPORT
-jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast, jl_svec_t *sparams, jl_module_t *ctx)
+JL_DLLEXPORT
+jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast, jl_svec_t *tvars, jl_svec_t *sparams,
+                                     jl_module_t *ctx)
 {
     jl_lambda_info_t *li =
         (jl_lambda_info_t*)newobj((jl_value_t*)jl_lambda_info_type,
                                   NWORDS(sizeof(jl_lambda_info_t)));
     li->ast = ast;
+    li->rettype = (jl_value_t*)jl_any_type;
     li->file = null_sym;
-    li->line = 0;
-    if (ast != NULL && jl_is_expr(ast)) {
-        jl_value_t *body1 = skip_meta(jl_lam_body((jl_expr_t*)ast)->args);
-        if (jl_is_linenode(body1)) {
-            li->file = (jl_sym_t*)jl_fieldref(body1, 0);
-            li->line = jl_unbox_long(jl_fieldref(body1, 1));
-        } else if (jl_is_expr(body1) && ((jl_expr_t*)body1)->head == line_sym) {
-            li->file = (jl_sym_t*)jl_exprarg(body1, 1);
-            li->line = jl_unbox_long(jl_exprarg(body1, 0));
-        }
-    }
     li->module = ctx;
-    li->sparams = sparams;
+    li->sparam_syms = tvars;
+    li->sparam_vals = sparams;
     li->tfunc = jl_nothing;
-    li->fptr = &jl_trampoline;
+    li->fptr = NULL;
+    li->jlcall_api = 0;
     li->roots = NULL;
-    li->functionObject = NULL;
-    li->specFunctionObject = NULL;
-    li->cFunctionList = NULL;
+    li->functionObjects.functionObject = NULL;
+    li->functionObjects.specFunctionObject = NULL;
+    li->functionObjects.cFunctionList = NULL;
     li->functionID = 0;
     li->specFunctionID = 0;
     li->specTypes = NULL;
@@ -361,24 +302,87 @@ jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast, jl_svec_t *sparams, jl_mod
     li->specializations = NULL;
     li->name = anonymous_sym;
     li->def = li;
-    li->capt = NULL;
+    li->line = 0;
+    li->pure = 0;
+    li->called = 0xff;
+    li->needs_sparam_vals_ducttape = 0;
+    if (ast && jl_is_expr(ast)) {
+        jl_array_t *body = jl_lam_body((jl_expr_t*)ast)->args;
+        if (has_meta(body, pure_sym))
+            li->pure = 1;
+        jl_value_t *body1 = skip_meta(body);
+        if (jl_is_linenode(body1)) {
+            li->file = jl_linenode_file(body1);
+            li->line = jl_linenode_line(body1);
+        }
+        else if (jl_is_expr(body1) && ((jl_expr_t*)body1)->head == line_sym) {
+            li->file = (jl_sym_t*)jl_exprarg(body1, 1);
+            li->line = jl_unbox_long(jl_exprarg(body1, 0));
+        }
+        jl_array_t *vis = jl_lam_vinfo((jl_expr_t*)li->ast);
+        jl_array_t *args = jl_lam_args((jl_expr_t*)li->ast);
+        size_t narg = jl_array_len(args);
+        uint8_t called=0;
+        int i, j=0;
+        for(i=1; i < narg && i <= 8; i++) {
+            jl_value_t *ai = jl_cellref(args,i);
+            if (ai == (jl_value_t*)unused_sym || !jl_is_symbol(ai)) continue;
+            jl_value_t *vj;
+            do {
+                vj = jl_cellref(vis, j++);
+            } while (jl_cellref(vj,0) != ai);
+
+            if (jl_unbox_long(jl_cellref(vj,2))&64)
+                called |= (1<<(i-1));
+        }
+        li->called = called;
+        if (tvars != jl_emptysvec)
+            if (jl_has_intrinsics(li, (jl_expr_t*)ast, ctx))
+                li->needs_sparam_vals_ducttape = 1;
+    }
     return li;
 }
 
+jl_lambda_info_t *jl_copy_lambda_info(jl_lambda_info_t *linfo)
+{
+    jl_lambda_info_t *new_linfo =
+        jl_new_lambda_info(linfo->ast, linfo->sparam_syms, linfo->sparam_vals, linfo->module);
+    new_linfo->rettype = linfo->rettype;
+    new_linfo->tfunc = linfo->tfunc;
+    new_linfo->name = linfo->name;
+    new_linfo->roots = linfo->roots;
+    new_linfo->specTypes = linfo->specTypes;
+    new_linfo->unspecialized = linfo->unspecialized;
+    new_linfo->specializations = linfo->specializations;
+    new_linfo->def = linfo->def;
+    new_linfo->file = linfo->file;
+    new_linfo->line = linfo->line;
+    new_linfo->fptr = linfo->fptr;
+    new_linfo->jlcall_api = linfo->jlcall_api;
+    new_linfo->functionObjects.functionObject = linfo->functionObjects.functionObject;
+    new_linfo->functionObjects.specFunctionObject = linfo->functionObjects.specFunctionObject;
+    new_linfo->functionID = linfo->functionID;
+    new_linfo->specFunctionID = linfo->specFunctionID;
+    new_linfo->needs_sparam_vals_ducttape = linfo->needs_sparam_vals_ducttape;
+    return new_linfo;
+}
+
 // symbols --------------------------------------------------------------------
 
-static jl_sym_t *symtab = NULL;
+JL_DEFINE_MUTEX(symbol_table)
+
+static jl_sym_t *volatile symtab = NULL;
 
-static uptrint_t hash_symbol(const char *str, size_t len)
+static uintptr_t hash_symbol(const char *str, size_t len)
 {
-    return memhash(str, len) ^ ~(uptrint_t)0/3*2;
+    return memhash(str, len) ^ ~(uintptr_t)0/3*2;
 }
 
 #define SYM_POOL_SIZE 524288
 
 static size_t symbol_nbytes(size_t len)
 {
-    return (sizeof_jl_taggedvalue_t+sizeof(jl_sym_t)+len+1+7)&-8;
+    return (sizeof_jl_taggedvalue_t + sizeof(jl_sym_t) + len + 1 + 7) & -8;
 }
 
 static jl_sym_t *mk_symbol(const char *str, size_t len)
@@ -395,94 +399,96 @@ static jl_sym_t *mk_symbol(const char *str, size_t len)
     }
 
 #ifdef MEMDEBUG
-    sym = (jl_sym_t*)&((jl_taggedvalue_t*)malloc(nb))->value;
+    sym = (jl_sym_t*)jl_valueof(malloc(nb));
 #else
     if (sym_pool == NULL || pool_ptr+nb > sym_pool+SYM_POOL_SIZE) {
         sym_pool = (char*)malloc(SYM_POOL_SIZE);
         pool_ptr = sym_pool;
     }
-    sym = (jl_sym_t*)&((jl_taggedvalue_t*)pool_ptr)->value;
+    sym = (jl_sym_t*)jl_valueof(pool_ptr);
     pool_ptr += nb;
 #endif
     jl_set_typeof(sym, jl_sym_type);
     sym->left = sym->right = NULL;
     sym->hash = hash_symbol(str, len);
-    memcpy(&sym->name[0], str, len);
-    sym->name[len] = 0;
+    memcpy(jl_symbol_name(sym), str, len);
+    jl_symbol_name(sym)[len] = 0;
     return sym;
 }
 
-static void unmark_symbols_(jl_sym_t *root)
+static jl_sym_t *symtab_lookup(jl_sym_t *volatile *ptree, const char *str,
+                               size_t len, jl_sym_t *volatile **slot)
 {
-    while (root != NULL) {
-        jl_set_typeof(root, jl_sym_type);
-        unmark_symbols_(root->left);
-        root = root->right;
-    }
-}
-
-void jl_unmark_symbols(void) { unmark_symbols_(symtab); }
-
-static jl_sym_t **symtab_lookup(jl_sym_t **ptree, const char *str, size_t len, jl_sym_t **parent)
-{
-    int x;
-    if (parent != NULL) *parent = NULL;
-    uptrint_t h = hash_symbol(str, len);
+    jl_sym_t *node = jl_atomic_load_acquire(ptree);
+    uintptr_t h = hash_symbol(str, len);
 
-    // Tree nodes sorted by major key of (int(hash)) and minor key o (str).
-    while (*ptree != NULL) {
-        x = (int)(h-(*ptree)->hash);
+    // Tree nodes sorted by major key of (int(hash)) and minor key of (str).
+    while (node != NULL) {
+        intptr_t x = (intptr_t)(h - node->hash);
         if (x == 0) {
-            x = strncmp(str, (*ptree)->name, len);
-            if (x == 0 && (*ptree)->name[len] == 0)
-                return ptree;
+            x = strncmp(str, jl_symbol_name(node), len);
+            if (x == 0 && jl_symbol_name(node)[len] == 0) {
+                if (slot != NULL)
+                    *slot = ptree;
+                return node;
+            }
         }
-        if (parent != NULL) *parent = *ptree;
         if (x < 0)
-            ptree = &(*ptree)->left;
+            ptree = &node->left;
         else
-            ptree = &(*ptree)->right;
+            ptree = &node->right;
+        node = jl_atomic_load_acquire(ptree);
     }
-    return ptree;
+    if (slot != NULL)
+        *slot = ptree;
+    return node;
 }
 
 static jl_sym_t *_jl_symbol(const char *str, size_t len)
 {
-    jl_sym_t **pnode;
-    jl_sym_t *parent;
-    pnode = symtab_lookup(&symtab, str, len, &parent);
-    if (*pnode == NULL) {
-        *pnode = mk_symbol(str, len);
-        if (parent != NULL)
-            jl_gc_wb(parent, *pnode);
+    jl_sym_t *volatile *slot;
+    jl_sym_t *node = symtab_lookup(&symtab, str, len, &slot);
+    if (node == NULL) {
+        JL_LOCK(symbol_table); // Might GC
+        // Someone might have updated it, check and look up again
+        if (*slot != NULL && (node = symtab_lookup(slot, str, len, &slot))) {
+            JL_UNLOCK(symbol_table);
+            return node;
+        }
+        node = mk_symbol(str, len);
+        jl_atomic_store_release(slot, node);
+        JL_UNLOCK(symbol_table);
     }
-    return *pnode;
+    return node;
 }
 
-jl_sym_t *jl_symbol(const char *str)
+JL_DLLEXPORT jl_sym_t *jl_symbol(const char *str)
 {
     return _jl_symbol(str, strlen(str));
 }
 
-jl_sym_t *jl_symbol_lookup(const char *str)
+JL_DLLEXPORT jl_sym_t *jl_symbol_lookup(const char *str)
 {
-    return *symtab_lookup(&symtab, str, strlen(str), NULL);
+    return symtab_lookup(&symtab, str, strlen(str), NULL);
 }
 
-DLLEXPORT jl_sym_t *jl_symbol_n(const char *str, int32_t len)
+JL_DLLEXPORT jl_sym_t *jl_symbol_n(const char *str, int32_t len)
 {
     if (memchr(str, 0, len))
         jl_exceptionf(jl_argumenterror_type, "Symbol name may not contain \\0");
     return _jl_symbol(str, len);
 }
 
-DLLEXPORT jl_sym_t *jl_get_root_symbol() { return symtab; }
+JL_DLLEXPORT jl_sym_t *jl_get_root_symbol(void)
+{
+    return symtab;
+}
 
 static uint32_t gs_ctr = 0;  // TODO: per-thread
 uint32_t jl_get_gs_ctr(void) { return gs_ctr; }
 void jl_set_gs_ctr(uint32_t ctr) { gs_ctr = ctr; }
 
-DLLEXPORT jl_sym_t *jl_gensym(void)
+JL_DLLEXPORT jl_sym_t *jl_gensym(void)
 {
     static char name[16];
     char *n;
@@ -492,7 +498,7 @@ DLLEXPORT jl_sym_t *jl_gensym(void)
     return jl_symbol(n);
 }
 
-DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len)
+JL_DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len)
 {
     static char gs_name[14];
     if (symbol_nbytes(len) >= SYM_POOL_SIZE)
@@ -514,19 +520,60 @@ DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len)
 
 // allocating types -----------------------------------------------------------
 
-jl_typename_t *jl_new_typename(jl_sym_t *name)
+jl_sym_t *jl_demangle_typename(jl_sym_t *s)
+{
+    char *n = jl_symbol_name(s);
+    if (n[0] != '#')
+        return s;
+    char *end = strrchr(n, '#');
+    int32_t len;
+    if (end == n || end == n+1)
+        len = strlen(n) - 1;
+    else
+        len = (end-n) - 1;
+    return jl_symbol_n(&n[1], len);
+}
+
+JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *module)
+{
+    jl_methtable_t *mt = (jl_methtable_t*)jl_gc_allocobj(sizeof(jl_methtable_t));
+    jl_set_typeof(mt, jl_methtable_type);
+    mt->name = jl_demangle_typename(name);
+    mt->module = module;
+    mt->defs = (jl_methlist_t*)jl_nothing;
+    mt->cache = (jl_methlist_t*)jl_nothing;
+    mt->cache_arg1 = (jl_array_t*)jl_nothing;
+    mt->cache_targ = (jl_array_t*)jl_nothing;
+    mt->max_args = 0;
+    mt->kwsorter = NULL;
+#ifdef JL_GF_PROFILE
+    mt->ncalls = 0;
+#endif
+    return mt;
+}
+
+JL_DLLEXPORT jl_typename_t *jl_new_typename_in(jl_sym_t *name, jl_module_t *module)
 {
     jl_typename_t *tn=(jl_typename_t*)newobj((jl_value_t*)jl_typename_type, NWORDS(sizeof(jl_typename_t)));
     tn->name = name;
-    tn->module = jl_current_module;
+    tn->module = module;
     tn->primary = NULL;
     tn->cache = jl_emptysvec;
     tn->linearcache = jl_emptysvec;
     tn->names = NULL;
     tn->uid = jl_assign_type_uid();
+    tn->mt = NULL;
+    JL_GC_PUSH1(&tn);
+    tn->mt = NULL;
+    JL_GC_POP();
     return tn;
 }
 
+JL_DLLEXPORT jl_typename_t *jl_new_typename(jl_sym_t *name)
+{
+    return jl_new_typename_in(name, jl_current_module);
+}
+
 jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_datatype_t *super,
                                    jl_svec_t *parameters)
 {
@@ -535,12 +582,20 @@ jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_datatype_t *super,
     return dt;
 }
 
-jl_datatype_t *jl_new_uninitialized_datatype(size_t nfields)
+JL_DLLEXPORT jl_datatype_t *jl_new_uninitialized_datatype(size_t nfields, int8_t fielddesc_type)
 {
+    // fielddesc_type is specified manually for builtin types
+    // and is (will be) calculated automatically for user defined types.
+    uint32_t fielddesc_size = jl_fielddesc_size(fielddesc_type);
     jl_datatype_t *t = (jl_datatype_t*)
         newobj((jl_value_t*)jl_datatype_type,
-               NWORDS(sizeof(jl_datatype_t) + nfields*sizeof(jl_fielddesc_t)));
+               NWORDS(sizeof(jl_datatype_t) + nfields * fielddesc_size));
+    // fielddesc_type should only be assigned here. It can cause data
+    // corruption otherwise.
+    t->fielddesc_type = fielddesc_type;
     t->nfields = nfields;
+    t->haspadding = 0;
+    t->pointerfree = 0;
     return t;
 }
 
@@ -549,15 +604,22 @@ void jl_compute_field_offsets(jl_datatype_t *st)
     size_t sz = 0, alignm = 1;
     int ptrfree = 1;
 
+    assert(0 <= st->fielddesc_type && st->fielddesc_type <= 2);
+
+    uint64_t max_offset = (((uint64_t)1) <<
+                           (1 << (3 + st->fielddesc_type))) - 1;
+    uint64_t max_size = max_offset >> 1;
+
     for(size_t i=0; i < jl_datatype_nfields(st); i++) {
         jl_value_t *ty = jl_field_type(st, i);
         size_t fsz, al;
         if (jl_isbits(ty) && jl_is_leaf_type(ty)) {
             fsz = jl_datatype_size(ty);
-            if (__unlikely(fsz > JL_FIELD_MAX_SIZE))
+            // Should never happen
+            if (__unlikely(fsz > max_size))
                 jl_throw(jl_overflow_exception);
             al = ((jl_datatype_t*)ty)->alignment;
-            st->fields[i].isptr = 0;
+            jl_field_setisptr(st, i, 0);
             if (((jl_datatype_t*)ty)->haspadding)
                 st->haspadding = 1;
         }
@@ -566,21 +628,21 @@ void jl_compute_field_offsets(jl_datatype_t *st)
             if (fsz > MAX_ALIGN)
                 fsz = MAX_ALIGN;
             al = fsz;
-            st->fields[i].isptr = 1;
+            jl_field_setisptr(st, i, 1);
             ptrfree = 0;
         }
         if (al != 0) {
             size_t alsz = LLT_ALIGN(sz, al);
-            if (alsz > sz)
+            if (sz & (al - 1))
                 st->haspadding = 1;
             sz = alsz;
             if (al > alignm)
                 alignm = al;
         }
-        if (__unlikely(sz > JL_FIELD_MAX_OFFSET))
+        jl_field_setoffset(st, i, sz);
+        jl_field_setsize(st, i, fsz);
+        if (__unlikely(max_offset - sz < fsz))
             jl_throw(jl_overflow_exception);
-        st->fields[i].offset = sz;
-        st->fields[i].size = fsz;
         sz += fsz;
     }
     st->alignment = alignm;
@@ -592,10 +654,11 @@ void jl_compute_field_offsets(jl_datatype_t *st)
 
 extern int jl_boot_file_loaded;
 
-jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
-                               jl_svec_t *parameters,
-                               jl_svec_t *fnames, jl_svec_t *ftypes,
-                               int abstract, int mutabl, int ninitialized)
+JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
+                                            jl_svec_t *parameters,
+                                            jl_svec_t *fnames, jl_svec_t *ftypes,
+                                            int abstract, int mutabl,
+                                            int ninitialized)
 {
     jl_datatype_t *t=NULL;
     jl_typename_t *tn=NULL;
@@ -604,15 +667,15 @@ jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
     if (!jl_boot_file_loaded && jl_is_symbol(name)) {
         // hack to avoid making two versions of basic types needed
         // during bootstrapping
-        if (!strcmp(((jl_sym_t*)name)->name, "Int32"))
+        if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Int32"))
             t = jl_int32_type;
-        else if (!strcmp(((jl_sym_t*)name)->name, "Int64"))
+        else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Int64"))
             t = jl_int64_type;
-        else if (!strcmp(((jl_sym_t*)name)->name, "Bool"))
+        else if (!strcmp(jl_symbol_name((jl_sym_t*)name), "Bool"))
             t = jl_bool_type;
     }
     if (t == NULL)
-        t = jl_new_uninitialized_datatype(jl_svec_len(fnames));
+        t = jl_new_uninitialized_datatype(jl_svec_len(fnames), 2); // TODO
     else
         tn = t->name;
     // init before possibly calling jl_new_typename
@@ -635,10 +698,16 @@ jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
 
     if (tn == NULL) {
         t->name = NULL;
-        if (jl_is_typename(name))
+        if (jl_is_typename(name)) {
             tn = (jl_typename_t*)name;
-        else
+        }
+        else {
             tn = jl_new_typename((jl_sym_t*)name);
+            if (!abstract) {
+                tn->mt = jl_new_method_table(name, jl_current_module);
+                jl_gc_wb(tn, tn->mt);
+            }
+        }
         t->name = tn;
         jl_gc_wb(t, t->name);
     }
@@ -662,8 +731,8 @@ jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
     return t;
 }
 
-jl_datatype_t *jl_new_bitstype(jl_value_t *name, jl_datatype_t *super,
-                               jl_svec_t *parameters, size_t nbits)
+JL_DLLEXPORT jl_datatype_t *jl_new_bitstype(jl_value_t *name, jl_datatype_t *super,
+                                            jl_svec_t *parameters, size_t nbits)
 {
     jl_datatype_t *bt = jl_new_datatype((jl_sym_t*)name, super, parameters,
                                         jl_emptysvec, jl_emptysvec, 0, 0, 0);
@@ -687,16 +756,16 @@ jl_typector_t *jl_new_type_ctor(jl_svec_t *params, jl_value_t *body)
 
 // bits constructors ----------------------------------------------------------
 
-#define BOXN_FUNC(nb,nw)                                       \
-jl_value_t *jl_box##nb(jl_datatype_t *t, int##nb##_t x)        \
-{                                                              \
-    assert(jl_isbits(t));                                      \
-    assert(jl_datatype_size(t) == sizeof(x));                  \
-    jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w();              \
-    jl_set_typeof(v, t);                                       \
-    *(int##nb##_t*)jl_data_ptr(v) = x;                         \
-    return v;                                                  \
-}
+#define BOXN_FUNC(nb,nw)                                                \
+    JL_DLLEXPORT jl_value_t *jl_box##nb(jl_datatype_t *t, int##nb##_t x) \
+    {                                                                   \
+        assert(jl_isbits(t));                                           \
+        assert(jl_datatype_size(t) == sizeof(x));                       \
+        jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w();             \
+        jl_set_typeof(v, t);                                            \
+        *(int##nb##_t*)jl_data_ptr(v) = x;                              \
+        return v;                                                       \
+    }
 BOXN_FUNC(8,  1)
 BOXN_FUNC(16, 1)
 BOXN_FUNC(32, 1)
@@ -707,12 +776,12 @@ BOXN_FUNC(64, 2)
 #endif
 
 #define UNBOX_FUNC(j_type,c_type)                                       \
-c_type jl_unbox_##j_type(jl_value_t *v)                                 \
-{                                                                       \
-    assert(jl_is_bitstype(jl_typeof(v)));                               \
-    assert(jl_datatype_size(jl_typeof(v)) == sizeof(c_type));           \
-    return *(c_type*)jl_data_ptr(v);                                    \
-}
+    JL_DLLEXPORT c_type jl_unbox_##j_type(jl_value_t *v)                \
+    {                                                                   \
+        assert(jl_is_bitstype(jl_typeof(v)));                           \
+        assert(jl_datatype_size(jl_typeof(v)) == sizeof(c_type));       \
+        return *(c_type*)jl_data_ptr(v);                                \
+    }
 UNBOX_FUNC(int8,   int8_t)
 UNBOX_FUNC(uint8,  uint8_t)
 UNBOX_FUNC(int16,  int16_t)
@@ -727,14 +796,14 @@ UNBOX_FUNC(float64, double)
 UNBOX_FUNC(voidpointer, void*)
 UNBOX_FUNC(gensym, ssize_t)
 
-#define BOX_FUNC(typ,c_type,pfx,nw)               \
-jl_value_t *pfx##_##typ(c_type x)                 \
-{                                                 \
-    jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w(); \
-    jl_set_typeof(v, jl_##typ##_type);            \
-    *(c_type*)jl_data_ptr(v) = x;                 \
-    return v;                                     \
-}
+#define BOX_FUNC(typ,c_type,pfx,nw)                         \
+    JL_DLLEXPORT jl_value_t *pfx##_##typ(c_type x)          \
+    {                                                       \
+        jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w(); \
+        jl_set_typeof(v, jl_##typ##_type);                  \
+        *(c_type*)jl_data_ptr(v) = x;                       \
+        return v;                                           \
+    }
 BOX_FUNC(float32, float,  jl_box, 1)
 BOX_FUNC(voidpointer, void*,  jl_box, 1)
 #ifdef _P64
@@ -745,29 +814,29 @@ BOX_FUNC(float64, double, jl_box, 2)
 
 #define NBOX_C 1024
 
-#define SIBOX_FUNC(typ,c_type,nw)                       \
-static jl_value_t *boxed_##typ##_cache[NBOX_C];         \
-jl_value_t *jl_box_##typ(c_type x)                      \
-{                                                       \
-    c_type idx = x+NBOX_C/2;                            \
-    if ((u##c_type)idx < (u##c_type)NBOX_C)             \
-        return boxed_##typ##_cache[idx];                \
-    jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w();       \
-    jl_set_typeof(v, jl_##typ##_type);                  \
-    *(c_type*)jl_data_ptr(v) = x;                       \
-    return v;                                           \
-}
-#define UIBOX_FUNC(typ,c_type,nw)                  \
-static jl_value_t *boxed_##typ##_cache[NBOX_C];    \
-jl_value_t *jl_box_##typ(c_type x)                 \
-{                                                  \
-    if (x < NBOX_C)                                \
-        return boxed_##typ##_cache[x];             \
-    jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w();  \
-    jl_set_typeof(v, jl_##typ##_type);             \
-    *(c_type*)jl_data_ptr(v) = x;                  \
-    return v;                                      \
-}
+#define SIBOX_FUNC(typ,c_type,nw)                             \
+    static jl_value_t *boxed_##typ##_cache[NBOX_C];           \
+    JL_DLLEXPORT jl_value_t *jl_box_##typ(c_type x)           \
+    {                                                         \
+        c_type idx = x+NBOX_C/2;                              \
+        if ((u##c_type)idx < (u##c_type)NBOX_C)               \
+            return boxed_##typ##_cache[idx];                  \
+        jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w();   \
+        jl_set_typeof(v, jl_##typ##_type);                    \
+        *(c_type*)jl_data_ptr(v) = x;                         \
+        return v;                                             \
+    }
+#define UIBOX_FUNC(typ,c_type,nw)                               \
+    static jl_value_t *boxed_##typ##_cache[NBOX_C];             \
+    JL_DLLEXPORT jl_value_t *jl_box_##typ(c_type x)             \
+    {                                                           \
+        if (x < NBOX_C)                                         \
+            return boxed_##typ##_cache[x];                      \
+        jl_value_t *v = (jl_value_t*)jl_gc_alloc_##nw##w();     \
+        jl_set_typeof(v, jl_##typ##_type);                      \
+        *(c_type*)jl_data_ptr(v) = x;                           \
+        return v;                                               \
+    }
 SIBOX_FUNC(int16,  int16_t, 1)
 SIBOX_FUNC(int32,  int32_t, 1)
 UIBOX_FUNC(uint16, uint16_t, 1)
@@ -783,12 +852,12 @@ UIBOX_FUNC(uint64, uint64_t, 2)
 #endif
 
 static jl_value_t *boxed_int8_cache[256];
-jl_value_t *jl_box_int8(int8_t x)
+JL_DLLEXPORT jl_value_t *jl_box_int8(int8_t x)
 {
     return boxed_int8_cache[(uint8_t)x];
 }
 static jl_value_t *boxed_uint8_cache[256];
-jl_value_t *jl_box_uint8(uint8_t x)
+JL_DLLEXPORT jl_value_t *jl_box_uint8(uint8_t x)
 {
     return boxed_uint8_cache[x];
 }
@@ -842,7 +911,7 @@ void jl_mark_box_caches(void)
     }
 }
 
-jl_value_t *jl_box_bool(int8_t x)
+JL_DLLEXPORT jl_value_t *jl_box_bool(int8_t x)
 {
     if (x)
         return jl_true;
@@ -864,7 +933,7 @@ jl_expr_t *jl_exprn(jl_sym_t *head, size_t n)
     return ex;
 }
 
-JL_CALLABLE(jl_f_new_expr)
+JL_CALLABLE(jl_f__expr)
 {
     JL_NARGSV(Expr, 1);
     JL_TYPECHK(Expr, symbol, args[0]);
diff --git a/src/anticodegen.c b/src/anticodegen.c
new file mode 100644
index 0000000000000..84c57b62131de
--- /dev/null
+++ b/src/anticodegen.c
@@ -0,0 +1,49 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#include "julia.h"
+#include "julia_internal.h"
+
+#include "intrinsics.h"
+
+int globalUnique = 0;
+
+#define UNAVAILABLE { jl_errorf("%s: not available in this build of Julia", __func__); }
+
+void jl_dump_bitcode(char *fname, const char *sysimg_data, size_t sysimg_len) UNAVAILABLE
+void jl_dump_objfile(char *fname, int jit_model, const char *sysimg_data, size_t sysimg_len) UNAVAILABLE
+int32_t jl_get_llvm_gv(jl_value_t *p) UNAVAILABLE
+void jl_write_malloc_log(void) UNAVAILABLE
+void jl_write_coverage_data(void) UNAVAILABLE
+void jl_generate_fptr(jl_lambda_info_t *li) UNAVAILABLE
+void jl_compile_linfo(jl_lambda_info_t *li, void *cyclectx) UNAVAILABLE
+
+JL_DLLEXPORT void jl_clear_malloc_data(void) UNAVAILABLE
+JL_DLLEXPORT void jl_extern_c(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name) UNAVAILABLE
+JL_DLLEXPORT void *jl_function_ptr(jl_function_t *f, jl_value_t *rt, jl_value_t *argt) UNAVAILABLE
+JL_DLLEXPORT const jl_value_t *jl_dump_function_asm(void *f, int raw_mc) UNAVAILABLE
+JL_DLLEXPORT const jl_value_t *jl_dump_function_ir(void *f, uint8_t strip_ir_metadata, uint8_t dump_module) UNAVAILABLE
+
+void jl_init_codegen(void) { }
+void jl_fptr_to_llvm(jl_fptr_t fptr, jl_lambda_info_t *lam, int specsig)
+{
+    if (!specsig)
+        lam->fptr = fptr;
+}
+void jl_getFunctionInfo(char **name, char **filename, size_t *line,
+                        char **inlinedat_file, size_t *inlinedat_line, jl_lambda_info_t **outer_linfo,
+                        size_t pointer, int *fromC, int skipC, int skipInline)
+{
+    *name = NULL;
+    *line = -1;
+    *filename = NULL;
+    *inlinedat_file = NULL;
+    *inlinedat_line = -1;
+    *outer_linfo = NULL;
+    *fromC = 0;
+}
+
+jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
+                           jl_lambda_info_t *li, int sparams, int allow_alloc)
+{
+    return NULL;
+}
diff --git a/src/array.c b/src/array.c
index 5b0124eab36bb..ef4f63ee7652e 100644
--- a/src/array.c
+++ b/src/array.c
@@ -83,7 +83,7 @@ static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
         tsz = JL_ARRAY_ALIGN(tsz, 16); // align whole object 16
         a = (jl_array_t*)jl_gc_allocobj(tsz);
         jl_set_typeof(a, atype);
-        a->how = 0;
+        a->flags.how = 0;
         data = (char*)a + doffs;
         if (tot > 0 && !isunboxed) {
             memset(data, 0, tot);
@@ -96,25 +96,29 @@ static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
         jl_set_typeof(a, atype);
         // temporarily initialize to make gc-safe
         a->data = NULL;
-        a->how = 2;
+        a->flags.how = 2;
+        // Make sure the GC can correctly identify if this is pool allocated
+        // and mark the page accordingly
+        a->flags.pooled = tsz <= GC_MAX_SZCLASS;
+
         data = jl_gc_managed_malloc(tot);
         jl_gc_track_malloced_array(a);
         if (!isunboxed)
             memset(data, 0, tot);
         JL_GC_POP();
     }
-    a->pooled = tsz <= GC_MAX_SZCLASS;
+    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
 
     a->data = data;
     if (elsz == 1) ((char*)data)[tot-1] = '\0';
 #ifdef STORE_ARRAY_LEN
     a->length = nel;
 #endif
-    a->ndims = ndims;
-    a->ptrarray = !isunboxed;
+    a->flags.ndims = ndims;
+    a->flags.ptrarray = !isunboxed;
     a->elsize = elsz;
-    a->isshared = 0;
-    a->isaligned = 1;
+    a->flags.isshared = 0;
+    a->flags.isaligned = 1;
     a->offset = 0;
     if (ndims == 1) {
         a->nrows = nel;
@@ -145,7 +149,8 @@ jl_array_t *jl_new_array_for_deserialization(jl_value_t *atype, uint32_t ndims,
     return _new_array_(atype, ndims, dims, isunboxed, elsz);
 }
 
-jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data, jl_value_t *dims)
+JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
+                                          jl_value_t *dims)
 {
     size_t i;
     jl_array_t *a;
@@ -155,35 +160,35 @@ jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data, jl_value_t *di
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t) + sizeof(void*), 16);
     a = (jl_array_t*)jl_gc_allocobj(tsz);
     jl_set_typeof(a, atype);
-    a->pooled = tsz <= GC_MAX_SZCLASS;
-    a->ndims = ndims;
+    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
+    a->flags.ndims = ndims;
     a->offset = 0;
     a->data = NULL;
-    a->isaligned = data->isaligned;
+    a->flags.isaligned = data->flags.isaligned;
     jl_value_t *el_type = jl_tparam0(atype);
     if (store_unboxed(el_type)) {
         a->elsize = jl_datatype_size(el_type);
-        a->ptrarray = 0;
+        a->flags.ptrarray = 0;
     }
     else {
         a->elsize = sizeof(void*);
-        a->ptrarray = 1;
+        a->flags.ptrarray = 1;
     }
     JL_GC_PUSH1(&a);
 
     jl_array_t *owner = data;
     // if data is itself a shared wrapper,
     // owner should point back to the original array
-    if (owner->how == 3) {
+    if (owner->flags.how == 3) {
         owner = (jl_array_t*)jl_array_data_owner(owner);
     }
-    assert(owner->how != 3);
+    assert(owner->flags.how != 3);
     jl_array_data_owner(a) = (jl_value_t*)owner;
 
-    a->how = 3;
+    a->flags.how = 3;
     a->data = data->data;
-    a->isshared = 1;
-    data->isshared = 1;
+    a->flags.isshared = 1;
+    data->flags.isshared = 1;
 
     if (ndims == 1) {
         size_t l = ((size_t*)jl_data_ptr(dims))[0];
@@ -214,8 +219,8 @@ jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data, jl_value_t *di
 }
 
 // own_buffer != 0 iff GC should call free() on this pointer eventually
-jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data, size_t nel,
-                               int own_buffer)
+JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
+                                            size_t nel, int own_buffer)
 {
     size_t elsz;
     jl_array_t *a;
@@ -231,23 +236,23 @@ jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data, size_t nel,
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), 16);
     a = (jl_array_t*)jl_gc_allocobj(tsz);
     jl_set_typeof(a, atype);
-    a->pooled = tsz <= GC_MAX_SZCLASS;
+    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
     a->data = data;
 #ifdef STORE_ARRAY_LEN
     a->length = nel;
 #endif
     a->elsize = elsz;
-    a->ptrarray = !isunboxed;
-    a->ndims = 1;
-    a->isshared = 1;
-    a->isaligned = 0;  // TODO: allow passing memalign'd buffers
+    a->flags.ptrarray = !isunboxed;
+    a->flags.ndims = 1;
+    a->flags.isshared = 1;
+    a->flags.isaligned = 0;  // TODO: allow passing memalign'd buffers
     if (own_buffer) {
-        a->how = 2;
+        a->flags.how = 2;
         jl_gc_track_malloced_array(a);
         jl_gc_count_allocd(nel*elsz + (elsz == 1 ? 1 : 0));
     }
     else {
-        a->how = 0;
+        a->flags.how = 0;
     }
 
     a->nrows = nel;
@@ -256,8 +261,8 @@ jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data, size_t nel,
     return a;
 }
 
-jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data, jl_value_t *dims,
-                            int own_buffer)
+JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
+                                         jl_value_t *dims, int own_buffer)
 {
     size_t i, elsz, nel=1;
     jl_array_t *a;
@@ -282,24 +287,24 @@ jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data, jl_value_t *dims,
     int tsz = JL_ARRAY_ALIGN(sizeof(jl_array_t) + ndimwords*sizeof(size_t), 16);
     a = (jl_array_t*)jl_gc_allocobj(tsz);
     jl_set_typeof(a, atype);
-    a->pooled = tsz <= GC_MAX_SZCLASS;
+    a->flags.pooled = tsz <= GC_MAX_SZCLASS;
     a->data = data;
 #ifdef STORE_ARRAY_LEN
     a->length = nel;
 #endif
     a->elsize = elsz;
-    a->ptrarray = !isunboxed;
-    a->ndims = ndims;
+    a->flags.ptrarray = !isunboxed;
+    a->flags.ndims = ndims;
     a->offset = 0;
-    a->isshared = 1;
-    a->isaligned = 0;
+    a->flags.isshared = 1;
+    a->flags.isaligned = 0;
     if (own_buffer) {
-        a->how = 2;
+        a->flags.how = 2;
         jl_gc_track_malloced_array(a);
         jl_gc_count_allocd(nel*elsz + (elsz == 1 ? 1 : 0));
     }
     else {
-        a->how = 0;
+        a->flags.how = 0;
     }
 
     if (ndims == 1) {
@@ -308,14 +313,17 @@ jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data, jl_value_t *dims,
     }
     else {
         size_t *adims = &a->nrows;
+        // jl_fieldref can allocate
+        JL_GC_PUSH1(&a);
         for(i=0; i < ndims; i++) {
             adims[i] = jl_unbox_long(jl_fieldref(dims, i));
         }
+        JL_GC_POP();
     }
     return a;
 }
 
-jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *dims)
+JL_DLLEXPORT jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *dims)
 {
     size_t ndims = jl_nfields(dims);
     size_t *adims = (size_t*)alloca(ndims*sizeof(size_t));
@@ -325,31 +333,33 @@ jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *dims)
     return _new_array(atype, ndims, adims);
 }
 
-jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr)
+JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr)
 {
     return _new_array(atype, 1, &nr);
 }
 
-jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr, size_t nc)
+JL_DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr,
+                                           size_t nc)
 {
     size_t d[2] = {nr, nc};
     return _new_array(atype, 2, &d[0]);
 }
 
-jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr, size_t nc, size_t z)
+JL_DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr,
+                                           size_t nc, size_t z)
 {
     size_t d[3] = {nr, nc, z};
     return _new_array(atype, 3, &d[0]);
 }
 
-jl_array_t *jl_pchar_to_array(const char *str, size_t len)
+JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len)
 {
     jl_array_t *a = jl_alloc_array_1d(jl_array_uint8_type, len);
     memcpy(a->data, str, len);
     return a;
 }
 
-jl_value_t *jl_array_to_string(jl_array_t *a)
+JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a)
 {
     if (!jl_typeis(a, jl_array_uint8_type))
         jl_type_error("jl_array_to_string", (jl_value_t*)jl_array_uint8_type, (jl_value_t*)a);
@@ -361,7 +371,7 @@ jl_value_t *jl_array_to_string(jl_array_t *a)
     return s;
 }
 
-jl_value_t *jl_pchar_to_string(const char *str, size_t len)
+JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len)
 {
     jl_array_t *a = jl_pchar_to_array(str, len);
     JL_GC_PUSH1(&a);
@@ -370,17 +380,17 @@ jl_value_t *jl_pchar_to_string(const char *str, size_t len)
     return s;
 }
 
-jl_value_t *jl_cstr_to_string(const char *str)
+JL_DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str)
 {
     return jl_pchar_to_string(str, strlen(str));
 }
 
-jl_array_t *jl_alloc_cell_1d(size_t n)
+JL_DLLEXPORT jl_array_t *jl_alloc_cell_1d(size_t n)
 {
     return jl_alloc_array_1d(jl_array_any_type, n);
 }
 
-jl_value_t *jl_apply_array_type(jl_datatype_t *type, size_t dim)
+JL_DLLEXPORT jl_value_t *jl_apply_array_type(jl_datatype_t *type, size_t dim)
 {
     jl_value_t *boxed_dim = jl_box_long(dim);
     JL_GC_PUSH1(&boxed_dim);
@@ -392,7 +402,7 @@ jl_value_t *jl_apply_array_type(jl_datatype_t *type, size_t dim)
 // array primitives -----------------------------------------------------------
 
 #ifndef STORE_ARRAY_LEN
-DLLEXPORT size_t jl_array_len_(jl_array_t *a)
+JL_DLLEXPORT size_t jl_array_len_(jl_array_t *a)
 {
     size_t l = 1;
     for(size_t i=0; i < jl_array_ndims(a); i++)
@@ -401,13 +411,6 @@ DLLEXPORT size_t jl_array_len_(jl_array_t *a)
 }
 #endif
 
-JL_CALLABLE(jl_f_arraylen)
-{
-    JL_NARGS(arraylen, 1, 1);
-    JL_TYPECHK(arraylen, array, args[0]);
-    return jl_box_long(jl_array_len((jl_array_t*)args[0]));
-}
-
 JL_CALLABLE(jl_f_arraysize)
 {
     JL_NARGS(arraysize, 2, 2);
@@ -423,11 +426,11 @@ JL_CALLABLE(jl_f_arraysize)
     return jl_box_long((&a->nrows)[dno-1]);
 }
 
-jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
+JL_DLLEXPORT jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
 {
     assert(i < jl_array_len(a));
     jl_value_t *elt;
-    if (!a->ptrarray) {
+    if (!a->flags.ptrarray) {
         jl_value_t *el_type = (jl_value_t*)jl_tparam0(jl_typeof(a));
         elt = jl_new_bits(el_type, &((char*)a->data)[i*a->elsize]);
     }
@@ -472,9 +475,9 @@ JL_CALLABLE(jl_f_arrayref)
     return jl_arrayref(a, i);
 }
 
-DLLEXPORT int jl_array_isassigned(jl_array_t *a, size_t i)
+JL_DLLEXPORT int jl_array_isassigned(jl_array_t *a, size_t i)
 {
-    if (a->ptrarray)
+    if (a->flags.ptrarray)
         return ((jl_value_t**)jl_array_data(a))[i] != NULL;
     return 1;
 }
@@ -503,12 +506,12 @@ int jl_array_isdefined(jl_value_t **args0, int nargs)
     if (i >= stride)
         return 0;
 
-    if (a->ptrarray)
+    if (a->flags.ptrarray)
         return ((jl_value_t**)jl_array_data(a))[i] != NULL;
     return 1;
 }
 
-void jl_arrayset(jl_array_t *a, jl_value_t *rhs, size_t i)
+JL_DLLEXPORT void jl_arrayset(jl_array_t *a, jl_value_t *rhs, size_t i)
 {
     assert(i < jl_array_len(a));
     jl_value_t *el_type = jl_tparam0(jl_typeof(a));
@@ -516,13 +519,13 @@ void jl_arrayset(jl_array_t *a, jl_value_t *rhs, size_t i)
         if (!jl_subtype(rhs, el_type, 1))
             jl_type_error("arrayset", el_type, rhs);
     }
-    if (!a->ptrarray) {
+    if (!a->flags.ptrarray) {
         jl_assign_bits(&((char*)a->data)[i*a->elsize], rhs);
     }
     else {
         ((jl_value_t**)a->data)[i] = rhs;
         jl_value_t *owner = (jl_value_t*)a;
-        if (a->how == 3) {
+        if (a->flags.how == 3) {
             owner = jl_array_data_owner(a);
         }
         jl_gc_wb(owner, rhs);
@@ -539,12 +542,12 @@ JL_CALLABLE(jl_f_arrayset)
     return args[0];
 }
 
-void jl_arrayunset(jl_array_t *a, size_t i)
+JL_DLLEXPORT void jl_arrayunset(jl_array_t *a, size_t i)
 {
     if (i >= jl_array_len(a))
         jl_bounds_error_int((jl_value_t*)a, i+1);
     char *ptail = (char*)a->data + i*a->elsize;
-    if (a->ptrarray)
+    if (a->flags.ptrarray)
         memset(ptail, 0, a->elsize);
 }
 
@@ -564,12 +567,12 @@ static void array_resize_buffer(jl_array_t *a, size_t newlen, size_t oldlen, siz
     size_t oldoffsnb = a->offset * es;
     if (es == 1)
         nbytes++;
-    assert(!a->isshared || a->how==3);
+    assert(!a->flags.isshared || a->flags.how==3);
     char *newdata;
-    if (a->how == 2) {
+    if (a->flags.how == 2) {
         // already malloc'd - use realloc
         newdata = (char*)jl_gc_managed_realloc((char*)a->data - oldoffsnb, nbytes,
-                                               oldnbytes+oldoffsnb, a->isaligned, (jl_value_t*)a);
+                                               oldnbytes+oldoffsnb, a->flags.isaligned, (jl_value_t*)a);
         if (offs != a->offset) {
             memmove(&newdata[offsnb], &newdata[oldoffsnb], oldnbytes);
         }
@@ -584,29 +587,29 @@ static void array_resize_buffer(jl_array_t *a, size_t newlen, size_t oldlen, siz
             ) {
             newdata = (char*)jl_gc_managed_malloc(nbytes);
             jl_gc_track_malloced_array(a);
-            a->how = 2;
-            a->isaligned = 1;
+            a->flags.how = 2;
+            a->flags.isaligned = 1;
         }
         else {
             newdata = (char*)allocb(nbytes);
-            a->how = 1;
+            a->flags.how = 1;
         }
         memcpy(newdata + offsnb, (char*)a->data, oldnbytes);
     }
 
     a->data = newdata + offsnb;
-    a->isshared = 0;
-    if (a->ptrarray || es==1)
+    a->flags.isshared = 0;
+    if (a->flags.ptrarray || es==1)
         memset(newdata+offsnb+oldnbytes, 0, nbytes-oldnbytes-offsnb);
-    if (a->how == 1)
+    if (a->flags.how == 1)
         jl_gc_wb_buf(a, newdata);
     a->maxsize = newlen;
 }
 
 static void array_try_unshare(jl_array_t *a)
 {
-    if (a->isshared) {
-        if (a->how != 3)
+    if (a->flags.isshared) {
+        if (a->flags.how != 3)
             jl_error("cannot resize array with shared data");
         size_t len = jl_array_nrows(a);
         array_resize_buffer(a, len, len, a->offset);
@@ -625,9 +628,9 @@ static size_t limit_overallocation(jl_array_t *a, size_t alen, size_t newlen, si
     return newlen;
 }
 
-void jl_array_grow_end(jl_array_t *a, size_t inc)
+JL_DLLEXPORT void jl_array_grow_end(jl_array_t *a, size_t inc)
 {
-    if (a->isshared && a->how!=3) jl_error("cannot resize array with shared data");
+    if (a->flags.isshared && a->flags.how!=3) jl_error("cannot resize array with shared data");
     // optimized for the case of only growing and shrinking at the end
     size_t alen = jl_array_nrows(a);
     if ((alen + inc) > a->maxsize - a->offset) {
@@ -644,16 +647,16 @@ void jl_array_grow_end(jl_array_t *a, size_t inc)
     a->nrows += inc;
 }
 
-void jl_array_del_end(jl_array_t *a, size_t dec)
+JL_DLLEXPORT void jl_array_del_end(jl_array_t *a, size_t dec)
 {
     if (dec == 0) return;
     if (dec > a->nrows)
         jl_bounds_error_int((jl_value_t*)a, a->nrows - dec);
-    if (a->isshared) array_try_unshare(a);
+    if (a->flags.isshared) array_try_unshare(a);
     if (a->elsize > 0) {
         char *ptail = (char*)a->data + (a->nrows-dec)*a->elsize;
         assert(ptail < (char*)a->data + (a->length*a->elsize));
-        if (a->ptrarray)
+        if (a->flags.ptrarray)
             memset(ptail, 0, dec*a->elsize);
         else
             ptail[0] = 0;
@@ -664,7 +667,7 @@ void jl_array_del_end(jl_array_t *a, size_t dec)
     a->nrows -= dec;
 }
 
-void jl_array_sizehint(jl_array_t *a, size_t sz)
+JL_DLLEXPORT void jl_array_sizehint(jl_array_t *a, size_t sz)
 {
     if (sz <= jl_array_len(a))
         return;
@@ -676,11 +679,12 @@ void jl_array_sizehint(jl_array_t *a, size_t sz)
     a->nrows -= inc;
 }
 
-void jl_array_grow_beg(jl_array_t *a, size_t inc)
+JL_DLLEXPORT void jl_array_grow_beg(jl_array_t *a, size_t inc)
 {
+    // For pointer array the memory grown should be zero'd
     if (inc == 0) return;
     // designed to handle the case of growing and shrinking at both ends
-    if (a->isshared) array_try_unshare(a);
+    if (a->flags.isshared) array_try_unshare(a);
     size_t es = a->elsize;
     size_t incnb = inc*es;
     if (a->offset >= inc) {
@@ -698,12 +702,8 @@ void jl_array_grow_beg(jl_array_t *a, size_t inc)
             newlen = limit_overallocation(a, alen, newlen, 2*inc);
             size_t center = (newlen - (alen + inc))/2;
             array_resize_buffer(a, newlen, alen, center+inc);
-            char *newdata = (char*)a->data - (center+inc)*es;
-            if (a->ptrarray) {
-                memset(newdata, 0, (center+inc)*es);
-            }
             a->offset = center;
-            a->data = newdata + center*es;
+            a->data = (char*)a->data - incnb;
         }
         else {
             size_t center = (a->maxsize - (alen + inc))/2;
@@ -713,18 +713,20 @@ void jl_array_grow_beg(jl_array_t *a, size_t inc)
             a->offset = center;
         }
     }
+    if (a->flags.ptrarray)
+        memset((char*)a->data, 0, incnb);
 #ifdef STORE_ARRAY_LEN
     a->length += inc;
 #endif
     a->nrows += inc;
 }
 
-void jl_array_del_beg(jl_array_t *a, size_t dec)
+JL_DLLEXPORT void jl_array_del_beg(jl_array_t *a, size_t dec)
 {
     if (dec == 0) return;
     if (dec > a->nrows)
         jl_bounds_error_int((jl_value_t*)a, dec);
-    if (a->isshared) array_try_unshare(a);
+    if (a->flags.isshared) array_try_unshare(a);
     size_t es = a->elsize;
     size_t nb = dec*es;
     memset(a->data, 0, nb);
@@ -756,14 +758,14 @@ void jl_array_del_beg(jl_array_t *a, size_t dec)
     a->offset = newoffs;
 }
 
-DLLEXPORT void jl_cell_1d_push(jl_array_t *a, jl_value_t *item)
+JL_DLLEXPORT void jl_cell_1d_push(jl_array_t *a, jl_value_t *item)
 {
     assert(jl_typeis(a, jl_array_any_type));
     jl_array_grow_end(a, 1);
     jl_cellset(a, jl_array_dim(a,0)-1, item);
 }
 
-DLLEXPORT void jl_cell_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c)
+JL_DLLEXPORT void jl_cell_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c)
 {
     assert(jl_typeis(a, jl_array_any_type));
     jl_array_grow_end(a, 2);
diff --git a/src/ast.c b/src/ast.c
index 0f30f19ddca78..225f3d62fc24b 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -26,202 +26,363 @@ extern "C" {
 #endif
 
 static uint8_t flisp_system_image[] = {
-#include "julia_flisp.boot.inc"
+#include <julia_flisp.boot.inc>
 };
 
-static fltype_t *jvtype=NULL;
+typedef struct _jl_ast_context_list_t {
+    struct _jl_ast_context_list_t *next;
+    struct _jl_ast_context_list_t **prev;
+} jl_ast_context_list_t;
 
-static value_t true_sym;
-static value_t false_sym;
-static value_t fl_error_sym;
-static value_t fl_null_sym;
-static value_t fl_jlgensym_sym;
+STATIC_INLINE void jl_ast_context_list_insert(jl_ast_context_list_t **head,
+                                              jl_ast_context_list_t *node)
+{
+    jl_ast_context_list_t *next = *head;
+    if (next)
+        next->prev = &node->next;
+    node->next = next;
+    node->prev = head;
+    *head = node;
+}
 
-static jl_value_t *scm_to_julia(value_t e, int expronly);
-static value_t julia_to_scm(jl_value_t *v);
+STATIC_INLINE void jl_ast_context_list_delete(jl_ast_context_list_t *node)
+{
+    if (node->next)
+        node->next->prev = node->prev;
+    *node->prev = node->next;
+}
 
-value_t fl_defined_julia_global(value_t *args, uint32_t nargs)
+typedef struct _jl_ast_context_t {
+    fl_context_t fl;
+    fltype_t *jvtype;
+
+    value_t true_sym;
+    value_t false_sym;
+    value_t error_sym;
+    value_t null_sym;
+    value_t jlgensym_sym;
+    arraylist_t gensym_to_flisp;
+    jl_ast_context_list_t list;
+    int ref;
+    jl_task_t *task;
+    // use a pointer to a stack slot so that we can detect if
+    // `jl_ast_preserve` is called in the wrong context.
+    // If `roots` is not NULL, it always points to a rooted stack slot.
+    jl_array_t **roots;
+} jl_ast_context_t;
+
+static jl_ast_context_t jl_ast_main_ctx;
+
+#define jl_ast_ctx(fl_ctx) container_of(fl_ctx, jl_ast_context_t, fl)
+#define jl_ast_context_list_item(node)          \
+    container_of(node, jl_ast_context_t, list)
+
+#define JL_AST_PRESERVE_PUSH(ctx, _roots, old_roots)    \
+    jl_array_t *_roots = NULL;                          \
+    jl_array_t **old_roots = ctx->roots;                \
+    ctx->roots = &_roots;                               \
+    JL_GC_PUSH1(&_roots)
+#define JL_AST_PRESERVE_POP(ctx, old_roots)     \
+    JL_GC_POP();                                \
+    ctx->roots = old_roots
+
+static void jl_ast_preserve(fl_context_t *fl_ctx, jl_value_t *obj)
+{
+    jl_ast_context_t *ctx = jl_ast_ctx(fl_ctx);
+    assert(ctx->roots);
+    jl_array_t *roots = *ctx->roots;
+    if (!roots) {
+        roots = *ctx->roots = jl_alloc_cell_1d(1);
+        jl_cellset(roots, 0, obj);
+    }
+    else {
+        jl_cell_1d_push(roots, obj);
+    }
+}
+
+static jl_value_t *scm_to_julia(fl_context_t *fl_ctx, value_t e, int expronly);
+static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v);
+
+value_t fl_defined_julia_global(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     // tells whether a var is defined in and *by* the current module
-    argcount("defined-julia-global", nargs, 1);
-    (void)tosymbol(args[0], "defined-julia-global");
+    argcount(fl_ctx, "defined-julia-global", nargs, 1);
+    (void)tosymbol(fl_ctx, args[0], "defined-julia-global");
     if (jl_current_module == NULL)
-        return FL_F;
-    jl_sym_t *var = jl_symbol(symbol_name(args[0]));
+        return fl_ctx->F;
+    jl_sym_t *var = jl_symbol(symbol_name(fl_ctx, args[0]));
     jl_binding_t *b =
         (jl_binding_t*)ptrhash_get(&jl_current_module->bindings, var);
-    return (b != HT_NOTFOUND && b->owner==jl_current_module) ? FL_T : FL_F;
+    return (b != HT_NOTFOUND && b->owner==jl_current_module) ? fl_ctx->T : fl_ctx->F;
 }
 
-value_t fl_current_julia_module(value_t *args, uint32_t nargs)
+value_t fl_current_julia_module(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    value_t opaque = cvalue(jvtype, sizeof(void*));
+    value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*));
     *(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = (jl_value_t*)jl_current_module;
     return opaque;
 }
 
-value_t fl_invoke_julia_macro(value_t *args, uint32_t nargs)
+value_t fl_current_module_counter(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
+{
+    static uint32_t fallback_counter = 0;
+    if (jl_current_module == NULL)
+        return fixnum(++fallback_counter);
+    else
+        return fixnum(jl_module_next_counter(jl_current_module));
+}
+
+value_t fl_invoke_julia_macro(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 1)
-        argcount("invoke-julia-macro", nargs, 1);
-    jl_function_t *f = NULL;
+        argcount(fl_ctx, "invoke-julia-macro", nargs, 1);
+    jl_value_t *f = NULL;
     jl_value_t **margs;
-    JL_GC_PUSHARGS(margs, nargs);
+    // Reserve one more slot for the result
+    JL_GC_PUSHARGS(margs, nargs + 1);
     int i;
-    for(i=1; i < nargs; i++) margs[i] = scm_to_julia(args[i], 1);
+    for(i=1; i < nargs; i++) margs[i] = scm_to_julia(fl_ctx, args[i], 1);
     jl_value_t *result = NULL;
 
     JL_TRY {
-        margs[0] = scm_to_julia(args[0], 1);
-        f = (jl_function_t*)jl_toplevel_eval(margs[0]);
-        assert(jl_is_func(f));
-        result = jl_apply(f, &margs[1], nargs-1);
+        margs[0] = scm_to_julia(fl_ctx, args[0], 1);
+        margs[0] = jl_toplevel_eval(margs[0]);
+        f = margs[0];
+        margs[nargs] = result = jl_apply_generic(margs, nargs);
     }
     JL_CATCH {
         JL_GC_POP();
-        value_t opaque = cvalue(jvtype, sizeof(void*));
+        value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*));
         *(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = jl_exception_in_transit;
-        return fl_list2(fl_error_sym, opaque);
+        return fl_list2(fl_ctx, jl_ast_ctx(fl_ctx)->error_sym, opaque);
     }
     // protect result from GC, otherwise it could be freed during future
     // macro expansions, since it will be referenced only from scheme and
     // not julia.
-    // all calls to invoke-julia-macro happen under a single call to jl_expand,
-    // so the preserved value stack is popped there.
+    // all calls to invoke-julia-macro happen under `jl_macroexpand`,
+    // `jl_expand` or `jl_parse_eval_all` so the preserved array is rooted there.
     assert(result != NULL);
-    jl_gc_preserve(result);
-    value_t scm = julia_to_scm(result);
-    fl_gc_handle(&scm);
+    jl_ast_preserve(fl_ctx, result);
+    value_t scm = julia_to_scm(fl_ctx, result);
+    fl_gc_handle(fl_ctx, &scm);
     value_t scmresult;
-    jl_module_t *defmod = f->linfo->module;
-    if (defmod == jl_current_module) {
-        scmresult = fl_cons(scm, FL_F);
+    jl_module_t *defmod = jl_gf_mtable(f)->module;
+    if (defmod == NULL || defmod == jl_current_module) {
+        scmresult = fl_cons(fl_ctx, scm, fl_ctx->F);
     }
     else {
-        value_t opaque = cvalue(jvtype, sizeof(void*));
+        value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*));
         *(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = (jl_value_t*)defmod;
-        scmresult = fl_cons(scm, opaque);
+        scmresult = fl_cons(fl_ctx, scm, opaque);
     }
-    fl_free_gc_handles(1);
+    fl_free_gc_handles(fl_ctx, 1);
 
     JL_GC_POP();
     return scmresult;
 }
 
-static builtinspec_t julia_flisp_ast_ext[] = {
+static const builtinspec_t julia_flisp_ast_ext[] = {
     { "defined-julia-global", fl_defined_julia_global },
     { "invoke-julia-macro", fl_invoke_julia_macro },
     { "current-julia-module", fl_current_julia_module },
+    { "current-julia-module-counter", fl_current_module_counter },
     { NULL, NULL }
 };
 
-extern int jl_parse_depwarn(int warn);
-extern int jl_parse_deperror(int err);
+static int jl_parse_deperror(fl_context_t *fl_ctx, int err);
+static int jl_parse_depwarn_(fl_context_t *fl_ctx, int warn);
 
-void jl_init_frontend(void)
+static void jl_init_ast_ctx(jl_ast_context_t *ast_ctx)
 {
-    fl_init(4*1024*1024);
+    fl_context_t *fl_ctx = &ast_ctx->fl;
+    fl_init(fl_ctx, 4*1024*1024);
 
-    if (fl_load_system_image_str((char*)flisp_system_image,
+    if (fl_load_system_image_str(fl_ctx, (char*)flisp_system_image,
                                  sizeof(flisp_system_image))) {
         jl_error("fatal error loading system image");
     }
 
-    fl_applyn(0, symbol_value(symbol("__init_globals")));
+    fl_applyn(fl_ctx, 0, symbol_value(symbol(fl_ctx, "__init_globals")));
 
-    jvtype = define_opaque_type(symbol("julia_value"), sizeof(void*),
-                                NULL, NULL);
-
-    assign_global_builtins(julia_flisp_ast_ext);
-    true_sym = symbol("true");
-    false_sym = symbol("false");
-    fl_error_sym = symbol("error");
-    fl_null_sym = symbol("null");
-    fl_jlgensym_sym = symbol("jlgensym");
+    jl_ast_ctx(fl_ctx)->jvtype = define_opaque_type(fl_ctx->jl_sym, sizeof(void*), NULL, NULL);
+    assign_global_builtins(fl_ctx, julia_flisp_ast_ext);
+    jl_ast_ctx(fl_ctx)->true_sym = symbol(fl_ctx, "true");
+    jl_ast_ctx(fl_ctx)->false_sym = symbol(fl_ctx, "false");
+    jl_ast_ctx(fl_ctx)->error_sym = symbol(fl_ctx, "error");
+    jl_ast_ctx(fl_ctx)->null_sym = symbol(fl_ctx, "null");
+    jl_ast_ctx(fl_ctx)->jlgensym_sym = symbol(fl_ctx, "jlgensym");
 
     // Enable / disable syntax deprecation warnings
     // Disable in imaging mode to avoid i/o errors (#10727)
     if (jl_generating_output())
-        jl_parse_depwarn(0);
+        jl_parse_depwarn_(fl_ctx, 0);
     else if (jl_options.depwarn == JL_OPTIONS_DEPWARN_ERROR)
-        jl_parse_deperror(1);
+        jl_parse_deperror(fl_ctx, 1);
     else
-        jl_parse_depwarn((int)jl_options.depwarn);
+        jl_parse_depwarn_(fl_ctx, (int)jl_options.depwarn);
 }
 
-DLLEXPORT void jl_lisp_prompt(void)
+// There should be no GC allocation while holding this lock
+JL_DEFINE_MUTEX(flisp)
+static jl_ast_context_list_t *jl_ast_ctx_using = NULL;
+static jl_ast_context_list_t *jl_ast_ctx_freed = NULL;
+
+static jl_ast_context_t *jl_ast_ctx_enter(void)
 {
-    if (jvtype==NULL) jl_init_frontend();
-    fl_applyn(1, symbol_value(symbol("__start")), fl_cons(FL_NIL,FL_NIL));
+    JL_LOCK_NOGC(flisp);
+    jl_ast_context_list_t *node;
+    jl_ast_context_t *ctx;
+    // First check if the current task is using one of the contexts
+    for (node = jl_ast_ctx_using;node;(node = node->next)) {
+        ctx = jl_ast_context_list_item(node);
+        if (ctx->task == jl_current_task) {
+            ctx->ref++;
+            JL_UNLOCK_NOGC(flisp);
+            return ctx;
+        }
+    }
+    // If not, grab one from the free list
+    if ((node = jl_ast_ctx_freed)) {
+        jl_ast_context_list_delete(node);
+        jl_ast_context_list_insert(&jl_ast_ctx_using, node);
+        ctx = jl_ast_context_list_item(node);
+        ctx->ref = 1;
+        ctx->task = jl_current_task;
+        ctx->roots = NULL;
+        JL_UNLOCK_NOGC(flisp);
+        return ctx;
+    }
+    // Construct a new one if we can't find any
+    ctx = (jl_ast_context_t*)calloc(1, sizeof(jl_ast_context_t));
+    // ctx->roots is NULL already due to calloc.
+    ctx->ref = 1;
+    ctx->task = jl_current_task;
+    node = &ctx->list;
+    jl_ast_context_list_insert(&jl_ast_ctx_using, node);
+    JL_UNLOCK_NOGC(flisp);
+    jl_init_ast_ctx(ctx);
+    return ctx;
+}
+
+static void jl_ast_ctx_leave(jl_ast_context_t *ctx)
+{
+    if (--ctx->ref)
+        return;
+    JL_LOCK_NOGC(flisp);
+    ctx->task = NULL;
+    jl_ast_context_list_t *node = &ctx->list;
+    jl_ast_context_list_delete(node);
+    jl_ast_context_list_insert(&jl_ast_ctx_freed, node);
+    JL_UNLOCK_NOGC(flisp);
 }
 
-static jl_sym_t *scmsym_to_julia(value_t s)
+void jl_init_frontend(void)
+{
+    if (jl_ast_ctx_using || jl_ast_ctx_freed)
+        return;
+    jl_ast_main_ctx.ref = 1;
+    jl_ast_main_ctx.task = jl_current_task;
+    jl_ast_context_list_insert(&jl_ast_ctx_using, &jl_ast_main_ctx.list);
+    jl_init_ast_ctx(&jl_ast_main_ctx);
+    jl_ast_ctx_leave(&jl_ast_main_ctx);
+}
+
+JL_DLLEXPORT void jl_lisp_prompt(void)
+{
+    jl_init_frontend();
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    JL_AST_PRESERVE_PUSH(ctx, roots, old_roots);
+    fl_context_t *fl_ctx = &ctx->fl;
+    fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "__start")), fl_cons(fl_ctx, fl_ctx->NIL,fl_ctx->NIL));
+    JL_AST_PRESERVE_POP(ctx, old_roots);
+    jl_ast_ctx_leave(ctx);
+}
+
+static jl_sym_t *scmsym_to_julia(fl_context_t *fl_ctx, value_t s)
 {
     assert(issymbol(s));
-    if (fl_isgensym(s)) {
+    if (fl_isgensym(fl_ctx, s)) {
         static char gsname[16];
         char *n = uint2str(&gsname[1], sizeof(gsname)-1,
                            ((gensym_t*)ptr(s))->id, 10);
         *(--n) = '#';
         return jl_symbol(n);
     }
-    return jl_symbol(symbol_name(s));
+    return jl_symbol(symbol_name(fl_ctx, s));
 }
 
-static jl_value_t *scm_to_julia_(value_t e, int expronly);
+static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, int expronly);
 
-static jl_value_t *full_list(value_t e, int expronly)
+static jl_svec_t *full_svec(fl_context_t *fl_ctx, value_t e, int expronly)
+{
+    size_t ln = llength(e);
+    if (ln == 0) return jl_emptysvec;
+    jl_svec_t *ar = jl_alloc_svec_uninit(ln);
+    JL_GC_PUSH1(&ar);
+    size_t i=0;
+    while (iscons(e)) {
+        jl_svecset(ar, i, scm_to_julia_(fl_ctx, car_(e), expronly));
+        e = cdr_(e);
+        i++;
+    }
+    JL_GC_POP();
+    return ar;
+}
+
+static jl_value_t *full_list(fl_context_t *fl_ctx, value_t e, int expronly)
 {
     size_t ln = llength(e);
     if (ln == 0) return jl_an_empty_cell;
     jl_array_t *ar = jl_alloc_cell_1d(ln);
+    JL_GC_PUSH1(&ar);
     size_t i=0;
     while (iscons(e)) {
-        jl_cellset(ar, i, scm_to_julia_(car_(e), expronly));
+        jl_cellset(ar, i, scm_to_julia_(fl_ctx, car_(e), expronly));
         e = cdr_(e);
         i++;
     }
+    JL_GC_POP();
     return (jl_value_t*)ar;
 }
 
-static jl_value_t *full_list_of_lists(value_t e, int expronly)
+static jl_value_t *full_list_of_lists(fl_context_t *fl_ctx, value_t e, int expronly)
 {
     size_t ln = llength(e);
     if (ln == 0) return jl_an_empty_cell;
     jl_array_t *ar = jl_alloc_cell_1d(ln);
+    JL_GC_PUSH1(&ar);
     size_t i=0;
     while (iscons(e)) {
-        jl_cellset(ar, i, full_list(car_(e),expronly));
+        jl_cellset(ar, i, full_list(fl_ctx, car_(e),expronly));
         e = cdr_(e);
         i++;
     }
+    JL_GC_POP();
     return (jl_value_t*)ar;
 }
 
-static jl_value_t *resolve_globals(jl_value_t *expr, jl_lambda_info_t *lam);
-
-static jl_value_t *scm_to_julia(value_t e, int expronly)
+static jl_value_t *scm_to_julia(fl_context_t *fl_ctx, value_t e, int expronly)
 {
-    int en = jl_gc_enable(0);
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     JL_TRY {
-        v = scm_to_julia_(e, expronly);
+        v = scm_to_julia_(fl_ctx, e, expronly);
     }
     JL_CATCH {
         // if expression cannot be converted, replace with error expr
         jl_expr_t *ex = jl_exprn(error_sym, 1);
-        jl_cellset(ex->args, 0, jl_cstr_to_string("invalid AST"));
         v = (jl_value_t*)ex;
+        jl_cellset(ex->args, 0, jl_cstr_to_string("invalid AST"));
     }
-    jl_gc_enable(en);
+    JL_GC_POP();
     return v;
 }
 
 extern int64_t conv_to_int64(void *data, numerictype_t tag);
 
-static jl_value_t *scm_to_julia_(value_t e, int eo)
+static jl_value_t *scm_to_julia_(fl_context_t *fl_ctx, value_t e, int eo)
 {
-    if (fl_isnumber(e)) {
+    if (fl_isnumber(fl_ctx, e)) {
         int64_t i64;
         if (isfixnum(e)) {
             i64 = numval(e);
@@ -258,145 +419,152 @@ static jl_value_t *scm_to_julia_(value_t e, int eo)
 #endif
     }
     if (issymbol(e)) {
-        if (e == true_sym)
+        if (e == jl_ast_ctx(fl_ctx)->true_sym)
             return jl_true;
-        else if (e == false_sym)
+        else if (e == jl_ast_ctx(fl_ctx)->false_sym)
             return jl_false;
-        return (jl_value_t*)scmsym_to_julia(e);
+        return (jl_value_t*)scmsym_to_julia(fl_ctx, e);
     }
-    if (fl_isstring(e))
+    if (fl_isstring(fl_ctx, e))
         return jl_pchar_to_string((char*)cvalue_data(e), cvalue_len(e));
-    if (e == FL_F)
+    if (e == fl_ctx->F)
         return jl_false;
-    if (e == FL_T)
+    if (e == fl_ctx->T)
         return jl_true;
-    if (e == FL_NIL) {
-        assert(0 && "Jeff doesn't think this is supposed to happen");
-    }
-    if (iscons(e)) {
-        value_t hd = car_(e);
-        if (hd == fl_jlgensym_sym) {
-            size_t genid = numval(car_(cdr_(e)));
-            return jl_box_gensym(genid);
+    if (iscons(e) || e == fl_ctx->NIL) {
+        value_t hd;
+        jl_sym_t *sym;
+        if (e == fl_ctx->NIL) {
+            hd = e;
         }
-        if (hd == fl_null_sym && llength(e) == 1)
-            return jl_nothing;
-        if (issymbol(hd)) {
-            jl_sym_t *sym = scmsym_to_julia(hd);
-            /* tree node types:
-               goto  gotoifnot  label  return
-               lambda  call  =  quote
-               null  top  method
-               body  file new
-               line  enter  leave
-            */
-            size_t n = llength(e)-1;
-            size_t i;
-            if (sym == lambda_sym) {
-                jl_expr_t *ex = jl_exprn(lambda_sym, n);
-                e = cdr_(e);
-                value_t largs = car_(e);
-                jl_cellset(ex->args, 0, full_list(largs,eo));
-                e = cdr_(e);
+        else {
+            hd = car_(e);
+            if (hd == jl_ast_ctx(fl_ctx)->jlgensym_sym) {
+                size_t genid = numval(car_(cdr_(e)));
+                return jl_box_gensym(genid);
+            }
+            if (hd == jl_ast_ctx(fl_ctx)->null_sym && llength(e) == 1)
+                return jl_nothing;
+        }
+        if (issymbol(hd))
+            sym = scmsym_to_julia(fl_ctx, hd);
+        else
+            sym = list_sym;
+        size_t n = llength(e)-1;
+        size_t i;
+        if (sym == lambda_sym) {
+            jl_expr_t *ex = jl_exprn(lambda_sym, n);
+            jl_svec_t *tvars = NULL;
+            jl_array_t *vinf = NULL;
+            jl_lambda_info_t *nli = NULL;
+            JL_GC_PUSH4(&ex, &tvars, &vinf, &nli);
+            e = cdr_(e);
+            value_t largs = car_(e);
+            jl_cellset(ex->args, 0, full_list(fl_ctx, largs, eo));
+            e = cdr_(e);
 
-                value_t ee = car_(e);
-                jl_array_t *vinf = jl_alloc_cell_1d(4);
-                jl_cellset(vinf, 0, full_list_of_lists(car_(ee),eo));
-                ee = cdr_(ee);
-                jl_cellset(vinf, 1, full_list_of_lists(car_(ee),eo));
-                ee = cdr_(ee);
-                jl_cellset(vinf, 2, isfixnum(car_(ee)) ?
-                           jl_box_long(numval(car_(ee))) :
-                           full_list(car_(ee),eo));
-                ee = cdr_(ee);
-                jl_cellset(vinf, 3, full_list(car_(ee),eo));
-                assert(!iscons(cdr_(ee)));
-                jl_cellset(ex->args, 1, vinf);
-                e = cdr_(e);
+            value_t ee = car_(e);
+            vinf = jl_alloc_cell_1d(3);
+            jl_cellset(vinf, 0, full_list_of_lists(fl_ctx, car_(ee), eo));
+            ee = cdr_(ee);
+            jl_cellset(vinf, 1, full_list_of_lists(fl_ctx, car_(ee), eo));
+            ee = cdr_(ee);
+            jl_cellset(vinf, 2, isfixnum(car_(ee)) ?
+                       jl_box_long(numval(car_(ee))) :
+                       full_list(fl_ctx,car_(ee),eo));
+            ee = cdr_(ee);
+            tvars = full_svec(fl_ctx, car_(ee), eo);
+            assert(!iscons(cdr_(ee)));
+            jl_cellset(ex->args, 1, vinf);
+            e = cdr_(e);
 
-                for(i=2; i < n; i++) {
-                    assert(iscons(e));
-                    jl_cellset(ex->args, i, scm_to_julia_(car_(e), eo));
-                    e = cdr_(e);
-                }
-                jl_lambda_info_t *nli = jl_new_lambda_info((jl_value_t*)ex, jl_emptysvec, jl_current_module);
-                resolve_globals(nli->ast, nli);
-                return (jl_value_t*)nli;
+            for(i=2; i < n; i++) {
+                assert(iscons(e));
+                jl_cellset(ex->args, i, scm_to_julia_(fl_ctx, car_(e), eo));
+                e = cdr_(e);
             }
+            nli = jl_new_lambda_info((jl_value_t*)ex, tvars, jl_emptysvec, jl_current_module);
+            jl_preresolve_globals(nli->ast, nli);
+            JL_GC_POP();
+            return (jl_value_t*)nli;
+        }
 
+        if (issymbol(hd))
             e = cdr_(e);
-            if (!eo) {
-                if (sym == line_sym && n==2) {
-                    // NOTE: n==3 case exists: '(line, linenum, filename, funcname) passes
-                    //       the original name through to keyword-arg specializations.
-                    //       See 'line handling in julia-syntax.scm:keywords-method-def-expr
-                    jl_value_t *filename = NULL, *linenum = NULL;
-                    JL_GC_PUSH2(&filename, &linenum);
-                    filename = scm_to_julia_(car_(cdr_(e)),0);
-                    linenum  = scm_to_julia_(car_(e),0);
-                    jl_value_t *temp = jl_new_struct(jl_linenumbernode_type,
-                                                     filename, linenum);
-                    JL_GC_POP();
-                    return temp;
-                }
-                jl_value_t *scmv = NULL, *temp = NULL;
-                JL_GC_PUSH1(&scmv);
-                if (sym == label_sym) {
-                    scmv = scm_to_julia_(car_(e),0);
-                    temp = jl_new_struct(jl_labelnode_type, scmv);
-                    JL_GC_POP();
-                    return temp;
-                }
-                if (sym == goto_sym) {
-                    scmv = scm_to_julia_(car_(e),0);
-                    temp = jl_new_struct(jl_gotonode_type, scmv);
-                    JL_GC_POP();
-                    return temp;
-                }
-                if (sym == inert_sym || (sym == quote_sym && (!iscons(car_(e))))) {
-                    scmv = scm_to_julia_(car_(e),0);
-                    temp = jl_new_struct(jl_quotenode_type, scmv);
-                    JL_GC_POP();
-                    return temp;
-                }
-                if (sym == top_sym) {
-                    scmv = scm_to_julia_(car_(e),0);
-                    temp = jl_new_struct(jl_topnode_type, scmv);
-                    JL_GC_POP();
-                    return temp;
-                }
-                if (sym == newvar_sym) {
-                    scmv = scm_to_julia_(car_(e),0);
-                    temp = jl_new_struct(jl_newvarnode_type, scmv);
-                    JL_GC_POP();
-                    return temp;
-                }
+        else
+            n++;
+        if (!eo) {
+            if (sym == line_sym && n==2) {
+                // NOTE: n==3 case exists: '(line, linenum, filename, funcname) passes
+                //       the original name through to keyword-arg specializations.
+                //       See 'line handling in julia-syntax.scm:keywords-method-def-expr
+                jl_value_t *filename = NULL, *linenum = NULL;
+                JL_GC_PUSH2(&filename, &linenum);
+                filename = scm_to_julia_(fl_ctx, car_(cdr_(e)), 0);
+                linenum  = scm_to_julia_(fl_ctx, car_(e), 0);
+                jl_value_t *temp = jl_new_struct(jl_linenumbernode_type,
+                                                 filename, linenum);
                 JL_GC_POP();
+                return temp;
             }
-            else if (sym == inert_sym && !iscons(car_(e))) {
-                sym = quote_sym;
+            jl_value_t *scmv = NULL, *temp = NULL;
+            JL_GC_PUSH1(&scmv);
+            if (sym == label_sym) {
+                scmv = scm_to_julia_(fl_ctx,car_(e),0);
+                temp = jl_new_struct(jl_labelnode_type, scmv);
+                JL_GC_POP();
+                return temp;
             }
-            jl_expr_t *ex = jl_exprn(sym, n);
-            // allocate a fresh args array for empty exprs passed to macros
-            if (eo && n == 0)
-                ex->args = jl_alloc_cell_1d(0);
-            for(i=0; i < n; i++) {
-                assert(iscons(e));
-                jl_cellset(ex->args, i, scm_to_julia_(car_(e),eo));
-                e = cdr_(e);
+            if (sym == goto_sym) {
+                scmv = scm_to_julia_(fl_ctx,car_(e),0);
+                temp = jl_new_struct(jl_gotonode_type, scmv);
+                JL_GC_POP();
+                return temp;
+            }
+            if (sym == inert_sym || (sym == quote_sym && (!iscons(car_(e))))) {
+                scmv = scm_to_julia_(fl_ctx,car_(e),0);
+                temp = jl_new_struct(jl_quotenode_type, scmv);
+                JL_GC_POP();
+                return temp;
+            }
+            if (sym == top_sym) {
+                scmv = scm_to_julia_(fl_ctx,car_(e),0);
+                temp = jl_new_struct(jl_topnode_type, scmv);
+                JL_GC_POP();
+                return temp;
             }
-            return (jl_value_t*)ex;
+            if (sym == newvar_sym) {
+                scmv = scm_to_julia_(fl_ctx,car_(e),0);
+                temp = jl_new_struct(jl_newvarnode_type, scmv);
+                JL_GC_POP();
+                return temp;
+            }
+            JL_GC_POP();
         }
-        else {
-            jl_error("malformed tree");
+        else if (sym == inert_sym && !iscons(car_(e))) {
+            sym = quote_sym;
+        }
+        jl_expr_t *ex = jl_exprn(sym, n);
+        JL_GC_PUSH1(&ex);
+        // allocate a fresh args array for empty exprs passed to macros
+        if (eo && n == 0) {
+            ex->args = jl_alloc_cell_1d(0);
+            jl_gc_wb(ex, ex->args);
         }
+        for(i=0; i < n; i++) {
+            assert(iscons(e));
+            jl_cellset(ex->args, i, scm_to_julia_(fl_ctx, car_(e), eo));
+            e = cdr_(e);
+        }
+        JL_GC_POP();
+        if (sym == list_sym)
+            return (jl_value_t*)ex->args;
+        return (jl_value_t*)ex;
     }
-    if (iscprim(e) && cp_class((cprim_t*)ptr(e))==wchartype) {
-        jl_value_t *wc =
-            jl_box32(jl_char_type, *(int32_t*)cp_data((cprim_t*)ptr(e)));
-        return wc;
+    if (iscprim(e) && cp_class((cprim_t*)ptr(e)) == fl_ctx->wchartype) {
+        return jl_box32(jl_char_type, *(int32_t*)cp_data((cprim_t*)ptr(e)));
     }
-    if (iscvalue(e) && cv_class((cvalue_t*)ptr(e)) == jvtype) {
+    if (iscvalue(e) && cv_class((cvalue_t*)ptr(e)) == jl_ast_ctx(fl_ctx)->jvtype) {
         return *(jl_value_t**)cv_data((cvalue_t*)ptr(e));
     }
     jl_error("malformed tree");
@@ -404,227 +572,290 @@ static jl_value_t *scm_to_julia_(value_t e, int eo)
     return jl_nothing;
 }
 
-static value_t julia_to_scm_(jl_value_t *v);
-static arraylist_t jlgensym_to_flisp;
+static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v);
 
-static value_t julia_to_scm(jl_value_t *v)
+static value_t julia_to_scm(fl_context_t *fl_ctx, jl_value_t *v)
 {
     value_t temp;
-    if (jlgensym_to_flisp.len)
-        jlgensym_to_flisp.len = 0; // in case we didn't free it last time we got here (for example, if we threw an error)
+    arraylist_t *jlgensym_to_flisp = &jl_ast_ctx(fl_ctx)->gensym_to_flisp;
+    if (jlgensym_to_flisp->len)
+        jlgensym_to_flisp->len = 0; // in case we didn't free it last time we got here (for example, if we threw an error)
     else
-        arraylist_new(&jlgensym_to_flisp, 0);
+        arraylist_new(jlgensym_to_flisp, 0);
     // need try/catch to reset GC handle stack in case of error
-    FL_TRY_EXTERN {
-        temp = julia_to_scm_(v);
+    FL_TRY_EXTERN(fl_ctx) {
+        temp = julia_to_scm_(fl_ctx, v);
     }
-    FL_CATCH_EXTERN {
-        temp = fl_list2(fl_error_sym, cvalue_static_cstring("expression too large"));
+    FL_CATCH_EXTERN(fl_ctx) {
+        temp = fl_list2(fl_ctx, jl_ast_ctx(fl_ctx)->error_sym, cvalue_static_cstring(fl_ctx, "expression too large"));
     }
-    arraylist_free(&jlgensym_to_flisp);
+    arraylist_free(jlgensym_to_flisp);
     return temp;
 }
 
-static void array_to_list(jl_array_t *a, value_t *pv)
+static void array_to_list(fl_context_t *fl_ctx, jl_array_t *a, value_t *pv)
 {
     if (jl_array_len(a) > 300000)
-        lerror(OutOfMemoryError, "expression too large");
+        lerror(fl_ctx, fl_ctx->OutOfMemoryError, "expression too large");
     value_t temp;
     for(long i=jl_array_len(a)-1; i >= 0; i--) {
-        *pv = fl_cons(FL_NIL, *pv);
-        temp = julia_to_scm_(jl_cellref(a,i));
+        *pv = fl_cons(fl_ctx, fl_ctx->NIL, *pv);
+        temp = julia_to_scm_(fl_ctx, jl_cellref(a,i));
         // note: must be separate statement
         car_(*pv) = temp;
     }
 }
 
-static value_t julia_to_list2(jl_value_t *a, jl_value_t *b)
+static value_t julia_to_list2(fl_context_t *fl_ctx, jl_value_t *a, jl_value_t *b)
 {
-    value_t sa = julia_to_scm_(a);
-    fl_gc_handle(&sa);
-    value_t sb = julia_to_scm_(b);
-    value_t l = fl_list2(sa, sb);
-    fl_free_gc_handles(1);
+    value_t sa = julia_to_scm_(fl_ctx, a);
+    fl_gc_handle(fl_ctx, &sa);
+    value_t sb = julia_to_scm_(fl_ctx, b);
+    value_t l = fl_list2(fl_ctx, sa, sb);
+    fl_free_gc_handles(fl_ctx, 1);
     return l;
 }
 
-static value_t julia_to_scm_(jl_value_t *v)
+static value_t julia_to_scm_(fl_context_t *fl_ctx, jl_value_t *v)
 {
     if (jl_is_symbol(v))
-        return symbol(((jl_sym_t*)v)->name);
+        return symbol(fl_ctx, jl_symbol_name((jl_sym_t*)v));
     if (jl_is_gensym(v)) {
         size_t idx = ((jl_gensym_t*)v)->id;
         size_t i;
-        for (i = 0; i < jlgensym_to_flisp.len; i+=2) {
-            if ((ssize_t)jlgensym_to_flisp.items[i] == idx)
-                return fl_list2(fl_jlgensym_sym, fixnum((size_t)jlgensym_to_flisp.items[i+1]));
+        arraylist_t *jlgensym_to_flisp = &jl_ast_ctx(fl_ctx)->gensym_to_flisp;
+        for (i = 0; i < jlgensym_to_flisp->len; i+=2) {
+            if ((ssize_t)jlgensym_to_flisp->items[i] == idx)
+                return fl_list2(fl_ctx, jl_ast_ctx(fl_ctx)->jlgensym_sym, fixnum((size_t)jlgensym_to_flisp->items[i+1]));
         }
-        arraylist_push(&jlgensym_to_flisp, (void*)idx);
-        value_t flv = fl_applyn(0, symbol_value(symbol("make-jlgensym")));
-        assert(iscons(flv) && car_(flv) == fl_jlgensym_sym);
-        arraylist_push(&jlgensym_to_flisp, (void*)(size_t)numval(car_(cdr_(flv))));
+        arraylist_push(jlgensym_to_flisp, (void*)idx);
+        value_t flv = fl_applyn(fl_ctx, 0, symbol_value(symbol(fl_ctx, "make-jlgensym")));
+        assert(iscons(flv) && car_(flv) == jl_ast_ctx(fl_ctx)->jlgensym_sym);
+        arraylist_push(jlgensym_to_flisp, (void*)(size_t)numval(car_(cdr_(flv))));
         return flv;
     }
     if (v == jl_true)
-        return FL_T;
+        return fl_ctx->T;
     if (v == jl_false)
-        return FL_F;
+        return fl_ctx->F;
     if (v == jl_nothing)
-        return fl_cons(fl_null_sym, FL_NIL);
+        return fl_cons(fl_ctx, jl_ast_ctx(fl_ctx)->null_sym, fl_ctx->NIL);
     if (jl_is_expr(v)) {
         jl_expr_t *ex = (jl_expr_t*)v;
-        value_t args = FL_NIL;
-        fl_gc_handle(&args);
-        array_to_list(ex->args, &args);
-        value_t hd = julia_to_scm_((jl_value_t*)ex->head);
-        value_t scmv = fl_cons(hd, args);
-        fl_free_gc_handles(1);
+        value_t args = fl_ctx->NIL;
+        fl_gc_handle(fl_ctx, &args);
+        array_to_list(fl_ctx, ex->args, &args);
+        value_t hd = julia_to_scm_(fl_ctx, (jl_value_t*)ex->head);
+        if (ex->head == lambda_sym && jl_expr_nargs(ex)>0 && jl_is_array(jl_exprarg(ex,0))) {
+            value_t llist = fl_ctx->NIL;
+            fl_gc_handle(fl_ctx, &llist);
+            array_to_list(fl_ctx, (jl_array_t*)jl_exprarg(ex,0), &llist);
+            car_(args) = llist;
+            fl_free_gc_handles(fl_ctx, 1);
+        }
+        value_t scmv = fl_cons(fl_ctx, hd, args);
+        fl_free_gc_handles(fl_ctx, 1);
         return scmv;
     }
     if (jl_typeis(v, jl_linenumbernode_type)) {
-        value_t args = julia_to_list2(jl_fieldref(v,1), jl_fieldref(v,0));
-        fl_gc_handle(&args);
-        value_t hd = julia_to_scm_((jl_value_t*)line_sym);
-        value_t scmv = fl_cons(hd, args);
-        fl_free_gc_handles(1);
+        // GC Note: jl_fieldref(v, 1) allocates but neither jl_fieldref(v, 0)
+        //          or julia_to_list2 should allocate here
+        value_t args = julia_to_list2(fl_ctx, jl_fieldref(v,1), jl_fieldref(v,0));
+        fl_gc_handle(fl_ctx, &args);
+        value_t hd = julia_to_scm_(fl_ctx, (jl_value_t*)line_sym);
+        value_t scmv = fl_cons(fl_ctx, hd, args);
+        fl_free_gc_handles(fl_ctx, 1);
         return scmv;
     }
+    // GC Note: jl_fieldref(v, 0) allocate for LabelNode, GotoNode
+    //          but we don't need a GC root here because julia_to_list2
+    //          shouldn't allocate in this case.
     if (jl_typeis(v, jl_labelnode_type))
-        return julia_to_list2((jl_value_t*)label_sym, jl_fieldref(v,0));
+        return julia_to_list2(fl_ctx, (jl_value_t*)label_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_gotonode_type))
-        return julia_to_list2((jl_value_t*)goto_sym, jl_fieldref(v,0));
+        return julia_to_list2(fl_ctx, (jl_value_t*)goto_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_quotenode_type))
-        return julia_to_list2((jl_value_t*)inert_sym, jl_fieldref(v,0));
+        return julia_to_list2(fl_ctx, (jl_value_t*)inert_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_newvarnode_type))
-        return julia_to_list2((jl_value_t*)newvar_sym, jl_fieldref(v,0));
+        return julia_to_list2(fl_ctx, (jl_value_t*)newvar_sym, jl_fieldref(v,0));
     if (jl_typeis(v, jl_topnode_type))
-        return julia_to_list2((jl_value_t*)top_sym, jl_fieldref(v,0));
+        return julia_to_list2(fl_ctx, (jl_value_t*)top_sym, jl_fieldref(v,0));
     if (jl_is_long(v) && fits_fixnum(jl_unbox_long(v)))
         return fixnum(jl_unbox_long(v));
-    value_t opaque = cvalue(jvtype, sizeof(void*));
+    value_t opaque = cvalue(fl_ctx, jl_ast_ctx(fl_ctx)->jvtype, sizeof(void*));
     *(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = v;
     return opaque;
 }
 
 // this is used to parse a line of repl input
-DLLEXPORT jl_value_t *jl_parse_input_line(const char *str, size_t len)
+JL_DLLEXPORT jl_value_t *jl_parse_input_line(const char *str, size_t len)
 {
-    value_t s = cvalue_static_cstrn(str, len);
-    value_t e = fl_applyn(1, symbol_value(symbol("jl-parse-string")), s);
-    if (e == FL_EOF)
-        return jl_nothing;
-    return scm_to_julia(e,0);
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    fl_context_t *fl_ctx = &ctx->fl;
+    value_t s = cvalue_static_cstrn(fl_ctx, str, len);
+    value_t e = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "jl-parse-string")), s);
+    jl_value_t *res = e == fl_ctx->FL_EOF ? jl_nothing : scm_to_julia(fl_ctx, e, 0);
+    jl_ast_ctx_leave(ctx);
+    return res;
 }
 
 // this is for parsing one expression out of a string, keeping track of
 // the current position.
-DLLEXPORT jl_value_t *jl_parse_string(const char *str, size_t len,
-                                      int pos0, int greedy)
+JL_DLLEXPORT jl_value_t *jl_parse_string(const char *str, size_t len,
+                                         int pos0, int greedy)
 {
-    value_t s = cvalue_static_cstrn(str, len);
-    value_t p = fl_applyn(3, symbol_value(symbol("jl-parse-one-string")),
-                          s, fixnum(pos0), greedy?FL_T:FL_F);
+    if (pos0 < 0 || pos0 > len) {
+        jl_array_t *buf = jl_pchar_to_array(str, len);
+        JL_GC_PUSH1(&buf);
+        // jl_bounds_error roots the arguments.
+        jl_bounds_error((jl_value_t*)buf, jl_box_long(pos0));
+    }
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    fl_context_t *fl_ctx = &ctx->fl;
+    value_t s = cvalue_static_cstrn(fl_ctx, str, len);
+    value_t p = fl_applyn(fl_ctx, 3, symbol_value(symbol(fl_ctx, "jl-parse-one-string")),
+                          s, fixnum(pos0), greedy?fl_ctx->T:fl_ctx->F);
     jl_value_t *expr=NULL, *pos1=NULL;
     JL_GC_PUSH2(&expr, &pos1);
 
     value_t e = car_(p);
-    if (e == FL_EOF)
+    if (e == fl_ctx->FL_EOF)
         expr = jl_nothing;
     else
-        expr = scm_to_julia(e,0);
+        expr = scm_to_julia(fl_ctx, e, 0);
 
-    pos1 = jl_box_long(tosize(cdr_(p),"parse"));
+    pos1 = jl_box_long(tosize(fl_ctx, cdr_(p),"parse"));
+    jl_ast_ctx_leave(ctx);
     jl_value_t *result = (jl_value_t*)jl_svec2(expr, pos1);
     JL_GC_POP();
     return result;
 }
 
-int jl_start_parsing_file(const char *fname)
+// parse and eval a whole file, possibly reading from a string (`content`)
+jl_value_t *jl_parse_eval_all(const char *fname, size_t len,
+                              const char *content, size_t contentlen)
 {
-    value_t s = cvalue_static_cstring(fname);
-    if (fl_applyn(1, symbol_value(symbol("jl-parse-file")), s) == FL_F)
-        return 1;
-    return 0;
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    fl_context_t *fl_ctx = &ctx->fl;
+    value_t f, ast;
+    f = cvalue_static_cstring(fl_ctx, fname);
+    fl_gc_handle(fl_ctx, &f);
+    if (content != NULL) {
+        value_t t = cvalue_static_cstrn(fl_ctx, content, contentlen);
+        fl_gc_handle(fl_ctx, &t);
+        ast = fl_applyn(fl_ctx, 2, symbol_value(symbol(fl_ctx, "jl-parse-string-stream")), t, f);
+        fl_free_gc_handles(fl_ctx, 1);
+    }
+    else {
+        ast = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "jl-parse-file")), f);
+    }
+    fl_free_gc_handles(fl_ctx, 1);
+    if (ast == fl_ctx->F) {
+        jl_ast_ctx_leave(ctx);
+        jl_errorf("could not open file %s", fname);
+    }
+    fl_gc_handle(fl_ctx, &ast);
+
+    int last_lineno = jl_lineno;
+    const char *last_filename = jl_filename;
+    jl_lineno = 0;
+    jl_filename = fname;
+    jl_array_t *roots = NULL;
+    jl_array_t **old_roots = ctx->roots;
+    ctx->roots = &roots;
+    jl_value_t *form=NULL, *result=jl_nothing;
+    int err = 0;
+    JL_GC_PUSH3(&roots, &form, &result);
+    JL_TRY {
+        assert(iscons(ast) && car_(ast) == symbol(fl_ctx,"toplevel"));
+        ast = cdr_(ast);
+        while (iscons(ast)) {
+            value_t expansion = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "jl-expand-to-thunk")), car_(ast));
+            form = scm_to_julia(fl_ctx, expansion, 0);
+            jl_sym_t *head = NULL;
+            if (jl_is_expr(form)) head = ((jl_expr_t*)form)->head;
+            if (head == jl_incomplete_sym)
+                jl_errorf("syntax: %s", jl_string_data(jl_exprarg(form,0)));
+            else if (head == error_sym)
+                jl_interpret_toplevel_expr(form);
+            else if (head == line_sym)
+                jl_lineno = jl_unbox_long(jl_exprarg(form,0));
+            else
+                result = jl_toplevel_eval_flex(form, 1);
+            ast = cdr_(ast);
+        }
+    }
+    JL_CATCH {
+        form = jl_pchar_to_string(fname, len);
+        result = jl_box_long(jl_lineno);
+        err = 1;
+    }
+    jl_lineno = last_lineno;
+    jl_filename = last_filename;
+    fl_free_gc_handles(fl_ctx, 1);
+    ctx->roots = old_roots;
+    jl_ast_ctx_leave(ctx);
+    if (err) {
+        if (jl_loaderror_type == NULL)
+            jl_rethrow();
+        else
+            jl_rethrow_other(jl_new_struct(jl_loaderror_type, form, result,
+                                           jl_exception_in_transit));
+    }
+    JL_GC_POP();
+    return result;
 }
 
-void jl_stop_parsing(void)
+JL_DLLEXPORT jl_value_t *jl_load_file_string(const char *text, size_t len,
+                                             char *filename, size_t namelen)
 {
-    fl_applyn(0, symbol_value(symbol("jl-parser-close-stream")));
+    return jl_parse_eval_all(filename, namelen, text, len);
 }
 
-DLLEXPORT int jl_parse_depwarn(int warn)
+JL_DLLEXPORT int jl_parse_depwarn(int warn)
 {
-    value_t prev = fl_applyn(1, symbol_value(symbol("jl-parser-depwarn")),
-                             warn ? FL_T : FL_F);
-    return prev == FL_T ? 1 : 0;
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    int res = jl_parse_depwarn_(&ctx->fl, warn);
+    jl_ast_ctx_leave(ctx);
+    return res;
 }
 
-int jl_parse_deperror(int err)
+static int jl_parse_depwarn_(fl_context_t *fl_ctx, int warn)
 {
-    value_t prev = fl_applyn(1, symbol_value(symbol("jl-parser-deperror")),
-                             err ? FL_T : FL_F);
-    return prev == FL_T ? 1 : 0;
+    value_t prev = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "jl-parser-depwarn")),
+                             warn ? fl_ctx->T : fl_ctx->F);
+    return prev == fl_ctx->T ? 1 : 0;
 }
 
-extern int jl_lineno;
-
-jl_value_t *jl_parse_next(void)
+static int jl_parse_deperror(fl_context_t *fl_ctx, int err)
 {
-    value_t c = fl_applyn(0, symbol_value(symbol("jl-parser-next")));
-    if (c == FL_EOF)
-        return NULL;
-    if (iscons(c)) {
-        if (cdr_(c) == FL_EOF)
-            return NULL;
-        value_t a = car_(c);
-        if (isfixnum(a)) {
-            jl_lineno = numval(a);
-            //jl_printf(JL_STDERR, "  on line %d\n", jl_lineno);
-            c = cdr_(c);
-        }
-    }
-    // for error, get most recent line number
-    if (iscons(c) && car_(c) == fl_error_sym)
-        jl_lineno = numval(fl_applyn(0, symbol_value(symbol("jl-parser-current-lineno"))));
-    return scm_to_julia(c,0);
+    value_t prev = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "jl-parser-deperror")),
+                             err ? fl_ctx->T : fl_ctx->F);
+    return prev == fl_ctx->T ? 1 : 0;
 }
 
-jl_value_t *jl_load_file_string(const char *text, size_t len,
-                                char *filename, size_t namelen)
+// returns either an expression or a thunk
+jl_value_t *jl_call_scm_on_ast(char *funcname, jl_value_t *expr)
 {
-    value_t t, f;
-    t = cvalue_static_cstrn(text, len);
-    fl_gc_handle(&t);
-    f = cvalue_static_cstrn(filename, namelen);
-    fl_applyn(2, symbol_value(symbol("jl-parse-string-stream")), t, f);
-    fl_free_gc_handles(1);
-    return jl_parse_eval_all(filename, namelen);
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    fl_context_t *fl_ctx = &ctx->fl;
+    JL_AST_PRESERVE_PUSH(ctx, roots, old_roots);
+    value_t arg = julia_to_scm(fl_ctx, expr);
+    value_t e = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, funcname)), arg);
+    jl_value_t *result = scm_to_julia(fl_ctx, e, 0);
+    JL_AST_PRESERVE_POP(ctx, old_roots);
+    jl_ast_ctx_leave(ctx);
+    return result;
 }
 
-// returns either an expression or a thunk
-jl_value_t *jl_expand(jl_value_t *expr)
+JL_DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr)
 {
-    int np = jl_gc_n_preserved_values();
-    value_t arg = julia_to_scm(expr);
-    value_t e = fl_applyn(1, symbol_value(symbol("jl-expand-to-thunk")), arg);
-    jl_value_t *result = scm_to_julia(e,0);
-    while (jl_gc_n_preserved_values() > np) {
-        jl_gc_unpreserve();
-    }
-    return result;
+    return jl_call_scm_on_ast("jl-expand-to-thunk", expr);
 }
 
-DLLEXPORT jl_value_t *jl_macroexpand(jl_value_t *expr)
+JL_DLLEXPORT jl_value_t *jl_macroexpand(jl_value_t *expr)
 {
-    int np = jl_gc_n_preserved_values();
-    value_t arg = julia_to_scm(expr);
-    value_t e = fl_applyn(1, symbol_value(symbol("jl-macroexpand")), arg);
-    jl_value_t *result;
-    result = scm_to_julia(e,0);
-    while (jl_gc_n_preserved_values() > np) {
-        jl_gc_unpreserve();
-    }
-    return result;
+    return jl_call_scm_on_ast("jl-macroexpand", expr);
 }
 
 ssize_t jl_max_jlgensym_in(jl_value_t *v)
@@ -654,11 +885,10 @@ jl_lambda_info_t *jl_wrap_expr(jl_value_t *expr)
     JL_GC_PUSH3(&le, &vi, &bo);
     le = jl_exprn(lambda_sym, 3);
     jl_cellset(le->args, 0, mt);
-    vi = (jl_value_t*)jl_alloc_cell_1d(4);
+    vi = (jl_value_t*)jl_alloc_cell_1d(3);
     jl_cellset(vi, 0, mt);
     jl_cellset(vi, 1, mt);
     jl_cellset(vi, 2, jl_box_long(jl_max_jlgensym_in(expr)+1));
-    jl_cellset(vi, 3, mt);
     jl_cellset(le->args, 1, vi);
     if (!jl_is_expr(expr) || ((jl_expr_t*)expr)->head != body_sym) {
         bo = jl_exprn(body_sym, 1);
@@ -667,7 +897,7 @@ jl_lambda_info_t *jl_wrap_expr(jl_value_t *expr)
         expr = (jl_value_t*)bo;
     }
     jl_cellset(le->args, 2, expr);
-    jl_lambda_info_t *li = jl_new_lambda_info((jl_value_t*)le, jl_emptysvec, jl_current_module);
+    jl_lambda_info_t *li = jl_new_lambda_info((jl_value_t*)le, jl_emptysvec, jl_emptysvec, jl_current_module);
     JL_GC_POP();
     return li;
 }
@@ -707,48 +937,16 @@ jl_array_t *jl_lam_vinfo(jl_expr_t *l)
     return (jl_array_t*)ll;
 }
 
-// get array of var info records for captured vars
-jl_array_t *jl_lam_capt(jl_expr_t *l)
-{
-    assert(jl_is_expr(l));
-    jl_value_t *le = jl_exprarg(l, 1);
-    assert(jl_is_array(le));
-    jl_value_t *ll = jl_cellref(le, 1);
-    assert(jl_is_array(ll));
-    return (jl_array_t*)ll;
-}
-
 // get array of types for GenSym vars, or its length (if not type-inferred)
 jl_value_t *jl_lam_gensyms(jl_expr_t *l)
 {
     assert(jl_is_expr(l));
     jl_value_t *le = jl_exprarg(l, 1);
     assert(jl_is_array(le));
-    assert(jl_array_len(le) == 4);
+    assert(jl_array_len(le) == 3);
     return jl_cellref(le, 2);
 }
 
-// get array of static parameter symbols
-jl_array_t *jl_lam_staticparams(jl_expr_t *l)
-{
-    assert(jl_is_expr(l));
-    jl_value_t *le = jl_exprarg(l, 1);
-    assert(jl_is_array(le));
-    assert(jl_array_len(le) == 4);
-    assert(jl_is_array(jl_cellref(le, 3)));
-    return (jl_array_t*)jl_cellref(le, 3);
-}
-
-int jl_lam_vars_captured(jl_expr_t *ast)
-{
-    jl_array_t *vinfos = jl_lam_vinfo(ast);
-    for(int i=0; i < jl_array_len(vinfos); i++) {
-        if (jl_vinfo_capt((jl_array_t*)jl_cellref(vinfos,i)))
-            return 1;
-    }
-    return 0;
-}
-
 // get array of body forms
 jl_expr_t *jl_lam_body(jl_expr_t *l)
 {
@@ -766,7 +964,7 @@ jl_sym_t *jl_decl_var(jl_value_t *ex)
     return (jl_sym_t*)jl_exprarg(ex, 0);
 }
 
-int jl_is_rest_arg(jl_value_t *ex)
+JL_DLLEXPORT int jl_is_rest_arg(jl_value_t *ex)
 {
     if (!jl_is_expr(ex)) return 0;
     if (((jl_expr_t*)ex)->head != colons_sym) return 0;
@@ -779,75 +977,7 @@ int jl_is_rest_arg(jl_value_t *ex)
     return ((jl_sym_t*)jl_exprarg(atype,1)) == vararg_sym;
 }
 
-static jl_value_t *copy_ast(jl_value_t *expr, jl_svec_t *sp, int do_sp)
-{
-    if (jl_is_symbol(expr)) {
-        if (!do_sp) return expr;
-        // pre-evaluate certain static parameters to help type inference
-        for(int i=0; i < jl_svec_len(sp); i+=2) {
-            assert(jl_is_typevar(jl_svecref(sp,i)));
-            if ((jl_sym_t*)expr == ((jl_tvar_t*)jl_svecref(sp,i))->name) {
-                jl_value_t *spval = jl_svecref(sp,i+1);
-                if (jl_is_long(spval))
-                    return spval;
-            }
-        }
-    }
-    else if (jl_is_lambda_info(expr)) {
-        jl_lambda_info_t *li = (jl_lambda_info_t*)expr;
-        /*
-        if (sp == jl_empty_svec && li->ast &&
-            jl_array_len(jl_lam_capt((jl_expr_t*)li->ast)) == 0)
-            return expr;
-        */
-        // TODO: avoid if above condition is true and decls have already
-        // been evaluated.
-        JL_GC_PUSH1(&li);
-        li = jl_add_static_parameters(li, sp);
-        // inner lambda does not need the "def" link. it leads to excess object
-        // retention, for example pointing to the original uncompressed AST
-        // of a top-level thunk that gets type inferred.
-        li->def = li;
-        li->ast = jl_prepare_ast(li, li->sparams);
-        jl_gc_wb(li, li->ast);
-        JL_GC_POP();
-        return (jl_value_t*)li;
-    }
-    else if (jl_typeis(expr,jl_array_any_type)) {
-        jl_array_t *a = (jl_array_t*)expr;
-        jl_array_t *na = jl_alloc_cell_1d(jl_array_len(a));
-        JL_GC_PUSH1(&na);
-        size_t i;
-        for(i=0; i < jl_array_len(a); i++)
-            jl_cellset(na, i, copy_ast(jl_cellref(a,i), sp, do_sp));
-        JL_GC_POP();
-        return (jl_value_t*)na;
-    }
-    else if (jl_is_expr(expr)) {
-        jl_expr_t *e = (jl_expr_t*)expr;
-        jl_expr_t *ne = jl_exprn(e->head, jl_array_len(e->args));
-        JL_GC_PUSH1(&ne);
-        if (e->head == lambda_sym) {
-            jl_exprargset(ne, 0, copy_ast(jl_exprarg(e,0), sp, 0));
-            jl_exprargset(ne, 1, copy_ast(jl_exprarg(e,1), sp, 0));
-            jl_exprargset(ne, 2, copy_ast(jl_exprarg(e,2), sp, 1));
-        }
-        else if (e->head == assign_sym) {
-            jl_exprargset(ne, 0, copy_ast(jl_exprarg(e,0), sp, 0));
-            jl_exprargset(ne, 1, copy_ast(jl_exprarg(e,1), sp, 1));
-        }
-        else {
-            for(size_t i=0; i < jl_array_len(e->args); i++) {
-                jl_exprargset(ne, i, copy_ast(jl_exprarg(e,i), sp, 1));
-            }
-        }
-        JL_GC_POP();
-        return (jl_value_t*)ne;
-    }
-    return expr;
-}
-
-DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
+JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
 {
     if (expr == NULL) {
         return NULL;
@@ -881,117 +1011,44 @@ DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr)
         JL_GC_POP();
         return (jl_value_t*)na;
     }
-    else if (jl_is_quotenode(expr)) {
-        jl_value_t *v = jl_fieldref(expr,0);
-        if (jl_is_symbol(v) || jl_is_gensym(v))
-            return expr;
-        jl_value_t *q = NULL;
-        JL_GC_PUSH2(&q, &v);
-        q = jl_copy_ast(v);
-        v = jl_new_struct(jl_quotenode_type, q);
-        JL_GC_POP();
-        return v;
-    }
-    return expr;
-}
-
-static jl_value_t *dont_copy_ast(jl_value_t *expr, jl_svec_t *sp, int do_sp)
-{
-    if (jl_is_symbol(expr) || jl_is_lambda_info(expr)) {
-        return copy_ast(expr, sp, do_sp);
-    }
-    else if (jl_is_expr(expr)) {
-        jl_expr_t *e = (jl_expr_t*)expr;
-        if (e->head == lambda_sym) {
-            jl_exprargset(e, 0, dont_copy_ast(jl_exprarg(e,0), sp, 0));
-            jl_exprargset(e, 1, dont_copy_ast(jl_exprarg(e,1), sp, 0));
-            jl_exprargset(e, 2, dont_copy_ast(jl_exprarg(e,2), sp, 1));
-        }
-        else if (e->head == assign_sym) {
-            jl_exprargset(e, 0, dont_copy_ast(jl_exprarg(e,0), sp, 0));
-            jl_exprargset(e, 1, dont_copy_ast(jl_exprarg(e,1), sp, 1));
-        }
-        else {
-            for(size_t i=0; i < jl_array_len(e->args); i++) {
-                jl_exprargset(e, i, dont_copy_ast(jl_exprarg(e,i), sp, 1));
-            }
-        }
-        return (jl_value_t*)e;
-    }
     return expr;
 }
 
-// TODO: eval decl types for arguments of non-generic functions
-static void eval_decl_types(jl_array_t *vi, jl_value_t *ast, jl_svec_t *spenv)
-{
-    size_t i, l = jl_array_len(vi);
-    for(i=0; i < l; i++) {
-        jl_array_t *v = (jl_array_t*)jl_cellref(vi, i);
-        assert(jl_array_len(v) > 1);
-        jl_value_t *ty = jl_static_eval(jl_cellref(v,1), NULL, jl_current_module,
-                                        (jl_value_t*)spenv, (jl_expr_t*)ast, 1, 1);
-        if (ty != NULL && (jl_is_type(ty) || jl_is_typevar(ty))) {
-            jl_cellset(v, 1, ty);
-        }
-        else {
-            jl_cellset(v, 1, (jl_value_t*)jl_any_type);
-        }
-    }
-}
-
-jl_svec_t *jl_svec_tvars_to_symbols(jl_svec_t *t)
-{
-    jl_svec_t *s = jl_alloc_svec_uninit(jl_svec_len(t));
-    size_t i;
-    for(i=0; i < jl_svec_len(s); i+=2) {
-        assert(jl_is_typevar(jl_svecref(t,i)));
-        jl_svecset(s, i, (jl_value_t*)((jl_tvar_t*)jl_svecref(t,i))->name);
-        jl_svecset(s, i+1, jl_svecref(t,i+1));
-    }
-    return s;
-}
-
 // given a new lambda_info with static parameter values, make a copy
 // of the tree with declared types evaluated and static parameters passed
 // on to all enclosed functions.
 // this tree can then be further mutated by optimization passes.
-DLLEXPORT jl_value_t *jl_prepare_ast(jl_lambda_info_t *li, jl_svec_t *sparams)
+JL_DLLEXPORT jl_value_t *jl_prepare_ast(jl_lambda_info_t *li)
 {
-    jl_svec_t *spenv = NULL;
     jl_value_t *ast = li->ast;
     if (ast == NULL) return NULL;
-    JL_GC_PUSH2(&spenv, &ast);
-    spenv = jl_svec_tvars_to_symbols(sparams);
+    JL_GC_PUSH1(&ast);
     if (!jl_is_expr(ast)) {
         ast = jl_uncompress_ast(li, ast);
-        ast = dont_copy_ast(ast, sparams, 1);
     }
     else {
-        ast = copy_ast(ast, sparams, 1);
-    }
-    jl_module_t *last_m = jl_current_module;
-    JL_TRY {
-        jl_current_module = li->module;
-        eval_decl_types(jl_lam_vinfo((jl_expr_t*)ast), ast, spenv);
-        eval_decl_types(jl_lam_capt((jl_expr_t*)ast), ast, spenv);
+        ast = jl_copy_ast(ast);
     }
-    JL_CATCH {
-        jl_current_module = last_m;
-        jl_rethrow();
-    }
-    jl_current_module = last_m;
     JL_GC_POP();
     return ast;
 }
 
-DLLEXPORT int jl_is_operator(char *sym)
+JL_DLLEXPORT int jl_is_operator(char *sym)
 {
-    return fl_applyn(1, symbol_value(symbol("operator?")), symbol(sym)) == FL_T;
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    fl_context_t *fl_ctx = &ctx->fl;
+    int res = fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "operator?")), symbol(fl_ctx, sym)) == fl_ctx->T;
+    jl_ast_ctx_leave(ctx);
+    return res;
 }
 
-DLLEXPORT int jl_operator_precedence(char *sym)
+JL_DLLEXPORT int jl_operator_precedence(char *sym)
 {
-    return numval(fl_applyn(1, symbol_value(symbol("operator-precedence")), symbol(sym)));
+    jl_ast_context_t *ctx = jl_ast_ctx_enter();
+    fl_context_t *fl_ctx = &ctx->fl;
+    int res = numval(fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "operator-precedence")), symbol(fl_ctx, sym)));
+    jl_ast_ctx_leave(ctx);
+    return res;
 }
 
 jl_value_t *skip_meta(jl_array_t *body)
@@ -1003,7 +1060,22 @@ jl_value_t *skip_meta(jl_array_t *body)
     return body1;
 }
 
-int jl_in_vinfo_array(jl_array_t *a, jl_sym_t *v)
+int has_meta(jl_array_t *body, jl_sym_t *sym)
+{
+    size_t i, l = jl_array_len(body);
+    for (i = 0; i < l; i++) {
+        jl_expr_t *stmt = (jl_expr_t*)jl_cellref(body, i);
+        if (jl_is_expr((jl_value_t*)stmt) && stmt->head == meta_sym) {
+            size_t i, l = jl_array_len(stmt->args);
+            for (i = 0; i < l; i++)
+                if (jl_cellref(stmt->args, i) == (jl_value_t*)sym)
+                    return 1;
+        }
+    }
+    return 0;
+}
+
+static int jl_in_vinfo_array(jl_array_t *a, jl_sym_t *v)
 {
     size_t i, l=jl_array_len(a);
     for(i=0; i<l; i++) {
@@ -1013,41 +1085,40 @@ int jl_in_vinfo_array(jl_array_t *a, jl_sym_t *v)
     return 0;
 }
 
-int jl_in_sym_array(jl_array_t *a, jl_sym_t *v)
+static int jl_in_sym_svec(jl_svec_t *a, jl_sym_t *v)
 {
-    size_t i, l=jl_array_len(a);
+    size_t i, l = jl_svec_len(a);
     for(i=0; i<l; i++) {
-        if (jl_cellref(a,i) == (jl_value_t*)v)
+        if (jl_svecref(a,i) == (jl_value_t*)v)
             return 1;
     }
     return 0;
 }
 
-int jl_local_in_ast(jl_expr_t *ast, jl_sym_t *sym)
+int jl_local_in_linfo(jl_lambda_info_t *linfo, jl_sym_t *sym)
 {
-    return jl_in_vinfo_array(jl_lam_vinfo(ast), sym) ||
-        jl_in_vinfo_array(jl_lam_capt(ast), sym) ||
-        jl_in_sym_array(jl_lam_staticparams(ast), sym);
+    return jl_in_vinfo_array(jl_lam_vinfo((jl_expr_t*)linfo->ast), sym) ||
+        jl_in_sym_svec(linfo->sparam_syms, sym);
 }
 
-JL_CALLABLE(jl_f_get_field);
+extern jl_value_t *jl_builtin_getfield;
 
-static jl_value_t *resolve_globals(jl_value_t *expr, jl_lambda_info_t *lam)
+jl_value_t *jl_preresolve_globals(jl_value_t *expr, jl_lambda_info_t *lam)
 {
     if (jl_is_symbol(expr)) {
         if (lam->module == NULL)
             return expr;
-        if (!jl_local_in_ast((jl_expr_t*)lam->ast, (jl_sym_t*)expr))
+        if (!jl_local_in_linfo(lam, (jl_sym_t*)expr))
             return jl_module_globalref(lam->module, (jl_sym_t*)expr);
     }
     else if (jl_is_lambda_info(expr)) {
         jl_lambda_info_t *l = (jl_lambda_info_t*)expr;
-        (void)resolve_globals(l->ast, l);
+        (void)jl_preresolve_globals(l->ast, l);
     }
     else if (jl_is_expr(expr)) {
         jl_expr_t *e = (jl_expr_t*)expr;
         if (e->head == lambda_sym) {
-            (void)resolve_globals(jl_exprarg(e,2), lam);
+            (void)jl_preresolve_globals(jl_exprarg(e,2), lam);
         }
         else if (jl_is_toplevel_only_expr(expr) || e->head == const_sym || e->head == copyast_sym ||
                  e->head == global_sym || e->head == quote_sym || e->head == inert_sym ||
@@ -1060,14 +1131,12 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_lambda_info_t *lam)
                 jl_value_t *s = jl_fieldref(jl_exprarg(e,2),0);
                 jl_value_t *fe = jl_exprarg(e,0);
                 if (jl_is_symbol(s) && jl_is_topnode(fe)) {
-                    jl_value_t *f = jl_static_eval(fe, NULL, lam->module,
-                                                   NULL, (jl_expr_t*)lam->ast, 0, 0);
-                    if (f && jl_is_func(f) && ((jl_function_t*)f)->fptr == &jl_f_get_field) {
+                    jl_value_t *f = jl_static_eval(fe, NULL, lam->module, lam, 0, 0);
+                    if (f == jl_builtin_getfield) {
                         jl_value_t *me = jl_exprarg(e,1);
                         if (jl_is_topnode(me) ||
                             (jl_is_symbol(me) && jl_binding_resolved_p(lam->module,(jl_sym_t*)me))) {
-                            jl_value_t *m = jl_static_eval(me, NULL, lam->module,
-                                                           NULL, (jl_expr_t*)lam->ast, 0, 0);
+                            jl_value_t *m = jl_static_eval(me, NULL, lam->module, lam, 0, 0);
                             if (m && jl_is_module(m))
                                 return jl_module_globalref((jl_module_t*)m, (jl_sym_t*)s);
                         }
@@ -1076,10 +1145,10 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_lambda_info_t *lam)
             }
             size_t i = 0;
             if (e->head == method_sym || e->head == abstracttype_sym || e->head == compositetype_sym ||
-                e->head == bitstype_sym || e->head == macro_sym || e->head == module_sym)
+                e->head == bitstype_sym || e->head == module_sym)
                 i++;
             for(; i < jl_array_len(e->args); i++) {
-                jl_exprargset(e, i, resolve_globals(jl_exprarg(e,i), lam));
+                jl_exprargset(e, i, jl_preresolve_globals(jl_exprarg(e,i), lam));
             }
         }
     }
diff --git a/src/ast.scm b/src/ast.scm
new file mode 100644
index 0000000000000..88965751c624f
--- /dev/null
+++ b/src/ast.scm
@@ -0,0 +1,253 @@
+;; AST utilities
+
+;; deparser
+
+(define (deparse-arglist l (sep ",")) (string.join (map deparse l) sep))
+
+(define (deparse e)
+  (cond ((or (symbol? e) (number? e)) (string e))
+        ((string? e) (print-to-string e))
+        ((eq? e #t) "true")
+        ((eq? e #f) "false")
+        ((eq? (typeof e) 'julia_value)
+         (let ((s (string e)))
+           (if (string.find s "#<julia: ")
+               ;; successfully printed as a julia value
+               (string.sub s 9 (string.dec s (length s)))
+               s)))
+        ((atom? e) (string e))
+        ((eq? (car e) '|.|)
+         (string (deparse (cadr e)) '|.|
+                 (if (and (pair? (caddr e)) (memq (caaddr e) '(quote inert)))
+                     (deparse (cadr (caddr e)))
+                     (string #\( (deparse (caddr e)) #\)))))
+        ((memq (car e) '(... |'| |.'|))
+         (string (deparse (cadr e)) (car e)))
+        ((syntactic-op? (car e))
+         (string (deparse (cadr e)) (car e) (deparse (caddr e))))
+        ((memq (car e) '($ &))
+         (string (car e) (deparse (cadr e))))
+        ((eq? (car e) '|::|)
+         (if (length> e 2)
+             (string (deparse (cadr e)) (car e) (deparse (caddr e)))
+             (string (car e) (deparse (cadr e)))))
+        (else (case (car e)
+                ((tuple)
+                 (string #\( (deparse-arglist (cdr e))
+                         (if (length= e 2) #\, "")
+                         #\)))
+                ((cell1d) (string #\{ (deparse-arglist (cdr e)) #\}))
+                ((call)   (string (deparse (cadr e)) #\( (deparse-arglist (cddr e)) #\)))
+                ((ref)    (string (deparse (cadr e)) #\[ (deparse-arglist (cddr e)) #\]))
+                ((curly)  (string (deparse (cadr e)) #\{ (deparse-arglist (cddr e)) #\}))
+                ((quote inert)
+                 (if (symbol? (cadr e))
+                     (string ":" (deparse (cadr e)))
+                     (string ":(" (deparse (cadr e)) ")")))
+                ((vcat)   (string #\[ (deparse-arglist (cdr e)) #\]))
+                ((hcat)   (string #\[ (deparse-arglist (cdr e) " ") #\]))
+                ((global local const)
+                 (string (car e) " " (deparse (cadr e))))
+                ((:)
+                 (string (deparse (cadr e)) ': (deparse (caddr e))
+                         (if (length> e 3)
+                             (string ': (deparse (cadddr e)))
+                             "")))
+                ((comparison) (apply string (map deparse (cdr e))))
+                ((in) (string (deparse (cadr e)) " in " (deparse (caddr e))))
+                ((jlgensym) (string "GenSym(" (cdr e) ")"))
+                ((line) (if (length= e 2)
+                            (string "# line " (cadr e))
+                            (string "# " (caddr e) ", line " (cadr e))))
+                ((block)
+                 (string "begin\n"
+                         (string.join (map (lambda (ex) (string "    " (deparse ex)))
+                                           (cdr e))
+                                      "\n")
+                         "\nend"))
+                (else
+                 (string e))))))
+
+;; custom gensyms
+
+(define *gensyms* '())
+(define *current-gensyms* '())
+(define *gensy-counter* 1)
+(define (gensy)
+  (if (null? *current-gensyms*)
+      (let ((g (symbol (string "#s" *gensy-counter*))))
+        (set! *gensy-counter* (+ *gensy-counter* 1))
+        (set! *gensyms* (cons g *gensyms*))
+        g)
+      (begin0 (car *current-gensyms*)
+              (set! *current-gensyms* (cdr *current-gensyms*)))))
+(define (named-gensy name)
+  (let ((g (symbol (string "#" *gensy-counter* "#" name))))
+    (set! *gensy-counter* (+ *gensy-counter* 1))
+    g))
+(define (reset-gensyms)
+  (set! *current-gensyms* *gensyms*))
+
+(define make-jlgensym
+  (let ((jlgensym-counter 0))
+    (lambda ()
+      (begin0 `(jlgensym ,jlgensym-counter)
+              (set! jlgensym-counter (+ 1 jlgensym-counter))))))
+
+;; predicates and accessors
+
+(define (quoted? e) (memq (car e) '(quote top line break inert)))
+
+(define (lam:args x) (cadr x))
+(define (lam:vars x) (llist-vars (lam:args x)))
+(define (lam:vinfo x) (caddr x))
+(define (lam:body x) (cadddr x))
+(define (lam:sp x) (cadddr (lam:vinfo x)))
+
+(define (bad-formal-argument v)
+  (error (string #\" (deparse v) #\" " is not a valid function argument name")))
+
+(define (arg-name v)
+  (cond ((and (symbol? v) (not (eq? v 'true)) (not (eq? v 'false)))
+         v)
+        ((not (pair? v))
+         (bad-formal-argument v))
+        (else
+         (case (car v)
+           ((... kw)      (decl-var (cadr v)))
+           ((|::|)
+            (if (not (symbol? (cadr v)))
+                (bad-formal-argument (cadr v)))
+            (decl-var v))
+           (else (bad-formal-argument v))))))
+
+(define (arg-type v)
+  (cond ((symbol? v)  'Any)
+        ((not (pair? v))
+         (bad-formal-argument v))
+        (else
+         (case (car v)
+           ((...) (if (eq? (length v) 3)
+                      `(... ,(decl-type (cadr v)) ,(caddr v))
+                      `(... ,(decl-type (cadr v)))))
+           ((|::|)
+            (if (not (symbol? (cadr v)))
+                (bad-formal-argument (cadr v)))
+            (decl-type v))
+           (else (bad-formal-argument v))))))
+
+;; convert a lambda list into a list of just symbols
+(define (llist-vars lst)
+  (map arg-name (filter (lambda (a) (not (and (pair? a)
+                                              (eq? (car a) 'parameters))))
+                        lst)))
+
+(define (llist-keywords lst)
+  (apply append
+         (map (lambda (a) (if (and (pair? a) (eq? (car a) 'parameters))
+                              (map arg-name (cdr a))
+                              '()))
+              lst)))
+
+;; get just argument types
+(define (llist-types lst) (map arg-type lst))
+
+(define (decl? e)
+  (and (pair? e) (eq? (car e) '|::|)))
+
+(define (make-decl n t) `(|::| ,n ,t))
+
+(define (jlgensym? e)
+  (and (pair? e) (eq? (car e) 'jlgensym)))
+
+(define (symbol-like? e)
+  (or (symbol? e) (jlgensym? e)))
+
+(define (simple-atom? x)
+  (or (number? x) (string? x) (char? x) (eq? x 'true) (eq? x 'false)))
+
+;; get the variable name part of a declaration, x::int => x
+(define (decl-var v)
+  (if (decl? v) (cadr v) v))
+
+(define (decl-type v)
+  (if (decl? v) (caddr v) 'Any))
+
+(define (sym-dot? e)
+  (and (length= e 3) (eq? (car e) '|.|)
+       (symbol-like? (cadr e))))
+
+(define (undot-name e)
+  (if (and (pair? e) (eq? (car e) '|.|))
+      (cadr (caddr e))
+      e))
+
+(define (dotop? o) (and (symbol? o) (eqv? (string.char (string o) 0) #\.)))
+
+(define (vararg? x) (and (pair? x) (eq? (car x) '...)))
+(define (varargexpr? x) (and
+                         (pair? x)
+                         (eq? (car x) '::)
+                         (or
+                          (eq? (caddr x) 'Vararg)
+                          (and
+                           (pair? (caddr x))
+                           (length> (caddr x) 1)
+                           (eq? (cadr (caddr x)) 'Vararg)))))
+(define (trans?  x) (and (pair? x) (eq? (car x) '|.'|)))
+(define (ctrans? x) (and (pair? x) (eq? (car x) '|'|)))
+
+(define (make-assignment l r) `(= ,l ,r))
+(define (assignment? e) (and (pair? e) (eq? (car e) '=)))
+(define (return? e) (and (pair? e) (eq? (car e) 'return)))
+
+(define (eq-sym? a b)
+  (or (eq? a b) (and (jlgensym? a) (jlgensym? b) (eqv? (cdr a) (cdr b)))))
+
+(define (make-var-info name) (list name 'Any 0))
+(define vinfo:name car)
+(define vinfo:type cadr)
+(define (vinfo:set-type! v t) (set-car! (cdr v) t))
+
+(define (vinfo:capt v) (< 0 (logand (caddr v) 1)))
+(define (vinfo:asgn v) (< 0 (logand (caddr v) 2)))
+(define (vinfo:const v) (< 0 (logand (caddr v) 8)))
+(define (vinfo:sa v) (< 0 (logand (caddr v) 16)))
+(define (set-bit x b val) (if val (logior x b) (logand x (lognot b))))
+;; record whether var is captured
+(define (vinfo:set-capt! v c)  (set-car! (cddr v) (set-bit (caddr v) 1 c)))
+;; whether var is assigned
+(define (vinfo:set-asgn! v a)  (set-car! (cddr v) (set-bit (caddr v) 2 a)))
+;; whether var is const
+(define (vinfo:set-const! v a) (set-car! (cddr v) (set-bit (caddr v) 8 a)))
+;; whether var is assigned once
+(define (vinfo:set-sa! v a)    (set-car! (cddr v) (set-bit (caddr v) 16 a)))
+;; occurs undef: mask 32
+;; whether var is called (occurs in function call head position)
+(define (vinfo:set-called! v a)  (set-car! (cddr v) (set-bit (caddr v) 64 a)))
+
+(define var-info-for assq)
+
+(define (assignment? e)
+  (and (pair? e) (eq? (car e) '=)))
+
+(define (assignment-like? e)
+  (and (pair? e) (is-prec-assignment? (car e))))
+
+(define (kwarg? e)
+  (and (pair? e) (eq? (car e) 'kw)))
+
+;; flatten nested expressions with the given head
+;; (op (op a b) c) => (op a b c)
+(define (flatten-ex head e)
+  (if (atom? e)
+      e
+      (cons (car e)
+            (apply append!
+                   (map (lambda (x)
+                          (if (and (pair? x) (eq? (car x) head))
+                              (cdr (flatten-ex head x))
+                              (list x)))
+                        (cdr e))))))
+
+(define (flatten-blocks e) (flatten-ex 'block e))
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index e4bb2187ff9c9..695916e7fdc15 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -9,33 +9,27 @@ extern "C" {
 
 // declarations for julia-callable builtin functions
 
-JL_CALLABLE(jl_f_throw);
-JL_CALLABLE(jl_f_is);
-JL_CALLABLE(jl_f_typeof);
-JL_CALLABLE(jl_f_sizeof);
-JL_CALLABLE(jl_f_subtype);
-JL_CALLABLE(jl_f_isa);
-JL_CALLABLE(jl_f_typeassert);
-JL_CALLABLE(jl_f_apply);
-JL_CALLABLE(jl_f_kwcall);
-JL_CALLABLE(jl_f_top_eval);
-JL_CALLABLE(jl_f_isdefined);
-JL_CALLABLE(jl_f_tuple);
-JL_CALLABLE(jl_f_svec);
-JL_CALLABLE(jl_f_get_field);
-JL_CALLABLE(jl_f_set_field);
-JL_CALLABLE(jl_f_field_type);
-JL_CALLABLE(jl_f_arraylen);
-JL_CALLABLE(jl_f_arrayref);
-JL_CALLABLE(jl_f_arrayset);
-JL_CALLABLE(jl_f_arraysize);
-JL_CALLABLE(jl_f_instantiate_type);
-JL_CALLABLE(jl_f_typevar);
-JL_CALLABLE(jl_f_methodexists);
-JL_CALLABLE(jl_f_applicable);
-JL_CALLABLE(jl_f_invoke);
-JL_CALLABLE(jl_f_new_expr);
-JL_CALLABLE(jl_f_nfields);
+#ifdef DEFINE_BUILTIN_GLOBALS
+#define DECLARE_BUILTIN(name) \
+    JL_CALLABLE(jl_f_##name); \
+    jl_value_t *jl_builtin_##name
+#else
+#define DECLARE_BUILTIN(name) \
+    JL_CALLABLE(jl_f_##name); \
+    extern jl_value_t *jl_builtin_##name
+#endif
+
+DECLARE_BUILTIN(throw);      DECLARE_BUILTIN(is);
+DECLARE_BUILTIN(typeof);     DECLARE_BUILTIN(sizeof);
+DECLARE_BUILTIN(issubtype);  DECLARE_BUILTIN(isa);
+DECLARE_BUILTIN(typeassert); DECLARE_BUILTIN(_apply);
+DECLARE_BUILTIN(isdefined);  DECLARE_BUILTIN(nfields);
+DECLARE_BUILTIN(tuple);      DECLARE_BUILTIN(svec);
+DECLARE_BUILTIN(getfield);   DECLARE_BUILTIN(setfield);
+DECLARE_BUILTIN(fieldtype);  DECLARE_BUILTIN(arrayref);
+DECLARE_BUILTIN(arrayset);   DECLARE_BUILTIN(arraysize);
+DECLARE_BUILTIN(apply_type); DECLARE_BUILTIN(applicable);
+DECLARE_BUILTIN(invoke);     DECLARE_BUILTIN(_expr);
 
 #ifdef __cplusplus
 }
diff --git a/src/builtins.c b/src/builtins.c
index 56b0cef763a49..b41f00da61f39 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -31,7 +31,7 @@ extern "C" {
 
 // exceptions -----------------------------------------------------------------
 
-DLLEXPORT void NORETURN jl_error(const char *str)
+JL_DLLEXPORT void JL_NORETURN jl_error(const char *str)
 {
     if (jl_errorexception_type == NULL) {
         jl_printf(JL_STDERR, "ERROR: %s\n", str);
@@ -44,7 +44,8 @@ DLLEXPORT void NORETURN jl_error(const char *str)
 
 extern int vasprintf(char **str, const char *fmt, va_list ap);
 
-static void NORETURN jl_vexceptionf(jl_datatype_t *exception_type, const char *fmt, va_list args)
+static void JL_NORETURN jl_vexceptionf(jl_datatype_t *exception_type,
+                                       const char *fmt, va_list args)
 {
     if (exception_type == NULL) {
         jl_printf(JL_STDERR, "ERROR: ");
@@ -66,7 +67,7 @@ static void NORETURN jl_vexceptionf(jl_datatype_t *exception_type, const char *f
     jl_throw(jl_new_struct(exception_type, msg));
 }
 
-DLLEXPORT void NORETURN jl_errorf(const char *fmt, ...)
+JL_DLLEXPORT void JL_NORETURN jl_errorf(const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
@@ -74,7 +75,8 @@ DLLEXPORT void NORETURN jl_errorf(const char *fmt, ...)
     va_end(args);
 }
 
-DLLEXPORT void NORETURN jl_exceptionf(jl_datatype_t *exception_type, const char *fmt, ...)
+JL_DLLEXPORT void JL_NORETURN jl_exceptionf(jl_datatype_t *exception_type,
+                                            const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
@@ -82,18 +84,18 @@ DLLEXPORT void NORETURN jl_exceptionf(jl_datatype_t *exception_type, const char
     va_end(args);
 }
 
-void NORETURN jl_too_few_args(const char *fname, int min)
+JL_DLLEXPORT void JL_NORETURN jl_too_few_args(const char *fname, int min)
 {
     jl_exceptionf(jl_argumenterror_type, "%s: too few arguments (expected %d)", fname, min);
 }
 
-void NORETURN jl_too_many_args(const char *fname, int max)
+JL_DLLEXPORT void JL_NORETURN jl_too_many_args(const char *fname, int max)
 {
     jl_exceptionf(jl_argumenterror_type, "%s: too many arguments (expected %d)", fname, max);
 }
 
-void NORETURN jl_type_error_rt(const char *fname, const char *context,
-                               jl_value_t *ty, jl_value_t *got)
+JL_DLLEXPORT void JL_NORETURN jl_type_error_rt(const char *fname, const char *context,
+                                               jl_value_t *ty, jl_value_t *got)
 {
     jl_value_t *ctxt=NULL;
     JL_GC_PUSH2(&ctxt, &got);
@@ -103,35 +105,30 @@ void NORETURN jl_type_error_rt(const char *fname, const char *context,
     jl_throw(ex);
 }
 
-void NORETURN jl_type_error_rt_line(const char *fname, const char *context,
-                                    jl_value_t *ty, jl_value_t *got, int line)
-{
-    jl_type_error_rt(fname, context, ty, got);
-}
-
-void NORETURN jl_type_error(const char *fname, jl_value_t *expected, jl_value_t *got)
+JL_DLLEXPORT void JL_NORETURN jl_type_error(const char *fname, jl_value_t *expected,
+                                            jl_value_t *got)
 {
     jl_type_error_rt(fname, "", expected, got);
 }
 
-DLLEXPORT void NORETURN jl_undefined_var_error(jl_sym_t *var)
+JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var)
 {
-    if (var->name[0] == '#') {
+    if (jl_symbol_name(var)[0] == '#') {
         // convention for renamed variables: #...#original_name
-        char *nxt = strchr(var->name+1, '#');
+        char *nxt = strchr(jl_symbol_name(var) + 1, '#');
         if (nxt)
             var = jl_symbol(nxt+1);
     }
     jl_throw(jl_new_struct(jl_undefvarerror_type, var));
 }
 
-DLLEXPORT void NORETURN jl_bounds_error(jl_value_t *v, jl_value_t *t)
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error(jl_value_t *v, jl_value_t *t)
 {
     JL_GC_PUSH2(&v, &t); // root arguments so the caller doesn't need to
     jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
-DLLEXPORT void NORETURN jl_bounds_error_v(jl_value_t *v, jl_value_t **idxs, size_t nidxs)
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_v(jl_value_t *v, jl_value_t **idxs, size_t nidxs)
 {
     jl_value_t *t = NULL;
     // items in idxs are assumed to already be rooted
@@ -140,13 +137,13 @@ DLLEXPORT void NORETURN jl_bounds_error_v(jl_value_t *v, jl_value_t **idxs, size
     jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
-DLLEXPORT void NORETURN jl_bounds_error_tuple_int(jl_value_t **v, size_t nv, size_t i)
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_tuple_int(jl_value_t **v, size_t nv, size_t i)
 {
     // values in v are expected to already be gc-rooted
     jl_bounds_error_int(jl_f_tuple(NULL, v, nv), i);
 }
 
-DLLEXPORT void NORETURN jl_bounds_error_unboxed_int(void *data, jl_value_t *vt, size_t i)
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_unboxed_int(void *data, jl_value_t *vt, size_t i)
 {
     jl_value_t *t = NULL, *v = NULL;
     // data is expected to be gc-safe (either gc-rooted, or alloca)
@@ -157,7 +154,7 @@ DLLEXPORT void NORETURN jl_bounds_error_unboxed_int(void *data, jl_value_t *vt,
     jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
-DLLEXPORT void NORETURN jl_bounds_error_int(jl_value_t *v, size_t i)
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_int(jl_value_t *v, size_t i)
 {
     jl_value_t *t = NULL;
     JL_GC_PUSH2(&v, &t); // root arguments so the caller doesn't need to
@@ -165,7 +162,7 @@ DLLEXPORT void NORETURN jl_bounds_error_int(jl_value_t *v, size_t i)
     jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
-DLLEXPORT void NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs, size_t nidxs)
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs, size_t nidxs)
 {
     size_t i;
     jl_value_t *t = NULL;
@@ -178,6 +175,22 @@ DLLEXPORT void NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs, size_t
     jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
+JL_DLLEXPORT void JL_NORETURN jl_eof_error(void)
+{
+    jl_datatype_t *eof_error =
+        (jl_datatype_t*)jl_get_global(jl_base_module, jl_symbol("EOFError"));
+    assert(eof_error != NULL);
+    jl_exceptionf(eof_error, "");
+}
+
+JL_DLLEXPORT jl_value_t *jl_get_keyword_sorter(jl_value_t *f)
+{
+    jl_methtable_t *mt = jl_gf_mtable(f);
+    if (mt->kwsorter == NULL)
+        jl_errorf("function %s does not accept keyword arguments", jl_symbol_name(mt->name));
+    return mt->kwsorter;
+}
+
 JL_CALLABLE(jl_f_throw)
 {
     JL_NARGS(throw, 1, 1);
@@ -185,18 +198,22 @@ JL_CALLABLE(jl_f_throw)
     return jl_nothing;
 }
 
-void jl_enter_handler(jl_handler_t *eh)
+JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh)
 {
     JL_SIGATOMIC_BEGIN();
     eh->prev = jl_current_task->eh;
     eh->gcstack = jl_pgcstack;
+#ifdef JULIA_ENABLE_THREADING
+    eh->gc_state = jl_gc_state();
+    eh->locks_len = jl_current_task->locks.len;
+#endif
     jl_current_task->eh = eh;
     // TODO: this should really go after setjmp(). see comment in
     // ctx_switch in task.c.
     JL_SIGATOMIC_END();
 }
 
-void jl_pop_handler(int n)
+JL_DLLEXPORT void jl_pop_handler(int n)
 {
     while (n > 0) {
         jl_eh_restore_state(jl_current_task->eh);
@@ -237,7 +254,7 @@ static int bits_equal(void *a, void *b, int sz)
 // The solution is to keep the code in jl_egal simple and split out the
 // (more) complex cases into their own functions which are marked with
 // NOINLINE.
-static int NOINLINE compare_svec(jl_value_t *a, jl_value_t *b)
+static int NOINLINE compare_svec(jl_svec_t *a, jl_svec_t *b)
 {
     size_t l = jl_svec_len(a);
     if (l != jl_svec_len(b))
@@ -254,11 +271,11 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b, jl_datatype_t *
 {
     size_t nf = jl_datatype_nfields(dt);
     for (size_t f=0; f < nf; f++) {
-        size_t offs = dt->fields[f].offset;
+        size_t offs = jl_field_offset(dt, f);
         char *ao = (char*)jl_data_ptr(a) + offs;
         char *bo = (char*)jl_data_ptr(b) + offs;
         int eq;
-        if (dt->fields[f].isptr) {
+        if (jl_field_isptr(dt, f)) {
             jl_value_t *af = *(jl_value_t**)ao;
             jl_value_t *bf = *(jl_value_t**)bo;
             if (af == bf) eq = 1;
@@ -268,7 +285,7 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b, jl_datatype_t *
         else {
             jl_datatype_t *ft = (jl_datatype_t*)jl_field_type(dt, f);
             if (!ft->haspadding) {
-                eq = bits_equal(ao, bo, dt->fields[f].size);
+                eq = bits_equal(ao, bo, jl_field_size(dt, f));
             }
             else {
                 assert(jl_datatype_nfields(ft) > 0);
@@ -280,21 +297,21 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b, jl_datatype_t *
     return 1;
 }
 
-int jl_egal(jl_value_t *a, jl_value_t *b) // warning: a,b may NOT have been gc-rooted by the caller
+JL_DLLEXPORT int jl_egal(jl_value_t *a, jl_value_t *b)
 {
+    // warning: a,b may NOT have been gc-rooted by the caller
     if (a == b)
         return 1;
     jl_value_t *ta = (jl_value_t*)jl_typeof(a);
     if (ta != (jl_value_t*)jl_typeof(b))
         return 0;
     if (jl_is_svec(a))
-        return compare_svec(a, b);
+        return compare_svec((jl_svec_t*)a, (jl_svec_t*)b);
     jl_datatype_t *dt = (jl_datatype_t*)ta;
     if (dt == jl_datatype_type) {
         jl_datatype_t *dta = (jl_datatype_t*)a;
         jl_datatype_t *dtb = (jl_datatype_t*)b;
-        return dta->name == dtb->name &&
-            jl_egal((jl_value_t*)dta->parameters, (jl_value_t*)dtb->parameters);
+        return dta->name == dtb->name && compare_svec(dta->parameters, dtb->parameters);
     }
     if (dt->mutabl) return 0;
     size_t sz = dt->size;
@@ -313,12 +330,6 @@ JL_CALLABLE(jl_f_is)
     return jl_egal(args[0],args[1]) ? jl_true : jl_false;
 }
 
-JL_CALLABLE(jl_f_no_function)
-{
-    jl_error("invalid function object");
-    return jl_nothing;
-}
-
 JL_CALLABLE(jl_f_typeof)
 {
     JL_NARGS(typeof, 1, 1);
@@ -353,7 +364,7 @@ JL_CALLABLE(jl_f_sizeof)
     return jl_box_long(jl_datatype_size(dt));
 }
 
-JL_CALLABLE(jl_f_subtype)
+JL_CALLABLE(jl_f_issubtype)
 {
     JL_NARGS(subtype, 2, 2);
     if (!jl_is_typevar(args[0]))
@@ -370,7 +381,7 @@ JL_CALLABLE(jl_f_isa)
     return (jl_subtype(args[0],args[1],1) ? jl_true : jl_false);
 }
 
-DLLEXPORT void jl_typeassert(jl_value_t *x, jl_value_t *t)
+JL_DLLEXPORT void jl_typeassert(jl_value_t *x, jl_value_t *t)
 {
     if (!jl_subtype(x,t,1))
         jl_type_error("typeassert", t, x);
@@ -387,23 +398,12 @@ JL_CALLABLE(jl_f_typeassert)
 
 static jl_function_t *jl_append_any_func;
 
-JL_CALLABLE(jl_f_apply)
+JL_CALLABLE(jl_f__apply)
 {
-    JL_NARGSV(apply, 2);
-    jl_function_t *f;
-    jl_function_t *call_func = (jl_function_t*)args[0];
-    assert(jl_is_function(call_func));
-    if (jl_is_function(args[1])) {
-        f = (jl_function_t*)args[1];
-        --nargs; ++args; /* args[1] becomes args[0] */
-    }
-    else { /* do generic call(args...) instead */
-        f = call_func;
-        // protect "function" arg from splicing
-        args[1] = (jl_value_t*)jl_svec1(args[1]);
-    }
+    JL_NARGSV(apply, 1);
+    jl_function_t *f = args[0];
     if (nargs == 2) {
-        if (f->fptr == &jl_f_svec) {
+        if (f == jl_builtin_svec) {
             if (jl_is_svec(args[1]))
                 return args[1];
             if (jl_is_array(args[1])) {
@@ -417,9 +417,6 @@ JL_CALLABLE(jl_f_apply)
                 return (jl_value_t*)t;
             }
         }
-        if (jl_is_svec(args[1])) {
-            return jl_apply(f, jl_svec_data(args[1]), jl_svec_len(args[1]));
-        }
     }
     size_t n=0, i, j;
     for(i=1; i < nargs; i++) {
@@ -429,7 +426,7 @@ JL_CALLABLE(jl_f_apply)
         else if (jl_is_tuple(args[i])) {
             n += jl_nfields(args[i]);
         }
-        else if (jl_is_array(args[i]) && ((jl_array_t*)args[i])->ptrarray) {
+        else if (jl_is_array(args[i])) {
             n += jl_array_len(args[i]);
         }
         else {
@@ -441,105 +438,89 @@ JL_CALLABLE(jl_f_apply)
                     JL_TYPECHK(apply, tuple, jl_typeof(args[i]));
                 }
             }
-            jl_value_t *argarr = jl_apply(jl_append_any_func, &args[1], nargs-1);
+            jl_array_t *argarr = NULL;
+            JL_GC_PUSH2(&argarr, &f);
+            args[0] = jl_append_any_func;
+            argarr = (jl_array_t*)jl_apply(args, nargs);
             assert(jl_typeis(argarr, jl_array_any_type));
-            JL_GC_PUSH1(&argarr);
-            jl_value_t *result = jl_apply(f, jl_cell_data(argarr), jl_array_len(argarr));
+            jl_array_grow_beg(argarr, 1);
+            jl_cellset(argarr, 0, f);
+            args[0] = f;
+            jl_value_t *result = jl_apply(jl_cell_data(argarr), jl_array_len(argarr));
             JL_GC_POP();
             return result;
         }
     }
     jl_value_t **newargs;
+    n++;
     int onstack = (n < jl_page_size/sizeof(jl_value_t*));
     JL_GC_PUSHARGS(newargs, onstack ? n : 1);
+    jl_svec_t *arg_heap = NULL;
     if (!onstack) {
         // put arguments on the heap if there are too many
-        jl_value_t *argarr = (jl_value_t*)jl_alloc_cell_1d(n);
-        newargs[0] = argarr;
-        newargs = jl_cell_data(argarr);
-    }
-    n = 0;
+        arg_heap = jl_alloc_svec(n);
+        newargs[0] = (jl_value_t*)arg_heap;
+        newargs = jl_svec_data(arg_heap);
+    }
+    // GC Note: here we assume that the the return value of `jl_svecref`,
+    //          `jl_cellref` will not be young if `arg_heap` becomes old
+    //          since they are allocated before `arg_heap`. Otherwise,
+    //          we need to add write barrier for !onstack
+    newargs[0] = f;
+    n = 1;
     for(i=1; i < nargs; i++) {
-        if (jl_is_svec(args[i])) {
-            jl_svec_t *t = (jl_svec_t*)args[i];
+        jl_value_t *ai = args[i];
+        if (jl_is_svec(ai)) {
+            jl_svec_t *t = (jl_svec_t*)ai;
             size_t al = jl_svec_len(t);
             for(j=0; j < al; j++)
                 newargs[n++] = jl_svecref(t, j);
         }
-        else if (jl_is_tuple(args[i])) {
-            size_t al = jl_nfields(args[i]);
-            for(j=0; j < al; j++)
-                newargs[n++] = jl_fieldref(args[i], j);
+        else if (jl_is_tuple(ai)) {
+            size_t al = jl_nfields(ai);
+            for(j=0; j < al; j++) {
+                // jl_fieldref may allocate.
+                newargs[n++] = jl_fieldref(ai, j);
+                if (arg_heap)
+                    jl_gc_wb(arg_heap, newargs[n - 1]);
+            }
         }
         else {
-            size_t al = jl_array_len(args[i]);
-            for (j = 0;j < al;j++) {
-                jl_value_t *arg = jl_cellref(args[i], j);
-                // apply with array splatting may have embedded NULL value
-                // #11772
-                if (__unlikely(arg == NULL)) {
-                    jl_throw(jl_undefref_exception);
+            assert(jl_is_array(ai));
+            jl_array_t *aai = (jl_array_t*)ai;
+            size_t al = jl_array_len(aai);
+            if (aai->flags.ptrarray) {
+                for (j = 0; j < al; j++) {
+                    jl_value_t *arg = jl_cellref(aai, j);
+                    // apply with array splatting may have embedded NULL value
+                    // #11772
+                    if (__unlikely(arg == NULL))
+                        jl_throw(jl_undefref_exception);
+                    newargs[n++] = arg;
+                }
+            }
+            else {
+                for (j = 0; j < al; j++) {
+                    newargs[n++] = jl_arrayref(aai, j);
+                    if (arg_heap)
+                        jl_gc_wb(arg_heap, newargs[n - 1]);
                 }
-                newargs[n++] = arg;
             }
         }
     }
-    jl_value_t *result = jl_apply(f, newargs, n);
+    jl_value_t *result = jl_apply(newargs, n);
     JL_GC_POP();
     return result;
 }
 
-JL_CALLABLE(jl_f_kwcall)
-{
-    if (nargs < 4)
-        jl_error("internal error: malformed keyword argument call");
-    jl_function_t *f;
-    jl_function_t *call_func = (jl_function_t*)args[0];
-    assert(jl_is_function(call_func));
-    size_t nkeys = jl_unbox_long(args[1]);
-    size_t pa = 4 + 2*nkeys;
-    jl_array_t *container = (jl_array_t*)args[pa-1];
-    assert(jl_array_len(container) > 0);
-    f = (jl_function_t*)args[pa-2];
-    if (!jl_is_function(f)) {
-        // do generic call(args...; kws...) instead
-        // switch (f container pa...) to (container f pa...)
-        args[pa-2] = args[pa-1];     // TODO: this might not be safe
-        args[pa-1] = (jl_value_t*)f;
-        f = call_func;
-        pa--;
-    }
-
-    if (!jl_is_gf(f))
-        jl_exceptionf(jl_argumenterror_type, "function does not accept keyword arguments");
-    jl_function_t *sorter = ((jl_methtable_t*)f->env)->kwsorter;
-    if (sorter == NULL) {
-        jl_exceptionf(jl_argumenterror_type, "function %s does not accept keyword arguments",
-                      jl_gf_name(f)->name);
-    }
-
-    for(size_t i=0; i < nkeys*2; i+=2) {
-        jl_cellset(container, i  , args[2+i]);
-        jl_cellset(container, i+1, args[2+i+1]);
-    }
-
-    args += pa-1;
-    nargs -= pa-1;
-    assert(jl_is_gf(sorter));
-    jl_function_t *m = jl_method_lookup((jl_methtable_t*)sorter->env, args, nargs, 1);
-    if (m == jl_bottom_func) {
-        jl_no_method_error(f, args+1, nargs-1);
-        // unreachable
-    }
-
-    return jl_apply(m, args, nargs);
-}
-
 // eval -----------------------------------------------------------------------
 
-extern int jl_lineno;
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex)
+{
+    return jl_toplevel_eval_in_warn(m, ex, 0);
+}
 
-DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int delay_warn)
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in_warn(jl_module_t *m, jl_value_t *ex, int delay_warn)
 {
     static int jl_warn_on_eval = 0;
     int last_delay_warn = jl_warn_on_eval;
@@ -553,12 +534,13 @@ DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int de
     jl_module_t *task_last_m = jl_current_task->current_module;
     if (!delay_warn && jl_options.incremental && jl_generating_output()) {
         if (m != last_m) {
-            jl_printf(JL_STDERR, "WARNING: eval from module %s to %s:    \n", m->name->name, last_m->name->name);
+            jl_printf(JL_STDERR, "WARNING: eval from module %s to %s:    \n",
+                      jl_symbol_name(m->name), jl_symbol_name(last_m->name));
             jl_static_show(JL_STDERR, ex);
             jl_printf(JL_STDERR, "\n  ** incremental compilation may be broken for this module **\n\n");
         }
         else if (jl_warn_on_eval) {
-            jl_printf(JL_STDERR, "WARNING: eval from staged function in module %s:    \n", m->name->name);
+            jl_printf(JL_STDERR, "WARNING: eval from staged function in module %s:    \n", jl_symbol_name(m->name));
             jl_static_show(JL_STDERR, ex);
             jl_printf(JL_STDERR, "\n  ** incremental compilation may be broken for these modules **\n\n");
         }
@@ -583,23 +565,6 @@ DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int de
     return v;
 }
 
-JL_CALLABLE(jl_f_top_eval)
-{
-    jl_module_t *m;
-    jl_value_t *ex;
-    if (nargs == 1) {
-        m = jl_main_module;
-        ex = args[0];
-    }
-    else {
-        JL_NARGS(eval, 2, 2);
-        JL_TYPECHK(eval, module, args[0]);
-        m = (jl_module_t*)args[0];
-        ex = args[1];
-    }
-    return jl_toplevel_eval_in(m, ex, 0);
-}
-
 JL_CALLABLE(jl_f_isdefined)
 {
     jl_module_t *m = jl_current_module;
@@ -681,7 +646,7 @@ JL_CALLABLE(jl_f_svec)
 
 // composite types ------------------------------------------------------------
 
-JL_CALLABLE(jl_f_get_field)
+JL_CALLABLE(jl_f_getfield)
 {
     JL_NARGS(getfield, 2, 2);
     jl_value_t *v = args[0];
@@ -710,7 +675,7 @@ JL_CALLABLE(jl_f_get_field)
     return fval;
 }
 
-JL_CALLABLE(jl_f_set_field)
+JL_CALLABLE(jl_f_setfield)
 {
     JL_NARGS(setfield!, 3, 3);
     jl_value_t *v = args[0];
@@ -721,7 +686,7 @@ JL_CALLABLE(jl_f_set_field)
         jl_type_error("setfield!", (jl_value_t*)jl_datatype_type, v);
     jl_datatype_t *st = (jl_datatype_t*)vt;
     if (!st->mutabl)
-        jl_errorf("type %s is immutable", st->name->name->name);
+        jl_errorf("type %s is immutable", jl_symbol_name(st->name->name));
     size_t idx;
     if (jl_is_long(args[1])) {
         idx = jl_unbox_long(args[1])-1;
@@ -740,7 +705,7 @@ JL_CALLABLE(jl_f_set_field)
     return args[2];
 }
 
-JL_CALLABLE(jl_f_field_type)
+JL_CALLABLE(jl_f_fieldtype)
 {
     JL_NARGS(fieldtype, 2, 2);
     jl_datatype_t *st = (jl_datatype_t*)args[0];
@@ -772,17 +737,17 @@ JL_CALLABLE(jl_f_nfields)
 
 // conversion -----------------------------------------------------------------
 
-DLLEXPORT void *jl_symbol_name(jl_sym_t *s)
+JL_DLLEXPORT void *(jl_symbol_name)(jl_sym_t *s)
 {
-    return s->name;
+    return jl_symbol_name(s);
 }
 
 //WARNING: THIS FUNCTION IS NEVER CALLED BUT INLINE BY CCALL
-DLLEXPORT void *jl_array_ptr(jl_array_t *a)
+JL_DLLEXPORT void *jl_array_ptr(jl_array_t *a)
 {
     return a->data;
 }
-DLLEXPORT jl_value_t *jl_value_ptr(jl_value_t *a)
+JL_DLLEXPORT jl_value_t *jl_value_ptr(jl_value_t *a)
 {
     return a;
 }
@@ -811,7 +776,7 @@ int str_isspace(char *p)
     return 1;
 }
 
-DLLEXPORT jl_nullable_float64_t jl_try_substrtod(char *str, size_t offset, size_t len)
+JL_DLLEXPORT jl_nullable_float64_t jl_try_substrtod(char *str, size_t offset, size_t len)
 {
     char *p;
     char *bstr = str+offset;
@@ -827,7 +792,7 @@ DLLEXPORT jl_nullable_float64_t jl_try_substrtod(char *str, size_t offset, size_
         bstr = newstr;
         pend = bstr+len;
     }
-    double out = strtod_c(bstr, &p);
+    double out = jl_strtod_c(bstr, &p);
 
     if (errno==ERANGE && (out==0 || out==HUGE_VAL || out==-HUGE_VAL)) {
         err = 1;
@@ -848,7 +813,7 @@ DLLEXPORT jl_nullable_float64_t jl_try_substrtod(char *str, size_t offset, size_
     return ret;
 }
 
-DLLEXPORT int jl_substrtod(char *str, size_t offset, size_t len, double *out)
+JL_DLLEXPORT int jl_substrtod(char *str, size_t offset, size_t len, double *out)
 {
     jl_nullable_float64_t nd = jl_try_substrtod(str, offset, len);
     if (0 == nd.isnull) {
@@ -863,7 +828,7 @@ DLLEXPORT int jl_substrtod(char *str, size_t offset, size_t len, double *out)
 #define HUGE_VALF (1e25f * 1e25f)
 #endif
 
-DLLEXPORT jl_nullable_float32_t jl_try_substrtof(char *str, size_t offset, size_t len)
+JL_DLLEXPORT jl_nullable_float32_t jl_try_substrtof(char *str, size_t offset, size_t len)
 {
     char *p;
     char *bstr = str+offset;
@@ -880,9 +845,9 @@ DLLEXPORT jl_nullable_float32_t jl_try_substrtof(char *str, size_t offset, size_
         pend = bstr+len;
     }
 #if defined(_OS_WINDOWS_) && !defined(_COMPILER_MINGW_)
-    float out = (float)strtod_c(bstr, &p);
+    float out = (float)jl_strtod_c(bstr, &p);
 #else
-    float out = strtof_c(bstr, &p);
+    float out = jl_strtof_c(bstr, &p);
 #endif
 
     if (errno==ERANGE && (out==0 || out==HUGE_VALF || out==-HUGE_VALF)) {
@@ -904,7 +869,7 @@ DLLEXPORT jl_nullable_float32_t jl_try_substrtof(char *str, size_t offset, size_
     return ret;
 }
 
-DLLEXPORT int jl_substrtof(char *str, int offset, size_t len, float *out)
+JL_DLLEXPORT int jl_substrtof(char *str, int offset, size_t len, float *out)
 {
     jl_nullable_float32_t nf = jl_try_substrtof(str, offset, len);
     if (0 == nf.isnull) {
@@ -916,13 +881,13 @@ DLLEXPORT int jl_substrtof(char *str, int offset, size_t len, float *out)
 
 // showing --------------------------------------------------------------------
 
-void jl_flush_cstdio(void)
+JL_DLLEXPORT void jl_flush_cstdio(void)
 {
     fflush(stdout);
     fflush(stderr);
 }
 
-jl_value_t *jl_stdout_obj(void)
+JL_DLLEXPORT jl_value_t *jl_stdout_obj(void)
 {
     if (jl_base_module == NULL) return NULL;
     jl_value_t *stdout_obj = jl_get_global(jl_base_module, jl_symbol("STDOUT"));
@@ -930,7 +895,7 @@ jl_value_t *jl_stdout_obj(void)
     return jl_get_global(jl_base_module, jl_symbol("OUTPUT_STREAM"));
 }
 
-jl_value_t *jl_stderr_obj(void)
+JL_DLLEXPORT jl_value_t *jl_stderr_obj(void)
 {
     if (jl_base_module == NULL) return NULL;
     jl_value_t *stderr_obj = jl_get_global(jl_base_module, jl_symbol("STDERR"));
@@ -940,7 +905,7 @@ jl_value_t *jl_stderr_obj(void)
 
 static jl_function_t *jl_show_gf=NULL;
 
-void jl_show(jl_value_t *stream, jl_value_t *v)
+JL_DLLEXPORT void jl_show(jl_value_t *stream, jl_value_t *v)
 {
     if (jl_base_module) {
         if (jl_show_gf == NULL) {
@@ -948,95 +913,26 @@ void jl_show(jl_value_t *stream, jl_value_t *v)
         }
         if (jl_show_gf==NULL || stream==NULL) {
             jl_printf(JL_STDERR, " could not show value of type %s",
-                      ((jl_datatype_t*)jl_typeof(v))->name->name->name);
+                      jl_symbol_name(((jl_datatype_t*)jl_typeof(v))->name->name));
             return;
         }
-        jl_value_t *args[2] = {stream,v};
-        jl_apply(jl_show_gf, args, 2);
+        jl_value_t *args[3] = {jl_show_gf,stream,v};
+        jl_apply(args, 3);
     }
 }
 
 // internal functions ---------------------------------------------------------
 
-extern int jl_in_inference;
-extern int jl_boot_file_loaded;
-int jl_eval_with_compiler_p(jl_expr_t *ast, jl_expr_t *expr, int compileloops, jl_module_t *m);
-
-static int jl_eval_inner_with_compiler(jl_expr_t *e, jl_module_t *m)
+JL_CALLABLE(jl_f_apply_type)
 {
-    int i;
-    for(i=0; i < jl_array_len(e->args); i++) {
-        jl_value_t *ei = jl_exprarg(e,i);
-        if (jl_is_lambda_info(ei)) {
-            jl_lambda_info_t *li = (jl_lambda_info_t*)ei;
-            if (!jl_is_expr(li->ast)) {
-                li->ast = jl_uncompress_ast(li, li->ast);
-                jl_gc_wb(li, li->ast);
-            }
-            jl_expr_t *a = (jl_expr_t*)li->ast;
-            if (jl_lam_capt(a)->length > 0 && jl_eval_with_compiler_p(a, jl_lam_body(a), 1, m))
-                return 1;
-        }
-        if (jl_is_expr(ei) && jl_eval_inner_with_compiler((jl_expr_t*)ei, m))
-            return 1;
-    }
-    return 0;
-}
-
-void jl_trampoline_compile_function(jl_function_t *f, int always_infer, jl_tupletype_t *sig)
-{
-    assert(sig);
-    assert(f->linfo != NULL);
-    // to run inference on all thunks. slows down loading files.
-    // NOTE: if this call to inference is removed, type_annotate in inference.jl
-    // needs to be updated to infer inner functions.
-    if (f->linfo->inferred == 0) {
-        if (!jl_in_inference) {
-            if (!jl_is_expr(f->linfo->ast)) {
-                f->linfo->ast = jl_uncompress_ast(f->linfo, f->linfo->ast);
-                jl_gc_wb(f->linfo, f->linfo->ast);
-            }
-            assert(jl_is_expr(f->linfo->ast));
-            if (always_infer ||
-                jl_eval_with_compiler_p((jl_expr_t*)f->linfo->ast, jl_lam_body((jl_expr_t*)f->linfo->ast), 1, f->linfo->module) ||
-                // if this function doesn't need to be compiled, but contains inner
-                // functions that do and that capture variables, we need to run
-                // inference on the whole thing to propagate types into the inner
-                // functions. caused issue #12794
-                jl_eval_inner_with_compiler(jl_lam_body((jl_expr_t*)f->linfo->ast), f->linfo->module)) {
-                jl_type_infer(f->linfo, sig, f->linfo);
-            }
-        }
-    }
-    jl_compile(f);
-    // this assertion is probably not correct; the fptr could have been assigned
-    // by a recursive invocation from inference above.
-    //assert(f->fptr == &jl_trampoline);
-    jl_generate_fptr(f);
-    if (jl_boot_file_loaded && jl_is_expr(f->linfo->ast)) {
-        f->linfo->ast = jl_compress_ast(f->linfo, f->linfo->ast);
-        jl_gc_wb(f->linfo, f->linfo->ast);
-    }
-}
-
-JL_CALLABLE(jl_trampoline)
-{
-    assert(jl_is_func(F));
-    jl_function_t *f = (jl_function_t*)F;
-    jl_trampoline_compile_function(f, 0, f->linfo->specTypes ? f->linfo->specTypes : jl_anytuple_type);
-    return jl_apply(f, args, nargs);
-}
-
-JL_CALLABLE(jl_f_instantiate_type)
-{
-    JL_NARGSV(instantiate_type, 1);
+    JL_NARGSV(apply_type, 1);
     if (!jl_is_datatype(args[0]) && !jl_is_typector(args[0])) {
         jl_type_error("Type{...} expression", (jl_value_t*)jl_type_type, args[0]);
     }
     return jl_apply_type_(args[0], &args[1], nargs-1);
 }
 
-DLLEXPORT jl_value_t *jl_new_type_constructor(jl_svec_t *p, jl_value_t *t)
+JL_DLLEXPORT jl_value_t *jl_new_type_constructor(jl_svec_t *p, jl_value_t *t)
 {
     jl_value_t *tc = (jl_value_t*)jl_new_type_ctor(p, t);
     int i;
@@ -1050,49 +946,19 @@ DLLEXPORT jl_value_t *jl_new_type_constructor(jl_svec_t *p, jl_value_t *t)
 static void jl_check_type_tuple(jl_value_t *t, jl_sym_t *name, const char *ctx)
 {
     if (!jl_is_tuple_type(t))
-        jl_type_error_rt(name->name, ctx, (jl_value_t*)jl_type_type, t);
-}
-
-JL_CALLABLE(jl_f_methodexists)
-{
-    JL_NARGS(method_exists, 2, 2);
-    JL_TYPECHK(method_exists, function, args[0]);
-    if (!jl_is_gf(args[0]))
-        jl_error("method_exists: not a generic function");
-    jl_value_t *argtypes = args[1];
-    JL_GC_PUSH1(&argtypes);
-    if (jl_is_tuple(args[1])) {
-        // TODO: maybe deprecation warning, better checking
-        argtypes = (jl_value_t*)jl_apply_tuple_type_v((jl_value_t**)jl_data_ptr(argtypes),
-                                                      jl_nfields(argtypes));
-    }
-    else {
-        jl_check_type_tuple(args[1], jl_gf_name(args[0]), "method_exists");
-    }
-    jl_value_t *res = jl_method_lookup_by_type(jl_gf_mtable(args[0]),
-                                               (jl_tupletype_t*)argtypes,0,0)!=jl_bottom_func ?
-        jl_true : jl_false;
-    JL_GC_POP();
-    return res;
+        jl_type_error_rt(jl_symbol_name(name), ctx, (jl_value_t*)jl_type_type, t);
 }
 
 JL_CALLABLE(jl_f_applicable)
 {
     JL_NARGSV(applicable, 1);
-    JL_TYPECHK(applicable, function, args[0]);
-    if (!jl_is_gf(args[0]))
-        jl_error("applicable: not a generic function");
-    return jl_method_lookup(jl_gf_mtable(args[0]),
-                            &args[1], nargs-1, 1) != jl_bottom_func ?
+    return jl_method_lookup(jl_gf_mtable(args[0]), args, nargs, 1) != NULL ?
         jl_true : jl_false;
 }
 
 JL_CALLABLE(jl_f_invoke)
 {
     JL_NARGSV(invoke, 2);
-    JL_TYPECHK(invoke, function, args[0]);
-    if (!jl_is_gf(args[0]))
-        jl_error("invoke: not a generic function");
     jl_value_t *argtypes = args[1];
     JL_GC_PUSH1(&argtypes);
     if (jl_is_tuple(args[1])) {
@@ -1105,8 +971,8 @@ JL_CALLABLE(jl_f_invoke)
     }
     if (!jl_tuple_subtype(&args[2], nargs-2, (jl_datatype_t*)argtypes, 1))
         jl_error("invoke: argument type error");
-    jl_value_t *res = jl_gf_invoke((jl_function_t*)args[0],
-                                   (jl_tupletype_t*)argtypes, &args[2], nargs-2);
+    args[1] = args[0];  // move function directly in front of arguments
+    jl_value_t *res = jl_gf_invoke((jl_tupletype_t*)argtypes, &args[1], nargs-1);
     JL_GC_POP();
     return res;
 }
@@ -1125,7 +991,7 @@ JL_CALLABLE(jl_f_invoke)
 #define hash64(a)   int64to32hash(a)
 #endif
 
-static uptrint_t bits_hash(void *b, size_t sz)
+static uintptr_t bits_hash(void *b, size_t sz)
 {
     switch (sz) {
     case 1:  return int32hash(*(int8_t*)b);
@@ -1141,64 +1007,68 @@ static uptrint_t bits_hash(void *b, size_t sz)
     }
 }
 
-static uptrint_t jl_object_id_(jl_value_t *tv, jl_value_t *v)
+static uintptr_t NOINLINE hash_svec(jl_svec_t *v)
+{
+    uintptr_t h = 0;
+    size_t l = jl_svec_len(v);
+    for(size_t i = 0; i < l; i++) {
+        jl_value_t *x = jl_svecref(v,i);
+        uintptr_t u = x==NULL ? 0 : jl_object_id(x);
+        h = bitmix(h, u);
+    }
+    return h;
+}
+
+static uintptr_t jl_object_id_(jl_value_t *tv, jl_value_t *v)
 {
     if (tv == (jl_value_t*)jl_sym_type)
         return ((jl_sym_t*)v)->hash;
-    if (tv == (jl_value_t*)jl_simplevector_type) {
-        uptrint_t h = 0;
-        size_t l = jl_svec_len(v);
-        for(size_t i = 0; i < l; i++) {
-            uptrint_t u = jl_object_id(jl_svecref(v,i));
-            h = bitmix(h, u);
-        }
-        return h;
-    }
+    if (tv == (jl_value_t*)jl_simplevector_type)
+        return hash_svec((jl_svec_t*)v);
     jl_datatype_t *dt = (jl_datatype_t*)tv;
     if (dt == jl_datatype_type) {
         jl_datatype_t *dtv = (jl_datatype_t*)v;
-        uptrint_t h = 0xda1ada1a;
+        uintptr_t h = 0xda1ada1a;
         // has_typevars always returns 0 on name->primary, so that type
         // can exist in the cache. however, interpreter.c mutates its
         // typevars' `bound` fields to 0, corrupting the cache. this is
         // avoided simply by hashing name->primary specially here.
         if (jl_egal(dtv->name->primary, v))
             return bitmix(bitmix(h, dtv->name->uid), 0xaa5566aa);
-        return bitmix(bitmix(h, dtv->name->uid),
-                      jl_object_id((jl_value_t*)dtv->parameters));
+        return bitmix(bitmix(h, dtv->name->uid), hash_svec(dtv->parameters));
     }
     if (dt == jl_typename_type)
         return bitmix(((jl_typename_t*)v)->uid, 0xa1ada1ad);
-    if (dt->mutabl) return inthash((uptrint_t)v);
+    if (dt->mutabl) return inthash((uintptr_t)v);
     size_t sz = jl_datatype_size(tv);
-    uptrint_t h = jl_object_id(tv);
+    uintptr_t h = jl_object_id(tv);
     if (sz == 0) return ~h;
     size_t nf = jl_datatype_nfields(dt);
     if (nf == 0) {
         return bits_hash(jl_data_ptr(v), sz) ^ h;
     }
     for (size_t f=0; f < nf; f++) {
-        size_t offs = dt->fields[f].offset;
+        size_t offs = jl_field_offset(dt, f);
         char *vo = (char*)jl_data_ptr(v) + offs;
-        uptrint_t u;
-        if (dt->fields[f].isptr) {
+        uintptr_t u;
+        if (jl_field_isptr(dt, f)) {
             jl_value_t *f = *(jl_value_t**)vo;
             u = f==NULL ? 0 : jl_object_id(f);
         }
         else {
-            jl_datatype_t *fieldtype = (jl_datatype_t*)jl_svecref(dt->types, f);
+            jl_datatype_t *fieldtype = (jl_datatype_t*)jl_field_type(dt, f);
             assert(jl_is_datatype(fieldtype) && !fieldtype->abstract && !fieldtype->mutabl);
             if (fieldtype->haspadding)
                 u = jl_object_id_((jl_value_t*)fieldtype, (jl_value_t*)vo);
             else
-                u = bits_hash(vo, dt->fields[f].size);
+                u = bits_hash(vo, jl_field_size(dt, f));
         }
         h = bitmix(h, u);
     }
     return h;
 }
 
-DLLEXPORT uptrint_t jl_object_id(jl_value_t *v)
+JL_DLLEXPORT uintptr_t jl_object_id(jl_value_t *v)
 {
     return jl_object_id_(jl_typeof(v), v);
 }
@@ -1210,10 +1080,28 @@ static void add_builtin(const char *name, jl_value_t *v)
     jl_set_const(jl_core_module, jl_symbol(name), v);
 }
 
-static void add_builtin_func(const char *name, jl_fptr_t f)
+jl_value_t *jl_mk_builtin_func(const char *name, jl_fptr_t fptr)
 {
-    add_builtin(name, (jl_value_t*)
-                jl_new_closure(f, (jl_value_t*)jl_symbol(name), NULL));
+    jl_sym_t *sname = jl_symbol(name);
+    jl_value_t *f = jl_new_generic_function_with_supertype(sname, jl_core_module, jl_builtin_type, 0);
+    jl_lambda_info_t *li = jl_new_lambda_info(jl_nothing, jl_emptysvec, jl_emptysvec, jl_core_module);
+    li->fptr = fptr;
+    li->name = sname;
+    // TODO jb/functions: what should li->ast be?
+    li->ast = (jl_value_t*)jl_exprn(lambda_sym,0); jl_gc_wb(li, li->ast);
+    jl_method_cache_insert(jl_gf_mtable(f), jl_anytuple_type, li);
+    return f;
+}
+
+jl_fptr_t jl_get_builtin_fptr(jl_value_t *b)
+{
+    assert(jl_subtype(b, (jl_value_t*)jl_builtin_type, 1));
+    return jl_gf_mtable(b)->cache->func->fptr;
+}
+
+static void add_builtin_func(const char *name, jl_fptr_t fptr)
+{
+    add_builtin(name, jl_mk_builtin_func(name, fptr));
 }
 
 void jl_init_primitives(void)
@@ -1221,33 +1109,33 @@ void jl_init_primitives(void)
     add_builtin_func("is", jl_f_is);
     add_builtin_func("typeof", jl_f_typeof);
     add_builtin_func("sizeof", jl_f_sizeof);
-    add_builtin_func("issubtype", jl_f_subtype);
+    add_builtin_func("issubtype", jl_f_issubtype);
     add_builtin_func("isa", jl_f_isa);
     add_builtin_func("typeassert", jl_f_typeassert);
-    add_builtin_func("_apply", jl_f_apply);
-    add_builtin_func("kwcall", jl_f_kwcall);
     add_builtin_func("throw", jl_f_throw);
     add_builtin_func("tuple", jl_f_tuple);
-    add_builtin_func("svec", jl_f_svec);
-    add_builtin_func("method_exists", jl_f_methodexists);
-    add_builtin_func("applicable", jl_f_applicable);
-    add_builtin_func("invoke", jl_f_invoke);
-    add_builtin_func("eval", jl_f_top_eval);
-    add_builtin_func("isdefined", jl_f_isdefined);
 
-    // functions for internal use
-    add_builtin_func("getfield",  jl_f_get_field);
-    add_builtin_func("setfield!",  jl_f_set_field);
-    add_builtin_func("fieldtype", jl_f_field_type);
+    // field access
+    add_builtin_func("getfield",  jl_f_getfield);
+    add_builtin_func("setfield!",  jl_f_setfield);
+    add_builtin_func("fieldtype", jl_f_fieldtype);
     add_builtin_func("nfields", jl_f_nfields);
-    add_builtin_func("_expr", jl_f_new_expr);
+    add_builtin_func("isdefined", jl_f_isdefined);
 
-    add_builtin_func("arraylen", jl_f_arraylen);
+    // array primitives
     add_builtin_func("arrayref", jl_f_arrayref);
     add_builtin_func("arrayset", jl_f_arrayset);
     add_builtin_func("arraysize", jl_f_arraysize);
 
-    add_builtin_func("apply_type", jl_f_instantiate_type);
+    // method table utils
+    add_builtin_func("applicable", jl_f_applicable);
+    add_builtin_func("invoke", jl_f_invoke);
+
+    // internal functions
+    add_builtin_func("apply_type", jl_f_apply_type);
+    add_builtin_func("_apply", jl_f__apply);
+    add_builtin_func("_expr", jl_f__expr);
+    add_builtin_func("svec", jl_f_svec);
 
     // builtin types
     add_builtin("Any", (jl_value_t*)jl_any_type);
@@ -1271,10 +1159,10 @@ void jl_init_primitives(void)
     add_builtin("GenSym", (jl_value_t*)jl_gensym_type);
     add_builtin("IntrinsicFunction", (jl_value_t*)jl_intrinsic_type);
     add_builtin("Function", (jl_value_t*)jl_function_type);
-    add_builtin("LambdaStaticData", (jl_value_t*)jl_lambda_info_type);
+    add_builtin("Builtin", (jl_value_t*)jl_builtin_type);
+    add_builtin("LambdaInfo", (jl_value_t*)jl_lambda_info_type);
     add_builtin("Ref", (jl_value_t*)jl_ref_type);
     add_builtin("Ptr", (jl_value_t*)jl_pointer_type);
-    add_builtin("Box", (jl_value_t*)jl_box_type);
     add_builtin("Task", (jl_value_t*)jl_task_type);
 
     add_builtin("AbstractArray", (jl_value_t*)jl_abstractarray_type);
@@ -1297,6 +1185,7 @@ void jl_init_primitives(void)
 #endif
 
     add_builtin("ANY", jl_ANY_flag);
+    add_builtin("Carnavalue", jl_carnavalue);
 }
 
 // toys for debugging ---------------------------------------------------------
@@ -1318,51 +1207,55 @@ static size_t jl_show_svec(JL_STREAM *out, jl_svec_t *t, char *head, char *opn,
 
 #define MAX_DEPTH 25
 
-size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth)
+static size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth);
+
+// `v` might be pointing to a field inlined in a structure therefore
+// `jl_typeof(v)` may not be the same with `vt` and only `vt` should be
+// used to determine the type of the value.
+// This is necessary to make sure that this function doesn't allocate any
+// memory through the Julia GC
+static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v,
+                                jl_datatype_t *vt, int depth)
 {
-    // mimic jl_show, but never calling a julia method
-    size_t n = 0;
     if (depth > MAX_DEPTH) { // cheap way of bailing out of cycles
         return jl_printf(out, "•");
     }
+    size_t n = 0;
     depth++;
-    if (v == NULL) {
-        n += jl_printf(out, "#<null>");
+    if ((uintptr_t)vt < 4096U) {
+        n += jl_printf(out, "<?#%p::%p>", v, vt);
     }
     else if ((uintptr_t)v < 4096U) {
-        n += jl_printf(out, "#<%d>", (int)(uintptr_t)v);
-    }
-    else if (jl_typeof(v) == NULL) {
-        n += jl_printf(out, "<?::#null>");
-    }
-    else if (jl_astaggedvalue(v)->type_bits < 4096U) {
-        n += jl_printf(out, "<?::#%d>", (int)jl_astaggedvalue(v)->type_bits);
+        n += jl_printf(out, "<?#%p::", v);
+        n += jl_static_show_x(out, (jl_value_t*)vt, depth);
+        n += jl_printf(out, ">");
     }
-    else if (jl_is_lambda_info(v)) {
+    else if (vt == jl_lambda_info_type) {
         jl_lambda_info_t *li = (jl_lambda_info_t*)v;
         n += jl_static_show_x(out, (jl_value_t*)li->module, depth);
         if (li->specTypes) {
             n += jl_printf(out, ".");
-            n += jl_show_svec(out, li->specTypes->parameters, li->name->name, "(", ")");
+            n += jl_show_svec(out, li->specTypes->parameters,
+                              jl_symbol_name(li->name), "(", ")");
         }
         else {
-            n += jl_printf(out, ".%s(?)", li->name->name);
+            n += jl_printf(out, ".%s(?)", jl_symbol_name(li->name));
         }
         // The following is nice for debugging, but allocates memory and generates a lot of output
         // so it may not be a good idea to to have it active
         //jl_printf(out, " -> ");
         //jl_static_show(out, !jl_is_expr(li->ast) ? jl_uncompress_ast(li, li->ast) : li->ast);
     }
-    else if (jl_is_svec(v)) {
+    else if (vt == jl_simplevector_type) {
         n += jl_show_svec(out, (jl_svec_t*)v, "svec", "(", ")");
     }
-    else if (jl_is_datatype(v)) {
+    else if (vt == jl_datatype_type) {
         jl_datatype_t *dv = (jl_datatype_t*)v;
         if (dv->name->module != jl_core_module) {
             n += jl_static_show_x(out, (jl_value_t*)dv->name->module, depth);
-            jl_printf(out, "."); n += 1;
+            n += jl_printf(out, ".");
         }
-        n += jl_printf(out, "%s", dv->name->name->name);
+        n += jl_printf(out, "%s", jl_symbol_name(dv->name->name));
         if (dv->parameters && (jl_value_t*)dv != dv->name->primary &&
             !jl_types_equal((jl_value_t*)dv, (jl_value_t*)jl_tuple_type)) {
             size_t j, tlen = jl_nparams(dv);
@@ -1376,135 +1269,130 @@ size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth)
                 }
                 n += jl_printf(out, "}");
             }
-            else if (jl_is_tuple_type(dv)) {
+            else if (dv->name == jl_tuple_typename) {
                 n += jl_printf(out, "{}");
             }
         }
     }
-    else if (jl_is_func(v)) {
-        if (jl_is_gf(v)) {
-            n += jl_printf(out, "%s", jl_gf_name(v)->name);
-        }
-        else {
-            n += jl_printf(out, "#<function>");
-        }
-    }
-    else if (jl_typeis(v, jl_intrinsic_type)) {
-        n += jl_printf(out, "#<intrinsic function %d>", *(uint32_t*)jl_data_ptr(v));
+    else if (vt == jl_intrinsic_type) {
+        int f = *(uint32_t*)jl_data_ptr(v);
+        n += jl_printf(out, "#<intrinsic #%d %s>", f, jl_intrinsic_name(f));
     }
-    else if (jl_is_int64(v)) {
-        n += jl_printf(out, "%" PRId64, jl_unbox_int64(v));
+    else if (vt == jl_int64_type) {
+        n += jl_printf(out, "%" PRId64, *(int64_t*)v);
     }
-    else if (jl_is_int32(v)) {
-        n += jl_printf(out, "%" PRId32, jl_unbox_int32(v));
+    else if (vt == jl_int32_type) {
+        n += jl_printf(out, "%" PRId32, *(int32_t*)v);
     }
-    else if (jl_typeis(v,jl_int16_type)) {
-        n += jl_printf(out, "%" PRId16, jl_unbox_int16(v));
+    else if (vt == jl_int16_type) {
+        n += jl_printf(out, "%" PRId16, *(int16_t*)v);
     }
-    else if (jl_typeis(v,jl_int8_type)) {
-        n += jl_printf(out, "%" PRId8, jl_unbox_int8(v));
+    else if (vt == jl_int8_type) {
+        n += jl_printf(out, "%" PRId8, *(int8_t*)v);
     }
-    else if (jl_is_uint64(v)) {
-        n += jl_printf(out, "0x%016" PRIx64, jl_unbox_uint64(v));
+    else if (vt == jl_uint64_type) {
+        n += jl_printf(out, "0x%016" PRIx64, *(uint64_t*)v);
     }
-    else if (jl_is_uint32(v)) {
-        n += jl_printf(out, "0x%08" PRIx32, jl_unbox_uint32(v));
+    else if (vt == jl_uint32_type) {
+        n += jl_printf(out, "0x%08" PRIx32, *(uint32_t*)v);
     }
-    else if (jl_typeis(v,jl_uint16_type)) {
-        n += jl_printf(out, "0x%04" PRIx16, jl_unbox_uint16(v));
+    else if (vt == jl_uint16_type) {
+        n += jl_printf(out, "0x%04" PRIx16, *(uint16_t*)v);
     }
-    else if (jl_typeis(v,jl_uint8_type)) {
-        n += jl_printf(out, "0x%02" PRIx8, jl_unbox_uint8(v));
+    else if (vt == jl_uint8_type) {
+        n += jl_printf(out, "0x%02" PRIx8, *(uint8_t*)v);
     }
-    else if (jl_is_cpointer(v)) {
+    else if (jl_is_cpointer_type((jl_value_t*)vt)) {
 #ifdef _P64
-        n += jl_printf(out, "0x%016" PRIx64,
-                       (int64_t)jl_unbox_voidpointer(v));
+        n += jl_printf(out, "0x%016" PRIx64, *(uint64_t*)v);
 #else
-        n += jl_printf(out, "0x%08" PRIx32, (int32_t)jl_unbox_voidpointer(v));
+        n += jl_printf(out, "0x%08" PRIx32, *(uint32_t*)v);
 #endif
     }
-    else if (jl_is_float32(v)) {
-        n += jl_printf(out, "%g", jl_unbox_float32(v));
+    else if (vt == jl_float32_type) {
+        n += jl_printf(out, "%g", *(float*)v);
     }
-    else if (jl_is_float64(v)) {
-        n += jl_printf(out, "%g", jl_unbox_float64(v));
+    else if (vt == jl_float64_type) {
+        n += jl_printf(out, "%g", *(double*)v);
     }
-    else if (v == jl_true) {
-        n += jl_printf(out, "true");
+    else if (vt == jl_bool_type) {
+        n += jl_printf(out, "%s", *(uint8_t*)v ? "true" : "false");
     }
-    else if (v == jl_false) {
-        n += jl_printf(out, "false");
-    }
-    else if (v == jl_nothing) {
+    else if ((jl_value_t*)vt == jl_typeof(jl_nothing)) {
         n += jl_printf(out, "nothing");
     }
-    else if (jl_is_byte_string(v)) {
+    else if (vt == jl_ascii_string_type || vt == jl_utf8_string_type) {
         n += jl_printf(out, "\"%s\"", jl_iostr_data(v));
     }
-    else if (jl_is_uniontype(v)) {
+    else if (vt == jl_uniontype_type) {
         n += jl_show_svec(out, ((jl_uniontype_t*)v)->types, "Union", "{", "}");
     }
-    else if (jl_is_typector(v)) {
+    else if (vt == jl_typector_type) {
         n += jl_static_show_x(out, ((jl_typector_t*)v)->body, depth);
     }
-    else if (jl_is_typevar(v)) {
+    else if (vt == jl_tvar_type) {
         if (((jl_tvar_t*)v)->lb != jl_bottom_type) {
             n += jl_static_show(out, ((jl_tvar_t*)v)->lb);
             n += jl_printf(out, "<:");
         }
-        n += jl_printf(out, "%s%s<:", (((jl_tvar_t*)v)->bound)?"#":"", ((jl_tvar_t*)v)->name->name);
+        n += jl_printf(out, "%s%s<:", (((jl_tvar_t*)v)->bound)?"#":"",
+                       jl_symbol_name(((jl_tvar_t*)v)->name));
         n += jl_static_show(out, ((jl_tvar_t*)v)->ub);
     }
-    else if (jl_is_module(v)) {
+    else if (vt == jl_module_type) {
         jl_module_t *m = (jl_module_t*)v;
         if (m->parent != m && m->parent != jl_main_module) {
             n += jl_static_show_x(out, (jl_value_t*)m->parent, depth);
             n += jl_printf(out, ".");
         }
-        n += jl_printf(out, "%s", m->name->name);
+        n += jl_printf(out, "%s", jl_symbol_name(m->name));
     }
-    else if (jl_is_symbol(v)) {
-        n += jl_printf(out, ":%s", ((jl_sym_t*)v)->name);
+    else if (vt == jl_sym_type) {
+        n += jl_printf(out, ":%s", jl_symbol_name((jl_sym_t*)v));
     }
-    else if (jl_is_gensym(v)) {
+    else if (vt == jl_gensym_type) {
         n += jl_printf(out, "GenSym(%" PRIuPTR ")",
                        (uintptr_t)((jl_gensym_t*)v)->id);
     }
-    else if (jl_is_symbolnode(v)) {
-        n += jl_printf(out, "%s::", jl_symbolnode_sym(v)->name);
+    else if (vt == jl_symbolnode_type) {
+        n += jl_printf(out, "%s::", jl_symbol_name(jl_symbolnode_sym(v)));
         n += jl_static_show_x(out, jl_symbolnode_type(v), depth);
     }
-    else if (jl_is_globalref(v)) {
+    else if (vt == jl_globalref_type) {
         n += jl_static_show_x(out, (jl_value_t*)jl_globalref_mod(v), depth);
-        n += jl_printf(out, ".%s", jl_globalref_name(v)->name);
+        n += jl_printf(out, ".%s", jl_symbol_name(jl_globalref_name(v)));
     }
-    else if (jl_is_labelnode(v)) {
+    else if (vt == jl_labelnode_type) {
         n += jl_printf(out, "%" PRIuPTR ":", jl_labelnode_label(v));
     }
-    else if (jl_is_gotonode(v)) {
+    else if (vt == jl_gotonode_type) {
         n += jl_printf(out, "goto %" PRIuPTR, jl_gotonode_label(v));
     }
-    else if (jl_is_quotenode(v)) {
-        jl_value_t *qv = jl_fieldref(v,0);
-        if (!jl_is_symbol(qv)) { n += jl_printf(out, "quote "); }
-        n += jl_static_show_x(out, jl_fieldref(v,0), depth);
-        if (!jl_is_symbol(qv)) { n += jl_printf(out, " end"); }
+    else if (vt == jl_quotenode_type) {
+        jl_value_t *qv = *(jl_value_t**)v;
+        if (!jl_is_symbol(qv)) {
+            n += jl_printf(out, "quote ");
+        }
+        n += jl_static_show_x(out, qv, depth);
+        if (!jl_is_symbol(qv)) {
+            n += jl_printf(out, " end");
+        }
     }
-    else if (jl_is_newvarnode(v)) {
+    else if (vt == jl_newvarnode_type) {
         n += jl_printf(out, "<newvar ");
-        n += jl_static_show_x(out, jl_fieldref(v,0), depth);
+        n += jl_static_show_x(out, *(jl_value_t**)v, depth);
         n += jl_printf(out, ">");
     }
-    else if (jl_is_topnode(v)) {
+    else if (vt == jl_topnode_type) {
         n += jl_printf(out, "top(");
-        n += jl_static_show_x(out, jl_fieldref(v,0), depth);
+        n += jl_static_show_x(out, *(jl_value_t**)v, depth);
         n += jl_printf(out, ")");
     }
-    else if (jl_is_linenode(v)) {
-        n += jl_printf(out, "# line %"PRIuPTR" %s", jl_linenode_line(v), jl_linenode_file(v)->name);
+    else if (vt == jl_linenumbernode_type) {
+        n += jl_printf(out, "# line %" PRIuPTR " %s",
+                       jl_linenode_line(v), jl_symbol_name(jl_linenode_file(v)));
     }
-    else if (jl_is_expr(v)) {
+    else if (vt == jl_expr_type) {
         jl_expr_t *e = (jl_expr_t*)v;
         if (e->head == assign_sym && jl_array_len(e->args) == 2) {
             n += jl_static_show_x(out, jl_exprarg(e,0), depth);
@@ -1515,7 +1403,7 @@ size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth)
             char sep = ' ';
             if (e->head == body_sym)
                 sep = '\n';
-            n += jl_printf(out, "Expr(:%s", e->head->name);
+            n += jl_printf(out, "Expr(:%s", jl_symbol_name(e->head));
             size_t i, len = jl_array_len(e->args);
             for (i = 0; i < len; i++) {
                 n += jl_printf(out, ",%c", sep);
@@ -1525,45 +1413,47 @@ size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth)
             n += jl_static_show_x(out, e->etype, depth);
         }
     }
-    else if (jl_is_array(v)) {
-        n += jl_static_show_x(out, jl_typeof(v), depth);
+    else if (jl_is_array_type(vt)) {
+        n += jl_static_show_x(out, (jl_value_t*)vt, depth);
         n += jl_printf(out, "[");
         size_t j, tlen = jl_array_len(v);
+        jl_array_t *av = (jl_array_t*)v;
+        jl_datatype_t *el_type = (jl_datatype_t*)jl_tparam0(vt);
         for (j = 0; j < tlen; j++) {
-            jl_value_t *elt;
-            if (((jl_array_t*)v)->ptrarray)
-                elt = jl_cellref(v, j);
-            else
-                elt = jl_arrayref((jl_array_t*)v,j);
-            n += jl_static_show_x(out, elt, depth);
+            if (av->flags.ptrarray) {
+                n += jl_static_show_x(out, jl_cellref(v, j), depth);
+            }
+            else {
+                char *ptr = ((char*)av->data) + j * av->elsize;
+                n += jl_static_show_x_(out, (jl_value_t*)ptr, el_type, depth);
+            }
             if (j != tlen-1)
                 n += jl_printf(out, ", ");
         }
         if (j < tlen) n += jl_printf(out, " ...");
         n += jl_printf(out, "]");
     }
-    else if (jl_typeis(v,jl_loaderror_type)) {
+    else if (vt == jl_loaderror_type) {
         n += jl_printf(out, "LoadError(at ");
-        n += jl_static_show_x(out, jl_fieldref(v, 0), depth);
-        n += jl_printf(out, " line ");
-        n += jl_static_show_x(out, jl_fieldref(v, 1), depth);
+        n += jl_static_show_x(out, *(jl_value_t**)v, depth);
+        // Access the field directly to avoid allocation
+        n += jl_printf(out, " line %" PRIdPTR, ((intptr_t*)v)[1]);
         n += jl_printf(out, ": ");
-        n += jl_static_show_x(out, jl_fieldref(v, 2), depth);
+        n += jl_static_show_x(out, ((jl_value_t**)v)[2], depth);
         n += jl_printf(out, ")");
     }
-    else if (jl_typeis(v,jl_errorexception_type)) {
+    else if (vt == jl_errorexception_type) {
         n += jl_printf(out, "ErrorException(");
-        n += jl_static_show_x(out, jl_fieldref(v, 0), depth);
+        n += jl_static_show_x(out, *(jl_value_t**)v, depth);
         n += jl_printf(out, ")");
     }
-    else if (jl_is_datatype(jl_typeof(v))) {
-        jl_datatype_t *t = (jl_datatype_t*)jl_typeof(v);
-        int istuple = jl_is_tuple_type(t);
+    else if (jl_is_datatype(vt)) {
+        int istuple = jl_is_tuple_type(vt);
         if (!istuple)
-            n += jl_static_show_x(out, (jl_value_t*)t, depth);
+            n += jl_static_show_x(out, (jl_value_t*)vt, depth);
         n += jl_printf(out, "(");
-        size_t nb = jl_datatype_size(t);
-        size_t tlen = jl_datatype_nfields(t);
+        size_t nb = jl_datatype_size(vt);
+        size_t tlen = jl_datatype_nfields(vt);
         if (nb > 0 && tlen == 0) {
             char *data = (char*)jl_data_ptr(v);
             n += jl_printf(out, "0x");
@@ -1571,47 +1461,74 @@ size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth)
                 n += jl_printf(out, "%02" PRIx8, data[i]);
         }
         else {
-            jl_value_t *fldval=NULL;
-            JL_GC_PUSH1(&fldval);
             for (size_t i = 0; i < tlen; i++) {
                 if (!istuple) {
-                    n += jl_printf(out, "%s", ((jl_sym_t*)jl_svecref(t->name->names, i))->name);
+                    n += jl_printf(out, "%s", jl_symbol_name((jl_sym_t*)jl_svecref(vt->name->names, i)));
                     //jl_fielddesc_t f = t->fields[i];
                     n += jl_printf(out, "=");
                 }
-                fldval = jl_get_nth_field(v, i);
-                n += jl_static_show_x(out, fldval, depth);
+                size_t offs = jl_field_offset(vt, i);
+                char *fld_ptr = (char*)v + offs;
+                if (jl_field_isptr(vt, i)) {
+                    n += jl_static_show_x(out, *(jl_value_t**)fld_ptr, depth);
+                }
+                else {
+                    n += jl_static_show_x_(out, (jl_value_t*)fld_ptr,
+                                           (jl_datatype_t*)jl_field_type(vt, i),
+                                           depth);
+                }
                 if (istuple && tlen==1)
                     n += jl_printf(out, ",");
                 else if (i != tlen-1)
                     n += jl_printf(out, ", ");
             }
-            JL_GC_POP();
         }
         n += jl_printf(out, ")");
     }
     else {
-        n += jl_printf(out, "<?::");
-        n += jl_static_show_x(out, jl_typeof(v), depth);
+        n += jl_printf(out, "<?#%p::", v);
+        n += jl_static_show_x(out, (jl_value_t*)vt, depth);
         n += jl_printf(out, ">");
     }
     return n;
 }
 
-DLLEXPORT size_t jl_static_show(JL_STREAM *out, jl_value_t *v)
+static size_t jl_static_show_x(JL_STREAM *out, jl_value_t *v, int depth)
+{
+    // mimic jl_show, but never calling a julia method and
+    // (hopefully) never allocate through julia gc
+    if (v == NULL) {
+        return jl_printf(out, "#<null>");
+    }
+    else if ((uintptr_t)v < 4096U) {
+        return jl_printf(out, "#<%d>", (int)(uintptr_t)v);
+    }
+    return jl_static_show_x_(out, v, (jl_datatype_t*)jl_typeof(v), depth);
+}
+
+JL_DLLEXPORT size_t jl_static_show(JL_STREAM *out, jl_value_t *v)
 {
     return jl_static_show_x(out, v, 0);
 }
 
-DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type)
+JL_DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type)
 {
-    if (!jl_is_tuple_type(type))
+    jl_value_t *ftype = jl_first_argument_datatype(type);
+    if (ftype == NULL)
         return jl_static_show(s, type);
     size_t n = 0;
+    if (jl_nparams(ftype)==0 || ftype == ((jl_datatype_t*)ftype)->name->primary) {
+        n += jl_printf(s, "%s", jl_symbol_name(((jl_datatype_t*)ftype)->name->mt->name));
+    }
+    else {
+        n += jl_printf(s, "(::");
+        n += jl_static_show(s, ftype);
+        n += jl_printf(s, ")");
+    }
     size_t tl = jl_nparams(type);
     n += jl_printf(s, "(");
     size_t i;
-    for (i = 0;i < tl;i++) {
+    for (i = 1; i < tl; i++) {
         jl_value_t *tp = jl_tparam(type, i);
         if (i != tl - 1) {
             n += jl_static_show(s, tp);
@@ -1631,21 +1548,22 @@ DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type)
     return n;
 }
 
-int in_jl_ = 0;
-DLLEXPORT void jl_(void *jl_value)
+JL_DLLEXPORT void jl_(void *jl_value)
 {
-    in_jl_++;
-    JL_TRY {
+    jl_jmp_buf *old_buf = jl_safe_restore;
+    jl_jmp_buf buf;
+    jl_safe_restore = &buf;
+    if (!jl_setjmp(buf, 0)) {
         (void)jl_static_show((JL_STREAM*)STDERR_FILENO, (jl_value_t*)jl_value);
         jl_printf((JL_STREAM*)STDERR_FILENO,"\n");
     }
-    JL_CATCH {
+    else {
         jl_printf((JL_STREAM*)STDERR_FILENO, "\n!!! ERROR in jl_ -- ABORTING !!!\n");
     }
-    in_jl_--;
+    jl_safe_restore = old_buf;
 }
 
-DLLEXPORT void jl_breakpoint(jl_value_t *v)
+JL_DLLEXPORT void jl_breakpoint(jl_value_t *v)
 {
     // put a breakpoint in you debugger here
 }
diff --git a/src/ccall.cpp b/src/ccall.cpp
index 1a5b7083cb313..8965de04dbcdc 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1,141 +1,40 @@
 // This file is a part of Julia. License is MIT: http://julialang.org/license
 
-// --- the ccall intrinsic ---
+#include "support/hashing.h"
 
-// --- library symbol lookup ---
+// --- the ccall, cglobal, and llvm intrinsics ---
 
-// map from "libX" to full soname "libX.so.ver"
-#if defined(__linux__) || defined(__FreeBSD__)
-static std::map<std::string, std::string> sonameMap;
-static bool got_sonames = false;
-
-extern "C" DLLEXPORT void jl_read_sonames(void)
-{
-    char *line=NULL;
-    size_t sz=0;
-#if defined(__linux__)
-    FILE *ldc = popen("/sbin/ldconfig -p", "r");
-#else
-    FILE *ldc = popen("/sbin/ldconfig -r", "r");
-#endif
-
-    while (!feof(ldc)) {
-        ssize_t n = getline(&line, &sz, ldc);
-        if (n == -1)
-            break;
-        if (n > 2 && isspace((unsigned char)line[0])) {
-#ifdef __linux__
-            int i = 0;
-            while (isspace((unsigned char)line[++i])) ;
-            char *name = &line[i];
-            char *dot = strstr(name, ".so");
-            i = 0;
+// keep track of llvmcall declarations
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+static std::map<uint64_t,llvm::GlobalValue*> llvmcallDecls;
 #else
-            char *name = strstr(line, ":-l");
-            if (name == NULL) continue;
-            strncpy(name, "lib", 3);
-            char *dot = strchr(name, '.');
-#endif
-
-            if (NULL == dot)
-                continue;
-
-#ifdef __linux__
-            // Detect if this entry is for the current architecture
-            while (!isspace((unsigned char)dot[++i])) ;
-            while (isspace((unsigned char)dot[++i])) ;
-            int j = i;
-            while (!isspace((unsigned char)dot[++j])) ;
-            char *arch = strstr(dot+i,"x86-64");
-            if (arch != NULL && arch < dot + j) {
-#ifdef _P32
-                continue;
-#endif
-            }
-            else {
-#ifdef _P64
-                continue;
+static std::set<uint64_t> llvmcallDecls;
 #endif
-            }
-#endif // __linux__
-
-            char *abslibpath = strrchr(line, ' ');
-            if (dot != NULL && abslibpath != NULL) {
-                std::string pfx(name, dot - name);
-                // Do not include ' ' in front and '\n' at the end
-                std::string soname(abslibpath+1, line+n-(abslibpath+1)-1);
-                sonameMap[pfx] = soname;
-            }
-        }
-    }
-
-    free(line);
-    pclose(ldc);
-}
 
-extern "C" DLLEXPORT const char *jl_lookup_soname(const char *pfx, size_t n)
-{
-    if (!got_sonames) {
-        jl_read_sonames();
-        got_sonames = true;
-    }
-    std::string str(pfx, n);
-    if (sonameMap.find(str) != sonameMap.end()) {
-        return sonameMap[str].c_str();
-    }
-    return NULL;
-}
-#endif
-
-// map from user-specified lib names to handles
-static std::map<std::string, uv_lib_t*> libMap;
+static std::map<std::string, GlobalVariable*> libMapGV;
+static std::map<std::string, GlobalVariable*> symMapGV;
 
-static uv_lib_t *get_library(char *lib)
+static Value *GetStringPtr(llvm::IRBuilder <> *builder, GlobalValue *GV, const Twine &Name)
 {
-    uv_lib_t *hnd;
-#ifdef _OS_WINDOWS_
-    if ((intptr_t)lib == 1)
-        return jl_exe_handle;
-    if ((intptr_t)lib == 2)
-        return jl_dl_handle;
+    Value *zero = ConstantInt::get(Type::getInt32Ty(jl_LLVMContext), 0);
+    Value *Args[] = { zero, zero };
+#ifdef LLVM37
+    return builder->CreateInBoundsGEP(GV->getValueType(), GV, Args, Name);
+#else
+    return builder->CreateInBoundsGEP(GV, Args, Name);
 #endif
-    if (lib == NULL)
-        return jl_RTLD_DEFAULT_handle;
-    hnd = libMap[lib];
-    if (hnd != NULL)
-        return hnd;
-    hnd = (uv_lib_t *) jl_load_dynamic_library(lib, JL_RTLD_DEFAULT);
-    if (hnd != NULL)
-        libMap[lib] = hnd;
-    return hnd;
 }
 
-extern "C" DLLEXPORT
-void *jl_load_and_lookup(char *f_lib, char *f_name, uv_lib_t **hnd)
-{
-    uv_lib_t *handle = *hnd;
-    if (!handle)
-        *hnd = handle = get_library(f_lib);
-    void *ptr = jl_dlsym_e(handle, f_name);
-    if (!ptr)
-        jl_errorf("symbol \"%s\" could not be found: %s", f_name, uv_dlerror(handle));
-    return ptr;
-}
-
-static std::map<std::string, GlobalVariable*> libMapGV;
-static std::map<std::string, GlobalVariable*> symMapGV;
-static Value *runtime_sym_lookup(PointerType *funcptype, char *f_lib, char *f_name, jl_codectx_t *ctx)
+static Value *runtime_sym_lookup(PointerType *funcptype, const char *f_lib, const char *f_name, jl_codectx_t *ctx)
 {
     // in pseudo-code, this function emits the following:
-    //   global uv_lib_t **libptrgv
+    //   global HMODULE *libptrgv
     //   global void **llvmgv
     //   if (*llvmgv == NULL) {
     //       *llvmgv = jl_load_and_lookup(f_lib, f_name, libptrgv);
     //   }
     //   return (*llvmgv)
-    Constant *initnul = ConstantPointerNull::get((PointerType*)T_pint8);
-
-    uv_lib_t *libsym = NULL;
+    void *libsym = NULL;
     bool runtime_lib = false;
     GlobalVariable *libptrgv;
 #ifdef _OS_WINDOWS_
@@ -157,36 +56,37 @@ static Value *runtime_sym_lookup(PointerType *funcptype, char *f_lib, char *f_na
         runtime_lib = true;
         libptrgv = libMapGV[f_lib];
         if (libptrgv == NULL) {
-            libptrgv = new GlobalVariable(*jl_Module, T_pint8,
+            libptrgv = new GlobalVariable(imaging_mode ? *shadow_module : *active_module, T_pint8,
                false, GlobalVariable::PrivateLinkage,
-               initnul, f_lib);
+               ConstantPointerNull::get((PointerType*)T_pint8), f_lib);
             libMapGV[f_lib] = libptrgv;
-            libsym = get_library(f_lib);
+            libsym = jl_get_library(f_lib);
             assert(libsym != NULL);
 #ifdef USE_MCJIT
             jl_llvm_to_jl_value[libptrgv] = libsym;
 #else
-            *((uv_lib_t**)jl_ExecutionEngine->getPointerToGlobal(libptrgv)) = libsym;
+            *((void**)jl_ExecutionEngine->getPointerToGlobal(libptrgv)) = libsym;
 #endif
         }
     }
     if (libsym == NULL) {
 #ifdef USE_MCJIT
-        libsym = (uv_lib_t*)jl_llvm_to_jl_value[libptrgv];
+        libsym = (void*)jl_llvm_to_jl_value[libptrgv];
 #else
-        libsym = *((uv_lib_t**)jl_ExecutionEngine->getPointerToGlobal(libptrgv));
+        libsym = *((void**)jl_ExecutionEngine->getPointerToGlobal(libptrgv));
 #endif
     }
 
     assert(libsym != NULL);
 
     GlobalVariable *llvmgv = symMapGV[f_name];
+    Constant *initnul = ConstantPointerNull::get((PointerType*)T_pvoidfunc);
     if (llvmgv == NULL) {
         // MCJIT forces this to have external linkage eventually, so we would clobber
         // the symbol of the actual function.
         std::string name = f_name;
         name = "ccall_" + name;
-        llvmgv = new GlobalVariable(*jl_Module, T_pint8,
+        llvmgv = new GlobalVariable(imaging_mode ? *shadow_module : *active_module, T_pvoidfunc,
            false, GlobalVariable::PrivateLinkage,
            initnul, name);
         symMapGV[f_name] = llvmgv;
@@ -201,19 +101,20 @@ static Value *runtime_sym_lookup(PointerType *funcptype, char *f_lib, char *f_na
                *ccall_bb = BasicBlock::Create(jl_LLVMContext, "ccall");
     builder.CreateCondBr(builder.CreateICmpNE(builder.CreateLoad(llvmgv), initnul), ccall_bb, dlsym_lookup);
 
+    assert(ctx->f->getParent() != NULL);
     ctx->f->getBasicBlockList().push_back(dlsym_lookup);
     builder.SetInsertPoint(dlsym_lookup);
     Value *libname;
     if (runtime_lib) {
-        libname = builder.CreateGlobalStringPtr(f_lib);
+        libname = GetStringPtr(&builder, stringConst(f_lib), "f_lib");
     }
     else {
         libname = literal_static_pointer_val(f_lib, T_pint8);
     }
 #ifdef LLVM37
-    Value *llvmf = builder.CreateCall(prepare_call(jldlsym_func), { libname, builder.CreateGlobalStringPtr(f_name), libptrgv });
+    Value *llvmf = builder.CreateCall(prepare_call(jldlsym_func), { libname, GetStringPtr(&builder, stringConst(f_name), "f_name"), libptrgv });
 #else
-    Value *llvmf = builder.CreateCall3(prepare_call(jldlsym_func), libname, builder.CreateGlobalStringPtr(f_name), libptrgv);
+    Value *llvmf = builder.CreateCall3(prepare_call(jldlsym_func), libname, GetStringPtr(&builder, stringConst(f_name), "f_name"), libptrgv);
 #endif
     builder.CreateStore(llvmf, llvmgv);
     builder.CreateBr(ccall_bb);
@@ -241,6 +142,10 @@ static Value *runtime_sym_lookup(PointerType *funcptype, char *f_lib, char *f_na
 #  else
 #    include "abi_x86.cpp"
 #  endif
+#elif defined _CPU_ARM_
+#  include "abi_arm.cpp"
+#elif defined _CPU_AARCH64_
+#    include "abi_aarch64.cpp"
 #else
 #  warning "ccall is defaulting to llvm ABI, since no platform ABI has been defined for this CPU/OS combination"
 #  include "abi_llvm.cpp"
@@ -314,13 +219,13 @@ Value *llvm_type_rewrite(Value *v, Type *from_type, Type *target_type,
 // to = desired LLVM type
 // jlto = Julia type of formal argument
 // jvinfo = value of actual argument
-static Value *julia_to_native(Type *to, jl_value_t *jlto, const jl_cgval_t &jvinfo,
+static Value *julia_to_native(Type *to, bool toboxed, jl_value_t *jlto, const jl_cgval_t &jvinfo,
                               bool addressOf, bool byRef, bool inReg, bool needCopy,
                               bool tojulia, int argn, jl_codectx_t *ctx,
                               bool *needStackRestore)
 {
     // We're passing Any
-    if (to == jl_pvalue_llvmt) {
+    if (toboxed) {
         assert(!addressOf && !byRef); // don't expect any ABI to pass pointers by pointer
         return boxed(jvinfo, ctx);
     }
@@ -371,7 +276,7 @@ static Value *julia_to_native(Type *to, jl_value_t *jlto, const jl_cgval_t &jvin
         if (!jl_is_abstracttype(ety)) {
             if (jl_is_mutable_datatype(ety)) {
                 // no copy, just reference the data field
-                return builder.CreateBitCast(jvinfo.V, to);
+                return data_pointer(jvinfo, ctx, to);
             }
             else if (jl_is_immutable_datatype(ety) && jlto != (jl_value_t*)jl_voidpointer_type) {
                 // yes copy
@@ -391,7 +296,8 @@ static Value *julia_to_native(Type *to, jl_value_t *jlto, const jl_cgval_t &jvin
                     *needStackRestore = true;
                 }
                 ai->setAlignment(16);
-                builder.CreateMemCpy(ai, builder.CreateBitCast(jvinfo.V, T_pint8), nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size
+                prepare_call(
+                    builder.CreateMemCpy(ai, data_pointer(jvinfo, ctx, T_pint8), nbytes, sizeof(void*))->getCalledValue()); // minimum gc-alignment in julia is pointer size
                 return builder.CreateBitCast(ai, to);
             }
         }
@@ -409,7 +315,7 @@ static Value *julia_to_native(Type *to, jl_value_t *jlto, const jl_cgval_t &jvin
                 T_int1);
         builder.CreateCondBr(ismutable, mutableBB, immutableBB);
         builder.SetInsertPoint(mutableBB);
-        Value *p1 = builder.CreatePointerCast(jvinfo.V, to);
+        Value *p1 = data_pointer(jvinfo, ctx, to);
         builder.CreateBr(afterBB);
         builder.SetInsertPoint(immutableBB);
         Value *nbytes = tbaa_decorate(tbaa_datatype, builder.CreateLoad(
@@ -418,8 +324,8 @@ static Value *julia_to_native(Type *to, jl_value_t *jlto, const jl_cgval_t &jvin
                     false));
         AllocaInst *ai = builder.CreateAlloca(T_int8, nbytes);
         ai->setAlignment(16);
-        builder.CreateMemCpy(ai, jvinfo.V, nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size
-        Value *p2 = builder.CreatePointerCast(ai, to);
+        prepare_call(builder.CreateMemCpy(ai, data_pointer(jvinfo, ctx, T_pint8), nbytes, sizeof(void*))->getCalledValue()); // minimum gc-alignment in julia is pointer size
+        Value *p2 = builder.CreateBitCast(ai, to);
         builder.CreateBr(afterBB);
         builder.SetInsertPoint(afterBB);
         PHINode *p = builder.CreatePHI(to, 2);
@@ -433,18 +339,23 @@ static Value *julia_to_native(Type *to, jl_value_t *jlto, const jl_cgval_t &jvin
     if (addressOf)
         to = to->getContainedType(0);
     Value *slot = emit_static_alloca(to, ctx);
-    if (!jvinfo.ispointer)
+    if (!jvinfo.ispointer) {
         builder.CreateStore(emit_unbox(to, jvinfo, ety), slot);
-    else
-        builder.CreateMemCpy(slot, jvinfo.V, (uint64_t)jl_datatype_size(ety), (uint64_t)((jl_datatype_t*)ety)->alignment);
+    }
+    else {
+        prepare_call(builder.CreateMemCpy(slot, data_pointer(jvinfo, ctx, slot->getType()),
+                    (uint64_t)jl_datatype_size(ety),
+                    (uint64_t)((jl_datatype_t*)ety)->alignment)->getCalledValue());
+        mark_gc_use(jvinfo);
+    }
     return slot;
 }
 
 typedef struct {
     Value *jl_ptr;  // if the argument is a run-time computed pointer
-    void *fptr;     // if the argument is a constant pointer
-    char *f_name;   // if the symbol name is known
-    char *f_lib;    // if a library name is specified
+    void (*fptr)(void);     // if the argument is a constant pointer
+    const char *f_name;   // if the symbol name is known
+    const char *f_lib;    // if a library name is specified
 } native_sym_arg_t;
 
 // --- parse :sym or (:sym, :lib) argument into address info ---
@@ -456,7 +367,7 @@ static native_sym_arg_t interpret_symbol_arg(jl_value_t *arg, jl_codectx_t *ctx,
     ptr = static_eval(arg, ctx, true);
     if (ptr == NULL) {
         jl_value_t *ptr_ty = expr_type(arg, ctx);
-        jl_cgval_t arg1 = emit_unboxed(arg, ctx);
+        jl_cgval_t arg1 = emit_expr(arg, ctx);
         if (!jl_is_cpointer_type(ptr_ty)) {
             emit_cpointercheck(arg1,
                                !strcmp(fname,"ccall") ?
@@ -468,8 +379,8 @@ static native_sym_arg_t interpret_symbol_arg(jl_value_t *arg, jl_codectx_t *ctx,
         jl_ptr = emit_unbox(T_size, arg1, (jl_value_t*)jl_voidpointer_type);
     }
 
-    void *fptr=NULL;
-    char *f_name=NULL, *f_lib=NULL;
+    void (*fptr)(void) = NULL;
+    const char *f_name=NULL, *f_lib=NULL;
     jl_value_t *t0 = NULL, *t1 = NULL;
     JL_GC_PUSH3(&ptr, &t0, &t1);
     if (ptr != NULL) {
@@ -477,7 +388,7 @@ static native_sym_arg_t interpret_symbol_arg(jl_value_t *arg, jl_codectx_t *ctx,
             ptr = jl_fieldref(ptr,0);
         }
         if (jl_is_symbol(ptr))
-            f_name = ((jl_sym_t*)ptr)->name;
+            f_name = jl_symbol_name((jl_sym_t*)ptr);
         else if (jl_is_byte_string(ptr))
             f_name = jl_string_data(ptr);
         if (f_name != NULL) {
@@ -488,19 +399,19 @@ static native_sym_arg_t interpret_symbol_arg(jl_value_t *arg, jl_codectx_t *ctx,
 #endif
         }
         else if (jl_is_cpointer_type(jl_typeof(ptr))) {
-            fptr = *(void**)jl_data_ptr(ptr);
+            fptr = *(void(**)(void))jl_data_ptr(ptr);
         }
         else if (jl_is_tuple(ptr) && jl_nfields(ptr)>1) {
             jl_value_t *t0 = jl_fieldref(ptr,0);
             jl_value_t *t1 = jl_fieldref(ptr,1);
             if (jl_is_symbol(t0))
-                f_name = ((jl_sym_t*)t0)->name;
+                f_name = jl_symbol_name((jl_sym_t*)t0);
             else if (jl_is_byte_string(t0))
                 f_name = jl_string_data(t0);
             else
                 JL_TYPECHKS(fname, symbol, t0);
             if (jl_is_symbol(t1))
-                f_lib = ((jl_sym_t*)t1)->name;
+                f_lib = jl_symbol_name((jl_sym_t*)t1);
             else if (jl_is_byte_string(t1))
                 f_lib = jl_string_data(t1);
             else
@@ -522,6 +433,27 @@ static native_sym_arg_t interpret_symbol_arg(jl_value_t *arg, jl_codectx_t *ctx,
 
 typedef AttributeSet attr_type;
 
+static jl_value_t* try_eval(jl_value_t *ex, jl_codectx_t *ctx, const char *failure, bool compiletime=false)
+{
+    jl_value_t *constant = NULL;
+    constant = static_eval(ex, ctx, true, true);
+    if (constant || jl_is_gensym(ex))
+        return constant;
+    JL_TRY {
+        constant = jl_interpret_toplevel_expr_in(ctx->module, ex,
+                                                 ctx->linfo->sparam_syms,
+                                                 ctx->linfo->sparam_vals);
+    }
+    JL_CATCH {
+        if (compiletime)
+            jl_rethrow_with_add(failure);
+        if (failure)
+            emit_error(failure, ctx);
+        constant = NULL;
+    }
+    return constant;
+}
+
 // --- code generator for cglobal ---
 
 static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
@@ -532,13 +464,10 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
     JL_GC_PUSH1(&rt);
 
     if (nargs == 2) {
-        JL_TRY {
-            rt = jl_interpret_toplevel_expr_in(ctx->module, args[2],
-                                               jl_svec_data(ctx->sp),
-                                               jl_svec_len(ctx->sp)/2);
-        }
-        JL_CATCH {
-            jl_rethrow_with_add("error interpreting cglobal type");
+        rt = try_eval(args[2], ctx, "error interpreting cglobal pointer type");
+        if (rt == NULL) {
+            JL_GC_POP();
+            return jl_cgval_t();
         }
 
         JL_TYPECHK(cglobal, type, rt);
@@ -556,7 +485,7 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
         res = builder.CreateIntToPtr(sym.jl_ptr, lrt);
     }
     else if (sym.fptr != NULL) {
-        res = literal_static_pointer_val(sym.fptr, lrt);
+        res = literal_static_pointer_val((void*)(uintptr_t)sym.fptr, lrt);
         if (imaging_mode)
             jl_printf(JL_STDERR,"WARNING: literal address used in cglobal for %s; code cannot be statically compiled\n", sym.f_name);
     }
@@ -565,7 +494,7 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
             res = runtime_sym_lookup((PointerType*)lrt, sym.f_lib, sym.f_name, ctx);
         }
         else {
-            void *symaddr = jl_dlsym_e(get_library(sym.f_lib), sym.f_name);
+            void *symaddr = jl_dlsym_e(jl_get_library(sym.f_lib), sym.f_name);
             if (symaddr == NULL) {
                 std::stringstream msg;
                 msg << "cglobal: could not find symbol ";
@@ -586,54 +515,33 @@ static jl_cgval_t emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ct
     }
 
     JL_GC_POP();
-    return mark_julia_type(res, rt);
+    return mark_julia_type(res, false, rt, ctx);
 }
 
 // llvmcall(ir, (rettypes...), (argtypes...), args...)
 static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
 {
     JL_NARGSV(llvmcall, 3)
-    jl_value_t *rt = NULL, *at = NULL, *ir = NULL;
+    jl_value_t *rt = NULL, *at = NULL, *ir = NULL, *decl = NULL;
     jl_svec_t *stt = NULL;
-    JL_GC_PUSH4(&ir, &rt, &at, &stt);
-    {
-    JL_TRY {
-        at  = jl_interpret_toplevel_expr_in(ctx->module, args[3],
-                                            jl_svec_data(ctx->sp),
-                                            jl_svec_len(ctx->sp)/2);
-    }
-    JL_CATCH {
-        jl_rethrow_with_add("error interpreting llvmcall argument tuple");
-    }
-    }
-    {
-    JL_TRY {
-        rt  = jl_interpret_toplevel_expr_in(ctx->module, args[2],
-                                            jl_svec_data(ctx->sp),
-                                            jl_svec_len(ctx->sp)/2);
-    }
-    JL_CATCH {
-        jl_rethrow_with_add("error interpreting llvmcall return type");
-    }
-    }
-    {
-    JL_TRY {
-        ir  = jl_interpret_toplevel_expr_in(ctx->module, args[1],
-                                            jl_svec_data(ctx->sp),
-                                            jl_svec_len(ctx->sp)/2);
-    }
-    JL_CATCH {
-        jl_rethrow_with_add("error interpreting IR argument");
-    }
-    }
+    JL_GC_PUSH5(&ir, &rt, &at, &stt, &decl);
+    at = try_eval(args[3], ctx, "error statically evaluating llvmcall argument tuple", true);
+    rt = try_eval(args[2], ctx, "error statically evaluating llvmcall return type", true);
+    ir = try_eval(args[1], ctx, "error statically evaluating llvm IR argument", true);
     int i = 1;
-    if (ir == NULL) {
-        jl_error("Cannot statically evaluate first argument to llvmcall");
+    if (jl_is_tuple(ir)) {
+        // if the IR is a tuple, we expect (declarations, ir)
+        if (jl_nfields(ir) != 2)
+            jl_error("Tuple as first argument to llvmcall must have exactly two children");
+        decl = jl_fieldref(ir,0);
+        ir = jl_fieldref(ir,1);
+        if (!jl_is_byte_string(decl))
+            jl_error("Declarations passed to llvmcall must be a string");
     }
     bool isString = jl_is_byte_string(ir);
     bool isPtr = jl_is_cpointer(ir);
     if (!isString && !isPtr) {
-        jl_error("First argument to llvmcall must be a string or pointer to an LLVM Function");
+        jl_error("IR passed to llvmcall must be a string or pointer to an LLVM Function");
     }
 
     JL_TYPECHK(llvmcall, type, rt);
@@ -661,37 +569,28 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
      * If the argument type is immutable (including bitstype), we pass the loaded llvm value
      * type. Otherwise we pass a pointer to a jl_value_t.
      */
+    jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargt);
     for (size_t i = 0; i < nargt; ++i) {
         jl_value_t *tti = jl_svecref(tt,i);
-        Type *t = julia_type_to_llvm(tti);
+        bool toboxed;
+        Type *t = julia_type_to_llvm(tti, &toboxed);
         argtypes.push_back(t);
         if (4+i > nargs) {
             jl_error("Missing arguments to llvmcall!");
         }
-        jl_value_t *argi = args[4+i];
-        jl_cgval_t arg;
-        bool needroot = false;
-        if (t == jl_pvalue_llvmt || !jl_isbits(tti)) {
-            arg = emit_expr(argi, ctx, true);
-            if (t == jl_pvalue_llvmt && !arg.isboxed) {
-                needroot = true;
-            }
-        }
-        else {
-            arg = emit_unboxed(argi, ctx);
-        }
+        jl_value_t *argi = args[4 + i];
+        jl_cgval_t &arg = argv[i];
+        arg = emit_expr(argi, ctx);
 
-        Value *v = julia_to_native(t, tti, arg, false, false, false, false, false, i, ctx, NULL);
+        Value *v = julia_to_native(t, toboxed, tti, arg, false, false, false, false, false, i, ctx, NULL);
         // make sure args are rooted
-        if (t == jl_pvalue_llvmt && (needroot || might_need_root(argi))) {
-            make_gcroot(v, ctx);
-        }
         bool issigned = jl_signed_type && jl_subtype(tti, (jl_value_t*)jl_signed_type, 0);
         argvals[i] = llvm_type_rewrite(v, t, t, false, false, issigned, ctx);
     }
 
     Function *f;
-    Type *rettype = julia_type_to_llvm(rtt);
+    bool retboxed;
+    Type *rettype = julia_type_to_llvm(rtt, &retboxed);
     if (isString) {
         // Make sure to find a unique name
         std::string ir_name;
@@ -699,7 +598,7 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
             std::stringstream name;
             name << (ctx->f->getName().str()) << "u" << i++;
             ir_name = name.str();
-            if (jl_Module->getFunction(ir_name) == NULL)
+            if (builtins_module->getFunction(ir_name) == NULL)
                 break;
         }
 
@@ -716,7 +615,46 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         std::string rstring;
         llvm::raw_string_ostream rtypename(rstring);
         rettype->print(rtypename);
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+        std::map<uint64_t,std::string> localDecls;
+#endif
 
+        if (decl != NULL) {
+            std::stringstream declarations(jl_string_data(decl));
+
+            // parse string line by line
+            std::string declstr;
+            while (std::getline(declarations, declstr, '\n')) {
+                uint64_t declhash = memhash(declstr.c_str(), declstr.length());
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+                auto it = llvmcallDecls.find(declhash);
+                if (it != llvmcallDecls.end()) {
+                    prepare_call(it->second);
+                }
+                else {
+#else
+                if (llvmcallDecls.count(declhash) == 0) {
+#endif
+                    // Find name of declaration by searching for '@'
+                    std::string::size_type atpos = declstr.find('@') + 1;
+                    // Find end of declaration by searching for '('
+                    std::string::size_type bracepos = declstr.find('(', atpos);
+                    // Declaration name is the string between @ and (
+                    std::string declname = declstr.substr(atpos, bracepos - atpos);
+
+                    // Check if declaration already present in module
+                    if(jl_Module->getNamedValue(declname) == NULL) {
+                        ir_stream << "; Declarations\n" << declstr << "\n";
+                    }
+
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+                    localDecls[declhash] = declname;
+#else
+                    llvmcallDecls.insert(declhash);
+#endif
+                }
+            }
+        }
         ir_stream << "; Number of arguments: " << nargt << "\n"
         << "define "<<rtypename.str()<<" @\"" << ir_name << "\"("<<argstream.str()<<") {\n"
         << jl_string_data(ir) << "\n}";
@@ -724,9 +662,9 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         std::string ir_string = ir_stream.str();
 #ifdef LLVM36
         Module *m = NULL;
-        bool failed = parseAssemblyInto(llvm::MemoryBufferRef(ir_string,"llvmcall"),*jl_Module,Err);
+        bool failed = parseAssemblyInto(llvm::MemoryBufferRef(ir_string,"llvmcall"),*builtins_module,Err);
         if (!failed)
-            m = jl_Module;
+            m = builtins_module;
 #else
         Module *m = ParseAssemblyString(ir_string.c_str(),jl_Module,Err,jl_LLVMContext);
 #endif
@@ -737,6 +675,12 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
             jl_error(stream.str().c_str());
         }
         f = m->getFunction(ir_name);
+        f->removeFromParent();
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+        for (auto it : localDecls) {
+            llvmcallDecls[it.first] = cast<GlobalValue>(prepare_call(m->getNamedValue(it.second)));
+        }
+#endif
     }
     else {
         assert(isPtr);
@@ -749,8 +693,8 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
             assert(*it == f->getFunctionType()->getParamType(i));
 
 #ifdef USE_MCJIT
-        if (f->getParent() != jl_Module) {
-            FunctionMover mover(jl_Module,f->getParent());
+        if (f->getParent() != active_module) {
+            FunctionMover mover(active_module,f->getParent());
             f = mover.CloneFunction(f);
         }
 #endif
@@ -775,12 +719,30 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
      * generated the entire function, so we need to store it in the context until the end of the
      * function. This also has the benefit of looking exactly like we cut/pasted it in in `code_llvm`.
      */
-    f->setLinkage(GlobalValue::LinkOnceODRLinkage);
+
+    // Since we dumped all of f's dependencies into the active module,
+    // we cannot reasonably inline it, so leave it there and just emit
+    // a regular call
+    if (!isString) {
+        static int llvmcallnumbering = 0;
+        std::stringstream name;
+        name << "jl_llvmcall" << llvmcallnumbering++;
+        f->setName(name.str());
+        f = cast<Function>(prepare_call(function_proto(f)));
+    }
+    else
+        f->setLinkage(GlobalValue::LinkOnceODRLinkage);
 
     // the actual call
-    assert(f->getParent() == jl_Module); // no prepare_call(f) is needed below, since this was just emitted into the same module
-    CallInst *inst = builder.CreateCall(f,ArrayRef<Value*>(&argvals[0],nargt));
-    ctx->to_inline.push_back(inst);
+    CallInst *inst = builder.CreateCall(f, ArrayRef<Value*>(&argvals[0], nargt));
+    if (isString)
+        ctx->to_inline.push_back(inst);
+
+    // after the llvmcall mark fake uses of all of the arguments to ensure the were live
+    for (size_t i = 0; i < nargt; ++i) {
+        const jl_cgval_t &arg = argv[i];
+        mark_gc_use(arg);
+    }
 
     JL_GC_POP();
 
@@ -788,12 +750,12 @@ static jl_cgval_t emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *c
         jl_error("Return type of llvmcall'ed function does not match declared return type");
     }
 
-    return mark_julia_type(emit_reg2mem(inst, ctx), rtt);
+    return mark_julia_type(inst, retboxed, rtt, ctx);
 }
 
 // --- code generator for ccall itself ---
 
-static jl_cgval_t mark_or_box_ccall_result(Value *result, jl_value_t *rt_expr, jl_value_t *rt, bool static_rt, jl_codectx_t *ctx)
+static jl_cgval_t mark_or_box_ccall_result(Value *result, bool isboxed, jl_value_t *rt_expr, jl_value_t *rt, bool static_rt, jl_codectx_t *ctx)
 {
     if (!static_rt) {
         // box if concrete type was not statically known
@@ -802,9 +764,10 @@ static jl_cgval_t mark_or_box_ccall_result(Value *result, jl_value_t *rt_expr, j
         int nb = sizeof(void*);
         return mark_julia_type(
                 init_bits_value(emit_allocobj(nb), runtime_bt, result),
-                (jl_value_t*)jl_pointer_type);
+                true,
+                (jl_value_t*)jl_pointer_type, ctx);
     }
-    return mark_julia_type(result, rt);
+    return mark_julia_type(result, isboxed, rt, ctx);
 }
 
 typedef AttributeSet attr_type;
@@ -814,6 +777,7 @@ static std::string generate_func_sig(
         Type **prt, // out parameter of the llvm return type for the function signature
         int &sret, // out parameter for indicating whether return value has been moved to the first argument position
         std::vector<Type *> &fargt, // vector of llvm output types (julia_struct_to_llvm) for arguments (vararg is the last item, if applicable)
+        std::vector<bool> &fargt_isboxed, // vector of whether the llvm output types is boxed for each argument (vararg is the last item, if applicable)
         std::vector<Type *> &fargt_sig, // vector of ABI coercion types for call signature
         Type *&fargt_vasig, // ABI coercion type for vararg list
         std::vector<bool> &inRegList, // vector of "inreg" parameters (vararg is the last item, if applicable)
@@ -859,12 +823,14 @@ static std::string generate_func_sig(
             tti = jl_tparam0(tti);
         }
         Type *t = NULL;
+        bool isboxed;
         Attribute::AttrKind av = Attribute::None;
         if (jl_is_abstract_ref_type(tti)) {
             if (jl_is_typevar(jl_tparam0(tti)))
                 jl_error("ccall: argument type Ref should have an element type, not Ref{T}");
             tti = (jl_value_t*)jl_voidpointer_type;
             t = T_pint8;
+            isboxed = false;
         }
         else {
             if (jl_is_cpointer_type(tti) && jl_is_typevar(jl_tparam0(tti)))
@@ -881,9 +847,8 @@ static std::string generate_func_sig(
                 }
             }
 
-            t = julia_struct_to_llvm(tti);
+            t = julia_struct_to_llvm(tti, &isboxed);
             if (t == NULL || t == T_void) {
-                JL_GC_POP();
                 std::stringstream msg;
                 msg << "ccall: the type of argument ";
                 msg << i+1;
@@ -916,6 +881,7 @@ static std::string generate_func_sig(
         byRefList.push_back(byRef);
         inRegList.push_back(inReg);
         fargt.push_back(t);
+        fargt_isboxed.push_back(isboxed);
         if (!current_isVa)
             fargt_sig.push_back(pat);
         else
@@ -927,8 +893,12 @@ static std::string generate_func_sig(
                 // Note that even though the LLVM argument is called ByVal
                 // this really means that the thing we're passing is pointing to
                 // the thing we want to pass by value
+#ifndef _CPU_AARCH64_
+                // the aarch64 backend seems to interpret ByVal as
+                // implicitly passed on stack.
                 if (byRef)
                     paramattrs[i + sret].addAttribute(Attribute::ByVal);
+#endif
                 if (inReg)
                     paramattrs[i + sret].addAttribute(Attribute::InReg);
                 if (av != Attribute::None)
@@ -961,8 +931,8 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
 
     native_sym_arg_t symarg = interpret_symbol_arg(args[1], ctx, "ccall");
     Value *jl_ptr=NULL;
-    void *fptr = NULL;
-    char *f_name = NULL, *f_lib = NULL;
+    void (*fptr)(void) = NULL;
+    const char *f_name = NULL, *f_lib = NULL;
     jl_ptr = symarg.jl_ptr;
     fptr = symarg.fptr;
     f_name = symarg.f_name;
@@ -981,12 +951,8 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         rt = jl_tparam0(rtt_);
     }
     else {
-        JL_TRY {
-            rt  = jl_interpret_toplevel_expr_in(ctx->module, args[2],
-                                                jl_svec_data(ctx->sp),
-                                                jl_svec_len(ctx->sp)/2);
-        }
-        JL_CATCH {
+        rt = try_eval(args[2], ctx, NULL);
+        if (rt == NULL) {
             static_rt = false;
             if (jl_is_type_type(rtt_)) {
                 if (jl_subtype(jl_tparam0(rtt_), (jl_value_t*)jl_pointer_type, 0)) {
@@ -1000,6 +966,33 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
                 }
             }
             if (rt == NULL) {
+                if (jl_is_expr(args[2])) {
+                    jl_expr_t *rtexpr = (jl_expr_t*)args[2];
+                    if (rtexpr->head == call_sym && jl_expr_nargs(rtexpr) == 4 &&
+                            static_eval(jl_exprarg(rtexpr, 0), ctx, true, false) == jl_builtin_apply_type &&
+                            static_eval(jl_exprarg(rtexpr, 1), ctx, true, false) == (jl_value_t*)jl_array_type) {
+                        // `Array` used as return type just returns a julia object reference
+                        rt = (jl_value_t*)jl_any_type;
+                        static_rt = true;
+                    }
+                    else if (rtexpr->head == call_sym && jl_expr_nargs(rtexpr) == 3 &&
+                            static_eval(jl_exprarg(rtexpr, 0), ctx, true, false) == jl_builtin_apply_type &&
+                            static_eval(jl_exprarg(rtexpr, 1), ctx, true, false) == (jl_value_t*)jl_pointer_type) {
+                        // substitute Ptr{Void} for statically-unknown pointer type
+                        rt = (jl_value_t*)jl_voidpointer_type;
+                    }
+                }
+            }
+            if (rt == NULL) {
+                if (jl_exception_in_transit && jl_typeis(jl_exception_in_transit,
+                                                         jl_undefvarerror_type)
+                                            && jl_is_symbol(args[2])) {
+                    std::string msg = "ccall return type undefined: " +
+                                      std::string(jl_symbol_name((jl_sym_t*)args[2]));
+                    emit_error(msg.c_str(), ctx);
+                    JL_GC_POP();
+                    return jl_cgval_t();
+                }
                 emit_error("error interpreting ccall return type", ctx);
                 JL_GC_POP();
                 return jl_cgval_t();
@@ -1027,25 +1020,18 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     }
 
     JL_TYPECHK(ccall, type, rt);
-    Type *lrt = julia_struct_to_llvm(rt);
+    bool retboxed;
+    Type *lrt = julia_struct_to_llvm(rt, &retboxed);
     if (lrt == NULL) {
         emit_error("ccall: return type doesn't correspond to a C type", ctx);
         JL_GC_POP();
         return jl_cgval_t();
     }
 
-    {
-        JL_TRY {
-            at  = jl_interpret_toplevel_expr_in(ctx->module, args[3],
-                                                jl_svec_data(ctx->sp),
-                                                jl_svec_len(ctx->sp)/2);
-        }
-        JL_CATCH {
-            //jl_rethrow_with_add("error interpreting ccall argument tuple");
-            emit_error("error interpreting ccall argument tuple", ctx);
-            JL_GC_POP();
-            return jl_cgval_t();
-        }
+    at = try_eval(args[3], ctx, "error interpreting ccall argument tuple");
+    if (at == NULL) {
+        JL_GC_POP();
+        return jl_cgval_t();
     }
 
     JL_TYPECHK(ccall, simplevector, at);
@@ -1094,7 +1080,7 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         jl_error("ccall: wrong number of arguments to C function");
 
     // some special functions
-    if (fptr == (void *) &jl_array_ptr ||
+    if (fptr == (void(*)(void))&jl_array_ptr ||
         ((f_lib==NULL || (intptr_t)f_lib==2)
          && f_name && !strcmp(f_name,"jl_array_ptr"))) {
         assert(lrt->isPointerTy());
@@ -1104,10 +1090,10 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         assert(!(jl_is_expr(argi) && ((jl_expr_t*)argi)->head == amp_sym));
         jl_cgval_t ary = emit_expr(argi, ctx);
         JL_GC_POP();
-        return mark_or_box_ccall_result(builder.CreateBitCast(emit_arrayptr(boxed(ary, ctx)),lrt),
-                                        args[2], rt, static_rt, ctx);
+        return mark_or_box_ccall_result(builder.CreateBitCast(emit_arrayptr(boxed(ary, ctx)), lrt),
+                                        retboxed, args[2], rt, static_rt, ctx);
     }
-    if (fptr == (void *) &jl_value_ptr ||
+    if (fptr == (void(*)(void))&jl_value_ptr ||
         ((f_lib==NULL || (intptr_t)f_lib==2)
          && f_name && !strcmp(f_name,"jl_value_ptr"))) {
         assert(lrt->isPointerTy());
@@ -1125,22 +1111,35 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         }
         Value *ary;
         Type *largty;
-        if (addressOf)
-            largty = jl_pvalue_llvmt;
-        else
-            largty = julia_struct_to_llvm(tti);
-        if (largty == jl_pvalue_llvmt) {
-            ary = boxed(emit_expr(argi, ctx),ctx);
+        bool isboxed;
+        if (addressOf) {
+            largty = T_pjlvalue;
+            isboxed = true;
+        }
+        else {
+            largty = julia_struct_to_llvm(tti, &isboxed);
+        }
+        if (isboxed) {
+            ary = boxed(emit_expr(argi, ctx), ctx);
         }
         else {
             assert(!addressOf);
-            ary = emit_unbox(largty, emit_unboxed(argi, ctx), tti);
+            ary = emit_unbox(largty, emit_expr(argi, ctx), tti);
         }
         JL_GC_POP();
         return mark_or_box_ccall_result(builder.CreateBitCast(ary, lrt),
-                                        args[2], rt, static_rt, ctx);
+                                        retboxed, args[2], rt, static_rt, ctx);
     }
-    if (fptr == (void *) &jl_is_leaf_type ||
+    if (JL_CPU_WAKE_NOOP &&
+        (fptr == &jl_cpu_wake || ((!f_lib || (intptr_t)f_lib == 2) &&
+                                  f_name && !strcmp(f_name, "jl_cpu_wake")))) {
+        assert(lrt == T_void);
+        assert(!isVa);
+        assert(nargt == 0);
+        JL_GC_POP();
+        return ghostValue(jl_void_type);
+    }
+    if (fptr == (void(*)(void))&jl_is_leaf_type ||
         ((f_lib==NULL || (intptr_t)f_lib==2)
          && f_name && !strcmp(f_name, "jl_is_leaf_type"))) {
         assert(nargt == 1);
@@ -1150,17 +1149,16 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
             int isleaf = jl_is_leaf_type(jl_tparam0(ty));
             JL_GC_POP();
             return mark_or_box_ccall_result(ConstantInt::get(T_int32, isleaf),
-                    args[2], rt, static_rt, ctx);
+                    false, args[2], rt, static_rt, ctx);
         }
     }
-    if (fptr == (void*)&jl_function_ptr ||
+    if (fptr == (void(*)(void))&jl_function_ptr ||
         ((f_lib==NULL || (intptr_t)f_lib==2)
          && f_name && !strcmp(f_name, "jl_function_ptr"))) {
         assert(nargt == 3);
         jl_value_t *f = static_eval(args[4], ctx, false, false);
         jl_value_t *frt = expr_type(args[6], ctx);
-        if (f && jl_is_function(f) &&
-                (jl_is_type_type((jl_value_t*)frt) && !jl_has_typevars(jl_tparam0(frt)))) {
+        if (f && (jl_is_type_type((jl_value_t*)frt) && !jl_has_typevars(jl_tparam0(frt)))) {
             jl_value_t *fargt = static_eval(args[8], ctx, true, true);
             if (fargt) {
                 if (jl_is_tuple(fargt)) {
@@ -1184,7 +1182,7 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
                     emit_expr(args[8], ctx);
                     JL_GC_POP();
                     return mark_or_box_ccall_result(builder.CreateBitCast(llvmf, lrt),
-                                                    args[2], rt, static_rt, ctx);
+                                                    retboxed, args[2], rt, static_rt, ctx);
                 }
                 JL_CATCH {
                 }
@@ -1208,13 +1206,14 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
 
     std::vector<Type*> fargt(0);
     std::vector<Type*> fargt_sig(0);
+    std::vector<bool> fargt_isboxed(0);
     Type *fargt_vasig = NULL;
     std::vector<bool> inRegList(0);
     std::vector<bool> byRefList(0);
     attr_type attrs;
     Type *prt = NULL;
     int sret = 0;
-    std::string err_msg = generate_func_sig(&lrt, &prt, sret, fargt, fargt_sig, fargt_vasig,
+    std::string err_msg = generate_func_sig(&lrt, &prt, sret, fargt, fargt_isboxed, fargt_sig, fargt_vasig,
                                             inRegList, byRefList, attrs, rt, tt, (nargs - 3)/2);
     if (!err_msg.empty()) {
         JL_GC_POP();
@@ -1229,6 +1228,7 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
 
     // First, if the ABI requires us to provide the space for the return
     // argument, allocate the box and store that as the first argument type
+    bool sretboxed = false;
     if (sret) {
         jl_cgval_t sret_val = emit_new_struct(rt,1,NULL,ctx); // TODO: is it valid to be creating an incomplete type this way?
         assert(sret_val.typ != NULL && "Type was not concrete");
@@ -1236,19 +1236,17 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
             Value *mem = emit_static_alloca(lrt, ctx);
             builder.CreateStore(sret_val.V, mem);
             result = mem;
-            argvals[0] = result;
         }
         else {
-            // XXX: result needs a GC root here if result->getType() == jl_pvalue_llvmt
+            // XXX: result needs a GC root here if result->getType() == T_pjlvalue
             result = sret_val.V;
-            argvals[0] = builder.CreateBitCast(result, fargt_sig.at(0));
         }
+        argvals[0] = builder.CreateBitCast(result, fargt_sig.at(0));
+        sretboxed = sret_val.isboxed;
     }
 
-    // save argument depth until after we're done emitting arguments
-    int last_depth = ctx->gc.argDepth;
-
     // number of parameters to the c function
+    jl_cgval_t *argv = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * (nargs - 3)/2);
     for(i = 4; i < nargs + 1; i += 2) {
         // Current C function parameter
         size_t ai = (i - 4) / 2;
@@ -1264,29 +1262,32 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         }
 
         Type *largty; // LLVM type of the current parameter
+        bool toboxed;
         jl_value_t *jargty; // Julia type of the current parameter
         bool byRef, inReg; // Argument attributes
         if (isVa && ai >= nargt - 1) {
             largty = fargt.at(nargt - 1);
+            toboxed = fargt_isboxed.at(nargt - 1);
             jargty = jl_tparam0(jl_svecref(tt, nargt - 1));
             byRef = byRefList.at(nargt - 1);
             inReg = inRegList.at(nargt - 1);
         }
         else {
             largty = fargt.at(ai);
+            toboxed = fargt_isboxed.at(ai);
             jargty = jl_svecref(tt, ai);
             byRef = byRefList.at(ai);
             inReg = inRegList.at(ai);
         }
 
-        jl_cgval_t arg;
-        bool needroot = false;
+        jl_cgval_t &arg = argv[ai];
+        arg = emit_expr((jl_value_t*)argi, ctx);
         if (jl_is_abstract_ref_type(jargty)) {
             if (addressOf) {
+                JL_GC_POP();
                 emit_error("ccall: & on a Ref{T} argument is invalid", ctx);
                 return jl_cgval_t();
             }
-            arg = emit_unboxed((jl_value_t*)argi, ctx);
             if (!jl_is_cpointer_type(arg.typ)) {
                 emit_cpointercheck(arg, "ccall: argument to Ref{T} is not a pointer", ctx);
                 arg.typ = (jl_value_t*)jl_voidpointer_type;
@@ -1294,22 +1295,9 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
             }
             jargty = (jl_value_t*)jl_voidpointer_type;
         }
-        else if (largty == jl_pvalue_llvmt || largty->isStructTy()) {
-            arg = emit_expr(argi, ctx, true);
-            if (largty == jl_pvalue_llvmt && !arg.isboxed) {
-                needroot = true;
-            }
-        }
-        else {
-            arg = emit_unboxed(argi, ctx);
-        }
 
-        Value *v = julia_to_native(largty, jargty, arg, addressOf, byRef, inReg,
+        Value *v = julia_to_native(largty, toboxed, jargty, arg, addressOf, byRef, inReg,
                     need_private_copy(jargty, byRef), false, ai + 1, ctx, &needStackRestore);
-        // make sure args are rooted
-        if (largty == jl_pvalue_llvmt && (needroot || might_need_root(argi))) {
-            make_gcroot(v, ctx);
-        }
         bool issigned = jl_signed_type && jl_subtype(jargty, (jl_value_t*)jl_signed_type, 0);
         argvals[ai + sret] = llvm_type_rewrite(v, largty,
                 ai + sret < fargt_sig.size() ? fargt_sig.at(ai + sret) : fargt_vasig,
@@ -1330,7 +1318,7 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     }
     else if (fptr != NULL) {
         Type *funcptype = PointerType::get(functype,0);
-        llvmf = literal_static_pointer_val(fptr, funcptype);
+        llvmf = literal_static_pointer_val((void*)(uintptr_t)fptr, funcptype);
         if (imaging_mode)
             jl_printf(JL_STDERR,"WARNING: literal address used in ccall for %s; code cannot be statically compiled\n", f_name);
     }
@@ -1342,7 +1330,7 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
             llvmf = runtime_sym_lookup(funcptype, f_lib, f_name, ctx);
         }
         else {
-            void *symaddr = jl_dlsym_e(get_library(f_lib), f_name);
+            void *symaddr = jl_dlsym_e(jl_get_library(f_lib), f_name);
             if (symaddr == NULL) {
                 JL_GC_POP();
                 std::stringstream msg;
@@ -1365,17 +1353,22 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     }
 
     if (needStackRestore) {
-        stacksave = CallInst::Create(Intrinsic::getDeclaration(jl_Module,
-                                                               Intrinsic::stacksave));
-        if (savespot)
-            instList.insertAfter((Instruction*)savespot, (Instruction*)stacksave);
+        stacksave = CallInst::Create(prepare_call(Intrinsic::getDeclaration(builtins_module,
+                                                               Intrinsic::stacksave)));
+        if (savespot) {
+#ifdef LLVM38
+                instList.insertAfter(savespot->getIterator(), (Instruction*)stacksave);
+#else
+                instList.insertAfter((Instruction*)savespot, (Instruction*)stacksave);
+#endif
+        }
         else
             instList.push_front((Instruction*)stacksave);
     }
 
     //llvmf->dump();
-    //for (std::vector<Value *>::iterator it = argvals.begin() ; it != argvals.end(); ++it)
-    //    (*it)->dump();
+    //for (int i = 0; i < (nargs - 3) / 2 + sret; ++i)
+    //    argvals[i]->dump();
 
     // the actual call
     Value *ret = builder.CreateCall(prepare_call(llvmf),
@@ -1388,33 +1381,46 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         result = ret;
     if (needStackRestore) {
         assert(stacksave != NULL);
-        builder.CreateCall(Intrinsic::getDeclaration(jl_Module,
-                                                     Intrinsic::stackrestore),
+        builder.CreateCall(prepare_call(
+            Intrinsic::getDeclaration(builtins_module,
+                                                     Intrinsic::stackrestore)),
                            stacksave);
     }
-    ctx->gc.argDepth = last_depth;
     if (0) { // Enable this to turn on SSPREQ (-fstack-protector) on the function containing this ccall
         ctx->f->addFnAttr(Attribute::StackProtectReq);
     }
 
+    // after the ccall itself, mark fake uses of all of the arguments to ensure the were live,
+    // and run over the gcroot list and make give them a `mark_gc_use`
+    for(i = 4; i < nargs + 1; i += 2) {
+        // Current C function parameter
+        size_t ai = (i - 4) / 2;
+        mark_gc_use(argv[ai]);
+
+        // Julia (expression) value of current parameter gcroot
+        jl_value_t *argi = args[i + 1];
+        if (jl_is_long(argi)) continue;
+        jl_cgval_t arg = emit_expr(argi, ctx);
+        mark_gc_use(arg);
+    }
+
     JL_GC_POP();
     // Finally we need to box the result into julia type
     // However, if we have already created a box for the return
     // type because the ABI required us to pass a pointer (sret),
     // then we do not need to do this.
     if (!sret) {
-        Type *jlrt = julia_type_to_llvm(rt);
+        Type *jlrt = julia_type_to_llvm(rt, &retboxed); // compute the real "julian" return type and update retboxed
         if (type_is_ghost(jlrt)) {
             return ghostValue(rt);
         }
-        else if (lrt->isStructTy() && jlrt == jl_pvalue_llvmt) {
+        else if (lrt->isStructTy() && retboxed) {
             assert(jl_is_structtype(rt));
             jl_cgval_t newst = emit_new_struct(rt, 1, NULL, ctx); // emit a new, empty struct
             assert(newst.typ != NULL && "Type was not concrete");
             assert(newst.isboxed);
             // copy the data from the return value to the new struct
-            // julia gc is aligned 16, otherwise use default alignment for alloca pointers
-            builder.CreateAlignedStore(result, builder.CreateBitCast(newst.V, prt->getPointerTo()), newst.V->getType() == jl_pvalue_llvmt ? 16 : 0);
+            builder.CreateAlignedStore(result, builder.CreateBitCast(newst.V, prt->getPointerTo()), 16); // julia gc is aligned 16
             return newst;
         }
         else if (jlrt != prt) {
@@ -1423,9 +1429,10 @@ static jl_cgval_t emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
         }
     }
     else {
-        if (result->getType() != jl_pvalue_llvmt)
+        retboxed = sretboxed;
+        if (!retboxed)
             result = builder.CreateLoad(result); // something alloca'd above
     }
 
-    return mark_or_box_ccall_result(result, args[2], rt, static_rt, ctx);
+    return mark_or_box_ccall_result(result, retboxed, args[2], rt, static_rt, ctx);
 }
diff --git a/src/ccalltest.c b/src/ccalltest.c
new file mode 100644
index 0000000000000..0999e522ebc18
--- /dev/null
+++ b/src/ccalltest.c
@@ -0,0 +1,375 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <complex.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include "../src/support/platform.h"
+#include "../src/support/dtypes.h"
+
+#ifdef _P64
+#define jint int64_t
+#define PRIjint PRId64
+#else
+#define jint int32_t
+#define PRIjint PRId32
+#endif
+
+int verbose = 1;
+
+
+//////////////////////////////////
+// Test for proper argument register truncation
+
+int xs[300] = {0,0,0,1,0};
+
+//int testUcharX(unsigned char x);
+#ifdef _COMPILER_MICROSOFT_
+int __declspec(noinline)
+#else
+int __attribute__((noinline))
+#endif
+JL_DLLEXPORT testUcharX(unsigned char x) {
+    return xs[x];
+}
+
+
+//////////////////////////////////
+// Tests for passing and returning Structs
+
+// Complex-like data types
+typedef struct {
+    jint real;
+    jint imag;
+} complex_t;
+
+JL_DLLEXPORT complex_t ctest(complex_t a) {
+    a.real += 1;
+    a.imag -= 2;
+    return a;
+}
+
+JL_DLLEXPORT complex double cgtest(complex double a) {
+    //Unpack a ComplexPair{Float64} struct
+    if (verbose) fprintf(stderr,"%g + %g i\n", creal(a), cimag(a));
+    a += 1 - (2.0*I);
+    return a;
+}
+
+JL_DLLEXPORT complex double *cgptest(complex double *a) {
+    //Unpack a ComplexPair{Float64} struct
+    if (verbose) fprintf(stderr,"%g + %g i\n", creal(*a), cimag(*a));
+    *a += 1 - (2.0*I);
+    return a;
+}
+
+JL_DLLEXPORT complex float cftest(complex float a) {
+    //Unpack a ComplexPair{Float32} struct
+    if (verbose) fprintf(stderr,"%g + %g i\n", creal(a), cimag(a));
+    a += 1 - (2.0*I);
+    return a;
+}
+
+JL_DLLEXPORT complex float *cfptest(complex float *a) {
+    //Unpack a ComplexPair{Float64} struct
+    if (verbose) fprintf(stderr,"%g + %g i\n", creal(*a), cimag(*a));
+    *a += 1 - (2.0*I);
+    return a;
+}
+
+JL_DLLEXPORT complex_t *cptest(complex_t *a) {
+    //Unpack a ComplexPair{Int} struct pointer
+    if (verbose) fprintf(stderr,"%" PRIjint " + %" PRIjint " i\n", a->real, a->imag);
+    a->real += 1;
+    a->imag -= 2;
+    return a;
+}
+
+JL_DLLEXPORT complex_t *cptest_static(complex_t *a) {
+    complex_t *b = (complex_t*)malloc(sizeof(complex_t));
+    b->real = a->real;
+    b->imag = a->imag;
+    return b;
+}
+
+// Various sized data types
+typedef struct {
+    float x;
+    double y;
+} struct1;
+
+typedef struct {
+    struct { int32_t x; } x;
+    struct { int32_t y; } y;
+} struct2a;
+
+typedef struct {
+    int32_t x;
+    int32_t y;
+} struct2b;
+
+typedef struct {
+    struct { int64_t x; } x;
+    struct { int64_t y; } y;
+} struct3a;
+
+typedef struct {
+    int64_t x;
+    int64_t y;
+} struct3b;
+
+typedef struct {
+    int32_t x;
+    int32_t y;
+    int32_t z;
+} struct4;
+
+typedef struct {
+    int32_t x;
+    int32_t y;
+    int32_t z;
+    int32_t a;
+} struct5;
+
+typedef struct {
+    int64_t x;
+    int64_t y;
+    int64_t z;
+} struct6;
+
+typedef struct {
+    int64_t x;
+    char y;
+} struct7;
+
+typedef struct {
+    int32_t x;
+    char y;
+} struct8;
+
+typedef struct {
+    int32_t x;
+    int16_t y;
+} struct9;
+
+typedef struct {
+    char x;
+    char y;
+    char z;
+    char a;
+} struct10;
+
+typedef struct {
+    complex float x;
+} struct11;
+
+typedef struct {
+    complex float x;
+    complex float y;
+} struct12;
+
+typedef struct {
+    complex double x;
+} struct13;
+
+typedef struct {
+    float x;
+    float y;
+} struct14;
+
+typedef struct {
+    double x;
+    double y;
+} struct15;
+
+typedef struct {
+    float x,y,z;
+    double a,b,c;
+} struct16;
+
+typedef struct {
+    jint x;
+    jint y;
+    char z;
+} struct_big;
+
+JL_DLLEXPORT struct1 test_1(struct1 a, float b) {
+    //Unpack a "small" struct { float, double }
+    if (verbose) fprintf(stderr,"%g + %g i & %g\n", a.x, a.y, b);
+    a.x += b * 1;
+    a.y -= b * 2;
+    return a;
+}
+
+JL_DLLEXPORT struct2a test_2a(struct2a a, int32_t b) {
+    //Unpack a ComplexPair{Int32} struct
+    if (verbose) fprintf(stderr,"%" PRId32 " + %" PRId32 " i & %" PRId32 "\n", a.x.x, a.y.y, b);
+    a.x.x += b*1;
+    a.y.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct2b test_2b(struct2b a, int32_t b) {
+    //Unpack a ComplexPair{Int32} struct
+    if (verbose) fprintf(stderr,"%" PRId32 " + %" PRId32 " i & %" PRId32 "\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct3a test_3a(struct3a a, int64_t b) {
+    //Unpack a ComplexPair{Int64} struct
+    if (verbose) fprintf(stderr,"%" PRId64 " + %" PRId64 " i & %" PRId64 "\n", a.x.x, a.y.y, b);
+    a.x.x += b*1;
+    a.y.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct3b test_3b(struct3b a, int64_t b) {
+    //Unpack a ComplexPair{Int64} struct
+    if (verbose) fprintf(stderr,"%" PRId64 " + %" PRId64 " i & %" PRId64 "\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct4 test_4(struct4 a, int32_t b) {
+    if (verbose) fprintf(stderr,"%" PRId32 ",%" PRId32 ",%" PRId32 " & %" PRId32 "\n", a.x, a.y, a.z, b);
+    a.x += b*1;
+    a.y -= b*2;
+    a.z += b*3;
+    return a;
+}
+
+JL_DLLEXPORT struct5 test_5(struct5 a, int32_t b) {
+    if (verbose) fprintf(stderr,"%" PRId32 ",%" PRId32 ",%" PRId32 ",%" PRId32 " & %" PRId32 "\n", a.x, a.y, a.z, a.a, b);
+    a.x += b*1;
+    a.y -= b*2;
+    a.z += b*3;
+    a.a -= b*4;
+
+    return a;
+}
+
+JL_DLLEXPORT struct6 test_6(struct6 a, int64_t b) {
+    if (verbose) fprintf(stderr,"%" PRId64 ",%" PRId64 ",%" PRId64 " & %" PRId64 "\n", a.x, a.y, a.z, b);
+    a.x += b*1;
+    a.y -= b*2;
+    a.z += b*3;
+    return a;
+}
+
+JL_DLLEXPORT struct7 test_7(struct7 a, int8_t b) {
+    if (verbose) fprintf(stderr,"%" PRId64 ",%" PRId8 " & %" PRId8 "\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct8 test_8(struct8 a, int8_t b) {
+    if (verbose) fprintf(stderr,"%" PRId32 ",%" PRId8 " & %" PRId8 "\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct9 test_9(struct9 a, int16_t b) {
+    if (verbose) fprintf(stderr,"%" PRId32 ",%" PRId16 " & %" PRId16 "\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct10 test_10(struct10 a, int8_t b) {
+    if (verbose) fprintf(stderr,"%" PRId8 ",%" PRId8 ",%" PRId8 ",%" PRId8 " & %" PRId8 "\n", a.x, a.y, a.z, a.a, b);
+    a.x += b*1;
+    a.y -= b*2;
+    a.z += b*3;
+    a.a -= b*4;
+
+    return a;
+}
+
+JL_DLLEXPORT struct11 test_11(struct11 a, float b) {
+    //Unpack a nested ComplexPair{Float32} struct
+    if (verbose) fprintf(stderr,"%g + %g i & %g\n", creal(a.x), cimag(a.x), b);
+    a.x += b*1 - (b*2.0*I);
+    return a;
+}
+
+JL_DLLEXPORT struct12 test_12(struct12 a, float b) {
+    //Unpack two nested ComplexPair{Float32} structs
+    if (verbose) fprintf(stderr,"%g + %g i & %g + %g i & %g\n",
+                         creal(a.x), cimag(a.x), creal(a.y), cimag(a.y), b);
+    a.x += b*1 - (b*2.0*I);
+    a.y += b*3 - (b*4.0*I);
+    return a;
+}
+
+JL_DLLEXPORT struct13 test_13(struct13 a, double b) {
+    //Unpack a nested ComplexPair{Float64} struct
+    if (verbose) fprintf(stderr,"%g + %g i & %g\n", creal(a.x), cimag(a.x), b);
+    a.x += b*1 - (b*2.0*I);
+    return a;
+}
+
+JL_DLLEXPORT struct14 test_14(struct14 a, float b) {
+    //The C equivalent of a  ComplexPair{Float32} struct (but without special complex ABI)
+    if (verbose) fprintf(stderr,"%g + %g i & %g\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct15 test_15(struct15 a, double b) {
+    //The C equivalent of a  ComplexPair{Float64} struct (but without special complex ABI)
+    if (verbose) fprintf(stderr,"%g + %g i & %g\n", a.x, a.y, b);
+    a.x += b*1;
+    a.y -= b*2;
+    return a;
+}
+
+JL_DLLEXPORT struct16 test_16(struct16 a, float b) {
+    //Unpack a struct with non-obvious packing requirements
+    if (verbose) fprintf(stderr,"%g %g %g %g %g %g & %g\n", a.x, a.y, a.z, a.a, a.b, a.c, b);
+    a.x += b*1;
+    a.y -= b*2;
+    a.z += b*3;
+    a.a -= b*4;
+    a.b += b*5;
+    a.c -= b*6;
+    return a;
+}
+
+#define int128_t struct3b
+JL_DLLEXPORT int128_t test_128(int128_t a, int64_t b) {
+    //Unpack a Int128
+    if (verbose) fprintf(stderr,"0x%016" PRIx64 "%016" PRIx64 " & %" PRId64 "\n", a.y, a.x, b);
+    a.x += b*1;
+    if (a.x == 0)
+        a.y += b*1;
+    return a;
+}
+
+JL_DLLEXPORT struct_big test_big(struct_big a) {
+    //Unpack a "big" struct { int, int, char }
+    if (verbose) fprintf(stderr,"%" PRIjint " %" PRIjint " %c\n", a.x, a.y, a.z);
+    a.x += 1;
+    a.y -= 2;
+    a.z -= 'A';
+    return a;
+}
+
+
+//////////////////////////////////
+// Turn off verbose for automated tests, leave on for debugging
+
+JL_DLLEXPORT void set_verbose(int level) {
+    verbose = level;
+}
+
+JL_DLLEXPORT void *test_echo_p(void *p) {
+    return p;
+}
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
index c959d433e5ea8..3bc029997078d 100644
--- a/src/cgutils.cpp
+++ b/src/cgutils.cpp
@@ -1,114 +1,233 @@
 // This file is a part of Julia. License is MIT: http://julialang.org/license
 
+#include <iostream>
+
 // utility procedures used in code generation
 
-#if defined(USE_MCJIT) && defined(_OS_WINDOWS_)
 template<class T> // for GlobalObject's
-static T* addComdat(T *G)
+static T *addComdat(T *G)
 {
-    if (imaging_mode && (!G->isDeclarationForLinker())) {
+#if defined(_OS_WINDOWS_)
+    if (imaging_mode && !G->isDeclaration()) {
+#ifdef LLVM35
+        // Add comdat information to make MSVC link.exe happy
         Comdat *jl_Comdat = G->getParent()->getOrInsertComdat(G->getName());
         jl_Comdat->setSelectionKind(Comdat::NoDuplicates);
         G->setComdat(jl_Comdat);
+        // add __declspec(dllexport) to everything marked for export
+        if (G->getLinkage() == GlobalValue::ExternalLinkage)
+            G->setDLLStorageClass(GlobalValue::DLLExportStorageClass);
+#endif
     }
+#endif
     return G;
 }
-#else
-template<class T>
-static T* addComdat(T *G) { return G; }
-#endif
 
-static Instruction *tbaa_decorate(MDNode* md, Instruction* load_or_store)
+static Instruction *tbaa_decorate(MDNode *md, Instruction *load_or_store)
 {
     load_or_store->setMetadata( llvm::LLVMContext::MD_tbaa, md );
     return load_or_store;
 }
 
 // Fixing up references to other modules for MCJIT
+std::set<llvm::GlobalValue*> pending_globals;
 static GlobalVariable *prepare_global(GlobalVariable *G)
 {
-#ifdef USE_MCJIT
-    if (G->getParent() != jl_Module) {
-        GlobalVariable *gv = jl_Module->getGlobalVariable(G->getName());
-        if (!gv) {
-            gv = new GlobalVariable(*jl_Module, G->getType()->getElementType(),
-                                    G->isConstant(), GlobalVariable::ExternalLinkage,
-                                    NULL, G->getName());
-        }
-        return gv;
-    }
-#endif
+    pending_globals.insert(G);
     return G;
 }
 
-static llvm::Value *prepare_call(llvm::Value* Callee)
+static llvm::Value *prepare_call(llvm::Value *Callee)
 {
-#ifdef USE_MCJIT
     llvm::Function *F = dyn_cast<Function>(Callee);
     if (!F)
         return Callee;
-    if (F->getParent() != jl_Module) {
-        Function *ModuleF = jl_Module->getFunction(F->getName());
-        if (ModuleF) {
-            return ModuleF;
+    pending_globals.insert(F);
+    return Callee;
+}
+
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+static GlobalValue *realize_pending_global(Instruction *User, GlobalValue *G, std::map<llvm::Module*,llvm::GlobalValue*> &FixedGlobals)
+{
+    Function *UsedInHere = User->getParent()->getParent();
+    assert(UsedInHere);
+    Module *M = UsedInHere->getParent();
+    if (M == G->getParent() && M != builtins_module) { // can happen during bootstrap
+        //std::cout << "Skipping " << std::string(G->getName()) << " due to parentage" << std::endl;
+        return nullptr;
+    }
+    // If we come across a function that is still being constructed,
+    // this use needs to remain pending
+    if (!M || M == builtins_module) {
+        pending_globals.insert(G);
+        //std::cout << "Skipping " << std::string(G->getName()) << " due to construction" << std::endl;
+        return nullptr;
+    }
+    if (!FixedGlobals.count(M)) {
+        if (GlobalVariable *GV = dyn_cast<GlobalVariable>(G)) {
+            GlobalVariable *NewGV = M->getGlobalVariable(GV->getName());
+            if (!NewGV) {
+                NewGV = new GlobalVariable(*M, GV->getType()->getElementType(),
+                                        GV->isConstant(), GlobalVariable::ExternalLinkage,
+                                        NULL, GV->getName(), NULL, GV->getThreadLocalMode(),
+                                        GV->getType()->getAddressSpace());
+                NewGV->setUnnamedAddr(GV->hasUnnamedAddr());
+                // Move over initializer
+                if (GV->hasInitializer()) {
+                    NewGV->setInitializer(GV->getInitializer());
+                    GV->setInitializer(nullptr);
+                }
+            }
+            FixedGlobals[M] = NewGV;
         }
         else {
-            return Function::Create(F->getFunctionType(),
-                                    Function::ExternalLinkage,
-                                    F->getName(),
-                                    jl_Module);
+            Function *F = cast<Function>(G);
+            //std::cout << "Realizing " << std::string(F->getName()) << std::endl;
+            //if (!F->getParent()) {
+                //std::cout << "Skipping" << std::endl;
+            //    return nullptr;
+            //}
+            Function *NewF = nullptr;
+            if (!F->isDeclaration() && F->getParent() == builtins_module) {
+                // It's a definition. Actually move the function and create a
+                // declaration in the original module
+                NewF = F;
+                F->removeFromParent();
+                M->getFunctionList().push_back(F);
+                Function::Create(F->getFunctionType(),
+                    Function::ExternalLinkage,
+                    F->getName(),
+                    active_module);
+            }
+            else {
+                assert(F);
+                NewF = M->getFunction(F->getName());
+                if (!NewF) {
+                    NewF = Function::Create(F->getFunctionType(),
+                                Function::ExternalLinkage,
+                                F->getName(),
+                                M);
+                }
+            }
+            FixedGlobals[M] = NewF;
         }
     }
-#endif
-    return Callee;
+    return FixedGlobals[M];
 }
 
+struct ExprChain {
+    ConstantExpr *Expr;
+    unsigned OpNo;
+    struct ExprChain *Next;
+};
+
+static void handleUse(Use &Use1, llvm::GlobalValue *G,
+                      std::map<llvm::Module*, llvm::GlobalValue*> &FixedGlobals,
+                      struct ExprChain *Chain, struct ExprChain *ChainEnd)
+{
+    Instruction *User = dyn_cast<Instruction>(Use1.getUser());
+    if (!User) {
+        ConstantExpr *Expr = cast<ConstantExpr>(Use1.getUser());
+        Value::use_iterator UI2 = Expr->use_begin(), E2 = Expr->use_end();
+        for (; UI2 != E2;) {
+            Use &Use2 = *UI2;
+            ++UI2;
+            struct ExprChain NextChain;
+            NextChain.Expr = Expr;
+            NextChain.OpNo = Use1.getOperandNo();
+            NextChain.Next = nullptr;
+            if (ChainEnd)
+               ChainEnd->Next = &NextChain;
+            handleUse(Use2,G,FixedGlobals,Chain ? Chain : &NextChain,&NextChain);
+        }
+        return;
+    }
+    llvm::Constant *Replacement = realize_pending_global(User,G,FixedGlobals);
+    if (!Replacement)
+        return;
+    while (Chain) {
+        Replacement = Chain->Expr->getWithOperandReplaced(Chain->OpNo,Replacement);
+        Chain->Expr = cast<ConstantExpr>(Replacement);
+        Chain = Chain->Next;
+    }
+    Use1.set(Replacement);
+}
+
+// RAUW, but only for those users which live in a module, and create a module
+// specific copy
+static void realize_pending_globals()
+{
+    std::set<llvm::GlobalValue *> local_pending_globals;
+    std::swap(local_pending_globals,pending_globals);
+    std::map<llvm::Module*,llvm::GlobalValue*> FixedGlobals;
+    for (auto *G : local_pending_globals) {
+        Value::use_iterator UI = G->use_begin(), E = G->use_end();
+        for (; UI != E;)
+            handleUse(*(UI++),G,FixedGlobals,nullptr,nullptr);
+        FixedGlobals.clear();
+    }
+}
+
+static void realize_cycle(jl_cyclectx_t *cyclectx)
+{
+    // These need to be resolved together
+    for (auto *F : cyclectx->functions) {
+        F->removeFromParent();
+        active_module->getFunctionList().push_back(F);
+    }
+    for (auto *CU : cyclectx->CUs) {
+        NamedMDNode *NMD = active_module->getOrInsertNamedMetadata("llvm.dbg.cu");
+        NMD->addOperand(CU);
+    }
+}
+#endif
+
+template<typename T>
 #ifdef LLVM35
-static inline void add_named_global(GlobalObject *gv, void *addr)
+static inline void add_named_global(GlobalObject *gv, T *_addr, bool dllimport = true)
 #else
-static inline void add_named_global(GlobalValue *gv, void *addr)
+static inline void add_named_global(GlobalValue *gv, T *_addr, bool dllimport = true)
 #endif
 {
-#ifdef USE_MCJIT
-
+    // cast through integer to avoid c++ pedantic warning about casting between
+    // data and code pointers
+    void *addr = (void*)(uintptr_t)_addr;
+#ifdef LLVM34
     StringRef name = gv->getName();
 #ifdef _OS_WINDOWS_
     std::string imp_name;
-    // setting DLLEXPORT correctly only matters when building a binary
-    if (jl_generating_output()) {
+#endif
+#endif
+
+#ifdef _OS_WINDOWS_
+    // setting JL_DLLEXPORT correctly only matters when building a binary
+    if (dllimport && imaging_mode) {
+        assert(gv->getLinkage() == GlobalValue::ExternalLinkage);
+#ifdef LLVM35
         // add the __declspec(dllimport) attribute
         gv->setDLLStorageClass(GlobalValue::DLLImportStorageClass);
         // this will cause llvm to rename it, so we do the same
         imp_name = Twine("__imp_", name).str();
         name = StringRef(imp_name);
-        // __imp_ functions are jmp stubs (no additional work needed)
-        // __imp_ variables are indirection pointers, so use malloc to simulate that too
-        if (isa<GlobalVariable>(gv)) {
-            void** imp_addr = (void**)malloc(sizeof(void**));
-            *imp_addr = addr;
-            addr = (void*)imp_addr;
-        }
-    }
+#else
+        gv->setLinkage(GlobalValue::DLLImportLinkage);
 #endif
-    addComdat(gv);
-    sys::DynamicLibrary::AddSymbol(name, addr);
-
-#else // USE_MCJIT
-
-#ifdef _OS_WINDOWS_
-    // setting DLLEXPORT correctly only matters when building a binary
-    if (jl_generating_output()) {
-        if (gv->getLinkage() == GlobalValue::ExternalLinkage)
-            gv->setLinkage(GlobalValue::DLLImportLinkage);
-#ifdef _P64
-        // the following is correct by observation,
-        // as long as everything stays within a 32-bit offset :/
-        void** imp_addr = (void**)malloc(sizeof(void**));
+#if defined(_P64) || defined(LLVM35)
+        // __imp_ variables are indirection pointers, so use malloc to simulate that
+        void **imp_addr = (void**)malloc(sizeof(void**));
         *imp_addr = addr;
         addr = (void*)imp_addr;
 #endif
     }
 #endif // _OS_WINDOWS_
+
+#ifdef USE_ORCJIT
+    addComdat(gv);
+    jl_ExecutionEngine->addGlobalMapping(name, addr);
+#elif defined(USE_MCJIT)
+    addComdat(gv);
+    sys::DynamicLibrary::AddSymbol(name, addr);
+#else // USE_MCJIT
     jl_ExecutionEngine->addGlobalMapping(gv, addr);
 #endif // USE_MCJIT
 }
@@ -120,6 +239,21 @@ extern "C" {
     extern int jl_in_inference;
 }
 
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+static GlobalVariable *global_proto(GlobalVariable *G)
+{
+    GlobalVariable *proto = new GlobalVariable(G->getType()->getElementType(),
+            G->isConstant(), GlobalVariable::ExternalLinkage,
+            NULL, G->getName(), G->getThreadLocalMode());
+    return proto;
+}
+#else
+static GlobalVariable *global_proto(GlobalVariable *G)
+{
+    return G;
+}
+#endif
+
 static GlobalVariable *stringConst(const std::string &txt)
 {
     GlobalVariable *gv = stringConstants[txt];
@@ -133,7 +267,7 @@ static GlobalVariable *stringConst(const std::string &txt)
         ssno << strno;
         vname += "_j_str";
         vname += ssno.str();
-        gv = new GlobalVariable(*jl_Module,
+        gv = new GlobalVariable(*active_module,
                                 ArrayType::get(T_int8, txt.length()+1),
                                 true,
                                 imaging_mode ? GlobalVariable::PrivateLinkage : GlobalVariable::ExternalLinkage,
@@ -143,20 +277,48 @@ static GlobalVariable *stringConst(const std::string &txt)
                                                        txt.length()+1)),
                                 vname);
         gv->setUnnamedAddr(true);
+        gv = imaging_mode ? gv : prepare_global(global_proto(gv));
         stringConstants[txt] = gv;
         strno++;
     }
+    else {
+        prepare_global(gv);
+    }
     return gv;
 
 }
 
 // --- Shadow module handling ---
 
-typedef struct {Value* gv; int32_t index;} jl_value_llvm; // uses 1-based indexing
+typedef struct {Value *gv; int32_t index;} jl_value_llvm; // uses 1-based indexing
 static std::map<void*, jl_value_llvm> jl_value_to_llvm;
-DLLEXPORT std::map<Value *, void*> jl_llvm_to_jl_value;
+JL_DLLEXPORT std::map<Value *, void*> jl_llvm_to_jl_value;
+
+// In imaging mode, cache a fast mapping of Function * to code address
+// because this is queried in the hot path
+static std::map<Function *, uint64_t> emitted_function_symtab;
+
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+static Function *function_proto(Function *F)
+{
+    Function *NewF = Function::Create(F->getFunctionType(),
+                                      Function::ExternalLinkage,
+                                      F->getName());
+    NewF->setAttributes(AttributeSet());
+
+    // FunctionType does not include any attributes. Copy them over manually
+    // as codegen may make decisions based on the presence of certain attributes
+    NewF->copyAttributesFrom(F);
+
+#ifdef LLVM37
+    // Declarations are not allowed to have personality routines, but
+    // copyAttributesFrom sets them anyway, so clear them again manually
+    NewF->setPersonalityFn(nullptr);
+#endif
+
+    return NewF;
+}
 
-#ifdef USE_MCJIT
 class FunctionMover : public ValueMaterializer
 {
 public:
@@ -164,7 +326,6 @@ class FunctionMover : public ValueMaterializer
         ValueMaterializer(), VMap(), destModule(dest), srcModule(src),
         LazyFunctions(0)
     {
-
     }
     ValueToValueMapTy VMap;
     llvm::Module *destModule;
@@ -173,6 +334,7 @@ class FunctionMover : public ValueMaterializer
 
     Function *CloneFunctionProto(Function *F)
     {
+        assert(!F->isDeclaration());
         Function *NewF = Function::Create(F->getFunctionType(),
                                           Function::ExternalLinkage,
                                           F->getName(),
@@ -190,7 +352,7 @@ class FunctionMover : public ValueMaterializer
         Function::arg_iterator DestI = NewF->arg_begin();
         for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) {
             DestI->setName(I->getName());    // Copy the name over...
-            VMap[I] = DestI++;        // Add mapping to VMap
+            VMap[&*I] = &*(DestI++);        // Add mapping to VMap
         }
 
     #ifdef LLVM36
@@ -219,7 +381,21 @@ class FunctionMover : public ValueMaterializer
         }
     }
 
+    Value *InjectFunctionProto(Function *F)
+    {
+        Function *NewF = destModule->getFunction(F->getName());
+        if (!NewF) {
+            NewF = function_proto(F);
+            destModule->getFunctionList().push_back(NewF);
+        }
+        return NewF;
+    }
+
+#ifdef LLVM38
+    virtual Value *materializeDeclFor(Value *V)
+#else
     virtual Value *materializeValueFor (Value *V)
+#endif
     {
         Function *F = dyn_cast<Function>(V);
         if (F) {
@@ -233,16 +409,20 @@ class FunctionMover : public ValueMaterializer
                 if (shadow != NULL && !shadow->isDeclaration()) {
                     // Not truly external
                     // Check whether we already emitted it once
-                    uint64_t addr = jl_mcjmm->getSymbolAddress(F->getName());
-                    if (addr == 0) {
-                        Function *oldF = destModule->getFunction(F->getName());
-                        if (oldF)
-                            return oldF;
-                        return CloneFunctionProto(F);
-                    }
-                    else {
-                        return destModule->getOrInsertFunction(F->getName(),F->getFunctionType());
-                    }
+                    if (emitted_function_symtab.find(shadow) != emitted_function_symtab.end())
+                        return InjectFunctionProto(F);
+
+                    Function *oldF = destModule->getFunction(F->getName());
+                    if (oldF)
+                        return oldF;
+
+#ifndef USE_ORCJIT
+                    // Also check if this function is pending in any other module
+                    if (jl_ExecutionEngine->FindFunctionNamed(F->getName().data()))
+                        return InjectFunctionProto(F);
+#endif
+
+                    return CloneFunctionProto(shadow);
                 }
                 else if (!F->isDeclaration()) {
                     return CloneFunctionProto(F);
@@ -251,7 +431,7 @@ class FunctionMover : public ValueMaterializer
             // Still a declaration and still in a different module
             if (F->isDeclaration() && F->getParent() != destModule) {
                 // Create forward declaration in current module
-                return destModule->getOrInsertFunction(F->getName(),F->getFunctionType());
+                return InjectFunctionProto(F);
             }
         }
         else if (isa<GlobalVariable>(V)) {
@@ -279,7 +459,7 @@ class FunctionMover : public ValueMaterializer
             std::map<Value*, void *>::iterator it;
             it = jl_llvm_to_jl_value.find(GV);
             if (it != jl_llvm_to_jl_value.end()) {
-                newGV->setInitializer(Constant::getIntegerValue(GV->getType()->getElementType(),APInt(sizeof(void*)*8,(ptrint_t)it->second)));
+                newGV->setInitializer(Constant::getIntegerValue(GV->getType()->getElementType(),APInt(sizeof(void*)*8,(intptr_t)it->second)));
                 newGV->setConstant(true);
             }
             else if (GV->hasInitializer()) {
@@ -291,6 +471,11 @@ class FunctionMover : public ValueMaterializer
         return NULL;
     };
 };
+#else
+static Function *function_proto(Function *F)
+{
+    return F;
+}
 #endif
 
 #ifdef LLVM37
@@ -299,8 +484,13 @@ static DIType *julia_type_to_di(jl_value_t *jt, DIBuilder *dbuilder, bool isboxe
 static DIType julia_type_to_di(jl_value_t *jt, DIBuilder *dbuilder, bool isboxed = false)
 #endif
 {
-    if (jl_is_abstracttype(jt) || !jl_is_datatype(jt) || !jl_isbits(jt) || isboxed)
+    if (isboxed)
+        return jl_pvalue_dillvmt;
+    if (jl_is_abstracttype(jt) || jl_is_uniontype(jt) || jl_is_array_type(jt))
+        return jl_pvalue_dillvmt;
+    if (jl_is_typector(jt) || jl_is_typevar(jt))
         return jl_pvalue_dillvmt;
+    assert(jl_is_datatype(jt));
     jl_datatype_t *jdt = (jl_datatype_t*)jt;
     if (jdt->ditype != NULL) {
 #ifdef LLVM37
@@ -310,24 +500,53 @@ static DIType julia_type_to_di(jl_value_t *jt, DIBuilder *dbuilder, bool isboxed
 #endif
     }
     if (jl_is_bitstype(jt)) {
+        uint64_t SizeInBits = jdt == jl_bool_type ? 1 : 8*jdt->size;
     #ifdef LLVM37
-        llvm::DIType *t = dbuilder->createBasicType(jdt->name->name->name,jdt->size,jdt->alignment,llvm::dwarf::DW_ATE_unsigned);
+        llvm::DIType *t = dbuilder->createBasicType(jl_symbol_name(jdt->name->name),SizeInBits,8*jdt->alignment,llvm::dwarf::DW_ATE_unsigned);
         jdt->ditype = t;
         return t;
     #else
-        DIType t = dbuilder->createBasicType(jdt->name->name->name,jdt->size,jdt->alignment,llvm::dwarf::DW_ATE_unsigned);
+        DIType t = dbuilder->createBasicType(jl_symbol_name(jdt->name->name),SizeInBits,8*jdt->alignment,llvm::dwarf::DW_ATE_unsigned);
         MDNode *M = t;
         jdt->ditype = M;
         return t;
     #endif
     }
+    #ifdef LLVM37
+    else if (jl_is_tuple_type(jt) || jl_is_structtype(jt)) {
+        jl_datatype_t *jst = (jl_datatype_t*)jt;
+        size_t ntypes = jl_datatype_nfields(jst);
+        llvm::DICompositeType *ct = dbuilder->createStructType(
+            NULL,                       // Scope
+            jl_symbol_name(jdt->name->name),      // Name
+            NULL,                       // File
+            0,                          // LineNumber
+            8*jdt->size,                // SizeInBits
+            8*jdt->alignment,           // AlignmentInBits
+            0,                          // Flags
+            NULL,                       // DerivedFrom
+            DINodeArray(),              // Elements
+            dwarf::DW_LANG_Julia        // RuntimeLanguage
+            );
+        jdt->ditype = ct;
+        std::vector<llvm::Metadata*> Elements;
+        for(unsigned i = 0; i < ntypes; i++)
+            Elements.push_back(julia_type_to_di(jl_svecref(jst->types,i),dbuilder,false));
+        dbuilder->replaceArrays(ct, dbuilder->getOrCreateArray(ArrayRef<Metadata*>(Elements)));
+        return ct;
+    }
+    else {
+        jdt->ditype = dbuilder->createTypedef(jl_pvalue_dillvmt, jl_symbol_name(jdt->name->name), NULL, 0, NULL);
+        return (llvm::DIType*)jdt->ditype;
+    }
+    #endif
     // TODO: Fixme
     return jl_pvalue_dillvmt;
 }
 
 // --- emitting pointers directly into code ---
 
-static Value *literal_static_pointer_val(void *p, Type *t)
+static Value *literal_static_pointer_val(const void *p, Type *t)
 {
     // this function will emit a static pointer into the generated code
     // the generated code will only be valid during the current session,
@@ -340,6 +559,7 @@ static Value *literal_static_pointer_val(void *p, Type *t)
 }
 
 static std::vector<Constant*> jl_sysimg_gvars;
+static std::vector<Constant*> jl_sysimg_fvars;
 
 extern "C" int32_t jl_get_llvm_gv(jl_value_t *p)
 {
@@ -357,21 +577,37 @@ extern "C" {
 }
 #endif
 
-static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap, const char *sysimg_data, size_t sysimg_len)
+static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap,
+                                   const char *sysimg_data, size_t sysimg_len)
 {
-    ArrayType *atype = ArrayType::get(T_psize, jl_sysimg_gvars.size());
+    ArrayType *gvars_type = ArrayType::get(T_psize, jl_sysimg_gvars.size());
     addComdat(new GlobalVariable(*mod,
-                                 atype,
+                                 gvars_type,
                                  true,
                                  GlobalVariable::ExternalLinkage,
-                                 MapValue(ConstantArray::get(atype, ArrayRef<Constant*>(jl_sysimg_gvars)), VMap),
+                                 MapValue(ConstantArray::get(gvars_type, ArrayRef<Constant*>(jl_sysimg_gvars)), VMap),
                                  "jl_sysimg_gvars"));
+    ArrayType *fvars_type = ArrayType::get(T_pvoidfunc, jl_sysimg_fvars.size());
+    addComdat(new GlobalVariable(*mod,
+                                 fvars_type,
+                                 true,
+                                 GlobalVariable::ExternalLinkage,
+                                 MapValue(ConstantArray::get(fvars_type, ArrayRef<Constant*>(jl_sysimg_fvars)), VMap),
+                                 "jl_sysimg_fvars"));
     addComdat(new GlobalVariable(*mod,
                                  T_size,
                                  true,
                                  GlobalVariable::ExternalLinkage,
                                  ConstantInt::get(T_size,globalUnique+1),
                                  "jl_globalUnique"));
+#ifdef JULIA_ENABLE_THREADING
+    addComdat(new GlobalVariable(*mod,
+                                 T_size,
+                                 true,
+                                 GlobalVariable::ExternalLinkage,
+                                 ConstantInt::get(T_size, jltls_states_func_idx),
+                                 "jl_ptls_states_getter_idx"));
+#endif
 
     Constant *feature_string = ConstantDataArray::getString(jl_LLVMContext, jl_options.cpu_target);
     addComdat(new GlobalVariable(*mod,
@@ -408,13 +644,21 @@ static void jl_gen_llvm_globaldata(llvm::Module *mod, ValueToValueMapTy &VMap, c
     }
 }
 
-static void jl_dump_shadow(char *fname, int jit_model, const char *sysimg_data, size_t sysimg_len, bool dump_as_bc)
+static void jl_dump_shadow(char *fname, int jit_model, const char *sysimg_data, size_t sysimg_len,
+                           bool dump_as_bc)
 {
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+    realize_pending_globals();
+#endif
+#ifdef JL_DEBUG_BUILD
+    verifyModule(*shadow_module);
+#endif
+
 #ifdef LLVM36
     std::error_code err;
     StringRef fname_ref = StringRef(fname);
     raw_fd_ostream OS(fname_ref, err, sys::fs::F_None);
-#elif  LLVM35
+#elif defined(LLVM35)
     std::string err;
     raw_fd_ostream OS(fname, err, sys::fs::F_None);
 #else
@@ -463,24 +707,28 @@ static void jl_dump_shadow(char *fname, int jit_model, const char *sysimg_data,
         CodeGenOpt::Aggressive // -O3
         ));
 
+#ifdef LLVM38
+    legacy::PassManager PM;
+#else
     PassManager PM;
-    if (!dump_as_bc) {
+#endif
 #ifndef LLVM37
-        PM.add(new TargetLibraryInfo(Triple(TM->getTargetTriple())));
+    PM.add(new TargetLibraryInfo(Triple(TM->getTargetTriple())));
 #else
-        PM.add(new TargetLibraryInfoWrapperPass(Triple(TM->getTargetTriple())));
+    PM.add(new TargetLibraryInfoWrapperPass(Triple(TM->getTargetTriple())));
 #endif
 #ifdef LLVM37
-    // No DataLayout pass needed anymore.
-#elif LLVM36
-        PM.add(new DataLayoutPass());
-#elif LLVM35
-        PM.add(new DataLayoutPass(*jl_ExecutionEngine->getDataLayout()));
+// No DataLayout pass needed anymore.
+#elif defined(LLVM36)
+    PM.add(new DataLayoutPass());
+#elif defined(LLVM35)
+    PM.add(new DataLayoutPass(*jl_ExecutionEngine->getDataLayout()));
 #else
-        PM.add(new DataLayout(*jl_ExecutionEngine->getDataLayout()));
+    PM.add(new DataLayout(*jl_ExecutionEngine->getDataLayout()));
 #endif
 
-
+    addOptimizationPasses(&PM);
+    if (!dump_as_bc) {
         if (TM->addPassesToEmitFile(PM, FOS, TargetMachine::CGFT_ObjectFile, false)) {
             jl_error("Could not generate obj file for this target");
         }
@@ -488,7 +736,11 @@ static void jl_dump_shadow(char *fname, int jit_model, const char *sysimg_data,
 
     // now copy the module, since PM.run may modify it
     ValueToValueMapTy VMap;
+#ifdef LLVM38
+    Module *clone = CloneModule(shadow_module, VMap).release();
+#else
     Module *clone = CloneModule(shadow_module, VMap);
+#endif
 #ifdef LLVM37
     // Reset the target triple to make sure it matches the new target machine
     clone->setTargetTriple(TM->getTargetTriple().str());
@@ -503,20 +755,20 @@ static void jl_dump_shadow(char *fname, int jit_model, const char *sysimg_data,
     jl_gen_llvm_globaldata(clone, VMap, sysimg_data, sysimg_len);
 
     // do the actual work
-    if (!dump_as_bc)
-        PM.run(*clone);
-    else
+    finalize_gc_frame(clone);
+    PM.run(*clone);
+    if (dump_as_bc)
         WriteBitcodeToFile(clone, FOS);
     delete clone;
 }
 
-static int32_t jl_assign_functionID(Function *functionObject)
+static int32_t jl_assign_functionID(Function *functionObject, int specsig)
 {
     // give the function an index in the constant lookup table
     if (!imaging_mode)
         return 0;
-    jl_sysimg_gvars.push_back(ConstantExpr::getBitCast(functionObject,T_psize));
-    return jl_sysimg_gvars.size();
+    jl_sysimg_fvars.push_back(ConstantExpr::getBitCast(functionObject, T_pvoidfunc));
+    return jl_sysimg_fvars.size();
 }
 
 static Value *julia_gv(const char *cname, void *addr)
@@ -526,14 +778,14 @@ static Value *julia_gv(const char *cname, void *addr)
     // first see if there already is a GlobalVariable for this address
     it = jl_value_to_llvm.find(addr);
     if (it != jl_value_to_llvm.end())
-        return builder.CreateLoad(it->second.gv);
+        return builder.CreateLoad(prepare_global((llvm::GlobalVariable*)it->second.gv));
 
     std::stringstream gvname;
     gvname << cname << globalUnique++;
     // no existing GlobalVariable, create one and store it
-    GlobalVariable *gv = new GlobalVariable(*jl_Module, jl_pvalue_llvmt,
+    GlobalVariable *gv = new GlobalVariable(imaging_mode ? *shadow_module : *builtins_module, T_pjlvalue,
                            false, imaging_mode ? GlobalVariable::InternalLinkage : GlobalVariable::ExternalLinkage,
-                           ConstantPointerNull::get((PointerType*)jl_pvalue_llvmt), gvname.str());
+                           ConstantPointerNull::get((PointerType*)T_pjlvalue), gvname.str());
     addComdat(gv);
 
     // make the pointer valid for this session
@@ -546,7 +798,7 @@ static Value *julia_gv(const char *cname, void *addr)
     // make the pointer valid for future sessions
     jl_sysimg_gvars.push_back(ConstantExpr::getBitCast(gv, T_psize));
     jl_value_llvm gv_struct;
-    gv_struct.gv = gv;
+    gv_struct.gv = prepare_global(gv);
     gv_struct.index = jl_sysimg_gvars.size();
     jl_value_to_llvm[addr] = gv_struct;
     return builder.CreateLoad(gv);
@@ -556,22 +808,22 @@ static Value *julia_gv(const char *prefix, jl_sym_t *name, jl_module_t *mod, voi
 {
     // emit a GlobalVariable for a jl_value_t, using the prefix, name, and module to
     // to create a readable name of the form prefixModA.ModB.name
-    size_t len = strlen(name->name)+strlen(prefix)+1;
+    size_t len = strlen(jl_symbol_name(name))+strlen(prefix)+1;
     jl_module_t *parent = mod, *prev = NULL;
     while (parent != NULL && parent != prev) {
-        len += strlen(parent->name->name)+1;
+        len += strlen(jl_symbol_name(parent->name))+1;
         prev = parent;
         parent = parent->parent;
     }
     char *fullname = (char*)alloca(len);
     strcpy(fullname, prefix);
-    len -= strlen(name->name)+1;
-    strcpy(fullname+len,name->name);
+    len -= strlen(jl_symbol_name(name))+1;
+    strcpy(fullname + len, jl_symbol_name(name));
     parent = mod;
     prev = NULL;
     while (parent != NULL && parent != prev) {
-        size_t part = strlen(parent->name->name)+1;
-        strcpy(fullname+len-part,parent->name->name);
+        size_t part = strlen(jl_symbol_name(parent->name))+1;
+        strcpy(fullname+len-part,jl_symbol_name(parent->name));
         fullname[len-1] = '.';
         len -= part;
         prev = parent;
@@ -585,7 +837,7 @@ static Value *literal_pointer_val(jl_value_t *p)
     // emit a pointer to any jl_value_t which will be valid across reloading code
     // also, try to give it a nice name for gdb, for easy identification
     if (p == NULL)
-        return ConstantPointerNull::get((PointerType*)jl_pvalue_llvmt);
+        return ConstantPointerNull::get((PointerType*)T_pjlvalue);
     // some common constant values
     if (p == jl_false)
         return tbaa_decorate(tbaa_const, builder.CreateLoad(prepare_global(jlfalse_var)));
@@ -594,20 +846,12 @@ static Value *literal_pointer_val(jl_value_t *p)
     if (p == (jl_value_t*)jl_emptysvec)
         return tbaa_decorate(tbaa_const, builder.CreateLoad(prepare_global(jlemptysvec_var)));
     if (!imaging_mode)
-        return literal_static_pointer_val(p, jl_pvalue_llvmt);
+        return literal_static_pointer_val(p, T_pjlvalue);
     if (jl_is_datatype(p)) {
         jl_datatype_t *addr = (jl_datatype_t*)p;
         // DataTypes are prefixed with a +
         return julia_gv("+", addr->name->name, addr->name->module, p);
     }
-    if (jl_is_func(p)) {
-        jl_lambda_info_t *linfo = ((jl_function_t*)p)->linfo;
-        // Functions are prefixed with a -
-        if (linfo != NULL)
-            return julia_gv("-", linfo->name, linfo->module, p);
-        // Anonymous lambdas are prefixed with jl_method#
-        return julia_gv("jl_method#", p);
-    }
     if (jl_is_lambda_info(p)) {
         jl_lambda_info_t *linfo = (jl_lambda_info_t*)p;
         // Type-inferred functions are prefixed with a -
@@ -630,9 +874,9 @@ static Value *literal_pointer_val(jl_binding_t *p)
 {
     // emit a pointer to any jl_value_t which will be valid across reloading code
     if (p == NULL)
-        return ConstantPointerNull::get((PointerType*)jl_pvalue_llvmt);
+        return ConstantPointerNull::get((PointerType*)T_pjlvalue);
     if (!imaging_mode)
-        return literal_static_pointer_val(p, jl_pvalue_llvmt);
+        return literal_static_pointer_val(p, T_pjlvalue);
     // bindings are prefixed with jl_bnd#
     return julia_gv("jl_bnd#", p->name, p->owner, p);
 }
@@ -649,23 +893,26 @@ static Value *julia_binding_gv(jl_binding_t *b)
     // emit a literal_pointer_val to the value field of a jl_binding_t
     // binding->value are prefixed with *
     Value *bv = imaging_mode ?
-        builder.CreateBitCast(julia_gv("*", b->name, b->owner, b), jl_ppvalue_llvmt) :
-        literal_static_pointer_val(b,jl_ppvalue_llvmt);
+        builder.CreateBitCast(julia_gv("*", b->name, b->owner, b), T_ppjlvalue) :
+        literal_static_pointer_val(b,T_ppjlvalue);
     return julia_binding_gv(bv);
 }
 
 // --- mapping between julia and llvm types ---
 
-static Type *julia_struct_to_llvm(jl_value_t *jt);
+static Type *julia_struct_to_llvm(jl_value_t *jt, bool *isboxed);
 
 extern "C" {
-DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt)
+JL_DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt, bool *isboxed)
 {
     // this function converts a Julia Type into the equivalent LLVM type
+    if (isboxed) *isboxed = false;
     if (jt == (jl_value_t*)jl_bool_type) return T_int1;
     if (jt == (jl_value_t*)jl_bottom_type) return T_void;
-    if (!jl_is_leaf_type(jt))
-        return jl_pvalue_llvmt;
+    if (!jl_is_leaf_type(jt)) {
+        if (isboxed) *isboxed = true;
+        return T_pjlvalue;
+    }
     if (jl_is_cpointer_type(jt)) {
         Type *lt = julia_type_to_llvm(jl_tparam0(jt));
         if (lt == NULL)
@@ -679,15 +926,15 @@ DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt)
         if (jl_is_floattype(jt)) {
 #ifndef DISABLE_FLOAT16
             if (nb == 2)
-                return Type::getHalfTy(jl_LLVMContext);
+                return T_float16;
             else
 #endif
             if (nb == 4)
-                return Type::getFloatTy(jl_LLVMContext);
+                return T_float32;
             else if (nb == 8)
-                return Type::getDoubleTy(jl_LLVMContext);
+                return T_float64;
             else if (nb == 16)
-                return Type::getFP128Ty(jl_LLVMContext);
+                return T_float128;
         }
         return Type::getIntNTy(jl_LLVMContext, nb*8);
     }
@@ -695,18 +942,20 @@ DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt)
         if (((jl_datatype_t*)jt)->size == 0) {
             return T_void;
         }
-        return julia_struct_to_llvm(jt);
+        return julia_struct_to_llvm(jt, isboxed);
     }
-    return jl_pvalue_llvmt;
+    if (isboxed) *isboxed = true;
+    return T_pjlvalue;
 }
 }
 
-static Type *julia_struct_to_llvm(jl_value_t *jt)
+static Type *julia_struct_to_llvm(jl_value_t *jt, bool *isboxed)
 {
     // this function converts a Julia Type into the equivalent LLVM struct
     // use this where C-compatible (unboxed) structs are desired
     // use julia_type_to_llvm directly when you want to preserve Julia's type semantics
     bool isTuple = jl_is_tuple_type(jt);
+    if (isboxed) *isboxed = false;
     if ((isTuple || jl_is_structtype(jt)) && !jl_is_array_type(jt)) {
         if (!jl_is_leaf_type(jt))
             return NULL;
@@ -717,7 +966,7 @@ static Type *julia_struct_to_llvm(jl_value_t *jt)
                 return T_void;
             StructType *structdecl;
             if (!isTuple) {
-                structdecl = StructType::create(jl_LLVMContext, jst->name->name->name);
+                structdecl = StructType::create(jl_LLVMContext, jl_symbol_name(jst->name->name));
                 jst->struct_decl = structdecl;
             }
             std::vector<Type*> latypes(0);
@@ -727,8 +976,8 @@ static Type *julia_struct_to_llvm(jl_value_t *jt)
             for(i = 0; i < ntypes; i++) {
                 jl_value_t *ty = jl_svecref(jst->types, i);
                 Type *lty;
-                if (jst->fields[i].isptr)
-                    lty = jl_pvalue_llvmt;
+                if (jl_field_isptr(jst, i))
+                    lty = T_pjlvalue;
                 else
                     lty = ty==(jl_value_t*)jl_bool_type ? T_int8 : julia_type_to_llvm(ty);
                 if (lasttype != NULL && lasttype != lty)
@@ -757,15 +1006,16 @@ static Type *julia_struct_to_llvm(jl_value_t *jt)
         }
         return (Type*)jst->struct_decl;
     }
-    return julia_type_to_llvm(jt);
+    return julia_type_to_llvm(jt, isboxed);
 }
 
 static bool is_datatype_all_pointers(jl_datatype_t *dt)
 {
     size_t i, l = jl_datatype_nfields(dt);
     for(i=0; i < l; i++) {
-        if (!dt->fields[i].isptr)
+        if (!jl_field_isptr(dt, i)) {
             return false;
+        }
     }
     return true;
 }
@@ -785,17 +1035,23 @@ static bool is_tupletype_homogeneous(jl_svec_t *t)
     return true;
 }
 
+static bool deserves_sret(jl_value_t *dt, Type *T)
+{
+    assert(jl_is_datatype(dt));
+    return (size_t)jl_datatype_size(dt) > sizeof(void*) && !T->isFloatingPointTy();
+}
+
 // --- generating various field accessors ---
 
 static Value *emit_nthptr_addr(Value *v, ssize_t n)
 {
-    return builder.CreateGEP(builder.CreateBitCast(v, jl_ppvalue_llvmt),
+    return builder.CreateGEP(builder.CreateBitCast(v, T_ppjlvalue),
                              ConstantInt::get(T_size, (ssize_t)n));
 }
 
 static Value *emit_nthptr_addr(Value *v, Value *idx)
 {
-    return builder.CreateGEP(builder.CreateBitCast(v, jl_ppvalue_llvmt), idx);
+    return builder.CreateGEP(builder.CreateBitCast(v, T_ppjlvalue), idx);
 }
 
 static Value *emit_nthptr(Value *v, ssize_t n, MDNode *tbaa)
@@ -805,13 +1061,6 @@ static Value *emit_nthptr(Value *v, ssize_t n, MDNode *tbaa)
     return tbaa_decorate(tbaa,builder.CreateLoad(vptr, false));
 }
 
-static Value *emit_nthptr_recast(Value *v, ssize_t n, MDNode *tbaa, Type* ptype)
-{
-    // p = (jl_value_t**)v; *(ptype)&p[n]
-    Value *vptr = emit_nthptr_addr(v, n);
-    return tbaa_decorate(tbaa,builder.CreateLoad(builder.CreateBitCast(vptr,ptype), false));
-}
-
 static Value *emit_nthptr_recast(Value *v, Value *idx, MDNode *tbaa, Type *ptype)
 {
     // p = (jl_value_t**)v; *(ptype)&p[n]
@@ -821,25 +1070,26 @@ static Value *emit_nthptr_recast(Value *v, Value *idx, MDNode *tbaa, Type *ptype
 
 static Value *emit_typeptr_addr(Value *p)
 {
-   ssize_t offset = (offsetof(jl_taggedvalue_t,value) - offsetof(jl_taggedvalue_t,type)) / sizeof(jl_value_t*);
-   return emit_nthptr_addr(p, -offset);
+    ssize_t offset = (sizeof(jl_taggedvalue_t) -
+                      offsetof(jl_taggedvalue_t, type)) / sizeof(jl_value_t*);
+    return emit_nthptr_addr(p, -offset);
 }
 
 static Value *emit_typeof(Value *tt)
 {
     // given p, a jl_value_t*, compute its type tag
-    assert(tt->getType() == jl_pvalue_llvmt);
+    assert(tt->getType() == T_pjlvalue);
     tt = builder.CreateLoad(emit_typeptr_addr(tt), false);
     tt = builder.CreateIntToPtr(builder.CreateAnd(
                 builder.CreatePtrToInt(tt, T_size),
-                ConstantInt::get(T_size,~(uptrint_t)15)),
-            jl_pvalue_llvmt);
+                ConstantInt::get(T_size,~(uintptr_t)15)),
+            T_pjlvalue);
     return tt;
 }
 static Value *emit_typeof(const jl_cgval_t &p)
 {
     // given p, compute its type
-    if (p.isboxed && !jl_is_leaf_type(p.typ)) {
+    if (!p.constant && p.isboxed && !jl_is_leaf_type(p.typ)) {
         return emit_typeof(p.V);
     }
     jl_value_t *aty = p.typ;
@@ -849,24 +1099,22 @@ static Value *emit_typeof(const jl_cgval_t &p)
     return literal_pointer_val(aty);
 }
 
-static Value *emit_datatype_types(const jl_cgval_t &dt)
+static Value *emit_datatype_types(Value *dt)
 {
-    assert(dt.isboxed);
     return builder.
         CreateLoad(builder.
                    CreateBitCast(builder.
-                                 CreateGEP(builder.CreateBitCast(dt.V, T_pint8),
+                                 CreateGEP(builder.CreateBitCast(dt, T_pint8),
                                            ConstantInt::get(T_size, offsetof(jl_datatype_t, types))),
-                                 jl_ppvalue_llvmt));
+                                 T_ppjlvalue));
 }
 
-static Value *emit_datatype_nfields(const jl_cgval_t &dt)
+static Value *emit_datatype_nfields(Value *dt)
 {
-    assert(dt.isboxed);
     Value *nf = builder.
         CreateLoad(builder.
                    CreateBitCast(builder.
-                                 CreateGEP(builder.CreateBitCast(dt.V, T_pint8),
+                                 CreateGEP(builder.CreateBitCast(dt, T_pint8),
                                            ConstantInt::get(T_size, offsetof(jl_datatype_t, nfields))),
                                  T_pint32));
 #ifdef _P64
@@ -875,6 +1123,44 @@ static Value *emit_datatype_nfields(const jl_cgval_t &dt)
     return nf;
 }
 
+static Value *emit_datatype_size(Value *dt)
+{
+    Value *size = builder.
+        CreateLoad(builder.
+                   CreateBitCast(builder.
+                                 CreateGEP(builder.CreateBitCast(dt, T_pint8),
+                                           ConstantInt::get(T_size, offsetof(jl_datatype_t, size))),
+                                 T_pint32));
+    return size;
+}
+
+static Value *emit_datatype_mutabl(Value *dt)
+{
+    Value *mutabl = builder.
+        CreateLoad(builder.CreateGEP(builder.CreateBitCast(dt, T_pint8),
+                                     ConstantInt::get(T_size, offsetof(jl_datatype_t, mutabl))));
+    return builder.CreateTrunc(mutabl, T_int1);
+}
+
+static Value *emit_datatype_abstract(Value *dt)
+{
+    Value *abstract = builder.
+        CreateLoad(builder.CreateGEP(builder.CreateBitCast(dt, T_pint8),
+                                     ConstantInt::get(T_size, offsetof(jl_datatype_t, abstract))));
+    return builder.CreateTrunc(abstract, T_int1);
+}
+
+static Value *emit_datatype_isbitstype(Value *dt)
+{
+    Value *immut = builder.CreateXor(emit_datatype_mutabl(dt), ConstantInt::get(T_int1, -1));
+    Value *nofields = builder.CreateICmpEQ(emit_datatype_nfields(dt), ConstantInt::get(T_size, 0));
+    Value *isbitstype = builder.CreateAnd(immut, builder.CreateAnd(nofields,
+            builder.CreateXor(builder.CreateAnd(emit_datatype_abstract(dt),
+                    builder.CreateICmpSGT(emit_datatype_size(dt), ConstantInt::get(T_int32, 0))),
+                ConstantInt::get(T_int1, -1))));
+    return isbitstype;
+}
+
 // --- generating various error checks ---
 
 static void just_emit_error(const std::string &txt, jl_codectx_t *ctx)
@@ -913,11 +1199,9 @@ static void raise_exception_unless(Value *cond, Value *exc, jl_codectx_t *ctx)
     builder.CreateCondBr(cond, passBB, failBB);
     builder.SetInsertPoint(failBB);
 #ifdef LLVM37
-    builder.CreateCall(prepare_call(jlthrow_line_func), { exc,
-                        ConstantInt::get(T_int32, ctx->lineno) });
+    builder.CreateCall(prepare_call(jlthrow_func), { exc });
 #else
-    builder.CreateCall2(prepare_call(jlthrow_line_func), exc,
-                        ConstantInt::get(T_int32, ctx->lineno));
+    builder.CreateCall(prepare_call(jlthrow_func), exc);
 #endif
     builder.CreateUnreachable();
     ctx->f->getBasicBlockList().push_back(passBB);
@@ -947,7 +1231,8 @@ static void null_pointer_check(Value *v, jl_codectx_t *ctx)
                            prepare_global(jlundeferr_var), ctx);
 }
 
-static Value *boxed(const jl_cgval_t &v, jl_codectx_t *ctx, jl_value_t *jt=NULL);
+static Value *boxed(const jl_cgval_t &v, jl_codectx_t *ctx, bool gcooted=true);
+static Value *boxed(const jl_cgval_t &v, jl_codectx_t *ctx, jl_value_t* type) = delete; // C++11 (temporary to prevent rebase error)
 
 static void emit_type_error(const jl_cgval_t &x, jl_value_t *type, const std::string &msg,
                             jl_codectx_t *ctx)
@@ -960,14 +1245,12 @@ static void emit_type_error(const jl_cgval_t &x, jl_value_t *type, const std::st
                                        ArrayRef<Value*>(zeros));
 #ifdef LLVM37
     builder.CreateCall(prepare_call(jltypeerror_func),
-                        { fname_val, msg_val,
-                        literal_pointer_val(type), boxed(x,ctx),
-                        ConstantInt::get(T_int32, ctx->lineno) });
+                       { fname_val, msg_val,
+                         literal_pointer_val(type), boxed(x, ctx, false)}); // x is rooted by jl_type_error_rt
 #else
-    builder.CreateCall5(prepare_call(jltypeerror_func),
-                    fname_val, msg_val,
-                    literal_pointer_val(type), boxed(x,ctx),
-                    ConstantInt::get(T_int32, ctx->lineno));
+    builder.CreateCall4(prepare_call(jltypeerror_func),
+                        fname_val, msg_val,
+                        literal_pointer_val(type), boxed(x, ctx, false)); // x is rooted by jl_type_error_rt
 #endif
 }
 
@@ -975,8 +1258,10 @@ static void emit_typecheck(const jl_cgval_t &x, jl_value_t *type, const std::str
                            jl_codectx_t *ctx)
 {
     Value *istype;
+    if (jl_subtype(x.typ, type, 0))
+        return;
     if (jl_is_type_type(type) || !jl_is_leaf_type(type)) {
-        Value *vx = boxed(x, ctx, type);
+        Value *vx = boxed(x, ctx);
         istype = builder.
             CreateICmpNE(
 #ifdef LLVM37
@@ -1003,12 +1288,26 @@ static void emit_typecheck(const jl_cgval_t &x, jl_value_t *type, const std::str
     builder.SetInsertPoint(passBB);
 }
 
+static bool is_inbounds(jl_codectx_t *ctx)
+{
+    // inbounds rule is either of top two values on inbounds stack are true
+    bool inbounds = !ctx->inbounds.empty() && ctx->inbounds.back();
+    if (ctx->inbounds.size() > 1)
+        inbounds |= ctx->inbounds[ctx->inbounds.size()-2];
+    return inbounds;
+}
+
+static bool is_bounds_check_block(jl_codectx_t *ctx)
+{
+    return !ctx->boundsCheck.empty() && ctx->boundsCheck.back();
+}
+
 #define CHECK_BOUNDS 1
 static Value *emit_bounds_check(const jl_cgval_t &ainfo, jl_value_t *ty, Value *i, Value *len, jl_codectx_t *ctx)
 {
     Value *im1 = builder.CreateSub(i, ConstantInt::get(T_size, 1));
 #if CHECK_BOUNDS==1
-    if (((ctx->boundsCheck.empty() || ctx->boundsCheck.back()==true) &&
+    if ((!is_inbounds(ctx) &&
          jl_options.check_bounds != JL_OPTIONS_CHECK_BOUNDS_OFF) ||
          jl_options.check_bounds == JL_OPTIONS_CHECK_BOUNDS_ON) {
         Value *ok = builder.CreateICmpULT(im1, len);
@@ -1025,9 +1324,9 @@ static Value *emit_bounds_check(const jl_cgval_t &ainfo, jl_value_t *ty, Value *
         }
         else if (ainfo.isboxed) { // jl_datatype_t or boxed jl_value_t
 #ifdef LLVM37
-            builder.CreateCall(prepare_call(jlboundserror_func), { ainfo.V, i });
+            builder.CreateCall(prepare_call(jlboundserror_func), { boxed(ainfo, ctx), i });
 #else
-            builder.CreateCall2(prepare_call(jlboundserror_func), ainfo.V, i);
+            builder.CreateCall2(prepare_call(jlboundserror_func), boxed(ainfo, ctx), i);
 #endif
         }
         else { // unboxed jl_value_t*
@@ -1066,9 +1365,10 @@ static Value *emit_bounds_check(const jl_cgval_t &ainfo, jl_value_t *ty, Value *
 static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt);
 
 static jl_cgval_t typed_load(Value *ptr, Value *idx_0based, jl_value_t *jltype,
-                         jl_codectx_t *ctx, MDNode* tbaa, size_t alignment = 0)
+                             jl_codectx_t *ctx, MDNode *tbaa, size_t alignment = 0)
 {
-    Type *elty = julia_type_to_llvm(jltype);
+    bool isboxed;
+    Type *elty = julia_type_to_llvm(jltype, &isboxed);
     assert(elty != NULL);
     if (type_is_ghost(elty))
         return ghostValue(jltype);
@@ -1099,19 +1399,18 @@ static jl_cgval_t typed_load(Value *ptr, Value *idx_0based, jl_value_t *jltype,
         else {
             elt = load;
         }
-        if (elty == jl_pvalue_llvmt) {
+        if (isboxed) {
             null_pointer_check(elt, ctx);
         }
-        elt = emit_reg2mem(elt, ctx);
     //}
     if (isbool)
-        return mark_julia_type(builder.CreateTrunc(elt, T_int1), jltype);
-    return mark_julia_type(elt, jltype);
+        return mark_julia_type(builder.CreateTrunc(elt, T_int1), false, jltype, ctx);
+    return mark_julia_type(elt, isboxed, jltype, ctx);
 }
 
 static void typed_store(Value *ptr, Value *idx_0based, const jl_cgval_t &rhs,
-                        jl_value_t *jltype, jl_codectx_t *ctx, MDNode* tbaa,
-                        Value* parent,  // for the write barrier, NULL if no barrier needed
+                        jl_value_t *jltype, jl_codectx_t *ctx, MDNode *tbaa,
+                        Value *parent,  // for the write barrier, NULL if no barrier needed
                         size_t alignment = 0)
 {
     Type *elty = julia_type_to_llvm(jltype);
@@ -1126,7 +1425,7 @@ static void typed_store(Value *ptr, Value *idx_0based, const jl_cgval_t &rhs,
         r = emit_unbox(elty, rhs, jltype);
     }
     else {
-        r = boxed(rhs, ctx, jltype);
+        r = boxed(rhs, ctx);
         if (parent != NULL) emit_write_barrier(ctx, parent, r);
     }
     Value *data;
@@ -1162,10 +1461,18 @@ static inline jl_module_t *topmod(jl_codectx_t *ctx)
 
 static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
 {
-    if (jl_is_expr(e))
-        return ((jl_expr_t*)e)->etype;
-    if (jl_is_symbolnode(e))
-        return jl_symbolnode_type(e);
+    if (jl_is_expr(e)) {
+        jl_value_t *typ = ((jl_expr_t*)e)->etype;
+        if (jl_is_typevar(typ))
+            typ = ((jl_tvar_t*)typ)->ub;
+        return typ;
+    }
+    if (jl_is_symbolnode(e)) {
+        jl_value_t *typ = jl_symbolnode_type(e);
+        if (jl_is_typevar(typ))
+            typ = ((jl_tvar_t*)typ)->ub;
+        return typ;
+    }
     if (jl_is_gensym(e)) {
         int idx = ((jl_gensym_t*)e)->id;
         jl_value_t *gensym_types = jl_lam_gensyms(ctx->ast);
@@ -1175,8 +1482,6 @@ static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
         e = jl_fieldref(e,0);
         goto type_of_constant;
     }
-    if (jl_is_lambda_info(e))
-        return (jl_value_t*)jl_function_type;
     if (jl_is_globalref(e)) {
         jl_value_t *v = static_eval(e, ctx);
         if (v == NULL)
@@ -1201,10 +1506,13 @@ static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
         if (jl_is_symbol(e)) {
             if (is_global((jl_sym_t*)e, ctx)) {
                 // look for static parameter
-                for(size_t i=0; i < jl_svec_len(ctx->sp); i+=2) {
-                    assert(jl_is_symbol(jl_svecref(ctx->sp, i)));
-                    if (e == jl_svecref(ctx->sp, i)) {
-                        e = jl_svecref(ctx->sp, i+1);
+                jl_svec_t *sp = ctx->linfo->sparam_syms;
+                for (size_t i=0; i < jl_svec_len(sp); i++) {
+                    assert(jl_is_symbol(jl_svecref(sp, i)));
+                    if (e == jl_svecref(sp, i)) {
+                        if (jl_svec_len(ctx->linfo->sparam_vals) == 0)
+                            return (jl_value_t*)jl_any_type;
+                        e = jl_svecref(ctx->linfo->sparam_vals, i);
                         goto type_of_constant;
                     }
                 }
@@ -1234,9 +1542,12 @@ static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
 
 static void jl_add_linfo_root(jl_lambda_info_t *li, jl_value_t *val);
 
-static Value *data_pointer(Value *x)
+static Value *data_pointer(const jl_cgval_t &x, jl_codectx_t *ctx, Type *astype = T_ppjlvalue)
 {
-    return builder.CreateBitCast(x, jl_ppvalue_llvmt);
+    Value *data = x.constant ? boxed(x, ctx) : x.V;
+    if (data->getType() != astype)
+        data = builder.CreateBitCast(data, astype);
+    return data;
 }
 
 static bool emit_getfield_unknownidx(jl_cgval_t *ret, const jl_cgval_t &strct, Value *idx, jl_datatype_t *stt, jl_codectx_t *ctx)
@@ -1246,30 +1557,38 @@ static bool emit_getfield_unknownidx(jl_cgval_t *ret, const jl_cgval_t &strct, V
         if (is_datatype_all_pointers(stt)) {
             idx = emit_bounds_check(strct, (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields), ctx);
             Value *fld = tbaa_decorate(tbaa_user, builder.CreateLoad(
-                        builder.CreateGEP(
-                            builder.CreateBitCast(strct.V, jl_ppvalue_llvmt),
-                            idx)));
+                        builder.CreateGEP(data_pointer(strct, ctx), idx)));
             if ((unsigned)stt->ninitialized != nfields)
                 null_pointer_check(fld, ctx);
-            *ret = mark_julia_type(fld, jl_any_type);
+            bool needsgcroot = true; // !strct.isimmutable; // jwn: probably want this as a llvm pass
+            *ret = mark_julia_type(fld, true, jl_any_type, ctx, needsgcroot);
             return true;
         }
         else if (is_tupletype_homogeneous(stt->types)) {
             assert(nfields > 0); // nf == 0 trapped by all_pointers case
             jl_value_t *jt = jl_field_type(stt, 0);
             idx = emit_bounds_check(strct, (jl_value_t*)stt, idx, ConstantInt::get(T_size, nfields), ctx);
-            Value *ptr = data_pointer(strct.V);
+            Value *ptr = data_pointer(strct, ctx);
+            if (!stt->mutabl) {
+                // just compute the pointer and let user load it when necessary
+                Type *fty = julia_type_to_llvm(jt);
+                Value *addr = builder.CreateGEP(builder.CreatePointerCast(ptr, PointerType::get(fty,0)), idx);
+                jl_cgval_t fieldval = mark_julia_slot(addr, jt);
+                fieldval.gcroot = strct.gcroot;
+                *ret = fieldval;
+                return true;
+            }
             *ret = typed_load(ptr, idx, jt, ctx, stt->mutabl ? tbaa_user : tbaa_immut);
             return true;
         }
         else if (strct.isboxed) {
             idx = builder.CreateSub(idx, ConstantInt::get(T_size, 1));
 #ifdef LLVM37
-            Value *fld = builder.CreateCall(prepare_call(jlgetnthfieldchecked_func), { strct.V, idx });
+            Value *fld = builder.CreateCall(prepare_call(jlgetnthfieldchecked_func), { boxed(strct, ctx), idx });
 #else
-            Value *fld = builder.CreateCall2(prepare_call(jlgetnthfieldchecked_func), strct.V, idx);
+            Value *fld = builder.CreateCall2(prepare_call(jlgetnthfieldchecked_func), boxed(strct, ctx), idx);
 #endif
-            *ret = mark_julia_type(fld, jl_any_type);
+            *ret = mark_julia_type(fld, true, jl_any_type, ctx);
             return true;
         }
     }
@@ -1299,7 +1618,7 @@ static bool emit_getfield_unknownidx(jl_cgval_t *ret, const jl_cgval_t &strct, V
         if (jt == (jl_value_t*)jl_bool_type) {
             fld = builder.CreateTrunc(fld, T_int1);
         }
-        *ret = mark_julia_type(fld, jt);
+        *ret = mark_julia_type(fld, false, jt, ctx);
         return true;
     }
     return false;
@@ -1319,14 +1638,16 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
     Value *fldv = NULL;
     if (strct.isboxed) {
         Value *addr =
-            builder.CreateGEP(builder.CreateBitCast(strct.V, T_pint8),
+            builder.CreateGEP(builder.CreateBitCast(boxed(strct, ctx), T_pint8),
                               ConstantInt::get(T_size, jl_field_offset(jt,idx)));
         MDNode *tbaa = strct.isimmutable ? tbaa_immut : tbaa_user;
-        if (jl_field_isptr(jt,idx)) {
-            Value *fldv = tbaa_decorate(tbaa, builder.CreateLoad(builder.CreateBitCast(addr,jl_ppvalue_llvmt)));
+        if (jl_field_isptr(jt, idx)) {
+            Value *fldv = tbaa_decorate(tbaa, builder.CreateLoad(builder.CreateBitCast(addr, T_ppjlvalue)));
             if (idx >= (unsigned)jt->ninitialized)
                 null_pointer_check(fldv, ctx);
-            return mark_julia_type(fldv, jfty);
+            bool needsgcroot = true; // !strct.isimmutable; // jwn: probably want this as a llvm pass
+            jl_cgval_t ret = mark_julia_type(fldv, true, jfty, ctx, needsgcroot);
+            return ret;
         }
         else {
             int align = jl_field_offset(jt,idx);
@@ -1340,10 +1661,12 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
     }
     else if (strct.ispointer) { // something stack allocated
         Value *addr = builder.CreateConstInBoundsGEP2_32(
-            LLVM37_param(cast<PointerType>(strct.V->getType()->getScalarType())->getElementType())
+            LLVM37_param(julia_type_to_llvm(strct.typ))
             strct.V, 0, idx);
         assert(!jt->mutabl);
-        return typed_load(addr, NULL, jfty, ctx, NULL);
+        jl_cgval_t fieldval = mark_julia_slot(addr, jfty);
+        fieldval.gcroot = strct.gcroot;
+        return fieldval;
     }
     else {
         assert(strct.V->getType()->isVectorTy());
@@ -1352,7 +1675,7 @@ static jl_cgval_t emit_getfield_knownidx(const jl_cgval_t &strct, unsigned idx,
             fldv = builder.CreateTrunc(fldv, T_int1);
         }
         assert(!jl_field_isptr(jt, idx));
-        return mark_julia_type(fldv, jfty);
+        return mark_julia_type(fldv, false, jfty, ctx);
     }
 }
 
@@ -1369,10 +1692,10 @@ static Value *emit_n_varargs(jl_codectx_t *ctx)
 #endif
 }
 
-static Value *emit_arraysize(const jl_cgval_t &tinfo, Value *dim)
+static Value *emit_arraysize(const jl_cgval_t &tinfo, Value *dim, jl_codectx_t *ctx)
 {
     assert(tinfo.isboxed);
-    Value *t = tinfo.V;
+    Value *t = boxed(tinfo, ctx);
     int o = offsetof(jl_array_t, nrows)/sizeof(void*) - 1;
     return emit_nthptr_recast(t, builder.CreateAdd(dim,
                                                    ConstantInt::get(dim->getType(), o)),
@@ -1394,12 +1717,12 @@ static jl_arrayvar_t *arrayvar_for(jl_value_t *ex, jl_codectx_t *ctx)
     return NULL;
 }
 
-static Value *emit_arraysize(const jl_cgval_t &tinfo, int dim)
+static Value *emit_arraysize(const jl_cgval_t &tinfo, int dim, jl_codectx_t *ctx)
 {
-    return emit_arraysize(tinfo, ConstantInt::get(T_int32, dim));
+    return emit_arraysize(tinfo, ConstantInt::get(T_int32, dim), ctx);
 }
 
-static Value *emit_arraylen_prim(Value *t, jl_value_t *ty)
+static Value *emit_arraylen_prim(Value *t, jl_value_t *ty, jl_codectx_t *ctx)
 {
 #ifdef STORE_ARRAY_LEN
     (void)ty;
@@ -1417,15 +1740,15 @@ static Value *emit_arraylen_prim(Value *t, jl_value_t *ty)
         size_t nd = jl_unbox_long(p1);
         Value *l = ConstantInt::get(T_size, 1);
         for(size_t i=0; i < nd; i++) {
-            l = builder.CreateMul(l, emit_arraysize(t, (int)(i+1)));
+            l = builder.CreateMul(l, emit_arraysize(t, (int)(i+1), ctx));
         }
         return l;
     }
     else {
         std::vector<Type *> fargt(0);
-        fargt.push_back(jl_pvalue_llvmt);
+        fargt.push_back(T_pjlvalue);
         FunctionType *ft = FunctionType::get(T_size, fargt, false);
-        Value *alen = jl_Module->getOrInsertFunction("jl_array_len_", ft);
+        Value *alen = jl_Module->getOrInsertFunction("jl_array_len_", ft); // TODO: move to codegen init block
         return builder.CreateCall(prepare_call(alen), t);
     }
 #endif
@@ -1437,12 +1760,12 @@ static Value *emit_arraylen(const jl_cgval_t &tinfo, jl_value_t *ex, jl_codectx_
     jl_arrayvar_t *av = arrayvar_for(ex, ctx);
     if (av!=NULL)
         return builder.CreateLoad(av->len);
-    return emit_arraylen_prim(tinfo.V, expr_type(ex,ctx));
+    return emit_arraylen_prim(boxed(tinfo, ctx), expr_type(ex, ctx), ctx);
 }
 
 static Value *emit_arrayptr(Value *t)
 {
-    Value* addr = builder.CreateStructGEP(
+    Value *addr = builder.CreateStructGEP(
 #ifdef LLVM37
                                           nullptr,
 #endif
@@ -1455,7 +1778,7 @@ static Value *emit_arrayptr(Value *t)
 static Value *emit_arrayptr(const jl_cgval_t &tinfo, jl_value_t *ex, jl_codectx_t *ctx)
 {
     assert(tinfo.isboxed);
-    Value *t = tinfo.V;
+    Value *t = boxed(tinfo, ctx);
     jl_arrayvar_t *av = arrayvar_for(ex, ctx);
     if (av!=NULL)
         return builder.CreateLoad(av->dataptr);
@@ -1467,42 +1790,48 @@ static Value *emit_arraysize(const jl_cgval_t &tinfo, jl_value_t *ex, int dim, j
     jl_arrayvar_t *av = arrayvar_for(ex, ctx);
     if (av != NULL && dim <= (int)av->sizes.size())
         return builder.CreateLoad(av->sizes[dim-1]);
-    return emit_arraysize(tinfo, dim);
+    return emit_arraysize(tinfo, dim, ctx);
 }
 
 static Value *emit_arrayflags(const jl_cgval_t &tinfo, jl_codectx_t *ctx)
 {
     assert(tinfo.isboxed);
-    Value *t = tinfo.V;
+    Value *t = boxed(tinfo, ctx);
+#ifdef STORE_ARRAY_LEN
+    int arrayflag_field = 2;
+#else
+    int arrayflag_field = 1;
+#endif
     Value *addr = builder.CreateStructGEP(
 #ifdef LLVM37
                             nullptr,
 #endif
-                            builder.CreateBitCast(t, jl_parray_llvmt), 2);
+                            builder.CreateBitCast(t, jl_parray_llvmt),
+                            arrayflag_field);
     return builder.CreateLoad(addr); // TODO: tbaa
 }
 
-static void assign_arrayvar(jl_arrayvar_t &av, const jl_cgval_t &ainfo)
+static void assign_arrayvar(jl_arrayvar_t &av, const jl_cgval_t &ainfo, jl_codectx_t *ctx)
 {
     assert(ainfo.isboxed);
-    Value *ar = ainfo.V;
+    Value *ar = boxed(ainfo, ctx);
     tbaa_decorate(tbaa_arrayptr,builder.CreateStore(builder.CreateBitCast(emit_arrayptr(ar),
                                                     av.dataptr->getType()->getContainedType(0)),
                                                     av.dataptr));
-    builder.CreateStore(emit_arraylen_prim(ar, av.ty), av.len);
+    builder.CreateStore(emit_arraylen_prim(ar, av.ty, ctx), av.len);
     for(size_t i=0; i < av.sizes.size(); i++)
-        builder.CreateStore(emit_arraysize(ainfo,i+1), av.sizes[i]);
+        builder.CreateStore(emit_arraysize(ainfo, i+1, ctx), av.sizes[i]);
 }
 
 static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, size_t nd, jl_value_t **args,
                                   size_t nidxs, jl_codectx_t *ctx)
 {
     assert(ainfo.isboxed);
-    Value *a = ainfo.V;
+    Value *a = boxed(ainfo, ctx);
     Value *i = ConstantInt::get(T_size, 0);
     Value *stride = ConstantInt::get(T_size, 1);
 #if CHECK_BOUNDS==1
-    bool bc = ((ctx->boundsCheck.empty() || ctx->boundsCheck.back()==true) &&
+    bool bc = (!is_inbounds(ctx) &&
                jl_options.check_bounds != JL_OPTIONS_CHECK_BOUNDS_OFF) ||
         jl_options.check_bounds == JL_OPTIONS_CHECK_BOUNDS_ON;
     BasicBlock *failBB=NULL, *endBB=NULL;
@@ -1513,7 +1842,7 @@ static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, size_
 #endif
     Value **idxs = (Value**)alloca(sizeof(Value*)*nidxs);
     for(size_t k=0; k < nidxs; k++) {
-        idxs[k] = emit_unbox(T_size, emit_unboxed(args[k], ctx), NULL);
+        idxs[k] = emit_unbox(T_size, emit_expr(args[k], ctx), NULL);
     }
     for(size_t k=0; k < nidxs; k++) {
         Value *ii = builder.CreateSub(idxs[k], ConstantInt::get(T_size, 1));
@@ -1563,7 +1892,7 @@ static Value *emit_array_nd_index(const jl_cgval_t &ainfo, jl_value_t *ex, size_
 
 // --- boxing ---
 
-static Value* emit_allocobj(size_t static_size);
+static Value *emit_allocobj(size_t static_size);
 static Value *init_bits_value(Value *newv, Value *jt, Value *v)
 {
     builder.CreateStore(jt, emit_typeptr_addr(newv));
@@ -1571,24 +1900,12 @@ static Value *init_bits_value(Value *newv, Value *jt, Value *v)
     return newv;
 }
 
-static jl_value_t *static_void_instance(jl_value_t *jt)
-{
-    assert(jl_is_datatype(jt));
-    jl_datatype_t *jb = (jl_datatype_t*)jt;
-    if (jb->instance == NULL)
-        // if we can't get an instance then this was an UndefValue due
-        // to throwing an error.
-        return (jl_value_t*)jl_nothing;
-    //assert(jb->instance != NULL);
-    return (jl_value_t*)jb->instance;
-}
-
 static jl_value_t *static_constant_instance(Constant *constant, jl_value_t *jt)
 {
     assert(constant != NULL);
 
     if (isa<UndefValue>(constant))
-	return NULL;
+        return NULL;
 
     ConstantInt *cint = dyn_cast<ConstantInt>(constant);
     if (cint != NULL) {
@@ -1665,38 +1982,27 @@ static Value *call_with_unsigned(Function *ufunc, Value *v)
 // this is used to wrap values for generic contexts, where a
 // dynamically-typed value is required (e.g. argument to unknown function).
 // if it's already a pointer it's left alone.
-static Value *boxed(const jl_cgval_t &vinfo, jl_codectx_t *ctx, jl_value_t *jt)
+static Value *boxed(const jl_cgval_t &vinfo, jl_codectx_t *ctx, bool gcrooted)
 {
-    if (jt == NULL) {
-        jt = vinfo.typ;
-    }
-    else if (jt != jl_bottom_type && !jl_is_leaf_type(jt)) {
-        // we can get a sharper type from julia_type_of than expr_type in some
-        // cases, due to ccall's compile-time evaluations of types. see issue #5752
-        jl_value_t *jt2 = vinfo.typ;
-        if (jt2 && jl_subtype(jt2, jt, 0))
-            jt = jt2;
-    }
-    if (jt == jl_bottom_type || jt == NULL) {
+    jl_value_t *jt = vinfo.typ;
+    Value *v = vinfo.V;
+    if (jt == jl_bottom_type || jt == NULL)
         // We have an undef value on a (hopefully) dead branch
-        return UndefValue::get(jl_pvalue_llvmt);
-    }
-    if (vinfo.isghost) {
-        jl_value_t *s = static_void_instance(jt);
-        assert(s);
-        return literal_pointer_val(s);
-    }
+        return UndefValue::get(T_pjlvalue);
+    if (vinfo.constant)
+        return literal_pointer_val(vinfo.constant);
+    assert(v);
+    if (vinfo.isboxed)
+        return v;
     Type *t = julia_type_to_llvm(vinfo.typ);
     assert(!type_is_ghost(t)); // should have been handled by isghost above!
 
-    if (vinfo.isboxed)
-        return vinfo.V;
-
-    Value *v = vinfo.V;
-    if (vinfo.ispointer) {
+    if (vinfo.ispointer)
         v = builder.CreateLoad(builder.CreatePointerCast(v, t->getPointerTo()));
-    }
-    if (t == T_int1) return julia_bool(v);
+
+    if (t == T_int1)
+        return julia_bool(v);
+
     Constant *c = NULL;
     if ((c = dyn_cast<Constant>(v)) != NULL) {
         jl_value_t *s = static_constant_instance(c, jt);
@@ -1708,45 +2014,62 @@ static Value *boxed(const jl_cgval_t &vinfo, jl_codectx_t *ctx, jl_value_t *jt)
 
     jl_datatype_t *jb = (jl_datatype_t*)jt;
     assert(jl_is_datatype(jb));
-    if (jb == jl_int8_type)  return call_with_signed(box_int8_func, v);
-    if (jb == jl_int16_type) return call_with_signed(box_int16_func, v);
-    if (jb == jl_int32_type) return call_with_signed(box_int32_func, v);
-    if (jb == jl_int64_type) return call_with_signed(box_int64_func, v);
-    if (jb == jl_float32_type) return builder.CreateCall(prepare_call(box_float32_func), v);
-    //if (jb == jl_float64_type) return builder.CreateCall(box_float64_func, v);
+    Value *box = NULL;
+    if (jb == jl_int8_type)
+        box = call_with_signed(box_int8_func, v);
+    else if (jb == jl_int16_type)
+        box = call_with_signed(box_int16_func, v);
+    else if (jb == jl_int32_type)
+        box = call_with_signed(box_int32_func, v);
+    else if (jb == jl_int64_type)
+        box = call_with_signed(box_int64_func, v);
+    else if (jb == jl_float32_type)
+        box = builder.CreateCall(prepare_call(box_float32_func), v);
+    //if (jb == jl_float64_type)
+    //  box = builder.CreateCall(box_float64_func, v);
     // for Float64, fall through to generic case below, to inline alloc & init of Float64 box. cheap, I know.
-    if (jb == jl_uint8_type)  return call_with_unsigned(box_uint8_func, v);
-    if (jb == jl_uint16_type) return call_with_unsigned(box_uint16_func, v);
-    if (jb == jl_uint32_type) return call_with_unsigned(box_uint32_func, v);
-    if (jb == jl_uint64_type) return call_with_unsigned(box_uint64_func, v);
-    if (jb == jl_char_type)   return call_with_unsigned(box_char_func, v);
-    if (jb == jl_gensym_type) {
+    else if (jb == jl_uint8_type)
+        box = call_with_unsigned(box_uint8_func, v);
+    else if (jb == jl_uint16_type)
+        box = call_with_unsigned(box_uint16_func, v);
+    else if (jb == jl_uint32_type)
+        box = call_with_unsigned(box_uint32_func, v);
+    else if (jb == jl_uint64_type)
+        box = call_with_unsigned(box_uint64_func, v);
+    else if (jb == jl_char_type)
+        box = call_with_unsigned(box_char_func, v);
+    else if (jb == jl_gensym_type) {
         unsigned zero = 0;
-        if (v->getType()->isPointerTy()) {
-            v = builder.CreateLoad(v);
-        }
-        v = builder.CreateExtractValue(v, ArrayRef<unsigned>(&zero,1));
-        return call_with_unsigned(box_gensym_func, v);
+        assert(v->getType() == jl_gensym_type->struct_decl);
+        v = builder.CreateExtractValue(v, makeArrayRef(&zero, 1));
+        box = call_with_unsigned(box_gensym_func, v);
     }
-
-    if (!jl_isbits(jt) || !jl_is_leaf_type(jt)) {
+    else if (!jl_isbits(jt) || !jl_is_leaf_type(jt)) {
         assert("Don't know how to box this type" && false);
         return NULL;
     }
-
-    if (!jb->abstract && jb->size == 0) {
+    else if (!jb->abstract && jb->size == 0) {
         assert(jb->instance != NULL);
         return literal_pointer_val(jb->instance);
     }
+    else {
+        box = init_bits_value(emit_allocobj(jl_datatype_size(jt)), literal_pointer_val(jt), v);
+    }
 
-    return init_bits_value(emit_allocobj(jl_datatype_size(jt)), literal_pointer_val(jt), v);
+    if (gcrooted) {
+        // make a gcroot for the new box
+        // (unless the caller explicitly said this was unnecessary)
+        Value *froot = emit_local_slot(ctx);
+        builder.CreateStore(box, froot);
+    }
+
+    return box;
 }
 
-static void emit_cpointercheck(const jl_cgval_t &x, const std::string &msg,
-                               jl_codectx_t *ctx)
+static void emit_cpointercheck(const jl_cgval_t &x, const std::string &msg, jl_codectx_t *ctx)
 {
     Value *t = emit_typeof(x);
-    emit_typecheck(mark_julia_type(t, jl_any_type), (jl_value_t*)jl_datatype_type, msg, ctx);
+    emit_typecheck(mark_julia_type(t, true, jl_any_type, ctx), (jl_value_t*)jl_datatype_type, msg, ctx);
 
     Value *istype =
         builder.CreateICmpEQ(emit_nthptr(t, (ssize_t)(offsetof(jl_datatype_t,name)/sizeof(char*)), tbaa_datatype),
@@ -1764,54 +2087,53 @@ static void emit_cpointercheck(const jl_cgval_t &x, const std::string &msg,
 }
 
 // allocation for known size object
-static Value* emit_allocobj(size_t static_size)
+static Value *emit_allocobj(size_t static_size)
 {
     if (static_size == sizeof(void*)*1)
-
         return builder.CreateCall(prepare_call(jlalloc1w_func)
 #ifdef LLVM37
-            , {}
+                                  , {}
 #endif
-            );
+                                  );
     else if (static_size == sizeof(void*)*2)
         return builder.CreateCall(prepare_call(jlalloc2w_func)
 #ifdef LLVM37
-            , {}
+                                  , {}
 #endif
-            );
+                                  );
     else if (static_size == sizeof(void*)*3)
         return builder.CreateCall(prepare_call(jlalloc3w_func)
 #ifdef LLVM37
-            , {}
+                                  , {}
 #endif
-            );
+                                  );
     else
         return builder.CreateCall(prepare_call(jlallocobj_func),
                                   ConstantInt::get(T_size, static_size));
 }
 
 // if ptr is NULL this emits a write barrier _back_
-static void emit_write_barrier(jl_codectx_t* ctx, Value *parent, Value *ptr)
+static void emit_write_barrier(jl_codectx_t *ctx, Value *parent, Value *ptr)
 {
     Value* parenttag = builder.CreateBitCast(emit_typeptr_addr(parent), T_psize);
     Value* parent_type = builder.CreateLoad(parenttag);
-    Value* parent_mark_bits = builder.CreateAnd(parent_type, 1);
+    Value* parent_mark_bits = builder.CreateAnd(parent_type, 3);
 
     // the branch hint does not seem to make it to the generated code
     //builder.CreateCall(expect_func, {parent_marked, ConstantInt::get(T_int1, 0)});
-    Value* parent_marked = builder.CreateICmpEQ(parent_mark_bits, ConstantInt::get(T_size, 1));
+    Value *parent_marked = builder.CreateICmpEQ(parent_mark_bits, ConstantInt::get(T_size, 1));
 
-    BasicBlock* cont = BasicBlock::Create(getGlobalContext(), "cont");
-    BasicBlock* barrier_may_trigger = BasicBlock::Create(getGlobalContext(), "wb_may_trigger", ctx->f);
-    BasicBlock* barrier_trigger = BasicBlock::Create(getGlobalContext(), "wb_trigger", ctx->f);
+    BasicBlock *cont = BasicBlock::Create(getGlobalContext(), "cont");
+    BasicBlock *barrier_may_trigger = BasicBlock::Create(getGlobalContext(), "wb_may_trigger", ctx->f);
+    BasicBlock *barrier_trigger = BasicBlock::Create(getGlobalContext(), "wb_trigger", ctx->f);
     builder.CreateCondBr(parent_marked, barrier_may_trigger, cont);
 
     builder.SetInsertPoint(barrier_may_trigger);
-    Value* ptr_mark_bit = builder.CreateAnd(builder.CreateLoad(builder.CreateBitCast(emit_typeptr_addr(ptr), T_psize)), 1);
-    Value* ptr_not_marked = builder.CreateICmpEQ(ptr_mark_bit, ConstantInt::get(T_size, 0));
+    Value *ptr_mark_bit = builder.CreateAnd(builder.CreateLoad(builder.CreateBitCast(emit_typeptr_addr(ptr), T_psize)), 1);
+    Value *ptr_not_marked = builder.CreateICmpEQ(ptr_mark_bit, ConstantInt::get(T_size, 0));
     builder.CreateCondBr(ptr_not_marked, barrier_trigger, cont);
     builder.SetInsertPoint(barrier_trigger);
-    builder.CreateCall(prepare_call(queuerootfun), builder.CreateBitCast(parent, jl_pvalue_llvmt));
+    builder.CreateCall(prepare_call(queuerootfun), builder.CreateBitCast(parent, T_pjlvalue));
     builder.CreateBr(cont);
     ctx->f->getBasicBlockList().push_back(cont);
     builder.SetInsertPoint(cont);
@@ -1832,19 +2154,18 @@ static void emit_checked_write_barrier(jl_codectx_t *ctx, Value *parent, Value *
 }
 
 static void emit_setfield(jl_datatype_t *sty, const jl_cgval_t &strct, size_t idx0,
-                            const jl_cgval_t &rhs, jl_codectx_t *ctx, bool checked, bool wb)
+                          const jl_cgval_t &rhs, jl_codectx_t *ctx, bool checked, bool wb)
 {
     if (sty->mutabl || !checked) {
         assert(strct.ispointer);
-        Value *addr =
-            builder.CreateGEP(builder.CreateBitCast(strct.V, T_pint8),
-                              ConstantInt::get(T_size, jl_field_offset(sty,idx0)));
+        Value *addr = builder.CreateGEP(data_pointer(strct, ctx, T_pint8),
+                ConstantInt::get(T_size, jl_field_offset(sty, idx0)));
         jl_value_t *jfty = jl_svecref(sty->types, idx0);
-        if (sty->fields[idx0].isptr) {
-            Value *r = boxed(rhs, ctx);
-            builder.CreateStore(r,
-                                builder.CreateBitCast(addr, jl_ppvalue_llvmt));
-            if (wb) emit_checked_write_barrier(ctx, strct.V, r);
+        if (jl_field_isptr(sty, idx0)) {
+            Value *r = boxed(rhs, ctx, false); // don't need a temporary gcroot since it'll be rooted by strct (but should ensure strct is rooted via mark_gc_use)
+            builder.CreateStore(r, builder.CreateBitCast(addr, T_ppjlvalue));
+            if (wb && strct.isboxed) emit_checked_write_barrier(ctx, boxed(strct, ctx), r);
+            mark_gc_use(strct);
         }
         else {
             int align = jl_field_offset(sty, idx0);
@@ -1853,7 +2174,7 @@ static void emit_setfield(jl_datatype_t *sty, const jl_cgval_t &strct, size_t id
             else if (align & 4) align = 4;
             else if (align & 8) align = 8;
             else align = 16;
-            typed_store(addr, ConstantInt::get(T_size, 0), rhs, jfty, ctx, sty->mutabl ? tbaa_user : tbaa_immut, strct.V, align);
+            typed_store(addr, ConstantInt::get(T_size, 0), rhs, jfty, ctx, sty->mutabl ? tbaa_user : tbaa_immut, data_pointer(strct, ctx, T_pjlvalue), align);
         }
     }
     else {
@@ -1862,7 +2183,14 @@ static void emit_setfield(jl_datatype_t *sty, const jl_cgval_t &strct, size_t id
     }
 }
 
-static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **args, jl_codectx_t *ctx)
+static bool might_need_root(jl_value_t *ex)
+{
+    return (!jl_is_symbol(ex) && !jl_is_symbolnode(ex) && !jl_is_gensym(ex) &&
+            !jl_is_bool(ex) && !jl_is_quotenode(ex) && !jl_is_byte_string(ex) &&
+            !jl_is_globalref(ex));
+}
+
+static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **args, jl_codectx_t *ctx, bool on_stack = false)
 {
     assert(jl_is_datatype(ty));
     assert(jl_is_leaf_type(ty));
@@ -1878,7 +2206,7 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
             for (size_t i=0; i < na; i++) {
                 jl_value_t *jtype = jl_svecref(sty->types,i);
                 Type *fty = julia_type_to_llvm(jtype);
-                jl_cgval_t fval_info = emit_unboxed(args[i+1], ctx);
+                jl_cgval_t fval_info = emit_expr(args[i+1], ctx);
                 if (!jl_subtype(fval_info.typ, jtype, 0))
                     emit_typecheck(fval_info, jtype, "new", ctx);
                 if (!type_is_ghost(fty)) {
@@ -1892,19 +2220,11 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
                 }
                 idx++;
             }
-            return mark_julia_type(emit_reg2mem(strct, ctx), ty);
+            return mark_julia_type(strct, false, ty, ctx);
         }
         Value *f1 = NULL;
-        int fieldStart = ctx->gc.argDepth;
-        bool needroots = false;
-        for (size_t i = 1;i < nargs;i++) {
-            if (might_need_root(args[i])) {
-                needroots = true;
-                break;
-            }
-        }
         size_t j = 0;
-        if (nf > 0 && sty->fields[0].isptr && nargs>1) {
+        if (nf > 0 && jl_field_isptr(sty, 0) && nargs>1) {
             // emit first field before allocating struct to save
             // a couple store instructions. avoids initializing
             // the first field to NULL, and sometimes the GC root
@@ -1912,56 +2232,49 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
             jl_cgval_t fval_info = emit_expr(args[1],ctx);
             f1 = boxed(fval_info, ctx);
             j++;
-            if (might_need_root(args[1]) || !fval_info.isboxed)
-                make_gcroot(f1, ctx);
         }
-        Value *strct = emit_allocobj(sty->size);
-        jl_cgval_t strctinfo = mark_julia_type(strct, ty);
-        builder.CreateStore(literal_pointer_val((jl_value_t*)ty),
-                            emit_typeptr_addr(strct));
+        Value *strct;
+        Value *tag = literal_pointer_val((jl_value_t*)ty);
+        if (on_stack) {
+            strct = builder.CreateConstGEP1_32(builder.CreateBitCast(emit_static_alloca(T_int8, sty->size + sizeof(void*), ctx), T_pjlvalue), 1);
+            // set the gc bits as marked & young
+            tag = builder.CreateIntToPtr(builder.CreateOr(builder.CreatePtrToInt(tag, T_size), 3), T_pjlvalue);
+        }
+        else {
+            strct = emit_allocobj(sty->size);
+        }
+        jl_cgval_t strctinfo = mark_julia_type(strct, true, ty, ctx);
+        builder.CreateStore(tag, emit_typeptr_addr(strct));
         if (f1) {
-            jl_cgval_t f1info = mark_julia_type(f1, jl_any_type);
+            jl_cgval_t f1info = mark_julia_type(f1, true, jl_any_type, ctx);
             if (!jl_subtype(expr_type(args[1],ctx), jl_field_type(sty,0), 0))
                 emit_typecheck(f1info, jl_field_type(sty,0), "new", ctx);
             emit_setfield(sty, strctinfo, 0, f1info, ctx, false, false);
-            ctx->gc.argDepth = fieldStart;
-            if (nf > 1 && needroots)
-                make_gcroot(strct, ctx);
-        }
-        else if (nf > 0 && needroots) {
-            make_gcroot(strct, ctx);
         }
         for(size_t i=j; i < nf; i++) {
-            if (sty->fields[i].isptr) {
+            if (jl_field_isptr(sty, i)) {
                 builder.CreateStore(
                         V_null,
                         builder.CreatePointerCast(
                             builder.CreateGEP(builder.CreateBitCast(strct, T_pint8),
                                 ConstantInt::get(T_size, jl_field_offset(sty,i))),
-                            jl_ppvalue_llvmt));
+                            T_ppjlvalue));
             }
         }
         bool need_wb = false;
+        // TODO: verify that nargs <= nf (currently handled by front-end)
         for(size_t i=j+1; i < nargs; i++) {
-            jl_cgval_t rhs = emit_expr(args[i],ctx);
-            if (sty->fields[i-1].isptr && !rhs.isboxed) {
-                if (!needroots) {
-                    // if this struct element needs boxing and we haven't rooted
-                    // the struct, root it now.
-                    make_gcroot(strct, ctx);
-                    needroots = true;
-                }
+            jl_cgval_t rhs = emit_expr(args[i], ctx);
+            if (jl_field_isptr(sty, i - 1) && !rhs.isboxed) {
                 need_wb = true;
             }
             if (rhs.isboxed) {
-                if (!jl_subtype(expr_type(args[i],ctx), jl_svecref(sty->types,i-1), 0))
                     emit_typecheck(rhs, jl_svecref(sty->types,i-1), "new", ctx);
             }
-            if (!need_wb && might_need_root(args[i]))
+            if (might_need_root(args[i])) // TODO: how to remove this?
                 need_wb = true;
             emit_setfield(sty, strctinfo, i-1, rhs, ctx, false, need_wb);
         }
-        ctx->gc.argDepth = fieldStart;
         return strctinfo;
     }
     else if (!sty->mutabl) {
@@ -1969,13 +2282,21 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
         if (sty->size == 0)
             return ghostValue(sty);
         if (nargs >= 2)
-            return emit_unboxed(args[1], ctx);  // do side effects
+            return emit_expr(args[1], ctx);  // do side effects
         Type *lt = julia_type_to_llvm(ty);
-        return mark_julia_type(UndefValue::get(lt), ty);
+        assert(lt != T_pjlvalue);
+        return mark_julia_type(UndefValue::get(lt), false, ty, ctx);
     }
     else {
         // 0 fields, singleton
         assert(sty->instance != NULL);
-        return mark_julia_type(literal_pointer_val(sty->instance), sty);
+        return mark_julia_const(sty->instance);
     }
 }
+
+static Value *emit_exc_in_transit(jl_codectx_t *ctx)
+{
+    Value *pexc_in_transit = builder.CreateBitCast(ctx->ptlsStates, T_ppjlvalue);
+    Constant *offset = ConstantInt::getSigned(T_int32, offsetof(jl_tls_states_t, exception_in_transit) / sizeof(void*));
+    return builder.CreateGEP(pexc_in_transit, ArrayRef<Value*>(offset), "jl_exception_in_transit");
+}
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 28fad20181102..e769e530eee34 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -35,6 +35,7 @@
 #include <llvm/Analysis/Passes.h>
 #include <llvm/Bitcode/ReaderWriter.h>
 #ifdef LLVM37
+#include <llvm/Analysis/TargetTransformInfo.h>
 #include <llvm/Analysis/TargetLibraryInfo.h>
 #else
 #include <llvm/Target/TargetLibraryInfo.h>
@@ -50,16 +51,6 @@
 #include <llvm/Analysis/Verifier.h>
 #endif
 #include <llvm/DebugInfo/DIContext.h>
-#ifdef USE_MCJIT
-#include <llvm/ExecutionEngine/MCJIT.h>
-#include <llvm/ExecutionEngine/SectionMemoryManager.h>
-#include <llvm/ADT/DenseMapInfo.h>
-#include <llvm/Object/ObjectFile.h>
-#else
-#include <llvm/ExecutionEngine/JIT.h>
-#include <llvm/ExecutionEngine/JITMemoryManager.h>
-#include <llvm/ExecutionEngine/Interpreter.h>
-#endif
 #include <llvm/IR/DerivedTypes.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Module.h>
@@ -87,6 +78,24 @@
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Transforms/Utils/Cloning.h>
 
+#if defined(USE_ORCJIT)
+#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
+#include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h"
+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/ObjectMemoryBuffer.h"
+#elif defined(USE_MCJIT)
+#include <llvm/ExecutionEngine/MCJIT.h>
+#include <llvm/ExecutionEngine/SectionMemoryManager.h>
+#include <llvm/ADT/DenseMapInfo.h>
+#include <llvm/Object/ObjectFile.h>
+#else
+#include <llvm/ExecutionEngine/JIT.h>
+#include <llvm/ExecutionEngine/JITMemoryManager.h>
+#include <llvm/ExecutionEngine/Interpreter.h>
+#endif
+
 #if defined(_OS_WINDOWS_) && !defined(NOMINMAX)
 #define NOMINMAX
 #endif
@@ -107,13 +116,21 @@
 using namespace llvm;
 
 // LLVM version compatibility macros
-#if LLVM37
+#ifdef LLVM37
 using namespace llvm::legacy;
 #define LLVM37_param(x) (x),
 #else
 #define LLVM37_param(x)
 #endif
 
+#ifndef LLVM35
+#define AddrSpaceCastInst BitCastInst
+#endif
+
+#if !defined(_COMPILER_MICROSOFT_) && __cplusplus < 201103L
+#  define static_assert(...)
+#endif
+
 extern "C" {
 
 #include "builtin_proto.h"
@@ -122,11 +139,12 @@ extern "C" {
 extern uintptr_t __stack_chk_guard;
 extern void __stack_chk_fail();
 #else
-DLLEXPORT uintptr_t __stack_chk_guard = (uintptr_t)0xBAD57ACCBAD67ACC; // 0xBADSTACKBADSTACK
-DLLEXPORT void __stack_chk_fail()
+JL_DLLEXPORT uintptr_t __stack_chk_guard = (uintptr_t)0xBAD57ACCBAD67ACC; // 0xBADSTACKBADSTACK
+JL_DLLEXPORT void __stack_chk_fail()
 {
     /* put your panic function or similar in here */
     fprintf(stderr, "fatal error: stack corruption detected\n");
+    gc_debug_critical_error();
     abort(); // end with abort, since the compiler destroyed the stack upon entry to this function, there's no going back now
 }
 #endif
@@ -159,41 +177,64 @@ extern void _chkstk(void);
 #define DISABLE_FLOAT16
 
 // llvm state
-DLLEXPORT LLVMContext &jl_LLVMContext = getGlobalContext();
+JL_DLLEXPORT LLVMContext &jl_LLVMContext = getGlobalContext();
 static IRBuilder<> builder(getGlobalContext());
-static bool nested_compile=false;
-DLLEXPORT ExecutionEngine *jl_ExecutionEngine;
-DLLEXPORT TargetMachine *jl_TargetMachine;
+static bool nested_compile = false;
+static TargetMachine *jl_TargetMachine;
+
+extern JITEventListener *CreateJuliaJITEventListener();
+
+namespace llvm {
+    extern Pass *createLowerSimdLoopPass();
+    extern bool annotateSimdLoop(BasicBlock *latch);
+}
+
+// for image reloading
+static bool imaging_mode = false;
+
+#include "jitlayers.cpp"
+
+#ifdef USE_ORCJIT
+JuliaOJIT *jl_ExecutionEngine;
+#else
+ExecutionEngine *jl_ExecutionEngine;
+#endif
+
 #ifdef USE_MCJIT
 static Module *shadow_module;
-DLLEXPORT RTDyldMemoryManager *jl_mcjmm;
+static Module *builtins_module;
+static Module *active_module;
 #define jl_Module (builder.GetInsertBlock()->getParent()->getParent())
 #else
 static Module *jl_Module;
 #define shadow_module jl_Module
+#define active_module jl_Module
+#define builtins_module jl_Module
 #endif
 static MDBuilder *mbuilder;
 static std::map<int, std::string> argNumberStrings;
+#ifdef LLVM38
+static legacy::FunctionPassManager *FPM;
+#else
 static FunctionPassManager *FPM;
+#endif
 
 #ifdef LLVM37
 // No DataLayout pass needed anymore.
-#elif LLVM35
+#elif defined(LLVM35)
 static DataLayoutPass *jl_data_layout;
 #else
 static DataLayout *jl_data_layout;
 #endif
 
-// for image reloading
-static bool imaging_mode = false;
-
 // types
-static Type *jl_value_llvmt;
-static Type *jl_pvalue_llvmt;
-static Type *jl_ppvalue_llvmt;
-static Type* jl_parray_llvmt;
+static Type *T_jlvalue;
+static Type *T_pjlvalue;
+static Type *T_ppjlvalue;
+static Type *jl_parray_llvmt;
 static FunctionType *jl_func_sig;
-static Type *jl_pfptr_llvmt;
+static FunctionType *jl_func_sig_sparams;
+static Type *T_pvoidfunc;
 
 static IntegerType *T_int1;
 static IntegerType *T_int8;
@@ -209,8 +250,10 @@ static IntegerType *T_uint64;
 static IntegerType *T_char;
 static IntegerType *T_size;
 
+static Type *T_float16;
 static Type *T_float32;
 static Type *T_float64;
+static Type *T_float128;
 
 static Type *T_pint8;
 static Type *T_pint16;
@@ -220,25 +263,23 @@ static Type *T_psize;
 static Type *T_pfloat32;
 static Type *T_pfloat64;
 
+static Type *T_ppint8;
+static Type *T_pppint8;
+
 static Type *T_void;
 
 // type-based alias analysis nodes.  Indentation of comments indicates hierarchy.
-static MDNode* tbaa_user;           // User data that is mutable
-static MDNode* tbaa_immut;          // User data inside a heap-allocated immutable
-static MDNode* tbaa_value;          // Julia value
-static MDNode* tbaa_array;              // Julia array
-static MDNode* tbaa_arrayptr;               // The pointer inside a jl_array_t
-static MDNode* tbaa_arraysize;              // A size in a jl_array_t
-static MDNode* tbaa_arraylen;               // The len in a jl_array_t
-static MDNode* tbaa_sveclen;           // The len in a jl_svec_t
-static MDNode* tbaa_func;           // A jl_function_t
-static MDNode* tbaa_datatype;       // A jl_datatype_t
-static MDNode* tbaa_const;          // Memory that is immutable by the time LLVM can see it
-
-namespace llvm {
-    extern Pass *createLowerSimdLoopPass();
-    extern bool annotateSimdLoop( BasicBlock* latch );
-}
+static MDNode *tbaa_user;           // User data that is mutable
+static MDNode *tbaa_immut;          // User data inside a heap-allocated immutable
+static MDNode *tbaa_value;          // Julia value
+static MDNode *tbaa_array;              // Julia array
+static MDNode *tbaa_arrayptr;               // The pointer inside a jl_array_t
+static MDNode *tbaa_arraysize;              // A size in a jl_array_t
+static MDNode *tbaa_arraylen;               // The len in a jl_array_t
+static MDNode *tbaa_sveclen;           // The len in a jl_svec_t
+static MDNode *tbaa_func;           // A jl_function_t
+static MDNode *tbaa_datatype;       // A jl_datatype_t
+static MDNode *tbaa_const;          // Memory that is immutable by the time LLVM can see it
 
 // Basic DITypes
 #ifdef LLVM37
@@ -262,7 +303,7 @@ static Value *V_null;
 static Type *NoopType;
 static Value *literal_pointer_val(jl_value_t *p);
 extern "C" {
-DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt);
+JL_DLLEXPORT Type *julia_type_to_llvm(jl_value_t *jt, bool *isboxed=NULL);
 }
 static bool type_is_ghost(Type *ty)
 {
@@ -277,11 +318,9 @@ static GlobalVariable *jlemptytuple_var;
 #if defined(_CPU_X86_)
 #define JL_NEED_FLOATTEMP_VAR 1
 #endif
-#if JL_NEED_FLOATTEMP_VAR
+#ifdef JL_NEED_FLOATTEMP_VAR
 static GlobalVariable *jlfloattemp_var;
 #endif
-static GlobalVariable *jlpgcstack_var;
-static GlobalVariable *jlexc_var;
 static GlobalVariable *jldiverr_var;
 static GlobalVariable *jlundeferr_var;
 static GlobalVariable *jldomerr_var;
@@ -292,18 +331,29 @@ static GlobalVariable *jlRTLD_DEFAULT_var;
 static GlobalVariable *jlexe_var;
 static GlobalVariable *jldll_var;
 #if defined(_CPU_X86_64_) && !defined(USE_MCJIT)
-extern JITMemoryManager* createJITMemoryManagerWin();
+extern JITMemoryManager *createJITMemoryManagerWin();
 #endif
 #endif //_OS_WINDOWS_
 #if defined(_OS_DARWIN_) && defined(LLVM37) && defined(LLVM_SHLIB)
-#define CUSTOM_MEMORY_MANAGER 1
-extern RTDyldMemoryManager* createRTDyldMemoryManagerOSX();
+#define CUSTOM_MEMORY_MANAGER createRTDyldMemoryManagerOSX
+extern RTDyldMemoryManager *createRTDyldMemoryManagerOSX();
+#elif defined(_OS_LINUX_) && defined(LLVM37) && defined(JL_UNW_HAS_FORMAT_IP)
+#define CUSTOM_MEMORY_MANAGER createRTDyldMemoryManagerUnix
+extern RTDyldMemoryManager *createRTDyldMemoryManagerUnix();
+#endif
+
+static Function *jltls_states_func;
+#ifndef JULIA_ENABLE_THREADING
+static GlobalVariable *jltls_states_var;
+#else
+// Imaging mode only
+static GlobalVariable *jltls_states_func_ptr = NULL;
+static size_t jltls_states_func_idx = 0;
 #endif
 
 // important functions
 static Function *jlnew_func;
 static Function *jlthrow_func;
-static Function *jlthrow_line_func;
 static Function *jlerror_func;
 static Function *jltypeerror_func;
 static Function *jlundefvarerror_func;
@@ -314,14 +364,14 @@ static Function *jlboundserrorv_func;
 static Function *jlcheckassign_func;
 static Function *jldeclareconst_func;
 static Function *jlgetbindingorerror_func;
+static Function *jlpref_func;
+static Function *jlpset_func;
 static Function *jltopeval_func;
 static Function *jlcopyast_func;
 static Function *jltuple_func;
 static Function *jlnsvec_func;
 static Function *jlapplygeneric_func;
 static Function *jlgetfield_func;
-static Function *jlbox_func;
-static Function *jlclosure_func;
 static Function *jlmethod_func;
 static Function *jlgenericfunction_func;
 static Function *jlenter_func;
@@ -351,11 +401,15 @@ static Function *box8_func;
 static Function *box16_func;
 static Function *box32_func;
 static Function *box64_func;
-static Function *wbfunc;
 static Function *queuerootfun;
 static Function *expect_func;
 static Function *jldlsym_func;
 static Function *jlnewbits_func;
+static Function *jltypeassert_func;
+#ifndef LLVM36
+static Function *jlpow_func;
+static Function *jlpowf_func;
+#endif
 //static Function *jlgetnthfield_func;
 static Function *jlgetnthfieldchecked_func;
 //static Function *jlsetnthfield_func;
@@ -364,73 +418,80 @@ static Function *resetstkoflw_func;
 #endif
 static Function *diff_gc_total_bytes_func;
 
+// placeholder functions
+static Function *gcroot_func;
+static Function *gcstore_func;
+static Function *gckill_func;
+static Function *jlcall_frame_func;
+
 static std::vector<Type *> two_pvalue_llvmt;
 static std::vector<Type *> three_pvalue_llvmt;
 
 static std::map<jl_fptr_t, Function*> builtin_func_map;
 
-extern "C" DLLEXPORT void jl_gc_wb_slow(jl_value_t* parent, jl_value_t* ptr)
-{
-    jl_gc_wb(parent, ptr);
-}
-
 // --- code generation ---
 
 // metadata tracking for a llvm Value* during codegen
 struct jl_cgval_t {
     Value *V; // may be of type T* or T, or set to NULL if ghost (or if the value has not been initialized yet, for a variable definition)
+    jl_value_t *constant; // constant value (rooted in linfo.def.roots)
+    Value *gcroot; // the gcroot associated with V (if it has one)
     jl_value_t *typ; // the original type of V, never NULL
     //Type *T; // cached result of julia_type_to_llvm(typ)
     bool isboxed; // whether this value is a jl_value_t* allocated on the heap with the right type tag
     bool isghost; // whether this value is "ghost"
     bool ispointer; // whether this value is actually pointer to the value
     bool isimmutable; // V points to something that is definitely immutable (e.g. not stack allocated)
-    //bool isbox; // points to memory inside a jl_box_t*
     //bool isstack; // points to stack-allocated memory
     //bool isarg; // derived from an argument
-    bool needsgcroot; // this value needs a gcroot
-    jl_cgval_t(Value *V, jl_value_t *typ) : // general constructor (with pointer type auto-detect)
+    jl_cgval_t(Value *V, Value *gcroot, bool isboxed, jl_value_t *typ) : // general constructor (with pointer type auto-detect)
         V(V), // V is allowed to be NULL in a jl_varinfo_t context, but not during codegen contexts
+        constant(NULL),
+        gcroot(gcroot),
         typ(typ),
         //T(julia_type_to_llvm(typ)),
-        isboxed(V && V->getType() == jl_pvalue_llvmt),
+        isboxed(isboxed),
         isghost(false),
-        ispointer(this->isboxed),
-        isimmutable(this->isboxed && jl_is_immutable_datatype(typ)),
-        needsgcroot(this->isboxed)
+        ispointer(isboxed),
+        isimmutable(isboxed && jl_is_immutable_datatype(typ))
     {
     }
     jl_cgval_t(jl_value_t *typ) : // ghost value constructor
         V(NULL),
+        constant(((jl_datatype_t*)typ)->instance),
+        gcroot(NULL),
         typ(typ),
         //T(T_void),
         isboxed(false),
         isghost(true),
         ispointer(false),
-        isimmutable(true),
-        needsgcroot(false)
+        isimmutable(true)
     {
+        assert(jl_is_datatype(typ));
+        assert(constant);
     }
     jl_cgval_t(const jl_cgval_t &v, jl_value_t *typ) : // copy constructor with new type
         V(v.V),
+        constant(v.constant),
+        gcroot(v.gcroot),
         typ(typ),
         //T(V.T),
         isboxed(v.isboxed),
         isghost(v.isghost),
         ispointer(v.ispointer),
-        isimmutable(v.isimmutable),
-        needsgcroot(v.needsgcroot)
+        isimmutable(v.isimmutable)
     {
         assert(isboxed || v.typ == typ); // expect a badly or equivalently typed version
     }
     jl_cgval_t() : // undef / unreachable / default constructor
         V(UndefValue::get(T_void)),
-        typ(jl_bottom_type), // TODO: jl_bottom_type?
+        constant(NULL),
+        gcroot(NULL),
+        typ(jl_bottom_type),
         isboxed(false),
         isghost(true),
         ispointer(false),
-        isimmutable(true),
-        needsgcroot(false)
+        isimmutable(true)
     {
     }
 };
@@ -444,13 +505,10 @@ struct jl_varinfo_t {
 #else
     DIVariable dinfo;
 #endif
-    int closureidx;   // index in closure env, or -1
     bool isAssigned;
-    bool isCaptured;
     bool isSA;
     bool isVolatile;
     bool isArgument;
-    bool isBox;
     bool hasGCRoot;
     bool escapes;
     bool usedUndef;
@@ -462,8 +520,8 @@ struct jl_varinfo_t {
 #else
                      dinfo(DIVariable()),
 #endif
-                     closureidx(-1), isAssigned(true), isCaptured(false), isSA(false),
-                     isVolatile(false), isArgument(false), isBox(false), hasGCRoot(false),
+                     isAssigned(true), isSA(false),
+                     isVolatile(false), isArgument(false), hasGCRoot(false),
                      escapes(true), usedUndef(false), used(false)
     {
     }
@@ -493,16 +551,12 @@ typedef struct {
     jl_value_t *ty;
 } jl_arrayvar_t;
 
-struct jl_gcinfo_t {
-    AllocaInst *gcframe;
-    Value *argSlot;
-    GetElementPtrInst *tempSlot;
-    int argDepth;
-    int maxDepth;
-    int argSpaceSize;
-    BasicBlock::iterator first_gcframe_inst;
-    BasicBlock::iterator last_gcframe_inst;
-};
+// Keeps tracks of all functions and compile units created during this cycle
+// to be able to atomically add them to a module.
+typedef struct {
+    std::vector<Function *> functions;
+    std::vector<DICompileUnit *> CUs;
+} jl_cyclectx_t;
 
 // information about the context of a piece of code: its enclosing
 // function and module, and visible local variables and labels.
@@ -519,52 +573,61 @@ typedef struct {
     std::map<int, Value*> *handlers;
     jl_module_t *module;
     jl_expr_t *ast;
-    jl_svec_t *sp;
     jl_lambda_info_t *linfo;
+    Value *spvals_ptr;
     Value *argArray;
     Value *argCount;
     std::string funcName;
     jl_sym_t *vaName;  // name of vararg argument
     bool vaStack;      // varargs stack-allocated
+    bool sret;
     int nReqArgs;
-    int lineno;
     std::vector<bool> boundsCheck;
+    std::vector<bool> inbounds;
 
-    jl_gcinfo_t gc;
+    CallInst *ptlsStates;
 
     llvm::DIBuilder *dbuilder;
     bool debug_enabled;
     std::vector<CallInst*> to_inline;
+
+    jl_cyclectx_t *cyclectx;
 } jl_codectx_t;
 
+typedef struct {
+    int64_t isref;
+    Function *f;
+} cFunction_t;
+
 typedef struct {
     size_t len;
-    struct {
-        int64_t isref;
-        Function *f;
-    } data[];
+    // cFunction_t data[];
+    cFunction_t *data()
+    {
+        return (cFunction_t*)((char*)this + sizeof(*this));
+    }
 } cFunctionList_t;
 
-static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool boxed=true,
-                        bool valuepos=true);
-static jl_cgval_t emit_unboxed(jl_value_t *e, jl_codectx_t *ctx);
+static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx);
 static int is_global(jl_sym_t *s, jl_codectx_t *ctx);
 
-static Value *make_gcroot(Value *v, jl_codectx_t *ctx);
-static jl_cgval_t emit_boxed_rooted(jl_value_t *e, jl_codectx_t *ctx);
+static Value* emit_local_slot(jl_codectx_t *ctx);
+static void mark_gc_use(const jl_cgval_t &v);
+static Value *make_jlcall(ArrayRef<const jl_cgval_t*> args, jl_codectx_t *ctx);
 static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
                                      jl_binding_t **pbnd, bool assign, jl_codectx_t *ctx);
 static jl_cgval_t emit_checked_var(Value *bp, jl_sym_t *name, jl_codectx_t *ctx, bool isvol=false);
-static bool might_need_root(jl_value_t *ex);
 static Value *emit_condition(jl_value_t *cond, const std::string &msg, jl_codectx_t *ctx);
-static void allocate_gc_frame(size_t n_roots, BasicBlock *b0, jl_codectx_t *ctx);
-static void finalize_gc_frame(jl_codectx_t *ctx);
+static void allocate_gc_frame(BasicBlock *b0, jl_codectx_t *ctx);
+static void finalize_gc_frame(Function *F);
+static void finalize_gc_frame(Module *m);
+static GlobalVariable *prepare_global(GlobalVariable *G);
 
 // --- convenience functions for tagging llvm values with julia types ---
 
 static AllocaInst *emit_static_alloca(Type *lty, int arraysize, jl_codectx_t *ctx)
 {
-    return new AllocaInst(lty, ConstantInt::get(T_int32, arraysize), "", /*InsertBefore=*/ctx->gc.gcframe);
+    return new AllocaInst(lty, ConstantInt::get(T_int32, arraysize), "", /*InsertBefore=*/ctx->ptlsStates);
 }
 static AllocaInst *emit_static_alloca(Type *lty, jl_codectx_t *ctx)
 {
@@ -573,12 +636,13 @@ static AllocaInst *emit_static_alloca(Type *lty, jl_codectx_t *ctx)
 static AllocaInst *emit_static_alloca(Type *lty)
 {
     return new AllocaInst(lty, "",
-            /*InsertBefore=*/builder.GetInsertBlock()->getParent()->getEntryBlock().getFirstInsertionPt());
+            /*InsertBefore=*/&*builder.GetInsertBlock()->getParent()->getEntryBlock().getFirstInsertionPt());
 }
 
 static inline jl_cgval_t ghostValue(jl_value_t *typ)
 {
-    assert(typ == jl_bottom_type || jl_is_datatype(typ));
+    if (typ == jl_bottom_type)
+        return jl_cgval_t(); // Undef{}
     return jl_cgval_t(typ);
 }
 static inline jl_cgval_t ghostValue(jl_datatype_t *typ)
@@ -589,29 +653,36 @@ static inline jl_cgval_t ghostValue(jl_datatype_t *typ)
 static inline jl_cgval_t mark_julia_slot(Value *v, jl_value_t *typ)
 {
     // eagerly put this back onto the stack
-    jl_cgval_t tagval(v, typ);
+    assert(v->getType() != T_pjlvalue);
+    jl_cgval_t tagval(v, NULL, false, typ);
     tagval.ispointer = true;
     return tagval;
 }
 
-static inline jl_cgval_t mark_julia_type(Value *v, jl_value_t *typ)
+static inline jl_cgval_t mark_julia_type(Value *v, bool isboxed, jl_value_t *typ, jl_codectx_t *ctx, bool needsroot = true)
 {
     Type *T = julia_type_to_llvm(typ);
     if (type_is_ghost(T)) {
         return ghostValue(typ);
     }
-    if (v && T->isAggregateType() && v->getType() != jl_pvalue_llvmt) {
+    if (v && T->isAggregateType() && !isboxed) {
+        assert(v->getType() != T_pjlvalue);
         // eagerly put this back onto the stack
         // llvm mem2reg pass will remove this if unneeded
         Value *loc = emit_static_alloca(T);
         builder.CreateStore(v, loc);
         return mark_julia_slot(loc, typ);
     }
-    return jl_cgval_t(v, typ);
+    Value *froot = NULL;
+    if (needsroot && isboxed) {
+        froot = emit_local_slot(ctx);
+        builder.CreateStore(v, froot);
+    }
+    return jl_cgval_t(v, froot, isboxed, typ);
 }
-static inline jl_cgval_t mark_julia_type(Value *v, jl_datatype_t *typ)
+static inline jl_cgval_t mark_julia_type(Value *v, bool isboxed, jl_datatype_t *typ, jl_codectx_t *ctx, bool needsroot = true)
 {
-    return mark_julia_type(v, (jl_value_t*)typ);
+    return mark_julia_type(v, isboxed, (jl_value_t*)typ, ctx, needsroot);
 }
 
 static inline jl_cgval_t remark_julia_type(const jl_cgval_t &v, jl_value_t *typ)
@@ -624,35 +695,26 @@ static inline jl_cgval_t remark_julia_type(const jl_cgval_t &v, jl_value_t *typ)
 }
 static inline jl_cgval_t mark_julia_const(jl_value_t *jv)
 {
-    jl_value_t *typ = jl_typeof(jv);
+    jl_value_t *typ;
+    if (jl_is_datatype(jv) || jl_is_uniontype(jv) || jl_is_typector(jv))
+        typ = (jl_value_t*)jl_wrap_Type(jv);
+    else
+        typ = jl_typeof(jv);
     if (type_is_ghost(julia_type_to_llvm(typ))) {
         return ghostValue(typ);
     }
-    return jl_cgval_t(literal_pointer_val(jv), typ);
+    jl_cgval_t constant(NULL, NULL, true, typ);
+    constant.constant = jv;
+    return constant;
 }
 
 
-static Value *emit_reg2mem(Value *v, jl_codectx_t *ctx) {
-    return v;
-}
-
 // --- utilities ---
 
 extern "C" {
     int globalUnique = 0;
 }
 
-extern "C" DLLEXPORT
-jl_value_t *jl_get_cpu_name(void)
-{
-#if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR < 5
-    std::string HostCPUName = llvm::sys::getHostCPUName();
-#else
-    StringRef HostCPUName = llvm::sys::getHostCPUName();
-#endif
-    return jl_pchar_to_string(HostCPUName.data(), HostCPUName.size());
-}
-
 static void emit_write_barrier(jl_codectx_t*, Value*, Value*);
 
 #include "cgutils.cpp"
@@ -696,7 +758,7 @@ static bool store_unboxed_p(jl_sym_t *s, jl_codectx_t *ctx)
     jl_varinfo_t &vi = ctx->vars[s];
     // only store a variable unboxed if type inference has run, which
     // checks that the variable is not referenced undefined.
-    return (ctx->linfo->inferred && !vi.isCaptured && !vi.usedUndef &&
+    return (ctx->linfo->inferred && !vi.usedUndef &&
             // don't unbox vararg tuples
             s != ctx->vaName && store_unboxed_p(vi.value.typ));
 }
@@ -706,18 +768,20 @@ static void alloc_local(jl_sym_t *s, jl_codectx_t *ctx)
     jl_varinfo_t &vi = ctx->vars[s];
     jl_value_t *jt = vi.value.typ;
     assert(store_unboxed_p(s,ctx));
-    Type *vtype = julia_struct_to_llvm(jt);
-    assert(vtype != jl_pvalue_llvmt);
+    Type *vtype = julia_type_to_llvm(jt);
+    assert(vtype != T_pjlvalue);
     if (type_is_ghost(vtype)) {
         vi.value = ghostValue(jt);
         return;
     }
     // CreateAlloca is OK here because alloc_local is only called during prologue setup
-    Value *lv = builder.CreateAlloca(vtype, 0, s->name);
+    Value *lv = builder.CreateAlloca(vtype, 0, jl_symbol_name(s));
     vi.value = mark_julia_slot(lv, jt);
+    vi.value.isimmutable &= vi.isSA; // slot is not immutable if there are multiple assignments
     assert(vi.value.isboxed == false);
 #ifdef LLVM36
     if (ctx->debug_enabled) {
+        prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::dbg_declare));
 #ifdef LLVM37
         ctx->dbuilder->insertDeclare(lv, vi.dinfo, ctx->dbuilder->createExpression(),
                 builder.getCurrentDebugLocation().get(), builder.GetInsertBlock());
@@ -753,190 +817,340 @@ static void maybe_alloc_arrayvar(jl_sym_t *s, jl_codectx_t *ctx)
     }
 }
 
+// Snooping on which functions are being compiled, and how long it takes
+JL_STREAM *dump_compiles_stream = NULL;
+uint64_t last_time = 0;
+extern "C" JL_DLLEXPORT
+void jl_dump_compiles(void *s)
+{
+    dump_compiles_stream = (JL_STREAM*)s;
+}
+
 // --- entry point ---
 //static int n_emit=0;
-static Function *emit_function(jl_lambda_info_t *lam);
+static void emit_function(jl_lambda_info_t *lam, jl_llvm_functions_t *declarations,
+    jl_llvm_functions_t *definitions, jl_cyclectx_t *cyclectx);
+static void jl_finalize_module(Module *m);
+void jl_add_linfo_in_flight(StringRef name, jl_lambda_info_t *linfo, const DataLayout &DL);
+
 //static int n_compile=0;
-static Function *to_function(jl_lambda_info_t *li)
+static Function *to_function(jl_lambda_info_t *li, jl_cyclectx_t *cyclectx)
 {
+    JL_LOCK(codegen);
     JL_SIGATOMIC_BEGIN();
     assert(!li->inInference);
     BasicBlock *old = nested_compile ? builder.GetInsertBlock() : NULL;
     DebugLoc olddl = builder.getCurrentDebugLocation();
     bool last_n_c = nested_compile;
+    if (!nested_compile && dump_compiles_stream != NULL)
+        last_time = jl_hrtime();
     nested_compile = true;
     jl_gc_inhibit_finalizers(nested_compile);
-    Function *f = NULL;
+    Function *f = NULL, *specf = NULL;
     JL_TRY {
-        f = emit_function(li);
+        jl_llvm_functions_t definitions;
+        #if defined(USE_MCJIT) || defined(USE_ORCJIT)
+        jl_cyclectx_t *newcyclectx = cyclectx;
+        if (!newcyclectx)
+            newcyclectx = new jl_cyclectx_t;
+        emit_function(li, &li->functionObjects, &definitions, newcyclectx);
+        // If we're the root of the cycle, realize all functions
+        if (!cyclectx) {
+            realize_cycle(newcyclectx);
+            delete newcyclectx;
+        }
+        #else
+        emit_function(li, &li->functionObjects, &definitions, NULL);
+        #endif
+        f = (llvm::Function*)definitions.functionObject;
+        specf = (llvm::Function*)definitions.specFunctionObject;
+        li->functionID = jl_assign_functionID(f, 0);
+        if (specf)
+            li->specFunctionID = jl_assign_functionID(specf, 1);
+        if (f->getFunctionType() != jl_func_sig)
+            // mark the pointer as jl_fptr_sparam_t calling convention
+            li->jlcall_api = 1;
         //n_emit++;
     }
     JL_CATCH {
-        li->functionObject = NULL;
-        li->specFunctionObject = NULL;
-        li->cFunctionList = NULL;
+        li->functionObjects.functionObject = NULL;
+        li->functionObjects.specFunctionObject = NULL;
+        li->functionObjects.cFunctionList = NULL;
         nested_compile = last_n_c;
         if (old != NULL) {
             builder.SetInsertPoint(old);
             builder.SetCurrentDebugLocation(olddl);
         }
         JL_SIGATOMIC_END();
-        jl_rethrow_with_add("error compiling %s", li->name->name);
+        JL_UNLOCK(codegen);
+        jl_rethrow_with_add("error compiling %s", jl_symbol_name(li->name));
     }
     assert(f != NULL);
-#ifdef JL_DEBUG_BUILD
-#ifdef LLVM35
-    llvm::raw_fd_ostream out(1,false);
-#endif
-    if (
+    const DataLayout &DL =
 #ifdef LLVM35
-        verifyFunction(*f,&out)
+        f->getParent()->getDataLayout();
 #else
-        verifyFunction(*f,PrintMessageAction)
-#endif
-        ) {
+        *jl_data_layout;
+#endif
+    // record that this function name came from this linfo,
+    // so we can build a reverse mapping for debug-info.
+    if (li->name != anonymous_sym) {
+        // but don't remember anonymous symbols because
+        // they may not be rooted in the gc for the life of the program,
+        // and the runtime doesn't notify us when the code becomes unreachable :(
+        jl_add_linfo_in_flight((specf ? specf : f)->getName(), li, DL);
+    }
+#if !defined(USE_MCJIT) && !defined(USE_ORCJIT)
+    finalize_gc_frame(f);
+    if (specf) finalize_gc_frame(specf);
+#ifdef JL_DEBUG_BUILD
+    if (verifyFunction(*f, PrintMessageAction) ||
+        (specf && verifyFunction(*specf, PrintMessageAction))) {
         f->dump();
+        if (specf) specf->dump();
+        gc_debug_critical_error();
         abort();
     }
 #endif
     FPM->run(*f);
-    //n_compile++;
-    // print out the function's LLVM code
-    //jl_static_show(JL_STDERR, (jl_value_t*)li);
-    //jl_printf(JL_STDERR, "%s:%d\n",
-    //           ((jl_sym_t*)li->file)->name, li->line);
-    //f->dump();
-    //if (verifyFunction(*f,PrintMessageAction)) {
-    //    f->dump();
-    //    abort();
-    //}
+    if (specf) FPM->run(*specf);
+#endif
+
     if (old != NULL) {
         builder.SetInsertPoint(old);
         builder.SetCurrentDebugLocation(olddl);
     }
     nested_compile = last_n_c;
     jl_gc_inhibit_finalizers(nested_compile);
+    JL_UNLOCK(codegen);
     JL_SIGATOMIC_END();
-    return f;
+    if (dump_compiles_stream != NULL) {
+        uint64_t this_time = jl_hrtime();
+        jl_printf(dump_compiles_stream, "%" PRIu64 "\t\"", this_time - last_time);
+        jl_static_show(dump_compiles_stream, (jl_value_t*)li);
+        jl_printf(dump_compiles_stream, "\"\n");
+        last_time = this_time;
+    }
+    return specf ? specf : f;
+}
+
+#ifndef LLVM37
+static Value *getModuleFlag(Module *m, StringRef Key)
+{
+    SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
+    m->getModuleFlagsMetadata(ModuleFlags);
+    SmallVector<Module::ModuleFlagEntry, 8>::iterator it = ModuleFlags.begin();
+    for (;it != ModuleFlags.end(); ++it) {
+        if (Key == it->Key->getString())
+            return it->Val;
+    }
+    return NULL;
 }
+#else
+#define getModuleFlag(m,str) m->getModuleFlag(str)
+#endif
 
-static void jl_setup_module(Module *m, bool add)
+static void jl_setup_module(Module *m)
 {
-    m->addModuleFlag(llvm::Module::Warning, "Dwarf Version",2);
+    if (!getModuleFlag(m,"Dwarf Version"))
+        m->addModuleFlag(llvm::Module::Warning, "Dwarf Version",2);
 #ifdef LLVM34
-    m->addModuleFlag(llvm::Module::Error, "Debug Info Version",
-        llvm::DEBUG_METADATA_VERSION);
+    if (!getModuleFlag(m,"Debug Info Version"))
+        m->addModuleFlag(llvm::Module::Error, "Debug Info Version",
+            llvm::DEBUG_METADATA_VERSION);
 #endif
 #ifdef LLVM37
-    if (jl_ExecutionEngine) {
-#ifdef LLVM38
-        m->setDataLayout(jl_ExecutionEngine->getDataLayout().getStringRepresentation());
+#ifdef USE_ORCJIT
+    m->setDataLayout(jl_ExecutionEngine->getDataLayout());
+#elif defined(LLVM38)
+    m->setDataLayout(jl_ExecutionEngine->getDataLayout().getStringRepresentation());
 #else
-        m->setDataLayout(jl_ExecutionEngine->getDataLayout()->getStringRepresentation());
+    m->setDataLayout(jl_ExecutionEngine->getDataLayout()->getStringRepresentation());
 #endif
-        m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
-    }
-#elif LLVM36
-    if (jl_ExecutionEngine)
-        m->setDataLayout(jl_ExecutionEngine->getDataLayout());
+    m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
+#elif defined(LLVM36)
+    m->setDataLayout(jl_ExecutionEngine->getDataLayout());
 #endif
-    if (add) {
-        assert(jl_ExecutionEngine);
-#ifdef LLVM36
-        jl_ExecutionEngine->addModule(std::unique_ptr<Module>(m));
+}
+
+static void jl_finalize_module(Module *m)
+{
+#if defined(_CPU_X86_64_) && defined(_OS_WINDOWS_) && defined(USE_MCJIT)
+    ArrayType *atype = ArrayType::get(T_uint32,3); // want 4-byte alignment of 12-bytes of data
+    (new GlobalVariable(*m, atype,
+        false, GlobalVariable::InternalLinkage,
+        ConstantAggregateZero::get(atype), "__UnwindData"))->setSection(".text");
+    (new GlobalVariable(*m, atype,
+        false, GlobalVariable::InternalLinkage,
+        ConstantAggregateZero::get(atype), "__catchjmp"))->setSection(".text");
+#endif
+    finalize_gc_frame(m);
+    assert(jl_ExecutionEngine);
+#if defined(LLVM36) && !defined(USE_ORCJIT)
+    jl_ExecutionEngine->addModule(std::unique_ptr<Module>(m));
 #else
-        jl_ExecutionEngine->addModule(m);
+    jl_ExecutionEngine->addModule(m);
 #endif
-#if defined(_CPU_X86_64_) && defined(_OS_WINDOWS_) && defined(USE_MCJIT)
-        ArrayType *atype = ArrayType::get(T_uint32,3); // want 4-byte alignment of 12-bytes of data
-        (new GlobalVariable(*m, atype,
-            false, GlobalVariable::InternalLinkage,
-            ConstantAggregateZero::get(atype), "__UnwindData"))->setSection(".text");
-        (new GlobalVariable(*m, atype,
-            false, GlobalVariable::InternalLinkage,
-            ConstantAggregateZero::get(atype), "__catchjmp"))->setSection(".text");
+}
+
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+#ifdef JL_DEBUG_BUILD
+static void writeRecoveryFile(llvm::Module *mod)
+{
+    std::error_code err;
+    mod->dump();
+    std::cout << "Julia emitted a broken LLVM module (about to be __jl_dump.bc)."
+              << "Please file a bug report.\n"
+              << "If the module writing below fails,"
+              << "please include the textual representation printed above this error.";
+    StringRef fname_ref = StringRef("__jl_dump.bc");
+    raw_fd_ostream OS(fname_ref, err, sys::fs::F_None);
+    WriteBitcodeToFile(mod,OS);
+    OS.flush();
+    gc_debug_critical_error();
+    abort();
+}
 #endif
+
+static uint64_t getAddressForOrCompileFunction(llvm::Function *llvmf)
+{
+    #ifdef JL_DEBUG_BUILD
+    llvm::raw_fd_ostream out(1,false);
+    #endif
+    Function *ActiveF = active_module->getFunction(llvmf->getName());
+    // Must have been in a prior module. Safe to ask the execution engine
+    // to emit it.
+    if (!ActiveF || ActiveF->isDeclaration())
+        return jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
+    if (!imaging_mode) {
+        realize_pending_globals();
+        #ifndef USE_ORCJIT
+        #ifdef JL_DEBUG_BUILD
+#ifdef LLVM38
+        Module *backup = llvm::CloneModule(active_module).release();
+#else
+        Module *backup = llvm::CloneModule(active_module);
+#endif
+        if(verifyModule(*active_module))
+            writeRecoveryFile(backup);
+        #endif
+        for (auto &F : active_module->functions()) {
+            if (F.isDeclaration())
+                continue;
+            #ifdef JL_DEBUG_BUILD
+            if(verifyFunction(F))
+                writeRecoveryFile(backup);
+            #endif
+            finalize_gc_frame(&F);
+            FPM->run(F);
+            #ifdef JL_DEBUG_BUILD
+            if(verifyFunction(F))
+                writeRecoveryFile(backup);
+            #endif
+        }
+        #ifdef JL_DEBUG_BUILD
+        if(verifyModule(*active_module))
+            writeRecoveryFile(backup);
+        delete backup;
+        #endif
+        #endif
+        jl_finalize_module(active_module);
+    }
+    uint64_t addr = jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
+    assert(addr != 0);
+    if (!imaging_mode) {
+        active_module = new Module("julia", jl_LLVMContext);
+        jl_setup_module(active_module);
     }
+    return addr;
 }
+#endif
 
-extern "C" void jl_generate_fptr(jl_function_t *f)
+extern "C" void jl_generate_fptr(jl_lambda_info_t *li)
 {
+    JL_LOCK(codegen);
     // objective: assign li->fptr
-    jl_lambda_info_t *li = f->linfo;
-    assert(li->functionObject);
-    if (li->fptr == &jl_trampoline) {
+    assert(li->functionObjects.functionObject);
+    if (li->fptr == NULL) {
         JL_SIGATOMIC_BEGIN();
         #ifdef USE_MCJIT
         if (imaging_mode) {
-            // Copy the function out of the shadow module
-            Module *m = new Module("julia", jl_LLVMContext);
-            jl_setup_module(m, true);
-            FunctionMover mover(m, shadow_module);
-            li->functionObject = mover.CloneFunction((Function*)li->functionObject);
-            if (li->specFunctionObject != NULL)
-                li->specFunctionObject = mover.CloneFunction((Function*)li->specFunctionObject);
-            if (li->cFunctionList != NULL) {
-                size_t i;
-                cFunctionList_t *list = (cFunctionList_t*)li->cFunctionList;
-                for (i = 0; i < list->len; i++) {
-                    list->data[i].f = mover.CloneFunction(list->data[i].f);
+            // see if it has been emitted already (as part of compiling something else)
+            li->fptr = (jl_fptr_t)jl_ExecutionEngine->getFunctionAddress(((Function*)li->functionObjects.functionObject)->getName());
+            if (li->fptr == NULL) {
+                // Copy the function out of the shadow module
+                Module *m = new Module("julia", jl_LLVMContext);
+                jl_setup_module(m);
+                FunctionMover mover(m, shadow_module);
+                mover.CloneFunction((Function*)li->functionObjects.functionObject);
+                if (li->functionObjects.specFunctionObject != NULL)
+                    mover.CloneFunction((Function*)li->functionObjects.specFunctionObject);
+                if (li->functionObjects.cFunctionList != NULL) {
+                    size_t i;
+                    cFunctionList_t *list = (cFunctionList_t*)li->functionObjects.cFunctionList;
+                    for (i = 0; i < list->len; i++) {
+                        list->data()[i].f = mover.CloneFunction(list->data()[i].f);
+                    }
                 }
+                jl_finalize_module(m);
+                li->fptr = (jl_fptr_t)jl_ExecutionEngine->getFunctionAddress(((Function*)li->functionObjects.functionObject)->getName());
             }
         }
+        else {
+            li->fptr = (jl_fptr_t)getAddressForOrCompileFunction((Function*)li->functionObjects.functionObject);
+        }
+        #else
+        li->fptr = (jl_fptr_t)jl_ExecutionEngine->getPointerToFunction((Function*)li->functionObjects.functionObject);
         #endif
 
-        Function *llvmf = (Function*)li->functionObject;
-#ifdef USE_MCJIT
-        li->fptr = (jl_fptr_t)(intptr_t)jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
-#else
-        li->fptr = (jl_fptr_t)jl_ExecutionEngine->getPointerToFunction(llvmf);
-#endif
         assert(li->fptr != NULL);
 #ifndef KEEP_BODIES
         if (!imaging_mode)
-            llvmf->deleteBody();
+            ((Function*)li->functionObjects.functionObject)->deleteBody();
 #endif
 
-        if (li->cFunctionList != NULL) {
+        if (li->functionObjects.cFunctionList != NULL) {
             size_t i;
-            cFunctionList_t *list = (cFunctionList_t*)li->cFunctionList;
+            cFunctionList_t *list = (cFunctionList_t*)li->functionObjects.cFunctionList;
             for (i = 0; i < list->len; i++) {
 #ifdef USE_MCJIT
-                (void)jl_ExecutionEngine->getFunctionAddress(list->data[i].f->getName());
+                (void)getAddressForOrCompileFunction(list->data()[i].f);
 #else
-                (void)jl_ExecutionEngine->getPointerToFunction(list->data[i].f);
+                (void)jl_ExecutionEngine->getPointerToFunction(list->data()[i].f);
 #endif
 #ifndef KEEP_BODIES
                 if (!imaging_mode) {
-                    list->data[i].f->deleteBody();
+                    list->data()[i].f->deleteBody();
                 }
 #endif
             }
         }
 
-        if (li->specFunctionObject != NULL) {
+        if (li->functionObjects.specFunctionObject != NULL) {
 #ifdef USE_MCJIT
-            (void)jl_ExecutionEngine->getFunctionAddress(((Function*)li->specFunctionObject)->getName());
+            if (imaging_mode)
+              (void)jl_ExecutionEngine->getFunctionAddress(((Function*)li->functionObjects.specFunctionObject)->getName());
+            else
+              (void)getAddressForOrCompileFunction((Function*)li->functionObjects.specFunctionObject);
 #else
-            (void)jl_ExecutionEngine->getPointerToFunction((Function*)li->specFunctionObject);
+            (void)jl_ExecutionEngine->getPointerToFunction((Function*)li->functionObjects.specFunctionObject);
 #endif
 #ifndef KEEP_BODIES
             if (!imaging_mode)
-                ((Function*)li->specFunctionObject)->deleteBody();
+                ((Function*)li->functionObjects.specFunctionObject)->deleteBody();
 #endif
         }
         JL_SIGATOMIC_END();
     }
-    f->fptr = li->fptr;
+    JL_UNLOCK(codegen);
 }
 
-extern "C" void jl_compile(jl_function_t *f)
+extern "C" void jl_compile_linfo(jl_lambda_info_t *li, void *cyclectx)
 {
-    jl_lambda_info_t *li = f->linfo;
-    if (li->functionObject == NULL) {
+    if (li->functionObjects.functionObject == NULL) {
         // objective: assign li->functionObject
         li->inCompile = 1;
-        (void)to_function(li);
+        (void)to_function(li, (jl_cyclectx_t *)cyclectx);
         li->inCompile = 0;
     }
 }
@@ -944,16 +1158,15 @@ extern "C" void jl_compile(jl_function_t *f)
 // Get the LLVM Function* for the C-callable entry point for a certain function
 // and argument types. If rt is NULL then whatever return type is present is
 // accepted.
-static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_tupletype_t *argt, int64_t isref);
+static Function *gen_cfun_wrapper(jl_lambda_info_t *ff, jl_function_t *f, jl_value_t *jlrettype, jl_tupletype_t *argt, int64_t isref);
 static Function *jl_cfunction_object(jl_function_t *f, jl_value_t *rt, jl_tupletype_t *argt)
 {
     if (rt) {
         JL_TYPECHK(cfunction, type, rt);
     }
     JL_TYPECHK(cfunction, type, (jl_value_t*)argt);
-    JL_TYPECHK(cfunction, function, (jl_value_t*)f);
-    if (!jl_is_gf(f))
-        jl_error("only generic functions are currently c-callable");
+    if (!jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(f)))
+        jl_error("closures are not yet c-callable");
 
     size_t i, nargs = jl_nparams(argt);
     if (nargs >= 64)
@@ -962,7 +1175,11 @@ static Function *jl_cfunction_object(jl_function_t *f, jl_value_t *rt, jl_tuplet
     uint64_t isref = 0; // bit vector of which argument types are a subtype of Type{Ref{T}}
     jl_value_t *sigt = NULL; // type signature with Ref{} annotations removed
     JL_GC_PUSH1(&sigt);
-    sigt = (jl_value_t*)jl_alloc_svec(nargs);
+    sigt = (jl_value_t*)jl_alloc_svec(nargs+1);
+    if (jl_is_type(f))
+        jl_svecset(sigt, 0, jl_wrap_Type(f));
+    else
+        jl_svecset(sigt, 0, jl_typeof(f));
     for (i = 0; i < nargs; i++) {
         jl_value_t *ati = jl_tparam(argt, i);
         if (jl_is_abstract_ref_type(ati)) {
@@ -974,7 +1191,7 @@ static Function *jl_cfunction_object(jl_function_t *f, jl_value_t *rt, jl_tuplet
         else if (ati != (jl_value_t*)jl_any_type && !jl_is_leaf_type(ati)) {
             jl_error("cfunction: type signature must only contain leaf types");
         }
-        jl_svecset(sigt, i, ati);
+        jl_svecset(sigt, i+1, ati);
     }
     sigt = (jl_value_t*)jl_apply_tuple_type((jl_svec_t*)sigt);
 
@@ -992,34 +1209,41 @@ static Function *jl_cfunction_object(jl_function_t *f, jl_value_t *rt, jl_tuplet
         }
     }
 
-    jl_function_t *ff = jl_get_specialization(f, (jl_tupletype_t*)sigt);
-    if (ff != NULL && ff->env==(jl_value_t*)jl_emptysvec && ff->linfo != NULL) {
-        jl_lambda_info_t *li = ff->linfo;
-        if (!jl_types_equal((jl_value_t*)li->specTypes, sigt)) {
-            jl_errorf("cfunction: type signature of %s does not match specification",
-                      li->name->name);
+    jl_lambda_info_t *li = jl_get_specialization1((jl_tupletype_t*)sigt, NULL);
+    if (li != NULL) {
+        for(i=1; i < nargs+1; i++) {
+            jl_value_t *speci = jl_nth_slot_type(li->specTypes, i);
+            jl_value_t *sigi = jl_nth_slot_type((jl_tupletype_t*)sigt, i);
+            if ((isref & (2<<(i-1))) && speci == (jl_value_t*)jl_any_type) {
+                // specialized for Any => can accept any Ref
+            }
+            else if (!jl_types_equal(speci, sigi)) {
+                jl_errorf("cfunction: type signature of %s does not match specification",
+                          jl_symbol_name(li->name));
+            }
         }
-        jl_value_t *astrt = jl_ast_rettype(li, li->ast);
+        jl_value_t *astrt = li->rettype;
         if (rt != NULL) {
             if (astrt == (jl_value_t*)jl_bottom_type) {
                 if (rt != (jl_value_t*)jl_void_type) {
                     // a function that doesn't return can be passed to C as void
-                    jl_errorf("cfunction: %s does not return", li->name->name);
+                    jl_errorf("cfunction: %s does not return",
+                              jl_symbol_name(li->name));
                 }
             }
             else if (!jl_subtype(astrt, rt, 0)) {
                 jl_errorf("cfunction: return type of %s does not match",
-                          li->name->name);
+                          jl_symbol_name(li->name));
             }
         }
         JL_GC_POP(); // kill list: sigt
-        return gen_cfun_wrapper(ff, astrt, argt, isref);
+        return gen_cfun_wrapper(li, f, astrt, argt, isref);
     }
     jl_error("cfunction: no method exactly matched the required type signature (function not yet c-callable)");
 }
 
 // get the address of a C-callable entry point for a function
-extern "C" DLLEXPORT
+extern "C" JL_DLLEXPORT
 void *jl_function_ptr(jl_function_t *f, jl_value_t *rt, jl_value_t *argt)
 {
     JL_GC_PUSH1(&argt);
@@ -1031,16 +1255,29 @@ void *jl_function_ptr(jl_function_t *f, jl_value_t *rt, jl_value_t *argt)
     Function *llvmf = jl_cfunction_object(f, rt, (jl_tupletype_t*)argt);
     assert(llvmf);
     JL_GC_POP();
+
+#ifdef USE_MCJIT
+    if (uint64_t addr = getAddressForOrCompileFunction(llvmf))
+        return (void*)(intptr_t)addr;
+    if (llvmf->getParent() == shadow_module) {
+        // Copy the function out of the shadow module
+        Module *m = new Module("julia", jl_LLVMContext);
+        jl_setup_module(m);
+        FunctionMover mover(m, shadow_module);
+        (void)mover.CloneFunction(llvmf);
+        jl_finalize_module(m);
+    }
+#endif
 #ifdef USE_MCJIT
-    return (void*)(intptr_t)jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
+    return (void*)getAddressForOrCompileFunction(llvmf);
 #else
     return jl_ExecutionEngine->getPointerToFunction(llvmf);
 #endif
 }
 
 
-extern "C" DLLEXPORT
-void *jl_function_ptr_by_llvm_name(char* name) {
+extern "C" JL_DLLEXPORT
+void *jl_function_ptr_by_llvm_name(char *name) {
 #ifdef __has_feature
 #if __has_feature(memory_sanitizer)
     __msan_unpoison_string(name);
@@ -1050,7 +1287,7 @@ void *jl_function_ptr_by_llvm_name(char* name) {
 }
 
 // export a C-callable entry point for a function, with a given name
-extern "C" DLLEXPORT
+extern "C" JL_DLLEXPORT
 void jl_extern_c(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name)
 {
     assert(jl_is_tuple_type(argt));
@@ -1058,7 +1295,7 @@ void jl_extern_c(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name)
     if (llvmf) {
         #ifndef LLVM35
         new GlobalAlias(llvmf->getType(), GlobalValue::ExternalLinkage, name, llvmf, llvmf->getParent());
-        #elif defined(LLVM37)
+        #elif defined(LLVM37) && !defined(LLVM38)
         GlobalAlias::create(cast<PointerType>(llvmf->getType()),
                             GlobalValue::ExternalLinkage, name, llvmf, llvmf->getParent());
         #else
@@ -1069,7 +1306,6 @@ void jl_extern_c(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name)
 }
 
 // --- native code info, and dump function to IR and ASM ---
-extern void RegisterJuliaJITEventListener();
 
 extern int jl_get_llvmf_info(uint64_t fptr, uint64_t *symsize, uint64_t *slide,
 #ifdef USE_MCJIT
@@ -1079,72 +1315,115 @@ extern int jl_get_llvmf_info(uint64_t fptr, uint64_t *symsize, uint64_t *slide,
 #endif
     );
 
+extern "C"
+uint64_t jl_getUnwindInfo(uint64_t dwAddr);
 
 // Get pointer to llvm::Function instance, compiling if necessary
-extern "C" DLLEXPORT
-void *jl_get_llvmf(jl_function_t *f, jl_tupletype_t *tt, bool getwrapper)
+extern "C" JL_DLLEXPORT
+void *jl_get_llvmf(jl_function_t *f, jl_tupletype_t *tt, bool getwrapper, bool getdeclarations)
 {
-    jl_function_t *sf = f;
+    jl_lambda_info_t *linfo = NULL;
+    JL_GC_PUSH2(&linfo, &tt);
     if (tt != NULL) {
-        if (!jl_is_function(f) || !jl_is_gf(f)) {
-            return NULL;
+        linfo = jl_get_specialization1(tt, NULL);
+        if (linfo == NULL) {
+            linfo = jl_method_lookup_by_type(jl_gf_mtable(f), tt, 0, 0);
+            if (linfo == NULL) {
+                JL_GC_POP();
+                return NULL;
+            }
         }
-        sf = jl_get_specialization(f, tt);
     }
-    if (sf == NULL || sf->linfo == NULL) {
-        sf = jl_method_lookup_by_type(jl_gf_mtable(f), tt, 0, 0);
-        if (sf == jl_bottom_func) {
-            return NULL;
-        }
-        jl_printf(JL_STDERR,
-                  "WARNING: Returned code may not match what actually runs.\n");
+    if (linfo == NULL) {
+        JL_GC_POP();
+        return NULL;
     }
-    if (sf->linfo->specFunctionObject != NULL) {
-        // found in the system image: force a recompile
-        Function *llvmf = (Function*)sf->linfo->specFunctionObject;
-        if (llvmf->isDeclaration()) {
-            sf->linfo->specFunctionObject = NULL;
-            sf->linfo->functionObject = NULL;
+    if (!linfo->specTypes) {
+        jl_printf(JL_STDERR, "WARNING: Returned code may not match what actually runs.\n");
+        linfo = jl_get_unspecialized(linfo);
+    }
+
+    if (!getdeclarations) {
+        Function *llvmDecl = NULL;
+        if (!getwrapper && linfo->functionObjects.specFunctionObject != NULL)
+            llvmDecl = (Function*)linfo->functionObjects.specFunctionObject;
+        else
+            llvmDecl = (Function*)linfo->functionObjects.functionObject;
+#if defined(USE_ORCJIT) || defined(USE_MCJIT)
+        Function *llvmf = llvmDecl ? active_module->getFunction(llvmDecl->getName()) : NULL;
+        // Note that in either case, we need to run the FPM manually,
+        // since this is now usually done as part of object emission
+#else
+        Function *llvmf = llvmDecl && !llvmDecl->isDeclaration() ? llvmDecl : NULL;
+#endif
+        if (!llvmf) {
+            Function *other;
+            jl_llvm_functions_t declarations;
+            emit_function(linfo, NULL, &declarations, NULL);
+            if (getwrapper || !declarations.specFunctionObject) {
+                llvmf = (llvm::Function*)declarations.functionObject;
+                other = (llvm::Function*)declarations.specFunctionObject;
+            }
+            else {
+                llvmf = (llvm::Function*)declarations.specFunctionObject;
+                other = (llvm::Function*)declarations.functionObject;
+            }
+            if (other)
+                other->eraseFromParent();
+#if defined(USE_ORCJIT) || defined(USE_MCJIT)
+            realize_pending_globals();
+            finalize_gc_frame(llvmf);
+            FPM->run(*llvmf);
+#endif
+            llvmf->removeFromParent();
+            if (llvmDecl)
+                llvmf->setName(llvmDecl->getName());
+        }
+        else {
+            ValueToValueMapTy VMap;
+            Function *oldllvmf = llvmf;
+            llvmf = CloneFunction(llvmf, VMap, false);
+#if defined(USE_ORCJIT) || defined(USE_MCJIT)
+            active_module->getFunctionList().push_back(llvmf);
+            realize_pending_globals();
+            finalize_gc_frame(llvmf);
+            FPM->run(*llvmf);
+            llvmf->removeFromParent();
+            llvmf->setName(oldllvmf->getName());
+#endif
         }
+        JL_GC_POP();
+        return llvmf;
     }
-    if (sf->linfo->functionObject != NULL) {
+
+    if (linfo->fptr && !jl_getUnwindInfo((uintptr_t)linfo->fptr)) {
+        // Not in in the current ExecutionEngine
         // found in the system image: force a recompile
-        Function *llvmf = (Function*)sf->linfo->functionObject;
-        if (llvmf->isDeclaration()) {
-            sf->linfo->specFunctionObject = NULL;
-            sf->linfo->functionObject = NULL;
-        }
+        linfo->functionObjects.specFunctionObject = NULL;
+        linfo->functionObjects.functionObject = NULL;
+        linfo->fptr = NULL;
     }
-    if (sf->linfo->functionObject == NULL && sf->linfo->specFunctionObject == NULL) {
-        jl_compile(sf);
+    if (linfo->functionObjects.functionObject == NULL) {
+        jl_compile_linfo(linfo, NULL);
     }
-    if (!getwrapper && sf->linfo->specFunctionObject != NULL)
-        return (Function*)sf->linfo->specFunctionObject;
-    else
-        return (Function*)sf->linfo->functionObject;
-}
-
-Function* CloneFunctionToModule(Function *F, Module *destModule)
-{
-    ValueToValueMapTy VMap;
-    Function *NewF = Function::Create(F->getFunctionType(),
-                                      Function::ExternalLinkage,
-                                      F->getName(),
-                                      destModule);
-    VMap[F] = NewF;
-
-    Function::arg_iterator DestI = NewF->arg_begin();
-    for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) {
-        DestI->setName(I->getName());    // Copy the name over...
-        VMap[I] = DestI++;        // Add mapping to VMap
-    }
-
-    SmallVector<ReturnInst*, 8> Returns;
-    llvm::CloneFunctionInto(NewF, F, VMap, true, Returns, "", NULL, NULL);
-    return NewF;
+    Function *llvmf;
+    if (!getwrapper && linfo->functionObjects.specFunctionObject != NULL) {
+        llvmf = (Function*)linfo->functionObjects.specFunctionObject;
+    }
+    else {
+        llvmf = (Function*)linfo->functionObjects.functionObject;
+    }
+#if !defined(USE_ORCJIT) && !defined(USE_MCJIT)
+    if (!getdeclarations) {
+        ValueToValueMapTy VMap;
+        llvmf = CloneFunction(llvmf, VMap, false);
+    }
+#endif
+    JL_GC_POP();
+    return llvmf;
 }
 
-extern "C" DLLEXPORT
+extern "C" JL_DLLEXPORT
 const jl_value_t *jl_dump_function_ir(void *f, bool strip_ir_metadata, bool dump_module)
 {
     std::string code;
@@ -1159,10 +1438,13 @@ const jl_value_t *jl_dump_function_ir(void *f, bool strip_ir_metadata, bool dump
         llvmf->print(stream);
     }
     else {
-        // make a copy of the function with all module metadata
+        if (llvmf->getParent())
+            jl_error("jl_dump_function_ir requires a parentless clone");
+        // Put the function in a module
         Module *m = new Module(llvmf->getName(), jl_LLVMContext);
-        jl_setup_module(m, false);
-        Function *f2 = CloneFunctionToModule(llvmf, m);
+        jl_setup_module(m);
+        m->getFunctionList().push_back(llvmf);
+        Function *f2 = llvmf;
         if (strip_ir_metadata) {
             // strip metadata from the copy
             Function::BasicBlockListType::iterator f2_bb = f2->getBasicBlockList().begin();
@@ -1171,7 +1453,7 @@ const jl_value_t *jl_dump_function_ir(void *f, bool strip_ir_metadata, bool dump
                 BasicBlock::InstListType::iterator f2_il = (*f2_bb).getInstList().begin();
                 // iterate over instructions in basic block
                 for (; f2_il != (*f2_bb).getInstList().end(); ) {
-                    Instruction *inst = f2_il++;
+                    Instruction *inst = &*f2_il++;
                     // remove dbg.declare and dbg.value calls
                     if (isa<DbgDeclareInst>(inst) || isa<DbgValueInst>(inst)) {
                         inst->eraseFromParent();
@@ -1189,11 +1471,16 @@ const jl_value_t *jl_dump_function_ir(void *f, bool strip_ir_metadata, bool dump
                 }
             }
         }
-        if (dump_module)
+        if (dump_module) {
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+            realize_pending_globals();
+#endif
             m->print(stream, NULL);
+        }
         else
             f2->print(stream);
         f2->eraseFromParent();
+        m->dropAllReferences();
         delete m;
     }
 
@@ -1208,14 +1495,21 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
 #else
                           std::vector<JITEvent_EmittedFunctionDetails::LineStart> lineinfo,
 #endif
-                          formatted_raw_ostream &stream);
+#ifdef LLVM37
+                          raw_ostream &rstream
+#else
+                          formatted_raw_ostream &stream
+#endif
+                          );
 
-extern "C" DLLEXPORT
+extern "C" JL_DLLEXPORT
 const jl_value_t *jl_dump_function_asm(void *f, int raw_mc)
 {
     std::string code;
     llvm::raw_string_ostream stream(code);
+#ifndef LLVM37
     llvm::formatted_raw_ostream fstream(stream);
+#endif
 
     Function *llvmf = dyn_cast<Function>((Function*)f);
     if (!llvmf)
@@ -1224,7 +1518,7 @@ const jl_value_t *jl_dump_function_asm(void *f, int raw_mc)
     // Dump assembly code
     uint64_t symsize, slide;
 #ifdef USE_MCJIT
-    uint64_t fptr = jl_ExecutionEngine->getFunctionAddress(llvmf->getName());
+    uint64_t fptr = getAddressForOrCompileFunction(llvmf);
     const object::ObjectFile *object;
 #else
     uint64_t fptr = (uintptr_t)jl_ExecutionEngine->getPointerToFunction(llvmf);
@@ -1234,12 +1528,18 @@ const jl_value_t *jl_dump_function_asm(void *f, int raw_mc)
     if (jl_get_llvmf_info(fptr, &symsize, &slide, &object)) {
         if (raw_mc)
             return (jl_value_t*)jl_pchar_to_array((char*)fptr, symsize);
+#ifdef LLVM37
+        jl_dump_asm_internal(fptr, symsize, slide, object, stream);
+#else
         jl_dump_asm_internal(fptr, symsize, slide, object, fstream);
+#endif
     }
     else {
         jl_printf(JL_STDERR, "WARNING: Unable to find function pointer\n");
     }
+#ifndef LLVM37
     fstream.flush();
+#endif
 
     return jl_cstr_to_string(const_cast<char*>(stream.str().c_str()));
 }
@@ -1273,7 +1573,7 @@ static void coverageVisitLine(std::string filename, int line)
 
 extern "C" int isabspath(const char *in);
 
-void write_log_data(logdata_t logData, const char *extension)
+static void write_log_data(logdata_t logData, const char *extension)
 {
     std::string base = std::string(jl_options.julia_home);
     base = base + "/../share/julia/base/";
@@ -1368,7 +1668,7 @@ static void mallocVisitLine(std::string filename, int line)
 
 // Resets the malloc counts. Needed to avoid including memory usage
 // from JITting.
-extern "C" DLLEXPORT void jl_clear_malloc_data(void)
+extern "C" JL_DLLEXPORT void jl_clear_malloc_data(void)
 {
     logdata_t::iterator it = mallocData.begin();
     for (; it != mallocData.end(); it++) {
@@ -1399,10 +1699,28 @@ extern "C" void jl_write_malloc_log(void)
 
 // --- constant determination ---
 
+static void show_source_loc(JL_STREAM *out, jl_codectx_t *ctx)
+{
+    if (ctx == NULL) return;
+    jl_printf(out, "in %s at %s", jl_symbol_name(ctx->linfo->name),
+              jl_symbol_name(ctx->linfo->file));
+}
+
+extern "C" void jl_binding_deprecation_warning(jl_binding_t *b);
+
+static void cg_bdw(jl_binding_t *b, jl_codectx_t *ctx)
+{
+    jl_binding_deprecation_warning(b);
+    if (jl_options.depwarn) {
+        show_source_loc(JL_STDERR, ctx);
+        jl_printf(JL_STDERR, "\n");
+    }
+}
+
 // try to statically evaluate, NULL if not possible
 extern "C"
 jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
-                           jl_value_t *sp, jl_expr_t *ast, int sparams, int allow_alloc)
+                           jl_lambda_info_t *linfo, int sparams, int allow_alloc)
 {
     jl_codectx_t *ctx = (jl_codectx_t*)ctx_;
     if (jl_is_symbolnode(ex))
@@ -1413,16 +1731,19 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
         if (ctx) {
             isglob = is_global(sym, ctx);
         }
-        else if (ast) {
-            isglob = !jl_local_in_ast(ast, sym);
+        else if (linfo) {
+            isglob = !jl_local_in_linfo(linfo, sym);
         }
         if (isglob) {
             size_t i;
             if (sparams) {
-                for(i=0; i < jl_svec_len(sp); i+=2) {
-                    if (sym == (jl_sym_t*)jl_svecref(sp, i)) {
+                for (i=0; i < jl_svec_len(linfo->sparam_syms); i++) {
+                    if (sym == (jl_sym_t*)jl_svecref(linfo->sparam_syms, i)) {
                         // static parameter
-                        return jl_svecref(sp, i+1);
+                        if (jl_svec_len(linfo->sparam_vals) > 0)
+                            return jl_svecref(linfo->sparam_vals, i);
+                        else
+                            return NULL;
                     }
                 }
             }
@@ -1431,8 +1752,14 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
         }
         return NULL;
     }
-    if (jl_is_gensym(ex))
+    if (jl_is_gensym(ex)) {
+        ssize_t idx = ((jl_gensym_t*)ex)->id;
+        assert(idx >= 0);
+        if (ctx != NULL && ctx->gensym_assigned.at(idx)) {
+            return ctx->gensym_SAvalues.at(idx).constant;
+        }
         return NULL;
+    }
     if (jl_is_topnode(ex)) {
         jl_binding_t *b = jl_get_binding(jl_base_relative_to(mod),
                                          (jl_sym_t*)jl_fieldref(ex,0));
@@ -1451,36 +1778,39 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
         s = (jl_sym_t*)jl_globalref_name(ex);
         if (s && jl_is_symbol(s)) {
             jl_binding_t *b = jl_get_binding(jl_globalref_mod(ex), s);
-            if (b && b->constp)
+            if (b && b->constp) {
+                if (b->deprecated) cg_bdw(b, ctx);
                 return b->value;
+            }
         }
         return NULL;
     }
     if (jl_is_expr(ex)) {
         jl_expr_t *e = (jl_expr_t*)ex;
         if (e->head == call_sym) {
-            jl_value_t *f = jl_static_eval(jl_exprarg(e,0),ctx,mod,sp,ast,sparams,allow_alloc);
-            if (f && jl_is_function(f)) {
-                jl_fptr_t fptr = ((jl_function_t*)f)->fptr;
-                if (jl_array_dim0(e->args) == 3 && fptr == &jl_f_get_field) {
-                    m = (jl_module_t*)jl_static_eval(jl_exprarg(e,1),ctx,mod,sp,ast,sparams,allow_alloc);
-                    s = (jl_sym_t*)jl_static_eval(jl_exprarg(e,2),ctx,mod,sp,ast,sparams,allow_alloc);
+            jl_value_t *f = jl_static_eval(jl_exprarg(e,0),ctx,mod,linfo,sparams,allow_alloc);
+            if (f) {
+                if (jl_array_dim0(e->args) == 3 && f==jl_builtin_getfield) {
+                    m = (jl_module_t*)jl_static_eval(jl_exprarg(e,1),ctx,mod,linfo,sparams,allow_alloc);
+                    s = (jl_sym_t*)jl_static_eval(jl_exprarg(e,2),ctx,mod,linfo,sparams,allow_alloc);
                     if (m && jl_is_module(m) && s && jl_is_symbol(s)) {
                         jl_binding_t *b = jl_get_binding(m, s);
-                        if (b && b->constp)
+                        if (b && b->constp) {
+                            if (b->deprecated) cg_bdw(b, ctx);
                             return b->value;
+                        }
                     }
                 }
-                else if (fptr == &jl_f_tuple || fptr == &jl_f_instantiate_type) {
+                else if (f==jl_builtin_tuple || f==jl_builtin_apply_type) {
                     size_t i;
                     size_t n = jl_array_dim0(e->args)-1;
-                    if (n==0 && fptr == &jl_f_tuple) return (jl_value_t*)jl_emptytuple;
+                    if (n==0 && f==jl_builtin_tuple) return (jl_value_t*)jl_emptytuple;
                     if (!allow_alloc)
                         return NULL;
                     jl_value_t **v;
                     JL_GC_PUSHARGS(v, n);
                     for (i = 0; i < n; i++) {
-                        v[i] = jl_static_eval(jl_exprarg(e,i+1),ctx,mod,sp,ast,sparams,allow_alloc);
+                        v[i] = jl_static_eval(jl_exprarg(e,i+1),ctx,mod,linfo,sparams,allow_alloc);
                         if (v[i] == NULL) {
                             JL_GC_POP();
                             return NULL;
@@ -1488,7 +1818,10 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
                     }
                     jl_value_t *result;
                     JL_TRY {
-                        result = fptr(f, v, n);
+                        if (f == jl_builtin_tuple)
+                            result = jl_f_tuple(NULL, v, n);
+                        else
+                            result = jl_f_apply_type(NULL, v, n);
                     }
                     JL_CATCH {
                         result = NULL;
@@ -1497,13 +1830,6 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
                     return result;
                 }
             }
-        // The next part is probably valid, but it is untested
-        //} else if (e->head == tuple_sym) {
-        //  size_t i;
-        //  for (i = 0; i < jl_array_dim0(e->args); i++)
-        //        if (jl_static_eval(jl_exprarg(e,i),ctx,mod,sp,ast,sparams,allow_alloc) == NULL)
-        //          return NULL;
-        //  return ex;
         }
         return NULL;
     }
@@ -1513,7 +1839,7 @@ jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
 static jl_value_t *static_eval(jl_value_t *ex, jl_codectx_t *ctx, bool sparams,
                                bool allow_alloc)
 {
-    return jl_static_eval(ex, ctx, ctx->module, (jl_value_t*)ctx->sp, ctx->ast,
+    return jl_static_eval(ex, ctx, ctx->module, ctx->linfo,
                           sparams, allow_alloc);
 }
 
@@ -1625,8 +1951,7 @@ static void simple_escape_analysis(jl_value_t *expr, bool esc, jl_codectx_t *ctx
             simple_escape_analysis(f, esc, ctx);
             if (expr_is_symbol(f)) {
                 if (is_constant(f, ctx, false)) {
-                    jl_value_t *fv =
-                        jl_interpret_toplevel_expr_in(ctx->module, f, NULL, 0);
+                    jl_value_t *fv = jl_interpret_toplevel_expr_in(ctx->module, f, jl_emptysvec, jl_emptysvec);
                     if (jl_typeis(fv, jl_intrinsic_type)) {
                         esc = false;
                         JL_I::intrinsic fi = (JL_I::intrinsic)jl_unbox_int32(fv);
@@ -1640,13 +1965,12 @@ static void simple_escape_analysis(jl_value_t *expr, bool esc, jl_codectx_t *ctx
                             return;
                         }
                     }
-                    else if (jl_is_function(fv)) {
-                        jl_function_t *ff = (jl_function_t*)fv;
-                        if ((ff->fptr == jl_f_get_field && alen==3 &&
+                    else {
+                        if ((fv==jl_builtin_getfield && alen==3 &&
                              expr_type(jl_exprarg(e,2),ctx) == (jl_value_t*)jl_long_type) ||
-                            ff->fptr == jl_f_nfields ||
-                            (ff->fptr == jl_f_apply && alen==4 &&
-                             expr_type(jl_exprarg(e,2),ctx) == (jl_value_t*)jl_function_type)) {
+                            fv==jl_builtin_nfields /*||   // TODO jb/functions
+                            (fv==jl_builtin__apply && alen==3 &&
+                            expr_type(jl_exprarg(e,2),ctx) == (jl_value_t*)jl_function_type)*/) {
                             esc = false;
                         }
                     }
@@ -1693,120 +2017,44 @@ static void simple_escape_analysis(jl_value_t *expr, bool esc, jl_codectx_t *ctx
 
 // ---- Get Element Pointer (GEP) instructions within the GC frame ----
 
-// Emit GEP for the @slot-th slot in the GC frame
-static Value*
-emit_local_slot(int slot, jl_codectx_t *ctx)
-{
-    Value *idx = ConstantInt::get(T_int32, slot);
-    return builder.CreateGEP(ctx->gc.argSlot, idx);
-}
-
-// Emit GEP for the @slot-th temporary variable in the GC frame.
-// The temporary variables are after all local variables in the GC frame.
-static Value*
-emit_temp_slot(int slot, jl_codectx_t *ctx)
-{
-    Value *idx = ConstantInt::get(T_int32, slot);
-    return builder.CreateGEP(ctx->gc.tempSlot, idx);
-}
-
-static Value *make_gcroot(Value *v, jl_codectx_t *ctx)
-{
-    Value *froot = emit_temp_slot(ctx->gc.argDepth, ctx);
-    builder.CreateStore(v, froot);
-    ctx->gc.argDepth++;
-    if (ctx->gc.argDepth > ctx->gc.maxDepth)
-        ctx->gc.maxDepth = ctx->gc.argDepth;
-    return froot;
-}
-
-// test whether getting a field from the given type using the given
-// field expression would not allocate memory
-static bool is_getfield_nonallocating(jl_datatype_t *ty, jl_value_t *fld)
-{
-    if (!jl_is_leaf_type((jl_value_t*)ty))
-        return false;
-    jl_sym_t *name = NULL;
-    if (jl_is_quotenode(fld) && jl_is_symbol(jl_fieldref(fld,0)))
-        name = (jl_sym_t*)jl_fieldref(fld,0);
-    int idx = -1;
-    if (name)
-        idx = jl_field_index(ty, name, 0);
-    else if (jl_is_long(fld))
-        idx = jl_unbox_long(fld)-1;
-    else if (jl_is_quotenode(fld) && jl_is_long(jl_fieldref(fld,0)))
-        idx = jl_unbox_long(jl_fieldref(fld,0))-1;
-    for(size_t i=0; i < jl_svec_len(ty->types); i++) {
-        if (!(ty->fields[i].isptr || (idx >= 0 && (size_t)idx != i)))
-            return false;
-    }
-    return true;
-}
-
-// does "ex" compute something that doesn't need a root over the whole function?
-static bool is_stable_expr(jl_value_t *ex, jl_codectx_t *ctx)
+// Emit a gc-root slot indicator
+static Value* emit_local_slot(jl_codectx_t *ctx)
 {
-    if (jl_is_symbolnode(ex))
-        ex = (jl_value_t*)jl_symbolnode_sym(ex);
-    if (jl_is_symbol(ex)) {
-        if (ctx->vars.find((jl_sym_t*)ex) != ctx->vars.end()) {
-            // arguments and SSA vars are stable
-            jl_varinfo_t &rhs = ctx->vars[(jl_sym_t*)ex];
-            if ((rhs.isArgument && !rhs.isAssigned) || rhs.isSA)
-                return true;
-        }
-    }
-    if (jl_is_gensym(ex))
-        return true;
-    if (static_eval(ex, ctx, true, false) != NULL)
-        return true;
-    if (jl_is_expr(ex)) {
-        jl_expr_t *e = (jl_expr_t*)ex;
-        if (e->head == call_sym) {
-            jl_value_t *f = static_eval(jl_exprarg(e,0),ctx,true,false);
-            if (f && jl_is_function(f)) {
-                jl_fptr_t fptr = ((jl_function_t*)f)->fptr;
-                // something reached via getfield from a stable value is also stable.
-                if (jl_array_dim0(e->args) == 3) {
-                    jl_value_t *ty = expr_type(jl_exprarg(e,1), ctx);
-                    if ((fptr == &jl_f_get_field && jl_is_immutable_datatype(ty) &&
-                         is_getfield_nonallocating((jl_datatype_t*)ty, jl_exprarg(e,2)))) {
-                        if (is_stable_expr(jl_exprarg(e,1), ctx))
-                            return true;
-                    }
-                }
-            }
-        }
-    }
-    return false;
+    CallInst *newroot = CallInst::Create(prepare_call(gcroot_func), "", /*InsertBefore*/ctx->ptlsStates);
+    return newroot;
 }
 
-// classify exprs that might need temporary rooting.
-static bool might_need_root(jl_value_t *ex)
+// Marks a use (and thus a potential kill) of a gcroot
+static void mark_gc_use(const jl_cgval_t &v)
 {
-    return (!jl_is_symbol(ex) && !jl_is_symbolnode(ex) && !jl_is_gensym(ex) &&
-            !jl_is_bool(ex) && !jl_is_quotenode(ex) && !jl_is_byte_string(ex) &&
-            !jl_is_globalref(ex));
+    if (v.gcroot)
+        builder.CreateCall(prepare_call(gckill_func), v.gcroot);
 }
 
-static jl_cgval_t emit_boxed_rooted(jl_value_t *e, jl_codectx_t *ctx) // TODO: make this return a Value*
+// turn an array of arguments into a single object suitable for passing to a jlcall
+static Value *make_jlcall(ArrayRef<const jl_cgval_t*> args, jl_codectx_t *ctx)
 {
-    jl_cgval_t v = emit_expr(e, ctx);
-    if (!v.isboxed) {
-        Value *vbox = boxed(v, ctx);
-        make_gcroot(vbox, ctx);
-        v = jl_cgval_t(vbox, v.typ); // bypass normal auto-unbox behavior for isghost
-    }
-    else if (might_need_root(e)) { // TODO: v.needsgcroot
-        make_gcroot(v.V, ctx);
-    }
-    return v;
+    // the temporary variables are after all local variables in the GC frame.
+    CallInst *largs = CallInst::Create(prepare_call(jlcall_frame_func),
+            ConstantInt::get(T_int32, args.size()),
+            "",
+            /*InsertBefore*/ctx->ptlsStates);
+    int slot = 0;
+    assert(args.size() > 0);
+    for (ArrayRef<const jl_cgval_t*>::iterator I = args.begin(), E = args.end(); I < E; ++I, ++slot) {
+        Value *arg = boxed(**I, ctx, false); // mark_gc_use isn't needed since jlcall_frame_func can take ownership of this root
+        GetElementPtrInst *newroot = GetElementPtrInst::Create(LLVM37_param(NULL) largs,
+                ArrayRef<Value*>(ConstantInt::get(T_int32, slot)));
+        newroot->insertAfter(ctx->ptlsStates);
+        builder.CreateStore(arg, newroot);
+    }
+    return largs;
 }
 
-// --- lambda ---
-
 static void jl_add_linfo_root(jl_lambda_info_t *li, jl_value_t *val)
 {
+    if (jl_is_leaf_type(val))
+        return;
     JL_GC_PUSH1(&val);
     li = li->def;
     if (li->roots == NULL) {
@@ -1827,84 +2075,9 @@ static void jl_add_linfo_root(jl_lambda_info_t *li, jl_value_t *val)
     JL_GC_POP();
 }
 
-static Value *emit_lambda_closure(jl_value_t *expr, jl_codectx_t *ctx)
-{
-    assert(jl_is_lambda_info(expr));
-    size_t i;
-    jl_value_t *ast = ((jl_lambda_info_t*)expr)->ast;
-    jl_array_t *capt;
-    if (jl_is_expr(ast))
-        capt = jl_lam_capt((jl_expr_t*)ast);
-    else
-        capt = (jl_array_t*)((jl_lambda_info_t*)expr)->capt;
-    if (capt == NULL || jl_array_dim0(capt) == 0) {
-        // no captured vars; lift
-        jl_value_t *fun =
-            (jl_value_t*)jl_new_closure(NULL, (jl_value_t*)jl_emptysvec,
-                                        (jl_lambda_info_t*)expr);
-        jl_add_linfo_root(ctx->linfo, fun);
-        return literal_pointer_val(fun);
-    }
-
-    int argStart = ctx->gc.argDepth;
-    size_t clen = jl_array_dim0(capt);
-    Value **captured = (Value**) alloca((1 + clen) * sizeof(Value*));
-    captured[0] = ConstantInt::get(T_size, clen);
-    for(i=0; i < clen; i++) {
-        Value *val;
-        jl_array_t *vi = (jl_array_t*)jl_cellref(capt, i);
-        assert(jl_is_array(vi));
-        jl_sym_t *s = (jl_sym_t*)jl_cellref(vi,0);
-        assert(jl_is_symbol(s));
-        jl_varinfo_t &vari = ctx->vars[s];
-        if (vari.memloc) {
-            val = builder.CreateLoad(vari.memloc, vari.isVolatile);
-        }
-        else {
-            assert(!vari.isAssigned || vari.value.isghost); // make sure there wasn't an inference / codegen error earlier
-            val = boxed(vari.value, ctx);
-            if (!vari.value.isghost)
-                make_gcroot(val, ctx);
-        }
-        captured[i+1] = val;
-    }
-    Value *env_tuple = builder.CreateCall(prepare_call(jlnsvec_func),
-                                   ArrayRef<Value*>(&captured[0], 1+clen));
-    ctx->gc.argDepth = argStart; // remove arguments roots from the implicit gc stack
-    make_gcroot(env_tuple, ctx);
-#ifdef LLVM37
-    Value *result = builder.CreateCall(prepare_call(jlclosure_func),
-                                        {Constant::getNullValue(T_pint8),
-                                        env_tuple, literal_pointer_val(expr)});
-#else
-    Value *result = builder.CreateCall3(prepare_call(jlclosure_func),
-                                        Constant::getNullValue(T_pint8),
-                                        env_tuple, literal_pointer_val(expr));
-#endif
-    ctx->gc.argDepth--; // pop env_tuple from the implicit gc stack
-    return result;
-}
-
-// --- generating function calls ---
-
-static jl_svec_t *call_arg_types(jl_value_t **args, size_t n, jl_codectx_t *ctx)
-{
-    jl_svec_t *t = jl_alloc_svec(n);
-    JL_GC_PUSH1(&t);
-    size_t i;
-    for(i=0; i < n; i++) {
-        jl_value_t *ty = expr_type(args[i], ctx);
-        if (!jl_is_leaf_type(ty)) {
-            t = NULL;
-            break;
-        }
-        jl_svecset(t, i, ty);
-    }
-    JL_GC_POP();
-    return t;
-}
-
-static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *ctx)
+// --- generating function calls ---
+
+static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *ctx)
 {
     if (jl_is_quotenode(expr) && jl_is_module(jl_fieldref(expr,0)))
         expr = jl_fieldref(expr,0);
@@ -1918,9 +2091,10 @@ static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *
         Value *bp = global_binding_pointer((jl_module_t*)expr, name, &bnd, false, ctx);
         // TODO: refactor. this partially duplicates code in emit_var
         if (bnd && bnd->value != NULL) {
-            if (bnd->constp && jl_isbits(jl_typeof(bnd->value)))
-                return emit_unboxed(bnd->value, ctx);
-            return mark_julia_type(builder.CreateLoad(bp), bnd->constp ? jl_typeof(bnd->value) : (jl_value_t*)jl_any_type);
+            if (bnd->constp) {
+                return mark_julia_const(bnd->value);
+            }
+            return mark_julia_type(builder.CreateLoad(bp), true, (jl_value_t*)jl_any_type, ctx);
         }
         // todo: use type info to avoid undef check
         return emit_checked_var(bp, name, ctx);
@@ -1934,7 +2108,7 @@ static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *
         jl_is_leaf_type((jl_value_t*)sty)) {
         unsigned idx = jl_field_index(sty, name, 0);
         if (idx != (unsigned)-1) {
-            jl_cgval_t strct = emit_expr(expr, ctx, false);
+            jl_cgval_t strct = emit_expr(expr, ctx);
             jl_cgval_t fld = emit_getfield_knownidx(strct, idx, sty, ctx);
             JL_GC_POP();
             return fld;
@@ -1944,13 +2118,11 @@ static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *
     // TODO: attempt better codegen for approximate types, if the types
     // and offsets of some fields are independent of parameters.
 
-    int argStart = ctx->gc.argDepth;
-    Value *arg1 = boxed(emit_expr(expr,ctx), ctx, expr_type(expr,ctx));
     // TODO: generic getfield func with more efficient calling convention
-    make_gcroot(arg1, ctx);
-    Value *arg2 = literal_pointer_val((jl_value_t*)name);
-    make_gcroot(arg2, ctx);
-    Value *myargs = emit_temp_slot(argStart, ctx);
+    jl_cgval_t arg1 = emit_expr(expr, ctx);
+    jl_cgval_t arg2 = mark_julia_const((jl_value_t*)name);
+    const jl_cgval_t* myargs_array[2] = {&arg1, &arg2};
+    Value *myargs = make_jlcall(makeArrayRef(myargs_array), ctx);
 #ifdef LLVM37
     Value *result = builder.CreateCall(prepare_call(jlgetfield_func), {V_null, myargs,
                                         ConstantInt::get(T_int32,2)});
@@ -1958,8 +2130,9 @@ static jl_cgval_t emit_getfield(jl_value_t *expr, jl_sym_t *name, jl_codectx_t *
     Value *result = builder.CreateCall3(prepare_call(jlgetfield_func), V_null, myargs,
                                         ConstantInt::get(T_int32,2));
 #endif
-    ctx->gc.argDepth = argStart;
-    return mark_julia_type(result, jl_any_type); // (typ will be patched up by caller)
+    bool needsgcroot = true; // !arg1.isimmutable || !jl_is_leaf_type(arg1.typ) || !is_datatype_all_pointers((jl_datatype_t*)arg1.typ); // TODO: probably want this as a llvm pass
+    jl_cgval_t ret = mark_julia_type(result, true, jl_any_type, ctx, needsgcroot); // (typ will be patched up by caller)
+    return ret;
 }
 
 static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codectx_t *ctx)
@@ -1984,7 +2157,7 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
             Value *subAns, *fld1, *fld2;
             fld1 = builder.CreateExtractElement(varg1, ConstantInt::get(T_int32,i)),
             fld2 = builder.CreateExtractElement(varg2, ConstantInt::get(T_int32,i)),
-            subAns = emit_bits_compare(mark_julia_type(fld1, fldty), mark_julia_type(fld2, fldty), ctx);
+            subAns = emit_bits_compare(mark_julia_type(fld1, false, fldty, ctx), mark_julia_type(fld2, false, fldty, ctx), ctx);
             answer = builder.CreateAnd(answer, subAns);
         }
         return answer;
@@ -1997,26 +2170,22 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
 #ifdef LLVM37
             Value *answer = builder.CreateCall(prepare_call(memcmp_func),
                             {
-                            builder.CreatePointerCast(arg1.V, T_pint8),
-                            builder.CreatePointerCast(arg2.V, T_pint8),
+                            data_pointer(arg1, ctx, T_pint8),
+                            data_pointer(arg2, ctx, T_pint8),
                             ConstantInt::get(T_size, sz)
                             });
 #else
             Value *answer = builder.CreateCall3(prepare_call(memcmp_func),
-                    builder.CreatePointerCast(arg1.V, T_pint8),
-                    builder.CreatePointerCast(arg2.V, T_pint8),
+                    data_pointer(arg1, ctx, T_pint8),
+                    data_pointer(arg2, ctx, T_pint8),
                     ConstantInt::get(T_size, sz));
 #endif
             return builder.CreateICmpEQ(answer, ConstantInt::get(T_int32, 0));
         }
         else {
             Type *atp = at->getPointerTo();
-            Value *varg1 = arg1.V;
-            if (varg1->getType() != atp)
-                builder.CreatePointerCast(varg1, atp);
-            Value *varg2 = arg2.V;
-            if (varg2->getType() != atp)
-                builder.CreatePointerCast(varg2, atp);
+            Value *varg1 = data_pointer(arg1, ctx, atp);
+            Value *varg2 = data_pointer(arg2, ctx, atp);
             jl_svec_t *types = ((jl_datatype_t*)arg1.typ)->types;
             Value *answer = ConstantInt::get(T_int1, 1);
             size_t l = jl_svec_len(types);
@@ -2025,7 +2194,7 @@ static Value *emit_bits_compare(const jl_cgval_t &arg1, const jl_cgval_t &arg2,
                 Value *subAns, *fld1, *fld2;
                 fld1 = builder.CreateConstGEP2_32(LLVM37_param(at) varg1, 0, i);
                 fld2 = builder.CreateConstGEP2_32(LLVM37_param(at) varg2, 0, i);
-                if (type_is_ghost(fld1->getType()))
+                if (type_is_ghost(fld1->getType()->getPointerElementType()))
                     continue;
                 subAns = emit_bits_compare(mark_julia_slot(fld1, fldty), mark_julia_slot(fld2, fldty), ctx);
                 answer = builder.CreateAnd(answer, subAns);
@@ -2054,13 +2223,10 @@ static Value *emit_f_is(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codec
         }
     }
 
-    bool sub1 = jl_subtype(rt1, rt2, 0);
-    bool sub2 = jl_subtype(rt2, rt1, 0);
-    bool isteq = sub1 && sub2;
-    if (!sub1 && !sub2) // types are disjoint (exhaustive test)
+    if (jl_type_intersection(rt1, rt2) == (jl_value_t*)jl_bottom_type) // types are disjoint (exhaustive test)
         return ConstantInt::get(T_int1, 0);
 
-    bool isbits = isleaf && isteq && jl_isbits(rt1);
+    bool isbits = isleaf && jl_isbits(rt1) && jl_types_equal(rt1, rt2);
     if (isbits) { // whether this type is unique'd by value
         return emit_bits_compare(arg1, arg2, ctx);
     }
@@ -2077,15 +2243,11 @@ static Value *emit_f_is(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codec
         ptr_comparable = 1;
     if (ptr_comparable) {
         assert(arg1.isboxed && arg2.isboxed); // only boxed types are valid for pointer comparison
-        return builder.CreateICmpEQ(arg1.V, arg2.V);
+        return builder.CreateICmpEQ(boxed(arg1, ctx), boxed(arg2, ctx));
     }
 
-    if (arg2.isboxed && arg2.needsgcroot)
-        make_gcroot(arg2.V, ctx);
     Value *varg1 = boxed(arg1, ctx);
-    if (!arg1.isboxed)
-        make_gcroot(varg1, ctx);
-    Value *varg2 = boxed(arg2, ctx); // unrooted!
+    Value *varg2 = boxed(arg2, ctx, false); // potentially unrooted!
 #ifdef LLVM37
     return builder.CreateTrunc(builder.CreateCall(prepare_call(jlegal_func), {varg1, varg2}), T_int1);
 #else
@@ -2093,72 +2255,44 @@ static Value *emit_f_is(const jl_cgval_t &arg1, const jl_cgval_t &arg2, jl_codec
 #endif
 }
 
-static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
-                            jl_value_t **args, size_t nargs,
-                            jl_codectx_t *ctx,
-                            Value **theFptr, jl_function_t **theF,
-                            jl_value_t *expr)
-// returns true if the call has been handled
+static jl_svec_t *call_arg_types(jl_value_t **args, size_t n, jl_codectx_t *ctx)
 {
-    if (jl_typeis(ff, jl_intrinsic_type)) {
-        *ret = emit_intrinsic((intrinsic)*(uint32_t*)jl_data_ptr(ff),
-                              args, nargs, ctx);
-        if (ret->typ == (jl_value_t*)jl_any_type) // the select_value intrinsic may be missing type information
-            *ret = remark_julia_type(*ret, expr_type(expr, ctx));
-        return true;
-    }
-    if (!jl_is_func(ff)) {
-        return false;
+    jl_svec_t *t = jl_alloc_svec(n);
+    JL_GC_PUSH1(&t);
+    size_t i;
+    for(i=0; i < n; i++) {
+        jl_value_t *ty = expr_type(args[i], ctx);
+        if (!jl_is_leaf_type(ty)) {
+            t = NULL;
+            break;
+        }
+        jl_svecset(t, i, ty);
     }
+    JL_GC_POP();
+    return t;
+}
+
+static bool emit_builtin_call(jl_cgval_t *ret, jl_value_t *f, jl_value_t **args, size_t nargs,
+                              jl_codectx_t *ctx, jl_value_t *expr)
+// returns true if the call has been handled
+{
     jl_value_t *rt1=NULL, *rt2=NULL, *rt3=NULL;
     JL_GC_PUSH3(&rt1, &rt2, &rt3);
-    jl_function_t *f = (jl_function_t*)ff;
 
-    if (f->fptr == &jl_apply_generic) {
-        *theFptr = jlapplygeneric_func;
-        *theF = f;
-        if (ctx->linfo->inferred) {
-            jl_svec_t *aty = call_arg_types(&args[1], nargs, ctx);
-            rt1 = (jl_value_t*)aty;
-            // attempt compile-time specialization for inferred types
-            if (aty != NULL) {
-                rt1 = (jl_value_t*)jl_apply_tuple_type(aty);
-                /*
-                  if (trace) {
-                      jl_printf(JL_STDOUT, "call %s%s\n",
-                      jl_sprint(args[0]),
-                      jl_sprint((jl_value_t*)aty));
-                  }
-                */
-                f = jl_get_specialization(f, (jl_tupletype_t*)rt1);
-                if (f != NULL) {
-                    assert(f->linfo->functionObject != NULL);
-                    *theFptr = (Value*)f->linfo->functionObject;
-                    *theF = f;
-                }
-            }
-        }
-        JL_GC_POP();
-        return false;
-    }
-
-    else if (f->fptr == &jl_f_is && nargs==2) {
+    if (f==jl_builtin_is && nargs==2) {
         // handle simple static expressions with no side-effects
         rt1 = static_eval(args[1], ctx, true);
         if (rt1) {
             rt2 = static_eval(args[2], ctx, true);
             if (rt2) {
-                *ret = mark_julia_type(ConstantInt::get(T_int1, jl_egal(rt1, rt2)), jl_bool_type);
+                *ret = mark_julia_type(ConstantInt::get(T_int1, jl_egal(rt1, rt2)), false, jl_bool_type, ctx);
                 JL_GC_POP();
                 return true;
             }
         }
         // emit values
-        int last_depth = ctx->gc.argDepth;
-        jl_cgval_t v1 = emit_unboxed(args[1], ctx);
-        if (v1.isboxed && v1.needsgcroot && might_need_root(args[1]))
-            make_gcroot(v1.V, ctx);
-        jl_cgval_t v2 = emit_unboxed(args[2], ctx); // unrooted!
+        jl_cgval_t v1 = emit_expr(args[1], ctx);
+        jl_cgval_t v2 = emit_expr(args[2], ctx);
         // FIXME: v.typ is roughly equiv. to expr_type, but with typeof(T) == Type{T} instead of DataType in a few cases
         if (v1.typ == (jl_value_t*)jl_datatype_type)
             v1 = remark_julia_type(v1, expr_type(args[1], ctx)); // patch up typ if necessary
@@ -2166,21 +2300,22 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
             v2 = remark_julia_type(v2, expr_type(args[2], ctx)); // patch up typ if necessary
         // emit comparison test
         Value *ans = emit_f_is(v1, v2, ctx);
-        ctx->gc.argDepth = last_depth;
-        *ret = mark_julia_type(ans, jl_bool_type);
+        mark_gc_use(v1);
+        mark_gc_use(v2);
+        *ret = mark_julia_type(ans, false, jl_bool_type, ctx);
         JL_GC_POP();
         return true;
     }
 
-    else if (f->fptr == &jl_f_typeof && nargs==1) {
+    else if (f==jl_builtin_typeof && nargs==1) {
         jl_cgval_t arg1 = emit_expr(args[1], ctx);
         Value *lty = emit_typeof(arg1);
-        *ret = mark_julia_type(lty, jl_datatype_type);
+        *ret = mark_julia_type(lty, true, jl_datatype_type, ctx);
         JL_GC_POP();
         return true;
     }
 
-    else if (f->fptr == &jl_f_typeassert && nargs==2) {
+    else if (f==jl_builtin_typeassert && nargs==2) {
         jl_value_t *arg = expr_type(args[1], ctx); rt1 = arg;
         jl_value_t *ty  = expr_type(args[2], ctx); rt2 = ty;
         if (jl_is_type_type(ty) && !jl_is_typevar(jl_tparam0(ty))) {
@@ -2200,28 +2335,25 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
             if (!jl_is_tuple_type(tp0) && jl_is_leaf_type(tp0)) {
                 *ret = emit_expr(args[1], ctx);
                 emit_typecheck(*ret, tp0, "typeassert", ctx);
-                *ret = remark_julia_type(*ret, expr_type(expr, ctx));
+                if (ret->isboxed)
+                    *ret = remark_julia_type(*ret, expr_type(expr, ctx));
                 JL_GC_POP();
                 return true;
             }
         }
         if (jl_subtype(ty, (jl_value_t*)jl_type_type, 0)) {
-            FunctionType *ft = FunctionType::get(T_void, two_pvalue_llvmt, false); // TODO: move this to the codegen init section
-            Value *typeassert = jl_Module->getOrInsertFunction("jl_typeassert", ft);
-            int ldepth = ctx->gc.argDepth;
-            *ret = emit_boxed_rooted(args[1], ctx);
+            *ret = emit_expr(args[1], ctx);
 #ifdef LLVM37
-            builder.CreateCall(prepare_call(typeassert), {ret->V, boxed(emit_expr(args[2], ctx),ctx)});
+            builder.CreateCall(prepare_call(jltypeassert_func), {boxed(*ret, ctx), boxed(emit_expr(args[2], ctx), ctx)});
 #else
-            builder.CreateCall2(prepare_call(typeassert), ret->V, boxed(emit_expr(args[2], ctx),ctx));
+            builder.CreateCall2(prepare_call(jltypeassert_func), boxed(*ret, ctx), boxed(emit_expr(args[2], ctx), ctx));
 #endif
-            ctx->gc.argDepth = ldepth;
             JL_GC_POP();
             return true;
         }
     }
 
-    else if (f->fptr == &jl_f_isa && nargs==2) {
+    else if (f==jl_builtin_isa && nargs==2) {
         jl_value_t *arg = expr_type(args[1], ctx); rt1 = arg;
         jl_value_t *ty  = expr_type(args[2], ctx); rt2 = ty;
         if (arg == jl_bottom_type) {
@@ -2233,13 +2365,15 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         if (jl_is_type_type(ty) && !jl_has_typevars(jl_tparam0(ty))) {
             jl_value_t *tp0 = jl_tparam0(ty);
             if (jl_subtype(arg, tp0, 0)) {
-                *ret = mark_julia_type(ConstantInt::get(T_int1,1), jl_bool_type);
+                emit_expr(args[1], ctx);  // TODO remove if no side effects
+                *ret = mark_julia_type(ConstantInt::get(T_int1, 1), false, jl_bool_type, ctx);
                 JL_GC_POP();
                 return true;
             }
             if (!jl_subtype(tp0, (jl_value_t*)jl_type_type, 0)) {
                 if (jl_is_leaf_type(arg)) {
-                    *ret = mark_julia_type(ConstantInt::get(T_int1,0), jl_bool_type);
+                    emit_expr(args[1], ctx);  // TODO remove if no side effects
+                    *ret = mark_julia_type(ConstantInt::get(T_int1, 0), false, jl_bool_type, ctx);
                     JL_GC_POP();
                     return true;
                 }
@@ -2247,8 +2381,9 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                     jl_cgval_t arg1 = emit_expr(args[1], ctx);
                     *ret = mark_julia_type(
                             builder.CreateICmpEQ(emit_typeof(arg1),
-                                                literal_pointer_val(tp0)),
-                            jl_bool_type);
+                                                 literal_pointer_val(tp0)),
+                            false,
+                            jl_bool_type, ctx);
                     JL_GC_POP();
                     return true;
                 }
@@ -2256,28 +2391,25 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         }
     }
 
-    else if (f->fptr == &jl_f_subtype && nargs == 2) {
+    else if (f==jl_builtin_issubtype && nargs == 2) {
         rt1 = expr_type(args[1], ctx);
         rt2 = expr_type(args[2], ctx);
         if (jl_is_type_type(rt1) && !jl_is_typevar(jl_tparam0(rt1)) &&
             jl_is_type_type(rt2) && !jl_is_typevar(jl_tparam0(rt2))) {
             int issub = jl_subtype(jl_tparam0(rt1), jl_tparam0(rt2), 0);
             // TODO: emit args[1] and args[2] in case of side effects?
-            *ret = mark_julia_type(ConstantInt::get(T_int1, issub), jl_bool_type);
+            *ret = mark_julia_type(ConstantInt::get(T_int1, issub), false, jl_bool_type, ctx);
             JL_GC_POP();
             return true;
         }
     }
 
-    else if (f->fptr == &jl_f_apply && nargs==3 && ctx->vaStack &&
-             symbol_eq(args[3], ctx->vaName) && expr_type(args[2],ctx) == (jl_value_t*)jl_function_type) {
+    // TODO jb/functions
+    /*
+    else if (f==jl_builtin__apply && nargs==2 && ctx->vaStack &&
+             symbol_eq(args[2], ctx->vaName)) {
         // turn Core._apply(f, Tuple) ==> f(Tuple...) using the jlcall calling convention if Tuple is the vaStack allocation
-        Value *theF = boxed(emit_expr(args[2], ctx), ctx);
-        Value *theFptr = emit_nthptr_recast(
-                theF,
-                (ssize_t)(offsetof(jl_function_t,fptr)/sizeof(void*)),
-                tbaa_func,
-                jl_pfptr_llvmt);
+        Value *theF = boxed(emit_expr(args[1], ctx), ctx);
         Value *nva = emit_n_varargs(ctx);
 #ifdef _P64
         nva = builder.CreateTrunc(nva, T_int32);
@@ -2294,12 +2426,13 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                                                   ConstantInt::get(T_size, ctx->nReqArgs)),
                                 nva);
 #endif
-        *ret = mark_julia_type(r, expr_type(expr, ctx));
+        *ret = mark_julia_type(r, true, expr_type(expr, ctx), ctx);
         JL_GC_POP();
         return true;
     }
+    */
 
-    else if (f->fptr == &jl_f_tuple) {
+    else if (f==jl_builtin_tuple) {
         if (nargs == 0) {
             *ret = ghostValue(jl_typeof(jl_emptytuple));
             JL_GC_POP();
@@ -2315,8 +2448,8 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         }
     }
 
-    else if (f->fptr == &jl_f_throw && nargs==1) {
-        Value *arg1 = boxed(emit_expr(args[1], ctx), ctx);
+    else if (f==jl_builtin_throw && nargs==1) {
+        Value *arg1 = boxed(emit_expr(args[1], ctx), ctx); // rooted by throw
         // emit a "conditional" throw so that codegen does't end up trying to emit code after an "unreachable" terminator
         raise_exception_unless(ConstantInt::get(T_int1,0), arg1, ctx);
         *ret = jl_cgval_t();
@@ -2324,18 +2457,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         return true;
     }
 
-    else if (f->fptr == &jl_f_arraylen && nargs==1) {
-        jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
-        if (jl_is_array_type(aty)) {
-            // todo: also allow e.g. Union of several array types
-            jl_cgval_t arg1 = emit_expr(args[1], ctx);
-            *ret = mark_julia_type(emit_arraylen(arg1, args[1], ctx), jl_long_type);
-            JL_GC_POP();
-            return true;
-        }
-    }
-
-    else if (f->fptr == &jl_f_arraysize && nargs==2) {
+    else if (f==jl_builtin_arraysize && nargs==2) {
         jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
         jl_value_t *ity = expr_type(args[2], ctx); rt2 = ity;
         if (jl_is_array_type(aty) && ity == (jl_value_t*)jl_long_type) {
@@ -2346,19 +2468,18 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                 if (jl_is_long(args[2])) {
                     uint32_t idx = (uint32_t)jl_unbox_long(args[2]);
                     if (idx > 0 && idx <= ndims) {
-                        *ret = mark_julia_type(emit_arraysize(ary, args[1], idx, ctx), jl_long_type);
+                        *ret = mark_julia_type(emit_arraysize(ary, args[1], idx, ctx), false, jl_long_type, ctx);
                         JL_GC_POP();
                         return true;
                     }
                     else if (idx > ndims) {
-                        *ret = mark_julia_type(ConstantInt::get(T_size, 1), jl_long_type);
+                        *ret = mark_julia_type(ConstantInt::get(T_size, 1), false, jl_long_type, ctx);
                         JL_GC_POP();
                         return true;
                     }
                 }
                 else {
-                    Value *idx = emit_unbox(T_size,
-                                            emit_unboxed(args[2], ctx), ity);
+                    Value *idx = emit_unbox(T_size, emit_expr(args[2], ctx), ity);
                     error_unless(builder.CreateICmpSGT(idx,
                                                       ConstantInt::get(T_size,0)),
                                  "arraysize: dimension out of range", ctx);
@@ -2373,14 +2494,14 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                     builder.CreateBr(ansBB);
                     ctx->f->getBasicBlockList().push_back(inBB);
                     builder.SetInsertPoint(inBB);
-                    Value *v_sz = emit_arraysize(ary, idx);
+                    Value *v_sz = emit_arraysize(ary, idx, ctx);
                     builder.CreateBr(ansBB);
                     ctx->f->getBasicBlockList().push_back(ansBB);
                     builder.SetInsertPoint(ansBB);
                     PHINode *result = builder.CreatePHI(T_size, 2);
                     result->addIncoming(v_one, outBB);
                     result->addIncoming(v_sz, inBB);
-                    *ret = mark_julia_type(result, jl_long_type);
+                    *ret = mark_julia_type(result, false, jl_long_type, ctx);
                     JL_GC_POP();
                     return true;
                 }
@@ -2388,7 +2509,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         }
     }
 
-    else if (f->fptr == &jl_f_arrayref && nargs>=2) {
+    else if (f==jl_builtin_arrayref && nargs>=2) {
         jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
         bool indexes_ok = true;
         for (size_t i=2; i <= nargs; i++) {
@@ -2422,7 +2543,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         }
     }
 
-    else if (f->fptr == &jl_f_arrayset && nargs>=3) {
+    else if (f==jl_builtin_arrayset && nargs>=3) {
         jl_value_t *aty = expr_type(args[1], ctx); rt1 = aty;
         jl_value_t *vty = expr_type(args[2], ctx); rt2 = vty;
         bool indexes_ok = true;
@@ -2445,13 +2566,14 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                     if (!isboxed && ((jl_datatype_t*)ety)->size == 0) {
                         // no-op, but emit expr for possible effects
                         assert(jl_is_datatype(ety));
-                        emit_expr(args[2],ctx,false);
+                        emit_expr(args[2], ctx);
                     }
                     else {
-                        jl_cgval_t v = (ety == (jl_value_t*)jl_any_type ? emit_expr(args[2],ctx) : emit_unboxed(args[2],ctx));
-                        PHINode* data_owner = NULL; // owner object against which the write barrier must check
+                        jl_cgval_t v = (ety == (jl_value_t*)jl_any_type ? emit_expr(args[2], ctx) : emit_expr(args[2], ctx));
+                        PHINode *data_owner = NULL; // owner object against which the write barrier must check
                         if (isboxed) { // if not boxed we don't need a write barrier
                             assert(ary.isboxed);
+                            Value *aryv = boxed(ary, ctx);
                             Value *flags = emit_arrayflags(ary, ctx);
                             // the owner of the data is ary itself except if ary->how == 3
                             flags = builder.CreateAnd(flags, 3);
@@ -2464,12 +2586,12 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                             // load owner pointer
                             Value *own_ptr = builder.CreateLoad(
                                 builder.CreateBitCast(builder.CreateConstGEP1_32(
-                                    builder.CreateBitCast(ary.V,T_pint8), jl_array_data_owner_offset(nd)),
-                                    jl_ppvalue_llvmt));
+                                    builder.CreateBitCast(aryv, T_pint8), jl_array_data_owner_offset(nd)),
+                                    T_ppjlvalue));
                             builder.CreateBr(mergeBB);
                             builder.SetInsertPoint(mergeBB);
-                            data_owner = builder.CreatePHI(jl_pvalue_llvmt, 2);
-                            data_owner->addIncoming(ary.V, curBB);
+                            data_owner = builder.CreatePHI(T_pjlvalue, 2);
+                            data_owner->addIncoming(aryv, curBB);
                             data_owner->addIncoming(own_ptr, ownedBB);
                         }
                         typed_store(emit_arrayptr(ary,args[1],ctx), idx, v,
@@ -2483,7 +2605,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         }
     }
 
-    else if (f->fptr == &jl_f_get_field && nargs==2) {
+    else if (f==jl_builtin_getfield && nargs==2) {
         if (jl_is_quotenode(args[2]) && jl_is_symbol(jl_fieldref(args[2],0))) {
             *ret = emit_getfield(args[1],
                                  (jl_sym_t*)jl_fieldref(args[2],0), ctx);
@@ -2498,15 +2620,17 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         // VA tuple
         if (ctx->vaStack && symbol_eq(args[1], ctx->vaName)) {
             Value *valen = emit_n_varargs(ctx);
-            Value *idx = emit_unbox(T_size,
-                                    emit_unboxed(args[2], ctx), fldt);
+            Value *idx = emit_unbox(T_size, emit_expr(args[2], ctx), fldt);
             idx = emit_bounds_check(
-                    jl_cgval_t(builder.CreateGEP(ctx->argArray, ConstantInt::get(T_size, ctx->nReqArgs)), NULL),
+                    jl_cgval_t(builder.CreateGEP(ctx->argArray, ConstantInt::get(T_size, ctx->nReqArgs)), NULL, false, NULL),
                     NULL, idx, valen, ctx);
             idx = builder.CreateAdd(idx, ConstantInt::get(T_size, ctx->nReqArgs));
             *ret = mark_julia_type(
-                    tbaa_decorate(tbaa_user,builder.CreateLoad(builder.CreateGEP(ctx->argArray,idx))),
-                    expr_type(expr, ctx));
+                    tbaa_decorate(tbaa_user, builder.CreateLoad(builder.CreateGEP(ctx->argArray, idx))),
+                    /*boxed*/ true,
+                    expr_type(expr, ctx),
+                    ctx,
+                    /*needsgcroot*/ false);
             JL_GC_POP();
             return true;
         }
@@ -2525,7 +2649,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                 }
                 else {
                     // unknown index
-                    Value *vidx = emit_unbox(T_size, emit_unboxed(args[2], ctx), (jl_value_t*)jl_long_type);
+                    Value *vidx = emit_unbox(T_size, emit_expr(args[2], ctx), (jl_value_t*)jl_long_type);
                     if (emit_getfield_unknownidx(ret, strct, vidx, stt, ctx)) {
                         if (ret->typ == (jl_value_t*)jl_any_type) // improve the type, if known from the expr
                             ret->typ = expr_type(expr, ctx);
@@ -2537,7 +2661,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         }
     }
 
-    else if (f->fptr == &jl_f_set_field && nargs==3) {
+    else if (f==jl_builtin_setfield && nargs==3) {
         jl_datatype_t *sty = (jl_datatype_t*)expr_type(args[1], ctx);
         rt1 = (jl_value_t*)sty;
         if (jl_is_structtype(sty) && sty != jl_module_type &&
@@ -2551,10 +2675,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
                 if (jl_is_leaf_type((jl_value_t*)sty) && jl_subtype(rhst, ft, 0)) {
                     // TODO: attempt better codegen for approximate types
                     jl_cgval_t strct = emit_expr(args[1], ctx); // emit lhs
-                    if (sty->fields[idx].isptr) // emit rhs
-                        *ret = emit_expr(args[3], ctx);
-                    else
-                        *ret = emit_unboxed(args[3], ctx);
+                    *ret = emit_expr(args[3], ctx);
                     emit_setfield(sty, strct, idx, *ret, ctx, true, true);
                     JL_GC_POP();
                     return true;
@@ -2564,9 +2685,9 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         // TODO: faster code for integer index
     }
 
-    else if (f->fptr == &jl_f_nfields && nargs==1) {
+    else if (f==jl_builtin_nfields && nargs==1) {
         if (ctx->vaStack && symbol_eq(args[1], ctx->vaName) && !ctx->vars[ctx->vaName].isAssigned) {
-            *ret = mark_julia_type(emit_n_varargs(ctx), jl_long_type);
+            *ret = mark_julia_type(emit_n_varargs(ctx), false, jl_long_type, ctx);
             JL_GC_POP();
             return true;
         }
@@ -2576,7 +2697,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
             if (jl_is_leaf_type(tp0)) {
                 emit_expr(args[1], ctx);
                 assert(jl_is_datatype(tp0));
-                *ret = mark_julia_type(ConstantInt::get(T_size, jl_datatype_nfields(tp0)), jl_long_type);
+                *ret = mark_julia_type(ConstantInt::get(T_size, jl_datatype_nfields(tp0)), false, jl_long_type, ctx);
                 JL_GC_POP();
                 return true;
             }
@@ -2584,36 +2705,44 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
         else if (jl_is_leaf_type(aty)) {
             jl_cgval_t arg1 = emit_expr(args[1], ctx);
             Value *sz;
-            if (aty == (jl_value_t*)jl_datatype_type)
-                sz = emit_datatype_nfields(arg1);
-            else
+            if (arg1.constant) {
+                sz = ConstantInt::get(T_size, jl_datatype_nfields(arg1.typ));
+            }
+            else if (aty == (jl_value_t*)jl_datatype_type) {
+                assert(arg1.isboxed);
+                sz = emit_datatype_nfields(boxed(arg1, ctx));
+            }
+            else {
                 sz = ConstantInt::get(T_size, jl_datatype_nfields(aty));
-            *ret = mark_julia_type(sz, jl_long_type);
+            }
+            *ret = mark_julia_type(sz, false, jl_long_type, ctx);
             JL_GC_POP();
             return true;
         }
     }
 
-    else if (f->fptr == &jl_f_field_type && nargs==2) {
+    else if (f==jl_builtin_fieldtype && nargs==2) {
         jl_datatype_t *sty = (jl_datatype_t*)expr_type(args[1], ctx);
         rt1 = (jl_value_t*)sty;
         if (jl_is_type_type((jl_value_t*)sty) || sty == jl_datatype_type) {
             rt2 = expr_type(args[2], ctx); // index argument type
             if (rt2 == (jl_value_t*)jl_long_type) {
                 jl_cgval_t ty = emit_expr(args[1], ctx);
-                Value *types_svec = emit_datatype_types(ty);
-                Value *types_len = emit_datatype_nfields(ty);
-                Value *idx = emit_unbox(T_size, emit_unboxed(args[2], ctx), (jl_value_t*)jl_long_type);
+                assert(ty.isboxed);
+                Value *tyv = boxed(ty, ctx);
+                Value *types_svec = emit_datatype_types(tyv);
+                Value *types_len = emit_datatype_nfields(tyv);
+                Value *idx = emit_unbox(T_size, emit_expr(args[2], ctx), (jl_value_t*)jl_long_type);
                 emit_bounds_check(ty, (jl_value_t*)jl_datatype_type, idx, types_len, ctx);
-                Value *fieldtyp = builder.CreateLoad(builder.CreateGEP(builder.CreateBitCast(types_svec, jl_ppvalue_llvmt), idx));
-                *ret = mark_julia_type(fieldtyp, expr_type(expr, ctx));
+                Value *fieldtyp = builder.CreateLoad(builder.CreateGEP(builder.CreateBitCast(types_svec, T_ppjlvalue), idx));
+                *ret = mark_julia_type(fieldtyp, true, expr_type(expr, ctx), ctx);
                 JL_GC_POP();
                 return true;
             }
         }
     }
 
-    else if (f->fptr == &jl_f_sizeof && nargs == 1) {
+    else if (f==jl_builtin_sizeof && nargs == 1) {
         jl_datatype_t *sty = (jl_datatype_t*)expr_type(args[1], ctx);
         rt1 = (jl_value_t*)sty;
         if (jl_is_type_type((jl_value_t*)sty) && !jl_is_typevar(jl_tparam0(sty))) {
@@ -2626,14 +2755,14 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
             sty != jl_datatype_type) {
             if (jl_is_leaf_type((jl_value_t*)sty) ||
                 (sty->name->names == jl_emptysvec && sty->size > 0)) {
-                *ret = mark_julia_type(ConstantInt::get(T_size, sty->size), jl_long_type);
+                *ret = mark_julia_type(ConstantInt::get(T_size, sty->size), false, jl_long_type, ctx);
                 JL_GC_POP();
                 return true;
             }
         }
     }
 
-    else if (f->fptr == &jl_f_instantiate_type && nargs > 0) {
+    else if (f==jl_builtin_apply_type && nargs > 0) {
         size_t i;
         for(i=1; i <= nargs; i++) {
             if (!is_constant(args[i], ctx))
@@ -2657,82 +2786,81 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
     return false;
 }
 
-static Value *emit_jlcall(Value *theFptr, Value *theF, int argStart,
+static Value *emit_jlcall(Value *theFptr, Value *theF, jl_value_t **args,
                           size_t nargs, jl_codectx_t *ctx)
 {
-    // call
+    // emit arguments
     Value *myargs;
-    if (nargs > 0)
-        myargs = emit_temp_slot(argStart, ctx);
-    else
-        myargs = Constant::getNullValue(jl_ppvalue_llvmt);
+    if (nargs > 0) {
+        jl_cgval_t *anArg = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargs);
+        const jl_cgval_t **largs = (const jl_cgval_t**)alloca(sizeof(jl_cgval_t*) * nargs);
+        for(size_t i=0; i < nargs; i++) {
+            anArg[i] = emit_expr(args[i], ctx);
+            largs[i] = &anArg[i];
+        }
+        // put into argument space
+        myargs = make_jlcall(makeArrayRef(largs, nargs), ctx);
+    }
+    else {
+        myargs = Constant::getNullValue(T_ppjlvalue);
+    }
 #ifdef LLVM37
     Value *result = builder.CreateCall(prepare_call(theFptr), {theF, myargs,
-                                        ConstantInt::get(T_int32,nargs)});
+                                       ConstantInt::get(T_int32,nargs)});
 #else
     Value *result = builder.CreateCall3(prepare_call(theFptr), theF, myargs,
                                         ConstantInt::get(T_int32,nargs));
 #endif
-    ctx->gc.argDepth = argStart; // clear the args from the gcstack
     return result;
 }
 
-static Value *emit_jlcall(Value *theFptr, Value *theF, jl_value_t **args,
-                          size_t nargs, jl_codectx_t *ctx)
+static jl_cgval_t emit_call_function_object(jl_lambda_info_t *li, const jl_cgval_t &theF, Value *theFptr,
+                                            jl_value_t **args, size_t nargs, jl_value_t *callexpr, jl_codectx_t *ctx)
 {
-    // emit arguments
-    int argStart = ctx->gc.argDepth;
-    for(size_t i=0; i < nargs; i++) {
-        jl_cgval_t anArg = emit_expr(args[i], ctx, true, true);
-        // put into argument space
-        make_gcroot(boxed(anArg, ctx, expr_type(args[i],ctx)), ctx);
-    }
-    return emit_jlcall(theFptr, theF, argStart, nargs, ctx);
-}
-
-static jl_cgval_t emit_call_function_object(jl_function_t *f, Value *theF, Value *theFptr,
-                                        bool specialized,
-                                        jl_value_t **args, size_t nargs,
-                                        jl_codectx_t *ctx)
-{
-    Value *result;
-    if (f!=NULL && specialized && f->linfo!=NULL && f->linfo->specFunctionObject!=NULL) {
+    if (li->functionObjects.specFunctionObject != NULL) {
         // emit specialized call site
-        jl_value_t *jlretty = jl_ast_rettype(f->linfo, f->linfo->ast);
-        Function *cf = (Function*)f->linfo->specFunctionObject;
+        jl_value_t *jlretty = li->rettype;
+        bool retboxed;
+        (void)julia_type_to_llvm(jlretty, &retboxed);
+        Function *cf = (Function*)li->functionObjects.specFunctionObject;
+        if (!cf->getParent() || (cf->getParent() == builtins_module &&
+            builtins_module != active_module)) { // Call cycle
+            prepare_call(cf);
+        }
         FunctionType *cft = cf->getFunctionType();
         size_t nfargs = cft->getNumParams();
         Value **argvals = (Value**) alloca(nfargs*sizeof(Value*));
+        bool sret = cf->hasStructRetAttr();
         unsigned idx = 0;
-        for(size_t i=0; i < nargs; i++) {
+        Value *result;
+        if (sret) {
+            result = emit_static_alloca(cft->getParamType(0)->getContainedType(0), ctx);
+            argvals[idx] = result;
+            idx++;
+        }
+        for(size_t i=0; i < nargs+1; i++) {
             Type *at = cft->getParamType(idx);
-            jl_value_t *jt = jl_nth_slot_type(f->linfo->specTypes,i);
-            Type *et = julia_type_to_llvm(jt);
+            jl_value_t *jt = jl_nth_slot_type(li->specTypes,i);
+            bool isboxed;
+            Type *et = julia_type_to_llvm(jt, &isboxed);
             if (type_is_ghost(et)) {
                 // Still emit the expression in case it has side effects
-                emit_expr(args[i+1], ctx);
+                if (i>0) emit_expr(args[i], ctx);
                 continue;
             }
-            if (at == jl_pvalue_llvmt) {
-                jl_cgval_t origval = emit_expr(args[i+1], ctx);
-                argvals[idx] = boxed(origval, ctx,expr_type(args[i+1],ctx));
-                assert(dyn_cast<UndefValue>(argvals[idx]) == 0);
-                // TODO: there should be a function emit_rooted that handles this, leaving
-                // the value rooted if it was already, to avoid redundant stores.
-                if (!origval.isboxed ||
-                    (might_need_root(args[i+1]) && !is_stable_expr(args[i+1], ctx))) {
-                    make_gcroot(argvals[idx], ctx);
-                }
+            if (isboxed) {
+                assert(at == T_pjlvalue && et == T_pjlvalue);
+                jl_cgval_t origval = i==0 ? theF : emit_expr(args[i], ctx);
+                argvals[idx] = boxed(origval, ctx);
+                assert(!isa<UndefValue>(argvals[idx]));
             }
             else if (et->isAggregateType()) {
                 assert(at == PointerType::get(et, 0));
-                jl_cgval_t arg = emit_unboxed(args[i+1], ctx);
-                if (arg.isimmutable && !arg.needsgcroot && arg.ispointer) {
+                jl_cgval_t arg = i==0 ? theF : emit_expr(args[i], ctx);
+                if (arg.isimmutable && arg.ispointer) {
                     // can lazy load on demand, no copy needed
-                    Value *argv = arg.V;
-                    if (argv->getType() != at)
-                        builder.CreatePointerCast(argv, at);
-                    argvals[idx] = argv;
+                    argvals[idx] = data_pointer(arg, ctx, at);
+                    mark_gc_use(arg); // jwn must be after the jlcall
                 }
                 else {
                     Value *v = emit_unbox(et, arg, jt);
@@ -2743,176 +2871,114 @@ static jl_cgval_t emit_call_function_object(jl_function_t *f, Value *theF, Value
             }
             else {
                 assert(at == et);
-                argvals[idx] = emit_unbox(et, emit_unboxed(args[i+1], ctx), jt);
+                if (i == 0)
+                    argvals[idx] = emit_unbox(et, theF, jt);
+                else
+                    argvals[idx] = emit_unbox(et, emit_expr(args[i], ctx), jt);
             }
             idx++;
         }
         assert(idx == nfargs);
-        result = builder.CreateCall(prepare_call(cf), ArrayRef<Value*>(&argvals[0],nfargs));
-        return mark_julia_type(emit_reg2mem(result, ctx), jlretty);
+        CallInst *call = builder.CreateCall(prepare_call(cf), ArrayRef<Value*>(&argvals[0], nfargs));
+        call->setAttributes(cf->getAttributes());
+        return sret ? mark_julia_slot(result, jlretty) : mark_julia_type(call, retboxed, jlretty, ctx);
     }
-    return mark_julia_type(emit_jlcall(theFptr, theF, &args[1], nargs, ctx), jl_any_type); // (typ will be patched up by caller)
-}
-
-static Value *emit_is_function(Value *x, jl_codectx_t *ctx)
-{
-    Value *xty = emit_typeof(x);
-    Value *isfunc =
-        builder.CreateICmpEQ(xty, literal_pointer_val((jl_value_t*)jl_function_type));
-    return isfunc;
+    return mark_julia_type(emit_jlcall(theFptr, boxed(theF,ctx), &args[1], nargs, ctx), true,
+                           expr_type(callexpr, ctx), ctx);
 }
 
 static jl_cgval_t emit_call(jl_value_t **args, size_t arglen, jl_codectx_t *ctx, jl_value_t *expr)
 {
     size_t nargs = arglen-1;
-    Value *theFptr=NULL, *theF=NULL;
-    jl_value_t *a0 = args[0];
-    jl_value_t *hdtype;
-    bool headIsGlobal = false;
-    bool definitely_function = false;
-    bool definitely_not_function = false;
+    Value *theFptr = NULL;
     jl_cgval_t result;
+    jl_value_t *aty = NULL;
 
-    jl_function_t *f = (jl_function_t*)static_eval(a0, ctx, true);
-    JL_GC_PUSH1(&f);
+    jl_function_t *f = (jl_function_t*)static_eval(args[0], ctx, true);
+    JL_GC_PUSH2(&f, &aty);
     if (f != NULL) {
         // function is a compile-time constant
-        headIsGlobal = true;
-        definitely_function = jl_is_func(f);
-        definitely_not_function = !definitely_function;
-        bool handled;
-        if (jl_typeis(f, jl_intrinsic_type) || jl_is_func(f)) {
-            handled = emit_known_call(&result, (jl_value_t*)f, args, nargs, ctx, &theFptr, &f, expr);
-            assert(!jl_typeis(f,jl_intrinsic_type) || handled);
+        if (jl_typeis(f, jl_intrinsic_type)) {
+            result = emit_intrinsic((intrinsic)*(uint32_t*)jl_data_ptr(f), args, nargs, ctx);
+            if (result.typ == (jl_value_t*)jl_any_type) // the select_value intrinsic may be missing type information
+                result = remark_julia_type(result, expr_type(expr, ctx));
+            JL_GC_POP();
+            return result;
         }
-        else {
-            handled = emit_known_call(&result, (jl_value_t*)jl_module_call_func(ctx->module),
-                                      args-1, nargs+1, ctx, &theFptr, &f, expr);
+        if (jl_subtype(f, (jl_value_t*)jl_builtin_type, 1)) {
+            bool handled = emit_builtin_call(&result, (jl_value_t*)f, args, nargs, ctx, expr);
+            if (handled) {
+                JL_GC_POP();
+                return result;
+            }
         }
-        if (handled) {
+    }
+
+    // special case for known builtin not handled by emit_builtin_call
+    if (f && jl_subtype(f, (jl_value_t*)jl_builtin_type, 1)) {
+        std::map<jl_fptr_t,Function*>::iterator it = builtin_func_map.find(jl_get_builtin_fptr(f));
+        if (it != builtin_func_map.end()) {
+            theFptr = (*it).second;
+            result = mark_julia_type(emit_jlcall(theFptr, V_null, &args[1], nargs, ctx), true, expr_type(expr,ctx), ctx);
             JL_GC_POP();
             return result;
         }
     }
 
-    hdtype = expr_type(a0, ctx);
-    definitely_function |= (hdtype == (jl_value_t*)jl_function_type);
-    definitely_not_function |= (jl_is_leaf_type(hdtype) && !definitely_function);
-
-    assert(!(definitely_function && definitely_not_function));
-
-    int last_depth = ctx->gc.argDepth;
-
-    if (definitely_not_function) {
-        f = jl_module_call_func(ctx->module);
-        bool handled = emit_known_call(NULL, (jl_value_t*)f, args-1, nargs+1, ctx, &theFptr, &f, expr);
-        assert(!handled); (void)handled;
-        if (theFptr == NULL) {
-            just_emit_error("\"call\" is not a generic function", ctx);
-            result = jl_cgval_t();
-        }
-        else {
-            theF = literal_pointer_val((jl_value_t*)f);
-            result = emit_call_function_object(f, theF, theFptr, true, args-1, nargs+1, ctx);
-        }
-    }
-    else if (definitely_function) {
-        bool specialized = true;
-        if (theFptr == NULL) {
-            specialized = false;
-            if (f != NULL) {
-                // builtin functions don't need the function object passed and are constant
-                std::map<jl_fptr_t,Function*>::iterator it = builtin_func_map.find(f->fptr);
-                if (it != builtin_func_map.end()) {
-                    theFptr = (*it).second;
-                    theF = V_null;
+    if (ctx->linfo->inferred) {
+        aty = (jl_value_t*)call_arg_types(args, arglen, ctx);
+        // attempt compile-time specialization for inferred types
+        if (aty != NULL) {
+            aty = (jl_value_t*)jl_apply_tuple_type((jl_svec_t*)aty);
+            /*if (trace) {
+                  jl_printf(JL_STDOUT, "call %s%s\n",
+                  jl_sprint(args[0]),
+                  jl_sprint((jl_value_t*)aty));
+              }*/
+            jl_lambda_info_t *li = jl_get_specialization1((jl_tupletype_t*)aty, ctx->cyclectx);
+            if (li != NULL) {
+                assert(li->functionObjects.functionObject != NULL);
+                theFptr = (Value*)li->functionObjects.functionObject;
+                jl_cgval_t fval;
+                if (f != NULL) {
+                    // TODO jb/functions: avoid making too many roots here
+                    if (!jl_is_globalref(args[0]) &&
+                        !(jl_is_symbol(args[0]) && is_global((jl_sym_t*)args[0],ctx)) &&
+                        !jl_is_leaf_type(f)) {
+                        jl_add_linfo_root(ctx->linfo, f);
+                    }
+                    fval = mark_julia_const((jl_value_t*)f);
                 }
+                else {
+                    fval = emit_expr(args[0], ctx);
+                }
+                jl_add_linfo_root(ctx->linfo, (jl_value_t*)li);
+                result = emit_call_function_object(li, fval, theFptr, args, nargs, expr, ctx);
+                JL_GC_POP();
+                return result;
             }
-            if (theFptr == NULL) {
-                Value *theFunc = boxed(emit_expr(args[0], ctx), ctx);
-                if (!headIsGlobal && (jl_is_expr(a0) || jl_is_lambda_info(a0)))
-                    make_gcroot(theFunc, ctx);
-                // extract pieces of the function object
-                // TODO: try extractvalue instead
-                theFptr = emit_nthptr_recast(theFunc, (ssize_t)(offsetof(jl_function_t,fptr)/sizeof(void*)), tbaa_func, jl_pfptr_llvmt);
-                theF = theFunc;
-            }
-        }
-        else {
-            theF = literal_pointer_val((jl_value_t*)f);
         }
-        result = emit_call_function_object(f, theF, theFptr, specialized, args, nargs, ctx);
     }
-    else {
-        // either direct function, or use call(), based on run-time branch
 
-        // emit "function" and arguments
-        int argStart = ctx->gc.argDepth;
-        Value *theFunc = boxed(emit_expr(args[0], ctx), ctx);
-        make_gcroot(theFunc, ctx);
-        for(size_t i=0; i < nargs; i++) {
-            jl_cgval_t anArg = emit_expr(args[i+1], ctx);
-            // put into argument space
-            make_gcroot(boxed(anArg, ctx, expr_type(args[i+1],ctx)), ctx);
-        }
-
-        Value *isfunc = emit_is_function(theFunc, ctx);
-        BasicBlock *funcBB1 = BasicBlock::Create(getGlobalContext(),"isf", ctx->f);
-        BasicBlock *elseBB1 = BasicBlock::Create(getGlobalContext(),"notf");
-        BasicBlock *mergeBB1 = BasicBlock::Create(getGlobalContext(),"mergef");
-        builder.CreateCondBr(isfunc, funcBB1, elseBB1);
-
-        builder.SetInsertPoint(funcBB1);
-        // is function
-        Value *myargs;
-        if (nargs > 0)
-            myargs = emit_temp_slot(argStart + 1, ctx); // argStart holds theFunc, argStart + 1 holds the start of the argument list
-        else
-            myargs = Constant::getNullValue(jl_ppvalue_llvmt); // no arguments
-        theFptr = emit_nthptr_recast(theFunc, (ssize_t)(offsetof(jl_function_t,fptr)/sizeof(void*)), tbaa_func, jl_pfptr_llvmt);
-#ifdef LLVM37
-        Value *r1 = builder.CreateCall(prepare_call(theFptr), {theFunc, myargs,
-                                        ConstantInt::get(T_int32,nargs)});
-#else
-        Value *r1 = builder.CreateCall3(prepare_call(theFptr), theFunc, myargs,
-                                        ConstantInt::get(T_int32,nargs));
-#endif
-        builder.CreateBr(mergeBB1);
-        ctx->f->getBasicBlockList().push_back(elseBB1);
-        builder.SetInsertPoint(elseBB1);
-        // not function
-        myargs = emit_temp_slot(argStart, ctx);
-        jl_value_t *call_func = (jl_value_t*)jl_module_call_func(ctx->module);
-        Value *r2;
-        if (!jl_is_gf(call_func)) {
-            just_emit_error("\"call\" is not a generic function", ctx);
-            r2 = UndefValue::get(jl_pvalue_llvmt);
-        }
-        else {
+    // emit function and arguments
+    nargs++; // add function to nargs count
+    jl_cgval_t *anArg = (jl_cgval_t*)alloca(sizeof(jl_cgval_t) * nargs);
+    const jl_cgval_t **largs = (const jl_cgval_t**)alloca(sizeof(jl_cgval_t*) * nargs);
+    for(size_t i=0; i < nargs; i++) {
+        anArg[i] = emit_expr(args[i], ctx);
+        largs[i] = &anArg[i];
+    }
+    // put into argument space
+    Value *myargs = make_jlcall(makeArrayRef(largs, nargs), ctx);
 #ifdef LLVM37
-            r2 = builder.CreateCall(prepare_call(jlapplygeneric_func),
-                                    {literal_pointer_val(call_func),
-                                     myargs,
-                                     ConstantInt::get(T_int32, nargs + 1)});
+    Value *callval = builder.CreateCall(prepare_call(jlapplygeneric_func),
+                                 {myargs, ConstantInt::get(T_int32, nargs)});
 #else
-            r2 = builder.CreateCall3(prepare_call(jlapplygeneric_func),
-                                     literal_pointer_val(call_func),
-                                     myargs,
-                                     ConstantInt::get(T_int32, nargs + 1));
+    Value *callval = builder.CreateCall2(prepare_call(jlapplygeneric_func),
+                                  myargs, ConstantInt::get(T_int32, nargs));
 #endif
-        }
-        builder.CreateBr(mergeBB1);
-        ctx->f->getBasicBlockList().push_back(mergeBB1);
-        builder.SetInsertPoint(mergeBB1);
-        PHINode *ph = builder.CreatePHI(jl_pvalue_llvmt, 2);
-        ph->addIncoming(r1, funcBB1);
-        ph->addIncoming(r2, elseBB1);
-        result = mark_julia_type(ph, jl_any_type);
-    }
-    if (result.typ == (jl_value_t*)jl_any_type)
-        result = remark_julia_type(result, expr_type(expr, ctx)); // patch up typ if necessary
+    result = mark_julia_type(callval, true, expr_type(expr, ctx), ctx);
 
-    ctx->gc.argDepth = last_depth; // remove the arguments from the gc stack
     JL_GC_POP();
     return result;
 }
@@ -2953,11 +3019,11 @@ static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
         b = jl_get_binding(m, s);
         if (b == NULL) {
             // var not found. switch to delayed lookup.
-            Constant *initnul = ConstantPointerNull::get((PointerType*)jl_pvalue_llvmt);
+            Constant *initnul = ConstantPointerNull::get((PointerType*)T_pjlvalue);
             GlobalVariable *bindinggv =
-                new GlobalVariable(*jl_Module, jl_pvalue_llvmt,
+                prepare_global(new GlobalVariable(imaging_mode ? *shadow_module : *builtins_module, T_pjlvalue,
                                    false, GlobalVariable::PrivateLinkage,
-                                   initnul, "delayedvar");
+                                   initnul, "delayedvar"));
             Value *cachedval = builder.CreateLoad(bindinggv);
             BasicBlock *have_val = BasicBlock::Create(jl_LLVMContext, "found"),
                 *not_found = BasicBlock::Create(jl_LLVMContext, "notfound");
@@ -2978,11 +3044,12 @@ static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
             builder.CreateBr(have_val);
             ctx->f->getBasicBlockList().push_back(have_val);
             builder.SetInsertPoint(have_val);
-            PHINode *p = builder.CreatePHI(jl_pvalue_llvmt, 2);
+            PHINode *p = builder.CreatePHI(T_pjlvalue, 2);
             p->addIncoming(cachedval, currentbb);
             p->addIncoming(bval, not_found);
-            return julia_binding_gv(builder.CreateBitCast(p, jl_ppvalue_llvmt));
+            return julia_binding_gv(builder.CreateBitCast(p, T_ppjlvalue));
         }
+        if (b->deprecated) cg_bdw(b, ctx);
     }
     if (pbnd) *pbnd = b;
     return julia_binding_gv(b);
@@ -2990,26 +3057,31 @@ static Value *global_binding_pointer(jl_module_t *m, jl_sym_t *s,
 
 static jl_cgval_t emit_checked_var(Value *bp, jl_sym_t *name, jl_codectx_t *ctx, bool isvol)
 {
-    assert(bp->getType() == jl_ppvalue_llvmt);
+    assert(bp->getType() == T_ppjlvalue);
     Value *v = builder.CreateLoad(bp, isvol);
-    // in unreachable code, there might be a poorly-typed instance of a variable
-    // that has a concrete type everywhere it's actually used. tolerate this
-    // situation by just skipping the NULL check if it wouldn't be valid. (issue #7836)
-    if (v->getType() == jl_pvalue_llvmt)
-        undef_var_error_if_null(v, name, ctx);
-    return mark_julia_type(v, jl_any_type);
+    undef_var_error_if_null(v, name, ctx);
+    return mark_julia_type(v, true, jl_any_type, ctx);
 }
 
-static jl_cgval_t emit_var(jl_sym_t *sym, jl_value_t *ty, jl_codectx_t *ctx, bool isboxed)
+static jl_cgval_t emit_var(jl_sym_t *sym, jl_codectx_t *ctx)
 {
     bool isglobal = is_global(sym, ctx);
     if (isglobal) {
         // look for static parameter
-        for(size_t i=0; i < jl_svec_len(ctx->sp); i+=2) {
-            assert(jl_is_symbol(jl_svecref(ctx->sp, i)));
-            if (sym == (jl_sym_t*)jl_svecref(ctx->sp, i)) {
-                jl_value_t *sp = jl_svecref(ctx->sp, i+1);
-                return mark_julia_const(sp);
+        jl_svec_t *sp = ctx->linfo->sparam_syms;
+        for(size_t i=0; i < jl_svec_len(sp); i++) {
+            assert(jl_is_symbol(jl_svecref(sp, i)));
+            if (sym == (jl_sym_t*)jl_svecref(sp, i)) {
+                if (jl_svec_len(ctx->linfo->sparam_vals) > 0) {
+                    return mark_julia_const(jl_svecref(ctx->linfo->sparam_vals, i));
+                }
+                else {
+                    assert(ctx->spvals_ptr != NULL);
+                    Value *bp = builder.CreateConstInBoundsGEP1_32(LLVM37_param(T_pjlvalue)
+                            builder.CreateBitCast(ctx->spvals_ptr, T_ppjlvalue),
+                            i + sizeof(jl_svec_t) / sizeof(jl_value_t*));
+                    return mark_julia_type(tbaa_decorate(tbaa_const, builder.CreateLoad(bp)), true, jl_any_type, ctx);
+                }
             }
         }
         jl_binding_t *jbp=NULL;
@@ -3017,13 +3089,12 @@ static jl_cgval_t emit_var(jl_sym_t *sym, jl_value_t *ty, jl_codectx_t *ctx, boo
         assert(bp != NULL);
         if (jbp && jbp->value != NULL) {
             if (jbp->constp) {
-                if (!isboxed && jl_isbits(jl_typeof(jbp->value)))
-                    return emit_unboxed(jbp->value, ctx);
+                return mark_julia_const(jbp->value);
             }
             // double-check that a global variable is actually defined. this
             // can be a problem in parallel when a definition is missing on
             // one machine.
-            return mark_julia_type(builder.CreateLoad(bp), jbp->constp ? jl_typeof(jbp->value) : (jl_value_t*)jl_any_type);
+            return mark_julia_type(builder.CreateLoad(bp), true, jl_any_type, ctx);
         }
         return emit_checked_var(bp, sym, ctx);
     }
@@ -3031,23 +3102,11 @@ static jl_cgval_t emit_var(jl_sym_t *sym, jl_value_t *ty, jl_codectx_t *ctx, boo
     jl_varinfo_t &vi = ctx->vars[sym];
     if (vi.memloc) {
         Value *bp = vi.memloc;
-        if (vi.isBox) {
-            Instruction *load = builder.CreateLoad(bp);
-            if (vi.closureidx != -1) {
-                // if the jl_box_t in the closure env, it will be const in the function
-                load = tbaa_decorate(tbaa_const, load);
-            }
-            bp = builder.CreatePointerCast(load, jl_ppvalue_llvmt);
-        }
         if (vi.isArgument ||  // arguments are always defined
-            ((vi.closureidx == -1 || !vi.isAssigned) && !vi.usedUndef)) {
+            (!vi.isAssigned && !vi.usedUndef)) {
             // if no undef usage was found by inference, and it's either not assigned or not in env it must be always defined
             Instruction *v = builder.CreateLoad(bp, vi.isVolatile);
-            if (vi.closureidx != -1 && !vi.isAssigned) {
-                // if it's in the closure env, but only assigned by the parent function, it will be const while in the child function
-                v = tbaa_decorate(tbaa_const, v);
-            }
-            return mark_julia_type(v, vi.value.typ);
+            return mark_julia_type(v, true, vi.value.typ, ctx);
         }
         else {
             jl_cgval_t v = emit_checked_var(bp, sym, ctx, vi.isVolatile);
@@ -3059,10 +3118,8 @@ static jl_cgval_t emit_var(jl_sym_t *sym, jl_value_t *ty, jl_codectx_t *ctx, boo
         // copy value to a non-volatile location
         assert(vi.value.ispointer);
         Type *T = julia_type_to_llvm(vi.value.typ)->getPointerTo();
-        Value *v = vi.value.V;
-        if (v->getType() != T)
-            v = builder.CreatePointerCast(v, T);
-        return mark_julia_type(builder.CreateLoad(v, true), vi.value.typ);
+        Value *v = data_pointer(vi.value, ctx, T);
+        return mark_julia_type(builder.CreateLoad(v, true), false, vi.value.typ, ctx);
     }
     else {
         return vi.value;
@@ -3075,35 +3132,26 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
         ssize_t idx = ((jl_gensym_t*)l)->id;
         assert(idx >= 0);
         assert(!ctx->gensym_assigned.at(idx));
-        jl_value_t *gensym_types = jl_lam_gensyms(ctx->ast);
-        jl_value_t *declType = (jl_is_array(gensym_types) ? jl_cellref(gensym_types, idx) : (jl_value_t*)jl_any_type);
-        jl_cgval_t slot; // slot is a jl_value_t or jl_value_t*
-        if (store_unboxed_p(declType)) {
-            Type *vtype = julia_struct_to_llvm(declType);
-            assert(vtype != jl_pvalue_llvmt);
-            if (type_is_ghost(vtype)) {
-                slot = emit_expr(r, ctx);
-            }
-            else {
-                slot = emit_unboxed(r, ctx);
-                if (slot.ispointer) { // emit a copy of boxed isbits values. TODO: elid this copy if unnecessary
-                    slot = mark_julia_type(
-                            emit_unbox(julia_type_to_llvm(declType), slot, declType),
-                            declType);
+        jl_cgval_t slot = emit_expr(r, ctx); // slot could be a jl_value_t (unboxed) or jl_value_t* (ispointer)
+        if (!slot.isboxed && !slot.isimmutable) { // emit a copy of values stored in mutable slots
+            Type *vtype = julia_type_to_llvm(slot.typ);
+            assert(vtype != T_pjlvalue);
+            slot = mark_julia_type(
+                    emit_unbox(vtype, slot, slot.typ),
+                    false, slot.typ, ctx);
+        }
+        else if (slot.isboxed) {
+            // see if inference had a better type for the gensym than the expression (after inlining getfield on a Tuple)
+            jl_value_t *gensym_types = jl_lam_gensyms(ctx->ast);
+            if (jl_is_array(gensym_types)) {
+                jl_value_t *declType = jl_cellref(gensym_types, idx);
+                if (declType != slot.typ) {
+                    slot = remark_julia_type(slot, declType);
                 }
             }
         }
-        else {
-            Value *rval = boxed(emit_expr(r, ctx, true), ctx);
-            if (!is_stable_expr(r, ctx)) {
-                // add a gc root for this GenSym node
-                Value *bp = emit_local_slot(ctx->gc.argSpaceSize++, ctx);
-                builder.CreateStore(rval, bp);
-            }
-            slot = mark_julia_type(rval, declType);
-        }
         ctx->gensym_SAvalues.at(idx) = slot; // now gensym_SAvalues[idx] contains the SAvalue
-        assert(ctx->gensym_assigned.at(idx) = true); // (assignment, not comparison test)
+        ctx->gensym_assigned.at(idx) = true;
         return;
     }
 
@@ -3123,7 +3171,7 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
     }
     if (bp != NULL) { // it's a global
         assert(bnd);
-        Value *rval = boxed(emit_expr(r, ctx, true),ctx);
+        Value *rval = boxed(emit_expr(r, ctx), ctx, false); // no root needed since this is about to be assigned to a global
 #ifdef LLVM37
         builder.CreateCall(prepare_call(jlcheckassign_func),
                            {literal_pointer_val(bnd),
@@ -3138,77 +3186,57 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
         return;
     }
 
-    // it's a local variable or closure variable
+    // it's a local variable
     jl_varinfo_t &vi = ctx->vars[s];
-    if (!vi.memloc && !vi.hasGCRoot && vi.used
-            && !vi.isArgument && !is_stable_expr(r, ctx) && !vi.value.isghost) {
-        Instruction *newroot = cast<Instruction>(emit_local_slot(ctx->gc.argSpaceSize++, ctx));
-        newroot->removeFromParent(); // move it to the gc frame basic block so it can be reused as needed
-        newroot->insertAfter(ctx->gc.last_gcframe_inst);
-        vi.memloc = newroot;
-        vi.hasGCRoot = true; // this has been discovered to need a gc root, add it now
-        //TODO: move this logic after the emit_expr
+    jl_cgval_t rval_info = emit_expr(r, ctx);
+    if (!vi.used)
+        return;
+
+    // add info to arravar list
+    if (rval_info.isboxed) {
+        // check isboxed in case rval isn't the right type (for example, on a dead branch),
+        // so we don't try to assign it to the arrayvar info
+        jl_arrayvar_t *av = arrayvar_for(l, ctx);
+        if (av != NULL) {
+            assign_arrayvar(*av, rval_info, ctx);
+        }
     }
 
-    if (vi.memloc || !vi.hasGCRoot) {
+    if (vi.memloc) {
         // boxed or unused variables
-        jl_cgval_t rval_info = emit_expr(r, ctx, true);
-        if (!vi.used)
-            return;
-        Value *rval = boxed(rval_info, ctx);
-        if (vi.memloc) {
-            Value *bp = vi.memloc;
-            if ((jl_is_symbol(r) || jl_is_symbolnode(r)) && (!rval_info.typ || rval_info.typ == jl_bottom_type)) {
-                if (vi.usedUndef) {
-                    // sometimes x = y::Union{} occurs
-                    jl_sym_t *s;
-                    if (jl_is_symbolnode(r))
-                        s = jl_symbolnode_sym(r);
-                    else
-                        s = (jl_sym_t*)r;
-                    builder.CreateCall(prepare_call(jlundefvarerror_func), literal_pointer_val((jl_value_t*)s));
-                }
-                return;
-            }
-            if (vi.isBox) {
-                bp = builder.CreatePointerCast(builder.CreateLoad(bp), jl_ppvalue_llvmt);
-            }
-            builder.CreateStore(rval, bp, vi.isVolatile);
-            if (vi.isBox) {
-                // bp is a jl_box_t*
-                emit_write_barrier(ctx, bp, rval);
-            }
-        }
-        else {
-            // SSA variable w/o gcroot, just track the value info
-            if (store_unboxed_p(vi.value.typ) && rval_info.ispointer) { // emit a copy of boxed isbits values. TODO: elid this copy if unnecessary
-                rval_info = mark_julia_type(
-                        emit_unbox(julia_type_to_llvm(vi.value.typ), rval_info, vi.value.typ),
-                        vi.value.typ);
-            }
-            vi.value = rval_info;
-        }
-        // add info to arravar list
-        if (rval && !isa<UndefValue>(rval) && rval_info.isboxed) {
-            // check isboxed in case rval isn't the right type (for example, on a dead branch),
-            // so we don't try to assign it to the arrayvar info
-            jl_arrayvar_t *av = arrayvar_for(l, ctx);
-            if (av != NULL) {
-                assign_arrayvar(*av, rval_info);
+        if ((jl_is_symbol(r) || jl_is_symbolnode(r)) && (!rval_info.typ || rval_info.typ == jl_bottom_type)) {
+            if (vi.usedUndef) {
+                // sometimes x = y::Union{} occurs
+                jl_sym_t *s;
+                if (jl_is_symbolnode(r))
+                    s = jl_symbolnode_sym(r);
+                else
+                    s = (jl_sym_t*)r;
+                builder.CreateCall(prepare_call(jlundefvarerror_func), literal_pointer_val((jl_value_t*)s));
             }
+            return;
         }
+        Value *rval = boxed(rval_info, ctx, false); // no root needed on the temporary since it is about to be assigned to variable slot
+        builder.CreateStore(rval, vi.memloc, vi.isVolatile);
     }
-    else if (vi.value.isghost) {
+    else if (vi.value.isghost || vi.value.constant) {
         // virtual store
-        (void)emit_expr(r, ctx);
+    }
+    else if (!vi.hasGCRoot) {
+        // SSA variable w/o gcroot, just track the value info directly
+        assert(vi.isSA);
+        if (!rval_info.isimmutable && !rval_info.isboxed) { // emit a copy of values stored in mutable slots
+            rval_info = mark_julia_type(
+                    emit_unbox(julia_type_to_llvm(rval_info.typ), rval_info, rval_info.typ),
+                    false, rval_info.typ, ctx);
+        }
+        vi.value = rval_info;
     }
     else {
         // store unboxed
         assert(vi.value.ispointer);
-        builder.CreateStore(emit_unbox(
-                    julia_type_to_llvm(vi.value.typ),
-                    emit_unboxed(r, ctx),
-                    vi.value.typ),
+        builder.CreateStore(
+                emit_unbox(julia_type_to_llvm(vi.value.typ), rval_info, vi.value.typ),
                 vi.value.V, vi.isVolatile);
     }
 }
@@ -3217,7 +3245,7 @@ static void emit_assignment(jl_value_t *l, jl_value_t *r, jl_codectx_t *ctx)
 
 static Value *emit_condition(jl_value_t *cond, const std::string &msg, jl_codectx_t *ctx)
 {
-    jl_cgval_t condV = emit_unboxed(cond, ctx);
+    jl_cgval_t condV = emit_expr(cond, ctx);
     if (condV.typ == (jl_value_t*)jl_bool_type) {
         Value *cond = emit_unbox(T_int1, condV, (jl_value_t*)jl_bool_type);
         assert(cond->getType() == T_int1);
@@ -3225,33 +3253,72 @@ static Value *emit_condition(jl_value_t *cond, const std::string &msg, jl_codect
     }
     emit_typecheck(condV, (jl_value_t*)jl_bool_type, msg, ctx);
     if (condV.isboxed) {
-        return builder.CreateICmpEQ(condV.V, tbaa_decorate(tbaa_const, builder.CreateLoad(prepare_global(jlfalse_var))));
+        return builder.CreateICmpEQ(boxed(condV, ctx), tbaa_decorate(tbaa_const, builder.CreateLoad(prepare_global(jlfalse_var))));
     }
     // not a boolean
     return ConstantInt::get(T_int1,0); // TODO: replace with Undef
 }
 
-static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, bool valuepos)
+static void emit_stmtpos(jl_value_t *expr, jl_codectx_t *ctx)
+{
+    if (jl_is_symbol(expr))
+        return; // value not used, no point in attempting codegen for it
+    if (jl_is_symbolnode(expr))
+        return; // value not used, no point in attempting codegen for it
+    if (jl_is_gensym(expr))
+        return; // value not used, no point in attempting codegen for it
+    if (jl_is_linenode(expr))
+        return;
+    if (jl_is_newvarnode(expr)) {
+        jl_sym_t *var = (jl_sym_t*)jl_fieldref(expr, 0);
+        assert(jl_is_symbol(var));
+        jl_varinfo_t &vi = ctx->vars[var];
+        Value *lv = vi.memloc;
+        if (lv != NULL) {
+            // create a new uninitialized variable
+            if (vi.usedUndef) {
+                builder.CreateStore(V_null, lv);
+            }
+        }
+        return;
+    }
+    if (jl_is_expr(expr)) {
+        jl_sym_t *head = ((jl_expr_t*)expr)->head;
+        // some expression types are metadata and can be ignored in statement position
+        if (head == line_sym || head == type_goto_sym || head == meta_sym) {
+            return;
+        }
+        // fall-through
+    }
+    (void)emit_expr(expr, ctx);
+}
+
+static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx)
 {
     if (jl_is_symbol(expr)) {
-        if (!valuepos) return jl_cgval_t(); // value not used, no point in doing codegen for it
         jl_sym_t *sym = (jl_sym_t*)expr;
-        return emit_var(sym, (jl_value_t*)jl_any_type, ctx, isboxed);
+        return emit_var(sym, ctx);
     }
     if (jl_is_symbolnode(expr)) {
-        if (!valuepos) return jl_cgval_t(); // value not used, no point in doing codegen for it
         jl_sym_t *sym = jl_symbolnode_sym(expr);
-        return remark_julia_type(
-                emit_var(sym, jl_symbolnode_type(expr), ctx, isboxed),
-                jl_symbolnode_type(expr)); // patch up typ to match SymbolNode.type
+        jl_value_t *typ = jl_symbolnode_type(expr);
+        if (jl_is_typevar(typ))
+            typ = ((jl_tvar_t*)typ)->ub;
+        jl_cgval_t val = emit_var(sym, ctx);
+        if (val.isboxed)
+            val = remark_julia_type(val, typ); // patch up typ to match SymbolNode.type
+        return val; // patch up typ to match SymbolNode.type
     }
     if (jl_is_gensym(expr)) {
-        if (!valuepos) return jl_cgval_t(); // value not used, no point in doing codegen for it
         ssize_t idx = ((jl_gensym_t*)expr)->id;
         assert(idx >= 0);
-        //assert(ctx->gensym_assigned.at(idx));
-        jl_cgval_t val = ctx->gensym_SAvalues.at(idx); // at this point, gensym_SAvalues[idx] actually contains the SAvalue
-        return val;
+        if (!ctx->gensym_assigned.at(idx)) {
+            ctx->gensym_assigned.at(idx) = true; // (assignment, not comparison test)
+            return jl_cgval_t(); // dead code branch
+        }
+        else {
+            return ctx->gensym_SAvalues.at(idx); // at this point, gensym_SAvalues[idx] actually contains the SAvalue
+        }
     }
     if (jl_is_labelnode(expr)) {
         int labelname = jl_labelnode_label(expr);
@@ -3260,14 +3327,11 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
         if (builder.GetInsertBlock()->getTerminator() == NULL) {
             builder.CreateBr(bb); // all BasicBlocks must exit explicitly
         }
-        ctx->f->getBasicBlockList().push_back(bb);
         builder.SetInsertPoint(bb);
         return jl_cgval_t();
     }
     if (jl_is_linenode(expr)) {
-        if (valuepos)
-            jl_error("Linenode in value position");
-        return jl_cgval_t();
+        jl_error("Linenode in value position");
     }
     if (jl_is_gotonode(expr)) {
         if (builder.GetInsertBlock()->getTerminator() == NULL) {
@@ -3290,32 +3354,10 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
         jl_binding_t *b = jl_get_binding(mod, var);
         if (b == NULL)
             b = jl_get_binding_wr(mod, var);
-        Value *bp = julia_binding_gv(b);
-        if (b->constp && b->value!=NULL) {
-            return mark_julia_type(builder.CreateLoad(bp), jl_typeof(b->value));
+        if (b->constp && b->value != NULL) {
+            return mark_julia_const(b->value);
         }
-        return emit_checked_var(bp, var, ctx);
-    }
-    if (jl_is_newvarnode(expr)) {
-        assert(!valuepos);
-        jl_sym_t *var = (jl_sym_t*)jl_fieldref(expr,0);
-        assert(!jl_is_gensym(var));
-        assert(jl_is_symbol(var));
-        jl_varinfo_t &vi = ctx->vars[var];
-        Value *lv = vi.memloc;
-        if (lv != NULL) {
-            // create a new uninitialized variable
-            if (vi.isBox) {
-                builder.CreateStore(builder.CreateCall(prepare_call(jlbox_func), V_null), lv);
-            }
-            else if (lv->getType() == jl_ppvalue_llvmt && vi.usedUndef) {
-                builder.CreateStore(V_null, lv);
-            }
-        }
-        return jl_cgval_t();
-    }
-    if (jl_is_lambda_info(expr)) {
-        return mark_julia_type(emit_lambda_closure(expr, ctx), jl_function_type);
+        return emit_checked_var(julia_binding_gv(b), var, ctx);
     }
     if (!jl_is_expr(expr)) {
         int needroot = true;
@@ -3378,76 +3420,50 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
         builder.SetInsertPoint(ifso);
     }
     else if (head == call_sym) {
+        jl_value_t *c = static_eval(expr, ctx, true, true);
+        if (c) {
+            jl_add_linfo_root(ctx->linfo, c);
+            return mark_julia_const(c);
+        }
         return emit_call(args, jl_array_dim0(ex->args), ctx, (jl_value_t*)ex);
     }
     else if (head == assign_sym) {
         emit_assignment(args[0], args[1], ctx);
-        if (valuepos) {
-            return ghostValue(jl_void_type);
-        }
+        return ghostValue(jl_void_type);
     }
     else if (head == method_sym) {
         jl_value_t *mn = args[0];
-        bool iskw = false;
-        Value *theF = NULL;
-        if (jl_is_expr(mn) || jl_is_globalref(mn)) {
-            if (jl_is_expr(mn) && ((jl_expr_t*)mn)->head == kw_sym) {
-                iskw = true;
-                mn = jl_exprarg(mn,0);
-            }
-            theF = boxed(emit_expr(mn, ctx), ctx);
-            if (!iskw) {
-                mn = jl_fieldref(jl_exprarg(mn, 2), 0);
-            }
-        }
-        if (jl_is_symbolnode(mn)) {
+        if (jl_is_symbolnode(mn))
             mn = (jl_value_t*)jl_symbolnode_sym(mn);
-        }
-        assert(jl_is_symbol(mn));
-        int last_depth = ctx->gc.argDepth;
-        Value *name = literal_pointer_val(mn);
-        jl_binding_t *bnd = NULL;
-        Value *bp, *bp_owner = V_null;
-        if (theF != NULL) {
-            bp = make_gcroot(theF, ctx);
-        }
-        else {
+        assert(jl_expr_nargs(ex) != 1 || jl_is_symbol(mn));
+
+        if (jl_is_symbol(mn)) {
+            if (jl_symbol_name((jl_sym_t*)mn)[0] == '@')
+                jl_errorf("macro definition not allowed inside a local scope");
+            Value *name = literal_pointer_val(mn);
+            jl_binding_t *bnd = NULL;
+            Value *bp, *bp_owner = V_null;
             if (is_global((jl_sym_t*)mn, ctx)) {
                 bnd = jl_get_binding_for_method_def(ctx->module, (jl_sym_t*)mn);
                 bp = julia_binding_gv(bnd);
                 bp_owner = literal_pointer_val((jl_value_t*)ctx->module);
             }
             else {
-                jl_sym_t *s = (jl_sym_t*)mn;
-                jl_varinfo_t &vi = ctx->vars[s];
+                jl_varinfo_t &vi = ctx->vars[(jl_sym_t*)mn];
                 bp = vi.memloc;
-                if (vi.isBox) {
-                    // bp is a jl_box_t*
-                    bp = builder.CreatePointerCast(builder.CreateLoad(bp), jl_ppvalue_llvmt);
-                    bp_owner = builder.CreateBitCast(bp, jl_pvalue_llvmt);
-                }
             }
-        }
-        if (jl_expr_nargs(ex) == 1) {
             Value *mdargs[4] = { name, bp, bp_owner, literal_pointer_val(bnd) };
-            return mark_julia_type(
+            jl_cgval_t gf = mark_julia_type(
                     builder.CreateCall(prepare_call(jlgenericfunction_func), ArrayRef<Value*>(&mdargs[0], 4)),
-                    jl_function_type);
-        }
-        else {
-            Value *a1 = boxed(emit_expr(args[1], ctx),ctx);
-            make_gcroot(a1, ctx);
-            Value *a2 = boxed(emit_expr(args[2], ctx),ctx);
-            make_gcroot(a2, ctx);
-            Value *mdargs[9] =
-                { name, bp, bp_owner, literal_pointer_val(bnd), a1, a2, literal_pointer_val(args[3]),
-                  literal_pointer_val((jl_value_t*)jl_module_call_func(ctx->module)),
-                  ConstantInt::get(T_int32, (int)iskw) };
-            ctx->gc.argDepth = last_depth;
-            return mark_julia_type(
-                    builder.CreateCall(prepare_call(jlmethod_func), ArrayRef<Value*>(&mdargs[0], 9)),
-                    jl_function_type);
-        }
+                    true, jl_function_type, ctx);
+            if (jl_expr_nargs(ex) == 1)
+                return gf;
+        }
+        Value *a1 = boxed(emit_expr(args[1], ctx), ctx);
+        Value *a2 = boxed(emit_expr(args[2], ctx), ctx);
+        Value *mdargs[3] = { a1, a2, literal_pointer_val(args[3]) };
+        builder.CreateCall(prepare_call(jlmethod_func), ArrayRef<Value*>(&mdargs[0], 3));
+        return ghostValue(jl_void_type);
     }
     else if (head == const_sym) {
         jl_sym_t *sym = (jl_sym_t*)args[0];
@@ -3476,20 +3492,23 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
             jl_add_linfo_root(ctx->linfo, extype);
         return mark_julia_const(extype);
     }
-    else if (head == new_sym) {
+    else if (head == new_sym || head == stknew_sym) {
         jl_value_t *ty = expr_type(args[0], ctx);
         size_t nargs = jl_array_len(ex->args);
         if (jl_is_type_type(ty) &&
             jl_is_datatype(jl_tparam0(ty)) &&
             jl_is_leaf_type(jl_tparam0(ty))) {
-            return emit_new_struct(jl_tparam0(ty),nargs,args,ctx);
+            assert(nargs <= jl_datatype_nfields(jl_tparam0(ty))+1);
+            return emit_new_struct(jl_tparam0(ty),nargs,args,ctx, head == stknew_sym);
         }
         Value *typ = boxed(emit_expr(args[0], ctx), ctx);
         Value *val = emit_jlcall(jlnew_func, typ, &args[1], nargs-1, ctx);
-        return mark_julia_type(val, ty);
+        return mark_julia_type(val, true, ty, ctx);
     }
     else if (head == exc_sym) { // *jl_exception_in_transit
-        return mark_julia_type(builder.CreateLoad(prepare_global(jlexc_var), /*isvolatile*/true), jl_any_type);
+        return mark_julia_type(builder.CreateLoad(emit_exc_in_transit(ctx),
+                                                  /*isvolatile*/true),
+                               true, jl_any_type, ctx);
     }
     else if (head == leave_sym) {
         assert(jl_is_long(args[0]));
@@ -3525,7 +3544,7 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
         builder.SetInsertPoint(cond_resetstkoflw_blk);
         builder.CreateCondBr(builder.CreateICmpEQ(
                     literal_pointer_val(jl_stackovf_exception),
-                    builder.CreateLoad(prepare_global(jlexc_var), true)),
+                    builder.CreateLoad(emit_exc_in_transit(ctx), true)),
                 resetstkoflw_blk, handlr);
         builder.SetInsertPoint(resetstkoflw_blk);
         builder.CreateCall(prepare_call(resetstkoflw_func)
@@ -3539,9 +3558,31 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
 #endif
         builder.SetInsertPoint(tryblk);
     }
+    else if (head == inbounds_sym) {
+        // manipulate inbounds stack
+        // note that when entering an inbounds context, we must also update
+        // the boundsCheck context to be false
+        if (jl_array_len(ex->args) > 0) {
+            jl_value_t *arg = args[0];
+            if (arg == jl_true) {
+                ctx->inbounds.push_back(true);
+                ctx->boundsCheck.push_back(false);
+            }
+            else if (arg == jl_false) {
+                ctx->inbounds.push_back(false);
+                ctx->boundsCheck.push_back(false);
+            }
+            else {
+                if (!ctx->inbounds.empty())
+                    ctx->inbounds.pop_back();
+                if (!ctx->boundsCheck.empty())
+                    ctx->boundsCheck.pop_back();
+            }
+        }
+        return ghostValue(jl_void_type);
+    }
     else if (head == boundscheck_sym) {
-        if (jl_array_len(ex->args) > 0 &&
-            jl_options.check_bounds == JL_OPTIONS_CHECK_BOUNDS_DEFAULT) {
+        if (jl_array_len(ex->args) > 0) {
             jl_value_t *arg = args[0];
             if (arg == jl_true) {
                 ctx->boundsCheck.push_back(true);
@@ -3567,21 +3608,19 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
             }
         }
         jl_cgval_t ast = emit_expr(arg, ctx);
-        return mark_julia_type(builder.CreateCall(prepare_call(jlcopyast_func), boxed(ast, ctx)), ast.typ);
+        return mark_julia_type(builder.CreateCall(prepare_call(jlcopyast_func), boxed(ast, ctx)), true, ast.typ, ctx);
     }
     else if (head == simdloop_sym) {
         if (!llvm::annotateSimdLoop(builder.GetInsertBlock()))
             jl_printf(JL_STDERR, "WARNING: could not attach metadata for @simd loop.\n");
         return jl_cgval_t();
     }
-    else if (head == meta_sym) {
-        return ghostValue(jl_void_type);  // will change as new metadata gets added
-    }
     else {
-        if (!strcmp(head->name, "$"))
+        if (!strcmp(jl_symbol_name(head), "$"))
             jl_error("syntax: prefix \"$\" in non-quoted expression");
         if (jl_is_toplevel_only_expr(expr) &&
-            ctx->linfo->name == anonymous_sym && ctx->vars.empty() &&
+            ctx->linfo->name == anonymous_sym &&
+            (ctx->vars.empty() || ((jl_expr_t*)expr)->head == thunk_sym) &&
             ctx->linfo->module == jl_current_module) {
             // call interpreter to run a toplevel expr from inside a
             // compiled toplevel thunk.
@@ -3589,19 +3628,14 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
             jl_add_linfo_root(ctx->linfo, expr);
             return ghostValue(jl_void_type);
         }
-        // some expression types are metadata and can be ignored
-        if (valuepos || !(head == line_sym || head == type_goto_sym)) {
-            if (head == abstracttype_sym || head == compositetype_sym ||
-                head == bitstype_sym) {
-                jl_errorf("type definition not allowed inside a local scope");
-            }
-            else if (head == macro_sym) {
-                jl_errorf("macro definition not allowed inside a local scope");
-            }
-            else {
-                jl_errorf("unsupported or misplaced expression \"%s\" in function %s",
-                          head->name, ctx->linfo->name->name);
-            }
+        if (head == abstracttype_sym || head == compositetype_sym ||
+            head == bitstype_sym) {
+            jl_errorf("type definition not allowed inside a local scope");
+        }
+        else {
+            jl_errorf("unsupported or misplaced expression \"%s\" in function %s",
+                      jl_symbol_name(head),
+                      jl_symbol_name(ctx->linfo->name));
         }
     }
     return jl_cgval_t();
@@ -3609,120 +3643,109 @@ static jl_cgval_t emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed, b
 
 // --- generate function bodies ---
 
-extern "C" jl_svec_t *jl_svec_tvars_to_symbols(jl_svec_t *t);
-
 // gc frame emission
-static void allocate_gc_frame(size_t n_roots, BasicBlock *b0, jl_codectx_t *ctx)
+static void allocate_gc_frame(BasicBlock *b0, jl_codectx_t *ctx)
 {
-    // allocate a placeholder gc frame
-    jl_gcinfo_t *gc = &ctx->gc;
-    gc->argSpaceSize = n_roots;
-    gc->argDepth = 0;
-    gc->maxDepth = 0;
-
-    gc->gcframe = builder.CreateAlloca(jl_pvalue_llvmt, ConstantInt::get(T_int32, 0));
-#ifdef JL_DEBUG_BUILD
-    gc->gcframe->setName("gcrootframe");
-#endif
-    gc->first_gcframe_inst = BasicBlock::iterator(gc->gcframe);
-    gc->argSlot = builder.CreateConstGEP1_32(gc->gcframe, 2);
-#ifdef JL_DEBUG_BUILD
-    gc->argSlot->setName("locals");
-#endif
-    gc->tempSlot = (GetElementPtrInst*)builder.CreateConstGEP1_32(gc->gcframe, 2);
-#ifdef JL_DEBUG_BUILD
-    gc->tempSlot->setName("temproots");
-#endif
-    gc->last_gcframe_inst = BasicBlock::iterator((Instruction*)gc->tempSlot);
+    // allocate a placeholder gc instruction
+    ctx->ptlsStates = builder.CreateCall(prepare_call(jltls_states_func));
 }
 
-static void clear_gc_frame(jl_gcinfo_t *gc)
+void jl_codegen_finalize_temp_arg(CallInst *ptlsStates, Type *T_pjlvalue);
+static void finalize_gc_frame(Function *F)
 {
-    // replace instruction uses with Undef first to avoid LLVM assertion failures
-    BasicBlock::iterator bbi = gc->first_gcframe_inst;
-    while (1) {
-        Instruction &iii = *bbi;
-        Type *ty = iii.getType();
-        if (ty != T_void)
-            iii.replaceAllUsesWith(UndefValue::get(ty));
-        if (bbi == gc->last_gcframe_inst) break;
-        bbi++;
-    }
-    // Remove GC frame creation
-    // (instructions from gc->gcframe to gc->last_gcframe_inst)
-    BasicBlock::InstListType &il = gc->gcframe->getParent()->getInstList();
-    il.erase(gc->first_gcframe_inst, gc->last_gcframe_inst);
-    // erase() erases up *to* the end point; erase last inst too
-    il.erase(gc->last_gcframe_inst);
-}
+    Module *M = F->getParent();
+    M->getOrInsertFunction(gcroot_func->getName(), gcroot_func->getFunctionType());
+    M->getOrInsertFunction(gckill_func->getName(), gckill_func->getFunctionType());
+    M->getOrInsertFunction(gcstore_func->getName(), gcstore_func->getFunctionType());
+    M->getOrInsertFunction(jlcall_frame_func->getName(), jlcall_frame_func->getFunctionType());
+    Function *jl_get_ptls_states = M->getFunction("jl_get_ptls_states");
+
+    CallInst *ptlsStates = NULL;
+    for (BasicBlock::iterator i = F->getEntryBlock().begin(), e = F->getEntryBlock().end(); i != e; ++i) {
+        if (CallInst *callInst = dyn_cast<CallInst>(&*i)) {
+            if (callInst->getCalledFunction() == jl_get_ptls_states) {
+                ptlsStates = callInst;
+                break;
+            }
+        }
+    }
+    if (!ptlsStates)
+        return;
 
-static void
-emit_gcpops(jl_codectx_t *ctx)
-{
-    Function *F = ctx->f;
-    for(Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
-        if (isa<ReturnInst>(I->getTerminator())) {
-            builder.SetInsertPoint(I->getTerminator()); // set insert *before* Ret
-            Instruction *gcpop =
-                (Instruction*)builder.CreateConstGEP1_32(ctx->gc.gcframe, 1);
-            builder.CreateStore(builder.CreatePointerCast(builder.CreateLoad(gcpop),
-                                                      jl_ppvalue_llvmt),
-                                prepare_global(jlpgcstack_var));
+    jl_codegen_finalize_temp_arg(ptlsStates, T_pjlvalue);
+
+#ifdef JULIA_ENABLE_THREADING
+    if (imaging_mode) {
+        Value *getter;
+        if (GlobalVariable *GV = M->getGlobalVariable(jltls_states_func_ptr->getName(), true /* AllowLocal */)) {
+            getter = tbaa_decorate(tbaa_const, new LoadInst(GV, "", ptlsStates));
         }
+        else {
+            // If the global variable doesn't exist, we are coping code out of
+            // the shadow_module to run, in which case, we just use the
+            // function directly.
+            getter = ConstantExpr::getIntToPtr(
+                ConstantInt::get(T_size, (intptr_t)jl_get_ptls_states_getter()),
+                jltls_states_func->getFunctionType()->getPointerTo());
+        }
+        ptlsStates->setCalledFunction(getter);
     }
+    ptlsStates->setAttributes(jltls_states_func->getAttributes());
+#else
+    Module *destModule = F->getParent();
+    GlobalVariable *GV = destModule->getGlobalVariable(jltls_states_var->getName());
+    if (GV == NULL) {
+        GV = new GlobalVariable(*destModule,
+            jltls_states_var->getType()->getElementType(),
+            jltls_states_var->isConstant(),
+            GlobalVariable::ExternalLinkage,
+            NULL,
+            jltls_states_var->getName());
+        GV->copyAttributesFrom(jltls_states_var);
+    }
+    ptlsStates->replaceAllUsesWith(GV);
+    ptlsStates->eraseFromParent();
+#endif
 }
 
-static void finalize_gc_frame(jl_codectx_t *ctx)
+static void finalize_gc_frame(Module *m)
 {
-    jl_gcinfo_t *gc = &ctx->gc;
-    if (gc->argSpaceSize + gc->maxDepth == 0) {
-        // 0 roots; remove gc frame entirely
-        clear_gc_frame(gc);
-        return;
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+    for (auto &F : m->functions()) {
+        if (F.isDeclaration())
+            continue;
+        finalize_gc_frame(&F);
     }
-    BasicBlock::iterator bbi(gc->gcframe);
-    AllocaInst *newgcframe = gc->gcframe;
-    builder.SetInsertPoint(++gc->last_gcframe_inst); // set insert *before* point, e.g. after the gcframe
-    // Allocate the real GC frame
-    // n_frames++;
-    newgcframe->setOperand(0, ConstantInt::get(T_int32, 2 + gc->argSpaceSize + gc->maxDepth)); // fix up the size of the gc frame
-    gc->tempSlot->setOperand(1, ConstantInt::get(T_int32, 2 + gc->argSpaceSize)); // fix up the offset to the temp slot space
-    builder.CreateStore(ConstantInt::get(T_size, (gc->argSpaceSize + gc->maxDepth) << 1),
-                        builder.CreateBitCast(builder.CreateConstGEP1_32(newgcframe, 0), T_psize));
-    builder.CreateStore(builder.CreateLoad(prepare_global(jlpgcstack_var)),
-                        builder.CreatePointerCast(builder.CreateConstGEP1_32(newgcframe, 1), PointerType::get(jl_ppvalue_llvmt,0)));
-    builder.CreateStore(newgcframe, prepare_global(jlpgcstack_var));
-    // Initialize the slots for temporary variables to NULL
-    for (int i = 0; i < gc->argSpaceSize; i++) {
-        Value *argTempi = emit_local_slot(i, ctx);
-        builder.CreateStore(V_null, argTempi);
-    }
-    for (int i = 0; i < gc->maxDepth; i++) {
-        Value *argTempi = emit_temp_slot(i, ctx);
-        builder.CreateStore(V_null, argTempi);
-    }
-    emit_gcpops(ctx);
+#ifndef JULIA_ENABLE_THREADING
+    m->getFunction("jl_get_ptls_states")->eraseFromParent();
+#endif
+    m->getFunction("julia.gc_root_decl")->eraseFromParent();
+    m->getFunction("julia.gc_root_kill")->eraseFromParent();
+    m->getFunction("julia.gc_store")->eraseFromParent();
+    m->getFunction("julia.jlcall_frame_decl")->eraseFromParent();
+#endif
 }
 
-static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_tupletype_t *argt, int64_t isref)
+// here argt does not include the leading function type argument
+static Function *gen_cfun_wrapper(jl_lambda_info_t *lam, jl_function_t *ff, jl_value_t *jlrettype, jl_tupletype_t *argt, int64_t isref)
 {
-    jl_lambda_info_t *lam = ff->linfo;
-    cFunctionList_t *list = (cFunctionList_t*)lam->cFunctionList;
+    cFunctionList_t *list = (cFunctionList_t*)lam->functionObjects.cFunctionList;
     if (list != NULL) {
         size_t i;
         for (i = 0; i < list->len; i++) {
-            if (list->data[i].isref == isref) {
-                return list->data[i].f;
+            if (list->data()[i].isref == isref) {
+                return list->data()[i].f;
             }
         }
     }
     // Generate a c-callable wrapper
-    Type *crt = ((isref&1) ? jl_pvalue_llvmt : julia_struct_to_llvm(jlrettype));
+    bool toboxed;
+    Type *crt = ((isref & 1) ? T_pjlvalue : julia_struct_to_llvm(jlrettype, &toboxed));
     if (crt == NULL)
         jl_error("cfunction: return type doesn't correspond to a C type");
     size_t i;
     size_t nargs = jl_nparams(argt);
-    for(i=0; i < nargs; i++) {
+    for(i=1; i < nargs+1; i++) {
         jl_value_t *tti = jl_nth_slot_type(lam->specTypes,i);
         if (tti == (jl_value_t*)jl_pointer_type) {
             jl_error("cfunction: argument type Ptr should have an element type, Ptr{T}");
@@ -3730,27 +3753,29 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     }
 
     std::vector<Type*> fargt(0);
+    std::vector<bool> fargt_isboxed(0);
     std::vector<Type*> fargt_sig(0);
-    Type* fargt_vasig;
+    Type *fargt_vasig;
     std::vector<bool> inRegList(0);
     std::vector<bool> byRefList(0);
     attr_type attrs;
     Type *prt = NULL;
     int sret = 0;
-    std::string err_msg = generate_func_sig(&crt, &prt, sret, fargt, fargt_sig, fargt_vasig, inRegList, byRefList, attrs,
+    std::string err_msg = generate_func_sig(&crt, &prt, sret, fargt, fargt_isboxed, fargt_sig, fargt_vasig, inRegList, byRefList, attrs,
                                             ((isref&1) ? (jl_value_t*)jl_any_type : jlrettype), argt->parameters, nargs);
     if (!err_msg.empty())
         jl_error(err_msg.c_str());
     if (fargt.size() + sret != fargt_sig.size())
         jl_error("va_arg syntax not allowed for cfunction argument list");
 
-    jl_compile(ff);
-    if (!lam->functionObject) {
-        jl_errorf("error compiling %s while creating cfunction", lam->name->name);
+    jl_compile_linfo(lam, NULL);
+    if (!lam->functionObjects.functionObject) {
+        jl_errorf("error compiling %s while creating cfunction",
+                  jl_symbol_name(lam->name));
     }
 
     std::stringstream funcName;
-    funcName << "jlcapi_" << lam->name->name << "_" << globalUnique++;
+    funcName << "jlcapi_" << jl_symbol_name(lam->name) << "_" << globalUnique++;
 
     // Backup the info for the nested compile
     JL_SIGATOMIC_BEGIN(); // no errors expected beyond this point
@@ -3760,24 +3785,16 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     nested_compile = true;
     jl_gc_inhibit_finalizers(nested_compile); // no allocations expected between the top of this function (when last scanned lam->cFunctionList) and here, which might have triggered running julia code
 
-    // Create the Function stub
-    Module *m;
-#ifdef USE_MCJIT
-    if (!imaging_mode) {
-        m = new Module(funcName.str(), jl_LLVMContext);
-        jl_setup_module(m,true);
-    }
-    else {
-        m = shadow_module;
-    }
-#else
-    m = jl_Module;
-#endif
-
     Function *cw = Function::Create(FunctionType::get(sret ? T_void : prt, fargt_sig, false),
             imaging_mode ? GlobalVariable::InternalLinkage : GlobalVariable::ExternalLinkage,
-            funcName.str(), m);
+            funcName.str(), builtins_module);
+    addComdat(cw);
     cw->setAttributes(attrs);
+#ifdef LLVM37
+    cw->addFnAttr("no-frame-pointer-elim", "true");
+#endif
+    Function *cw_proto = function_proto(cw);
+
     BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", cw);
     builder.SetInsertPoint(b0);
     DebugLoc noDbg;
@@ -3786,28 +3803,35 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     jl_codectx_t ctx;
     ctx.f = cw;
     ctx.linfo = lam;
-    allocate_gc_frame(0, b0, &ctx);
+    ctx.sret = false;
+    ctx.spvals_ptr = NULL;
+    allocate_gc_frame(b0, &ctx);
 
     // Save the Function object reference
     int len = (list ? list->len : 0) + 1;
-    cFunctionList_t *list2 = (cFunctionList_t*)realloc(list, sizeof(*list)+sizeof(list->data[0])*len);
+    cFunctionList_t *list2 = (cFunctionList_t*)realloc(list, sizeof(cFunctionList_t)+sizeof(list->data()[0])*len);
     if (!list2)
         jl_throw(jl_memory_exception);
     list2->len = len;
-    list2->data[len-1].isref = isref;
-    list2->data[len-1].f = cw;
-    lam->cFunctionList = list2;
+    list2->data()[len-1].isref = isref;
+    list2->data()[len-1].f = imaging_mode ? cw : cw_proto;
+    lam->functionObjects.cFunctionList = list2;
 
     // See whether this function is specsig or jlcall
-    bool specsig;
+    bool specsig, jlfunc_sret;
     Function *theFptr;
-    if (lam->specFunctionObject != NULL) {
-        theFptr = (Function*)lam->specFunctionObject;
+    Value *myargs;
+    if (lam->functionObjects.specFunctionObject != NULL) {
+        theFptr = (Function*)lam->functionObjects.specFunctionObject;
         specsig = true;
+        jlfunc_sret = theFptr->hasStructRetAttr();
+        myargs = NULL;
     }
     else {
-        theFptr = (Function*)lam->functionObject;
+        theFptr = (Function*)lam->functionObjects.functionObject;
         specsig = false;
+        jlfunc_sret = false;
+        myargs = builder.CreateCall(prepare_call(jlcall_frame_func), ConstantInt::get(T_int32, nargs));
     }
     assert(theFptr);
 
@@ -3817,92 +3841,140 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     Function::arg_iterator AI = cw->arg_begin();
     Value *sretPtr = NULL;
     if (sret)
-        sretPtr = AI++; //const Argument &fArg = *AI++;
+        sretPtr = &*AI++;
 
-    for (size_t i=0; i < nargs; i++) {
-        Value *val = AI++;
-        jl_value_t *jargty = jl_nth_slot_type(lam->specTypes, i);
+    Value *result;
+    size_t FParamIndex = 0;
+    if (jlfunc_sret) {
+        if (sret)
+            result = builder.CreateBitCast(sretPtr, theFptr->getFunctionType()->getParamType(0));
+        else
+            result = builder.CreateAlloca(theFptr->getFunctionType()->getParamType(0)->getContainedType(0));
+        args.push_back(result);
+        FParamIndex++;
+    }
+
+    for (size_t i = 0; i < nargs; i++) {
+        Value *val = &*AI++;
+        jl_value_t *jargty = jl_nth_slot_type(lam->specTypes, i+1);  // +1 because argt excludes function
+        bool isboxed, argboxed;
+        Type *t = julia_type_to_llvm(jargty, &isboxed);
+        (void)julia_struct_to_llvm(jargty, &argboxed);
+        jl_cgval_t inputarg;
 
         // figure out how to unpack this type
         if (isref & (2<<i)) {
             if (!jl_isbits(jargty)) {
-                val = builder.CreatePointerCast(val, jl_pvalue_llvmt);
+                inputarg = mark_julia_type(builder.CreatePointerCast(val, T_pjlvalue), true, jargty, &ctx);
             }
             else {
-                Type *t = julia_type_to_llvm(jargty);
-                val = builder.CreatePointerCast(val, t->getPointerTo());
-                val = builder.CreateAlignedLoad(val, 1); // make no alignment assumption about pointer from C
+                if (type_is_ghost(t)) {
+                    if (specsig) {
+                        continue; // ghost types are skipped by the specsig method signature
+                    }
+                    else {
+                        inputarg = ghostValue(jargty);
+                    }
+                }
+                else {
+                    val = builder.CreatePointerCast(val, t->getPointerTo());
+                    val = builder.CreateAlignedLoad(val, 1); // make no alignment assumption about pointer from C
+                    inputarg = mark_julia_type(val, false, jargty, &ctx);
+                }
             }
         }
+        else if (argboxed) {
+            inputarg = mark_julia_type(val, true, jargty, &ctx);
+        }
         else {
             // undo whatever we might have done to this poor argument
             bool issigned = jl_signed_type && jl_subtype(jargty, (jl_value_t*)jl_signed_type, 0);
             val = llvm_type_rewrite(val, val->getType(), fargt[i], true, byRefList[i], issigned, &ctx);
+            if (isboxed) {
+                Value *mem = emit_allocobj(jl_datatype_size(jargty));
+                builder.CreateStore(literal_pointer_val((jl_value_t*)jargty),
+                                    emit_typeptr_addr(mem));
+                builder.CreateAlignedStore(val,
+                        builder.CreateBitCast(mem, val->getType()->getPointerTo()),
+                        16); // julia's gc gives 16-byte aligned addresses
+                inputarg = mark_julia_type(mem, true, jargty, &ctx);
+            }
+            else {
+                inputarg = mark_julia_type(val, false, jargty, &ctx);
+            }
         }
 
         // figure out how to repack this type
-        Type *at = specsig ? theFptr->getFunctionType()->getParamType(i) : jl_pvalue_llvmt;
-        if (val->getType() != at) {
-            if (at == jl_pvalue_llvmt) {
-                assert(jl_is_leaf_type(jargty));
-                if (jl_datatype_nfields(jargty) == 0) {
-                    val = literal_pointer_val(jl_new_struct_uninit((jl_datatype_t*)jargty));
-                }
-                else if (jl_isbits(jargty)) {
-                    val = boxed(mark_julia_type(val, jargty), &ctx, jargty);
-                }
-                else {
-                    Value *mem = emit_allocobj(jl_datatype_size(jargty));
-                    builder.CreateStore(literal_pointer_val((jl_value_t*)jargty),
-                                        emit_typeptr_addr(mem));
-                    builder.CreateAlignedStore(val, builder.CreateBitCast(mem, val->getType()->getPointerTo()), 16); // julia's gc gives 16-byte aligned addresses
-                    val = mem;
-                }
-                if (specsig)
-                    make_gcroot(val, &ctx);
-            }
-            else if (val->getType()->isAggregateType()) {
-                assert(at->isPointerTy() && at->getContainedType(0) == val->getType());
-                // aggregate types are passed by pointer
-                Value *loc = emit_static_alloca(val->getType(), &ctx);
-                builder.CreateStore(val, loc);
-                val = loc;
+        if (!specsig) {
+            Value *arg = boxed(inputarg, &ctx, false); // don't want a gcroot, since it's about to be but into the jlcall frame anyways
+            Value *slot = builder.CreateGEP(myargs, ConstantInt::get(T_int32, FParamIndex++));
+            builder.CreateStore(arg, slot);
+        }
+        else {
+            Value *arg;
+            FParamIndex++;
+            if (isboxed) {
+                arg = boxed(inputarg, &ctx);
             }
             else {
-                val = emit_unbox(at, mark_julia_type(val, jargty), jargty);
-                assert(dyn_cast<UndefValue>(val) == 0);
+                arg = emit_unbox(t, inputarg, jargty);
+                assert(!isa<UndefValue>(arg));
+                if (t->isAggregateType()) {
+#ifndef NDEBUG
+                    Type *at = theFptr->getFunctionType()->getParamType(FParamIndex-1);
+#endif
+                    assert(at->isPointerTy() && at->getContainedType(0) == t);
+                    // aggregate types are passed by pointer
+                    Value *loc = emit_static_alloca(t, &ctx);
+                    builder.CreateStore(arg, loc);
+                    arg = loc;
+                }
             }
-        }
 
-        // add to argument list
-        if (specsig)
-            args.push_back(val);
-        else
-            make_gcroot(val, &ctx);
+            // add to argument list
+            args.push_back(arg);
+        }
     }
 
     // Create the call
-    Value *r;
+    jl_cgval_t retval;
     if (specsig) {
-        r = builder.CreateCall(prepare_call(theFptr), ArrayRef<Value*>(args));
+        bool retboxed;
+        CallInst *call = builder.CreateCall(prepare_call(theFptr), ArrayRef<Value*>(args));
+        call->setAttributes(theFptr->getAttributes());
+        (void)julia_type_to_llvm(jlrettype, &retboxed);
+        retval = mark_julia_type(jlfunc_sret ? (Value*)builder.CreateLoad(result) : (Value*)call, retboxed, jlrettype, &ctx);
     }
     else {
-        r = emit_jlcall(theFptr, literal_pointer_val((jl_value_t*)ff), 0, nargs, &ctx);
+        assert(nargs > 0);
+        // for jlcall, we need to pass the function object even if it is a ghost.
+        // here we reconstruct the function instance from its type (first elt of argt)
+        Value *theF = literal_pointer_val((jl_value_t*)ff);
+#ifdef LLVM37
+        Value *ret = builder.CreateCall(prepare_call(theFptr), {theF, myargs,
+                                        ConstantInt::get(T_int32, nargs)});
+#else
+        Value *ret = builder.CreateCall3(prepare_call(theFptr), theF, myargs,
+                                         ConstantInt::get(T_int32, nargs));
+#endif
+        retval = mark_julia_type(ret, true, jlrettype, &ctx);
     }
 
     // Prepare the return value
-    if (isref&1) {
+    Value *r;
+    if (isref & 1) {
         assert(!sret);
         // return a jl_value_t*
-        if (r->getType() != jl_pvalue_llvmt) {
-            r = boxed(mark_julia_type(r, jlrettype), &ctx, jlrettype);
-        }
+        r = boxed(retval, &ctx, false); // no gcroot since this is on the return path
+    }
+    else if (sret && jlfunc_sret) {
+        // nothing to do
     }
     else if (!type_is_ghost(crt)) {
         if (sret)
             prt = fargt_sig[0]->getContainedType(0); // sret is a PointerType
         bool issigned = jl_signed_type && jl_subtype(jlrettype, (jl_value_t*)jl_signed_type, 0);
-        Value *v = julia_to_native(crt, jlrettype, mark_julia_type(r, jlrettype),
+        Value *v = julia_to_native(crt, toboxed, jlrettype, retval,
                 false, false, false, false, false, 0, &ctx, NULL);
         r = llvm_type_rewrite(v, crt, prt, false, false, issigned, &ctx);
         if (sret)
@@ -3917,37 +3989,14 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
         builder.CreateRetVoid();
     else
         builder.CreateRet(r);
-    finalize_gc_frame(&ctx);
 
-#ifdef JL_DEBUG_BUILD
-#ifdef LLVM35
-    llvm::raw_fd_ostream out(1,false);
-#endif
-    if (
-#ifdef LLVM35
-        verifyFunction(*cw,&out)
-#else
-        verifyFunction(*cw,PrintMessageAction)
-#endif
-    ) {
-        cw->dump();
-        abort();
-    }
+#if !defined(USE_MCJIT) && !defined(USE_ORCJIT)
+    finalize_gc_frame(cw);
+    FPM->run(*cw);
 #endif
 
-#ifdef USE_MCJIT
-    if (imaging_mode) {
-        // Copy the function out of the shadow module
-        Module *m = new Module("julia", jl_LLVMContext);
-        jl_setup_module(m, true);
-        FunctionMover mover(m, shadow_module);
-        Function *clone = mover.CloneFunction(cw);
-        FPM->run(*clone);
-    }
-    else {
-        FPM->run(*cw);
-    }
-#endif
+    cw->removeFromParent();
+    active_module->getFunctionList().push_back(cw);
 
     // Restore the previous compile context
     if (old != NULL) {
@@ -3958,11 +4007,11 @@ static Function *gen_cfun_wrapper(jl_function_t *ff, jl_value_t *jlrettype, jl_t
     jl_gc_inhibit_finalizers(nested_compile);
     JL_SIGATOMIC_END();
 
-    return cw;
+    return cw_proto;
 }
 
 // generate a julia-callable function that calls f (AKA lam)
-static Function *gen_jlcall_wrapper(jl_lambda_info_t *lam, jl_expr_t *ast, Function *f)
+static Function *gen_jlcall_wrapper(jl_lambda_info_t *lam, jl_expr_t *ast, Function *f, bool sret)
 {
     std::stringstream funcName;
     const std::string &fname = f->getName().str();
@@ -3973,12 +4022,15 @@ static Function *gen_jlcall_wrapper(jl_lambda_info_t *lam, jl_expr_t *ast, Funct
         funcName << fname;
 
     Function *w = Function::Create(jl_func_sig, imaging_mode ? GlobalVariable::InternalLinkage : GlobalVariable::ExternalLinkage,
-                                   funcName.str(), f->getParent());
+                                   funcName.str(), builtins_module);
     addComdat(w);
+#ifdef LLVM37
+    w->addFnAttr("no-frame-pointer-elim", "true");
+#endif
     Function::arg_iterator AI = w->arg_begin();
-    AI++; //const Argument &fArg = *AI++;
-    Value *argArray = AI++;
-    //const Argument &argCount = *AI++;
+    Value *fArg = &*AI++;
+    Value *argArray = &*AI++;
+    /* const Argument &argCount = *AI++; */
     BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", w);
 
     builder.SetInsertPoint(b0);
@@ -3986,22 +4038,37 @@ static Function *gen_jlcall_wrapper(jl_lambda_info_t *lam, jl_expr_t *ast, Funct
     builder.SetCurrentDebugLocation(noDbg);
 
     jl_codectx_t ctx;
+    ctx.f = w;
     ctx.linfo = lam;
-    allocate_gc_frame(0, b0, &ctx);
+    ctx.sret = false;
+    ctx.spvals_ptr = NULL;
+    allocate_gc_frame(b0, &ctx);
 
     size_t nargs = jl_array_dim0(jl_lam_args(ast));
     size_t nfargs = f->getFunctionType()->getNumParams();
     Value **args = (Value**) alloca(nfargs*sizeof(Value*));
     unsigned idx = 0;
+    Value *result;
+    if (sret) {
+        result = builder.CreateAlloca(f->getFunctionType()->getParamType(0)->getContainedType(0));
+        args[idx] = result;
+        idx++;
+    }
     for(size_t i=0; i < nargs; i++) {
         jl_value_t *ty = jl_nth_slot_type(lam->specTypes, i);
-        Type *lty = julia_type_to_llvm(ty);
+        bool isboxed;
+        Type *lty = julia_type_to_llvm(ty, &isboxed);
         if (lty != NULL && type_is_ghost(lty))
             continue;
-        Value *argPtr = builder.CreateGEP(argArray,
-                                          ConstantInt::get(T_size, i));
-        Value *theArg = builder.CreateLoad(argPtr);
-        if (lty != NULL && lty != jl_pvalue_llvmt) {
+        Value *theArg;
+        if (i == 0) {
+            theArg = fArg;
+        }
+        else {
+            Value *argPtr = builder.CreateGEP(argArray, ConstantInt::get(T_size, i-1));
+            theArg = builder.CreateLoad(argPtr);
+        }
+        if (lty != NULL && !isboxed) {
             theArg = builder.CreatePointerCast(theArg, PointerType::get(lty,0));
             if (!lty->isAggregateType()) // keep "aggregate" type values in place as pointers
                 theArg = builder.CreateLoad(theArg);
@@ -4010,34 +4077,33 @@ static Function *gen_jlcall_wrapper(jl_lambda_info_t *lam, jl_expr_t *ast, Funct
         args[idx] = theArg;
         idx++;
     }
-    // TODO: consider pulling the function pointer out of fArg so these
-    // wrappers can be reused for different functions of the same type.
-    Value *r = builder.CreateCall(prepare_call(f), ArrayRef<Value*>(&args[0], nfargs));
-    if (r->getType() != jl_pvalue_llvmt) {
-        r = boxed(mark_julia_type(r, jl_ast_rettype(lam, (jl_value_t*)ast)), &ctx);
-    }
-
-    builder.CreateRet(r);
-    finalize_gc_frame(&ctx);
+    CallInst *call = builder.CreateCall(prepare_call(f), ArrayRef<Value*>(&args[0], nfargs));
+    call->setAttributes(f->getAttributes());
 
-    FPM->run(*w);
+    jl_value_t *jlretty = lam->rettype;
+    bool retboxed;
+    (void)julia_type_to_llvm(jlretty, &retboxed);
+    if (sret) { assert(!retboxed); }
+    jl_cgval_t retval = sret ? mark_julia_slot(result, jlretty) : mark_julia_type(call, retboxed, jlretty, &ctx);
+    builder.CreateRet(boxed(retval, &ctx, false)); // no gcroot needed since this on the return path
 
     return w;
 }
 
 // Compile to LLVM IR, using a specialized signature if applicable.
-static Function *emit_function(jl_lambda_info_t *lam)
+static void emit_function(jl_lambda_info_t *lam, jl_llvm_functions_t *declarations,
+    jl_llvm_functions_t *definitions, jl_cyclectx_t *cyclectx)
 {
+    assert(definitions && "Capturing definitions is always required");
+
     // step 1. unpack AST and allocate codegen context for this function
     jl_expr_t *ast = (jl_expr_t*)lam->ast;
-    jl_svec_t *sparams = NULL;
-    JL_GC_PUSH2(&ast, &sparams);
+    JL_GC_PUSH1(&ast);
     if (!jl_is_expr(ast)) {
         ast = (jl_expr_t*)jl_uncompress_ast(lam, (jl_value_t*)ast);
     }
     assert(jl_is_expr(ast));
-    sparams = jl_svec_tvars_to_symbols(lam->sparams);
-    //jl_printf((jl_value_t*)ast);
+    //jl_static_show(JL_STDOUT, (jl_value_t*)ast);
     //jl_printf(JL_STDOUT, "\n");
     std::map<jl_sym_t*, jl_arrayvar_t> arrayvars;
     std::map<int, BasicBlock*> labels;
@@ -4048,30 +4114,36 @@ static Function *emit_function(jl_lambda_info_t *lam)
     ctx.handlers = &handlers;
     ctx.module = lam->module;
     ctx.ast = ast;
-    ctx.sp = sparams;
     ctx.linfo = lam;
-    ctx.funcName = lam->name->name;
+    ctx.funcName = jl_symbol_name(lam->name);
     ctx.vaName = NULL;
     ctx.vaStack = false;
-    ctx.boundsCheck.push_back(true);
+    ctx.inbounds.push_back(false);
+    ctx.boundsCheck.push_back(false);
+    ctx.cyclectx = cyclectx;
+    ctx.spvals_ptr = NULL;
 
-    // step 2. process var-info lists to see what vars are captured, need boxing
+    // step 2. process var-info lists to see what vars need boxing
     jl_value_t *gensym_types = jl_lam_gensyms(ast);
     int n_gensyms = (jl_is_array(gensym_types) ? jl_array_len(gensym_types) : jl_unbox_gensym(gensym_types));
     jl_array_t *largs = jl_lam_args(ast);
     size_t largslen = jl_array_dim0(largs);
     jl_array_t *vinfos = jl_lam_vinfo(ast);
     size_t vinfoslen = jl_array_dim0(vinfos);
-    jl_array_t *captvinfos = jl_lam_capt(ast);
-    size_t captvinfoslen = jl_array_dim0(captvinfos);
     size_t nreq = largslen;
     int va = 0;
-    if (!lam->specTypes)
-        lam->specTypes = jl_anytuple_type;
+
+    assert(lam->specTypes); // this could happen if the user tries to compile a generic-function
+                            // without specializing (or unspecializing) it first
+                            // compiling this would cause all specializations to inherit
+                            // this code and could create an broken compile / function cache
+
     if (nreq > 0 && jl_is_rest_arg(jl_cellref(largs,nreq-1))) {
         nreq--;
         va = 1;
-        ctx.vaName = jl_decl_var(jl_cellref(largs,nreq));
+        jl_sym_t *vn = jl_decl_var(jl_cellref(largs,nreq));
+        if (vn != unused_sym)
+            ctx.vaName = vn;
     }
     ctx.nReqArgs = nreq;
 
@@ -4079,15 +4151,16 @@ static Function *emit_function(jl_lambda_info_t *lam)
     for(i=0; i < nreq; i++) {
         jl_value_t *arg = jl_cellref(largs,i);
         jl_sym_t *argname = jl_decl_var(arg);
+        if (argname == unused_sym) continue;
         jl_varinfo_t &varinfo = ctx.vars[argname];
         varinfo.isArgument = true;
-        jl_value_t *ty = lam->specTypes ? jl_nth_slot_type(lam->specTypes, i) : (jl_value_t*)jl_any_type;
-        varinfo.value = mark_julia_type((Value*)NULL, ty);
+        jl_value_t *ty = jl_nth_slot_type(lam->specTypes, i);
+        varinfo.value = mark_julia_type((Value*)NULL, false, ty, &ctx);
     }
-    if (va) {
+    if (va && ctx.vaName) {
         jl_varinfo_t &varinfo = ctx.vars[ctx.vaName];
         varinfo.isArgument = true;
-        varinfo.value = mark_julia_type((Value*)NULL, jl_tuple_type);
+        varinfo.value = mark_julia_type((Value*)NULL, false, jl_tuple_type, &ctx);
     }
 
     for(i=0; i < vinfoslen; i++) {
@@ -4097,38 +4170,15 @@ static Function *emit_function(jl_lambda_info_t *lam)
         assert(jl_is_symbol(vname));
         jl_varinfo_t &varinfo = ctx.vars[vname];
         varinfo.isAssigned = (jl_vinfo_assigned(vi)!=0);
-        varinfo.isCaptured = (jl_vinfo_capt(vi)!=0);
-        if (varinfo.isCaptured && varinfo.isAssigned)
-            varinfo.isBox = true;
-        varinfo.escapes = varinfo.isCaptured;
-        if (varinfo.isCaptured)
-            varinfo.used = true;
+        varinfo.escapes = false;
         varinfo.isSA = (jl_vinfo_sa(vi)!=0);
         varinfo.usedUndef = (jl_vinfo_usedundef(vi)!=0) || (!varinfo.isArgument && !lam->inferred);
-        jl_value_t *typ = jl_cellref(vi,1);
-        if (!jl_is_type(typ))
-            typ = (jl_value_t*)jl_any_type;
-        varinfo.value = mark_julia_type((Value*)NULL, typ);
-    }
-    bool hasCapt = (captvinfoslen > 0);
-    for(i=0; i < captvinfoslen; i++) {
-        jl_array_t *vi = (jl_array_t*)jl_cellref(captvinfos, i);
-        assert(jl_is_array(vi));
-        jl_sym_t *vname = ((jl_sym_t*)jl_cellref(vi,0));
-        assert(jl_is_symbol(vname));
-        jl_varinfo_t &varinfo = ctx.vars[vname];
-        varinfo.closureidx = i;
-        varinfo.isAssigned = (jl_vinfo_assigned(vi)!=0);
-        varinfo.isCaptured = true;
-        if (varinfo.isAssigned)
-            varinfo.isBox = true;
-        varinfo.escapes = true;
-        varinfo.used = true;
-        varinfo.usedUndef = (jl_vinfo_usedundef(vi)!=0) || !lam->inferred;
-        jl_value_t *typ = jl_cellref(vi,1);
-        if (!jl_is_type(typ))
-            typ = (jl_value_t*)jl_any_type;
-        varinfo.value = mark_julia_type((Value*)NULL, typ);
+        if (!varinfo.isArgument || varinfo.isAssigned) {
+            jl_value_t *typ = jl_cellref(vi,1);
+            if (!jl_is_type(typ))
+                typ = (jl_value_t*)jl_any_type;
+            varinfo.value = mark_julia_type((Value*)NULL, false, typ, &ctx);
+        }
     }
 
     // step 3. some variable analysis
@@ -4141,13 +4191,13 @@ static Function *emit_function(jl_lambda_info_t *lam)
     mark_volatile_vars(stmts, ctx.vars);
 
     // step 4. determine function signature
-    jl_value_t *jlrettype = jl_ast_rettype(lam, (jl_value_t*)ast);
+    jl_value_t *jlrettype = lam->rettype;
     Function *f = NULL;
 
     bool specsig = false;
-    if (!va && !hasCapt && lam->specTypes != jl_anytuple_type && lam->inferred) {
-        // no captured vars and not vararg
-        // consider specialized signature
+    bool needsparams = jl_svec_len(lam->sparam_syms) != jl_svec_len(lam->sparam_vals);
+    if (!va && !needsparams && lam->specTypes != jl_anytuple_type && lam->inferred) {
+        // not vararg, consider specialized signature
         for(size_t i=0; i < jl_nparams(lam->specTypes); i++) {
             if (isbits_spec(jl_tparam(lam->specTypes, i))) { // assumes !va
                 specsig = true;
@@ -4159,27 +4209,33 @@ static Function *emit_function(jl_lambda_info_t *lam)
         if (isbits_spec(jlrettype))
             specsig = true;
     }
+    if (!specsig)
+        ctx.nReqArgs--;  // function not part of argArray in jlcall
 
     std::stringstream funcName;
     // try to avoid conflicts in the global symbol table
-    funcName << "julia_" << lam->name->name;
+    funcName << "julia_" << jl_symbol_name(lam->name);
 
-    Module *m;
-#ifdef USE_MCJIT
-    if (!imaging_mode) {
-        m = new Module(funcName.str(), jl_LLVMContext);
-        jl_setup_module(m,true);
-    }
-    else {
-        m = shadow_module;
-    }
-#else
-    m = jl_Module;
-#endif
+    Function *fwrap = NULL;
     funcName << "_" << globalUnique++;
 
-    if (specsig) { // assumes !va
+    ctx.sret = false;
+    if (specsig) { // assumes !va and !needsparams
         std::vector<Type*> fsig(0);
+        Type *rt;
+        bool retboxed;
+        if (jlrettype == (jl_value_t*)jl_void_type) {
+            rt = T_void;
+            retboxed = false;
+        }
+        else {
+            rt = julia_type_to_llvm(jlrettype, &retboxed);
+        }
+        if (!retboxed && rt != T_void && deserves_sret(jlrettype, rt)) {
+            ctx.sret = true;
+            fsig.push_back(rt->getPointerTo());
+            rt = T_void;
+        }
         for(size_t i=0; i < jl_nparams(lam->specTypes); i++) {
             Type *ty = julia_type_to_llvm(jl_tparam(lam->specTypes,i));
             if (type_is_ghost(ty))
@@ -4188,28 +4244,37 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 ty = PointerType::get(ty,0);
             fsig.push_back(ty);
         }
-        Type *rt = (jlrettype == (jl_value_t*)jl_void_type ? T_void : julia_type_to_llvm(jlrettype));
         f = Function::Create(FunctionType::get(rt, fsig, false),
                              imaging_mode ? GlobalVariable::InternalLinkage : GlobalVariable::ExternalLinkage,
-                             funcName.str(), m);
+                             funcName.str(), builtins_module);
+        if (ctx.sret)
+            f->addAttribute(1, Attribute::StructRet);
         addComdat(f);
-        if (lam->specFunctionObject == NULL) {
-            lam->specFunctionObject = (void*)f;
-            lam->specFunctionID = jl_assign_functionID(f);
-        }
-        if (lam->functionObject == NULL) {
-            Function *fwrap = gen_jlcall_wrapper(lam, ast, f);
-            lam->functionObject = (void*)fwrap;
-            lam->functionID = jl_assign_functionID(fwrap);
-        }
+#ifdef LLVM37
+        f->addFnAttr("no-frame-pointer-elim", "true");
+#endif
+        definitions->specFunctionObject = f;
+        if (declarations)
+            declarations->specFunctionObject = function_proto(f);
+        fwrap = gen_jlcall_wrapper(lam, ast,
+            (llvm::Function*)lam->functionObjects.specFunctionObject, ctx.sret);
+        definitions->functionObject = fwrap;
+        if (declarations)
+            declarations->functionObject = function_proto(fwrap);
     }
     else {
-        f = Function::Create(jl_func_sig, imaging_mode ? GlobalVariable::InternalLinkage : GlobalVariable::ExternalLinkage,
-                             funcName.str(), m);
+        f = Function::Create(needsparams ? jl_func_sig_sparams : jl_func_sig,
+                             imaging_mode ? GlobalVariable::InternalLinkage : GlobalVariable::ExternalLinkage,
+                             funcName.str(), builtins_module);
         addComdat(f);
-        if (lam->functionObject == NULL) {
-            lam->functionObject = (void*)f;
-            lam->functionID = jl_assign_functionID(f);
+#ifdef LLVM37
+        f->addFnAttr("no-frame-pointer-elim", "true");
+#endif
+        definitions->functionObject = f;
+        definitions->specFunctionObject = NULL;
+        if (declarations) {
+            declarations->functionObject = function_proto(f);
+            declarations->specFunctionObject = NULL;
         }
     }
     if (jlrettype == (jl_value_t*)jl_bottom_type)
@@ -4226,7 +4291,7 @@ static Function *emit_function(jl_lambda_info_t *lam)
             AttributeSet::FunctionIndex,*attr));
 #endif
 
-#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && LLVM35
+#if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && defined(LLVM35)
     f->setHasUWTable(); // force NeedsWinEH
 #endif
 
@@ -4241,12 +4306,12 @@ static Function *emit_function(jl_lambda_info_t *lam)
     bool do_malloc_log = jl_options.malloc_log  == JL_LOG_ALL || (jl_options.malloc_log    == JL_LOG_USER && in_user_code);
     jl_value_t *stmt = skip_meta(stmts);
     std::string filename = "no file";
-    char *dbgFuncName = lam->name->name;
+    char *dbgFuncName = jl_symbol_name(lam->name);
     int lno = -1;
     // look for initial (line num filename [funcname]) node, [funcname] for kwarg methods.
     if (jl_is_linenode(stmt)) {
         lno = jl_linenode_line(stmt);
-        filename = jl_linenode_file(stmt)->name;
+        filename = jl_symbol_name(jl_linenode_file(stmt));
     }
     else if (jl_is_expr(stmt) && ((jl_expr_t*)stmt)->head == line_sym &&
              jl_array_dim0(((jl_expr_t*)stmt)->args) > 0) {
@@ -4256,31 +4321,33 @@ static Function *emit_function(jl_lambda_info_t *lam)
         if (jl_array_dim0(((jl_expr_t*)stmt)->args) > 1) {
             a1 = jl_exprarg(stmt,1);
             if (jl_is_symbol(a1))
-                filename = ((jl_sym_t*)a1)->name;
+                filename = jl_symbol_name((jl_sym_t*)a1);
             if (jl_array_dim0(((jl_expr_t*)stmt)->args) > 2) {
                 a1 = jl_exprarg(stmt,2);
                 if (jl_is_symbol(a1))
-                    dbgFuncName = ((jl_sym_t*)a1)->name;
+                    dbgFuncName = jl_symbol_name((jl_sym_t*)a1);
             }
         }
     }
-    ctx.lineno = lno;
+    int toplineno = lno;
 
-    DIBuilder dbuilder(*m);
+    DIBuilder dbuilder(*builtins_module);
     ctx.dbuilder = &dbuilder;
 #ifdef LLVM37
     DIFile *topfile = NULL;
-    DISubprogram *SP;
+    DISubprogram *SP = NULL;
+    DICompileUnit *CU;
 #else
     DIFile topfile;
     DISubprogram SP;
 #endif
+    DebugLoc inlineLoc;
 
     BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", f);
     builder.SetInsertPoint(b0);
 
-    //jl_printf(JL_STDERR, "\n*** compiling %s at %s:%d\n\n",
-    //           lam->name->name, filename.c_str(), lno);
+    // jl_printf(JL_STDERR, "\n*** compiling %s at %s:%d\n\n",
+    //           jl_symbol_name(lam->name), filename.c_str(), lno);
 
     DebugLoc noDbg;
     ctx.debug_enabled = true;
@@ -4295,8 +4362,8 @@ static Function *emit_function(jl_lambda_info_t *lam)
         // TODO: Fix when moving to new LLVM version
         #ifndef LLVM34
         dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
-        #elif LLVM37
-        DICompileUnit *CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
+        #elif defined(LLVM37)
+        CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
         #else
         DICompileUnit CU = dbuilder.createCompileUnit(0x01, filename, ".", "julia", true, "", 0);
         assert(CU.Verify());
@@ -4304,7 +4371,7 @@ static Function *emit_function(jl_lambda_info_t *lam)
 
 #ifdef LLVM37
         DISubroutineType *subrty;
-#elif LLVM36
+#elif defined(LLVM36)
         DISubroutineType subrty;
 #else
         DICompositeType subrty;
@@ -4324,7 +4391,9 @@ static Function *emit_function(jl_lambda_info_t *lam)
                     continue;
                 ditypes.push_back(julia_type_to_di(jl_tparam(lam->specTypes,i),ctx.dbuilder,false));
             }
-#ifdef LLVM36
+#ifdef LLVM38
+            subrty = ctx.dbuilder->createSubroutineType(ctx.dbuilder->getOrCreateTypeArray(ditypes));
+#elif defined(LLVM36)
             subrty = ctx.dbuilder->createSubroutineType(topfile,ctx.dbuilder->getOrCreateTypeArray(ditypes));
 #else
             subrty = ctx.dbuilder->createSubroutineType(topfile,ctx.dbuilder->getOrCreateArray(ditypes));
@@ -4347,9 +4416,17 @@ static Function *emit_function(jl_lambda_info_t *lam)
                                     0,            // ScopeLine
                                     0,            // Flags
                                     true,         // isOptimized
-                                    f);           // Fn
+        #ifdef LLVM38
+                                    nullptr);       // Template Parameters
+        #else
+                                    f);             // Function
+        #endif
         // set initial line number
-        builder.SetCurrentDebugLocation(DebugLoc::get(lno, 0, (MDNode*)SP, NULL));
+        inlineLoc = DebugLoc::get(lno, 0, (MDNode*)SP, NULL);
+        builder.SetCurrentDebugLocation(inlineLoc);
+        #ifdef LLVM38
+        f->setSubprogram(SP);
+        #endif
         #ifndef LLVM37
         assert(SP.Verify() && SP.describes(f) && SP.getFunction() == f);
         #endif
@@ -4359,49 +4436,50 @@ static Function *emit_function(jl_lambda_info_t *lam)
         // Go over all arguments and local variables and initialize their debug information
         for(i=0; i < nreq; i++) {
             jl_sym_t *argname = jl_decl_var(jl_cellref(largs,i));
+            if (argname == unused_sym) continue;
             jl_varinfo_t &varinfo = ctx.vars[argname];
 #ifdef LLVM38
             varinfo.dinfo = ctx.dbuilder->createParameterVariable(
                 SP,                                 // Scope (current function will be fill in later)
-                argname->name,                      // Variable name
-                i+1,                                // Argument number (1-based)
+                jl_symbol_name(argname),            // Variable name
+                ctx.sret + i + 1,                                // Argument number (1-based)
                 topfile,                            // File
-                ctx.lineno == -1 ? 0 : ctx.lineno,  // Line
+                toplineno == -1 ? 0 : toplineno,  // Line
                 // Variable type
-                julia_type_to_di(varinfo.value.typ,ctx.dbuilder,specsig));
+                julia_type_to_di(varinfo.value.typ,ctx.dbuilder,false));
 #else
             varinfo.dinfo = ctx.dbuilder->createLocalVariable(
                 llvm::dwarf::DW_TAG_arg_variable,    // Tag
                 SP,         // Scope (current function will be fill in later)
-                argname->name,    // Variable name
+                jl_symbol_name(argname),    // Variable name
                 topfile,                    // File
-                ctx.lineno == -1 ? 0 : ctx.lineno,             // Line (for now, use lineno of the function)
-                julia_type_to_di(varinfo.value.typ, ctx.dbuilder, specsig), // Variable type
+                toplineno == -1 ? 0 : toplineno,             // Line (for now, use lineno of the function)
+                julia_type_to_di(varinfo.value.typ, ctx.dbuilder,false), // Variable type
                 false,                  // May be optimized out
                 0,                      // Flags (TODO: Do we need any)
-                i+1);                   // Argument number (1-based)
+                ctx.sret + i + 1);                   // Argument number (1-based)
 #endif
         }
-        if (va) {
+        if (va && ctx.vaName) {
 #ifdef LLVM38
             ctx.vars[ctx.vaName].dinfo = ctx.dbuilder->createParameterVariable(
                 SP,                     // Scope (current function will be fill in later)
-                ctx.vaName->name,       // Variable name
-                nreq + 1,               // Argument number (1-based)
+                jl_symbol_name(ctx.vaName),        // Variable name
+                ctx.sret + nreq + 1,               // Argument number (1-based)
                 topfile,                    // File
-                ctx.lineno == -1 ? 0 : ctx.lineno,             // Line (for now, use lineno of the function)
-                julia_type_to_di(ctx.vars[ctx.vaName].value.typ,ctx.dbuilder,false));
+                toplineno == -1 ? 0 : toplineno,             // Line (for now, use lineno of the function)
+                julia_type_to_di(ctx.vars[ctx.vaName].value.typ, ctx.dbuilder, false));
 #else
             ctx.vars[ctx.vaName].dinfo = ctx.dbuilder->createLocalVariable(
                 llvm::dwarf::DW_TAG_arg_variable,   // Tag
                 SP,                                 // Scope (current function will be fill in later)
-                ctx.vaName->name,                   // Variable name
-                topfile,                             // File
-                ctx.lineno == -1 ? 0 : ctx.lineno,  // Line (for now, use lineno of the function)
-                julia_type_to_di(ctx.vars[ctx.vaName].value.typ,ctx.dbuilder,false),      // Variable type
+                jl_symbol_name(ctx.vaName),         // Variable name
+                topfile,                            // File
+                toplineno == -1 ? 0 : toplineno,  // Line (for now, use lineno of the function)
+                julia_type_to_di(ctx.vars[ctx.vaName].value.typ, ctx.dbuilder, false),      // Variable type
                 false,                  // May be optimized out
                 0,                      // Flags (TODO: Do we need any)
-                nreq + 1);              // Argument number (1-based)
+                ctx.sret + nreq + 1);              // Argument number (1-based)
 #endif
         }
         for(i=0; i < vinfoslen; i++) {
@@ -4416,34 +4494,10 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 llvm::dwarf::DW_TAG_auto_variable,    // Tag
 #endif
                 SP,                     // Scope (current function will be fill in later)
-                s->name,                // Variable name
-                topfile,                 // File
-                ctx.lineno == -1 ? 0 : ctx.lineno, // Line (for now, use lineno of the function)
-                julia_type_to_di(varinfo.value.typ, ctx.dbuilder, specsig), // Variable type
-                false,                  // May be optimized out
-                0                       // Flags (TODO: Do we need any)
-#ifndef LLVM38
-                ,0                      // Argument number (1-based)
-#endif
-                );
-        }
-        for(i=0; i < captvinfoslen; i++) {
-            jl_array_t *vi = (jl_array_t*)jl_cellref(captvinfos, i);
-            assert(jl_is_array(vi));
-            jl_sym_t *vname = ((jl_sym_t*)jl_cellref(vi,0));
-            assert(jl_is_symbol(vname));
-            jl_varinfo_t &varinfo = ctx.vars[vname];
-#ifdef LLVM38
-            varinfo.dinfo = ctx.dbuilder->createAutoVariable(
-#else
-            varinfo.dinfo = ctx.dbuilder->createLocalVariable(
-                llvm::dwarf::DW_TAG_auto_variable,    // Tag
-#endif
-                SP,                     // Scope (current function will be filled in later)
-                vname->name,            // Variable name
+                jl_symbol_name(s),       // Variable name
                 topfile,                 // File
-                ctx.lineno == -1 ? 0 : ctx.lineno, // Line (for now, use lineno of the function)
-                julia_type_to_di(varinfo.value.typ, ctx.dbuilder, specsig), // Variable type
+                toplineno == -1 ? 0 : toplineno, // Line (for now, use lineno of the function)
+                julia_type_to_di(varinfo.value.typ, ctx.dbuilder, false), // Variable type
                 false,                  // May be optimized out
                 0                       // Flags (TODO: Do we need any)
 #ifndef LLVM38
@@ -4462,9 +4516,12 @@ static Function *emit_function(jl_lambda_info_t *lam)
     Value *fArg=NULL, *argArray=NULL, *argCount=NULL;
     if (!specsig) {
         Function::arg_iterator AI = f->arg_begin();
-        fArg = AI++;
-        argArray = AI++;
-        argCount = AI++;
+        if (needsparams) {
+            ctx.spvals_ptr = &*AI++;
+        }
+        fArg = &*AI++;
+        argArray = &*AI++;
+        argCount = &*AI++;
         ctx.argArray = argArray;
         ctx.argCount = argCount;
 
@@ -4473,19 +4530,22 @@ static Function *emit_function(jl_lambda_info_t *lam)
         // before we get to loading local variables
         for(i=0; i < nreq; i++) {
             jl_sym_t *s = jl_decl_var(jl_cellref(largs,i));
+            if (s == unused_sym) continue;
             if (ctx.vars[s].dinfo != (MDNode*)NULL) {
                 SmallVector<int64_t, 9> addr;
                 addr.push_back(llvm::dwarf::DW_OP_plus);
                 addr.push_back(i * sizeof(void*));
-                //addr.push_back(llvm::dwarf::DW_OP_deref);
+                addr.push_back(llvm::dwarf::DW_OP_deref);
+                prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::dbg_value));
+                ctx.dbuilder->insertDbgValueIntrinsic(
+                    argArray,
+                    0,
+                    ctx.vars[s].dinfo,
+                    ctx.dbuilder->createExpression(addr),
 #ifdef LLVM37
-                ctx.dbuilder->insertDbgValueIntrinsic(argArray, 0, ctx.vars[s].dinfo,
-                ctx.dbuilder->createExpression(addr),
-                builder.getCurrentDebugLocation().get(), builder.GetInsertBlock());
-#else
-                ctx.dbuilder->insertDbgValueIntrinsic(argArray, 0, ctx.vars[s].dinfo,
-                ctx.dbuilder->createExpression(addr), builder.GetInsertBlock());
+                    builder.getCurrentDebugLocation().get(),
 #endif
+                    builder.GetInsertBlock());
             }
         }
 #endif
@@ -4509,12 +4569,17 @@ static Function *emit_function(jl_lambda_info_t *lam)
     int n_roots = 0;
     for(i=0; i < largslen; i++) {
         jl_sym_t *s = jl_decl_var(jl_cellref(largs,i));
+        if (s == unused_sym) continue;
         jl_varinfo_t &varinfo = ctx.vars[s];
-        if (varinfo.value.isghost) {
-            // no need to explicitly load/store a ghost value
+        if (varinfo.value.isghost || varinfo.value.constant) {
+            // no need to explicitly load/store a constant/ghost value
             continue;
         }
-        if (store_unboxed_p(s, &ctx)) {
+        if (jl_is_type_type(varinfo.value.typ) && jl_is_leaf_type(jl_tparam0(varinfo.value.typ))) {
+            // replace T::Type{T} with T
+            varinfo.value = mark_julia_const(jl_tparam0(varinfo.value.typ));
+        }
+        else if (store_unboxed_p(s, &ctx)) {
             if (varinfo.isAssigned) // otherwise, just leave it in the input register
                 alloc_local(s, &ctx);
         }
@@ -4527,10 +4592,11 @@ static Function *emit_function(jl_lambda_info_t *lam)
         jl_sym_t *s = (jl_sym_t*)jl_cellref(jl_cellref(vinfos,i),0);
         assert(jl_is_symbol(s));
         jl_varinfo_t &vi = ctx.vars[s];
-        if (vi.isArgument)
+        if (vi.isArgument) {
             continue;
-        if (vi.value.isghost && !vi.usedUndef) {
-            // no need to explicitly load/store a ghost value
+        }
+        if ((vi.value.isghost || vi.value.constant) && !vi.usedUndef) {
+            // no need to explicitly load/store a constant/ghost value
             continue;
         }
         if (store_unboxed_p(s, &ctx)) {
@@ -4541,9 +4607,14 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 vi.hasGCRoot = false;
                 continue;
             }
-            if (vi.isSA && !vi.isVolatile && !vi.isCaptured && !vi.usedUndef) {
+            if (jl_options.opt_level > 0 && vi.isSA && !vi.isVolatile && !vi.usedUndef) {
                 vi.hasGCRoot = false; // so far...
             }
+            else if (jl_is_type_type(vi.value.typ) && jl_is_leaf_type(jl_tparam0(vi.value.typ)) && !vi.usedUndef) {
+                // replace T::Type{T} with T
+                vi.value = mark_julia_const(jl_tparam0(vi.value.typ));
+                vi.hasGCRoot = false;
+            }
             else {
                 vi.hasGCRoot = true;
                 n_roots++;
@@ -4556,40 +4627,26 @@ static Function *emit_function(jl_lambda_info_t *lam)
     ctx.gensym_assigned.assign(n_gensyms, false);
     ctx.gensym_SAvalues.assign(n_gensyms, jl_cgval_t());
 
-    // fetch env out of function object if we need it
-    if (hasCapt) {
-        Value *envArg = emit_nthptr(fArg, offsetof(jl_function_t,env)/sizeof(jl_value_t*), tbaa_const);
-        for(i=0; i < captvinfoslen; i++) {
-            jl_array_t *vi = (jl_array_t*)jl_cellref(captvinfos, i);
-            assert(jl_is_array(vi));
-            jl_sym_t *vname = ((jl_sym_t*)jl_cellref(vi,0));
-            assert(jl_is_symbol(vname));
-            jl_varinfo_t &varinfo = ctx.vars[vname];
-            varinfo.memloc = builder.CreatePointerCast(
-                    emit_nthptr_addr(envArg, i + offsetof(jl_svec_t,data) / sizeof(void*)),
-                    jl_ppvalue_llvmt);
-            varinfo.hasGCRoot = true;
-        }
-    }
-
     // step 8. set up GC frame
-    allocate_gc_frame(n_roots, b0, &ctx);
+    allocate_gc_frame(b0, &ctx);
 
     // get pointers for locals stored in the gc frame array (argTemp)
     int varnum = 0;
     for(i=0; i < largslen; i++) {
         jl_sym_t *s = jl_decl_var(jl_cellref(largs,i));
+        if (s == unused_sym) continue;
         jl_varinfo_t &varinfo = ctx.vars[s];
-        assert(!varinfo.memloc); // arguments shouldn't also be in the closure env
-        if (varinfo.value.isghost) {
+        assert(!varinfo.memloc); // arguments shouldn't also have memory locs
+        if (varinfo.value.isghost || varinfo.value.constant) {
             // no need to explicitly load/store a ghost value
+            varinfo.hasGCRoot = true;
             continue;
         }
         if (store_unboxed_p(s, &ctx)) {
             varinfo.hasGCRoot = true;
         }
         else if (varinfo.isAssigned || (va && i==largslen-1 && varinfo.escapes)) {
-            Value *av = emit_local_slot(varnum, &ctx);
+            Value *av = emit_local_slot(&ctx);
             varnum++;
             varinfo.memloc = av;
         }
@@ -4599,16 +4656,17 @@ static Function *emit_function(jl_lambda_info_t *lam)
         jl_varinfo_t &varinfo = ctx.vars[s];
         if (varinfo.memloc || varinfo.isArgument)
             continue; // gc root already created
-        if (store_unboxed_p(s, &ctx)) {
-            varinfo.hasGCRoot = true;
-        }
+        if ((varinfo.value.isghost || varinfo.value.constant) && !varinfo.usedUndef)
+            varinfo.hasGCRoot = true; // will never need a gc-root for this
+        else if (store_unboxed_p(s, &ctx))
+            varinfo.hasGCRoot = true; // will never need a gc-root for this
         else if (varinfo.hasGCRoot) {
-            Value *lv = emit_local_slot(varnum, &ctx);
+            Value *lv = emit_local_slot(&ctx);
             varnum++;
             varinfo.memloc = lv;
         }
     }
-    assert(varnum == ctx.gc.argSpaceSize);
+    assert(varnum == n_roots);
 
     // step 9. create boxes for boxed locals
     // now handled by explicit :newvar nodes
@@ -4629,52 +4687,48 @@ static Function *emit_function(jl_lambda_info_t *lam)
     }
 
     // step 11. check arg count
-    if (jl_is_va_tuple(ctx.linfo->specTypes)) {
-        std::string msg;
-        Value *enough;
-        if (va) {
-            msg = "too few arguments";
-            enough = builder.CreateICmpUGE(argCount,
-                                      ConstantInt::get(T_int32, nreq));
-        }
-        else {
-            msg = "wrong number of arguments";
-            enough =
-                builder.CreateICmpEQ(argCount,
-                                     ConstantInt::get(T_int32, nreq));
-        }
-        BasicBlock *elseBB =
-            BasicBlock::Create(getGlobalContext(), "else", f);
-        BasicBlock *mergeBB =
-            BasicBlock::Create(getGlobalContext(), "ifcont");
-        builder.CreateCondBr(enough, mergeBB, elseBB);
-        builder.SetInsertPoint(elseBB);
-        just_emit_error(msg, &ctx);
-        builder.CreateUnreachable();
-        f->getBasicBlockList().push_back(mergeBB);
-        builder.SetInsertPoint(mergeBB);
-    }
+    // (obsoleted by jb/functions branch)
 
     // step 12. move args into local variables
     Function::arg_iterator AI = f->arg_begin();
+    if (ctx.sret)
+        AI++; // skip sret slot
     for(i=0; i < nreq; i++) {
         jl_sym_t *s = jl_decl_var(jl_cellref(largs,i));
+        jl_value_t *argType = jl_nth_slot_type(lam->specTypes, i);
+        bool isboxed;
+        Type *llvmArgType = julia_type_to_llvm(argType, &isboxed);
+        if (s == unused_sym) {
+            if (specsig && !type_is_ghost(llvmArgType)) ++AI;
+            continue;
+        }
         jl_varinfo_t &vi = ctx.vars[s];
         jl_cgval_t theArg;
         if (!vi.value.isghost) {
-            if (specsig) {
-                jl_value_t *argType = jl_nth_slot_type(lam->specTypes, i);
-                Type *llvmArgType = julia_type_to_llvm(argType);
+            if (vi.value.constant) {
+                assert(vi.memloc == NULL);
+                if (specsig && !type_is_ghost(llvmArgType)) ++AI;
+                continue;
+            }
+            else if (specsig) {
                 if (type_is_ghost(llvmArgType)) // this argument is not actually passed
                     theArg = ghostValue(argType);
-                else if (llvmArgType->isAggregateType())
-                    theArg = mark_julia_slot(AI++, argType); // this argument is by-pointer
+                else if (llvmArgType->isAggregateType()) {
+                    theArg = mark_julia_slot(&*AI++, argType); // this argument is by-pointer
+                    theArg.isimmutable = true;
+                }
                 else
-                    theArg = mark_julia_type(AI++, argType);
+                    theArg = mark_julia_type(&*AI++, isboxed, argType, &ctx, /*needsgcroot*/false);
             }
             else {
-                Value *argPtr = builder.CreateGEP(argArray, ConstantInt::get(T_size, i));
-                theArg = mark_julia_type(builder.CreateLoad(argPtr), vi.value.typ);
+                if (i==0) {
+                    // first (function) arg is separate in jlcall
+                    theArg = mark_julia_type(fArg, true, vi.value.typ, &ctx, /*needsgcroot*/false);
+                }
+                else {
+                    Value *argPtr = builder.CreateGEP(argArray, ConstantInt::get(T_size, i-1));
+                    theArg = mark_julia_type(builder.CreateLoad(argPtr), true, vi.value.typ, &ctx, /*needsgcroot*/false);
+                }
             }
 
             Value *lv = vi.memloc;
@@ -4683,10 +4737,9 @@ static Function *emit_function(jl_lambda_info_t *lam)
                     // copy theArg into its local variable slot (unboxed)
                     assert(vi.isAssigned);
                     assert(vi.value.ispointer);
-                    builder.CreateStore(
-                            emit_unbox(vi.value.V->getType()->getContainedType(0),
-                                theArg, vi.value.typ),
-                            vi.value.V);
+                    builder.CreateStore(emit_unbox(vi.value.V->getType()->getContainedType(0),
+                                                   theArg, vi.value.typ),
+                                        vi.value.V);
                 }
                 else {
                     // keep track of original (boxed) value to avoid re-boxing or moving
@@ -4694,38 +4747,22 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 }
             }
             else {
-                Value *argp = boxed(theArg, &ctx);
-                if (vi.isBox) {
-                    if (!theArg.isboxed) {
-                        builder.CreateStore(argp, lv); // temporarily root
-                    }
-                    builder.CreateStore(builder.CreateCall(prepare_call(jlbox_func), argp), lv);
-                }
-                else {
-                    builder.CreateStore(argp, lv);
-                }
+                Value *argp = boxed(theArg, &ctx, false); // skip the temporary gcroot since it would be folded to argp anyways
+                builder.CreateStore(argp, lv);
             }
             // get arrayvar data if applicable
             if (arrayvars.find(s) != arrayvars.end()) {
                 jl_arrayvar_t av = arrayvars[s];
-                assign_arrayvar(av, theArg);
+                assign_arrayvar(av, theArg, &ctx);
             }
         }
-        else if (vi.isBox) {
-            // boxed ghost value -- TODO: kill this
-            Value *lv = vi.memloc;
-            assert(lv);
-            jl_value_t *inst = static_void_instance(vi.value.typ);
-            assert(inst);
-            builder.CreateStore(builder.CreateCall(prepare_call(jlbox_func), literal_pointer_val(inst)), lv);
-        }
         else {
             assert(vi.memloc == NULL);
         }
     }
 
     // step 13. allocate rest argument if necessary
-    if (va) {
+    if (va && ctx.vaName) {
         jl_sym_t *argname = ctx.vaName;
         jl_varinfo_t &vi = ctx.vars[argname];
         if (!vi.escapes && !vi.isAssigned) {
@@ -4739,21 +4776,18 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 Value *restTuple =
                     builder.CreateCall(prepare_call(jltuple_func), {V_null,
                                         builder.CreateGEP(argArray,
-                                                          ConstantInt::get(T_size,nreq)),
+                                                          ConstantInt::get(T_size,nreq-1)),
                                         builder.CreateSub(argCount,
-                                                          ConstantInt::get(T_int32,nreq))});
+                                                          ConstantInt::get(T_int32,nreq-1))});
 #else
                 Value *restTuple =
                     builder.CreateCall3(prepare_call(jltuple_func), V_null,
                                         builder.CreateGEP(argArray,
-                                                          ConstantInt::get(T_size,nreq)),
+                                                          ConstantInt::get(T_size,nreq-1)),
                                         builder.CreateSub(argCount,
-                                                          ConstantInt::get(T_int32,nreq)));
+                                                          ConstantInt::get(T_int32,nreq-1)));
 #endif
-                if (vi.isBox)
-                    builder.CreateStore(builder.CreateCall(prepare_call(jlbox_func), restTuple), lv);
-                else
-                    builder.CreateStore(restTuple, lv);
+                builder.CreateStore(restTuple, lv);
             }
             else {
                 // TODO: Perhaps allow this in the future, but for now since varargs
@@ -4777,7 +4811,7 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 labels[lname] = prev;
             }
             else {
-                prev = BasicBlock::Create(getGlobalContext(), "L");
+                prev = BasicBlock::Create(getGlobalContext(), "L", f);
                 labels[lname] = prev;
             }
         }
@@ -4799,7 +4833,8 @@ static Function *emit_function(jl_lambda_info_t *lam)
             if (jl_is_linenode(stmt)) {
                 lno = jl_linenode_line(stmt);
                 file = jl_linenode_file(stmt);
-            } else if (jl_is_expr(stmt)) {
+            }
+            else if (jl_is_expr(stmt)) {
                 lno = jl_unbox_long(jl_exprarg(stmt,0));
                 if (jl_array_dim0(((jl_expr_t*)stmt)->args) > 1) {
                     jl_value_t *a1 = jl_exprarg(stmt,1);
@@ -4808,7 +4843,7 @@ static Function *emit_function(jl_lambda_info_t *lam)
                     }
                 }
             }
-            assert(file->name);
+            assert(jl_symbol_name(file));
 
 #           ifdef LLVM37
             DIFile *dfil = NULL;
@@ -4817,7 +4852,7 @@ static Function *emit_function(jl_lambda_info_t *lam)
 #           endif
 
             // If the string is not empty
-            if (*file->name != '\0') {
+            if (*jl_symbol_name(file) != '\0') {
 #               ifdef LLVM37
                 std::map<jl_sym_t *, DIFile *>::iterator it = filescopes.find(file);
 #               else
@@ -4825,36 +4860,38 @@ static Function *emit_function(jl_lambda_info_t *lam)
 #               endif
                 if (it != filescopes.end()) {
                     dfil = it->second;
-                } else {
+                }
+                else {
 #                   ifdef LLVM37
-                    dfil = (DIFile*)dbuilder.createFile(file->name, ".");
+                    dfil = (DIFile*)dbuilder.createFile(jl_symbol_name(file),
+                                                        ".");
 #                   else
-                    dfil = (MDNode*)dbuilder.createFile(file->name, ".");
+                    dfil = (MDNode*)dbuilder.createFile(jl_symbol_name(file),
+                                                        ".");
 #                   endif
                 }
             }
             DebugLoc loc;
             if (ctx.debug_enabled) {
-                MDNode *funcscope = (MDNode*)dbuilder.createLexicalBlockFile(SP, topfile);
                 MDNode *scope;
                 if ((dfil == topfile || dfil == NULL) &&
-                    lno >= ctx.lineno) // if we are in the top-level file
-                                       // and the current lineno is less than
-                                       // the last, must be same-file inline
-                                       // TODO: improve this heuristic...
+                    lno >= toplineno)
                     {
-                    // set location to the current top-level line
-                    loc = DebugLoc::get(lno, 1, SP, NULL);
-                } else {
-                    // otherwise, we are compiling code from another file,
-                    // so create a location for the top-level line, and
-                    // set the DebugLoc "inlinedAt" parameter.
+                    // for sequentially-defined code,
+                    // set location to line in top file.
+                    // TODO: improve handling of nested inlines
+                    loc = inlineLoc = DebugLoc::get(lno, 1, SP, NULL);
+                }
+                else {
+                    // otherwise, we are compiling inlined code,
+                    // so set the DebugLoc "inlinedAt" parameter
+                    // to the current line, then use source loc.
 #ifdef LLVM37
                     scope = (MDNode*)dbuilder.createLexicalBlockFile(SP,dfil);
-                    MDNode *inlineLocMd = DebugLoc::get(ctx.lineno, 1, funcscope, NULL).getAsMDNode();
+                    MDNode *inlineLocMd = inlineLoc.getAsMDNode();
 #else
                     scope = (MDNode*)dbuilder.createLexicalBlockFile(SP,DIFile(dfil));
-                    MDNode *inlineLocMd = DebugLoc::get(ctx.lineno, 1, funcscope, NULL).getAsMDNode(jl_LLVMContext);
+                    MDNode *inlineLocMd = inlineLoc.getAsMDNode(jl_LLVMContext);
 #endif
                     loc = DebugLoc::get(lno, 1, scope, inlineLocMd);
                 }
@@ -4883,21 +4920,27 @@ static Function *emit_function(jl_lambda_info_t *lam)
         if (jl_is_expr(stmt) && ((jl_expr_t*)stmt)->head == return_sym) {
             jl_expr_t *ex = (jl_expr_t*)stmt;
             Value *retval;
-            Type *retty = f->getReturnType();
-            if (retty == jl_pvalue_llvmt) {
-                retval = boxed(emit_expr(jl_exprarg(ex,0), &ctx, true),&ctx,expr_type(stmt,&ctx));
+            bool retboxed;
+            Type *retty;
+            if (specsig) {
+                retty = julia_type_to_llvm(jlrettype, &retboxed);
             }
-            else if (!type_is_ghost(retty)) {
-                retval = emit_unbox(retty,
-                                    emit_unboxed(jl_exprarg(ex,0), &ctx), jlrettype);
+            else {
+                retty = T_pjlvalue;
+                retboxed = true;
             }
-            else { // undef return type
-                emit_expr(jl_exprarg(ex,0), &ctx, false);
+            jl_cgval_t retvalinfo = emit_expr(jl_exprarg(ex,0), &ctx);
+            if (retboxed)
+                retval = boxed(retvalinfo, &ctx, false); // skip the gcroot on the return path
+            else if (!type_is_ghost(retty))
+                retval = emit_unbox(retty, retvalinfo, jlrettype);
+            else // undef return type
                 retval = NULL;
-            }
             if (do_malloc_log && lno != -1)
                 mallocVisitLine(filename, lno);
-            if (type_is_ghost(retty))
+            if (ctx.sret)
+                builder.CreateStore(retval, &*ctx.f->arg_begin());
+            if (type_is_ghost(retty) || ctx.sret)
                 builder.CreateRetVoid();
             else
                 builder.CreateRet(retval);
@@ -4907,8 +4950,15 @@ static Function *emit_function(jl_lambda_info_t *lam)
                 builder.SetInsertPoint(bb);
             }
         }
+        else if (jl_is_expr(stmt) && ((jl_expr_t*)stmt)->head == boundscheck_sym) {
+            // always emit expressions that update the boundscheck stack
+            emit_stmtpos(stmt, &ctx);
+        }
+        else if (is_inbounds(&ctx) && is_bounds_check_block(&ctx)) {
+            // elide bounds check blocks
+        }
         else {
-            (void)emit_expr(stmt, &ctx, false, false);
+            emit_stmtpos(stmt, &ctx);
         }
     }
 
@@ -4919,25 +4969,51 @@ static Function *emit_function(jl_lambda_info_t *lam)
         builder.CreateUnreachable();
     }
 
-    // step 16. fix up size of stack root list
-    finalize_gc_frame(&ctx);
+    // patch up dangling BasicBlocks from skipped labels
+    for (std::map<int,BasicBlock*>::iterator it = labels.begin(); it != labels.end(); ++it) {
+        if (it->second->getTerminator() == NULL) {
+            builder.SetInsertPoint(it->second);
+            builder.CreateUnreachable();
+        }
+    }
 
     // step 17, Apply LLVM level inlining
     for(std::vector<CallInst*>::iterator it = ctx.to_inline.begin(); it != ctx.to_inline.end(); ++it) {
         Function *inlinef = (*it)->getCalledFunction();
         InlineFunctionInfo info;
+        // Intrinsics that InlineFunction might create
+        prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::lifetime_start));
+        prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::lifetime_end));
         if (!InlineFunction(*it,info))
             jl_error("Inlining Pass failed");
-        inlinef->eraseFromParent();
+        if (inlinef->getParent())
+            inlinef->eraseFromParent();
+        else {
+            inlinef->dropAllReferences();
+            delete inlinef;
+        }
     }
 
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+    if (cyclectx) {
+        cyclectx->functions.push_back(f);
+        if (fwrap)
+            cyclectx->functions.push_back(fwrap);
+    }
+#endif
+
     // step 18. Perform any delayed instantiations
-    if (ctx.debug_enabled)
+    if (ctx.debug_enabled) {
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+        if(cyclectx)
+            cyclectx->CUs.push_back(CU);
+#endif
         ctx.dbuilder->finalize();
+    }
 
     JL_GC_POP();
 
-    return f;
+    return;
 }
 
 // --- initialization ---
@@ -4958,33 +5034,48 @@ static MDNode *tbaa_make_child( const char *name, MDNode *parent, bool isConstan
 static GlobalVariable *global_to_llvm(const std::string &cname, void *addr, Module *m)
 {
     GlobalVariable *gv =
-        new GlobalVariable(*m, jl_pvalue_llvmt, true,
+        new GlobalVariable(*m, T_pjlvalue, true,
                            GlobalVariable::ExternalLinkage, NULL, cname);
     add_named_global(gv, addr);
     return gv;
 }
 
-static Function *jlcall_func_to_llvm(const std::string &cname, void *addr, Module *m)
+static Function *jlcall_func_to_llvm(const std::string &cname, jl_fptr_t addr, Module *m)
 {
     Function *f = Function::Create(jl_func_sig, Function::ExternalLinkage, cname, m);
     add_named_global(f, addr);
     return f;
 }
 
-extern "C" void jl_fptr_to_llvm(void *fptr, jl_lambda_info_t *lam, int specsig)
+extern "C" void jl_fptr_to_llvm(jl_fptr_t fptr, jl_lambda_info_t *lam, int specsig)
 {
     if (imaging_mode) {
         if (!specsig) {
-            lam->fptr = (jl_fptr_t)fptr; // in imaging mode, it's fine to use the fptr, but we don't want it in the shadow_module
+            lam->fptr = fptr; // in imaging mode, it's fine to use the fptr, but we don't want it in the shadow_module
         }
     }
     else {
         // this assigns a function pointer (from loading the system image), to the function object
-        std::string funcName = lam->name->name;
+        std::string funcName = jl_symbol_name(lam->name);
         funcName = "julia_" + funcName;
         if (specsig) { // assumes !va
-            jl_value_t *jlrettype = jl_ast_rettype(lam, (jl_value_t*)lam->ast);
             std::vector<Type*> fsig(0);
+            jl_value_t *jlrettype = lam->rettype;
+            bool retboxed;
+            Type *rt;
+            if (jlrettype == (jl_value_t*)jl_void_type) {
+                rt = T_void;
+                retboxed = false;
+            }
+            else {
+                rt = julia_type_to_llvm(jlrettype, &retboxed);
+            }
+            bool sret = false;
+            if (!retboxed && rt != T_void && deserves_sret(jlrettype, rt)) {
+                sret = true;
+                fsig.push_back(rt->getPointerTo());
+                rt = T_void;
+            }
             for (size_t i=0; i < jl_nparams(lam->specTypes); i++) {
                 Type *ty = julia_type_to_llvm(jl_tparam(lam->specTypes,i));
                 if (type_is_ghost(ty))
@@ -4993,45 +5084,41 @@ extern "C" void jl_fptr_to_llvm(void *fptr, jl_lambda_info_t *lam, int specsig)
                     ty = PointerType::get(ty,0);
                 fsig.push_back(ty);
             }
-            Type *rt = (jlrettype == (jl_value_t*)jl_void_type ? T_void : julia_type_to_llvm(jlrettype));
             Function *f = Function::Create(FunctionType::get(rt, fsig, false), Function::ExternalLinkage, funcName,
                                            shadow_module);
+            if (sret)
+                f->addAttribute(1, Attribute::StructRet);
 
-        if (lam->specFunctionObject == NULL) {
-            lam->specFunctionObject = (void*)f;
-            lam->specFunctionID = jl_assign_functionID(f);
+            if (lam->functionObjects.specFunctionObject == NULL) {
+                lam->functionObjects.specFunctionObject = (void*)f;
             }
-            add_named_global(f, (void*)fptr);
+            add_named_global(f, fptr);
         }
         else {
-            Function *f = jlcall_func_to_llvm(funcName, fptr, shadow_module);
-            if (lam->functionObject == NULL) {
-                lam->functionObject = (void*)f;
-                lam->functionID = jl_assign_functionID(f);
-                assert(lam->fptr == &jl_trampoline);
-                lam->fptr = (jl_fptr_t)fptr;
+            if (lam->jlcall_api == 1) { // jl_func_sig_sparams -- don't bother emitting the FunctionObject (since can't be used right now)
+                assert(lam->fptr == NULL);
+                lam->fptr = fptr;
+            }
+            else {
+                Function *f = jlcall_func_to_llvm(funcName, fptr, shadow_module);
+                if (lam->functionObjects.functionObject == NULL) {
+                    lam->functionObjects.functionObject = (void*)f;
+                    assert(lam->fptr == NULL);
+                    lam->fptr = fptr;
+                }
             }
         }
     }
 }
 
-extern "C" DLLEXPORT jl_value_t *jl_new_box(jl_value_t *v)
-{
-    jl_value_t *box = (jl_value_t*)jl_gc_alloc_1w();
-    jl_set_typeof(box, jl_box_any_type);
-    // if (v) jl_gc_wb(box, v); // write block not needed: box was just allocated
-    box->fieldptr[0] = v;
-    return box;
-}
-
-#if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR == 3 && SYSTEM_LLVM
+#if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR == 3 && defined(SYSTEM_LLVM)
 #define INSTCOMBINE_BUG
 #define V128_BUG
 #endif
 
 static void init_julia_llvm_env(Module *m)
 {
-    MDNode* tbaa_root = mbuilder->createTBAARoot("jtbaa");
+    MDNode *tbaa_root = mbuilder->createTBAARoot("jtbaa");
     tbaa_user = tbaa_make_child("jtbaa_user",tbaa_root);
     tbaa_value = tbaa_make_child("jtbaa_value",tbaa_root);
     tbaa_immut = tbaa_make_child("jtbaa_immut",tbaa_root);
@@ -5049,6 +5136,8 @@ static void init_julia_llvm_env(Module *m)
     T_int1  = Type::getInt1Ty(getGlobalContext());
     T_int8  = Type::getInt8Ty(getGlobalContext());
     T_pint8 = PointerType::get(T_int8, 0);
+    T_ppint8 = PointerType::get(T_pint8, 0);
+    T_pppint8 = PointerType::get(T_ppint8, 0);
     T_int16 = Type::getInt16Ty(getGlobalContext());
     T_pint16 = PointerType::get(T_int16, 0);
     T_int32 = Type::getInt32Ty(getGlobalContext());
@@ -5063,21 +5152,24 @@ static void init_julia_llvm_env(Module *m)
     else
         T_size = T_uint32;
     T_psize = PointerType::get(T_size, 0);
+    T_float16 = Type::getHalfTy(getGlobalContext());
     T_float32 = Type::getFloatTy(getGlobalContext());
     T_pfloat32 = PointerType::get(T_float32, 0);
     T_float64 = Type::getDoubleTy(getGlobalContext());
     T_pfloat64 = PointerType::get(T_float64, 0);
+    T_float128 = Type::getFP128Ty(getGlobalContext());
     T_void = Type::getVoidTy(jl_LLVMContext);
+    T_pvoidfunc = FunctionType::get(T_void, /*isVarArg*/false)->getPointerTo();
 
     // This type is used to create undef Values for use in struct declarations to skip indices
-    NoopType = ArrayType::get(T_int1,0);
+    NoopType = ArrayType::get(T_int1, 0);
 
     // add needed base definitions to our LLVM environment
     StructType *valueSt = StructType::create(getGlobalContext(), "jl_value_t");
     Type *valueStructElts[1] = { PointerType::getUnqual(valueSt) };
     ArrayRef<Type*> vselts(valueStructElts);
     valueSt->setBody(vselts);
-    jl_value_llvmt = valueSt;
+    T_jlvalue = valueSt;
 
     DIBuilder dbuilder(*m);
 #ifdef LLVM37
@@ -5090,8 +5182,8 @@ static void init_julia_llvm_env(Module *m)
         "jl_value_t",
         julia_h,
         71, // At the time of this writing. Not sure if it's worth it to keep this in sync
-        sizeof(jl_value_t)*8,
-        __alignof__(jl_value_t)*8,
+        0 * 8, // sizeof(jl_value_t) * 8,
+        __alignof__(void*) * 8, // __alignof__(jl_value_t) * 8,
         0, // Flags
 #ifdef LLVM37
         nullptr,    // Derived from
@@ -5126,7 +5218,10 @@ static void init_julia_llvm_env(Module *m)
     // Third argument (length(argv))
     diargs.push_back(julia_type_to_di((jl_value_t*)jl_int32_type,&dbuilder,false));
 
-#ifdef LLVM36
+#ifdef LLVM38
+    jl_di_func_sig = dbuilder.createSubroutineType(
+        dbuilder.getOrCreateTypeArray(diargs));
+#elif defined(LLVM36)
     jl_di_func_sig = dbuilder.createSubroutineType(julia_h,
         dbuilder.getOrCreateTypeArray(diargs));
 #else
@@ -5134,54 +5229,52 @@ static void init_julia_llvm_env(Module *m)
         dbuilder.getOrCreateArray(diargs));
 #endif
 
-    jl_pvalue_llvmt = PointerType::get(jl_value_llvmt, 0);
-    jl_ppvalue_llvmt = PointerType::get(jl_pvalue_llvmt, 0);
-    two_pvalue_llvmt.push_back(jl_pvalue_llvmt);
-    two_pvalue_llvmt.push_back(jl_pvalue_llvmt);
-    three_pvalue_llvmt.push_back(jl_pvalue_llvmt);
-    three_pvalue_llvmt.push_back(jl_pvalue_llvmt);
-    three_pvalue_llvmt.push_back(jl_pvalue_llvmt);
-    V_null = Constant::getNullValue(jl_pvalue_llvmt);
+    T_pjlvalue = PointerType::get(T_jlvalue, 0);
+    T_ppjlvalue = PointerType::get(T_pjlvalue, 0);
+    two_pvalue_llvmt.push_back(T_pjlvalue);
+    two_pvalue_llvmt.push_back(T_pjlvalue);
+    three_pvalue_llvmt.push_back(T_pjlvalue);
+    three_pvalue_llvmt.push_back(T_pjlvalue);
+    three_pvalue_llvmt.push_back(T_pjlvalue);
+    V_null = Constant::getNullValue(T_pjlvalue);
+
     std::vector<Type*> ftargs(0);
-    ftargs.push_back(jl_pvalue_llvmt);
-    ftargs.push_back(jl_ppvalue_llvmt);
-    ftargs.push_back(T_int32);
-    jl_func_sig = FunctionType::get(jl_pvalue_llvmt, ftargs, false);
+    ftargs.push_back(T_pjlvalue);  // linfo->sparam_vals
+    ftargs.push_back(T_pjlvalue);  // function
+    ftargs.push_back(T_ppjlvalue); // args[]
+    ftargs.push_back(T_int32);     // nargs
+    jl_func_sig_sparams = FunctionType::get(T_pjlvalue, ftargs, false);
+    assert(jl_func_sig_sparams != NULL);
+    ftargs.erase(ftargs.begin());  // drop linfo->sparams_vals argument
+    jl_func_sig = FunctionType::get(T_pjlvalue, ftargs, false);
     assert(jl_func_sig != NULL);
-    jl_pfptr_llvmt = PointerType::get(PointerType::get(jl_func_sig, 0), 0);
 
-    Type* vaelts[] = {T_pint8
+    Type *vaelts[] = {T_pint8
 #ifdef STORE_ARRAY_LEN
                       , T_size
 #endif
                       , T_int16
     };
-    Type* jl_array_llvmt =
+    static_assert(sizeof(jl_array_flags_t) == sizeof(int16_t),
+                  "Size of jl_array_flags_t is not the same as int16_t");
+    Type *jl_array_llvmt =
         StructType::create(jl_LLVMContext,
                            ArrayRef<Type*>(vaelts,sizeof(vaelts)/sizeof(vaelts[0])),
                            "jl_array_t");
     jl_parray_llvmt = PointerType::get(jl_array_llvmt,0);
 
-    jlpgcstack_var =
-        new GlobalVariable(*m, jl_ppvalue_llvmt,
-                           false, GlobalVariable::ExternalLinkage,
-                           NULL, "jl_pgcstack");
-    add_named_global(jlpgcstack_var, (void*)&jl_pgcstack);
-
     global_to_llvm("__stack_chk_guard", (void*)&__stack_chk_guard, m);
     Function *jl__stack_chk_fail =
         Function::Create(FunctionType::get(T_void, false),
                          Function::ExternalLinkage,
                          "__stack_chk_fail", m);
     jl__stack_chk_fail->setDoesNotReturn();
-    add_named_global(jl__stack_chk_fail, (void*)&__stack_chk_fail);
+    add_named_global(jl__stack_chk_fail, &__stack_chk_fail);
 
     jltrue_var = global_to_llvm("jl_true", (void*)&jl_true, m);
     jlfalse_var = global_to_llvm("jl_false", (void*)&jl_false, m);
     jlemptysvec_var = global_to_llvm("jl_emptysvec", (void*)&jl_emptysvec, m);
     jlemptytuple_var = global_to_llvm("jl_emptytuple", (void*)&jl_emptytuple, m);
-    jlexc_var = global_to_llvm("jl_exception_in_transit",
-                               (void*)&jl_exception_in_transit, m);
     jldiverr_var = global_to_llvm("jl_diverror_exception",
                                   (void*)&jl_diverror_exception, m);
     jlundeferr_var = global_to_llvm("jl_undefref_exception",
@@ -5197,20 +5290,20 @@ static void init_julia_llvm_env(Module *m)
         new GlobalVariable(*m, T_pint8,
                            true, GlobalVariable::ExternalLinkage,
                            NULL, "jl_RTLD_DEFAULT_handle");
-    add_named_global(jlRTLD_DEFAULT_var, (void*)&jl_RTLD_DEFAULT_handle);
+    add_named_global(jlRTLD_DEFAULT_var, &jl_RTLD_DEFAULT_handle);
 #ifdef _OS_WINDOWS_
     jlexe_var =
         new GlobalVariable(*m, T_pint8,
                            true, GlobalVariable::ExternalLinkage,
                            NULL, "jl_exe_handle");
-    add_named_global(jlexe_var, (void*)&jl_exe_handle);
+    add_named_global(jlexe_var, &jl_exe_handle);
     jldll_var =
         new GlobalVariable(*m, T_pint8,
                            true, GlobalVariable::ExternalLinkage,
                            NULL, "jl_dl_handle");
-    add_named_global(jldll_var, (void*)&jl_dl_handle);
+    add_named_global(jldll_var, &jl_dl_handle);
 #endif
-#if JL_NEED_FLOATTEMP_VAR
+#ifdef JL_NEED_FLOATTEMP_VAR
     // Has to be big enough for the biggest LLVM-supported float type
     jlfloattemp_var =
         addComdat(new GlobalVariable(*m, IntegerType::get(jl_LLVMContext,128),
@@ -5219,6 +5312,59 @@ static void init_julia_llvm_env(Module *m)
                                      "jl_float_temp"));
 #endif
 
+#ifndef JULIA_ENABLE_THREADING
+    // For non-threading, we use the address of the global variable directly
+    jltls_states_var =
+        new GlobalVariable(*m, T_ppjlvalue,
+                           false, GlobalVariable::ExternalLinkage,
+                           NULL, "jl_tls_states");
+    add_named_global(jltls_states_var, &jl_tls_states);
+    // placeholder function for keeping track of the end of the gcframe
+    jltls_states_func = Function::Create(FunctionType::get(jltls_states_var->getType(), false),
+                                         Function::ExternalLinkage,
+                                         "jl_get_ptls_states", m);
+    add_named_global(jltls_states_func, (void*)NULL, /*dllimport*/false);
+#else
+    // For threading, we emit a call to the getter function.
+    // In non-imaging mode, (i.e. the code will not be saved to disk), we
+    // use the address of the actual getter function directly
+    // (`jl_tls_states_cb` returned by `jl_get_ptls_states_getter()`)
+    // In imaging mode, we emit the function address as a load of a static
+    // variable to be filled (in `dump.c`) at initialization time of the sysimg.
+    // This way we can by pass the extra indirection in `jl_get_ptls_states`
+    // since we don't know which getter function to use ahead of time.
+    jltls_states_func = Function::Create(FunctionType::get(PointerType::get(T_ppjlvalue, 0), false),
+                                         Function::ExternalLinkage,
+                                         "jl_get_ptls_states", m);
+    jltls_states_func->setAttributes(
+        jltls_states_func->getAttributes()
+        .addAttribute(jltls_states_func->getContext(),
+                      AttributeSet::FunctionIndex, Attribute::ReadNone)
+        .addAttribute(jltls_states_func->getContext(),
+                      AttributeSet::FunctionIndex, Attribute::NoUnwind));
+    add_named_global(jltls_states_func, jl_get_ptls_states_getter());
+    if (imaging_mode) {
+        PointerType *pfunctype = jltls_states_func->getFunctionType()->getPointerTo();
+        jltls_states_func_ptr =
+            new GlobalVariable(*m, pfunctype,
+                               false, GlobalVariable::InternalLinkage,
+                               ConstantPointerNull::get(pfunctype),
+                               "jl_get_ptls_states.ptr");
+        addComdat(jltls_states_func_ptr);
+#ifdef USE_MCJIT
+        jl_llvm_to_jl_value[jltls_states_func_ptr] =
+            (void*)jl_get_ptls_states_getter();
+#else
+        void **p = (void**)jl_ExecutionEngine->getPointerToGlobal(jltls_states_func_ptr);
+        *p = (void*)jl_get_ptls_states_getter();
+#endif
+        jl_sysimg_gvars.push_back(ConstantExpr::getBitCast(jltls_states_func_ptr,
+                                                           T_psize));
+        jltls_states_func_idx = jl_sysimg_gvars.size();
+    }
+
+#endif
+
     std::vector<Type*> args1(0);
     args1.push_back(T_pint8);
     jlerror_func =
@@ -5226,26 +5372,26 @@ static void init_julia_llvm_env(Module *m)
                          Function::ExternalLinkage,
                          "jl_error", m);
     jlerror_func->setDoesNotReturn();
-    add_named_global(jlerror_func, (void*)&jl_error);
+    add_named_global(jlerror_func, &jl_error);
 
     std::vector<Type*> args1_(0);
-    args1_.push_back(jl_pvalue_llvmt);
+    args1_.push_back(T_pjlvalue);
     jlthrow_func =
         Function::Create(FunctionType::get(T_void, args1_, false),
                          Function::ExternalLinkage,
                          "jl_throw", m);
     jlthrow_func->setDoesNotReturn();
-    add_named_global(jlthrow_func, (void*)&jl_throw);
+    add_named_global(jlthrow_func, &jl_throw);
 
     jlundefvarerror_func =
         Function::Create(FunctionType::get(T_void, args1_, false),
                          Function::ExternalLinkage,
                          "jl_undefined_var_error", m);
     jlundefvarerror_func->setDoesNotReturn();
-    add_named_global(jlundefvarerror_func, (void*)&jl_undefined_var_error);
+    add_named_global(jlundefvarerror_func, &jl_undefined_var_error);
 
     std::vector<Type*> args2_boundserrorv(0);
-    args2_boundserrorv.push_back(jl_pvalue_llvmt);
+    args2_boundserrorv.push_back(T_pjlvalue);
     args2_boundserrorv.push_back(T_psize);
     args2_boundserrorv.push_back(T_size);
     jlboundserrorv_func =
@@ -5253,20 +5399,20 @@ static void init_julia_llvm_env(Module *m)
                          Function::ExternalLinkage,
                          "jl_bounds_error_ints", m);
     jlboundserrorv_func->setDoesNotReturn();
-    add_named_global(jlboundserrorv_func, (void*)&jl_bounds_error_ints);
+    add_named_global(jlboundserrorv_func, &jl_bounds_error_ints);
 
     std::vector<Type*> args2_boundserror(0);
-    args2_boundserror.push_back(jl_pvalue_llvmt);
+    args2_boundserror.push_back(T_pjlvalue);
     args2_boundserror.push_back(T_size);
     jlboundserror_func =
         Function::Create(FunctionType::get(T_void, args2_boundserror, false),
                          Function::ExternalLinkage,
                          "jl_bounds_error_int", m);
     jlboundserror_func->setDoesNotReturn();
-    add_named_global(jlboundserror_func, (void*)&jl_bounds_error_int);
+    add_named_global(jlboundserror_func, &jl_bounds_error_int);
 
     std::vector<Type*> args3_vboundserror(0);
-    args3_vboundserror.push_back(jl_ppvalue_llvmt);
+    args3_vboundserror.push_back(T_ppjlvalue);
     args3_vboundserror.push_back(T_size);
     args3_vboundserror.push_back(T_size);
     jlvboundserror_func =
@@ -5274,32 +5420,23 @@ static void init_julia_llvm_env(Module *m)
                          Function::ExternalLinkage,
                          "jl_bounds_error_tuple_int", m);
     jlvboundserror_func->setDoesNotReturn();
-    add_named_global(jlvboundserror_func, (void*)&jl_bounds_error_tuple_int);
+    add_named_global(jlvboundserror_func, &jl_bounds_error_tuple_int);
 
     std::vector<Type*> args3_uboundserror(0);
     args3_uboundserror.push_back(T_pint8);
-    args3_uboundserror.push_back(jl_pvalue_llvmt);
+    args3_uboundserror.push_back(T_pjlvalue);
     args3_uboundserror.push_back(T_size);
     jluboundserror_func =
         Function::Create(FunctionType::get(T_void, args3_uboundserror, false),
                          Function::ExternalLinkage,
                          "jl_bounds_error_unboxed_int", m);
     jluboundserror_func->setDoesNotReturn();
-    add_named_global(jluboundserror_func, (void*)&jl_bounds_error_unboxed_int);
-
-    std::vector<Type*> args2_throw(0);
-    args2_throw.push_back(jl_pvalue_llvmt);
-    args2_throw.push_back(T_int32);
-    jlthrow_line_func =
-        (Function*)m->getOrInsertFunction("jl_throw_with_superfluous_argument",
-                                          FunctionType::get(T_void, args2_throw, false));
-    jlthrow_line_func->setDoesNotReturn();
-    add_named_global(jlthrow_line_func, (void*)&jl_throw_with_superfluous_argument);
+    add_named_global(jluboundserror_func, &jl_bounds_error_unboxed_int);
 
     jlnew_func =
         Function::Create(jl_func_sig, Function::ExternalLinkage,
                          "jl_new_structv", m);
-    add_named_global(jlnew_func, (void*)&jl_new_structv);
+    add_named_global(jlnew_func, &jl_new_structv);
 
     std::vector<Type*> args2(0);
     args2.push_back(T_pint8);
@@ -5310,7 +5447,7 @@ static void init_julia_llvm_env(Module *m)
         Function::Create(FunctionType::get(T_int32, args2, false),
                          Function::ExternalLinkage, jl_setjmp_name, m);
     setjmp_func->addFnAttr(Attribute::ReturnsTwice);
-    add_named_global(setjmp_func, (void*)&jl_setjmp_f);
+    add_named_global(setjmp_func, &jl_setjmp_f);
 
     std::vector<Type*> args_memcmp(0);
     args_memcmp.push_back(T_pint8);
@@ -5319,155 +5456,141 @@ static void init_julia_llvm_env(Module *m)
     memcmp_func =
         Function::Create(FunctionType::get(T_int32, args_memcmp, false),
                          Function::ExternalLinkage, "memcmp", m);
-    add_named_global(memcmp_func, (void*)&memcmp);
+    add_named_global(memcmp_func, &memcmp);
 
     std::vector<Type*> te_args(0);
     te_args.push_back(T_pint8);
     te_args.push_back(T_pint8);
-    te_args.push_back(jl_pvalue_llvmt);
-    te_args.push_back(jl_pvalue_llvmt);
-    te_args.push_back(T_int32);
+    te_args.push_back(T_pjlvalue);
+    te_args.push_back(T_pjlvalue);
     jltypeerror_func =
         Function::Create(FunctionType::get(T_void, te_args, false),
                          Function::ExternalLinkage,
-                         "jl_type_error_rt_line", m);
+                         "jl_type_error_rt", m);
     jltypeerror_func->setDoesNotReturn();
-    add_named_global(jltypeerror_func, (void*)&jl_type_error_rt_line);
+    add_named_global(jltypeerror_func, &jl_type_error_rt);
 
     std::vector<Type *> args_2ptrs(0);
-    args_2ptrs.push_back(jl_pvalue_llvmt);
-    args_2ptrs.push_back(jl_pvalue_llvmt);
+    args_2ptrs.push_back(T_pjlvalue);
+    args_2ptrs.push_back(T_pjlvalue);
     jlcheckassign_func =
         Function::Create(FunctionType::get(T_void, args_2ptrs, false),
                          Function::ExternalLinkage,
                          "jl_checked_assignment", m);
-    add_named_global(jlcheckassign_func, (void*)&jl_checked_assignment);
+    add_named_global(jlcheckassign_func, &jl_checked_assignment);
 
     std::vector<Type *> args_1ptr(0);
-    args_1ptr.push_back(jl_pvalue_llvmt);
+    args_1ptr.push_back(T_pjlvalue);
     jldeclareconst_func =
         Function::Create(FunctionType::get(T_void, args_1ptr, false),
                          Function::ExternalLinkage,
                          "jl_declare_constant", m);
-    add_named_global(jldeclareconst_func, (void*)&jl_declare_constant);
+    add_named_global(jldeclareconst_func, &jl_declare_constant);
 
     jlgetbindingorerror_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, args_2ptrs, false),
+        Function::Create(FunctionType::get(T_pjlvalue, args_2ptrs, false),
                          Function::ExternalLinkage,
                          "jl_get_binding_or_error", m);
-    add_named_global(jlgetbindingorerror_func, (void*)&jl_get_binding_or_error);
-
-    builtin_func_map[jl_f_is] = jlcall_func_to_llvm("jl_f_is", (void*)&jl_f_is, m);
-    builtin_func_map[jl_f_typeof] = jlcall_func_to_llvm("jl_f_typeof", (void*)&jl_f_typeof, m);
-    builtin_func_map[jl_f_sizeof] = jlcall_func_to_llvm("jl_f_sizeof", (void*)&jl_f_sizeof, m);
-    builtin_func_map[jl_f_subtype] = jlcall_func_to_llvm("jl_f_subtype", (void*)&jl_f_subtype, m);
-    builtin_func_map[jl_f_isa] = jlcall_func_to_llvm("jl_f_isa", (void*)&jl_f_isa, m);
-    builtin_func_map[jl_f_typeassert] = jlcall_func_to_llvm("jl_f_typeassert", (void*)&jl_f_typeassert, m);
-    builtin_func_map[jl_f_apply] = jlcall_func_to_llvm("jl_f_apply", (void*)&jl_f_apply, m);
-    builtin_func_map[jl_f_kwcall] = jlcall_func_to_llvm("jl_f_kwcall", (void*)&jl_f_kwcall, m);
-    builtin_func_map[jl_f_throw] = jlcall_func_to_llvm("jl_f_throw", (void*)&jl_f_throw, m);
-    builtin_func_map[jl_f_tuple] = jlcall_func_to_llvm("jl_f_tuple", (void*)&jl_f_tuple, m);
-    builtin_func_map[jl_f_svec] = jlcall_func_to_llvm("jl_f_svec", (void*)&jl_f_svec, m);
-    builtin_func_map[jl_f_methodexists] = jlcall_func_to_llvm("jl_f_methodexists", (void*)&jl_f_methodexists, m);
-    builtin_func_map[jl_f_applicable] = jlcall_func_to_llvm("jl_f_applicable", (void*)&jl_f_applicable, m);
-    builtin_func_map[jl_f_invoke] = jlcall_func_to_llvm("jl_f_invoke", (void*)&jl_f_invoke, m);
-    builtin_func_map[jl_f_top_eval] = jlcall_func_to_llvm("jl_f_top_eval", (void*)&jl_f_top_eval, m);
-    builtin_func_map[jl_f_isdefined] = jlcall_func_to_llvm("jl_f_isdefined", (void*)&jl_f_isdefined, m);
-    builtin_func_map[jl_f_get_field] = jlcall_func_to_llvm("jl_f_get_field", (void*)&jl_f_get_field, m);
-    builtin_func_map[jl_f_set_field] = jlcall_func_to_llvm("jl_f_set_field", (void*)&jl_f_set_field, m);
-    builtin_func_map[jl_f_field_type] = jlcall_func_to_llvm("jl_f_field_type", (void*)&jl_f_field_type, m);
-    builtin_func_map[jl_f_nfields] = jlcall_func_to_llvm("jl_f_nfields", (void*)&jl_f_nfields, m);
-    builtin_func_map[jl_f_new_expr] = jlcall_func_to_llvm("jl_f_new_expr", (void*)&jl_f_new_expr, m);
-    builtin_func_map[jl_f_arraylen] = jlcall_func_to_llvm("jl_f_arraylen", (void*)&jl_f_arraylen, m);
-    builtin_func_map[jl_f_arrayref] = jlcall_func_to_llvm("jl_f_arrayref", (void*)&jl_f_arrayref, m);
-    builtin_func_map[jl_f_arrayset] = jlcall_func_to_llvm("jl_f_arrayset", (void*)&jl_f_arrayset, m);
-    builtin_func_map[jl_f_arraysize] = jlcall_func_to_llvm("jl_f_arraysize", (void*)&jl_f_arraysize, m);
-    builtin_func_map[jl_f_instantiate_type] = jlcall_func_to_llvm("jl_f_instantiate_type", (void*)&jl_f_instantiate_type, m);
+    add_named_global(jlgetbindingorerror_func, &jl_get_binding_or_error);
+
+    jlpref_func = Function::Create(FunctionType::get(T_pjlvalue, two_pvalue_llvmt, false),
+                            Function::ExternalLinkage,
+                            "jl_pointerref", m);
+
+    jlpset_func = Function::Create(FunctionType::get(T_pjlvalue, three_pvalue_llvmt, false),
+                            Function::ExternalLinkage,
+                            "jl_pointerset", m);
+
+
+    builtin_func_map[jl_f_is] = jlcall_func_to_llvm("jl_f_is", &jl_f_is, m);
+    builtin_func_map[jl_f_typeof] = jlcall_func_to_llvm("jl_f_typeof", &jl_f_typeof, m);
+    builtin_func_map[jl_f_sizeof] = jlcall_func_to_llvm("jl_f_sizeof", &jl_f_sizeof, m);
+    builtin_func_map[jl_f_issubtype] = jlcall_func_to_llvm("jl_f_issubtype", &jl_f_issubtype, m);
+    builtin_func_map[jl_f_isa] = jlcall_func_to_llvm("jl_f_isa", &jl_f_isa, m);
+    builtin_func_map[jl_f_typeassert] = jlcall_func_to_llvm("jl_f_typeassert", &jl_f_typeassert, m);
+    builtin_func_map[jl_f__apply] = jlcall_func_to_llvm("jl_f__apply", &jl_f__apply, m);
+    builtin_func_map[jl_f_throw] = jlcall_func_to_llvm("jl_f_throw", &jl_f_throw, m);
+    builtin_func_map[jl_f_tuple] = jlcall_func_to_llvm("jl_f_tuple", &jl_f_tuple, m);
+    builtin_func_map[jl_f_svec] = jlcall_func_to_llvm("jl_f_svec", &jl_f_svec, m);
+    builtin_func_map[jl_f_applicable] = jlcall_func_to_llvm("jl_f_applicable", &jl_f_applicable, m);
+    builtin_func_map[jl_f_invoke] = jlcall_func_to_llvm("jl_f_invoke", &jl_f_invoke, m);
+    builtin_func_map[jl_f_isdefined] = jlcall_func_to_llvm("jl_f_isdefined", &jl_f_isdefined, m);
+    builtin_func_map[jl_f_getfield] = jlcall_func_to_llvm("jl_f_getfield", &jl_f_getfield, m);
+    builtin_func_map[jl_f_setfield] = jlcall_func_to_llvm("jl_f_setfield", &jl_f_setfield, m);
+    builtin_func_map[jl_f_fieldtype] = jlcall_func_to_llvm("jl_f_fieldtype", &jl_f_fieldtype, m);
+    builtin_func_map[jl_f_nfields] = jlcall_func_to_llvm("jl_f_nfields", &jl_f_nfields, m);
+    builtin_func_map[jl_f__expr] = jlcall_func_to_llvm("jl_f__expr", &jl_f__expr, m);
+    builtin_func_map[jl_f_arrayref] = jlcall_func_to_llvm("jl_f_arrayref", &jl_f_arrayref, m);
+    builtin_func_map[jl_f_arrayset] = jlcall_func_to_llvm("jl_f_arrayset", &jl_f_arrayset, m);
+    builtin_func_map[jl_f_arraysize] = jlcall_func_to_llvm("jl_f_arraysize", &jl_f_arraysize, m);
+    builtin_func_map[jl_f_apply_type] = jlcall_func_to_llvm("jl_f_apply_type", &jl_f_apply_type, m);
     jltuple_func = builtin_func_map[jl_f_tuple];
-    jlgetfield_func = builtin_func_map[jl_f_get_field];
-    jlapplygeneric_func = jlcall_func_to_llvm("jl_apply_generic", (void*)&jl_apply_generic, m);
+    jlgetfield_func = builtin_func_map[jl_f_getfield];
+
+    jltypeassert_func = Function::Create(FunctionType::get(T_void, two_pvalue_llvmt, false),
+                                        Function::ExternalLinkage,
+                                        "jl_typeassert", m);
+    add_named_global(jltypeassert_func, &jl_typeassert);
 
     queuerootfun = Function::Create(FunctionType::get(T_void, args_1ptr, false),
                                     Function::ExternalLinkage,
                                     "jl_gc_queue_root", m);
-    add_named_global(queuerootfun, (void*)&jl_gc_queue_root);
+    add_named_global(queuerootfun, &jl_gc_queue_root);
 
-    std::vector<Type *> wbargs(0);
-    wbargs.push_back(jl_pvalue_llvmt);
-    wbargs.push_back(jl_pvalue_llvmt);
-    wbfunc = Function::Create(FunctionType::get(T_void, wbargs, false),
-                              Function::ExternalLinkage,
-                              "jl_gc_wb_slow", m);
-    add_named_global(wbfunc, (void*)&jl_gc_wb_slow);
+    std::vector<Type *> agargs(0);
+    agargs.push_back(T_ppjlvalue);
+    agargs.push_back(T_uint32);
+    jlapplygeneric_func = Function::Create(FunctionType::get(T_pjlvalue, agargs, false),
+                                           Function::ExternalLinkage,
+                                           "jl_apply_generic", m);
+    add_named_global(jlapplygeneric_func, &jl_apply_generic);
 
     std::vector<Type *> exp_args(0);
     exp_args.push_back(T_int1);
     expect_func = Intrinsic::getDeclaration(m, Intrinsic::expect, exp_args);
 
     std::vector<Type*> args3(0);
-    args3.push_back(jl_pvalue_llvmt);
-    jlbox_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, args3, false),
-                         Function::ExternalLinkage,
-                         "jl_new_box", m);
-    add_named_global(jlbox_func, (void*)&jl_new_box);
-
+    args3.push_back(T_pjlvalue);
     jltopeval_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, args3, false),
+        Function::Create(FunctionType::get(T_pjlvalue, args3, false),
                          Function::ExternalLinkage,
                          "jl_toplevel_eval", m);
-    add_named_global(jltopeval_func, (void*)&jl_toplevel_eval);
+    add_named_global(jltopeval_func, &jl_toplevel_eval);
 
     jlcopyast_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, args3, false),
+        Function::Create(FunctionType::get(T_pjlvalue, args3, false),
                          Function::ExternalLinkage,
                          "jl_copy_ast", m);
-    add_named_global(jlcopyast_func, (void*)&jl_copy_ast);
-
-    std::vector<Type*> args4(0);
-    args4.push_back(T_pint8);
-    args4.push_back(jl_pvalue_llvmt);
-    args4.push_back(jl_pvalue_llvmt);
-    jlclosure_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, args4, false),
-                         Function::ExternalLinkage,
-                         "jl_new_closure", m);
-    add_named_global(jlclosure_func, (void*)&jl_new_closure);
+    add_named_global(jlcopyast_func, &jl_copy_ast);
 
     std::vector<Type*> args5(0);
     args5.push_back(T_size);
     jlnsvec_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, args5, true),
+        Function::Create(FunctionType::get(T_pjlvalue, args5, true),
                          Function::ExternalLinkage,
                          "jl_svec", m);
-    add_named_global(jlnsvec_func, (void*)&jl_svec);
+    add_named_global(jlnsvec_func, &jl_svec);
 
     std::vector<Type*> mdargs(0);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(jl_ppvalue_llvmt);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(jl_pvalue_llvmt);
-    mdargs.push_back(T_int32);
+    mdargs.push_back(T_pjlvalue);
+    mdargs.push_back(T_pjlvalue);
+    mdargs.push_back(T_pjlvalue);
     jlmethod_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, mdargs, false),
+        Function::Create(FunctionType::get(T_void, mdargs, false),
                          Function::ExternalLinkage,
                          "jl_method_def", m);
-    add_named_global(jlmethod_func, (void*)&jl_method_def);
+    add_named_global(jlmethod_func, &jl_method_def);
 
     std::vector<Type*> funcdefargs(0);
-    funcdefargs.push_back(jl_pvalue_llvmt);
-    funcdefargs.push_back(jl_ppvalue_llvmt);
-    funcdefargs.push_back(jl_pvalue_llvmt);
-    funcdefargs.push_back(jl_pvalue_llvmt);
+    funcdefargs.push_back(T_pjlvalue);
+    funcdefargs.push_back(T_ppjlvalue);
+    funcdefargs.push_back(T_pjlvalue);
+    funcdefargs.push_back(T_pjlvalue);
     jlgenericfunction_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, funcdefargs, false),
+        Function::Create(FunctionType::get(T_pjlvalue, funcdefargs, false),
                          Function::ExternalLinkage,
                          "jl_generic_function_def", m);
-    add_named_global(jlgenericfunction_func, (void*)&jl_generic_function_def);
+    add_named_global(jlgenericfunction_func, &jl_generic_function_def);
 
     std::vector<Type*> ehargs(0);
     ehargs.push_back(T_pint8);
@@ -5475,31 +5598,33 @@ static void init_julia_llvm_env(Module *m)
         Function::Create(FunctionType::get(T_void, ehargs, false),
                          Function::ExternalLinkage,
                          "jl_enter_handler", m);
-    add_named_global(jlenter_func, (void*)&jl_enter_handler);
+    add_named_global(jlenter_func, &jl_enter_handler);
 
 #ifdef _OS_WINDOWS_
-    resetstkoflw_func = Function::Create(FunctionType::get(T_void, false),
+    resetstkoflw_func = Function::Create(FunctionType::get(T_int32, false),
             Function::ExternalLinkage, "_resetstkoflw", m);
-    add_named_global(resetstkoflw_func, (void*)&_resetstkoflw);
+    add_named_global(resetstkoflw_func, &_resetstkoflw);
+#ifndef FORCE_ELF
 #if defined(_CPU_X86_64_)
 #if defined(_COMPILER_MINGW_)
     Function *chkstk_func = Function::Create(FunctionType::get(T_void, false),
             Function::ExternalLinkage, "___chkstk_ms", m);
-    add_named_global(chkstk_func, (void*)&___chkstk_ms);
+    add_named_global(chkstk_func, &___chkstk_ms, /*dllimport*/false);
 #else
     Function *chkstk_func = Function::Create(FunctionType::get(T_void, false),
             Function::ExternalLinkage, "__chkstk", m);
-    add_named_global(chkstk_func, (void*)&__chkstk);
+    add_named_global(chkstk_func, &__chkstk, /*dllimport*/false);
 #endif
 #else
 #if defined(_COMPILER_MINGW_)
     Function *chkstk_func = Function::Create(FunctionType::get(T_void, false),
             Function::ExternalLinkage, "_alloca", m);
-    add_named_global(chkstk_func, (void*)&_alloca);
+    add_named_global(chkstk_func, &_alloca, /*dllimport*/false);
 #else
     Function *chkstk_func = Function::Create(FunctionType::get(T_void, false),
             Function::ExternalLinkage, "_chkstk", m);
-    add_named_global(chkstk_func, (void*)&_chkstk);
+    add_named_global(chkstk_func, &_chkstk, /*dllimport*/false);
+#endif
 #endif
 #endif
 #endif
@@ -5510,104 +5635,153 @@ static void init_julia_llvm_env(Module *m)
         Function::Create(FunctionType::get(T_void, lhargs, false),
                          Function::ExternalLinkage,
                          "jl_pop_handler", m);
-    add_named_global(jlleave_func, (void*)&jl_pop_handler);
+    add_named_global(jlleave_func, &jl_pop_handler);
 
     std::vector<Type *> args_2vals(0);
-    args_2vals.push_back(jl_pvalue_llvmt);
-    args_2vals.push_back(jl_pvalue_llvmt);
+    args_2vals.push_back(T_pjlvalue);
+    args_2vals.push_back(T_pjlvalue);
     jlegal_func =
         Function::Create(FunctionType::get(T_int32, args_2vals, false),
                          Function::ExternalLinkage,
                          "jl_egal", m);
-    add_named_global(jlegal_func, (void*)&jl_egal);
+    add_named_global(jlegal_func, &jl_egal);
 
     std::vector<Type *> subt_args(0);
-    subt_args.push_back(jl_pvalue_llvmt);
-    subt_args.push_back(jl_pvalue_llvmt);
+    subt_args.push_back(T_pjlvalue);
+    subt_args.push_back(T_pjlvalue);
     subt_args.push_back(T_int32);
     jlsubtype_func =
         Function::Create(FunctionType::get(T_int32, subt_args, false),
                          Function::ExternalLinkage,
                          "jl_subtype", m);
-    add_named_global(jlsubtype_func, (void*)&jl_subtype);
+    add_named_global(jlsubtype_func, &jl_subtype);
 
     std::vector<Type*> aoargs(0);
     aoargs.push_back(T_size);
     jlallocobj_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, aoargs, false),
+        Function::Create(FunctionType::get(T_pjlvalue, aoargs, false),
                          Function::ExternalLinkage,
                          "jl_gc_allocobj", m);
-    add_named_global(jlallocobj_func, (void*)&jl_gc_allocobj);
+    add_named_global(jlallocobj_func, &jl_gc_allocobj);
 
     std::vector<Type*> empty_args(0);
     jlalloc1w_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, empty_args, false),
+        Function::Create(FunctionType::get(T_pjlvalue, empty_args, false),
                          Function::ExternalLinkage,
                          "jl_gc_alloc_1w", m);
-    add_named_global(jlalloc1w_func, (void*)&jl_gc_alloc_1w);
+    add_named_global(jlalloc1w_func, &jl_gc_alloc_1w);
 
     jlalloc2w_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, empty_args, false),
+        Function::Create(FunctionType::get(T_pjlvalue, empty_args, false),
                          Function::ExternalLinkage,
                          "jl_gc_alloc_2w", m);
-    add_named_global(jlalloc2w_func, (void*)&jl_gc_alloc_2w);
+    add_named_global(jlalloc2w_func, &jl_gc_alloc_2w);
 
     jlalloc3w_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, empty_args, false),
+        Function::Create(FunctionType::get(T_pjlvalue, empty_args, false),
                          Function::ExternalLinkage,
                          "jl_gc_alloc_3w", m);
-    add_named_global(jlalloc3w_func, (void*)&jl_gc_alloc_3w);
+    add_named_global(jlalloc3w_func, &jl_gc_alloc_3w);
 
     std::vector<Type*> atargs(0);
     atargs.push_back(T_size);
     jl_alloc_svec_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, atargs, false),
+        Function::Create(FunctionType::get(T_pjlvalue, atargs, false),
                          Function::ExternalLinkage,
                          "jl_alloc_svec", m);
-    add_named_global(jl_alloc_svec_func, (void*)&jl_alloc_svec);
+    add_named_global(jl_alloc_svec_func, &jl_alloc_svec);
 
     std::vector<Type *> dlsym_args(0);
     dlsym_args.push_back(T_pint8);
     dlsym_args.push_back(T_pint8);
     dlsym_args.push_back(PointerType::get(T_pint8,0));
     jldlsym_func =
-        Function::Create(FunctionType::get(T_pint8, dlsym_args, false),
+        Function::Create(FunctionType::get(T_pvoidfunc, dlsym_args, false),
                          Function::ExternalLinkage,
                          "jl_load_and_lookup", m);
-    add_named_global(jldlsym_func, (void*)&jl_load_and_lookup);
+    add_named_global(jldlsym_func, &jl_load_and_lookup);
 
     std::vector<Type *> newbits_args(0);
-    newbits_args.push_back(jl_pvalue_llvmt);
+    newbits_args.push_back(T_pjlvalue);
     newbits_args.push_back(T_pint8);
     jlnewbits_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, newbits_args, false),
+        Function::Create(FunctionType::get(T_pjlvalue, newbits_args, false),
                          Function::ExternalLinkage,
                          "jl_new_bits", m);
-    add_named_global(jlnewbits_func, (void*)&jl_new_bits);
+    add_named_global(jlnewbits_func, &jl_new_bits);
 
     std::vector<Type *> getnthfld_args(0);
-    getnthfld_args.push_back(jl_pvalue_llvmt);
+    getnthfld_args.push_back(T_pjlvalue);
     getnthfld_args.push_back(T_size);
     jlgetnthfieldchecked_func =
-        Function::Create(FunctionType::get(jl_pvalue_llvmt, getnthfld_args, false),
+        Function::Create(FunctionType::get(T_pjlvalue, getnthfld_args, false),
                          Function::ExternalLinkage,
                          "jl_get_nth_field_checked", m);
-    add_named_global(jlgetnthfieldchecked_func, (void*)*jl_get_nth_field_checked);
+    add_named_global(jlgetnthfieldchecked_func, *jl_get_nth_field_checked);
 
     diff_gc_total_bytes_func =
         Function::Create(FunctionType::get(T_int64, false),
                          Function::ExternalLinkage,
                          "jl_gc_diff_total_bytes", m);
-    add_named_global(diff_gc_total_bytes_func, (void*)*jl_gc_diff_total_bytes);
+    add_named_global(diff_gc_total_bytes_func, *jl_gc_diff_total_bytes);
+
+#ifndef LLVM36
+    Type *powf_type[2] = { T_float32, T_float32 };
+    jlpowf_func = Function::Create(FunctionType::get(T_float32, powf_type, false),
+                                   Function::ExternalLinkage,
+                                   "powf", m);
+    add_named_global(jlpowf_func, &powf, false);
+
+    Type *pow_type[2] = { T_float64, T_float64 };
+    jlpow_func = Function::Create(FunctionType::get(T_float64, pow_type, false),
+                                  Function::ExternalLinkage,
+                                  "pow", m);
+    add_named_global(jlpow_func,
+#ifdef _COMPILER_MICROSOFT_
+        static_cast<double (*)(double, double)>(&pow),
+#else
+        &pow,
+#endif
+        false);
+#endif
+
+    gcroot_func =
+        Function::Create(FunctionType::get(T_ppjlvalue, false),
+                     Function::ExternalLinkage,
+                     "julia.gc_root_decl", m);
+    add_named_global(gcroot_func, (void*)NULL, /*dllimport*/false);
+
+    gckill_func =
+        Function::Create(FunctionType::get(T_void, ArrayRef<Type*>(T_ppjlvalue), false),
+                     Function::ExternalLinkage,
+                     "julia.gc_root_kill", m);
+    add_named_global(gckill_func, (void*)NULL, /*dllimport*/false);
+
+    Type* gc_store_args[2] = { T_ppjlvalue, T_pjlvalue }; // [1] <= [2]
+    gcstore_func =
+        Function::Create(FunctionType::get(T_void, makeArrayRef(gc_store_args),  false),
+                     Function::ExternalLinkage,
+                     "julia.gc_store", m);
+    add_named_global(gcstore_func, (void*)NULL, /*dllimport*/false);
+
+    jlcall_frame_func =
+        Function::Create(FunctionType::get(T_ppjlvalue, ArrayRef<Type*>(T_int32), false),
+                     Function::ExternalLinkage,
+                     "julia.jlcall_frame_decl", m);
+    add_named_global(jlcall_frame_func, (void*)NULL, /*dllimport*/false);
 
     // set up optimization passes
+#ifdef LLVM38
+    FPM = new legacy::FunctionPassManager(m);
+#else
     FPM = new FunctionPassManager(m);
+#endif
 
 #ifdef LLVM37
 // No DataLayout pass needed anymore.
-#elif LLVM36
+#elif defined(LLVM36)
     jl_data_layout = new llvm::DataLayoutPass();
-#elif LLVM35
+#elif defined(LLVM35)
     jl_data_layout = new llvm::DataLayoutPass(*jl_ExecutionEngine->getDataLayout());
 #else
     jl_data_layout = new DataLayout(*jl_ExecutionEngine->getDataLayout());
@@ -5616,121 +5790,77 @@ static void init_julia_llvm_env(Module *m)
 #ifndef LLVM37
     FPM->add(jl_data_layout);
 #endif
+    addOptimizationPasses(FPM);
+    FPM->doInitialization();
+}
 
-#ifdef __has_feature
-#   if __has_feature(address_sanitizer)
-    FPM->add(createAddressSanitizerFunctionPass());
-#   endif
-#   if __has_feature(memory_sanitizer)
-    FPM->add(llvm::createMemorySanitizerPass(true));
-#   endif
-#endif
-#ifndef LLVM37
-    jl_TargetMachine->addAnalysisPasses(*FPM);
-#endif
-    FPM->add(createTypeBasedAliasAnalysisPass());
-    if (jl_options.opt_level>=1)
-        FPM->add(createBasicAliasAnalysisPass());
-    // list of passes from vmkit
-    FPM->add(createCFGSimplificationPass()); // Clean up disgusting code
-    FPM->add(createPromoteMemoryToRegisterPass());// Kill useless allocas
-
-#ifndef INSTCOMBINE_BUG
-    FPM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
-#endif
-    FPM->add(createScalarReplAggregatesPass()); // Break up aggregate allocas
-#ifndef INSTCOMBINE_BUG
-    FPM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
-#endif
-    FPM->add(createJumpThreadingPass());        // Thread jumps.
-    // NOTE: CFG simp passes after this point seem to hurt native codegen.
-    // See issue #6112. Should be re-evaluated when we switch to MCJIT.
-    //FPM->add(createCFGSimplificationPass());    // Merge & remove BBs
-#ifndef INSTCOMBINE_BUG
-    FPM->add(createInstructionCombiningPass()); // Combine silly seq's
-#endif
-
-    //FPM->add(createCFGSimplificationPass());    // Merge & remove BBs
-    FPM->add(createReassociatePass());          // Reassociate expressions
-
-    // this has the potential to make some things a bit slower
-    //FPM->add(createBBVectorizePass());
-
-    FPM->add(createEarlyCSEPass()); //// ****
-
-    FPM->add(createLoopIdiomPass()); //// ****
-    FPM->add(createLoopRotatePass());           // Rotate loops.
-    // LoopRotate strips metadata from terminator, so run LowerSIMD afterwards
-    FPM->add(createLowerSimdLoopPass());        // Annotate loop marked with "simdloop" as LLVM parallel loop
-    FPM->add(createLICMPass());                 // Hoist loop invariants
-    FPM->add(createLoopUnswitchPass());         // Unswitch loops.
-    // Subsequent passes not stripping metadata from terminator
-#ifndef INSTCOMBINE_BUG
-    FPM->add(createInstructionCombiningPass());
-#endif
-    FPM->add(createIndVarSimplifyPass());       // Canonicalize indvars
-    FPM->add(createLoopDeletionPass());         // Delete dead loops
-#if LLVM35
-    FPM->add(createSimpleLoopUnrollPass());     // Unroll small loops
-#else
-    FPM->add(createLoopUnrollPass());           // Unroll small loops
-#endif
-#if !LLVM35 && !defined(INSTCOMBINE_BUG)
-    FPM->add(createLoopVectorizePass());        // Vectorize loops
-#endif
-    //FPM->add(createLoopStrengthReducePass());   // (jwb added)
-
-#ifndef INSTCOMBINE_BUG
-    FPM->add(createInstructionCombiningPass()); // Clean up after the unroller
-#endif
-    FPM->add(createGVNPass());                  // Remove redundancies
-    //FPM->add(createMemCpyOptPass());            // Remove memcpy / form memset
-    FPM->add(createSCCPPass());                 // Constant prop with SCCP
-
-    // Run instcombine after redundancy elimination to exploit opportunities
-    // opened up by them.
-    FPM->add(createSinkingPass()); ////////////// ****
-    FPM->add(createInstructionSimplifierPass());///////// ****
-#ifndef INSTCOMBINE_BUG
-    FPM->add(createInstructionCombiningPass());
-#endif
-    FPM->add(createJumpThreadingPass());         // Thread jumps
-    FPM->add(createDeadStoreEliminationPass());  // Delete dead stores
-#if !defined(INSTCOMBINE_BUG)
-    if (jl_options.opt_level>=1)
-        FPM->add(createSLPVectorizerPass());     // Vectorize straight-line code
-#endif
-
-    FPM->add(createAggressiveDCEPass());         // Delete dead instructions
-#if !defined(INSTCOMBINE_BUG)
-    if (jl_options.opt_level>=1)
-        FPM->add(createInstructionCombiningPass());   // Clean up after SLP loop vectorizer
-#endif
-#if LLVM35
-    FPM->add(createLoopVectorizePass());         // Vectorize loops
-    FPM->add(createInstructionCombiningPass());  // Clean up after loop vectorizer
+// Helper to figure out what features to set for the LLVM target
+// If the user specifies native ( or does not specify ) we default
+// using the API provided by LLVM
+static inline SmallVector<std::string,10> getTargetFeatures() {
+  StringMap<bool> HostFeatures;
+  if( !strcmp(jl_options.cpu_target,"native") )
+  {
+    // On earlier versions of LLVM this is empty
+    llvm::sys::getHostCPUFeatures(HostFeatures);
+  }
+
+  // Platform specific overides follow
+#if defined(_CPU_X86_64_) || defined(_CPU_X86_)
+#ifndef USE_MCJIT
+    // Temporarily disable Haswell BMI2 features due to LLVM bug.
+  HostFeatures["bmi2"] = false;
+  HostFeatures["avx2"] = false;
 #endif
-    //FPM->add(createCFGSimplificationPass());     // Merge & remove BBs
-
-    FPM->doInitialization();
+#ifdef V128_BUG
+  HostFeatures["avx"] = false;
+#endif
+#endif
+
+  // Figure out if we know the cpu_target
+  std::string cpu = strcmp(jl_options.cpu_target,"native") ? jl_options.cpu_target : sys::getHostCPUName();
+  if (cpu.empty() || cpu == "generic") {
+    jl_printf(JL_STDERR, "WARNING: unable to determine host cpu name.\n");
+#if defined(_CPU_ARM_) && defined(__ARM_PCS_VFP)
+    // Check if this is required when you have read the features directly from the processor
+    // This affects the platform calling convention.
+    // TODO: enable vfp3 for ARMv7+ (but adapt the ABI)
+    HostFeatures["vfp2"] = true;
+#endif
+  }
+
+  SmallVector<std::string,10> attr;
+  for( StringMap<bool>::const_iterator it = HostFeatures.begin(); it != HostFeatures.end(); it++  )
+  {
+    std::string att = it->getValue() ? it->getKey().str() :
+                      std::string("-") + it->getKey().str();
+    attr.append( 1, att );
+  }
+  return attr;
 }
 
+extern "C" void jl_init_debuginfo(void);
+
 extern "C" void jl_init_codegen(void)
 {
+    const char *const argv_tailmerge[] = {"", "-enable-tail-merge=0"}; // NOO TOUCHIE; NO TOUCH! See #922
+    cl::ParseCommandLineOptions(sizeof(argv_tailmerge)/sizeof(argv_tailmerge[0]), argv_tailmerge, "disable-tail-merge\n");
 #if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_)
-    const char *const argv[] = {"", "-disable-copyprop"}; // llvm bug 21743
-    cl::ParseCommandLineOptions(sizeof(argv)/sizeof(argv[0]), argv, "disable-copyprop\n");
+    const char *const argv_copyprop[] = {"", "-disable-copyprop"}; // llvm bug 21743
+    cl::ParseCommandLineOptions(sizeof(argv_copyprop)/sizeof(argv_copyprop[0]), argv_copyprop, "disable-copyprop\n");
 #endif
 #ifdef JL_DEBUG_BUILD
     cl::ParseEnvironmentOptions("Julia", "JULIA_LLVM_ARGS");
 #endif
+
 #if defined(_CPU_PPC_) || defined(_CPU_PPC64_)
     imaging_mode = true; // LLVM seems to JIT bad TOC tables for the optimizations we attempt in non-imaging_mode
 #else
     imaging_mode = jl_generating_output();
 #endif
+    jl_init_debuginfo();
 
-#if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR <= 3
+#ifndef LLVM34
     // this option disables LLVM's signal handlers
     llvm::DisablePrettyStackTrace = true;
 #endif
@@ -5743,17 +5873,20 @@ extern "C" void jl_init_codegen(void)
 
 #ifdef USE_MCJIT
     m = shadow_module = new Module("shadow", jl_LLVMContext);
-    jl_setup_module(shadow_module,false);
+    builtins_module = new Module("julia_builtins", jl_LLVMContext);
     if (imaging_mode) {
         engine_module = new Module("engine_module", jl_LLVMContext);
-        jl_setup_module(engine_module,false);
+        active_module = shadow_module;
     }
     else {
+        active_module = new Module("julia", jl_LLVMContext);
         engine_module = m;
+#ifdef USE_ORCJIT
+        engine_module = new Module("engine_module", jl_LLVMContext);
+#endif
     }
 #else
     engine_module = m = jl_Module = new Module("julia", jl_LLVMContext);
-    jl_setup_module(engine_module,false);
 #endif
 
     TargetOptions options = TargetOptions();
@@ -5777,24 +5910,9 @@ extern "C" void jl_init_codegen(void)
     // turn on JIT support for libunwind to walk the stack
     options.JITExceptionHandling = 1;
 #endif
-#ifdef USE_MCJIT
-    jl_mcjmm = new SectionMemoryManager();
-#endif
-    const char *mattr[] = {
-#if defined(_CPU_X86_64_) || defined(_CPU_X86_)
-#ifndef USE_MCJIT
-        // Temporarily disable Haswell BMI2 features due to LLVM bug.
-        "-bmi2", "-avx2",
-#endif
-#ifdef V128_BUG
-        "-avx",
-#endif
-#endif
-        "", // padding to make sure this isn't an empty array (ref #11817)
-    };
-    SmallVector<std::string, 4> MAttrs(mattr, mattr+sizeof(mattr)/sizeof(mattr[0]));
+
 #ifdef LLVM36
-    EngineBuilder eb(std::move(std::unique_ptr<Module>(engine_module)));
+    EngineBuilder eb((std::unique_ptr<Module>(engine_module)));
 #else
     EngineBuilder eb(engine_module);
 #endif
@@ -5803,17 +5921,30 @@ extern "C" void jl_init_codegen(void)
 #if defined(_OS_WINDOWS_) && defined(_CPU_X86_64_) && !defined(USE_MCJIT)
         .setJITMemoryManager(createJITMemoryManagerWin())
 #elif defined(CUSTOM_MEMORY_MANAGER)
-        .setMCJITMemoryManager(std::move(std::unique_ptr<RTDyldMemoryManager>{createRTDyldMemoryManagerOSX()}))
-#elif defined(USE_ORCJIT) // ORCJIT forgets to create one if one isn't created for it
-        .setMCJITMemoryManager(std::move(std::unique_ptr<RTDyldMemoryManager>{new SectionMemoryManager()}))
+        .setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>{CUSTOM_MEMORY_MANAGER()})
+#elif defined(USE_ORCMCJIT) // ORCJIT forgets to create one if one isn't created for it
+        .setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>{new SectionMemoryManager()})
 #endif
         .setTargetOptions(options)
+#if (defined(_OS_LINUX_) && defined(_CPU_X86_64_)) || defined(CODEGEN_TLS)
         .setRelocationModel(Reloc::PIC_)
+#else
+        .setRelocationModel(Reloc::Default)
+#endif
+#ifdef CODEGEN_TLS
         .setCodeModel(CodeModel::Small)
+#else
+        .setCodeModel(CodeModel::JITDefault)
+#endif
+#ifdef DISABLE_OPT
+        .setOptLevel(CodeGenOpt::None)
+#else
+        .setOptLevel(CodeGenOpt::Aggressive)
+#endif
 #if defined(USE_MCJIT) && !defined(LLVM36)
         .setUseMCJIT(true)
 #endif
-#ifdef USE_ORCJIT
+#ifdef USE_ORCMCJIT
         .setUseOrcMCJITReplacement(true)
 #endif
     ;
@@ -5826,48 +5957,22 @@ extern "C" void jl_init_codegen(void)
 #endif
 #endif
     std::string TheCPU = strcmp(jl_options.cpu_target,"native") ? jl_options.cpu_target : sys::getHostCPUName();
-    if (TheCPU.empty() || TheCPU == "generic") {
-        jl_printf(JL_STDERR, "WARNING: unable to determine host cpu name.\n");
-#ifdef _CPU_ARM_
-        MAttrs.append(1, "+vfp2"); // the processors that don't have VFP are old and (hopefully) rare. this affects the platform calling convention.
-#endif
-    }
-    TargetMachine *targetMachine = eb.selectTarget(
+    SmallVector<std::string, 10>  targetFeatures = getTargetFeatures( );
+    jl_TargetMachine = eb.selectTarget(
             TheTriple,
             "",
             TheCPU,
-            MAttrs);
-    assert(targetMachine && "Failed to select target machine -"
-                            " Is the LLVM backend for this CPU enabled?");
-    jl_TargetMachine = targetMachine->getTarget().createTargetMachine(
-            TheTriple.getTriple(),
-            targetMachine->getTargetCPU(),
-            targetMachine->getTargetFeatureString(),
-            targetMachine->Options,
-#ifdef CODEGEN_TLS
-            Reloc::PIC_,
-            CodeModel::Small,
-#else
-            Reloc::Default,
-            CodeModel::JITDefault,
+            targetFeatures);
+    assert(jl_TargetMachine && "Failed to select target machine -"
+                               " Is the LLVM backend for this CPU enabled?");
+#if defined(USE_MCJIT) && !defined(_CPU_ARM_)
+    // FastISel seems to be buggy for ARM. Ref #13321
+    jl_TargetMachine->setFastISel(true);
 #endif
-#ifdef DISABLE_OPT
-            CodeGenOpt::None
-#else
-            CodeGenOpt::Aggressive // -O3
-#endif
-            );
-    delete targetMachine;
-    assert(jl_TargetMachine);
-#if defined(LLVM38)
-    engine_module->setDataLayout(jl_TargetMachine->createDataLayout());
-#elif defined(LLVM36) && !defined(LLVM37)
-    engine_module->setDataLayout(jl_TargetMachine->getSubtargetImpl()->getDataLayout());
-#elif defined(LLVM35) && !defined(LLVM37)
-    engine_module->setDataLayout(jl_TargetMachine->getDataLayout());
+
+#ifdef USE_ORCJIT
+    jl_ExecutionEngine = new JuliaOJIT(*jl_TargetMachine);
 #else
-    engine_module->setDataLayout(jl_TargetMachine->getDataLayout()->getStringRepresentation());
-#endif
     jl_ExecutionEngine = eb.create(jl_TargetMachine);
     //jl_printf(JL_STDERR,"%s\n",jl_ExecutionEngine->getDataLayout()->getStringRepresentation().c_str());
     if (!jl_ExecutionEngine) {
@@ -5875,35 +5980,44 @@ extern "C" void jl_init_codegen(void)
                   ErrorStr.c_str());
         exit(1);
     }
-#if defined(LLVM35) && !defined(USE_ORCJIT)
+#if defined(LLVM35) && !defined(USE_ORCMCJIT)
     jl_ExecutionEngine->setProcessAllSections(true);
 #endif
     jl_ExecutionEngine->DisableLazyCompilation();
+#endif
+
     mbuilder = new MDBuilder(getGlobalContext());
 
-#ifdef LLVM37
-#ifdef LLVM38
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout().getStringRepresentation());
-    engine_module->setDataLayout(jl_ExecutionEngine->getDataLayout().getStringRepresentation());
+    // Now that the execution engine exists, initialize all modules
+#ifdef USE_MCJIT
+    jl_setup_module(engine_module);
+    jl_setup_module(shadow_module);
+    jl_setup_module(active_module);
+    jl_setup_module(builtins_module);
 #else
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout()->getStringRepresentation());
-    engine_module->setDataLayout(jl_ExecutionEngine->getDataLayout()->getStringRepresentation());
+    jl_setup_module(engine_module);
 #endif
-    m->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
-    engine_module->setTargetTriple(jl_TargetMachine->getTargetTriple().str());
-#elif LLVM36
-    m->setDataLayout(jl_ExecutionEngine->getDataLayout());
-    engine_module->setDataLayout(jl_ExecutionEngine->getDataLayout());
-#endif
-    init_julia_llvm_env(m);
 
-    RegisterJuliaJITEventListener();
+    if (imaging_mode)
+        init_julia_llvm_env(shadow_module);
+    else
+        init_julia_llvm_env(builtins_module);
+
+#ifndef USE_ORCJIT
+    jl_ExecutionEngine->RegisterJITEventListener(CreateJuliaJITEventListener());
 #ifdef JL_USE_INTEL_JITEVENTS
     if (jl_using_intel_jitevents)
         jl_ExecutionEngine->RegisterJITEventListener(
             JITEventListener::createIntelJITEventListener());
 #endif // JL_USE_INTEL_JITEVENTS
 
+#ifdef JL_USE_OPROFILE_JITEVENTS
+    if (jl_using_oprofile_jitevents)
+        jl_ExecutionEngine->RegisterJITEventListener(
+            JITEventListener::createOProfileJITEventListener());
+#endif // JL_USE_OPROFILE_JITEVENTS
+#endif
+
     BOX_F(int8,int8);  UBOX_F(uint8,uint8);
     BOX_F(int16,int16); UBOX_F(uint16,uint16);
     BOX_F(int32,int32); UBOX_F(uint32,uint32);
@@ -5912,14 +6026,15 @@ extern "C" void jl_init_codegen(void)
     BOX_F(char,char);
     UBOX_F(gensym,size);
 
-    box8_func  = boxfunc_llvm(ft2arg(jl_pvalue_llvmt, jl_pvalue_llvmt, T_int8),
-                              "jl_box8", (void*)&jl_box8, m);
-    box16_func = boxfunc_llvm(ft2arg(jl_pvalue_llvmt, jl_pvalue_llvmt, T_int16),
-                              "jl_box16", (void*)&jl_box16, m);
-    box32_func = boxfunc_llvm(ft2arg(jl_pvalue_llvmt, jl_pvalue_llvmt, T_int32),
-                              "jl_box32", (void*)&jl_box32, m);
-    box64_func = boxfunc_llvm(ft2arg(jl_pvalue_llvmt, jl_pvalue_llvmt, T_int64),
-                              "jl_box64", (void*)&jl_box64, m);
+    box8_func  = boxfunc_llvm(ft2arg(T_pjlvalue, T_pjlvalue, T_int8),
+                              "jl_box8", &jl_box8, m);
+    box16_func = boxfunc_llvm(ft2arg(T_pjlvalue, T_pjlvalue, T_int16),
+                              "jl_box16", &jl_box16, m);
+    box32_func = boxfunc_llvm(ft2arg(T_pjlvalue, T_pjlvalue, T_int32),
+                              "jl_box32", &jl_box32, m);
+    box64_func = boxfunc_llvm(ft2arg(T_pjlvalue, T_pjlvalue, T_int64),
+                              "jl_box64", &jl_box64, m);
+    jl_init_intrinsic_functions_codegen(m);
 }
 
 // for debugging from gdb
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
index 86e1fbe1979c3..1eae157f8f686 100644
--- a/src/debuginfo.cpp
+++ b/src/debuginfo.cpp
@@ -7,17 +7,21 @@
 #include <llvm/ExecutionEngine/JITEventListener.h>
 #include <llvm/DebugInfo/DIContext.h>
 #ifdef LLVM37
-#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include <llvm/DebugInfo/DWARF/DWARFContext.h>
+#include <llvm/Object/SymbolSize.h>
 #endif
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/IR/Function.h>
 #include <llvm/ADT/StringRef.h>
+#include <llvm/ADT/StringMap.h>
 #ifdef LLVM35
 #include <llvm/IR/DebugInfo.h>
 #else
 #include <llvm/DebugInfo.h>
 #endif
-#ifdef USE_MCJIT
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+#include <llvm/IR/DataLayout.h>
+#include <llvm/IR/Mangler.h>
 #ifndef LLVM36
 #include <llvm/ExecutionEngine/ObjectImage.h>
 #endif
@@ -41,6 +45,10 @@
 
 #include "julia.h"
 #include "julia_internal.h"
+#ifdef _OS_LINUX_
+#  define UNW_LOCAL_ONLY
+#  include <libunwind.h>
+#endif
 
 #include <string>
 #include <sstream>
@@ -52,37 +60,67 @@
 #include <cassert>
 using namespace llvm;
 
-extern DLLEXPORT ExecutionEngine *jl_ExecutionEngine;
+#if defined(LLVM35) && !defined(LLVM36)
+extern ExecutionEngine *jl_ExecutionEngine;
+#endif
 
 #ifdef USE_MCJIT
 typedef object::SymbolRef SymRef;
 #endif
 
+static uv_rwlock_t threadsafe;
+
+extern "C" void jl_init_debuginfo()
+{
+    uv_rwlock_init(&threadsafe);
+}
+
 // --- storing and accessing source location metadata ---
 
 #ifndef USE_MCJIT
 struct FuncInfo {
-    const Function* func;
+    const Function *func;
     size_t lengthAdr;
-    std::string name;
-    std::string filename;
     std::vector<JITEvent_EmittedFunctionDetails::LineStart> lines;
+    jl_lambda_info_t *linfo;
 };
 #else
 struct ObjectInfo {
-    const object::ObjectFile* object;
-    size_t SectionSize;
+    const object::ObjectFile *object;
+    size_t size;
 #ifdef LLVM37
     const llvm::LoadedObjectInfo *L;
 #elif defined(LLVM36)
     size_t slide;
 #endif
-#ifdef _OS_DARWIN_
+#if defined(_OS_DARWIN_) && !defined(LLVM37)
     const char *name;
 #endif
+    jl_lambda_info_t *linfo;
 };
 #endif
 
+// Maintain a mapping of unrealized function names -> linfo objects
+// so that when we see it get emitted, we can add a link back to the linfo
+// that it came from (providing name, type signature, file info, etc.)
+static StringMap<jl_lambda_info_t*> linfo_in_flight;
+static std::string mangle(const std::string &Name, const DataLayout &DL) {
+#if defined(USE_MCJIT) || defined(USE_ORCJIT)
+    std::string MangledName;
+    {
+        raw_string_ostream MangledNameStream(MangledName);
+        Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
+    }
+    return MangledName;
+#else
+    return Name;
+#endif
+}
+void jl_add_linfo_in_flight(StringRef name, jl_lambda_info_t *linfo, const DataLayout &DL)
+{
+    linfo_in_flight[mangle(name, DL)] = linfo;
+}
+
 #if defined(_OS_WINDOWS_)
 #if defined(_CPU_X86_64_)
 extern "C" EXCEPTION_DISPOSITION _seh_exception_handler(PEXCEPTION_RECORD ExceptionRecord,void *EstablisherFrame, PCONTEXT ContextRecord, void *DispatcherContext);
@@ -184,15 +222,28 @@ class JuliaJITEventListener: public JITEventListener
     virtual void NotifyFunctionEmitted(const Function &F, void *Code,
                                        size_t Size, const EmittedFunctionDetails &Details)
     {
+        int8_t gc_state = jl_gc_safe_enter();
+        uv_rwlock_wrlock(&threadsafe);
+        jl_gc_safe_leave(gc_state);
+        StringMap<jl_lambda_info_t*>::iterator linfo_it = linfo_in_flight.find(F.getName());
+        jl_lambda_info_t *linfo = NULL;
+        if (linfo_it != linfo_in_flight.end()) {
+            linfo = linfo_it->second;
+            linfo_in_flight.erase(linfo_it);
+        }
 #if defined(_OS_WINDOWS_)
         create_PRUNTIME_FUNCTION((uint8_t*)Code, Size, F.getName(), (uint8_t*)Code, Size, NULL);
 #endif
-        FuncInfo tmp = {&F, Size, F.getName().str(), std::string(), Details.LineStarts};
+        FuncInfo tmp = {&F, Size, Details.LineStarts, linfo};
         info[(size_t)(Code)] = tmp;
+        uv_rwlock_wrunlock(&threadsafe);
     }
 
     std::map<size_t, FuncInfo, revcomp>& getMap()
     {
+        int8_t gc_state = jl_gc_safe_enter();
+        uv_rwlock_rdlock(&threadsafe);
+        jl_gc_safe_leave(gc_state);
         return info;
     }
 #endif // ifndef USE_MCJIT
@@ -201,90 +252,77 @@ class JuliaJITEventListener: public JITEventListener
 #ifdef LLVM36
     virtual void NotifyObjectEmitted(const object::ObjectFile &obj,
                                      const RuntimeDyld::LoadedObjectInfo &L)
+    {
+        return _NotifyObjectEmitted(obj,obj,L);
+    }
+
+    virtual void _NotifyObjectEmitted(const object::ObjectFile &obj,
+                                     const object::ObjectFile &debugObj,
+                                     const RuntimeDyld::LoadedObjectInfo &L)
 #else
     virtual void NotifyObjectEmitted(const ObjectImage &obj)
 #endif
     {
-        uint64_t Addr;
-        uint64_t Size;
-        object::SymbolRef::Type SymbolType;
+        int8_t gc_state = jl_gc_safe_enter();
+        uv_rwlock_wrlock(&threadsafe);
+        jl_gc_safe_leave(gc_state);
 #ifdef LLVM36
         object::section_iterator Section = obj.section_begin();
         object::section_iterator EndSection = obj.section_end();
-        uint64_t SectionAddr = 0;
-        StringRef sName;
 #else
         object::section_iterator Section = obj.begin_sections();
         object::section_iterator EndSection = obj.end_sections();
-        bool isText;
-#ifndef _OS_LINUX_
-        StringRef sName;
-#endif
 #endif
 
-#ifndef LLVM36
-        uint64_t SectionAddr = 0;
-#endif
-        uint64_t SectionSize = 0;
-        uint64_t SectionAddrCheck = 0; // assert that all of the Sections are at the same location
-
 #if defined(_OS_WINDOWS_)
-#if defined(_CPU_X86_64_)
+        uint64_t SectionAddrCheck = 0; // assert that all of the Sections are at the same location
         uint8_t *UnwindData = NULL;
+#if defined(_CPU_X86_64_)
         uint8_t *catchjmp = NULL;
         for (const object::SymbolRef &sym_iter : obj.symbols()) {
-#  ifdef LLVM37
+            StringRef sName;
+#ifdef LLVM37
             sName = sym_iter.getName().get();
-#  else
+#else
             sym_iter.getName(sName);
-#  endif
+#endif
+            uint8_t **pAddr = NULL;
             if (sName.equals("__UnwindData")) {
-#  ifdef LLVM37
+                pAddr = &UnwindData;
+            }
+            else if (sName.equals("__catchjmp")) {
+                pAddr = &catchjmp;
+            }
+            if (pAddr) {
+                uint64_t Addr, SectionAddr;
+#if defined(LLVM38)
                 Addr = sym_iter.getAddress().get();
-#  else
-                sym_iter.getAddress(Addr);
-#  endif
-                sym_iter.getSection(Section);
-#  ifdef LLVM36
-                assert(Section->isText());
-#    ifdef LLVM38
+                Section = sym_iter.getSection().get();
+                assert(Section != EndSection && Section->isText());
                 SectionAddr = L.getSectionLoadAddress(*Section);
-#    else
+#elif defined(LLVM37)
+                Addr = sym_iter.getAddress().get();
+                sym_iter.getSection(Section);
+                assert(Section != EndSection && Section->isText());
                 Section->getName(sName);
                 SectionAddr = L.getSectionLoadAddress(sName);
-#    endif
-                Addr += SectionAddr;
-#  else
-                if (Section->isText(isText) || !isText) assert(0 && "!isText");
-                Section->getAddress(SectionAddr);
-#  endif
-                UnwindData = (uint8_t*)Addr;
-                if (SectionAddrCheck)
-                    assert(SectionAddrCheck == SectionAddr);
-                else
-                    SectionAddrCheck = SectionAddr;
-            }
-            if (sName.equals("__catchjmp")) {
-#  ifdef LLVM37
-                Addr = sym_iter.getAddress().get();
-#  else
+#elif defined(LLVM36)
                 sym_iter.getAddress(Addr);
-#  endif
                 sym_iter.getSection(Section);
-#  ifdef LLVM36
-                assert(Section->isText());
-#    ifdef LLVM38
-                SectionAddr = L.getSectionLoadAddress(*Section);
-#    else
+                assert(Section != EndSection && Section->isText());
                 Section->getName(sName);
                 SectionAddr = L.getSectionLoadAddress(sName);
-#    endif
-                Addr += SectionAddr;
-#  else
-                if (Section->isText(isText) || !isText) assert(0 && "!isText");
+#else // LLVM35
+                sym_iter.getAddress(Addr);
+                sym_iter.getSection(Section);
+                assert(Section != EndSection);
+                assert(!Section->isText(isText) && isText);
                 Section->getAddress(SectionAddr);
-#  endif
-                catchjmp = (uint8_t*)Addr;
+#endif
+#ifdef LLVM36
+                Addr += SectionAddr;
+#endif
+                *pAddr = (uint8_t*)Addr;
                 if (SectionAddrCheck)
                     assert(SectionAddrCheck == SectionAddr);
                 else
@@ -293,6 +331,7 @@ class JuliaJITEventListener: public JITEventListener
         }
         assert(catchjmp);
         assert(UnwindData);
+        assert(SectionAddrCheck);
         catchjmp[0] = 0x48;
         catchjmp[1] = 0xb8; // mov RAX, QWORD PTR [&_seh_exception_handle]
         *(uint64_t*)(&catchjmp[2]) = (uint64_t)&_seh_exception_handler;
@@ -306,79 +345,100 @@ class JuliaJITEventListener: public JITEventListener
         UnwindData[5] = 0x03; // mov RBP, RSP
         UnwindData[6] = 1;    // first instruction
         UnwindData[7] = 0x50; // push RBP
-        *(DWORD*)&UnwindData[8] = (DWORD)(catchjmp - (uint8_t*)SectionAddr); // relative location of catchjmp
-#else // defined(_OS_X86_64_)
-        uint8_t *UnwindData = NULL;
+        *(DWORD*)&UnwindData[8] = (DWORD)(catchjmp - (uint8_t*)SectionAddrCheck); // relative location of catchjmp
 #endif // defined(_OS_X86_64_)
 #endif // defined(_OS_WINDOWS_)
 
-#ifdef LLVM35
+#ifdef LLVM37
+        auto symbols = object::computeSymbolSizes(obj);
+        for(const auto &sym_size : symbols) {
+            const object::SymbolRef &sym_iter = sym_size.first;
+            object::SymbolRef::Type SymbolType = sym_iter.getType();
+            if (SymbolType != object::SymbolRef::ST_Function) continue;
+            uint64_t Size = sym_size.second;
+            uint64_t Addr = sym_iter.getAddress().get();
+#ifdef LLVM38
+            Section = sym_iter.getSection().get();
+#else
+            sym_iter.getSection(Section);
+#endif
+            if (Section == EndSection) continue;
+            if (!Section->isText()) continue;
+#ifdef LLVM38
+            uint64_t SectionAddr = L.getSectionLoadAddress(*Section);
+#else
+            StringRef secName;
+            Section->getName(secName);
+            uint64_t SectionAddr = L.getSectionLoadAddress(secName);
+#endif
+            Addr += SectionAddr;
+            StringRef sName = sym_iter.getName().get();
+#if defined(_OS_WINDOWS_)
+            uint64_t SectionSize = Section->getSize();
+            if (SectionAddrCheck)
+                assert(SectionAddrCheck == SectionAddr);
+            else
+                SectionAddrCheck = SectionAddr;
+            create_PRUNTIME_FUNCTION(
+                   (uint8_t*)(intptr_t)Addr, (size_t)Size, sName,
+                   (uint8_t*)(intptr_t)SectionAddr, (size_t)SectionSize, UnwindData);
+#endif
+            StringMap<jl_lambda_info_t*>::iterator linfo_it = linfo_in_flight.find(sName);
+            jl_lambda_info_t *linfo = NULL;
+            if (linfo_it != linfo_in_flight.end()) {
+                linfo = linfo_it->second;
+                linfo_in_flight.erase(linfo_it);
+            }
+            ObjectInfo tmp = {&debugObj, (size_t)Size, L.clone().release(), linfo};
+            objectmap[Addr] = tmp;
+        }
+
+#else // pre-LLVM37
+        uint64_t Addr;
+        uint64_t Size;
+        object::SymbolRef::Type SymbolType;
+        StringRef sName;
+#ifdef LLVM36
+        uint64_t SectionAddr = 0;
+#else
+        bool isText;
+#ifdef _OS_WINDOWS_
+        uint64_t SectionAddr = 0;
+#endif
+#endif
+
+#if defined(LLVM35)
         for (const object::SymbolRef &sym_iter : obj.symbols()) {
-#           ifdef LLVM37
-                SymbolType = sym_iter.getType();
-#           else
-                sym_iter.getType(SymbolType);
-#           endif
+            sym_iter.getType(SymbolType);
             if (SymbolType != object::SymbolRef::ST_Function) continue;
-#           ifdef LLVM37
-                Addr = sym_iter.getAddress().get();
-#           else
-                sym_iter.getAddress(Addr);
-#           endif
-#           ifdef LLVM38
-                Section = sym_iter.getSection().get();
-#           else
-                sym_iter.getSection(Section);
-#           endif
+            sym_iter.getSize(Size);
+            sym_iter.getAddress(Addr);
+            sym_iter.getSection(Section);
             if (Section == EndSection) continue;
 #if defined(LLVM36)
             if (!Section->isText()) continue;
-#    ifdef LLVM38
-            SectionAddr = L.getSectionLoadAddress(*Section);
-#    else
             Section->getName(sName);
             SectionAddr = L.getSectionLoadAddress(sName);
-#    endif
             Addr += SectionAddr;
 #else
             if (Section->isText(isText) || !isText) continue;
 #endif
-#if defined(LLVM36)
-            SectionSize = Section->getSize();
-#else
-            Section->getAddress(SectionAddr);
-            Section->getSize(SectionSize);
-#endif
-#ifdef _OS_DARWIN_
-#   if defined(LLVM37)
-            Size = Section->getSize();
-            sName = sym_iter.getName().get();
-#   else
             sym_iter.getName(sName);
-#   endif
-#   if defined(LLVM36)
-            if (sName[0] == '_') {
-                sName = sName.substr(1);
-            }
-#   else
+#ifdef _OS_DARWIN_
+#   if !defined(LLVM36)
             Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName, true);
             if (!Addr && sName[0] == '_') {
-                sName = sName.substr(1);
-                Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName, true);
+                Addr = ((MCJIT*)jl_ExecutionEngine)->getSymbolAddress(sName.substr(1), true);
             }
             if (!Addr) continue;
 #   endif
 #elif defined(_OS_WINDOWS_)
-#   if defined(LLVM37)
-            assert(obj.isELF());
-            Size = ((llvm::object::ELFSymbolRef)sym_iter).getSize();
-            sName = sym_iter.getName().get();
+            uint64_t SectionSize = 0;
+#   if defined(LLVM36)
+            SectionSize = Section->getSize();
 #   else
-            sym_iter.getSize(Size);
-            sym_iter.getName(sName);
-#   endif
-#   ifdef _CPU_X86_
-            if (sName[0] == '_') sName = sName.substr(1);
+            Section->getAddress(SectionAddr);
+            Section->getSize(SectionSize);
 #   endif
             if (SectionAddrCheck)
                 assert(SectionAddrCheck == SectionAddr);
@@ -388,21 +448,28 @@ class JuliaJITEventListener: public JITEventListener
                    (uint8_t*)(intptr_t)Addr, (size_t)Size, sName,
                    (uint8_t*)(intptr_t)SectionAddr, (size_t)SectionSize, UnwindData);
 #endif
+            StringMap<jl_lambda_info_t*>::iterator linfo_it = linfo_in_flight.find(sName);
+            jl_lambda_info_t *linfo = NULL;
+            if (linfo_it != linfo_in_flight.end()) {
+                linfo = linfo_it->second;
+                linfo_in_flight.erase(linfo_it);
+            }
             const object::ObjectFile *objfile =
 #ifdef LLVM36
                 &obj;
 #else
                 obj.getObjectFile();
 #endif
-            ObjectInfo tmp = {objfile, SectionSize
+            ObjectInfo tmp = {objfile, (size_t)Size,
 #ifdef LLVM37
-                ,L.clone().release()
+                L.clone().release(),
 #elif defined(LLVM36)
-                ,(size_t)SectionAddr
+                (size_t)SectionAddr,
 #endif
 #ifdef _OS_DARWIN_
-                ,strndup(sName.data(), sName.size())
+                strndup(sName.data(), sName.size()),
 #endif
+                linfo
             };
             objectmap[Addr] = tmp;
         }
@@ -420,6 +487,8 @@ class JuliaJITEventListener: public JITEventListener
             objectmap[Addr] = tmp;
         }
 #endif
+#endif
+        uv_rwlock_wrunlock(&threadsafe);
     }
 
     // must implement if we ever start freeing code
@@ -428,14 +497,29 @@ class JuliaJITEventListener: public JITEventListener
 
     std::map<size_t, ObjectInfo, revcomp>& getObjectMap()
     {
+        int8_t gc_state = jl_gc_safe_enter();
+        uv_rwlock_rdlock(&threadsafe);
+        jl_gc_safe_leave(gc_state);
         return objectmap;
     }
 #endif // USE_MCJIT
 };
 
+#ifdef USE_ORCJIT
+JL_DLLEXPORT void ORCNotifyObjectEmitted(JITEventListener *Listener,
+                                         const object::ObjectFile &obj,
+                                         const object::ObjectFile &debugObj,
+                                         const RuntimeDyld::LoadedObjectInfo &L)
+{
+    ((JuliaJITEventListener*)Listener)->_NotifyObjectEmitted(obj,debugObj,L);
+}
+#endif
+
 extern "C"
 char *jl_demangle(const char *name)
 {
+    // This function is not allowed to reference any TLS variables since
+    // it can be called from an unmanaged thread on OSX.
     const char *start = name + 6;
     const char *end = name + strlen(name);
     char *ret;
@@ -454,19 +538,21 @@ char *jl_demangle(const char *name)
     return strdup(name);
 }
 
-JuliaJITEventListener *jl_jit_events;
-void RegisterJuliaJITEventListener()
+static JuliaJITEventListener *jl_jit_events;
+JITEventListener *CreateJuliaJITEventListener()
 {
     jl_jit_events = new JuliaJITEventListener();
-    jl_ExecutionEngine->RegisterJITEventListener(jl_jit_events);
+    return jl_jit_events;
 }
 
 // *name and *filename are either NULL or malloc'd pointers
-void lookup_pointer(DIContext *context, char **name, size_t *line,
-                    char **filename, size_t *inlinedat_line,
-                    char **inlinedat_file, size_t pointer,
-                    int demangle, int *fromC)
+static void lookup_pointer(DIContext *context, char **name, size_t *line,
+                           char **filename, size_t *inlinedat_line,
+                           char **inlinedat_file, size_t pointer,
+                           int demangle, int *fromC)
 {
+    // This function is not allowed to reference any TLS variables since
+    // it can be called from an unmanaged thread on OSX.
     DILineInfo info, topinfo;
     DIInliningInfo inlineinfo;
     if (demangle && *name != NULL) {
@@ -523,8 +609,8 @@ void lookup_pointer(DIContext *context, char **name, size_t *line,
 #endif
 
 done:
-    // If this is a jlcall wrapper, set fromC to match JIT behavior
-    if (*name == NULL || memcmp(*name, "jlcall_",7) == 0) {
+    // If this is a jlcall or jlcapi wrapper, set fromC to match JIT behavior
+    if (*name == NULL || !strncmp(*name, "jlcall_", 7) || !strncmp(*name, "jlcapi_", 7)) {
         *fromC = true;
     }
 }
@@ -544,9 +630,8 @@ typedef std::map<uint64_t, objfileentry_t> obfiletype;
 static obfiletype objfilemap;
 
 #ifdef _OS_DARWIN_
-bool getObjUUID(llvm::object::MachOObjectFile *obj, uint8_t uuid[16])
+static bool getObjUUID(llvm::object::MachOObjectFile *obj, uint8_t uuid[16])
 {
-
 # ifdef LLVM37
     for (auto Load : obj->load_commands ()) {
 # else
@@ -581,13 +666,25 @@ bool getObjUUID(llvm::object::MachOObjectFile *obj, uint8_t uuid[16])
 }
 #endif
 
-extern "C" uint64_t jl_sysimage_base;
+static uint64_t jl_sysimage_base;
+static void **sysimg_fvars;
+static jl_lambda_info_t **sysimg_fvars_linfo;
+static size_t sysimg_fvars_n;
+extern "C" void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_lambda_info_t **linfos, size_t n)
+{
+    jl_sysimage_base = sysimage_base;
+    sysimg_fvars = fptrs;
+    sysimg_fvars_linfo = linfos;
+    sysimg_fvars_n = n;
+}
 
 // *name and *filename should be either NULL or malloc'd pointer
-void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
-                             char** inlinedat_file, size_t *inlinedat_line,
-                             size_t pointer, int *fromC, int skipC, int skipInline)
+static void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
+                                    char **inlinedat_file, size_t *inlinedat_line, jl_lambda_info_t **outer_linfo,
+                                    size_t pointer, int *fromC, int skipC, int skipInline)
 {
+    // This function is not allowed to reference any TLS variables since
+    // it can be called from an unmanaged thread on OSX.
 #ifdef _OS_WINDOWS_
     IMAGEHLP_MODULE64 ModuleInfo;
     BOOL isvalid;
@@ -613,6 +710,7 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
         DWORD dwDisplacement = 0;
         DWORD64 dwDisplacement64 = 0;
         DWORD64 dwAddress = pointer;
+        void *saddr = NULL;
         PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)frame_info_func;
         pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
         pSymbol->MaxNameLen = MAX_SYM_NAME;
@@ -621,6 +719,7 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
                         pSymbol)) {
             // SymFromAddr returned success
             jl_copy_str(name, pSymbol->Name);
+            saddr = (void*)(uintptr_t)pSymbol->Address;
         }
         else {
             // SymFromAddr failed
@@ -645,6 +744,7 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
     if ((dladdr((void*)pointer, &dlinfo) != 0) && dlinfo.dli_fname) {
         const char *fname;
         uint64_t fbase = (uint64_t)dlinfo.dli_fbase;
+        void *saddr = dlinfo.dli_saddr;
 #if defined(_OS_DARWIN_)
         size_t msize = (size_t)(((uint64_t)-1)-fbase);
 #endif
@@ -663,6 +763,7 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
         obfiletype::iterator it = objfilemap.find(fbase);
         llvm::object::ObjectFile *obj = NULL;
         if (it == objfilemap.end()) {
+            // TODO: need write lock here for objfilemap syncronization
 #if defined(_OS_DARWIN_)
 #ifdef LLVM36
            std::unique_ptr<MemoryBuffer> membuf = MemoryBuffer::getMemBuffer(
@@ -688,7 +789,7 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
             }
 #ifdef LLVM36
             llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile *)origerrorobj.get().release();
-#elif LLVM35
+#elif defined(LLVM35)
             llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile *)origerrorobj.get();
 #else
             llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile *)origerrorobj;
@@ -724,11 +825,11 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
 #endif
 #endif // ifdef _OS_DARWIN_
             if (errorobj) {
-#if LLVM36
+#ifdef LLVM36
                 auto binary = errorobj.get().takeBinary();
                 obj = binary.first.release();
                 binary.second.release();
-#elif LLVM35
+#elif defined(LLVM35)
                 obj = errorobj.get();
 #else
                 obj = errorobj;
@@ -738,7 +839,7 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
 #endif
 #ifdef LLVM37
                     context = new DWARFContextInMemory(*obj);
-#elif LLVM36
+#elif defined(LLVM36)
                     context = DIContext::getDWARFContext(*obj);
 #else
                     context = DIContext::getDWARFContext(obj);
@@ -769,7 +870,6 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
                 }
 #endif
 #endif
-
             }
             objfileentry_t entry = {obj,context,slide};
             objfilemap[fbase] = entry;
@@ -785,6 +885,22 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
 #endif
         lookup_pointer(context, name, line, filename, inlinedat_line, inlinedat_file, pointer+slide,
                        fbase == jl_sysimage_base, fromC);
+        if (jl_sysimage_base == fbase && sysimg_fvars) {
+#ifdef _OS_LINUX_
+            unw_proc_info_t pip;
+            if (!saddr && unw_get_proc_info_by_ip(unw_local_addr_space,
+                                                  pointer, &pip, NULL) == 0)
+                saddr = (void*)pip.start_ip;
+#endif
+            if (saddr) {
+                for (size_t i = 0; i < sysimg_fvars_n; i++) {
+                    if (saddr == sysimg_fvars[i]) {
+                        *outer_linfo = sysimg_fvars_linfo[i];
+                        break;
+                    }
+                }
+            }
+        }
     }
     else {
         *fromC = 1;
@@ -793,29 +909,29 @@ void jl_getDylibFunctionInfo(char **name, char **filename, size_t *line,
 
 // Set *name and *filename to either NULL or malloc'd string
 void jl_getFunctionInfo(char **name, char **filename, size_t *line,
-                        char **inlinedat_file, size_t *inlinedat_line,
+                        char **inlinedat_file, size_t *inlinedat_line, jl_lambda_info_t **outer_linfo,
                         size_t pointer, int *fromC, int skipC, int skipInline)
 {
+    // This function is not allowed to reference any TLS variables since
+    // it can be called from an unmanaged thread on OSX.
     *name = NULL;
     *line = -1;
     *filename = NULL;
     *inlinedat_file = NULL;
     *inlinedat_line = -1;
+    *outer_linfo = NULL;
     *fromC = 0;
 
 #ifdef USE_MCJIT
     // With MCJIT we can get function information directly from the ObjectFile
-    std::map<size_t, ObjectInfo, revcomp> &objmap =
-        jl_jit_events->getObjectMap();
+    std::map<size_t, ObjectInfo, revcomp> &objmap = jl_jit_events->getObjectMap();
     std::map<size_t, ObjectInfo, revcomp>::iterator it =
         objmap.lower_bound(pointer);
 
     if (it != objmap.end() &&
-        (intptr_t)(*it).first + (*it).second.SectionSize > pointer) {
+        (intptr_t)(*it).first + (*it).second.size > pointer) {
+        *outer_linfo = (*it).second.linfo;
 #if defined(_OS_DARWIN_) && !defined(LLVM37)
-        // *name should always be NULL here, free it anyway just to be more
-        // robust
-        free(*name);
         *name = jl_demangle((*it).second.name);
         DIContext *context = NULL; // versions of MCJIT < 3.7 can't handle MachO relocations
 #else
@@ -832,7 +948,6 @@ void jl_getFunctionInfo(char **name, char **filename, size_t *line,
 #endif
         lookup_pointer(context, name, line, filename, inlinedat_line, inlinedat_file, pointer, 1, fromC);
         delete context;
-        return;
     }
 
 #else // !USE_MCJIT
@@ -846,17 +961,20 @@ void jl_getFunctionInfo(char **name, char **filename, size_t *line,
             // Technically not true, but we don't want them
             // in julia backtraces, so close enough
             *fromC = 1;
+            uv_rwlock_rdunlock(&threadsafe);
             return;
         }
 
-        jl_copy_str(name, (*it).second.name.c_str());
-        jl_copy_str(filename, (*it).second.filename.c_str());
+        jl_copy_str(name, (*it).second.func->getName().str().c_str());
+        jl_copy_str(filename, "");
 
         if ((*it).second.lines.empty()) {
             *fromC = 1;
+            uv_rwlock_rdunlock(&threadsafe);
             return;
         }
 
+        *outer_linfo = (*it).second.linfo;
         std::vector<JITEvent_EmittedFunctionDetails::LineStart>::iterator vit =
             (*it).second.lines.begin();
         JITEvent_EmittedFunctionDetails::LineStart prev = *vit;
@@ -870,7 +988,8 @@ void jl_getFunctionInfo(char **name, char **filename, size_t *line,
             // subprogram.
             if (debugscope.getName().data() != NULL) {
                 jl_copy_str(name, debugscope.getName().str().c_str());
-            } else {
+            }
+            else {
                 char *oldname = *name;
                 *name = jl_demangle(*name);
                 free(oldname);
@@ -901,21 +1020,25 @@ void jl_getFunctionInfo(char **name, char **filename, size_t *line,
             jl_copy_str(inlinedat_file, inlinescope.getFilename().str().c_str());
             *inlinedat_line = inlineloc.getLine();
         }
-
-        return;
     }
 #endif // USE_MCJIT
-    jl_getDylibFunctionInfo(name, filename, line, inlinedat_file, inlinedat_line, pointer, fromC, skipC, skipInline);
+
+    else {
+        jl_getDylibFunctionInfo(name, filename, line, inlinedat_file, inlinedat_line, outer_linfo, pointer, fromC, skipC, skipInline);
+    }
+
+    uv_rwlock_rdunlock(&threadsafe);
 }
 
 int jl_get_llvmf_info(uint64_t fptr, uint64_t *symsize, uint64_t *slide,
 #ifdef USE_MCJIT
-    const object::ObjectFile **object
+                      const object::ObjectFile **object
 #else
-    std::vector<JITEvent_EmittedFunctionDetails::LineStart> *lines
+                      std::vector<JITEvent_EmittedFunctionDetails::LineStart> *lines
 #endif
-    )
+                      )
 {
+    int found = 0;
 #ifndef USE_MCJIT
     std::map<size_t, FuncInfo, revcomp> &fmap = jl_jit_events->getMap();
     std::map<size_t, FuncInfo, revcomp>::iterator fit = fmap.find(fptr);
@@ -924,27 +1047,54 @@ int jl_get_llvmf_info(uint64_t fptr, uint64_t *symsize, uint64_t *slide,
         *symsize = fit->second.lengthAdr;
         *lines = fit->second.lines;
         *slide = 0;
-        return 1;
+        found = 1;
     }
-    return 0;
 #else // MCJIT version
     std::map<size_t, ObjectInfo, revcomp> &objmap = jl_jit_events->getObjectMap();
     std::map<size_t, ObjectInfo, revcomp>::iterator fit = objmap.find(fptr);
 
     if (fit != objmap.end()) {
-        *symsize = fit->second.SectionSize;
+        *symsize = fit->second.size;
         *object = fit->second.object;
 #if defined(LLVM36) && !defined(LLVM37)
         *slide = fit->second.slide;
 #else
         *slide = 0;
 #endif
-        return 1;
+        found = 1;
     }
-    return 0;
 #endif
+    uv_rwlock_rdunlock(&threadsafe);
+    return found;
 }
 
+#if defined(LLVM37) && (defined(_OS_LINUX_) || (defined(_OS_DARWIN_) && defined(LLVM_SHLIB)))
+extern "C" void __register_frame(void*);
+extern "C" void __deregister_frame(void*);
+
+template <typename callback>
+static const char *processFDE(const char *Entry, callback f)
+{
+    const char *P = Entry;
+    uint32_t Length = *((const uint32_t *)P);
+    P += 4;
+    uint32_t Offset = *((const uint32_t *)P);
+    if (Offset != 0) {
+        f(Entry);
+    }
+    return P + Length;
+}
+
+template <typename callback>
+static void processFDEs(const char *EHFrameAddr, size_t EHFrameSize, callback f)
+{
+    const char *P = (const char*)EHFrameAddr;
+    const char *End = P + EHFrameSize;
+    do  {
+        P = processFDE(P, f);
+    } while(P != End);
+}
+#endif
 
 #if defined(_OS_DARWIN_) && defined(LLVM37) && defined(LLVM_SHLIB)
 
@@ -959,94 +1109,436 @@ int jl_get_llvmf_info(uint64_t fptr, uint64_t *symsize, uint64_t *slide,
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 class RTDyldMemoryManagerOSX : public SectionMemoryManager
 {
-  RTDyldMemoryManagerOSX(const RTDyldMemoryManagerOSX&) = delete;
-  void operator=(const RTDyldMemoryManagerOSX&) = delete;
+    RTDyldMemoryManagerOSX(const RTDyldMemoryManagerOSX&) = delete;
+    void operator=(const RTDyldMemoryManagerOSX&) = delete;
 
 public:
     RTDyldMemoryManagerOSX() {};
     ~RTDyldMemoryManagerOSX() override {};
     void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
-    void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size);
+    void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
 };
 
-extern "C" void __register_frame(void*);
-extern "C" void __deregister_frame(void*);
-
 static void (*libc_register_frame)(void*)   = NULL;
 static void (*libc_deregister_frame)(void*) = NULL;
 
-static const char *processFDE(const char *Entry, bool isDeregister)
+// This implementation handles frame registration for local targets.
+// Memory managers for remote targets should re-implement this function
+// and use the LoadAddr parameter.
+void RTDyldMemoryManagerOSX::registerEHFrames(uint8_t *Addr,
+                                              uint64_t LoadAddr,
+                                              size_t Size)
 {
-    const char *P = Entry;
-    uint32_t Length = *((const uint32_t *)P);
-    P += 4;
-    uint32_t Offset = *((const uint32_t *)P);
-    if (Offset != 0) {
-        if (isDeregister) {
-            if (!libc_deregister_frame) {
-                libc_deregister_frame = (void(*)(void*))dlsym(RTLD_NEXT,"__deregister_frame");
+  // On OS X OS X __register_frame takes a single FDE as an argument.
+  // See http://lists.cs.uiuc.edu/pipermail/llvmdev/2013-April/061768.html
+  processFDEs((char*)Addr, Size, [](const char *Entry) {
+        if (!libc_register_frame) {
+          libc_register_frame = (void(*)(void*))dlsym(RTLD_NEXT,"__register_frame");
+        }
+        assert(libc_register_frame);
+        libc_register_frame(const_cast<char *>(Entry));
+        __register_frame(const_cast<char *>(Entry));
+    });
+}
+
+void RTDyldMemoryManagerOSX::deregisterEHFrames(uint8_t *Addr,
+                                                uint64_t LoadAddr,
+                                                size_t Size)
+{
+   processFDEs((char*)Addr, Size, [](const char *Entry) {
+        if (!libc_deregister_frame) {
+          libc_deregister_frame = (void(*)(void*))dlsym(RTLD_NEXT,"__deregister_frame");
+        }
+        assert(libc_deregister_frame);
+        libc_deregister_frame(const_cast<char *>(Entry));
+        __deregister_frame(const_cast<char *>(Entry));
+    });
+}
+
+RTDyldMemoryManager* createRTDyldMemoryManagerOSX()
+{
+    return new RTDyldMemoryManagerOSX();
+}
+
+#endif
+
+#if defined(_OS_LINUX_) && defined(LLVM37) && defined(JL_UNW_HAS_FORMAT_IP)
+#include <type_traits>
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+class RTDyldMemoryManagerUnix : public SectionMemoryManager
+{
+    RTDyldMemoryManagerUnix(const RTDyldMemoryManagerUnix&) = delete;
+    void operator=(const RTDyldMemoryManagerUnix&) = delete;
+
+public:
+    RTDyldMemoryManagerUnix() {};
+    ~RTDyldMemoryManagerUnix() override {};
+    void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
+    void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
+};
+
+struct unw_table_entry
+{
+    int32_t start_ip_offset;
+    int32_t fde_offset;
+};
+
+// Skip over an arbitrary long LEB128 encoding.
+// Return the pointer to the first unprocessed byte.
+static const uint8_t *consume_leb128(const uint8_t *Addr, const uint8_t *End)
+{
+    const uint8_t *P = Addr;
+    while ((*P >> 7) != 0 && P < End)
+        ++P;
+    return P + 1;
+}
+
+// Parse a LEB128 encoding to a type T. Truncate the result if there's more
+// bytes than what there are more bytes than what the type can store.
+// Adjust the pointer to the first unprocessed byte.
+template<typename T> static T parse_leb128(const uint8_t *&Addr,
+                                           const uint8_t *End)
+{
+    typedef typename std::make_unsigned<T>::type uT;
+    uT v = 0;
+    for (unsigned i = 0;i < ((sizeof(T) * 8 - 1) / 7 + 1);i++) {
+        uint8_t a = *Addr;
+        Addr++;
+        v |= uT(a & 0x7f) << (i * 7);
+        if ((a & 0x80) == 0 || Addr >= End) {
+            if (a & 0x40 && std::is_signed<T>::value) {
+                int valid_bits = (i + 1) * 7;
+                if (valid_bits < 64) {
+                    v |= -(uT(1) << valid_bits);
+                }
             }
-            assert(libc_deregister_frame);
-            libc_deregister_frame(const_cast<char *>(Entry));
-            __deregister_frame(const_cast<char *>(Entry));
+            return T(v);
         }
-        else {
-            if (!libc_register_frame) {
-                libc_register_frame = (void(*)(void*))dlsym(RTLD_NEXT,"__register_frame");
+    }
+    Addr = consume_leb128(Addr, End);
+    return T(v);
+}
+
+template <typename U, typename T>
+static U safe_trunc(T t)
+{
+    assert((t >= static_cast<T>(std::numeric_limits<U>::min()))
+           && (t <= static_cast<T>(std::numeric_limits<U>::max())));
+    return static_cast<U>(t);
+}
+
+// How the address and size in the FDE are encoded.
+enum DW_EH_PE : uint8_t {
+    DW_EH_PE_absptr = 0x00, /* An absolute pointer. The size is determined by
+                             * whether this is a 32-bit or 64-bit address space,
+                             * and will be 32 or 64 bits */
+    DW_EH_PE_omit = 0xff, // The value is omitted
+    DW_EH_PE_uleb128 = 0x01, // The value is an unsigned LEB128
+    DW_EH_PE_udata2 = 0x02,
+    DW_EH_PE_udata4 = 0x03,
+    DW_EH_PE_udata8 = 0x04, /* The value is stored as unsigned data with the
+                             * specified number of bytes. */
+    DW_EH_PE_signed = 0x08, /* A signed number. The size is determined by
+                             * whether this is a 32-bit or 64-bit address space */
+    DW_EH_PE_sleb128 = 0x09, /* A signed LEB128. */
+    DW_EH_PE_sdata2 = 0x0a,
+    DW_EH_PE_sdata4 = 0x0b,
+    DW_EH_PE_sdata8 = 0x0c, /* The value is stored as signed data with the
+                             * specified number of bytes. */
+
+    // In addition the above basic encodings, there are modifiers.
+
+    DW_EH_PE_pcrel = 0x10, // Value is PC relative.
+
+    // We currently don't support the following once.
+    DW_EH_PE_textrel = 0x20, // Value is text relative.
+    DW_EH_PE_datarel = 0x30, // Value is data relative.
+    DW_EH_PE_funcrel = 0x40, // Value is relative to start of function.
+    DW_EH_PE_aligned = 0x50, /* Value is aligned: padding bytes are inserted as
+                              * required to make value be naturally aligned. */
+    DW_EH_PE_indirect = 0x80 /* This is actually the address of the real value. */
+};
+
+// Parse the CIE and return the type of encoding used by FDE
+static DW_EH_PE parseCIE(const uint8_t *Addr, const uint8_t *End)
+{
+    // http://www.airs.com/blog/archives/460
+    // Length (4 bytes)
+    uint32_t cie_size = *(const uint32_t*)Addr;
+    const uint8_t *cie_addr = Addr + 4;
+    const uint8_t *p = cie_addr;
+    const uint8_t *cie_end = cie_addr + cie_size;
+    assert(cie_end <= End);
+    // Check this is an CIE record (CIE ID: 4 bytes)
+    assert(*(const uint32_t*)cie_addr == 0);
+    p += 4;
+    // Check CIE version (1 byte)
+    uint8_t cie_version = *p;
+    assert(cie_version == 1 || cie_version == 3);
+    p++;
+    // Augmentation String (NUL terminate)
+    const char *augmentation = (const char*)p;
+    size_t augmentation_len = strlen(augmentation);
+    // Assume there's no EH Data field, which exist when the augmentation
+    // string has "eh" in it.
+    p += augmentation_len + 1;
+    // Code Alignment Factor (1 byte) should always be 1
+    assert(*p == 1);
+    p++;
+    // Data Alignment Factor (LEB128)
+    assert(cie_end >= p);
+    p = consume_leb128(p, cie_end);
+    // return address register
+    if (cie_version == 1) {
+        p++;
+    }
+    else {
+        p = consume_leb128(p, cie_end);
+    }
+    // Now it's the augmentation data. which may have the information we
+    // are interested in...
+    for (const char *augp = augmentation;;augp++) {
+        switch (*augp) {
+        case 'z':
+            // Augmentation Length
+            p = consume_leb128(p, cie_end);
+            break;
+        case 'L':
+            // LSDA encoding
+            p++;
+            break;
+        case 'R':
+            // .... the only one we care about ....
+            return static_cast<DW_EH_PE>(*p);
+        case 'P': {
+            // Personality data
+            // Encoding
+            auto encoding = static_cast<DW_EH_PE>(*p);
+            p++;
+            // Personality function
+            switch (encoding & 0xf) {
+            case DW_EH_PE_uleb128:
+            case DW_EH_PE_sleb128:
+                p = consume_leb128(p, cie_end);
+                break;
+            case DW_EH_PE_udata2:
+            case DW_EH_PE_sdata2:
+                p += 2;
+                break;
+            case DW_EH_PE_udata4:
+            case DW_EH_PE_sdata4:
+                p += 4;
+                break;
+            case DW_EH_PE_udata8:
+            case DW_EH_PE_sdata8:
+                p += 8;
+                break;
+            case DW_EH_PE_signed:
+                p += sizeof(void*);
+                break;
+            default:
+                if (encoding == DW_EH_PE_absptr || encoding == DW_EH_PE_omit) {
+                    p += sizeof(void*);
+                }
+                else {
+                    assert(0 && "Invalid personality encoding.");
+                }
+                break;
             }
-            assert(libc_register_frame);
-            libc_register_frame(const_cast<char *>(Entry));
-            __register_frame(const_cast<char *>(Entry));
         }
+            break;
+        default:
+            continue;
+        }
+        assert(cie_end >= p);
     }
-    return P + Length;
+    return DW_EH_PE_absptr;
 }
 
-// This implementation handles frame registration for local targets.
-// Memory managers for remote targets should re-implement this function
-// and use the LoadAddr parameter.
-void RTDyldMemoryManagerOSX::registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size)
+void RTDyldMemoryManagerUnix::registerEHFrames(uint8_t *Addr,
+                                               uint64_t LoadAddr,
+                                               size_t Size)
 {
-    // On OS X OS X __register_frame takes a single FDE as an argument.
-    // See http://lists.cs.uiuc.edu/pipermail/llvmdev/2013-April/061768.html
-    const char *P = (const char *)Addr;
-    const char *End = P + Size;
-    do  {
-        P = processFDE(P, false);
-    } while(P != End);
+#ifndef _CPU_ARM_
+    // System unwinder
+    // Linux uses setjmp/longjmp exception handling on ARM.
+    __register_frame(Addr);
+#endif
+    // Our unwinder
+    unw_dyn_info_t *di = new unw_dyn_info_t;
+    // In a shared library, this is set to the address of the PLT.
+    // For us, just put 0 to emulate a static library. This field does
+    // not seem to be used on our supported architectures.
+    di->gp = 0;
+    // I'm not a great fan of the naming of this constant, but it means the
+    // right thing, which is a table of FDEs and ips.
+    di->format = UNW_INFO_FORMAT_IP_OFFSET;
+    di->u.ti.name_ptr = 0;
+    di->u.ti.segbase = (unw_word_t)Addr;
+    // Now first count the number of FDEs
+    size_t nentries = 0;
+    processFDEs((char*)Addr, Size, [&](const char*){ nentries++; });
+
+    uintptr_t start_ip = (uintptr_t)-1;
+    uintptr_t end_ip = 0;
+
+    // Then allocate a table and fill in the information
+    // While we're at it, also record the start_ip and size,
+    // which we fill in the table
+    unw_table_entry *table = new unw_table_entry[nentries];
+    std::vector<uintptr_t> start_ips(nentries);
+    size_t cur_entry = 0;
+    // Cache the previously parsed CIE entry so that we can support multiple
+    // CIE's (may not happen) without parsing it everytime.
+    const uint8_t *cur_cie = nullptr;
+    DW_EH_PE encoding = DW_EH_PE_omit;
+    processFDEs((char*)Addr, Size, [&](const char *Entry) {
+            // Skip Length (4bytes) and CIE offset (4bytes)
+            uint32_t fde_size = *(const uint32_t*)Entry;
+            uint32_t cie_id = ((const uint32_t*)Entry)[1];
+            const uint8_t *cie_addr = (const uint8_t*)(Entry + 4 - cie_id);
+            if (cie_addr != cur_cie)
+                encoding = parseCIE(cie_addr, Addr + Size);
+            const uint8_t *fde_end = (const uint8_t*)(Entry + 4 + fde_size);
+            const uint8_t *EntryPtr = (const uint8_t*)(Entry + 8);
+            uintptr_t start = 0;
+            uintptr_t size = 0;
+            // The next two fields are address and size of the PC range
+            // covered by this FDE.
+            if (encoding == DW_EH_PE_absptr || encoding == DW_EH_PE_omit) {
+                assert(fde_size >= 2 * sizeof(void*) + 4);
+                start = *(const uintptr_t*)EntryPtr;
+                size = *(const uintptr_t*)(EntryPtr + sizeof(void*));
+            }
+            else {
+                uintptr_t baseptr = (uintptr_t)EntryPtr;
+                // Only support pcrel for now...
+                assert((encoding & 0xf0) == 0x10 &&
+                       "Only pcrel mode is supported");
+                switch (encoding & 0xf) {
+                case DW_EH_PE_uleb128:
+                    start = baseptr + parse_leb128<uintptr_t>(EntryPtr, fde_end);
+                    size = parse_leb128<uintptr_t>(EntryPtr, fde_end);
+                    break;
+                case DW_EH_PE_udata2:
+                    assert(fde_size >= 2 * 2 + 4);
+                    start = baseptr + ((const uint16_t*)EntryPtr)[0];
+                    size = ((const uint16_t*)EntryPtr)[1];
+                    break;
+                case DW_EH_PE_udata4:
+                    assert(fde_size >= 2 * 4 + 4);
+                    start = baseptr + ((const uint32_t*)EntryPtr)[0];
+                    size = ((const uint32_t*)EntryPtr)[1];
+                    break;
+                case DW_EH_PE_udata8:
+                    assert(fde_size >= 2 * 8 + 4);
+                    start = uintptr_t(baseptr + ((const uint64_t*)EntryPtr)[0]);
+                    size = uintptr_t(((const uint64_t*)EntryPtr)[1]);
+                    break;
+                case DW_EH_PE_signed:
+                    assert(fde_size >= 2 * sizeof(void*) + 4);
+                    start = baseptr + ((const intptr_t*)EntryPtr)[0];
+                    size = ((const intptr_t*)EntryPtr)[1];
+                    break;
+                case DW_EH_PE_sleb128:
+                    start = baseptr + parse_leb128<intptr_t>(EntryPtr, fde_end);
+                    size = parse_leb128<intptr_t>(EntryPtr, fde_end);
+                    break;
+                case DW_EH_PE_sdata2:
+                    assert(fde_size >= 2 * 2 + 4);
+                    start = baseptr + ((const int16_t*)EntryPtr)[0];
+                    size = ((const int16_t*)EntryPtr)[1];
+                    break;
+                case DW_EH_PE_sdata4:
+                    assert(fde_size >= 2 * 4 + 4);
+                    start = baseptr + ((const int32_t*)EntryPtr)[0];
+                    size = ((const int32_t*)EntryPtr)[1];
+                    break;
+                case DW_EH_PE_sdata8:
+                    assert(fde_size >= 2 * 8 + 4);
+                    start = uintptr_t(baseptr + ((const int64_t*)EntryPtr)[0]);
+                    size = uintptr_t(((const int64_t*)EntryPtr)[1]);
+                    break;
+                default:
+                    assert(0 && "Invalid FDE encoding.");
+                    break;
+                }
+            }
+
+            if (start < start_ip)
+                start_ip = start;
+            if (end_ip < (start + size))
+                end_ip = start+size;
+            table[cur_entry].fde_offset =
+                safe_trunc<int32_t>((intptr_t)Entry - (intptr_t)Addr);
+            start_ips[cur_entry] = start;
+            cur_entry++;
+        });
+    for (size_t i = 0;i < nentries;i++) {
+        table[i].start_ip_offset =
+            safe_trunc<int32_t>((intptr_t)start_ips[i] - (intptr_t)start_ip);
+    }
+    assert(end_ip != 0);
+
+    di->u.ti.table_len = nentries;
+    di->u.ti.table_data = (unw_word_t*)table;
+    di->start_ip = start_ip;
+    di->end_ip = end_ip;
+
+    JL_SIGATOMIC_BEGIN();
+    _U_dyn_register(di);
+    JL_SIGATOMIC_END();
 }
 
-void RTDyldMemoryManagerOSX::deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size)
+void RTDyldMemoryManagerUnix::deregisterEHFrames(uint8_t *Addr,
+                                           uint64_t LoadAddr,
+                                           size_t Size)
 {
-    const char *P = (const char *)Addr;
-    const char *End = P + Size;
-    do  {
-        P = processFDE(P, true);
-    } while(P != End);
+#ifndef _CPU_ARM_
+    __deregister_frame(Addr);
+#endif
+    // Deregistering with our unwinder requires a lookup table to find the
+    // the allocated entry above (or we could look in libunwind's internal
+    // data structures).
 }
 
-RTDyldMemoryManager* createRTDyldMemoryManagerOSX()
+RTDyldMemoryManager* createRTDyldMemoryManagerUnix()
 {
-    return new RTDyldMemoryManagerOSX();
+    return new RTDyldMemoryManagerUnix();
 }
 
 #endif
 
-#if defined(_OS_WINDOWS_)
 #ifdef USE_MCJIT
 extern "C"
-DWORD64 jl_getUnwindInfo(ULONG64 dwAddr)
+uint64_t jl_getUnwindInfo(uint64_t dwAddr)
 {
     std::map<size_t, ObjectInfo, revcomp> &objmap = jl_jit_events->getObjectMap();
     std::map<size_t, ObjectInfo, revcomp>::iterator it = objmap.lower_bound(dwAddr);
-    if (it != objmap.end() && (intptr_t)(*it).first + (*it).second.SectionSize > dwAddr) {
-        return (DWORD64)(intptr_t)(*it).first;
+    uint64_t ipstart = 0; // ip of the first instruction in the function (if found)
+    if (it != objmap.end() && (intptr_t)(*it).first + (*it).second.size > dwAddr) {
+        ipstart = (uint64_t)(intptr_t)(*it).first;
+    }
+    uv_rwlock_rdunlock(&threadsafe);
+    return ipstart;
+}
+#else
+extern "C"
+uint64_t jl_getUnwindInfo(uint64_t dwAddr)
+{
+    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
+    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound(dwAddr);
+    uint64_t ipstart = 0; // ip of the first instruction in the function (if found)
+    if (it != info.end() && (intptr_t)(*it).first + (*it).second.lengthAdr > dwAddr) {
+        ipstart = (uint64_t)(intptr_t)(*it).first;
     }
-    return 0;
+    uv_rwlock_rdunlock(&threadsafe);
+    return ipstart;
 }
+#endif
 
-#else //ifdef USE_MCJIT
-#if defined(_CPU_X86_64_)
+
+#if defined(_OS_WINDOWS_) && !defined(USE_MCJIT) && defined(_CPU_X86_64_)
 // Custom memory manager for exception handling on Windows
 // we overallocate 48 bytes at the end of each function
 // for unwind information (see NotifyFunctionEmitted)
@@ -1072,7 +1564,7 @@ class JITMemoryManagerWin : public JITMemoryManager {
         ActualSize -= 48;
         return mem;
     }
-    virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize, unsigned Alignment)
+    virtual uint8_t *allocateStub(const GlobalValue *F, unsigned StubSize, unsigned Alignment)
     {
         return JMM->allocateStub(F,StubSize,Alignment);
     }
@@ -1084,7 +1576,7 @@ class JITMemoryManagerWin : public JITMemoryManager {
     virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) { return JMM->allocateSpace(Size,Alignment); }
     virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) { return JMM->allocateGlobal(Size,Alignment); }
     virtual void deallocateFunctionBody(void *Body) { return JMM->deallocateFunctionBody(Body); }
-    virtual uint8_t *startExceptionTable(const Function* F,
+    virtual uint8_t *startExceptionTable(const Function *F,
                                          uintptr_t &ActualSize) { return JMM->startExceptionTable(F,ActualSize); }
     virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
                                    uint8_t *TableEnd, uint8_t *FrameRegister) { return JMM->endExceptionTable(F,TableStart,TableEnd,FrameRegister); }
@@ -1130,21 +1622,8 @@ class JITMemoryManagerWin : public JITMemoryManager {
     virtual bool applyPermissions(std::string *ErrMsg = 0) { return JMM->applyPermissions(ErrMsg); }
     virtual void registerEHFrames(StringRef SectionData) { return JMM->registerEHFrames(SectionData); }
 };
-JITMemoryManager* createJITMemoryManagerWin()
+JITMemoryManager *createJITMemoryManagerWin()
 {
     return new JITMemoryManagerWin();
 }
-#else
-extern "C"
-DWORD64 jl_getUnwindInfo(ULONG64 dwAddr)
-{
-    std::map<size_t, FuncInfo, revcomp> &info = jl_jit_events->getMap();
-    std::map<size_t, FuncInfo, revcomp>::iterator it = info.lower_bound(dwAddr);
-    if (it != info.end() && (intptr_t)(*it).first + (*it).second.lengthAdr > dwAddr) {
-        return (DWORD64)(intptr_t)(*it).first;
-    }
-    return 0;
-}
-#endif
-#endif
 #endif
diff --git a/src/disasm.cpp b/src/disasm.cpp
index bfc3d41ff7bf4..c6c91adb2d44f 100644
--- a/src/disasm.cpp
+++ b/src/disasm.cpp
@@ -19,6 +19,7 @@
 
 #include <cstdio>
 #include <cstring>
+#include <iomanip>
 #include <iostream>
 #include <map>
 #include <set>
@@ -29,7 +30,6 @@
 #include <llvm/Object/ObjectFile.h>
 #include <llvm/Support/MachO.h>
 #include <llvm/Support/COFF.h>
-#include <llvm/MC/MCDisassembler.h>
 #include <llvm/MC/MCInst.h>
 #include <llvm/MC/MCStreamer.h>
 #include <llvm/MC/MCSubtargetInfo.h>
@@ -45,11 +45,18 @@
 #include <llvm/MC/MCInstrAnalysis.h>
 #include <llvm/MC/MCSymbol.h>
 #ifdef LLVM35
-#include <llvm/AsmParser/Parser.h>
-#include <llvm/MC/MCExternalSymbolizer.h>
-#else
-#include <llvm/Assembly/Parser.h>
-#include <llvm/ADT/OwningPtr.h>
+#  include <llvm/AsmParser/Parser.h>
+#  ifdef LLVM39
+#    include <llvm/MC/MCDisassembler/MCDisassembler.h>
+#    include <llvm/MC/MCDisassembler/MCExternalSymbolizer.h>
+#  else
+#    include <llvm/MC/MCExternalSymbolizer.h>
+#    include <llvm/MC/MCDisassembler.h>
+#  endif
+#else
+#  include <llvm/Assembly/Parser.h>
+#  include <llvm/ADT/OwningPtr.h>
+#  include <llvm/MC/MCDisassembler.h>
 #endif
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/MemoryBuffer.h>
@@ -74,16 +81,13 @@
 #else
 #include <llvm/DebugInfo.h>
 #endif
-#ifndef LLVM37
-#define format_hex(v, d) format("%#0" #d "x", v)
-#endif
 
 #include "julia.h"
 #include "julia_internal.h"
 
 using namespace llvm;
 
-extern DLLEXPORT LLVMContext &jl_LLVMContext;
+extern JL_DLLEXPORT LLVMContext &jl_LLVMContext;
 
 namespace {
 #ifdef LLVM36
@@ -134,7 +138,8 @@ class SymbolTable {
     void insertAddress(uint64_t addr);
     // void createSymbol(const char *name, uint64_t addr);
     void createSymbols();
-    const char *lookupSymbol(uint64_t addr);
+    const char *lookupSymbolName(uint64_t addr);
+    MCSymbol *lookupSymbol(uint64_t addr);
     void setIP(uint64_t addr);
     uint64_t getIP() const;
 };
@@ -167,7 +172,7 @@ void SymbolTable::createSymbols()
         name << "L" << addr;
 #ifdef LLVM37
         MCSymbol *symb = Ctx.getOrCreateSymbol(StringRef(name.str()));
-        symb->setVariableValue(MCConstantExpr::create(addr, Ctx));
+        assert(symb->isUndefined());
 #else
         MCSymbol *symb = Ctx.GetOrCreateSymbol(StringRef(name.str()));
         symb->setVariableValue(MCConstantExpr::Create(addr, Ctx));
@@ -175,25 +180,27 @@ void SymbolTable::createSymbols()
         isymb->second = symb;
     }
 }
-const char *SymbolTable::lookupSymbol(uint64_t addr)
+const char *SymbolTable::lookupSymbolName(uint64_t addr)
 {
     if (!Table.count(addr)) return NULL;
     MCSymbol *symb = Table[addr];
     TempName = symb->getName().str();
     return TempName.c_str();
 }
+MCSymbol *SymbolTable::lookupSymbol(uint64_t addr)
+{
+    if (!Table.count(addr)) return NULL;
+    return Table[addr];
+}
 
-const char *SymbolLookup(void *DisInfo,
-                         uint64_t ReferenceValue,
-                         uint64_t *ReferenceType,
-                         uint64_t ReferencePC,
-                         const char **ReferenceName)
+static const char *SymbolLookup(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType,
+                                uint64_t ReferencePC, const char **ReferenceName)
 {
     SymbolTable *SymTab = (SymbolTable*)DisInfo;
     if (SymTab->getPass() != 0) {
         if (*ReferenceType == LLVMDisassembler_ReferenceType_In_Branch) {
             uint64_t addr = ReferenceValue + SymTab->getIP();
-            const char *symbolName = SymTab->lookupSymbol(addr);
+            const char *symbolName = SymTab->lookupSymbolName(addr);
             *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
             *ReferenceName = NULL;
             return symbolName;
@@ -204,9 +211,8 @@ const char *SymbolLookup(void *DisInfo,
     return NULL;
 }
 
-int OpInfoLookup(void *DisInfo, uint64_t PC,
-                 uint64_t Offset, uint64_t Size,
-                 int TagType, void *TagBuf)
+static int OpInfoLookup(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t Size,
+                        int TagType, void *TagBuf)
 {
     SymbolTable *SymTab = (SymbolTable*)DisInfo;
     PC += SymTab->getIP() - (uint64_t)(uintptr_t)SymTab->getMemoryObject().data(); // add offset from MemoryObject base
@@ -232,8 +238,9 @@ int OpInfoLookup(void *DisInfo, uint64_t PC,
     size_t line;
     char *inlinedat_file;
     size_t inlinedat_line;
+    jl_lambda_info_t *outer_linfo;
     int fromC;
-    jl_getFunctionInfo(&name, &filename, &line, &inlinedat_file, &inlinedat_line, pointer, &fromC, skipC, 1);
+    jl_getFunctionInfo(&name, &filename, &line, &inlinedat_file, &inlinedat_line, &outer_linfo, pointer, &fromC, skipC, 1);
     free(filename);
     free(inlinedat_file);
     if (!name)
@@ -247,6 +254,23 @@ int OpInfoLookup(void *DisInfo, uint64_t PC,
 }
 } // namespace
 
+#ifndef USE_MCJIT
+static void print_source_line(raw_ostream &stream, DebugLoc Loc)
+{
+    MDNode *inlinedAt = Loc.getInlinedAt(jl_LLVMContext);
+    if (inlinedAt != NULL) {
+        DebugLoc inlineloc = DebugLoc::getFromDILocation(inlinedAt);
+        stream << "Source line: " << inlineloc.getLine() << "\n";
+
+        DILexicalBlockFile innerscope = DILexicalBlockFile(Loc.getScope(jl_LLVMContext));
+        stream << "Source line: [inline] " << innerscope.getFilename().str().c_str() << ':' << Loc.getLine() << "\n";
+    }
+    else {
+        stream << "Source line: " << Loc.getLine() << "\n";
+    }
+}
+#endif
+
 extern "C"
 void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
 #ifndef USE_MCJIT
@@ -255,7 +279,7 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
                           const object::ObjectFile *objectfile,
 #endif
 #ifdef LLVM37
-                          raw_ostream &stream
+                          raw_ostream &rstream
 #else
                           formatted_raw_ostream &stream
 #endif
@@ -273,11 +297,17 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
     Triple TheTriple(Triple::normalize(TripleName));
 
     std::string MCPU = sys::getHostCPUName();
+#ifdef _CPU_ARM_
+    // The Raspberry Pi CPU is misdetected by LLVM (at least of version
+    // 3.6); correct this.
+    if (MCPU == "arm1176jz-s")
+        MCPU = "arm1176jzf-s";
+#endif
     SubtargetFeatures Features;
     Features.getDefaultSubtargetFeatures(TheTriple);
 
     std::string err;
-    const Target* TheTarget = TargetRegistry::lookupTarget(TripleName, err);
+    const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, err);
 
     // Set up required helpers and streamer
 #ifdef LLVM35
@@ -313,7 +343,11 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
 #else
     MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr);
 #endif
+#ifdef LLVM37
+    MOFI->InitMCObjectFileInfo(TheTriple, Reloc::Default, CodeModel::Default, Ctx);
+#else
     MOFI->InitMCObjectFileInfo(TripleName, Reloc::Default, CodeModel::Default, Ctx);
+#endif
 
     // Set up Subtarget and Disassembler
 #ifdef LLVM35
@@ -345,10 +379,10 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
         MCIA(TheTarget->createMCInstrAnalysis(MCII.get()));
 #endif
 #ifdef LLVM37
-    MCInstPrinter* IP =
+    MCInstPrinter *IP =
         TheTarget->createMCInstPrinter(TheTriple, OutputAsmVariant, *MAI, *MCII, *MRI);
 #else
-    MCInstPrinter* IP =
+    MCInstPrinter *IP =
         TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI, *MCII, *MRI, *STI);
 #endif
     MCCodeEmitter *CE = 0;
@@ -367,17 +401,21 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
     }
 
 #ifdef LLVM37
-    auto ustream = llvm::make_unique<formatted_raw_ostream>(stream);
+    // createAsmStreamer expects a unique_ptr to a formatted stream, which means
+    // it will destruct the stream when it is done. We cannot have this, so we
+    // start out with a raw stream, and create formatted stream from it here.
+    // LLVM will desctruct the formatted stream, and we keep the raw stream.
+    auto ustream = llvm::make_unique<formatted_raw_ostream>(rstream);
     Streamer.reset(TheTarget->createAsmStreamer(Ctx, std::move(ustream), /*asmverbose*/true,
 #else
     Streamer.reset(TheTarget->createAsmStreamer(Ctx, stream, /*asmverbose*/true,
 #endif
 #ifndef LLVM35
-                                           /*useLoc*/ true,
-                                           /*useCFI*/ true,
+                                                /*useLoc*/ true,
+                                                /*useCFI*/ true,
 #endif
-                                           /*useDwarfDirectory*/ true,
-                                           IP, CE, MAB, ShowInst));
+                                                /*useDwarfDirectory*/ true,
+                                                IP, CE, MAB, ShowInst));
 #ifdef LLVM36
     Streamer->InitSections(true);
 #else
@@ -428,16 +466,13 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
                         &DisInfo)));
 #elif defined LLVM34
             OwningPtr<MCRelocationInfo> relinfo(new MCRelocationInfo(Ctx));
-            DisAsm->setupForSymbolicDisassembly(
-                    OpInfoLookup, SymbolLookup, &DisInfo, &Ctx,
-                    relinfo);
+            DisAsm->setupForSymbolicDisassembly(OpInfoLookup, SymbolLookup, &DisInfo, &Ctx,
+                                                relinfo);
 #else
-            DisAsm->setupForSymbolicDisassembly(
-                    OpInfoLookup, SymbolLookup, &DisInfo, &Ctx);
+            DisAsm->setupForSymbolicDisassembly(OpInfoLookup, SymbolLookup, &DisInfo, &Ctx);
 #endif
         }
 
-
         uint64_t nextLineAddr = -1;
 #ifdef USE_MCJIT
         // Set up the line info
@@ -447,7 +482,11 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
         if (lineIter != lineEnd) {
             nextLineAddr = lineIter->first;
             if (pass != 0) {
-#ifdef LLVM35
+#ifdef LLVM37
+                std::ostringstream buf;
+                buf << "Filename: " << lineIter->second.FileName << "\n";
+                Streamer->EmitRawText(buf.str());
+#elif defined LLVM35
                 stream << "Filename: " << lineIter->second.FileName << "\n";
 #else
                 stream << "Filename: " << lineIter->second.getFileName() << "\n";
@@ -461,10 +500,21 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
 
         if (lineIter != lineEnd) {
             nextLineAddr = (*lineIter).Address;
-            DISubprogram debugscope = DISubprogram((*lineIter).Loc.getScope(jl_LLVMContext));
             if (pass != 0) {
-                stream << "Filename: " << debugscope.getFilename() << "\n";
-                stream << "Source line: " << (*lineIter).Loc.getLine() << "\n";
+                DebugLoc Loc = (*lineIter).Loc;
+                MDNode *outer = Loc.getInlinedAt(jl_LLVMContext);
+                StringRef FileName;
+                if (!outer) {
+                    DISubprogram debugscope = DISubprogram(Loc.getScope(jl_LLVMContext));
+                    FileName = debugscope.getFilename();
+                }
+                else {
+                    DebugLoc inlineloc = DebugLoc::getFromDILocation(outer);
+                    DILexicalBlockFile debugscope = DILexicalBlockFile(inlineloc.getScope(jl_LLVMContext));
+                    FileName = debugscope.getFilename();
+                }
+                stream << "Filename: " << FileName << "\n";
+                print_source_line(stream, (*lineIter).Loc);
             }
         }
 #endif
@@ -477,7 +527,13 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
 
             if (nextLineAddr != (uint64_t)-1 && Index + Fptr - slide == nextLineAddr) {
 #ifdef USE_MCJIT
-#ifdef LLVM35
+#ifdef LLVM37
+                if (pass != 0) {
+                    std::ostringstream buf;
+                    buf << "Source line: " << lineIter->second.Line << "\n";
+                    Streamer->EmitRawText(buf.str());
+                }
+#elif defined LLVM35
                 if (pass != 0)
                     stream << "Source line: " << lineIter->second.Line << "\n";
 #else
@@ -486,8 +542,9 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
 #endif
                 nextLineAddr = (++lineIter)->first;
 #else
-                if (pass != 0)
-                    stream << "Source line: " << (*lineIter).Loc.getLine() << "\n";
+                if (pass != 0) {
+                    print_source_line(stream, (*lineIter).Loc);
+                }
                 nextLineAddr = (*++lineIter).Address;
 #endif
             }
@@ -495,9 +552,16 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
             if (pass != 0) {
                 // Uncomment this to output addresses for all instructions
                 // stream << Index << ": ";
-                const char *symbolName = DisInfo.lookupSymbol(Fptr+Index);
+#ifdef LLVM37
+                MCSymbol *symbol = DisInfo.lookupSymbol(Fptr+Index);
+                if (symbol)
+                    Streamer->EmitLabel(symbol);
+                    // emitInstructionAnnot
+#else
+                const char *symbolName = DisInfo.lookupSymbolName(Fptr+Index);
                 if (symbolName)
                     stream << symbolName << ":";
+#endif
             }
 
             MCInst Inst;
@@ -518,33 +582,52 @@ void jl_dump_asm_internal(uintptr_t Fptr, size_t Fsize, size_t slide,
                                       /*REMOVE*/ nulls(), nulls());
             switch (S) {
             case MCDisassembler::Fail:
-                if (pass != 0)
-#if defined(_CPU_PPC_) || defined(_CPU_PPC64_) || defined(_CPU_ARM_)
-                    stream << "\t.long " << format_hex(*(uint32_t*)(Fptr+Index), 10) << "\n";
-#elif defined(_CPU_X86_) || defined(_CPU_X86_64_)
-                    SrcMgr.PrintMessage(SMLoc::getFromPointer((const char*)(Fptr + Index)),
-                                        SourceMgr::DK_Warning,
-                                        "invalid instruction encoding");
-#else
-                    stream << "\t.byte " << format_hex(*(uint8_t*)(Fptr+Index), 4) << "\n";
-#endif
                 if (insSize == 0) // skip illegible bytes
-#if defined(_CPU_PPC_) || defined(_CPU_PPC64_) || defined(_CPU_ARM_)
+#if defined(_CPU_PPC_) || defined(_CPU_PPC64_) || defined(_CPU_ARM_) || defined(_CPU_AARCH64_)
                     insSize = 4; // instructions are always 4 bytes
 #else
                     insSize = 1; // attempt to slide 1 byte forward
 #endif
+                if (pass != 0) {
+                    std::ostringstream buf;
+                    if (insSize == 4)
+                        buf << "\t.long\t0x" << std::hex
+                            << std::setfill('0') << std::setw(8)
+                            << *(const uint32_t*)(Fptr+Index) << "\n";
+                    else
+                        for (uint64_t i=0; i<insSize; ++i)
+                            buf << "\t.byte\t0x" << std::hex
+                                << std::setfill('0') << std::setw(2)
+                                << *(const uint8_t*)(Fptr+Index+i) << "\n";
+#ifdef LLVM37
+                    Streamer->EmitRawText(buf.str());
+#else
+                    stream << buf.str();
+#endif
+#if defined(_CPU_X86_) || defined(_CPU_X86_64_)
+                    SrcMgr.PrintMessage(SMLoc::getFromPointer((const char*)(Fptr + Index)),
+                                        SourceMgr::DK_Warning,
+                                        "invalid instruction encoding");
+#endif
+                }
                 break;
 
             case MCDisassembler::SoftFail:
-                if (pass != 0)
+                if (pass != 0) {
 #if !defined(_CPU_X86_) || !defined(_CPU_X86_64_)
+#ifdef LLVM37
+                    std::ostringstream buf;
+                    buf << "potentially undefined instruction encoding:\n";
+                    Streamer->EmitRawText(buf.str());
+#else
                     stream << "potentially undefined instruction encoding:\n";
+#endif
 #else
                     SrcMgr.PrintMessage(SMLoc::getFromPointer((const char*)(Fptr + Index)),
                                         SourceMgr::DK_Warning,
                                         "potentially undefined instruction encoding");
 #endif
+                }
                 // Fall through
 
             case MCDisassembler::Success:
diff --git a/src/dlload.c b/src/dlload.c
index 17e6411596e7b..f940f783d50ff 100644
--- a/src/dlload.c
+++ b/src/dlload.c
@@ -39,54 +39,76 @@ static char *extensions[] = { ".so", "" };
 extern char *julia_home;
 
 #define JL_RTLD(flags, FLAG) (flags & JL_RTLD_ ## FLAG ? RTLD_ ## FLAG : 0)
+#ifdef __has_feature
+#   if __has_feature(address_sanitizer)
+#      define SANITIZE_ADDRESS
+#   endif
+#endif
+
+static void JL_NORETURN jl_dlerror(const char *fmt, const char *sym)
+{
+#ifdef _OS_WINDOWS_
+    CHAR reason[256];
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL, GetLastError(),
+            MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+            reason, sizeof(reason) / sizeof(reason[0]), NULL);
+#else
+    const char *reason = dlerror();
+#endif
+    jl_errorf(fmt, sym, reason);
+}
 
-DLLEXPORT int jl_uv_dlopen(const char *filename, jl_uv_libhandle lib_, unsigned flags)
+JL_DLLEXPORT void *jl_dlopen(const char *filename, unsigned flags)
 {
-    uv_lib_t *lib = (uv_lib_t *) lib_;
 #if defined(_OS_WINDOWS_)
     needsSymRefreshModuleList = 1;
-#endif
-#if defined(RTLD_GLOBAL) && defined(RTLD_LAZY) /* POSIX flags available */
+    size_t len = MultiByteToWideChar(CP_UTF8, 0, filename, -1, NULL, 0);
+    if (!len) return NULL;
+    WCHAR *wfilename = (WCHAR*)alloca(len * sizeof(WCHAR));
+    if (!MultiByteToWideChar(CP_UTF8, 0, filename, -1, wfilename, len)) return NULL;
+    return LoadLibraryExW(wfilename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+#else
     dlerror(); /* Reset error status. */
-    lib->handle = dlopen(filename,
-                         (flags & JL_RTLD_NOW ? RTLD_NOW : RTLD_LAZY)
-                         | JL_RTLD(flags, LOCAL)
-                         | JL_RTLD(flags, GLOBAL)
+    return dlopen(filename,
+                  (flags & JL_RTLD_NOW ? RTLD_NOW : RTLD_LAZY)
+                  | JL_RTLD(flags, LOCAL)
+                  | JL_RTLD(flags, GLOBAL)
 #ifdef RTLD_NODELETE
-                         | JL_RTLD(flags, NODELETE)
+                  | JL_RTLD(flags, NODELETE)
 #endif
 #ifdef RTLD_NOLOAD
-                         | JL_RTLD(flags, NOLOAD)
+                  | JL_RTLD(flags, NOLOAD)
 #endif
-#ifdef RTLD_DEEPBIND
-                         | JL_RTLD(flags, DEEPBIND)
+#if defined(RTLD_DEEPBIND) && !defined(SANITIZE_ADDRESS)
+                  | JL_RTLD(flags, DEEPBIND)
 #endif
 #ifdef RTLD_FIRST
-                         | JL_RTLD(flags, FIRST)
+                  | JL_RTLD(flags, FIRST)
 #endif
-                         );
-    if (lib->handle) {
-        lib->errmsg = NULL;
-        return 0;
-    }
-    else {
-        lib->errmsg = strdup(dlerror());
-        return -1;
-    }
+                  );
+#endif
+}
+
+JL_DLLEXPORT int jl_dlclose(void *handle)
+{
+#ifdef _OS_WINDOWS_
+    if (!handle) return -1;
+    return FreeLibrary((HMODULE) handle);
 #else
-    return uv_dlopen(filename, lib);
+    dlerror(); /* Reset error status. */
+    if (!handle) return -1;
+    return dlclose(handle);
 #endif
 }
 
-static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, int throw_err)
+static void *jl_load_dynamic_library_(const char *modname, unsigned flags, int throw_err)
 {
-    int error;
     char *ext;
     char path[PATHBUF];
     int i;
     uv_stat_t stbuf;
-    uv_lib_t *handle = (uv_lib_t*)malloc(sizeof(uv_lib_t));
-    handle->errmsg = NULL;
+    void *handle;
 
 /*
     this branch returns handle of libjulia
@@ -95,12 +117,11 @@ static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, i
 #ifdef _OS_WINDOWS_
         if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                                 (LPCWSTR)(&jl_load_dynamic_library),
-                                &handle->handle)) {
-            free(handle);
+                                (HMODULE*)&handle)) {
             jl_error("could not load base module");
         }
 #else
-        handle->handle = dlopen(NULL,RTLD_NOW);
+        handle = dlopen(NULL, RTLD_NOW);
 #endif
         goto done;
     }
@@ -112,14 +133,12 @@ static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, i
 #else
     else if (modname[0] == '/') {
 #endif
-        error = jl_uv_dlopen(modname,handle,flags);
-        if (!error)
+        handle = jl_dlopen(modname, flags);
+        if (handle)
             goto done;
         // bail out and show the error if file actually exists
         if (jl_stat(modname, (char*)&stbuf) == 0)
             goto notfound;
-        if (handle->errmsg)
-            uv_dlclose(handle);
     }
 /*
     this branch permutes all base paths in DL_LOAD_PATH with all extensions
@@ -137,16 +156,13 @@ static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, i
                 for(i=0; i < N_EXTENSIONS; i++) {
                     ext = extensions[i];
                     path[0] = '\0';
-                    handle->handle = NULL;
+                    handle = NULL;
                     if (dl_path[len-1] == PATHSEPSTRING[0])
                         snprintf(path, PATHBUF, "%s%s%s", dl_path, modname, ext);
                     else
                         snprintf(path, PATHBUF, "%s" PATHSEPSTRING "%s%s", dl_path, modname, ext);
-                    // free handle->errmsg, else it will leak on next uv_dlopen
-                    if (handle->errmsg)
-                        uv_dlclose(handle);
-                    error = jl_uv_dlopen(path, handle, flags);
-                    if (!error)
+                    handle = jl_dlopen(path, flags);
+                    if (handle)
                         goto done;
                     // bail out and show the error if file actually exists
                     if (jl_stat(path, (char*)&stbuf) == 0)
@@ -160,12 +176,10 @@ static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, i
     for(i=0; i < N_EXTENSIONS; i++) {
         ext = extensions[i];
         path[0] = '\0';
-        handle->handle = NULL;
+        handle = NULL;
         snprintf(path, PATHBUF, "%s%s", modname, ext);
-        if (handle->errmsg)
-            uv_dlclose(handle);
-        error = jl_uv_dlopen(path, handle, flags);
-        if (!error)
+        handle = jl_dlopen(path, flags);
+        if (handle)
             goto done;
     }
 
@@ -173,75 +187,75 @@ static uv_lib_t *jl_load_dynamic_library_(const char *modname, unsigned flags, i
 // check map of versioned libs from "libX" to full soname "libX.so.ver"
     {
         const char *soname = jl_lookup_soname(modname, strlen(modname));
-        error = (soname==NULL) || jl_uv_dlopen(soname, handle, flags);
-        if (!error)
-            goto done;
+        if (soname) {
+            handle = jl_dlopen(soname, flags);
+            if (handle)
+                goto done;
+        }
     }
 #endif
 
 notfound:
-    // copy the error message into the path buffer so we can free the lib handle
-    path[0] = '\0';
-    snprintf(path, PATHBUF, "%s", uv_dlerror(handle));
-    uv_dlclose(handle);
-    free(handle);
     if (throw_err)
-        jl_errorf("could not load library \"%s\"\n%s", modname, path);
+        jl_dlerror("could not load library \"%s\"\n%s", modname);
     return NULL;
 
 done:
     return handle;
 }
 
-jl_uv_libhandle jl_load_dynamic_library_e(const char *modname, unsigned flags)
+JL_DLLEXPORT void *jl_load_dynamic_library_e(const char *modname, unsigned flags)
 {
-    return (jl_uv_libhandle) jl_load_dynamic_library_(modname, flags, 0);
+    return jl_load_dynamic_library_(modname, flags, 0);
 }
 
-jl_uv_libhandle jl_load_dynamic_library(const char *modname, unsigned flags)
+JL_DLLEXPORT void *jl_load_dynamic_library(const char *modname, unsigned flags)
 {
-    return (jl_uv_libhandle) jl_load_dynamic_library_(modname, flags, 1);
+    return jl_load_dynamic_library_(modname, flags, 1);
 }
 
-void *jl_dlsym_e(jl_uv_libhandle handle, const char *symbol)
+JL_DLLEXPORT void *jl_dlsym_e(void *handle, const char *symbol)
 {
-    void *ptr;
-    int error = uv_dlsym((uv_lib_t *) handle, symbol, &ptr);
-    if (error) ptr=NULL;
+#ifdef _OS_WINDOWS_
+    void *ptr = GetProcAddress((HMODULE) handle, symbol);
+#else
+    dlerror(); /* Reset error status. */
+    void *ptr = dlsym(handle, symbol);
+#endif
     return ptr;
 }
 
-void *jl_dlsym(jl_uv_libhandle handle, const char *symbol)
+JL_DLLEXPORT void *jl_dlsym(void *handle, const char *symbol)
 {
-    void *ptr;
-    int error = uv_dlsym((uv_lib_t *) handle, symbol, &ptr);
-    if (error) {
-        jl_errorf("could not load symbol \"%s\"\n%s", symbol, uv_dlerror((uv_lib_t *) handle));
-    }
+    void *ptr = jl_dlsym_e(handle, symbol);
+    if (!ptr)
+        jl_dlerror("could not load symbol \"%s\":\n%s", symbol);
     return ptr;
 }
 
 #ifdef _OS_WINDOWS_
 //Look for symbols in win32 libraries
-char *jl_dlfind_win32(const char *f_name)
+const char *jl_dlfind_win32(const char *f_name)
 {
     if (jl_dlsym_e(jl_exe_handle, f_name))
-        return (char*)1;
+        return (const char*)1;
     if (jl_dlsym_e(jl_dl_handle, f_name))
-        return (char*)2;
+        return (const char*)2;
     if (jl_dlsym_e(jl_kernel32_handle, f_name))
         return "kernel32";
     if (jl_dlsym_e(jl_ntdll_handle, f_name))
         return "ntdll";
     if (jl_dlsym_e(jl_crtdll_handle, f_name))
+#if defined(_MSC_VER)
 #if _MSC_VER == 1800
         return "msvcr120";
-#elif defined(_MSC_VER)
+#else
 #error This version of MSVC has not been tested.
+#endif
 #else
         return "msvcrt";
 #endif
-    if (jl_dlsym(jl_winsock_handle, f_name))
+    if (jl_dlsym_e(jl_winsock_handle, f_name))
         return "ws2_32";
     // additional common libraries (libc?) could be added here, but in general,
     // it is better to specify the library explicitly in the code. This exists
diff --git a/src/dump.c b/src/dump.c
index ce2426576c8b0..1fef7e2b1a648 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -25,6 +25,8 @@
 extern "C" {
 #endif
 
+JL_DEFINE_MUTEX(dump)
+
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
@@ -68,38 +70,36 @@ static jl_array_t *serializer_worklist;
 static htable_t fptr_to_id;
 // array of definitions for the predefined function pointers
 // (reverse of fptr_to_id)
-static jl_fptr_t id_to_fptrs[] = {
+static const jl_fptr_t id_to_fptrs[] = {
   NULL, NULL,
-  jl_f_throw, jl_f_is, jl_f_no_function, jl_f_typeof,
-  jl_f_subtype, jl_f_isa, jl_f_typeassert, jl_f_apply,
-  jl_f_top_eval, jl_f_isdefined, jl_f_tuple, jl_f_svec,
-  jl_f_get_field, jl_f_set_field, jl_f_field_type, jl_f_nfields,
-  jl_f_arraylen, jl_f_arrayref, jl_f_arrayset, jl_f_arraysize,
-  jl_f_instantiate_type, jl_f_kwcall, jl_trampoline,
-  jl_f_methodexists, jl_f_applicable, jl_f_invoke,
-  jl_apply_generic, jl_unprotect_stack, jl_f_sizeof, jl_f_new_expr,
+  jl_f_throw, jl_f_is, jl_f_typeof, jl_f_issubtype, jl_f_isa,
+  jl_f_typeassert, jl_f__apply, jl_f_isdefined, jl_f_tuple, jl_f_svec,
+  jl_f_getfield, jl_f_setfield, jl_f_fieldtype, jl_f_nfields,
+  jl_f_arrayref, jl_f_arrayset, jl_f_arraysize, jl_f_apply_type,
+  jl_f_applicable, jl_f_invoke, jl_unprotect_stack, jl_f_sizeof, jl_f__expr,
+  jl_f_intrinsic_call,
   NULL };
 
 // pointers to non-AST-ish objects in a compressed tree
 static jl_array_t *tree_literal_values=NULL;    // (only used in MODE_AST)
 static jl_module_t *tree_enclosing_module=NULL; // (only used in MODE_AST)
 
-static const ptrint_t LongSymbol_tag   = 23;
-static const ptrint_t LongSvec_tag     = 24;
-static const ptrint_t LongExpr_tag     = 25;
-static const ptrint_t LiteralVal_tag   = 26;
-static const ptrint_t SmallInt64_tag   = 27;
-static const ptrint_t SmallDataType_tag= 28;
-static const ptrint_t Int32_tag        = 29;
-static const ptrint_t Array1d_tag      = 30;
-static const ptrint_t Singleton_tag    = 31;
-static const ptrint_t CommonSym_tag    = 32;
-static const ptrint_t NearbyGlobal_tag = 33;  // a GlobalRef pointing to tree_enclosing_module
-static const ptrint_t Null_tag         = 253;
-static const ptrint_t ShortBackRef_tag = 254;
-static const ptrint_t BackRef_tag      = 255;
-
-static ptrint_t VALUE_TAGS;
+static const intptr_t LongSymbol_tag   = 23;
+static const intptr_t LongSvec_tag     = 24;
+static const intptr_t LongExpr_tag     = 25;
+static const intptr_t LiteralVal_tag   = 26;
+static const intptr_t SmallInt64_tag   = 27;
+static const intptr_t SmallDataType_tag= 28;
+static const intptr_t Int32_tag        = 29;
+static const intptr_t Array1d_tag      = 30;
+static const intptr_t Singleton_tag    = 31;
+static const intptr_t CommonSym_tag    = 32;
+static const intptr_t NearbyGlobal_tag = 33;  // a GlobalRef pointing to tree_enclosing_module
+static const intptr_t Null_tag         = 253;
+static const intptr_t ShortBackRef_tag = 254;
+static const intptr_t BackRef_tag      = 255;
+
+static intptr_t VALUE_TAGS;
 
 typedef enum _DUMP_MODES {
     // not in the serializer at all, or
@@ -107,7 +107,7 @@ typedef enum _DUMP_MODES {
     MODE_INVALID = 0,
 
     // jl_uncompress_ast
-    // compressing / decompressing an AST Expr in a LambdaStaticData
+    // compressing / decompressing an AST Expr in a LambdaInfo
     MODE_AST,
 
     // jl_restore_system_image
@@ -179,7 +179,7 @@ static uint16_t read_uint16(ios_t *s)
 
 static void writetag(ios_t *s, void *v)
 {
-    write_uint8(s, (uint8_t)(ptrint_t)ptrhash_get(&ser_tag, v));
+    write_uint8(s, (uint8_t)(intptr_t)ptrhash_get(&ser_tag, v));
 }
 
 static void write_as_tag(ios_t *s, uint8_t tag)
@@ -200,25 +200,26 @@ static void write_float64(ios_t *s, double x)
 #define jl_serialize_value(s, v) jl_serialize_value_(s,(jl_value_t*)(v))
 static void jl_serialize_value_(ios_t *s, jl_value_t *v);
 static jl_value_t *jl_deserialize_value(ios_t *s, jl_value_t **loc);
-jl_value_t ***sysimg_gvars = NULL;
+static jl_value_t ***sysimg_gvars = NULL;
+static void **sysimg_fvars = NULL;
 
 #ifdef HAVE_CPUID
 extern void jl_cpuid(int32_t CPUInfo[4], int32_t InfoType);
 #endif
 
 extern int globalUnique;
-uv_lib_t *jl_sysimg_handle = NULL;
-uint64_t jl_sysimage_base = 0;
+static void *jl_sysimg_handle = NULL;
+static uint64_t sysimage_base = 0;
 #ifdef _OS_WINDOWS_
 #include <dbghelp.h>
 #endif
 
-DLLEXPORT int jl_running_on_valgrind()
+JL_DLLEXPORT int jl_running_on_valgrind(void)
 {
     return RUNNING_ON_VALGRIND;
 }
 
-static int jl_load_sysimg_so()
+static int jl_load_sysimg_so(void)
 {
 #ifndef _OS_WINDOWS_
     Dl_info dlinfo;
@@ -231,7 +232,14 @@ static int jl_load_sysimg_so()
     // in --build mode only use sysimg data, not precompiled native code
     if (!imaging_mode && jl_options.use_precompiled==JL_OPTIONS_USE_PRECOMPILED_YES) {
         sysimg_gvars = (jl_value_t***)jl_dlsym(jl_sysimg_handle, "jl_sysimg_gvars");
+        sysimg_fvars = (void**)jl_dlsym(jl_sysimg_handle, "jl_sysimg_fvars");
         globalUnique = *(size_t*)jl_dlsym(jl_sysimg_handle, "jl_globalUnique");
+#ifdef JULIA_ENABLE_THREADING
+        size_t tls_getter_idx = *(size_t*)jl_dlsym(jl_sysimg_handle,
+                                                   "jl_ptls_states_getter_idx");
+        *sysimg_gvars[tls_getter_idx - 1] =
+            (jl_value_t*)jl_get_ptls_states_getter();
+#endif
         const char *cpu_target = (const char*)jl_dlsym(jl_sysimg_handle, "jl_sysimg_cpu_target");
         if (strcmp(cpu_target,jl_options.cpu_target) != 0)
             jl_error("Julia and the system image were compiled for different architectures.\n"
@@ -255,13 +263,13 @@ static int jl_load_sysimg_so()
 #endif
 
 #ifdef _OS_WINDOWS_
-        jl_sysimage_base = (intptr_t)jl_sysimg_handle->handle;
+        sysimage_base = (intptr_t)jl_sysimg_handle;
 #else
         if (dladdr((void*)sysimg_gvars, &dlinfo) != 0) {
-            jl_sysimage_base = (intptr_t)dlinfo.dli_fbase;
+            sysimage_base = (intptr_t)dlinfo.dli_fbase;
         }
         else {
-            jl_sysimage_base = 0;
+            sysimage_base = 0;
         }
 #endif
     }
@@ -376,13 +384,14 @@ static void jl_deserialize_gv_others(ios_t *s)
     }
 }
 
-struct delayed_fptrs_t {
+static struct delayed_fptrs_t {
     jl_lambda_info_t *li;
     int32_t func;
     int32_t cfunc;
 } *delayed_fptrs = NULL;
 static size_t delayed_fptrs_n = 0;
 static size_t delayed_fptrs_max = 0;
+static size_t sysimg_fvars_max = 0;
 
 static void jl_delayed_fptrs(jl_lambda_info_t *li, int32_t func, int32_t cfunc)
 {
@@ -391,8 +400,8 @@ static void jl_delayed_fptrs(jl_lambda_info_t *li, int32_t func, int32_t cfunc)
     if (cfunc || func) {
         if (delayed_fptrs_max < delayed_fptrs_n + 1) {
             if (delayed_fptrs_max == 0)
-                // current measurements put the number of functions at 1130
-                delayed_fptrs_max = 2048;
+                // current measurements put the number of functions at 4508
+                delayed_fptrs_max = 4096;
             else
                 delayed_fptrs_max *= 2;
             delayed_fptrs = (struct delayed_fptrs_t*)realloc(delayed_fptrs, delayed_fptrs_max*sizeof(delayed_fptrs[0])); //assumes sizeof==alignof
@@ -401,31 +410,43 @@ static void jl_delayed_fptrs(jl_lambda_info_t *li, int32_t func, int32_t cfunc)
         delayed_fptrs[delayed_fptrs_n].func = func;
         delayed_fptrs[delayed_fptrs_n].cfunc = cfunc;
         delayed_fptrs_n++;
+        if (func > 0 && func > sysimg_fvars_max)
+            sysimg_fvars_max = func;
+        if (cfunc > 0 && cfunc > sysimg_fvars_max)
+            sysimg_fvars_max = cfunc;
     }
 }
 
-static void jl_update_all_fptrs()
+void jl_register_fptrs(uint64_t sysimage_base, void **fptrs, jl_lambda_info_t **linfos, size_t n);
+
+static void jl_update_all_fptrs(void)
 {
     //jl_printf(JL_STDOUT, "delayed_fptrs_n: %d\n", delayed_fptrs_n);
-    jl_value_t ***gvars = sysimg_gvars;
-    if (gvars == 0) return;
+    void **fvars = sysimg_fvars;
+    if (fvars == 0) return;
     // jl_fptr_to_llvm needs to decompress some ASTs, therefore this needs to be NULL
     // to skip trying to restore GlobalVariable pointers in jl_deserialize_gv
     sysimg_gvars = NULL;
+    sysimg_fvars = NULL;
     size_t i;
+    jl_lambda_info_t **linfos = (jl_lambda_info_t**)malloc(sizeof(jl_lambda_info_t*) * sysimg_fvars_max);
     for (i = 0; i < delayed_fptrs_n; i++) {
         jl_lambda_info_t *li = delayed_fptrs[i].li;
-        int32_t func = delayed_fptrs[i].func-1;
+        int32_t func = delayed_fptrs[i].func - 1;
         if (func >= 0) {
-            jl_fptr_to_llvm((void*)gvars[func], li, 0);
+            jl_fptr_to_llvm((jl_fptr_t)fvars[func], li, 0);
+            linfos[func] = li;
         }
-        int32_t cfunc = delayed_fptrs[i].cfunc-1;
+        int32_t cfunc = delayed_fptrs[i].cfunc - 1;
         if (cfunc >= 0) {
-            jl_fptr_to_llvm((void*)gvars[cfunc], li, 1);
+            jl_fptr_to_llvm((jl_fptr_t)fvars[cfunc], li, 1);
+            linfos[cfunc] = li;
         }
     }
+    jl_register_fptrs(sysimage_base, fvars, linfos, sysimg_fvars_max);
     delayed_fptrs_n = 0;
     delayed_fptrs_max = 0;
+    sysimg_fvars_max = 0;
     free(delayed_fptrs);
     delayed_fptrs = NULL;
 }
@@ -435,9 +456,10 @@ static void jl_update_all_fptrs()
 static void jl_serialize_fptr(ios_t *s, void *fptr)
 {
     void **pbp = ptrhash_bp(&fptr_to_id, fptr);
-    if (*pbp == HT_NOTFOUND)
-        jl_error("unknown function pointer");
-    write_uint16(s, *(ptrint_t*)pbp);
+    if (*pbp == HT_NOTFOUND || fptr == NULL)
+        write_uint16(s, 1);
+    else
+        write_uint16(s, *(intptr_t*)pbp);
 }
 
 static int module_in_worklist(jl_module_t *mod) {
@@ -484,9 +506,9 @@ static void jl_serialize_datatype(ios_t *s, jl_datatype_t *dt)
             tag = 5; // anything else (needs uid assigned later)
             if (!internal) {
                 // also flag this in the backref table as special
-                uptrint_t *bp = (uptrint_t*)ptrhash_bp(&backref_table, dt);
-                assert(*bp != (uptrint_t)HT_NOTFOUND);
-                *bp |= 1; assert(((uptrint_t)HT_NOTFOUND)|1);
+                uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, dt);
+                assert(*bp != (uintptr_t)HT_NOTFOUND);
+                *bp |= 1; assert(((uintptr_t)HT_NOTFOUND)|1);
             }
         }
     }
@@ -514,6 +536,7 @@ static void jl_serialize_datatype(ios_t *s, jl_datatype_t *dt)
     write_int32(s, dt->size);
     int has_instance = !!(dt->instance != NULL);
     write_uint8(s, dt->abstract | (dt->mutabl<<1) | (dt->pointerfree<<2) | (has_instance<<3));
+    write_int8(s, dt->fielddesc_type);
     if (!dt->abstract) {
         write_uint16(s, dt->ninitialized);
         if (mode != MODE_MODULE && mode != MODE_MODULE_POSTWORK) {
@@ -525,7 +548,8 @@ static void jl_serialize_datatype(ios_t *s, jl_datatype_t *dt)
     if (nf > 0) {
         write_int32(s, dt->alignment);
         write_int8(s, dt->haspadding);
-        ios_write(s, (char*)&dt->fields[0], nf*sizeof(jl_fielddesc_t));
+        size_t fieldsize = jl_fielddesc_size(dt->fielddesc_type);
+        ios_write(s, jl_datatype_fields(dt), nf * fieldsize);
         jl_serialize_value(s, dt->types);
     }
 
@@ -563,7 +587,7 @@ static void jl_serialize_module(ios_t *s, jl_module_t *m)
                 jl_serialize_value(s, b->value);
                 jl_serialize_value(s, b->globalref);
                 jl_serialize_value(s, b->owner);
-                write_int8(s, (b->constp<<2) | (b->exportp<<1) | (b->imported));
+                write_int8(s, (b->deprecated<<3) | (b->constp<<2) | (b->exportp<<1) | (b->imported));
                 jl_serialize_gv(s, (jl_value_t*)b);
             }
         }
@@ -579,10 +603,10 @@ static void jl_serialize_module(ios_t *s, jl_module_t *m)
             jl_serialize_value(s, (jl_value_t*)m->usings.items[i]);
         }
     }
-    jl_serialize_value(s, m->constant_table);
     write_uint8(s, m->istopmod);
     write_uint8(s, m->std_imports);
     write_uint64(s, m->uuid);
+    write_int32(s, m->counter);
 }
 
 static int is_ast_node(jl_value_t *v)
@@ -599,7 +623,7 @@ static int is_ast_node(jl_value_t *v)
         jl_is_expr(v) || jl_is_newvarnode(v) || jl_is_svec(v) ||
         jl_typeis(v, jl_array_any_type) || jl_is_tuple(v) ||
         jl_is_uniontype(v) || jl_is_int32(v) || jl_is_int64(v) ||
-        jl_is_bool(v) || jl_is_typevar(v) ||
+        jl_is_bool(v) ||
         jl_is_topnode(v) || jl_is_quotenode(v) || jl_is_gotonode(v) ||
         jl_is_labelnode(v) || jl_is_linenode(v) || jl_is_globalref(v);
 }
@@ -623,7 +647,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
 
     void **bp = ptrhash_bp(&ser_tag, v);
     if (*bp != HT_NOTFOUND) {
-        write_as_tag(s, (uint8_t)(ptrint_t)*bp);
+        write_as_tag(s, (uint8_t)(intptr_t)*bp);
         return;
     }
     if (jl_is_symbol(v)) {
@@ -639,7 +663,9 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
         // compressing tree
         if (!is_ast_node(v)) {
             writetag(s, (jl_value_t*)LiteralVal_tag);
-            write_uint16(s, literal_val_id(v));
+            int id = literal_val_id(v);
+            assert(id >= 0 && id < UINT16_MAX);
+            write_uint16(s, id);
             return;
         }
     }
@@ -657,7 +683,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
             }
             return;
         }
-        ptrint_t pos = backref_table_numel++;
+        intptr_t pos = backref_table_numel++;
         if (jl_typeof(v) == jl_idtable_type) {
             // will need to rehash this, later (after types are fully constructed)
             arraylist_push(&reinit_list, (void*)pos);
@@ -692,7 +718,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
         }
     }
     else if (jl_is_symbol(v)) {
-        size_t l = strlen(((jl_sym_t*)v)->name);
+        size_t l = strlen(jl_symbol_name((jl_sym_t*)v));
         if (l <= 255) {
             writetag(s, jl_symbol_type);
             write_uint8(s, (uint8_t)l);
@@ -701,7 +727,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
             writetag(s, (jl_value_t*)LongSymbol_tag);
             write_int32(s, l);
         }
-        ios_write(s, ((jl_sym_t*)v)->name, l);
+        ios_write(s, jl_symbol_name((jl_sym_t*)v), l);
     }
     else if (jl_is_globalref(v)) {
         if (mode == MODE_AST && jl_globalref_mod(v) == tree_enclosing_module) {
@@ -716,19 +742,19 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
     }
     else if (jl_is_array(v)) {
         jl_array_t *ar = (jl_array_t*)v;
-        if (ar->ndims == 1 && ar->elsize < 128) {
+        if (ar->flags.ndims == 1 && ar->elsize < 128) {
             writetag(s, (jl_value_t*)Array1d_tag);
-            write_uint8(s, (ar->ptrarray<<7) | (ar->elsize & 0x7f));
+            write_uint8(s, (ar->flags.ptrarray<<7) | (ar->elsize & 0x7f));
         }
         else {
             writetag(s, (jl_value_t*)jl_array_type);
-            write_uint16(s, ar->ndims);
-            write_uint16(s, (ar->ptrarray<<15) | (ar->elsize & 0x7fff));
+            write_uint16(s, ar->flags.ndims);
+            write_uint16(s, (ar->flags.ptrarray<<15) | (ar->elsize & 0x7fff));
         }
-        for (i=0; i < ar->ndims; i++)
+        for (i=0; i < ar->flags.ndims; i++)
             jl_serialize_value(s, jl_box_long(jl_array_dim(ar,i)));
         jl_serialize_value(s, jl_typeof(ar));
-        if (!ar->ptrarray) {
+        if (!ar->flags.ptrarray) {
             size_t tot = jl_array_len(ar) * ar->elsize;
             ios_write(s, (char*)jl_array_data(ar), tot);
         }
@@ -765,35 +791,13 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
         jl_serialize_value(s, ((jl_tvar_t*)v)->ub);
         write_int8(s, ((jl_tvar_t*)v)->bound);
     }
-    else if (jl_is_function(v)) {
-        writetag(s, jl_function_type);
-        if (mode == MODE_MODULE || mode == MODE_MODULE_POSTWORK) {
-            if (jl_is_gf(v)) {
-                jl_methtable_t *mt = jl_gf_mtable(v);
-                if (mt->module && !module_in_worklist(mt->module)) {
-                    write_int8(s, 1);
-                    jl_serialize_value(s, (jl_value_t*)mt->module);
-                    jl_serialize_value(s, (jl_value_t*)mt->name);
-                    return;
-                }
-            }
-            write_int8(s, 0);
-        }
-        jl_function_t *f = (jl_function_t*)v;
-        jl_serialize_value(s, (jl_value_t*)f->linfo);
-        jl_serialize_value(s, f->env);
-        if (f->linfo && f->linfo->ast && f->fptr != &jl_trampoline) {
-            jl_serialize_fptr(s, (void*)&jl_trampoline);
-        }
-        else {
-            jl_serialize_fptr(s, (void*)f->fptr);
-        }
-    }
     else if (jl_is_lambda_info(v)) {
         writetag(s, jl_lambda_info_type);
         jl_lambda_info_t *li = (jl_lambda_info_t*)v;
         jl_serialize_value(s, li->ast);
-        jl_serialize_value(s, (jl_value_t*)li->sparams);
+        jl_serialize_value(s, li->rettype);
+        jl_serialize_value(s, (jl_value_t*)li->sparam_syms);
+        jl_serialize_value(s, (jl_value_t*)li->sparam_vals);
         // don't save cached type info for code in the Core module, because
         // it might reference types in the old Base module.
         if (li->module == jl_core_module) {
@@ -808,9 +812,12 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
                 size_t i, l = jl_array_len(tf);
                 for(i=0; i < l; i += 3) {
                     if (!jl_is_leaf_type(jl_cellref(tf,i))) {
-                        jl_value_t *ast = jl_cellref(tf,i+1);
-                        if (ast && jl_is_array(ast) && jl_array_len(ast) > 500)
-                            jl_cellset(tf, i+1, jl_ast_rettype(li, (jl_value_t*)ast));
+                        jl_value_t *ret = jl_cellref(tf,i+1);
+                        if (jl_is_tuple(ret)) {
+                            jl_value_t *ast = jl_fieldref(ret, 0);
+                            if (jl_is_array(ast) && jl_array_len(ast) > 500)
+                                jl_cellset(tf, i+1, jl_fieldref(ret,1));
+                        }
                     }
                 }
             }
@@ -820,16 +827,21 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
         jl_serialize_value(s, (jl_value_t*)li->specTypes);
         jl_serialize_value(s, (jl_value_t*)li->specializations);
         write_int8(s, li->inferred);
+        write_int8(s, li->pure);
+        write_int8(s, li->called);
         jl_serialize_value(s, (jl_value_t*)li->file);
         write_int32(s, li->line);
         jl_serialize_value(s, (jl_value_t*)li->module);
         jl_serialize_value(s, (jl_value_t*)li->roots);
         jl_serialize_value(s, (jl_value_t*)li->def);
-        jl_serialize_value(s, (jl_value_t*)li->capt);
         jl_serialize_value(s, (jl_value_t*)li->unspecialized);
+        jl_serialize_fptr(s, li->fptr);
         // save functionObject pointers
         write_int32(s, li->functionID);
         write_int32(s, li->specFunctionID);
+        if (li->functionID)
+            write_int8(s, li->jlcall_api);
+        write_int8(s, li->needs_sparam_vals_ducttape);
     }
     else if (jl_typeis(v, jl_module_type)) {
         jl_serialize_module(s, (jl_module_t*)v);
@@ -853,9 +865,9 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
             if (v == t->instance) {
                 if (mode == MODE_MODULE) {
                     // also flag this in the backref table as special
-                    uptrint_t *bp = (uptrint_t*)ptrhash_bp(&backref_table, v);
-                    assert(*bp != (uptrint_t)HT_NOTFOUND);
-                    *bp |= 1; assert(((uptrint_t)HT_NOTFOUND)|1);
+                    uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, v);
+                    assert(*bp != (uintptr_t)HT_NOTFOUND);
+                    *bp |= 1; assert(((uintptr_t)HT_NOTFOUND)|1);
                 }
                 writetag(s, (jl_value_t*)Singleton_tag);
                 jl_serialize_value(s, t);
@@ -896,7 +908,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
             }
             else {
                 for(size_t i=0; i < nf; i++) {
-                    if (t->fields[i].size > 0) {
+                    if (jl_field_size(t, i) > 0) {
                         jl_serialize_value(s, jl_get_nth_field(v, i));
                     }
                 }
@@ -907,10 +919,10 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
 
 static void jl_serialize_methtable_from_mod(ios_t *s, jl_methtable_t *mt, int8_t iskw)
 {
+    jl_sym_t *name = mt->name;
     if (iskw) {
         if (!mt->kwsorter)
             return;
-        assert(jl_is_gf(mt->kwsorter));
         assert(mt->module == jl_gf_mtable(mt->kwsorter)->module);
         mt = jl_gf_mtable(mt->kwsorter);
         assert(!mt->kwsorter);
@@ -918,16 +930,13 @@ static void jl_serialize_methtable_from_mod(ios_t *s, jl_methtable_t *mt, int8_t
     assert(mt->module);
     jl_methlist_t *ml = mt->defs;
     while (ml != (void*)jl_nothing) {
-        if (module_in_worklist(ml->func->linfo->module)) {
+        if (module_in_worklist(ml->func->module)) {
             jl_serialize_value(s, mt->module);
-            jl_serialize_value(s, mt->name);
+            jl_serialize_value(s, name);
             write_int8(s, iskw);
             jl_serialize_value(s, ml->sig);
             jl_serialize_value(s, ml->func);
-            if (jl_is_svec(ml->tvars))
-                jl_serialize_value(s, ml->tvars);
-            else
-                jl_serialize_value(s, jl_svec1(ml->tvars));
+            jl_serialize_value(s, ml->tvars);
             write_int8(s, ml->isstaged);
         }
         ml = ml->next;
@@ -943,28 +952,27 @@ static void jl_serialize_lambdas_from_mod(ios_t *s, jl_module_t *m)
         if (table[i] != HT_NOTFOUND) {
             jl_binding_t *b = (jl_binding_t*)table[i];
             if (b->owner == m && b->value && b->constp) {
-                if (jl_is_function(b->value) && jl_is_gf(b->value)) {
-                    jl_function_t *gf = (jl_function_t*)b->value;
-                    jl_methtable_t *mt = jl_gf_mtable(gf);
-                    if (mt->name == b->name && mt->module == m) {
-                        jl_serialize_methtable_from_mod(s, mt, 0);
-                        jl_serialize_methtable_from_mod(s, mt, 1);
-                    }
-                }
-                else if (jl_is_module(b->value)) {
+                if (jl_is_module(b->value)) {
                     jl_module_t *child = (jl_module_t*)b->value;
                     if (child != m && child->parent == m && child->name == b->name) {
                         // this is the original/primary binding for the submodule
                         jl_serialize_lambdas_from_mod(s, (jl_module_t*)b->value);
                     }
                 }
+                else {
+                    jl_methtable_t *mt = jl_gf_mtable(b->value);
+                    if (mt && mt->name == b->name && mt->module == m) {
+                        jl_serialize_methtable_from_mod(s, mt, 0);
+                        jl_serialize_methtable_from_mod(s, mt, 1);
+                    }
+                }
             }
         }
     }
 }
 
 // serialize information about all of the modules accessible directly from Main
-void jl_serialize_mod_list(ios_t *s)
+static void jl_serialize_mod_list(ios_t *s)
 {
     jl_module_t *m = jl_main_module;
     size_t i;
@@ -979,9 +987,9 @@ void jl_serialize_mod_list(ios_t *s)
                 jl_module_t *child = (jl_module_t*)b->value;
                 if (child->name == b->name) {
                     // this is the original/primary binding for the submodule
-                    size_t l = strlen(child->name->name);
+                    size_t l = strlen(jl_symbol_name(child->name));
                     write_int32(s, l);
-                    ios_write(s, child->name->name, l);
+                    ios_write(s, jl_symbol_name(child->name), l);
                     write_uint64(s, child->uuid);
                 }
             }
@@ -1000,7 +1008,8 @@ static void jl_serialize_header(ios_t *s)
     write_uint16(s, JI_FORMAT_VERSION);
     ios_write(s, (char *) &BOM, 2);
     write_uint8(s, sizeof(void*));
-    const char *OS_NAME = jl_get_OS_NAME()->name, *ARCH = jl_get_ARCH()->name;
+    const char *OS_NAME = jl_symbol_name(jl_get_OS_NAME());
+    const char *ARCH = jl_symbol_name(jl_get_ARCH());
     ios_write(s, OS_NAME, strlen(OS_NAME)+1);
     ios_write(s, ARCH, strlen(ARCH)+1);
     ios_write(s, JULIA_VERSION_STRING, strlen(JULIA_VERSION_STRING)+1);
@@ -1011,7 +1020,7 @@ static void jl_serialize_header(ios_t *s)
 
 // serialize the global _require_dependencies array of pathnames that
 // are include depenencies
-void jl_serialize_dependency_list(ios_t *s)
+static void jl_serialize_dependency_list(ios_t *s)
 {
     size_t total_size = 0;
     static jl_array_t *deps = NULL;
@@ -1023,10 +1032,11 @@ void jl_serialize_dependency_list(ios_t *s)
     static jl_value_t *unique_func = NULL;
     if (!unique_func)
         unique_func = jl_get_global(jl_base_module, jl_symbol("unique"));
-    jl_array_t *udeps = deps && unique_func ? (jl_array_t *) jl_apply((jl_function_t*)unique_func, (jl_value_t**)&deps, 1) : NULL;
+    jl_value_t *uniqargs[2] = {unique_func,(jl_value_t*)deps};
+    jl_array_t *udeps = deps && unique_func ? (jl_array_t*)jl_apply(uniqargs, 2) : NULL;
 
+    JL_GC_PUSH1(&udeps);
     if (udeps) {
-        JL_GC_PUSH1(&udeps);
         size_t l = jl_array_len(udeps);
         for (size_t i=0; i < l; i++) {
             jl_value_t *dep = jl_fieldref(jl_cellref(udeps, i), 0);
@@ -1049,8 +1059,95 @@ void jl_serialize_dependency_list(ios_t *s)
             write_float64(s, jl_unbox_float64(jl_fieldref(deptuple, 1)));
         }
         write_int32(s, 0); // terminator, for ease of reading
-        JL_GC_POP();
     }
+    JL_GC_POP();
+}
+
+static int is_module_replaced(jl_module_t *m)
+{
+    return (jl_value_t*)m != jl_get_global(m->parent, m->name);
+}
+
+static int type_has_replaced_module(jl_value_t *t)
+{
+    if (jl_is_datatype(t)) {
+        jl_datatype_t *dt = (jl_datatype_t*)t;
+        if (is_module_replaced(dt->name->module))
+            return 1;
+        int i;
+        for(i=0; i < jl_nparams(dt); i++)
+            if (type_has_replaced_module(jl_tparam(dt,i)))
+                return 1;
+    }
+    // TODO: might eventually need to handle more types here
+    return 0;
+}
+
+static void remove_specializations_from_replaced_modules(jl_methlist_t *l)
+{
+    while (l != (void*)jl_nothing) {
+        jl_array_t *a = l->func->specializations;
+        if (a) {
+            size_t len = jl_array_len(a);
+            size_t i, insrt=0;
+            for(i=0; i < len; i++) {
+                jl_lambda_info_t *li = (jl_lambda_info_t*)jl_cellref(a, i);
+                if (!(li->rettype && type_has_replaced_module(li->rettype)) &&
+                    !(li->specTypes && type_has_replaced_module((jl_value_t*)li->specTypes))) {
+                    jl_cellset(a, insrt, li);
+                    insrt++;
+                }
+            }
+            jl_array_del_end(a, len-insrt);
+        }
+        a = l->func->roots;
+        if (a) {
+            size_t len = jl_array_len(a);
+            size_t i;
+            for(i=0; i < len; i++) {
+                jl_value_t *ai = jl_cellref(a, i);
+                if (jl_is_type(ai) && type_has_replaced_module(ai))
+                    jl_cellset(a, i, jl_nothing);
+            }
+        }
+        l = l->next;
+    }
+}
+
+static void remove_methods_from_replaced_modules_from_list(jl_methlist_t **pl)
+{
+    jl_methlist_t *l = *pl;
+    while (l != (void*)jl_nothing) {
+        if ((l->func && is_module_replaced(l->func->module)) ||
+            type_has_replaced_module((jl_value_t*)l->sig))
+            *pl = l->next;
+        else
+            pl = &l->next;
+        l = l->next;
+    }
+}
+
+static void remove_methods_from_replaced_modules_from_cache(jl_array_t *a)
+{
+    jl_value_t **data;
+    size_t i, l = jl_array_len(a); data = (jl_value_t**)jl_array_data(a);
+    for(i=0; i < l; i++) {
+        if (data[i] != NULL)
+            remove_methods_from_replaced_modules_from_list((jl_methlist_t**)&data[i]);
+    }
+}
+
+static void remove_methods_from_replaced_modules(jl_methtable_t *mt)
+{
+    remove_methods_from_replaced_modules_from_list(&mt->defs);
+    remove_methods_from_replaced_modules_from_list(&mt->cache);
+    if ((jl_value_t*)mt->cache_arg1 != jl_nothing)
+        remove_methods_from_replaced_modules_from_cache(mt->cache_arg1);
+    if ((jl_value_t*)mt->cache_targ != jl_nothing)
+        remove_methods_from_replaced_modules_from_cache(mt->cache_targ);
+    remove_specializations_from_replaced_modules(mt->defs);
+    if (mt->kwsorter)
+        remove_methods_from_replaced_modules(jl_gf_mtable(mt->kwsorter));
 }
 
 // --- deserialize ---
@@ -1082,6 +1179,7 @@ static jl_value_t *jl_deserialize_datatype(ios_t *s, int pos, jl_value_t **loc)
     uint16_t nf = read_uint16(s);
     size_t size = read_int32(s);
     uint8_t flags = read_uint8(s);
+    uint8_t fielddesc_type = read_int8(s);
     jl_datatype_t *dt;
     if (tag == 2)
         dt = jl_int32_type;
@@ -1090,7 +1188,7 @@ static jl_value_t *jl_deserialize_datatype(ios_t *s, int pos, jl_value_t **loc)
     else if (tag == 4)
         dt = jl_int64_type;
     else
-        dt = jl_new_uninitialized_datatype(nf);
+        dt = jl_new_uninitialized_datatype(nf, fielddesc_type);
     assert(tree_literal_values==NULL && mode != MODE_AST);
     backref_list.items[pos] = dt;
     dt->size = size;
@@ -1118,14 +1216,15 @@ static jl_value_t *jl_deserialize_datatype(ios_t *s, int pos, jl_value_t **loc)
         assert(pos > 0);
         assert(mode != MODE_MODULE_POSTWORK);
         arraylist_push(&flagref_list, loc);
-        arraylist_push(&flagref_list, (void*)(uptrint_t)pos);
+        arraylist_push(&flagref_list, (void*)(uintptr_t)pos);
         dt->uid = -1; // mark that this type needs a new uid
     }
 
     if (nf > 0) {
         dt->alignment = read_int32(s);
         dt->haspadding = read_int8(s);
-        ios_read(s, (char*)&dt->fields[0], nf*sizeof(jl_fielddesc_t));
+        size_t fieldsize = jl_fielddesc_size(fielddesc_type);
+        ios_read(s, jl_datatype_fields(dt), nf * fieldsize);
         dt->types = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&dt->types);
         jl_gc_wb(dt, dt->types);
     }
@@ -1157,8 +1256,6 @@ static jl_value_t *jl_deserialize_datatype(ios_t *s, int pos, jl_value_t **loc)
     return (jl_value_t*)dt;
 }
 
-jl_array_t *jl_eqtable_put(jl_array_t *h, void *key, void *val);
-
 static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t **loc);
 static jl_value_t *jl_deserialize_value(ios_t *s, jl_value_t **loc)
 {
@@ -1174,7 +1271,7 @@ static jl_value_t *jl_deserialize_value(ios_t *s, jl_value_t **loc)
     }
     if (tag == BackRef_tag || tag == ShortBackRef_tag) {
         assert(tree_literal_values == NULL && mode != MODE_AST);
-        uptrint_t offs = (tag == BackRef_tag) ? read_int32(s) : read_uint16(s);
+        uintptr_t offs = (tag == BackRef_tag) ? read_int32(s) : read_uint16(s);
         int isdatatype = 0;
         if (mode == MODE_MODULE) {
             isdatatype = !!(offs & 1);
@@ -1183,12 +1280,13 @@ static jl_value_t *jl_deserialize_value(ios_t *s, jl_value_t **loc)
         else if (mode == MODE_MODULE_POSTWORK) {
             offs >>= 1;
         }
-        assert(offs >= 0 && offs < backref_list.len);
+        // assert(offs >= 0); // offs is unsigned so this is always true
+        assert(offs < backref_list.len);
         jl_value_t *bp = (jl_value_t*)backref_list.items[offs];
         assert(bp);
         if (isdatatype && loc != NULL) {
             arraylist_push(&flagref_list, loc);
-            arraylist_push(&flagref_list, (void*)(uptrint_t)-1);
+            arraylist_push(&flagref_list, (void*)(uintptr_t)-1);
         }
         return (jl_value_t*)bp;
     }
@@ -1219,7 +1317,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         jl_svec_t *sv = jl_alloc_svec_uninit(len);
         if (usetable)
             arraylist_push(&backref_list, (jl_value_t*)sv);
-        jl_value_t **data = sv->data;
+        jl_value_t **data = jl_svec_data(sv);
         for(i=0; i < len; i++) {
             data[i] = jl_deserialize_value(s, &data[i]);
         }
@@ -1272,12 +1370,12 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
             backref_list.items[pos] = a;
         jl_value_t *aty = jl_deserialize_value(s, &jl_astaggedvalue(a)->type);
         jl_set_typeof(a, aty);
-        if (!a->ptrarray) {
+        if (!a->flags.ptrarray) {
             size_t tot = jl_array_len(a) * a->elsize;
             ios_read(s, (char*)jl_array_data(a), tot);
         }
         else {
-            jl_value_t** data = (jl_value_t**)jl_array_data(a);
+            jl_value_t **data = (jl_value_t**)jl_array_data(a);
             for(i=0; i < jl_array_len(a); i++) {
                 data[i] = jl_deserialize_value(s, &data[i]);
                 if (data[i]) jl_gc_wb(a, data[i]);
@@ -1319,30 +1417,6 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         tv->bound = read_int8(s);
         return (jl_value_t*)tv;
     }
-    else if (vtag == (jl_value_t*)jl_function_type) {
-        if (mode == MODE_MODULE || mode == MODE_MODULE_POSTWORK) {
-            int ref_only = read_int8(s);
-            if (ref_only) {
-                int pos = backref_list.len;
-                arraylist_push(&backref_list, NULL);
-                jl_module_t *module = (jl_module_t*)jl_deserialize_value(s, NULL);
-                jl_sym_t *name = (jl_sym_t*)jl_deserialize_value(s, NULL);
-                jl_value_t *f = jl_get_global(module, name);
-                backref_list.items[pos] = f;
-                return f;
-            }
-        }
-        jl_function_t *f =
-            (jl_function_t*)newobj((jl_value_t*)jl_function_type, NWORDS(sizeof(jl_function_t)));
-        if (usetable)
-            arraylist_push(&backref_list, f);
-        f->linfo = (jl_lambda_info_t*)jl_deserialize_value(s, (jl_value_t**)&f->linfo);
-        if (f->linfo != NULL) jl_gc_wb(f, f->linfo);
-        f->env = jl_deserialize_value(s, &f->env);
-        jl_gc_wb(f, f->env);
-        f->fptr = jl_deserialize_fptr(s);
-        return (jl_value_t*)f;
-    }
     else if (vtag == (jl_value_t*)jl_lambda_info_type) {
         jl_lambda_info_t *li =
             (jl_lambda_info_t*)newobj((jl_value_t*)jl_lambda_info_type,
@@ -1351,8 +1425,12 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
             arraylist_push(&backref_list, li);
         li->ast = jl_deserialize_value(s, &li->ast);
         jl_gc_wb(li, li->ast);
-        li->sparams = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&li->sparams);
-        jl_gc_wb(li, li->sparams);
+        li->rettype = jl_deserialize_value(s, &li->rettype);
+        jl_gc_wb(li, li->rettype);
+        li->sparam_syms = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&li->sparam_syms);
+        jl_gc_wb(li, li->sparam_syms);
+        li->sparam_vals = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&li->sparam_vals);
+        jl_gc_wb(li, li->sparam_vals);
         li->tfunc = jl_deserialize_value(s, (jl_value_t**)&li->tfunc);
         jl_gc_wb(li, li->tfunc);
         li->name = (jl_sym_t*)jl_deserialize_value(s, NULL);
@@ -1362,6 +1440,8 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         li->specializations = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->specializations);
         if (li->specializations) jl_gc_wb(li, li->specializations);
         li->inferred = read_int8(s);
+        li->pure = read_int8(s);
+        li->called = read_int8(s);
         li->file = (jl_sym_t*)jl_deserialize_value(s, NULL);
         jl_gc_wb(li, li->file);
         li->line = read_int32(s);
@@ -1371,22 +1451,23 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         if (li->roots) jl_gc_wb(li, li->roots);
         li->def = (jl_lambda_info_t*)jl_deserialize_value(s, (jl_value_t**)&li->def);
         jl_gc_wb(li, li->def);
-        li->capt = jl_deserialize_value(s, &li->capt);
-        if (li->capt) jl_gc_wb(li, li->capt);
-        li->fptr = &jl_trampoline;
-        li->functionObject = NULL;
-        li->cFunctionList = NULL;
-        li->specFunctionObject = NULL;
+        li->fptr = NULL;
+        li->functionObjects.functionObject = NULL;
+        li->functionObjects.cFunctionList = NULL;
+        li->functionObjects.specFunctionObject = NULL;
         li->inInference = 0;
         li->inCompile = 0;
-        li->unspecialized = (jl_function_t*)jl_deserialize_value(s, (jl_value_t**)&li->unspecialized);
+        li->unspecialized = (jl_lambda_info_t*)jl_deserialize_value(s, (jl_value_t**)&li->unspecialized);
         if (li->unspecialized) jl_gc_wb(li, li->unspecialized);
+        li->fptr = jl_deserialize_fptr(s);
         li->functionID = 0;
         li->specFunctionID = 0;
         int32_t cfunc_llvm, func_llvm;
         func_llvm = read_int32(s);
         cfunc_llvm = read_int32(s);
         jl_delayed_fptrs(li, func_llvm, cfunc_llvm);
+        li->jlcall_api = func_llvm ? read_int8(s) : 0;
+        li->needs_sparam_vals_ducttape = read_int8(s);
         return (jl_value_t*)li;
     }
     else if (vtag == (jl_value_t*)jl_module_type) {
@@ -1426,6 +1507,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
             b->owner = (jl_module_t*)jl_deserialize_value(s, (jl_value_t**)&b->owner);
             if (b->owner != NULL) jl_gc_wb(m, b->owner);
             int8_t flags = read_int8(s);
+            b->deprecated = (flags>>3) & 1;
             b->constp = (flags>>2) & 1;
             b->exportp = (flags>>1) & 1;
             b->imported = (flags) & 1;
@@ -1439,11 +1521,10 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
             m->usings.items[i] = jl_deserialize_value(s, (jl_value_t**)&m->usings.items[i]);
             i++;
         }
-        m->constant_table = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&m->constant_table);
-        if (m->constant_table != NULL) jl_gc_wb(m, m->constant_table);
         m->istopmod = read_uint8(s);
         m->std_imports = read_uint8(s);
         m->uuid = read_uint64(s);
+        m->counter = read_int32(s);
         return (jl_value_t*)m;
     }
     else if (vtag == (jl_value_t*)SmallInt64_tag) {
@@ -1467,7 +1548,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         if (usetable) {
             jl_value_t *v = jl_new_struct_uninit(jl_globalref_type);
             arraylist_push(&backref_list, v);
-            jl_value_t* *data = jl_data_ptr(v);
+            jl_value_t **data = jl_data_ptr(v);
             data[0] = jl_deserialize_value(s, &data[0]);
             data[1] = jl_deserialize_value(s, &data[1]);
             return v;
@@ -1488,6 +1569,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         jl_set_typeof(v, dt);
         if (dt == jl_datatype_type)
             return jl_deserialize_datatype(s, pos, loc);
+        assert(mode==MODE_AST || sz!=0 || loc);
         if ((mode == MODE_MODULE || mode == MODE_MODULE_POSTWORK) && dt == jl_typename_type) {
             int ref_only = read_uint8(s);
             if (ref_only) {
@@ -1510,8 +1592,8 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         else {
             char *data = (char*)jl_data_ptr(v);
             for(i=0; i < nf; i++) {
-                if (dt->fields[i].size > 0) {
-                    if (dt->fields[i].isptr) {
+                if (jl_field_size(dt,i) > 0) {
+                    if (jl_field_isptr(dt,i)) {
                         jl_value_t **fld = (jl_value_t**)(data+jl_field_offset(dt, i));
                         *fld = jl_deserialize_value(s, fld);
                     }
@@ -1524,7 +1606,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
                 if (jl_is_mtable(v))
                     arraylist_push(&methtable_list, v); // will resort this table, later
                 if (dt == jl_typename_type) {
-                    jl_typename_t* tn = (jl_typename_t*)v;
+                    jl_typename_t *tn = (jl_typename_t*)v;
                     tn->uid = jl_assign_type_uid(); // make sure this has a new uid
                     tn->cache = jl_emptysvec; // the cache is refilled later (tag 5)
                     tn->linearcache = jl_emptysvec; // the cache is refilled later (tag 5)
@@ -1535,7 +1617,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
     }
     else if (vtag == (jl_value_t*)Singleton_tag) {
         if (mode == MODE_MODULE_POSTWORK) {
-            uptrint_t pos = backref_list.len;
+            uintptr_t pos = backref_list.len;
             arraylist_push(&backref_list, NULL);
             jl_datatype_t *dt = (jl_datatype_t*)jl_deserialize_value(s, NULL);
             backref_list.items[pos] = dt->instance;
@@ -1543,9 +1625,11 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
         }
         jl_value_t *v = (jl_value_t*)jl_gc_alloc_0w();
         if (usetable) {
-            uptrint_t pos = backref_list.len;
+            uintptr_t pos = backref_list.len;
             arraylist_push(&backref_list, (void*)v);
             if (mode == MODE_MODULE) {
+                // TODO: optimize the case where the value can easily be obtained
+                // from an external module (tag == 6) as dt->instance
                 assert(loc != NULL);
                 arraylist_push(&flagref_list, loc);
                 arraylist_push(&flagref_list, (void*)pos);
@@ -1559,7 +1643,7 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
     return NULL;
 }
 
-void jl_deserialize_lambdas_from_mod(ios_t *s)
+static void jl_deserialize_lambdas_from_mod(ios_t *s)
 {
     while (1) {
         jl_module_t *mod = (jl_module_t*)jl_deserialize_value(s, NULL);
@@ -1568,25 +1652,17 @@ void jl_deserialize_lambdas_from_mod(ios_t *s)
         jl_sym_t *name = (jl_sym_t*)jl_deserialize_value(s, NULL);
         jl_function_t *gf = (jl_function_t*)jl_get_global(mod, name);
         int8_t iskw = read_int8(s);
-        assert(jl_is_gf(gf));
-        if (iskw) {
-            jl_methtable_t* mt = jl_gf_mtable(gf);
-            if (!mt->kwsorter) {
-                mt->kwsorter = jl_new_generic_function(jl_gf_name(gf), mt->module);
-                jl_gc_wb(mt, mt->kwsorter);
-            }
-            gf = mt->kwsorter;
-            assert(jl_is_gf(gf));
-        }
+        if (iskw)
+            gf = jl_get_kwsorter(((jl_datatype_t*)jl_typeof(gf))->name);
         jl_tupletype_t *types = (jl_tupletype_t*)jl_deserialize_value(s, NULL);
-        jl_function_t *meth = (jl_function_t*)jl_deserialize_value(s, NULL);
+        jl_lambda_info_t *meth = (jl_lambda_info_t*)jl_deserialize_value(s, NULL);
         jl_svec_t *tvars = (jl_svec_t*)jl_deserialize_value(s, NULL);
         int8_t isstaged = read_int8(s);
-        jl_add_method(gf, types, meth, tvars, isstaged);
+        jl_method_table_insert(jl_gf_mtable(gf), types, meth, tvars, isstaged);
     }
 }
 
-int jl_deserialize_verify_mod_list(ios_t *s)
+static int jl_deserialize_verify_mod_list(ios_t *s)
 {
     if (!jl_main_module->uuid) {
         jl_printf(JL_STDERR, "ERROR: Main module uuid state is invalid for module deserialization.\n");
@@ -1606,8 +1682,9 @@ int jl_deserialize_verify_mod_list(ios_t *s)
             static jl_value_t *require_func = NULL;
             if (!require_func)
                 require_func = jl_get_global(jl_base_module, jl_symbol("require"));
+            jl_value_t *reqargs[2] = {require_func, (jl_value_t*)sym};
             JL_TRY {
-                jl_apply((jl_function_t*)require_func, (jl_value_t**)&sym, 1);
+                jl_apply(reqargs, 2);
             }
             JL_CATCH {
                 ios_close(s);
@@ -1624,7 +1701,11 @@ int jl_deserialize_verify_mod_list(ios_t *s)
             jl_errorf("invalid module path (%s does not name a module)", name);
         }
         if (m->uuid != uuid) {
-            jl_printf(JL_STDERR, "WARNING: Module %s uuid did not match cache file\n", name);
+            jl_printf(JL_STDERR,
+                      "WARNING: Module %s uuid did not match cache file\n"
+                      "  This is likely because module %s does not support"
+                      "  precompilation but is imported by a module that does.\n",
+                      name, name);
             return 0;
         }
     }
@@ -1639,15 +1720,15 @@ static int readstr_verify(ios_t *s, const char *str)
     return 1;
 }
 
-DLLEXPORT int jl_deserialize_verify_header(ios_t *s)
+JL_DLLEXPORT int jl_deserialize_verify_header(ios_t *s)
 {
     uint16_t bom;
     return (readstr_verify(s, JI_MAGIC) &&
             read_uint16(s) == JI_FORMAT_VERSION &&
             ios_read(s, (char *) &bom, 2) == 2 && bom == BOM &&
             read_uint8(s) == sizeof(void*) &&
-            readstr_verify(s, jl_get_OS_NAME()->name) && !read_uint8(s) &&
-            readstr_verify(s, jl_get_ARCH()->name) && !read_uint8(s) &&
+            readstr_verify(s, jl_symbol_name(jl_get_OS_NAME())) && !read_uint8(s) &&
+            readstr_verify(s, jl_symbol_name(jl_get_ARCH())) && !read_uint8(s) &&
             readstr_verify(s, JULIA_VERSION_STRING) && !read_uint8(s) &&
             readstr_verify(s, jl_git_branch()) && !read_uint8(s) &&
             readstr_verify(s, jl_git_commit()) && !read_uint8(s));
@@ -1681,28 +1762,30 @@ static void jl_reinit_item(ios_t *f, jl_value_t *v, int how) {
     JL_TRY {
         switch (how) {
             case 1: { // rehash ObjectIdDict
-                jl_array_t **a = (jl_array_t**)&v->fieldptr[0];
+                jl_array_t **a = (jl_array_t**)v;
                 jl_idtable_rehash(a, jl_array_len(*a));
                 jl_gc_wb(v, *a);
                 break;
-                    }
+            }
             case 2: { // reinsert module v into parent (const)
                 jl_module_t *mod = (jl_module_t*)v;
                 jl_binding_t *b = jl_get_binding_wr(mod->parent, mod->name);
                 jl_declare_constant(b); // this can throw
                 if (b->value != NULL) {
                     if (!jl_is_module(b->value)) {
-                        jl_errorf("invalid redefinition of constant %s", mod->name->name); // this also throws
+                        jl_errorf("invalid redefinition of constant %s",
+                                  jl_symbol_name(mod->name)); // this also throws
                     }
                     if (jl_generating_output() && jl_options.incremental) {
-                        jl_errorf("cannot replace module %s during incremental precompile", mod->name->name);
+                        jl_errorf("cannot replace module %s during incremental precompile", jl_symbol_name(mod->name));
                     }
-                    jl_printf(JL_STDERR, "WARNING: replacing module %s\n", mod->name->name);
+                    jl_printf(JL_STDERR, "WARNING: replacing module %s\n",
+                              jl_symbol_name(mod->name));
                 }
                 b->value = v;
                 jl_gc_wb_binding(b, v);
                 break;
-                    }
+            }
             default:
                 assert(0);
         }
@@ -1743,11 +1826,12 @@ void jl_init_restored_modules(jl_array_t *init_order)
 
 // --- entry points ---
 
-void jl_save_system_image_to_stream(ios_t *f)
+static void jl_save_system_image_to_stream(ios_t *f)
 {
     jl_gc_collect(1); // full
     jl_gc_collect(0); // incremental (sweep finalizers)
     JL_SIGATOMIC_BEGIN();
+    JL_LOCK(dump); // Might GC
     int en = jl_gc_enable(0);
     htable_reset(&backref_table, 250000);
     arraylist_new(&reinit_list, 0);
@@ -1756,14 +1840,27 @@ void jl_save_system_image_to_stream(ios_t *f)
     // orphan old Base module if present
     jl_base_module = (jl_module_t*)jl_get_global(jl_main_module, jl_symbol("Base"));
 
+    // empty!(Core.ARGS)
+    if (jl_core_module != NULL) {
+        jl_array_t *args = (jl_array_t*)jl_get_global(jl_core_module, jl_symbol("ARGS"));
+        if (args != NULL) {
+            jl_array_del_end(args, jl_array_len(args));
+        }
+    }
+
+    // remove constructors (which go in a single shared method table) from modules
+    // that were replaced during bootstrap.
+    remove_methods_from_replaced_modules(jl_datatype_type->name->mt);
+
     jl_idtable_type = jl_base_module ? jl_get_global(jl_base_module, jl_symbol("ObjectIdDict")) : NULL;
 
     jl_serialize_value(f, jl_main_module);
     jl_serialize_value(f, jl_top_module);
     jl_serialize_value(f, jl_typeinf_func);
+    jl_serialize_value(f, jl_type_type->name->mt);
 
     // ensure everything in deser_tag is reassociated with its GlobalValue
-    ptrint_t i=2;
+    intptr_t i=2;
     for (i=2; i < 255; i++) {
         jl_serialize_gv(f, deser_tag[i]);
     }
@@ -1778,10 +1875,11 @@ void jl_save_system_image_to_stream(ios_t *f)
     arraylist_free(&reinit_list);
 
     jl_gc_enable(en);
+    JL_UNLOCK(dump);
     JL_SIGATOMIC_END();
 }
 
-DLLEXPORT void jl_save_system_image(const char *fname)
+JL_DLLEXPORT void jl_save_system_image(const char *fname)
 {
     ios_t f;
     if (ios_file(&f, fname, 1, 1, 1, 1) == NULL) {
@@ -1793,9 +1891,9 @@ DLLEXPORT void jl_save_system_image(const char *fname)
     JL_SIGATOMIC_END();
 }
 
-DLLEXPORT ios_t *jl_create_system_image()
+JL_DLLEXPORT ios_t *jl_create_system_image(void)
 {
-    ios_t *f; f = (ios_t*)malloc(sizeof(ios_t));
+    ios_t *f = (ios_t*)malloc(sizeof(ios_t));
     ios_mem(f, 1000000);
     jl_save_system_image_to_stream(f);
     return f;
@@ -1803,11 +1901,12 @@ DLLEXPORT ios_t *jl_create_system_image()
 
 extern jl_function_t *jl_typeinf_func;
 extern int jl_boot_file_loaded;
+extern void jl_get_builtins(void);
 extern void jl_get_builtin_hooks(void);
 extern void jl_get_system_hooks(void);
 
 // Takes in a path of the form "usr/lib/julia/sys.{ji,so}", as passed to jl_restore_system_image()
-DLLEXPORT void jl_preload_sysimg_so(const char *fname)
+JL_DLLEXPORT void jl_preload_sysimg_so(const char *fname)
 {
     // If passed NULL, don't even bother
     if (!fname)
@@ -1824,7 +1923,7 @@ DLLEXPORT void jl_preload_sysimg_so(const char *fname)
     }
 
     // Get handle to sys.so
-    jl_sysimg_handle = (uv_lib_t*)jl_load_dynamic_library_e(fname_shlib, JL_RTLD_DEFAULT | JL_RTLD_GLOBAL);
+    jl_sysimg_handle = jl_load_dynamic_library_e(fname_shlib, JL_RTLD_DEFAULT | JL_RTLD_GLOBAL);
 
     // set cpu target if unspecified by user and available from sysimg
     // otherwise default to native.
@@ -1832,9 +1931,10 @@ DLLEXPORT void jl_preload_sysimg_so(const char *fname)
         jl_options.cpu_target = (const char *)jl_dlsym(jl_sysimg_handle, "jl_sysimg_cpu_target");
 }
 
-void jl_restore_system_image_from_stream(ios_t *f)
+static void jl_restore_system_image_from_stream(ios_t *f)
 {
     JL_SIGATOMIC_BEGIN();
+    JL_LOCK(dump); // Might GC
     int en = jl_gc_enable(0);
     DUMP_MODES last_mode = mode;
     mode = MODE_SYSTEM_IMAGE;
@@ -1846,6 +1946,10 @@ void jl_restore_system_image_from_stream(ios_t *f)
     jl_top_module = (jl_module_t*)jl_deserialize_value(f, NULL);
     jl_internal_main_module = jl_main_module;
     jl_typeinf_func = (jl_function_t*)jl_deserialize_value(f, NULL);
+    jl_type_type->name->mt = (jl_methtable_t*)jl_deserialize_value(f, NULL);
+    jl_typector_type->name->mt = jl_uniontype_type->name->mt = jl_datatype_type->name->mt =
+        jl_type_type->name->mt;
+
     jl_core_module = (jl_module_t*)jl_get_global(jl_main_module,
                                                  jl_symbol("Core"));
     jl_base_module = (jl_module_t*)jl_get_global(jl_main_module,
@@ -1853,7 +1957,7 @@ void jl_restore_system_image_from_stream(ios_t *f)
     jl_current_module = jl_base_module; // run start_image in Base
 
     // ensure everything in deser_tag is reassociated with its GlobalValue
-    ptrint_t i;
+    intptr_t i;
     for (i=2; i < 255; i++) {
         jl_deserialize_gv(f, deser_tag[i]);
     }
@@ -1864,6 +1968,9 @@ void jl_restore_system_image_from_stream(ios_t *f)
     int gs_ctr = read_int32(f);
     jl_module_init_order = jl_finalize_deserializer(f); // done with f
 
+    jl_set_t_uid_ctr(uid_ctr);
+    jl_set_gs_ctr(gs_ctr);
+
     // cache builtin parametric types
     for(int i=0; i < jl_array_len(datatype_list); i++) {
         jl_value_t *v = jl_cellref(datatype_list, i);
@@ -1871,6 +1978,7 @@ void jl_restore_system_image_from_stream(ios_t *f)
     }
     datatype_list = NULL;
 
+    jl_get_builtins();
     jl_get_builtin_hooks();
     if (jl_base_module) {
         jl_get_system_hooks();
@@ -1878,19 +1986,17 @@ void jl_restore_system_image_from_stream(ios_t *f)
     jl_boot_file_loaded = 1;
     jl_init_box_caches();
 
-    jl_set_t_uid_ctr(uid_ctr);
-    jl_set_gs_ctr(gs_ctr);
-
     //jl_printf(JL_STDERR, "backref_list.len = %d\n", backref_list.len);
     arraylist_free(&backref_list);
 
     jl_gc_enable(en);
     mode = last_mode;
     jl_update_all_fptrs();
+    JL_UNLOCK(dump);
     JL_SIGATOMIC_END();
 }
 
-DLLEXPORT void jl_restore_system_image(const char *fname)
+JL_DLLEXPORT void jl_restore_system_image(const char *fname)
 {
     char *dot = (char*) strrchr(fname, '.');
     int is_ji = (dot && !strcmp(dot, ".ji"));
@@ -1914,7 +2020,7 @@ DLLEXPORT void jl_restore_system_image(const char *fname)
     }
 }
 
-DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len)
+JL_DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len)
 {
     ios_t f;
     JL_SIGATOMIC_BEGIN();
@@ -1924,95 +2030,67 @@ DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len)
     JL_SIGATOMIC_END();
 }
 
-DLLEXPORT jl_value_t *jl_ast_rettype(jl_lambda_info_t *li, jl_value_t *ast)
-{
-    if (jl_is_expr(ast))
-        return jl_lam_body((jl_expr_t*)ast)->etype;
-    JL_SIGATOMIC_BEGIN();
-    DUMP_MODES last_mode = mode;
-    mode = MODE_AST;
-    if (li->module->constant_table == NULL) {
-        li->module->constant_table = jl_alloc_cell_1d(0);
-        jl_gc_wb(li->module, li->module->constant_table);
-    }
-    tree_literal_values = li->module->constant_table;
-    ios_t src;
-    jl_array_t *bytes = (jl_array_t*)ast;
-    ios_mem(&src, 0);
-    ios_setbuf(&src, (char*)bytes->data, jl_array_len(bytes), 0);
-    src.size = jl_array_len(bytes);
-    int en = jl_gc_enable(0);
-    jl_value_t *rt = jl_deserialize_value(&src, NULL);
-    jl_gc_enable(en);
-    tree_literal_values = NULL;
-    mode = last_mode;
-    JL_SIGATOMIC_END();
-    return rt;
-}
-
-DLLEXPORT jl_value_t *jl_compress_ast(jl_lambda_info_t *li, jl_value_t *ast)
+JL_DLLEXPORT jl_value_t *jl_compress_ast(jl_lambda_info_t *li, jl_value_t *ast)
 {
     JL_SIGATOMIC_BEGIN();
+    JL_LOCK(dump); // Might GC
     DUMP_MODES last_mode = mode;
     mode = MODE_AST;
     ios_t dest;
     ios_mem(&dest, 0);
     jl_array_t *last_tlv = tree_literal_values;
     jl_module_t *last_tem = tree_enclosing_module;
-    int en = jl_gc_enable(0);
+    int en = jl_gc_enable(0); // Might GC
 
-    if (li->module->constant_table == NULL) {
-        li->module->constant_table = jl_alloc_cell_1d(0);
-        jl_gc_wb(li->module, li->module->constant_table);
+    if (li->def->roots == NULL) {
+        li->def->roots = jl_alloc_cell_1d(0);
+        jl_gc_wb(li->def, li->def->roots);
     }
-    tree_literal_values = li->module->constant_table;
+    tree_literal_values = li->def->roots;
     tree_enclosing_module = li->module;
-    li->capt = (jl_value_t*)jl_lam_capt((jl_expr_t*)ast);
-    jl_gc_wb(li, li->capt);
-    if (jl_array_len(li->capt) == 0)
-        li->capt = NULL;
-    jl_serialize_value(&dest, jl_lam_body((jl_expr_t*)ast)->etype);
     jl_serialize_value(&dest, ast);
 
     //jl_printf(JL_STDERR, "%d bytes, %d values\n", dest.size, vals->length);
 
     jl_value_t *v = (jl_value_t*)jl_takebuf_array(&dest);
     if (jl_array_len(tree_literal_values) == 0 && last_tlv == NULL) {
-        li->module->constant_table = NULL;
+        li->def->roots = NULL;
     }
     tree_literal_values = last_tlv;
     tree_enclosing_module = last_tem;
     jl_gc_enable(en);
     mode = last_mode;
+    JL_UNLOCK(dump);
     JL_SIGATOMIC_END();
     return v;
 }
 
-DLLEXPORT jl_value_t *jl_uncompress_ast(jl_lambda_info_t *li, jl_value_t *data)
+JL_DLLEXPORT jl_value_t *jl_uncompress_ast(jl_lambda_info_t *li, jl_value_t *data)
 {
     JL_SIGATOMIC_BEGIN();
+    JL_LOCK(dump); // Might GC
     assert(jl_is_array(data));
     DUMP_MODES last_mode = mode;
     mode = MODE_AST;
     jl_array_t *bytes = (jl_array_t*)data;
-    tree_literal_values = li->module->constant_table;
+    tree_literal_values = li->def->roots;
     tree_enclosing_module = li->module;
     ios_t src;
     ios_mem(&src, 0);
     ios_setbuf(&src, (char*)bytes->data, jl_array_len(bytes), 0);
     src.size = jl_array_len(bytes);
-    int en = jl_gc_enable(0);
-    (void)jl_deserialize_value(&src, NULL); // skip ret type
+    int en = jl_gc_enable(0); // Might GC
     jl_value_t *v = jl_deserialize_value(&src, NULL);
     jl_gc_enable(en);
     tree_literal_values = NULL;
     tree_enclosing_module = NULL;
     mode = last_mode;
+    JL_UNLOCK(dump);
     JL_SIGATOMIC_END();
     return v;
 }
 
-DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
+JL_DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
 {
     char *tmpfname = strcat(strcpy((char *) alloca(strlen(fname)+8), fname), ".XXXXXX");
     ios_t f;
@@ -2026,6 +2104,7 @@ DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
     jl_serialize_dependency_list(&f);
 
     JL_SIGATOMIC_BEGIN();
+    JL_LOCK(dump); // Might GC
     arraylist_new(&reinit_list, 0);
     htable_new(&backref_table, 5000);
     ptrhash_put(&backref_table, jl_main_module, (char*)HT_NOTFOUND + 1);
@@ -2050,6 +2129,7 @@ DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
     htable_reset(&backref_table, 0);
     arraylist_free(&reinit_list);
     ios_close(&f);
+    JL_UNLOCK(dump);
     JL_SIGATOMIC_END();
 
     if (jl_fs_rename(tmpfname, fname) < 0) {
@@ -2060,41 +2140,43 @@ DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist)
     return 0;
 }
 
-jl_function_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tupletype_t *type,
-                                      jl_function_t *method);
-
-static jl_datatype_t *jl_recache_type(jl_datatype_t *dt, size_t start)
+static jl_datatype_t *jl_recache_type(jl_datatype_t *dt, size_t start, jl_value_t *v)
 {
-    assert(dt->uid == -1);
-    jl_svec_t *tt = dt->parameters;
-    jl_value_t *v = dt->instance; // the instance before unique'ing
+    if (v == NULL)
+        v = dt->instance; // the instance before unique'ing
     jl_datatype_t *t; // the type after unique'ing
-    size_t l = jl_svec_len(tt);
-    if (l == 0) { // jl_cache_type doesn't work if length(parameters) == 0
-        dt->uid = jl_assign_type_uid();
-        t = dt;
-    }
-    else {
-        // recache all type parameters, then type type itself
-        size_t i;
-        for (i = 0; i < l; i++) {
-            jl_datatype_t *p = (jl_datatype_t*)jl_svecref(tt, i);
-            if (jl_is_datatype(p) && p->uid == -1) {
-                jl_datatype_t *cachep = jl_recache_type(p, start);
-                if (p != cachep)
-                    jl_svecset(tt, i, cachep);
-            }
-            jl_datatype_t *tp = (jl_datatype_t*)jl_typeof(p);
-            if (jl_is_datatype_singleton(tp)) {
-                if (tp->uid == -1) {
-                    tp = jl_recache_type(tp, start);
+    if (dt->uid == -1) {
+        jl_svec_t *tt = dt->parameters;
+        size_t l = jl_svec_len(tt);
+        if (l == 0) { // jl_cache_type doesn't work if length(parameters) == 0
+            dt->uid = jl_assign_type_uid();
+            t = dt;
+        }
+        else {
+            // recache all type parameters, then type type itself
+            size_t i;
+            for (i = 0; i < l; i++) {
+                jl_datatype_t *p = (jl_datatype_t*)jl_svecref(tt, i);
+                if (jl_is_datatype(p) && p->uid == -1) {
+                    jl_datatype_t *cachep = jl_recache_type(p, start, NULL);
+                    if (p != cachep)
+                        jl_svecset(tt, i, cachep);
+                }
+                jl_datatype_t *tp = (jl_datatype_t*)jl_typeof(p);
+                if (jl_is_datatype_singleton(tp)) {
+                    if (tp->uid == -1) {
+                        tp = jl_recache_type(tp, start, NULL);
+                    }
+                    if ((jl_value_t*)p != tp->instance)
+                        jl_svecset(tt, i, tp->instance);
                 }
-                if ((jl_value_t*)p != tp->instance)
-                    jl_svecset(tt, i, tp->instance);
             }
+            dt->uid = 0;
+            t = (jl_datatype_t*)jl_cache_type_(dt);
         }
-        dt->uid = 0;
-        t = (jl_datatype_t*)jl_cache_type_(dt);
+    }
+    else {
+        t = dt;
     }
     assert(t->uid != 0);
     // delete / replace any other usages of this type in the backref list
@@ -2130,7 +2212,7 @@ static jl_datatype_t *jl_recache_type(jl_datatype_t *dt, size_t start)
     return t;
 }
 
-static void jl_recache_types()
+static void jl_recache_types(void)
 {
     size_t i = 0;
     while (i < flagref_list.len) {
@@ -2141,26 +2223,24 @@ static void jl_recache_types()
         if (jl_is_datatype(o)) {
             dt = (jl_datatype_t*)o;
             v = dt->instance;
-            t = jl_recache_type(dt, i);
+            assert(dt->uid == -1);
+            t = jl_recache_type(dt, i, NULL);
         }
         else {
             dt = (jl_datatype_t*)jl_typeof(o);
             v = o;
-            if (dt->uid == -1)
-                t = jl_recache_type(dt, i);
-            else
-                t = dt;
+            t = jl_recache_type(dt, i, v);
         }
         assert(dt);
         if (t != dt) {
-            jl_set_typeof(dt, (jl_value_t*)(ptrint_t)0x10); // invalidate the old value to help catch errors
+            jl_set_typeof(dt, (jl_value_t*)(intptr_t)0x10); // invalidate the old value to help catch errors
             if ((jl_value_t*)dt == o) {
                 if (loc) *loc = (jl_value_t*)t;
                 if (offs > 0) backref_list.items[offs] = t;
             }
         }
         if (t->instance != v) {
-            jl_set_typeof(v, (jl_value_t*)(ptrint_t)0x20); // invalidate the old value to help catch errors
+            jl_set_typeof(v, (jl_value_t*)(intptr_t)0x20); // invalidate the old value to help catch errors
             if (v == o) {
                 *loc = t->instance;
                 if (offs > 0) backref_list.items[offs] = t->instance;
@@ -2183,6 +2263,7 @@ static jl_array_t *_jl_restore_incremental(ios_t *f)
     size_t deplen = read_uint64(f);
     ios_skip(f, deplen); // skip past the dependency list
     JL_SIGATOMIC_BEGIN();
+    JL_LOCK(dump); // Might GC
     arraylist_new(&backref_list, 4000);
     arraylist_push(&backref_list, jl_main_module);
     arraylist_new(&flagref_list, 0);
@@ -2242,6 +2323,7 @@ static jl_array_t *_jl_restore_incremental(ios_t *f)
     arraylist_free(&methtable_list);
     arraylist_free(&backref_list);
     ios_close(f);
+    JL_UNLOCK(dump);
     JL_SIGATOMIC_END();
 
     JL_GC_PUSH2(&init_order,&restored);
@@ -2251,7 +2333,8 @@ static jl_array_t *_jl_restore_incremental(ios_t *f)
     return restored;
 }
 
-DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(const char *buf, size_t sz)
+JL_DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(const char *buf,
+                                                         size_t sz)
 {
     ios_t f;
     jl_array_t *modules;
@@ -2260,7 +2343,7 @@ DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(const char *buf, size_t sz
     return modules ? (jl_value_t*) modules : jl_nothing;
 }
 
-DLLEXPORT jl_value_t *jl_restore_incremental(const char *fname)
+JL_DLLEXPORT jl_value_t *jl_restore_incremental(const char *fname)
 {
     ios_t f;
     jl_array_t *modules;
@@ -2282,7 +2365,7 @@ void jl_init_serializer(void)
     htable_new(&backref_table, 0);
 
     void *tags[] = { jl_symbol_type, jl_gensym_type, jl_datatype_type,
-                     jl_function_type, jl_simplevector_type, jl_array_type,
+                     jl_simplevector_type, jl_array_type,
                      jl_expr_type, (void*)LongSymbol_tag, (void*)LongSvec_tag,
                      (void*)LongExpr_tag, (void*)LiteralVal_tag,
                      (void*)SmallInt64_tag, (void*)SmallDataType_tag,
@@ -2293,7 +2376,7 @@ void jl_init_serializer(void)
 
                      jl_emptysvec, jl_emptytuple, jl_false, jl_true, jl_nothing, jl_any_type,
                      call_sym, goto_ifnot_sym, return_sym, body_sym, line_sym,
-                     lambda_sym, tuple_sym, assign_sym,
+                     lambda_sym, jl_symbol("tuple"), assign_sym,
 
                      // empirical list of very common symbols
                      #include "common_symbols1.inc"
@@ -2340,8 +2423,8 @@ void jl_init_serializer(void)
                      jl_gotonode_type, jl_quotenode_type, jl_topnode_type,
                      jl_type_type, jl_bottom_type, jl_ref_type, jl_pointer_type,
                      jl_vararg_type, jl_ntuple_type, jl_abstractarray_type,
-                     jl_densearray_type, jl_box_type, jl_void_type,
-                     jl_typector_type, jl_typename_type,
+                     jl_densearray_type, jl_void_type, jl_function_type,
+                     jl_typector_type, jl_typename_type, jl_builtin_type,
                      jl_task_type, jl_uniontype_type, jl_typetype_type, jl_typetype_tvar,
                      jl_ANY_flag, jl_array_any_type, jl_intrinsic_type, jl_method_type,
                      jl_methtable_type, jl_voidpointer_type, jl_newvarnode_type,
@@ -2354,13 +2437,13 @@ void jl_init_serializer(void)
                      jl_methtable_type->name, jl_method_type->name, jl_tvar_type->name,
                      jl_ntuple_type->name, jl_abstractarray_type->name, jl_vararg_type->name,
                      jl_densearray_type->name, jl_void_type->name, jl_lambda_info_type->name,
-                     jl_module_type->name, jl_box_type->name, jl_function_type->name,
+                     jl_module_type->name, jl_function_type->name,
                      jl_typector_type->name, jl_intrinsic_type->name, jl_task_type->name,
-                     jl_labelnode_type->name, jl_linenumbernode_type->name,
+                     jl_labelnode_type->name, jl_linenumbernode_type->name, jl_builtin_type->name,
                      jl_gotonode_type->name, jl_quotenode_type->name, jl_topnode_type->name,
                      jl_globalref_type->name,
 
-                     jl_root_task, jl_bottom_func,
+                     jl_root_task,
 
                      NULL };
 
@@ -2370,14 +2453,14 @@ void jl_init_serializer(void)
         NULL
     };
 
-    ptrint_t i=2;
+    intptr_t i=2;
     while (tags[i-2] != NULL) {
         ptrhash_put(&ser_tag, tags[i-2], (void*)i);
         deser_tag[i] = (jl_value_t*)tags[i-2];
         i += 1;
     }
     assert(i <= Null_tag);
-    VALUE_TAGS = (ptrint_t)ptrhash_get(&ser_tag, jl_emptysvec);
+    VALUE_TAGS = (intptr_t)ptrhash_get(&ser_tag, jl_emptysvec);
 
     i=2;
     while (id_to_fptrs[i] != NULL) {
diff --git a/src/flisp/Makefile b/src/flisp/Makefile
index bec862493544c..67d35ffe9ae09 100644
--- a/src/flisp/Makefile
+++ b/src/flisp/Makefile
@@ -1,41 +1,38 @@
-JULIAHOME = $(abspath ../..)
+JULIAHOME := $(abspath ../..)
+BUILDDIR := .
 include $(JULIAHOME)/Make.inc
 
 override CFLAGS += $(JCFLAGS)
 override CXXFLAGS += $(JCXXFLAGS)
 override CPPFLAGS += $(JCPPFLAGS)
 
-BUILDDIR ?= .
+NAME := flisp
+EXENAME := $(NAME)
+LIBTARGET := lib$(NAME)
 
-NAME = flisp
-EXENAME = $(NAME)
-LIBTARGET = lib$(NAME)
-
-SRCS = flisp.c builtins.c string.c equalhash.c table.c iostream.c \
+SRCS := flisp.c builtins.c string.c equalhash.c table.c iostream.c \
         julia_extensions.c
-ifeq ($(USEMSVC), 1)
-SRCS += dirname.c
-endif
 
-HEADERS = $(wildcard *.h) $(LIBUV_INC)/uv.h
+HEADERS := $(wildcard *.h) $(LIBUV_INC)/uv.h
 
-OBJS = $(SRCS:%.c=$(BUILDDIR)/%.o)
-DOBJS = $(SRCS:%.c=$(BUILDDIR)/%.dbg.obj)
-LLTDIR = ../support
-LLT_release = $(BUILDDIR)/$(LLTDIR)/libsupport.a
-LLT_debug = $(BUILDDIR)/$(LLTDIR)/libsupport-debug.a
-LIBFILES_release = $(LLT_release) $(LIBUV) $(LIBUTF8PROC)
-LIBFILES_debug = $(LLT_debug) $(LIBUV) $(LIBUTF8PROC)
-LIBS =
+OBJS := $(SRCS:%.c=$(BUILDDIR)/%.o)
+DOBJS := $(SRCS:%.c=$(BUILDDIR)/%.dbg.obj)
+LLTDIR := ../support
+LLT_release := $(BUILDDIR)/$(LLTDIR)/libsupport.a
+LLT_debug := $(BUILDDIR)/$(LLTDIR)/libsupport-debug.a
+LIBFILES_release := $(LLT_release) $(LIBUV) $(LIBUTF8PROC)
+LIBFILES_debug := $(LLT_debug) $(LIBUV) $(LIBUTF8PROC)
+LIBS :=
 ifneq ($(OS),WINNT)
 LIBS += -lpthread
 endif
 
-FLAGS = -I$(LLTDIR) $(CFLAGS) $(HFILEDIRS:%=-I%) \
+FLAGS := -I$(LLTDIR) $(CFLAGS) $(HFILEDIRS:%=-I%) \
         -I$(LIBUV_INC) -I$(build_includedir) $(LIBDIRS:%=-L%) \
         -DLIBRARY_EXPORTS -DUTF8PROC_EXPORTS
 ifneq ($(USEMSVC), 1)
-FLAGS += -Wall -Wno-strict-aliasing -DUSE_COMPUTED_GOTO -fvisibility=hidden
+FLAGS += -Wall -Wno-strict-aliasing -DUSE_COMPUTED_GOTO -fvisibility=hidden -Wpointer-arith -Wundef
+FLAGS += -Wold-style-definition -Wstrict-prototypes -Wc++-compat
 endif
 
 DEBUGFLAGS += $(FLAGS)
@@ -48,7 +45,7 @@ release: $(BUILDDIR)/$(EXENAME)
 debug: $(BUILDDIR)/$(EXENAME)-debug
 
 $(BUILDDIR):
-	mkdir $(BUILDDIR)
+	mkdir -p $(BUILDDIR)
 
 $(BUILDDIR)/%.o: %.c $(HEADERS) | $(BUILDDIR)
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(SHIPFLAGS) $(DISABLE_ASSERTIONS) -c $< -o $@)
@@ -68,20 +65,19 @@ $(LLT_debug): $(LLTDIR)/*.h $(LLTDIR)/*.c
 $(BUILDDIR)/$(LIBTARGET)-debug.a: $(DOBJS) | $(BUILDDIR)
 	rm -rf $@
 	@$(call PRINT_LINK, $(AR) -rcs $@ $(DOBJS))
-	ln -sf $@ $(LIBTARGET).a
 
 $(BUILDDIR)/$(LIBTARGET).a: $(OBJS) | $(BUILDDIR)
 	rm -rf $@
 	@$(call PRINT_LINK, $(AR) -rcs $@ $(OBJS))
 
 ifneq ($(USEMSVC), 1)
-CCLD = $(CC)
+CCLD := $(CC)
 else
-CCLD = $(LD)
+CCLD := $(LD)
 endif
 
-$(BUILDDIR)/$(EXENAME)-debug: $(DOBJS) $(LIBFILES_debug) $(BUILDDIR)/$(LIBTARGET)-debug.a $(BUILDDIR)/flmain.dbg.obj
-	@$(call PRINT_LINK, $(CCLD) $(DEBUGFLAGS) $(DOBJS) $(BUILDDIR)/flmain.dbg.obj -o $@ $(BUILDDIR)/$(LIBTARGET).a $(LIBFILES_debug) $(LIBS) $(OSLIBS))
+$(BUILDDIR)/$(EXENAME)-debug: $(DOBJS) $(LIBFILES_debug) $(BUILDDIR)/$(LIBTARGET)-debug.a $(BUILDDIR)/flmain.dbg.obj | $(BUILDDIR)/flisp.boot
+	@$(call PRINT_LINK, $(CCLD) $(DEBUGFLAGS) $(DOBJS) $(BUILDDIR)/flmain.dbg.obj -o $@ $(BUILDDIR)/$(LIBTARGET)-debug.a $(LIBFILES_debug) $(LIBS) $(OSLIBS))
 
 $(BUILDDIR)/$(EXENAME): $(OBJS) $(LIBFILES_release) $(BUILDDIR)/$(LIBTARGET).a $(BUILDDIR)/flmain.o | $(BUILDDIR)/flisp.boot
 	@$(call PRINT_LINK, $(CCLD) $(SHIPFLAGS) $(OBJS) $(BUILDDIR)/flmain.o -o $@ $(BUILDDIR)/$(LIBTARGET).a $(LIBFILES_release) $(LIBS) $(OSLIBS))
diff --git a/src/flisp/Windows.mk b/src/flisp/Windows.mk
index 9e9b83db129ec..56410473d2d40 100644
--- a/src/flisp/Windows.mk
+++ b/src/flisp/Windows.mk
@@ -10,8 +10,7 @@ SOURCES = \
 	equalhash.c \
 	table.c \
 	iostream.c \
-	julia_extensions.c \
-	dirname.c
+	julia_extensions.c
 
 HEADERS = \
 	flisp.h \
@@ -25,8 +24,7 @@ OBJECTS = \
 	equalhash.obj \
 	table.obj \
 	iostream.obj \
-	julia_extensions.obj \
-	dirname.obj
+	julia_extensions.obj
 
 LIBUV = $(MAKEDIR)\..\..\deps\libuv\libuv.lib
 LIBUTF8PROC = $(MAKEDIR)\..\..\deps\libutf8proc\libutf8proc.lib
diff --git a/src/flisp/aliases.scm b/src/flisp/aliases.scm
index 1eceb8e145b25..59e89acd33897 100644
--- a/src/flisp/aliases.scm
+++ b/src/flisp/aliases.scm
@@ -12,7 +12,6 @@
 (define char>? >)
 (define char<=? <=)
 (define char>=? >=)
-(define (char-whitespace? c) (not (not (string.find *whitespace* c))))
 (define (char-numeric? c) (not (not (string.find "0123456789" c))))
 
 (define string-append string)
diff --git a/src/flisp/builtins.c b/src/flisp/builtins.c
index 05380644338c3..7eb4e9f36a8b8 100644
--- a/src/flisp/builtins.c
+++ b/src/flisp/builtins.c
@@ -33,11 +33,11 @@ size_t llength(value_t v)
     return n;
 }
 
-static value_t fl_nconc(value_t *args, u_int32_t nargs)
+static value_t fl_nconc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs == 0)
-        return FL_NIL;
-    value_t lst, first=FL_NIL;
+        return fl_ctx->NIL;
+    value_t lst, first=fl_ctx->NIL;
     value_t *pcdr = &first;
     cons_t *c;
     uint32_t i=0;
@@ -51,17 +51,17 @@ static value_t fl_nconc(value_t *args, u_int32_t nargs)
                 c = (cons_t*)ptr(c->cdr);
             pcdr = &c->cdr;
         }
-        else if (lst != FL_NIL) {
-            type_error("nconc", "cons", lst);
+        else if (lst != fl_ctx->NIL) {
+            type_error(fl_ctx, "nconc", "cons", lst);
         }
     }
     *pcdr = lst;
     return first;
 }
 
-static value_t fl_assq(value_t *args, u_int32_t nargs)
+static value_t fl_assq(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("assq", nargs, 2);
+    argcount(fl_ctx, "assq", nargs, 2);
     value_t item = args[0];
     value_t v = args[1];
     value_t bind;
@@ -72,24 +72,24 @@ static value_t fl_assq(value_t *args, u_int32_t nargs)
             return bind;
         v = cdr_(v);
     }
-    return FL_F;
+    return fl_ctx->F;
 }
 
-static value_t fl_memq(value_t *args, u_int32_t nargs)
+static value_t fl_memq(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("memq", nargs, 2);
+    argcount(fl_ctx, "memq", nargs, 2);
     while (iscons(args[1])) {
         cons_t *c = (cons_t*)ptr(args[1]);
         if (c->car == args[0])
             return args[1];
         args[1] = c->cdr;
     }
-    return FL_F;
+    return fl_ctx->F;
 }
 
-static value_t fl_length(value_t *args, u_int32_t nargs)
+static value_t fl_length(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("length", nargs, 1);
+    argcount(fl_ctx, "length", nargs, 1);
     value_t a = args[0];
     cvalue_t *cv;
     if (isvector(a)) {
@@ -97,152 +97,148 @@ static value_t fl_length(value_t *args, u_int32_t nargs)
     }
     else if (iscprim(a)) {
         cv = (cvalue_t*)ptr(a);
-        if (cp_class(cv) == bytetype)
+        if (cp_class(cv) == fl_ctx->bytetype)
             return fixnum(1);
-        else if (cp_class(cv) == wchartype)
+        else if (cp_class(cv) == fl_ctx->wchartype)
             return fixnum(u8_charlen(*(uint32_t*)cp_data((cprim_t*)cv)));
     }
     else if (iscvalue(a)) {
         cv = (cvalue_t*)ptr(a);
         if (cv_class(cv)->eltype != NULL)
-            return size_wrap(cvalue_arraylen(a));
+            return size_wrap(fl_ctx, cvalue_arraylen(a));
     }
-    else if (a == FL_NIL) {
+    else if (a == fl_ctx->NIL) {
         return fixnum(0);
     }
     else if (iscons(a)) {
         return fixnum(llength(a));
     }
-    type_error("length", "sequence", a);
+    type_error(fl_ctx, "length", "sequence", a);
 }
 
-static value_t fl_f_raise(value_t *args, u_int32_t nargs)
+static value_t fl_f_raise(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("raise", nargs, 1);
-    fl_raise(args[0]);
+    argcount(fl_ctx, "raise", nargs, 1);
+    fl_raise(fl_ctx, args[0]);
 }
 
-static value_t fl_exit(value_t *args, u_int32_t nargs)
+static value_t fl_exit(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs > 0)
-        exit(tofixnum(args[0], "exit"));
+        exit(tofixnum(fl_ctx, args[0], "exit"));
     exit(0);
-    return FL_NIL;
+    return fl_ctx->NIL;
 }
 
-static value_t fl_symbol(value_t *args, u_int32_t nargs)
+static value_t fl_symbol(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("symbol", nargs, 1);
-    if (!fl_isstring(args[0]))
-        type_error("symbol", "string", args[0]);
-    return symbol((char*)cvalue_data(args[0]));
+    argcount(fl_ctx, "symbol", nargs, 1);
+    if (!fl_isstring(fl_ctx, args[0]))
+        type_error(fl_ctx, "symbol", "string", args[0]);
+    return symbol(fl_ctx, (char*)cvalue_data(args[0]));
 }
 
-static value_t fl_keywordp(value_t *args, u_int32_t nargs)
+static value_t fl_keywordp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("keyword?", nargs, 1);
+    argcount(fl_ctx, "keyword?", nargs, 1);
     return (issymbol(args[0]) &&
-            iskeyword((symbol_t*)ptr(args[0]))) ? FL_T : FL_F;
+            iskeyword((symbol_t*)ptr(args[0]))) ? fl_ctx->T : fl_ctx->F;
 }
 
-static value_t fl_top_level_value(value_t *args, u_int32_t nargs)
+static value_t fl_top_level_value(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("top-level-value", nargs, 1);
-    symbol_t *sym = tosymbol(args[0], "top-level-value");
+    argcount(fl_ctx, "top-level-value", nargs, 1);
+    symbol_t *sym = tosymbol(fl_ctx, args[0], "top-level-value");
     if (sym->binding == UNBOUND)
-        fl_raise(fl_list2(UnboundError, args[0]));
+        fl_raise(fl_ctx, fl_list2(fl_ctx, fl_ctx->UnboundError, args[0]));
     return sym->binding;
 }
 
-static value_t fl_set_top_level_value(value_t *args, u_int32_t nargs)
+static value_t fl_set_top_level_value(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("set-top-level-value!", nargs, 2);
-    symbol_t *sym = tosymbol(args[0], "set-top-level-value!");
+    argcount(fl_ctx, "set-top-level-value!", nargs, 2);
+    symbol_t *sym = tosymbol(fl_ctx, args[0], "set-top-level-value!");
     if (!isconstant(sym))
         sym->binding = args[1];
     return args[1];
 }
 
-static void global_env_list(symbol_t *root, value_t *pv)
+static void global_env_list(fl_context_t *fl_ctx, symbol_t *root, value_t *pv)
 {
     while (root != NULL) {
         if (root->name[0] != ':' && (root->binding != UNBOUND)) {
-            *pv = fl_cons(tagptr(root,TAG_SYM), *pv);
+            *pv = fl_cons(fl_ctx, tagptr(root,TAG_SYM), *pv);
         }
-        global_env_list(root->left, pv);
+        global_env_list(fl_ctx, root->left, pv);
         root = root->right;
     }
 }
 
-extern symbol_t *symtab;
-
-value_t fl_global_env(value_t *args, u_int32_t nargs)
+value_t fl_global_env(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     (void)args;
-    argcount("environment", nargs, 0);
-    value_t lst = FL_NIL;
-    fl_gc_handle(&lst);
-    global_env_list(symtab, &lst);
-    fl_free_gc_handles(1);
+    argcount(fl_ctx, "environment", nargs, 0);
+    value_t lst = fl_ctx->NIL;
+    fl_gc_handle(fl_ctx, &lst);
+    global_env_list(fl_ctx, fl_ctx->symtab, &lst);
+    fl_free_gc_handles(fl_ctx, 1);
     return lst;
 }
 
-extern value_t QUOTE;
-
-static value_t fl_constantp(value_t *args, u_int32_t nargs)
+static value_t fl_constantp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("constant?", nargs, 1);
+    argcount(fl_ctx, "constant?", nargs, 1);
     if (issymbol(args[0]))
-        return (isconstant((symbol_t*)ptr(args[0])) ? FL_T : FL_F);
+        return (isconstant((symbol_t*)ptr(args[0])) ? fl_ctx->T : fl_ctx->F);
     if (iscons(args[0])) {
-        if (car_(args[0]) == QUOTE)
-            return FL_T;
-        return FL_F;
+        if (car_(args[0]) == fl_ctx->QUOTE)
+            return fl_ctx->T;
+        return fl_ctx->F;
     }
-    return FL_T;
+    return fl_ctx->T;
 }
 
-static value_t fl_integer_valuedp(value_t *args, u_int32_t nargs)
+static value_t fl_integer_valuedp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("integer-valued?", nargs, 1);
+    argcount(fl_ctx, "integer-valued?", nargs, 1);
     value_t v = args[0];
     if (isfixnum(v)) {
-        return FL_T;
+        return fl_ctx->T;
     }
     else if (iscprim(v)) {
         numerictype_t nt = cp_numtype((cprim_t*)ptr(v));
         if (nt < T_FLOAT)
-            return FL_T;
+            return fl_ctx->T;
         void *data = cp_data((cprim_t*)ptr(v));
         if (nt == T_FLOAT) {
             float f = *(float*)data;
             if (f < 0) f = -f;
             if (f <= FLT_MAXINT && (float)(int32_t)f == f)
-                return FL_T;
+                return fl_ctx->T;
         }
         else {
             assert(nt == T_DOUBLE);
             double d = *(double*)data;
             if (d < 0) d = -d;
             if (d <= DBL_MAXINT && (double)(int64_t)d == d)
-                return FL_T;
+                return fl_ctx->T;
         }
     }
-    return FL_F;
+    return fl_ctx->F;
 }
 
-static value_t fl_integerp(value_t *args, u_int32_t nargs)
+static value_t fl_integerp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("integer?", nargs, 1);
+    argcount(fl_ctx, "integer?", nargs, 1);
     value_t v = args[0];
     return (isfixnum(v) ||
             (iscprim(v) && cp_numtype((cprim_t*)ptr(v)) < T_FLOAT)) ?
-        FL_T : FL_F;
+        fl_ctx->T : fl_ctx->F;
 }
 
-static value_t fl_fixnum(value_t *args, u_int32_t nargs)
+static value_t fl_fixnum(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("fixnum", nargs, 1);
+    argcount(fl_ctx, "fixnum", nargs, 1);
     if (isfixnum(args[0])) {
         return args[0];
     }
@@ -250,12 +246,12 @@ static value_t fl_fixnum(value_t *args, u_int32_t nargs)
         cprim_t *cp = (cprim_t*)ptr(args[0]);
         return fixnum(conv_to_ptrdiff(cp_data(cp), cp_numtype(cp)));
     }
-    type_error("fixnum", "number", args[0]);
+    type_error(fl_ctx, "fixnum", "number", args[0]);
 }
 
-static value_t fl_truncate(value_t *args, u_int32_t nargs)
+static value_t fl_truncate(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("truncate", nargs, 1);
+    argcount(fl_ctx, "truncate", nargs, 1);
     if (isfixnum(args[0]))
         return args[0];
     if (iscprim(args[0])) {
@@ -272,30 +268,30 @@ static value_t fl_truncate(value_t *args, u_int32_t nargs)
         if (d > 0) {
             if (d > (double)U64_MAX)
                 return args[0];
-            return return_from_uint64((uint64_t)d);
+            return return_from_uint64(fl_ctx, (uint64_t)d);
         }
         if (d > (double)S64_MAX || d < (double)S64_MIN)
             return args[0];
-        return return_from_int64((int64_t)d);
+        return return_from_int64(fl_ctx, (int64_t)d);
     }
-    type_error("truncate", "number", args[0]);
+    type_error(fl_ctx, "truncate", "number", args[0]);
 }
 
-static value_t fl_vector_alloc(value_t *args, u_int32_t nargs)
+static value_t fl_vector_alloc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     fixnum_t i;
     value_t f, v;
     if (nargs == 0)
-        lerror(ArgError, "vector.alloc: too few arguments");
-    i = (fixnum_t)tosize(args[0], "vector.alloc");
+        lerror(fl_ctx, fl_ctx->ArgError, "vector.alloc: too few arguments");
+    i = (fixnum_t)tosize(fl_ctx, args[0], "vector.alloc");
     if (i < 0)
-        lerror(ArgError, "vector.alloc: invalid size");
+        lerror(fl_ctx, fl_ctx->ArgError, "vector.alloc: invalid size");
     if (nargs == 2)
         f = args[1];
     else
-        f = FL_UNSPECIFIED;
-    v = alloc_vector((unsigned)i, f==FL_UNSPECIFIED);
-    if (f != FL_UNSPECIFIED) {
+        f = FL_UNSPECIFIED(fl_ctx);
+    v = alloc_vector(fl_ctx, (unsigned)i, f==FL_UNSPECIFIED(fl_ctx));
+    if (f != FL_UNSPECIFIED(fl_ctx)) {
         int k;
         for(k=0; k < i; k++)
             vector_elt(v,k) = f;
@@ -303,60 +299,60 @@ static value_t fl_vector_alloc(value_t *args, u_int32_t nargs)
     return v;
 }
 
-static value_t fl_time_now(value_t *args, u_int32_t nargs)
+static value_t fl_time_now(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("time.now", nargs, 0);
+    argcount(fl_ctx, "time.now", nargs, 0);
     (void)args;
-    return mk_double(clock_now());
+    return mk_double(fl_ctx, jl_clock_now());
 }
 
-static value_t fl_path_cwd(value_t *args, uint32_t nargs)
+static value_t fl_path_cwd(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     int err;
     if (nargs > 1)
-        argcount("path.cwd", nargs, 1);
+        argcount(fl_ctx, "path.cwd", nargs, 1);
     if (nargs == 0) {
         char buf[1024];
         size_t len = sizeof(buf);
         err = uv_cwd(buf, &len);
         if (err != 0)
-            lerrorf(IOError, "path.cwd: could not get cwd: %s", uv_strerror(err));
-        return string_from_cstr(buf);
+            lerrorf(fl_ctx, fl_ctx->IOError, "path.cwd: could not get cwd: %s", uv_strerror(err));
+        return string_from_cstr(fl_ctx, buf);
     }
-    char *ptr = tostring(args[0], "path.cwd");
+    char *ptr = tostring(fl_ctx, args[0], "path.cwd");
     err = uv_chdir(ptr);
     if (err != 0)
-        lerrorf(IOError, "path.cwd: could not cd to %s: %s", ptr, uv_strerror(err));
-    return FL_T;
+        lerrorf(fl_ctx, fl_ctx->IOError, "path.cwd: could not cd to %s: %s", ptr, uv_strerror(err));
+    return fl_ctx->T;
 }
 
-static value_t fl_path_exists(value_t *args, uint32_t nargs)
+static value_t fl_path_exists(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("path.exists?", nargs, 1);
-    char *str = tostring(args[0], "path.exists?");
+    argcount(fl_ctx, "path.exists?", nargs, 1);
+    char *str = tostring(fl_ctx, args[0], "path.exists?");
     struct stat sbuf;
     if (stat(str, &sbuf) == -1)
-        return FL_F;
-    return FL_T;
+        return fl_ctx->F;
+    return fl_ctx->T;
 }
 
-static value_t fl_os_getenv(value_t *args, uint32_t nargs)
+static value_t fl_os_getenv(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("os.getenv", nargs, 1);
-    char *name = tostring(args[0], "os.getenv");
+    argcount(fl_ctx, "os.getenv", nargs, 1);
+    char *name = tostring(fl_ctx, args[0], "os.getenv");
     char *val = getenv(name);
-    if (val == NULL) return FL_F;
+    if (val == NULL) return fl_ctx->F;
     if (*val == 0)
-        return symbol_value(emptystringsym);
-    return cvalue_static_cstring(val);
+        return symbol_value(fl_ctx->emptystringsym);
+    return cvalue_static_cstring(fl_ctx, val);
 }
 
-static value_t fl_os_setenv(value_t *args, uint32_t nargs)
+static value_t fl_os_setenv(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("os.setenv", nargs, 2);
-    char *name = tostring(args[0], "os.setenv");
+    argcount(fl_ctx, "os.setenv", nargs, 2);
+    char *name = tostring(fl_ctx, args[0], "os.setenv");
     int result;
-    if (args[1] == FL_F) {
+    if (args[1] == fl_ctx->F) {
 #ifdef _OS_LINUX_
         result = unsetenv(name);
 #elif defined(_OS_WINDOWS_)
@@ -368,7 +364,7 @@ static value_t fl_os_setenv(value_t *args, uint32_t nargs)
 
     }
     else {
-        char *val = tostring(args[1], "os.setenv");
+        char *val = tostring(fl_ctx, args[1], "os.setenv");
 #if defined (_OS_WINDOWS_)
         result = SetEnvironmentVariable(name,val);
 #else
@@ -376,15 +372,15 @@ static value_t fl_os_setenv(value_t *args, uint32_t nargs)
 #endif
     }
     if (result != 0)
-        lerror(ArgError, "os.setenv: invalid environment variable");
-    return FL_T;
+        lerror(fl_ctx, fl_ctx->ArgError, "os.setenv: invalid environment variable");
+    return fl_ctx->T;
 }
 
-extern void stringfuncs_init(void);
-extern void table_init(void);
-extern void iostream_init(void);
+extern void stringfuncs_init(fl_context_t *fl_ctx);
+extern void table_init(fl_context_t *fl_ctx);
+extern void iostream_init(fl_context_t *fl_ctx);
 
-static builtinspec_t builtin_info[] = {
+static const builtinspec_t builtin_info[] = {
     { "environment", fl_global_env },
     { "constant?", fl_constantp },
     { "top-level-value", fl_top_level_value },
@@ -416,12 +412,12 @@ static builtinspec_t builtin_info[] = {
     { NULL, NULL }
 };
 
-void builtins_init(void)
+void builtins_init(fl_context_t *fl_ctx)
 {
-    assign_global_builtins(builtin_info);
-    stringfuncs_init();
-    table_init();
-    iostream_init();
+    assign_global_builtins(fl_ctx, builtin_info);
+    stringfuncs_init(fl_ctx);
+    table_init(fl_ctx);
+    iostream_init(fl_ctx);
 }
 
 #ifdef __cplusplus
diff --git a/src/flisp/cvalues.c b/src/flisp/cvalues.c
index 582e4a724902f..bbe2a6a36d150 100644
--- a/src/flisp/cvalues.c
+++ b/src/flisp/cvalues.c
@@ -4,63 +4,45 @@
 #define NWORDS(sz) (((sz)+3)>>2)
 #endif
 
-static int ALIGN2, ALIGN4, ALIGN8, ALIGNPTR;
-
-value_t int8sym, uint8sym, int16sym, uint16sym, int32sym, uint32sym;
-value_t int64sym, uint64sym;
-value_t ptrdiffsym, sizesym, bytesym, wcharsym;
-value_t floatsym, doublesym;
-value_t gftypesym, stringtypesym, wcstringtypesym;
-value_t emptystringsym;
-
-value_t arraysym, cfunctionsym, voidsym, pointersym;
-
-static htable_t TypeTable;
-static htable_t reverse_dlsym_lookup_table;
-static fltype_t *int8type, *uint8type;
-static fltype_t *int16type, *uint16type;
-static fltype_t *int32type, *uint32type;
-static fltype_t *int64type, *uint64type;
-static fltype_t *ptrdifftype, *sizetype;
-static fltype_t *floattype, *doubletype;
-       fltype_t *bytetype, *wchartype;
-       fltype_t *stringtype, *wcstringtype;
-       fltype_t *builtintype;
-
-static void cvalue_init(fltype_t *type, value_t v, void *dest);
+struct prim_int16{ char a; int16_t i; };
+struct prim_int32{ char a; int32_t i; };
+struct prim_int64{ char a; int64_t i; };
+struct prim_ptr{ char a;  void   *i; };
+
+// compute struct field alignment required for primitives
+static const int ALIGN2   = sizeof(struct prim_int16) - 2;
+static const int ALIGN4   = sizeof(struct prim_int32) - 4;
+static const int ALIGN8   = sizeof(struct prim_int64) - 8;
+static const int ALIGNPTR = sizeof(struct prim_ptr) - sizeof(void*);
+
+static void cvalue_init(fl_context_t *fl_ctx, fltype_t *type, value_t v, void *dest);
 
 // cvalues-specific builtins
-value_t cvalue_new(value_t *args, u_int32_t nargs);
-value_t cvalue_sizeof(value_t *args, u_int32_t nargs);
-value_t cvalue_typeof(value_t *args, u_int32_t nargs);
+value_t cvalue_new(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+value_t cvalue_sizeof(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+value_t cvalue_typeof(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
 
 // trigger unconditional GC after this many bytes are allocated
 #define ALLOC_LIMIT_TRIGGER 67108864
 
-static size_t malloc_pressure = 0;
-
-static cvalue_t **Finalizers = NULL;
-static size_t nfinalizers=0;
-static size_t maxfinalizers=0;
-
-void add_finalizer(cvalue_t *cv)
+void add_finalizer(fl_context_t *fl_ctx, cvalue_t *cv)
 {
-    if (nfinalizers == maxfinalizers) {
-        size_t nn = (maxfinalizers==0 ? 256 : maxfinalizers*2);
-        cvalue_t **temp = (cvalue_t**)realloc(Finalizers, nn*sizeof(value_t));
+    if (fl_ctx->nfinalizers == fl_ctx->maxfinalizers) {
+        size_t nn = (fl_ctx->maxfinalizers==0 ? 256 : fl_ctx->maxfinalizers*2);
+        cvalue_t **temp = (cvalue_t**)realloc(fl_ctx->Finalizers, nn*sizeof(value_t));
         if (temp == NULL)
-            lerror(OutOfMemoryError, "out of memory");
-        Finalizers = temp;
-        maxfinalizers = nn;
+            lerror(fl_ctx, fl_ctx->OutOfMemoryError, "out of memory");
+        fl_ctx->Finalizers = temp;
+        fl_ctx->maxfinalizers = nn;
     }
-    Finalizers[nfinalizers++] = cv;
+    fl_ctx->Finalizers[fl_ctx->nfinalizers++] = cv;
 }
 
 // remove dead objects from finalization list in-place
-static void sweep_finalizers(void)
+static void sweep_finalizers(fl_context_t *fl_ctx)
 {
-    cvalue_t **lst = Finalizers;
-    size_t n=0, ndel=0, l=nfinalizers;
+    cvalue_t **lst = fl_ctx->Finalizers;
+    size_t n=0, ndel=0, l=fl_ctx->nfinalizers;
     cvalue_t *tmp;
 #define SWAP_sf(a,b) (tmp=a,a=b,b=tmp,1)
     if (l == 0)
@@ -75,7 +57,7 @@ static void sweep_finalizers(void)
         else {
             fltype_t *t = cv_class(tmp);
             if (t->vtable != NULL && t->vtable->finalize != NULL) {
-                t->vtable->finalize(tagptr(tmp, TAG_CVALUE));
+                t->vtable->finalize(fl_ctx, tagptr(tmp, TAG_CVALUE));
             }
             if (!isinlined(tmp) && owned(tmp)) {
 #ifdef DEBUG
@@ -87,75 +69,75 @@ static void sweep_finalizers(void)
         }
     } while ((n < l-ndel) && SWAP_sf(lst[n],lst[n+ndel]));
 
-    nfinalizers -= ndel;
+    fl_ctx->nfinalizers -= ndel;
 #ifdef VERBOSEGC
     if (ndel > 0)
         printf("GC: finalized %d objects\n", ndel);
 #endif
 
-    malloc_pressure = 0;
+    fl_ctx->malloc_pressure = 0;
 }
 
 // compute the size of the metadata object for a cvalue
-static size_t cv_nwords(cvalue_t *cv)
+static size_t cv_nwords(fl_context_t *fl_ctx, cvalue_t *cv)
 {
     if (isinlined(cv)) {
         size_t n = cv_len(cv);
-        if (n==0 || cv_isstr(cv))
+        if (n==0 || cv_isstr(fl_ctx, cv))
             n++;
         return CVALUE_NWORDS - 1 + NWORDS(n);
     }
     return CVALUE_NWORDS;
 }
 
-static void autorelease(cvalue_t *cv)
+static void autorelease(fl_context_t *fl_ctx, cvalue_t *cv)
 {
-    cv->type = (fltype_t*)(((uptrint_t)cv->type) | CV_OWNED_BIT);
-    add_finalizer(cv);
+    cv->type = (fltype_t*)(((uintptr_t)cv->type) | CV_OWNED_BIT);
+    add_finalizer(fl_ctx, cv);
 }
 
-void cv_autorelease(cvalue_t *cv)
+void cv_autorelease(fl_context_t *fl_ctx, cvalue_t *cv)
 {
-    autorelease(cv);
+    autorelease(fl_ctx, cv);
 }
 
-static value_t cprim(fltype_t *type, size_t sz)
+static value_t cprim(fl_context_t *fl_ctx, fltype_t *type, size_t sz)
 {
-    cprim_t *pcp = (cprim_t*)alloc_words(CPRIM_NWORDS-1+NWORDS(sz));
+    cprim_t *pcp = (cprim_t*)alloc_words(fl_ctx, CPRIM_NWORDS-1+NWORDS(sz));
     pcp->type = type;
     return tagptr(pcp, TAG_CPRIM);
 }
 
-value_t cvalue(fltype_t *type, size_t sz)
+value_t cvalue(fl_context_t *fl_ctx, fltype_t *type, size_t sz)
 {
     cvalue_t *pcv;
     int str=0;
 
     if (valid_numtype(type->numtype)) {
-        return cprim(type, sz);
+        return cprim(fl_ctx, type, sz);
     }
-    if (type->eltype == bytetype) {
+    if (type->eltype == fl_ctx->bytetype) {
         if (sz == 0)
-            return symbol_value(emptystringsym);
+            return symbol_value(fl_ctx->emptystringsym);
         sz++;
         str=1;
     }
     if (sz <= MAX_INL_SIZE) {
         size_t nw = CVALUE_NWORDS - 1 + NWORDS(sz) + (sz==0 ? 1 : 0);
-        pcv = (cvalue_t*)alloc_words(nw);
+        pcv = (cvalue_t*)alloc_words(fl_ctx, nw);
         pcv->type = type;
         pcv->data = &pcv->_space[0];
         if (type->vtable != NULL && type->vtable->finalize != NULL)
-            add_finalizer(pcv);
+            add_finalizer(fl_ctx, pcv);
     }
     else {
-        if (malloc_pressure > ALLOC_LIMIT_TRIGGER)
-            gc(0);
-        pcv = (cvalue_t*)alloc_words(CVALUE_NWORDS);
+        if (fl_ctx->malloc_pressure > ALLOC_LIMIT_TRIGGER)
+            gc(fl_ctx, 0);
+        pcv = (cvalue_t*)alloc_words(fl_ctx, CVALUE_NWORDS);
         pcv->type = type;
         pcv->data = malloc(sz);
-        autorelease(pcv);
-        malloc_pressure += sz;
+        autorelease(fl_ctx, pcv);
+        fl_ctx->malloc_pressure += sz;
     }
     if (str) {
         sz--;
@@ -165,10 +147,10 @@ value_t cvalue(fltype_t *type, size_t sz)
     return tagptr(pcv, TAG_CVALUE);
 }
 
-value_t cvalue_from_data(fltype_t *type, void *data, size_t sz)
+value_t cvalue_from_data(fl_context_t *fl_ctx, fltype_t *type, void *data, size_t sz)
 {
     value_t cv;
-    cv = cvalue(type, sz);
+    cv = cvalue(fl_ctx, type, sz);
     memcpy(cptr(cv), data, sz);
     return cv;
 }
@@ -180,88 +162,88 @@ value_t cvalue_from_data(fltype_t *type, void *data, size_t sz)
 // ptr is user-managed; we don't autorelease it unless the
 // user explicitly calls (autorelease ) on the result of this function.
 // 'parent' is an optional cvalue that this pointer is known to point
-// into; NIL if none.
-value_t cvalue_from_ref(fltype_t *type, void *ptr, size_t sz, value_t parent)
+// into; fl_ctx->NIL if none.
+value_t cvalue_from_ref(fl_context_t *fl_ctx, fltype_t *type, void *ptr, size_t sz, value_t parent)
 {
     cvalue_t *pcv;
     value_t cv;
 
-    pcv = (cvalue_t*)alloc_words(CVALUE_NWORDS);
+    pcv = (cvalue_t*)alloc_words(fl_ctx, CVALUE_NWORDS);
     pcv->data = ptr;
     pcv->len = sz;
     pcv->type = type;
-    if (parent != NIL) {
-        pcv->type = (fltype_t*)(((uptrint_t)pcv->type) | CV_PARENT_BIT);
+    if (parent != fl_ctx->NIL) {
+        pcv->type = (fltype_t*)(((uintptr_t)pcv->type) | CV_PARENT_BIT);
         pcv->parent = parent;
     }
     cv = tagptr(pcv, TAG_CVALUE);
     return cv;
 }
 
-value_t cvalue_string(size_t sz)
+value_t cvalue_string(fl_context_t *fl_ctx, size_t sz)
 {
-    return cvalue(stringtype, sz);
+    return cvalue(fl_ctx, fl_ctx->stringtype, sz);
 }
 
-value_t cvalue_static_cstrn(const char *str, size_t n)
+value_t cvalue_static_cstrn(fl_context_t *fl_ctx, const char *str, size_t n)
 {
-    return cvalue_from_ref(stringtype, (char*)str, n, NIL);
+    return cvalue_from_ref(fl_ctx, fl_ctx->stringtype, (char*)str, n, fl_ctx->NIL);
 }
 
-value_t cvalue_static_cstring(const char *str)
+value_t cvalue_static_cstring(fl_context_t *fl_ctx, const char *str)
 {
-    return cvalue_static_cstrn(str, strlen(str));
+    return cvalue_static_cstrn(fl_ctx, str, strlen(str));
 }
 
-value_t string_from_cstrn(char *str, size_t n)
+value_t string_from_cstrn(fl_context_t *fl_ctx, char *str, size_t n)
 {
-    value_t v = cvalue_string(n);
+    value_t v = cvalue_string(fl_ctx, n);
     memcpy(cvalue_data(v), str, n);
     return v;
 }
 
-value_t string_from_cstr(char *str)
+value_t string_from_cstr(fl_context_t *fl_ctx, char *str)
 {
-    return string_from_cstrn(str, strlen(str));
+    return string_from_cstrn(fl_ctx, str, strlen(str));
 }
 
-int fl_isstring(value_t v)
+int fl_isstring(fl_context_t *fl_ctx, value_t v)
 {
-    return (iscvalue(v) && cv_isstr((cvalue_t*)ptr(v)));
+    return (iscvalue(v) && cv_isstr(fl_ctx, (cvalue_t*)ptr(v)));
 }
 
 // convert to malloc representation (fixed address)
-void cv_pin(cvalue_t *cv)
+void cv_pin(fl_context_t *fl_ctx, cvalue_t *cv)
 {
     if (!isinlined(cv))
         return;
     size_t sz = cv_len(cv);
-    if (cv_isstr(cv)) sz++;
+    if (cv_isstr(fl_ctx, cv)) sz++;
     void *data = malloc(sz);
     memcpy(data, cv_data(cv), sz);
     cv->data = data;
-    autorelease(cv);
+    autorelease(fl_ctx, cv);
 }
 
-#define num_init(ctype, cnvt, tag)                              \
-static int cvalue_##ctype##_init(fltype_t *type, value_t arg,   \
-                                 void *dest)                    \
-{                                                               \
-    fl_##ctype##_t n=0;                                         \
-    (void)type;                                                 \
-    if (isfixnum(arg)) {                                        \
-        n = numval(arg);                                        \
-    }                                                           \
-    else if (iscprim(arg)) {                                    \
-        cprim_t *cp = (cprim_t*)ptr(arg);                       \
-        void *p = cp_data(cp);                                  \
-        n = (fl_##ctype##_t)conv_to_##cnvt(p, cp_numtype(cp));  \
-    }                                                           \
-    else {                                                      \
-        return 1;                                               \
-    }                                                           \
-    *((fl_##ctype##_t*)dest) = n;                               \
-    return 0;                                                   \
+#define num_init(ctype, cnvt, tag)                                     \
+static int cvalue_##ctype##_init(fl_context_t *fl_ctx, fltype_t *type, \
+                                 value_t arg, void *dest)              \
+{                                                                      \
+    fl_##ctype##_t n=0;                                                \
+    (void)type;                                                        \
+    if (isfixnum(arg)) {                                               \
+        n = numval(arg);                                               \
+    }                                                                  \
+    else if (iscprim(arg)) {                                           \
+        cprim_t *cp = (cprim_t*)ptr(arg);                              \
+        void *p = cp_data(cp);                                         \
+        n = (fl_##ctype##_t)conv_to_##cnvt(p, cp_numtype(cp));         \
+    }                                                                  \
+    else {                                                             \
+        return 1;                                                      \
+    }                                                                  \
+    *((fl_##ctype##_t*)dest) = n;                                      \
+    return 0;                                                          \
 }
 num_init(int8, int32, T_INT8)
 num_init(uint8, uint32, T_UINT8)
@@ -275,25 +257,25 @@ num_init(float, double, T_FLOAT)
 num_init(double, double, T_DOUBLE)
 
 #define num_ctor_init(typenam, ctype, tag)                              \
-value_t cvalue_##typenam(value_t *args, u_int32_t nargs)                \
+value_t cvalue_##typenam(fl_context_t *fl_ctx, value_t *args, uint32_t nargs) \
 {                                                                       \
-    if (nargs==0) { PUSH(fixnum(0)); args = &Stack[SP-1]; }             \
-    value_t cp = cprim(typenam##type, sizeof(fl_##ctype##_t));          \
-    if (cvalue_##ctype##_init(typenam##type,                            \
+    if (nargs==0) { PUSH(fl_ctx, fixnum(0)); args = &fl_ctx->Stack[fl_ctx->SP-1]; } \
+    value_t cp = cprim(fl_ctx, fl_ctx->typenam##type, sizeof(fl_##ctype##_t)); \
+    if (cvalue_##ctype##_init(fl_ctx, fl_ctx->typenam##type,            \
                               args[0], cp_data((cprim_t*)ptr(cp))))     \
-        type_error(#typenam, "number", args[0]);                        \
+        type_error(fl_ctx, #typenam, "number", args[0]);                \
     return cp;                                                          \
 }
 
 #define num_ctor_ctor(typenam, ctype, tag)                              \
-value_t mk_##typenam(fl_##ctype##_t n)                                  \
+value_t mk_##typenam(fl_context_t *fl_ctx, fl_##ctype##_t n)            \
 {                                                                       \
-    value_t cp = cprim(typenam##type, sizeof(fl_##ctype##_t));          \
+    value_t cp = cprim(fl_ctx, fl_ctx->typenam##type, sizeof(fl_##ctype##_t)); \
     *(fl_##ctype##_t*)cp_data((cprim_t*)ptr(cp)) = n;                   \
     return cp;                                                          \
 }
 
-#define num_ctor(typenam, ctype, tag) \
+#define num_ctor(typenam, ctype, tag)  \
     num_ctor_init(typenam, ctype, tag) \
     num_ctor_ctor(typenam, ctype, tag)
 
@@ -317,15 +299,15 @@ num_ctor(size, uint32, T_UINT32)
 num_ctor(float, float, T_FLOAT)
 num_ctor(double, double, T_DOUBLE)
 
-value_t size_wrap(size_t sz)
+value_t size_wrap(fl_context_t *fl_ctx, size_t sz)
 {
     if (fits_fixnum(sz))
         return fixnum(sz);
     assert(sizeof(void*) == sizeof(size_t));
-    return mk_size(sz);
+    return mk_size(fl_ctx, sz);
 }
 
-size_t tosize(value_t n, char *fname)
+size_t tosize(fl_context_t *fl_ctx, value_t n, char *fname)
 {
     if (isfixnum(n))
         return numval(n);
@@ -333,7 +315,7 @@ size_t tosize(value_t n, char *fname)
         cprim_t *cp = (cprim_t*)ptr(n);
         return conv_to_size(cp_data(cp), cp_numtype(cp));
     }
-    type_error(fname, "number", n);
+    type_error(fl_ctx, fname, "number", n);
     return 0;
 }
 
@@ -342,54 +324,54 @@ static int isarray(value_t v)
     return iscvalue(v) && cv_class((cvalue_t*)ptr(v))->eltype != NULL;
 }
 
-static size_t predict_arraylen(value_t arg)
+static size_t predict_arraylen(fl_context_t *fl_ctx, value_t arg)
 {
     if (isvector(arg))
         return vector_size(arg);
     else if (iscons(arg))
         return llength(arg);
-    else if (arg == NIL)
+    else if (arg == fl_ctx->NIL)
         return 0;
     if (isarray(arg))
         return cvalue_arraylen(arg);
     return 1;
 }
 
-static int cvalue_array_init(fltype_t *ft, value_t arg, void *dest)
+static int cvalue_array_init(fl_context_t *fl_ctx, fltype_t *ft, value_t arg, void *dest)
 {
     value_t type = ft->type;
     size_t elsize, i, cnt, sz;
     fltype_t *eltype = ft->eltype;
 
     elsize = ft->elsz;
-    cnt = predict_arraylen(arg);
+    cnt = predict_arraylen(fl_ctx, arg);
 
     if (iscons(cdr_(cdr_(type)))) {
-        size_t tc = tosize(car_(cdr_(cdr_(type))), "array");
+        size_t tc = tosize(fl_ctx, car_(cdr_(cdr_(type))), "array");
         if (tc != cnt)
-            lerror(ArgError, "array: size mismatch");
+            lerror(fl_ctx, fl_ctx->ArgError, "array: size mismatch");
     }
 
     sz = elsize * cnt;
 
     if (isvector(arg)) {
         for(i=0; i < cnt; i++) {
-            cvalue_init(eltype, vector_elt(arg,i), dest);
+            cvalue_init(fl_ctx, eltype, vector_elt(arg,i), dest);
             dest = (char *)dest + elsize;
         }
         return 0;
     }
-    else if (iscons(arg) || arg==NIL) {
+    else if (iscons(arg) || arg==fl_ctx->NIL) {
         i = 0;
         while (iscons(arg)) {
             if (i == cnt) { i++; break; } // trigger error
-            cvalue_init(eltype, car_(arg), dest);
+            cvalue_init(fl_ctx, eltype, car_(arg), dest);
             i++;
             dest = (char *)dest + elsize;
             arg = cdr_(arg);
         }
         if (i != cnt)
-            lerror(ArgError, "array: size mismatch");
+            lerror(fl_ctx, fl_ctx->ArgError, "array: size mismatch");
         return 0;
     }
     else if (iscvalue(arg)) {
@@ -400,39 +382,39 @@ static int cvalue_array_init(fltype_t *ft, value_t arg, void *dest)
                 if (cv_len(cv) == sz)
                     memcpy(dest, cv_data(cv), sz);
                 else
-                    lerror(ArgError, "array: size mismatch");
+                    lerror(fl_ctx, fl_ctx->ArgError, "array: size mismatch");
                 return 0;
             }
             else {
                 // TODO: initialize array from different type elements
-                lerror(ArgError, "array: element type mismatch");
+                lerror(fl_ctx, fl_ctx->ArgError, "array: element type mismatch");
             }
         }
     }
     if (cnt == 1)
-        cvalue_init(eltype, arg, dest);
+        cvalue_init(fl_ctx, eltype, arg, dest);
     else
-        type_error("array", "sequence", arg);
+        type_error(fl_ctx, "array", "sequence", arg);
     return 0;
 }
 
-value_t cvalue_array(value_t *args, u_int32_t nargs)
+value_t cvalue_array(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     size_t elsize, cnt, sz, i;
     value_t arg;
 
     if (nargs < 1)
-        argcount("array", nargs, 1);
+        argcount(fl_ctx, "array", nargs, 1);
 
     cnt = nargs - 1;
-    fltype_t *type = get_array_type(args[0]);
+    fltype_t *type = get_array_type(fl_ctx, args[0]);
     elsize = type->elsz;
     sz = elsize * cnt;
 
-    value_t cv = cvalue(type, sz);
+    value_t cv = cvalue(fl_ctx, type, sz);
     char *dest = (char*)cv_data((cvalue_t*)ptr(cv));
     FOR_ARGS(i,1,arg,args) {
-        cvalue_init(type->eltype, arg, dest);
+        cvalue_init(fl_ctx, type->eltype, arg, dest);
         dest += elsize;
     }
     return cv;
@@ -446,26 +428,26 @@ size_t cvalue_arraylen(value_t v)
 }
 
 // *palign is an output argument giving the alignment required by type
-size_t ctype_sizeof(value_t type, int *palign)
+size_t ctype_sizeof(fl_context_t *fl_ctx, value_t type, int *palign)
 {
-    if (type == int8sym || type == uint8sym || type == bytesym) {
+    if (type == fl_ctx->int8sym || type == fl_ctx->uint8sym || type == fl_ctx->bytesym) {
         *palign = 1;
         return 1;
     }
-    if (type == int16sym || type == uint16sym) {
+    if (type == fl_ctx->int16sym || type == fl_ctx->uint16sym) {
         *palign = ALIGN2;
         return 2;
     }
-    if (type == int32sym || type == uint32sym || type == wcharsym ||
-        type == floatsym) {
+    if (type == fl_ctx->int32sym || type == fl_ctx->uint32sym || type == fl_ctx->wcharsym ||
+        type == fl_ctx->floatsym) {
         *palign = ALIGN4;
         return 4;
     }
-    if (type == int64sym || type == uint64sym || type == doublesym) {
+    if (type == fl_ctx->int64sym || type == fl_ctx->uint64sym || type == fl_ctx->doublesym) {
         *palign = ALIGN8;
         return 8;
     }
-    if (type == ptrdiffsym || type == sizesym) {
+    if (type == fl_ctx->ptrdiffsym || type == fl_ctx->sizesym) {
 #ifdef _P64
         *palign = ALIGN8;
         return 8;
@@ -476,34 +458,32 @@ size_t ctype_sizeof(value_t type, int *palign)
     }
     if (iscons(type)) {
         value_t hed = car_(type);
-        if (hed == pointersym || hed == cfunctionsym) {
+        if (hed == fl_ctx->pointersym || hed == fl_ctx->cfunctionsym) {
             *palign = ALIGNPTR;
             return sizeof(void*);
         }
-        if (hed == arraysym) {
-            value_t t = car(cdr_(type));
+        if (hed == fl_ctx->arraysym) {
+            value_t t = car(fl_ctx, cdr_(type));
             if (!iscons(cdr_(cdr_(type))))
-                lerror(ArgError, "sizeof: incomplete type");
+                lerror(fl_ctx, fl_ctx->ArgError, "sizeof: incomplete type");
             value_t n = car_(cdr_(cdr_(type)));
-            size_t sz = tosize(n, "sizeof");
-            return sz * ctype_sizeof(t, palign);
+            size_t sz = tosize(fl_ctx, n, "sizeof");
+            return sz * ctype_sizeof(fl_ctx, t, palign);
         }
     }
-    lerror(ArgError, "sizeof: invalid c type");
+    lerror(fl_ctx, fl_ctx->ArgError, "sizeof: invalid c type");
     return 0;
 }
 
-extern fltype_t *iostreamtype;
-
 // get pointer and size for any plain-old-data value
-void to_sized_ptr(value_t v, char *fname, char **pdata, size_t *psz)
+void to_sized_ptr(fl_context_t *fl_ctx, value_t v, char *fname, char **pdata, size_t *psz)
 {
     if (iscvalue(v)) {
         cvalue_t *pcv = (cvalue_t*)ptr(v);
         ios_t *x = value2c(ios_t*,v);
-        if (cv_class(pcv) == iostreamtype && (x->bm == bm_mem)) {
+        if (cv_class(pcv) == fl_ctx->iostreamtype && (x->bm == bm_mem)) {
             *pdata = x->buf;
-            *psz = x->size;
+            *psz = (size_t)x->size;
             return;
         }
         else if (cv_isPOD(pcv)) {
@@ -518,82 +498,82 @@ void to_sized_ptr(value_t v, char *fname, char **pdata, size_t *psz)
         *psz = cp_class(pcp)->size;
         return;
     }
-    type_error(fname, "plain-old-data", v);
+    type_error(fl_ctx, fname, "plain-old-data", v);
 }
 
-value_t cvalue_sizeof(value_t *args, u_int32_t nargs)
+value_t cvalue_sizeof(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("sizeof", nargs, 1);
+    argcount(fl_ctx, "sizeof", nargs, 1);
     if (issymbol(args[0]) || iscons(args[0])) {
         int a;
-        return size_wrap(ctype_sizeof(args[0], &a));
+        return size_wrap(fl_ctx, ctype_sizeof(fl_ctx, args[0], &a));
     }
     size_t n; char *data;
-    to_sized_ptr(args[0], "sizeof", &data, &n);
-    return size_wrap(n);
+    to_sized_ptr(fl_ctx, args[0], "sizeof", &data, &n);
+    return size_wrap(fl_ctx, n);
 }
 
-value_t cvalue_typeof(value_t *args, u_int32_t nargs)
+value_t cvalue_typeof(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("typeof", nargs, 1);
+    argcount(fl_ctx, "typeof", nargs, 1);
     switch(tag(args[0])) {
-    case TAG_CONS: return pairsym;
+    case TAG_CONS: return fl_ctx->pairsym;
     case TAG_NUM1:
-    case TAG_NUM:  return fixnumsym;
-    case TAG_SYM:  return symbolsym;
-    case TAG_VECTOR: return vectorsym;
+    case TAG_NUM:  return fl_ctx->fixnumsym;
+    case TAG_SYM:  return fl_ctx->symbolsym;
+    case TAG_VECTOR: return fl_ctx->vectorsym;
     case TAG_FUNCTION:
-        if (args[0] == FL_T || args[0] == FL_F)
-            return booleansym;
-        if (args[0] == NIL)
-            return nullsym;
-        if (args[0] == FL_EOF)
-            return symbol("eof-object");
+        if (args[0] == fl_ctx->T || args[0] == fl_ctx->F)
+            return fl_ctx->booleansym;
+        if (args[0] == fl_ctx->NIL)
+            return fl_ctx->nullsym;
+        if (args[0] == fl_ctx->FL_EOF)
+            return symbol(fl_ctx, "eof-object");
         if (isbuiltin(args[0]))
-            return builtinsym;
-        return FUNCTION;
+            return fl_ctx->builtinsym;
+        return fl_ctx->FUNCTION;
     }
     return cv_type((cvalue_t*)ptr(args[0]));
 }
 
-static value_t cvalue_relocate(value_t v)
+static value_t cvalue_relocate(fl_context_t *fl_ctx, value_t v)
 {
     size_t nw;
     cvalue_t *cv = (cvalue_t*)ptr(v);
     cvalue_t *nv;
     value_t ncv;
 
-    nw = cv_nwords(cv);
-    nv = (cvalue_t*)alloc_words(nw);
+    nw = cv_nwords(fl_ctx, cv);
+    nv = (cvalue_t*)alloc_words(fl_ctx, nw);
     memcpy(nv, cv, nw*sizeof(value_t));
     if (isinlined(cv))
         nv->data = &nv->_space[0];
     ncv = tagptr(nv, TAG_CVALUE);
     fltype_t *t = cv_class(cv);
     if (t->vtable != NULL && t->vtable->relocate != NULL)
-        t->vtable->relocate(v, ncv);
+        t->vtable->relocate(fl_ctx, v, ncv);
     forward(v, ncv);
     return ncv;
 }
 
-value_t cvalue_copy(value_t v)
+value_t cvalue_copy(fl_context_t *fl_ctx, value_t v)
 {
     assert(iscvalue(v));
-    PUSH(v);
+    PUSH(fl_ctx, v);
     cvalue_t *cv = (cvalue_t*)ptr(v);
-    size_t nw = cv_nwords(cv);
-    cvalue_t *ncv = (cvalue_t*)alloc_words(nw);
-    v = POP(); cv = (cvalue_t*)ptr(v);
+    size_t nw = cv_nwords(fl_ctx, cv);
+    cvalue_t *ncv = (cvalue_t*)alloc_words(fl_ctx, nw);
+    v = POP(fl_ctx); cv = (cvalue_t*)ptr(v);
     memcpy(ncv, cv, nw * sizeof(value_t));
     if (!isinlined(cv)) {
         size_t len = cv_len(cv);
-        if (cv_isstr(cv)) len++;
+        if (cv_isstr(fl_ctx, cv)) len++;
         ncv->data = malloc(len);
         memcpy(ncv->data, cv_data(cv), len);
-        autorelease(ncv);
+        autorelease(fl_ctx, ncv);
         if (hasparent(cv)) {
-            ncv->type = (fltype_t*)(((uptrint_t)ncv->type) & ~CV_PARENT_BIT);
-            ncv->parent = NIL;
+            ncv->type = (fltype_t*)(((uintptr_t)ncv->type) & ~CV_PARENT_BIT);
+            ncv->parent = fl_ctx->NIL;
         }
     }
     else {
@@ -603,73 +583,73 @@ value_t cvalue_copy(value_t v)
     return tagptr(ncv, TAG_CVALUE);
 }
 
-value_t fl_copy(value_t *args, u_int32_t nargs)
+value_t fl_copy(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("copy", nargs, 1);
+    argcount(fl_ctx, "copy", nargs, 1);
     if (iscons(args[0]) || isvector(args[0]))
-        lerror(ArgError, "copy: argument must be a leaf atom");
+        lerror(fl_ctx, fl_ctx->ArgError, "copy: argument must be a leaf atom");
     if (!iscvalue(args[0]))
         return args[0];
     if (!cv_isPOD((cvalue_t*)ptr(args[0])))
-        lerror(ArgError, "copy: argument must be a plain-old-data type");
-    return cvalue_copy(args[0]);
+        lerror(fl_ctx, fl_ctx->ArgError, "copy: argument must be a plain-old-data type");
+    return cvalue_copy(fl_ctx, args[0]);
 }
 
-value_t fl_podp(value_t *args, u_int32_t nargs)
+value_t fl_podp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("plain-old-data?", nargs, 1);
+    argcount(fl_ctx, "plain-old-data?", nargs, 1);
     return (iscprim(args[0]) ||
             (iscvalue(args[0]) && cv_isPOD((cvalue_t*)ptr(args[0])))) ?
-        FL_T : FL_F;
+        fl_ctx->T : fl_ctx->F;
 }
 
-static void cvalue_init(fltype_t *type, value_t v, void *dest)
+static void cvalue_init(fl_context_t *fl_ctx, fltype_t *type, value_t v, void *dest)
 {
     cvinitfunc_t f=type->init;
 
     if (f == NULL)
-        lerror(ArgError, "c-value: invalid c type");
+        lerror(fl_ctx, fl_ctx->ArgError, "c-value: invalid c type");
 
-    f(type, v, dest);
+    f(fl_ctx, type, v, dest);
 }
 
-static numerictype_t sym_to_numtype(value_t type)
+static numerictype_t sym_to_numtype(fl_context_t *fl_ctx, value_t type)
 {
-    if (type == int8sym)
+    if (type == fl_ctx->int8sym)
         return T_INT8;
-    else if (type == uint8sym || type == bytesym)
+    else if (type == fl_ctx->uint8sym || type == fl_ctx->bytesym)
         return T_UINT8;
-    else if (type == int16sym)
+    else if (type == fl_ctx->int16sym)
         return T_INT16;
-    else if (type == uint16sym)
+    else if (type == fl_ctx->uint16sym)
         return T_UINT16;
 #ifdef _P64
-    else if (type == int32sym || type == wcharsym)
+    else if (type == fl_ctx->int32sym || type == fl_ctx->wcharsym)
 #else
-    else if (type == int32sym || type == wcharsym || type == ptrdiffsym)
+    else if (type == fl_ctx->int32sym || type == fl_ctx->wcharsym || type == fl_ctx->ptrdiffsym)
 #endif
         return T_INT32;
 #ifdef _P64
-    else if (type == uint32sym)
+    else if (type == fl_ctx->uint32sym)
 #else
-    else if (type == uint32sym || type == sizesym)
+    else if (type == fl_ctx->uint32sym || type == fl_ctx->sizesym)
 #endif
         return T_UINT32;
 #ifdef _P64
-    else if (type == int64sym || type == ptrdiffsym)
+    else if (type == fl_ctx->int64sym || type == fl_ctx->ptrdiffsym)
 #else
-    else if (type == int64sym)
+    else if (type == fl_ctx->int64sym)
 #endif
         return T_INT64;
 #ifdef _P64
-    else if (type == uint64sym || type == sizesym)
+    else if (type == fl_ctx->uint64sym || type == fl_ctx->sizesym)
 #else
-    else if (type == uint64sym)
+    else if (type == fl_ctx->uint64sym)
 #endif
         return T_UINT64;
-    else if (type == floatsym)
+    else if (type == fl_ctx->floatsym)
         return T_FLOAT;
-    else if (type == doublesym)
+    else if (type == fl_ctx->doublesym)
         return T_DOUBLE;
     return (numerictype_t)N_NUMTYPES;
 }
@@ -678,12 +658,12 @@ static numerictype_t sym_to_numtype(value_t type)
 // this provides (1) a way to allocate values with a shared type for
 // efficiency, (2) a uniform interface for allocating cvalues of any
 // type, including user-defined.
-value_t cvalue_new(value_t *args, u_int32_t nargs)
+value_t cvalue_new(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 1 || nargs > 2)
-        argcount("c-value", nargs, 2);
+        argcount(fl_ctx, "c-value", nargs, 2);
     value_t type = args[0];
-    fltype_t *ft = get_type(type);
+    fltype_t *ft = get_type(fl_ctx, type);
     value_t cv;
     if (ft->eltype != NULL) {
         // special case to handle incomplete array types bla[]
@@ -691,19 +671,19 @@ value_t cvalue_new(value_t *args, u_int32_t nargs)
         size_t cnt;
 
         if (iscons(cdr_(cdr_(type))))
-            cnt = tosize(car_(cdr_(cdr_(type))), "array");
+            cnt = tosize(fl_ctx, car_(cdr_(cdr_(type))), "array");
         else if (nargs == 2)
-            cnt = predict_arraylen(args[1]);
+            cnt = predict_arraylen(fl_ctx, args[1]);
         else
             cnt = 0;
-        cv = cvalue(ft, elsz * cnt);
+        cv = cvalue(fl_ctx, ft, elsz * cnt);
         if (nargs == 2)
-            cvalue_array_init(ft, args[1], cv_data((cvalue_t*)ptr(cv)));
+            cvalue_array_init(fl_ctx, ft, args[1], cv_data((cvalue_t*)ptr(cv)));
     }
     else {
-        cv = cvalue(ft, ft->size);
+        cv = cvalue(fl_ctx, ft, ft->size);
         if (nargs == 2)
-            cvalue_init(ft, args[1], cptr(cv));
+            cvalue_init(fl_ctx, ft, args[1], cptr(cv));
     }
     return cv;
 }
@@ -728,27 +708,27 @@ value_t cvalue_compare(value_t a, value_t b)
     return fixnum(diff);
 }
 
-static void check_addr_args(char *fname, value_t arr, value_t ind,
-                            char **data, size_t *index)
+static void check_addr_args(fl_context_t *fl_ctx, char *fname, value_t arr,
+                            value_t ind, char **data, size_t *index)
 {
     size_t numel;
     cvalue_t *cv = (cvalue_t*)ptr(arr);
     *data = (char*)cv_data(cv);
     numel = cv_len(cv)/(cv_class(cv)->elsz);
-    *index = tosize(ind, fname);
+    *index = tosize(fl_ctx, ind, fname);
     if (*index >= numel)
-        bounds_error(fname, arr, ind);
+        bounds_error(fl_ctx, fname, arr, ind);
 }
 
-static value_t cvalue_array_aref(value_t *args)
+static value_t cvalue_array_aref(fl_context_t *fl_ctx, value_t *args)
 {
     char *data; size_t index;
     fltype_t *eltype = cv_class((cvalue_t*)ptr(args[0]))->eltype;
     value_t el = 0;
     numerictype_t nt = eltype->numtype;
     if (nt >= T_INT32)
-        el = cvalue(eltype, eltype->size);
-    check_addr_args("aref", args[0], args[1], &data, &index);
+        el = cvalue(fl_ctx, eltype, eltype->size);
+    check_addr_args(fl_ctx, "aref", args[0], args[1], &data, &index);
     if (nt < T_INT32) {
         if (nt == T_INT8)
             return fixnum((int8_t)data[index]);
@@ -773,49 +753,49 @@ static value_t cvalue_array_aref(value_t *args)
     return el;
 }
 
-static value_t cvalue_array_aset(value_t *args)
+static value_t cvalue_array_aset(fl_context_t *fl_ctx, value_t *args)
 {
     char *data; size_t index;
     fltype_t *eltype = cv_class((cvalue_t*)ptr(args[0]))->eltype;
-    check_addr_args("aset!", args[0], args[1], &data, &index);
+    check_addr_args(fl_ctx, "aset!", args[0], args[1], &data, &index);
     char *dest = data + index*eltype->size;
-    cvalue_init(eltype, args[2], dest);
+    cvalue_init(fl_ctx, eltype, args[2], dest);
     return args[2];
 }
 
-value_t fl_builtin(value_t *args, u_int32_t nargs)
+value_t fl_builtin(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("builtin", nargs, 1);
-    symbol_t *name = tosymbol(args[0], "builtin");
+    argcount(fl_ctx, "builtin", nargs, 1);
+    symbol_t *name = tosymbol(fl_ctx, args[0], "builtin");
     cvalue_t *cv;
-    if (ismanaged(args[0]) || (cv=(cvalue_t*)name->dlcache) == NULL) {
-        lerrorf(ArgError, "builtin: function %s not found", name->name);
+    if (ismanaged(fl_ctx, args[0]) || (cv=(cvalue_t*)name->dlcache) == NULL) {
+        lerrorf(fl_ctx, fl_ctx->ArgError, "builtin: function %s not found", name->name);
     }
     return tagptr(cv, TAG_CVALUE);
 }
 
-value_t cbuiltin(char *name, builtin_t f)
+value_t cbuiltin(fl_context_t *fl_ctx, char *name, builtin_t f)
 {
     cvalue_t *cv = (cvalue_t*)malloc(CVALUE_NWORDS * sizeof(value_t));
-    cv->type = builtintype;
+    cv->type = fl_ctx->builtintype;
     cv->data = &cv->_space[0];
     cv->len = sizeof(value_t);
     *(void**)cv->data = (void*)f;
 
-    value_t sym = symbol(name);
+    value_t sym = symbol(fl_ctx, name);
     ((symbol_t*)ptr(sym))->dlcache = cv;
-    ptrhash_put(&reverse_dlsym_lookup_table, cv, (void*)sym);
+    ptrhash_put(&fl_ctx->reverse_dlsym_lookup_table, cv, (void*)sym);
 
     return tagptr(cv, TAG_CVALUE);
 }
 
-static value_t fl_logand(value_t *args, u_int32_t nargs);
-static value_t fl_logior(value_t *args, u_int32_t nargs);
-static value_t fl_logxor(value_t *args, u_int32_t nargs);
-static value_t fl_lognot(value_t *args, u_int32_t nargs);
-static value_t fl_ash(value_t *args, u_int32_t nargs);
+static value_t fl_logand(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+static value_t fl_logior(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+static value_t fl_logxor(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+static value_t fl_lognot(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+static value_t fl_ash(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
 
-static builtinspec_t cvalues_builtin_info[] = {
+static const builtinspec_t cvalues_builtin_info[] = {
     { "c-value", cvalue_new },
     { "typeof", cvalue_typeof },
     { "sizeof", cvalue_sizeof },
@@ -832,123 +812,120 @@ static builtinspec_t cvalues_builtin_info[] = {
     { NULL, NULL }
 };
 
-#define cv_intern(tok) tok##sym = symbol(#tok)
-#define ctor_cv_intern(tok) \
-    cv_intern(tok);set(tok##sym, cbuiltin(#tok, cvalue_##tok))
+#define cv_intern(fl_ctx, tok) fl_ctx->tok##sym = symbol(fl_ctx, #tok)
+#define ctor_cv_intern(fl_ctx, tok)                             \
+    cv_intern(fl_ctx, tok);                                     \
+    set(fl_ctx->tok##sym, cbuiltin(fl_ctx, #tok, cvalue_##tok))
 
-#define mk_primtype(name) \
-  name##type=get_type(name##sym);name##type->init = &cvalue_##name##_init
+#define mk_primtype(fl_ctx, name)                               \
+    fl_ctx->name##type = get_type(fl_ctx, fl_ctx->name##sym);   \
+    fl_ctx->name##type->init = &cvalue_##name##_init
 
-#define mk_primtype_(name,ctype) \
-  name##type=get_type(name##sym);name##type->init = &cvalue_##ctype##_init
-
-struct prim_int16{ char a; int16_t i; };
-struct prim_int32{ char a; int32_t i; };
-struct prim_int64{ char a; int64_t i; };
-struct prim_ptr{ char a;  void   *i; };
+#define mk_primtype_(fl_ctx, name, ctype)                       \
+    fl_ctx->name##type = get_type(fl_ctx, fl_ctx->name##sym);   \
+    fl_ctx->name##type->init = &cvalue_##ctype##_init
 
-static void cvalues_init(void)
+static void cvalues_init(fl_context_t *fl_ctx)
 {
-    htable_new(&TypeTable, 256);
-    htable_new(&reverse_dlsym_lookup_table, 256);
-
-    // compute struct field alignment required for primitives
-    ALIGN2   = sizeof(struct prim_int16) - 2;
-    ALIGN4   = sizeof(struct prim_int32) - 4;
-    ALIGN8   = sizeof(struct prim_int64) - 8;
-    ALIGNPTR = sizeof(struct prim_ptr) - sizeof(void*);
-
-    builtintype = define_opaque_type(builtinsym, sizeof(builtin_t), NULL, NULL);
-
-    ctor_cv_intern(int8);
-    ctor_cv_intern(uint8);
-    ctor_cv_intern(int16);
-    ctor_cv_intern(uint16);
-    ctor_cv_intern(int32);
-    ctor_cv_intern(uint32);
-    ctor_cv_intern(int64);
-    ctor_cv_intern(uint64);
-    ctor_cv_intern(byte);
-    ctor_cv_intern(wchar);
-    ctor_cv_intern(ptrdiff);
-    ctor_cv_intern(size);
-    ctor_cv_intern(float);
-    ctor_cv_intern(double);
-
-    ctor_cv_intern(array);
-    cv_intern(pointer);
-    cv_intern(void);
-    cfunctionsym = symbol("c-function");
-
-    assign_global_builtins(cvalues_builtin_info);
-
-    stringtypesym = symbol("*string-type*");
-    setc(stringtypesym, fl_list2(arraysym, bytesym));
-
-    wcstringtypesym = symbol("*wcstring-type*");
-    setc(wcstringtypesym, fl_list2(arraysym, wcharsym));
-
-    mk_primtype(int8);
-    mk_primtype(uint8);
-    mk_primtype(int16);
-    mk_primtype(uint16);
-    mk_primtype(int32);
-    mk_primtype(uint32);
-    mk_primtype(int64);
-    mk_primtype(uint64);
+    fl_ctx->malloc_pressure = 0;
+    fl_ctx->Finalizers = NULL;
+    fl_ctx->nfinalizers = 0;
+    fl_ctx->maxfinalizers = 0;
+
+    htable_new(&fl_ctx->TypeTable, 256);
+    htable_new(&fl_ctx->reverse_dlsym_lookup_table, 256);
+
+    fl_ctx->builtintype = define_opaque_type(fl_ctx->builtinsym, sizeof(builtin_t), NULL, NULL);
+
+    ctor_cv_intern(fl_ctx, int8);
+    ctor_cv_intern(fl_ctx, uint8);
+    ctor_cv_intern(fl_ctx, int16);
+    ctor_cv_intern(fl_ctx, uint16);
+    ctor_cv_intern(fl_ctx, int32);
+    ctor_cv_intern(fl_ctx, uint32);
+    ctor_cv_intern(fl_ctx, int64);
+    ctor_cv_intern(fl_ctx, uint64);
+    ctor_cv_intern(fl_ctx, byte);
+    ctor_cv_intern(fl_ctx, wchar);
+    ctor_cv_intern(fl_ctx, ptrdiff);
+    ctor_cv_intern(fl_ctx, size);
+    ctor_cv_intern(fl_ctx, float);
+    ctor_cv_intern(fl_ctx, double);
+
+    ctor_cv_intern(fl_ctx, array);
+    cv_intern(fl_ctx, pointer);
+    cv_intern(fl_ctx, void);
+    fl_ctx->cfunctionsym = symbol(fl_ctx, "c-function");
+
+    assign_global_builtins(fl_ctx, cvalues_builtin_info);
+
+    fl_ctx->stringtypesym = symbol(fl_ctx, "*string-type*");
+    setc(fl_ctx->stringtypesym, fl_list2(fl_ctx, fl_ctx->arraysym, fl_ctx->bytesym));
+
+    fl_ctx->wcstringtypesym = symbol(fl_ctx, "*wcstring-type*");
+    setc(fl_ctx->wcstringtypesym, fl_list2(fl_ctx, fl_ctx->arraysym, fl_ctx->wcharsym));
+
+    mk_primtype(fl_ctx, int8);
+    mk_primtype(fl_ctx, uint8);
+    mk_primtype(fl_ctx, int16);
+    mk_primtype(fl_ctx, uint16);
+    mk_primtype(fl_ctx, int32);
+    mk_primtype(fl_ctx, uint32);
+    mk_primtype(fl_ctx, int64);
+    mk_primtype(fl_ctx, uint64);
 #ifdef _P64
-    mk_primtype_(ptrdiff,int64);
-    mk_primtype_(size,uint64);
+    mk_primtype_(fl_ctx, ptrdiff, int64);
+    mk_primtype_(fl_ctx, size, uint64);
 #else
-    mk_primtype_(ptrdiff,int32);
-    mk_primtype_(size,uint32);
+    mk_primtype_(fl_ctx, ptrdiff, int32);
+    mk_primtype_(fl_ctx, size, uint32);
 #endif
-    mk_primtype_(byte,uint8);
-    mk_primtype_(wchar,int32);
-    mk_primtype(float);
-    mk_primtype(double);
+    mk_primtype_(fl_ctx, byte, uint8);
+    mk_primtype_(fl_ctx, wchar, int32);
+    mk_primtype(fl_ctx, float);
+    mk_primtype(fl_ctx, double);
 
-    stringtype = get_type(symbol_value(stringtypesym));
-    wcstringtype = get_type(symbol_value(wcstringtypesym));
+    fl_ctx->stringtype = get_type(fl_ctx, symbol_value(fl_ctx->stringtypesym));
+    fl_ctx->wcstringtype = get_type(fl_ctx, symbol_value(fl_ctx->wcstringtypesym));
 
-    emptystringsym = symbol("*empty-string*");
-    setc(emptystringsym, cvalue_static_cstring(""));
+    fl_ctx->emptystringsym = symbol(fl_ctx, "*empty-string*");
+    setc(fl_ctx->emptystringsym, cvalue_static_cstring(fl_ctx, ""));
 }
 
-#define RETURN_NUM_AS(var, type) return(mk_##type((fl_##type##_t)var))
+#define RETURN_NUM_AS(fl_ctx, var, type) return(mk_##type(fl_ctx, (fl_##type##_t)var))
 
-value_t return_from_uint64(uint64_t Uaccum)
+value_t return_from_uint64(fl_context_t *fl_ctx, uint64_t Uaccum)
 {
     if (fits_fixnum(Uaccum)) {
         return fixnum((fixnum_t)Uaccum);
     }
     if (Uaccum > (uint64_t)S64_MAX) {
-        RETURN_NUM_AS(Uaccum, uint64);
+        RETURN_NUM_AS(fl_ctx, Uaccum, uint64);
     }
     else if (Uaccum > (uint64_t)INT_MAX) {
-        RETURN_NUM_AS(Uaccum, int64);
+        RETURN_NUM_AS(fl_ctx, Uaccum, int64);
     }
-    RETURN_NUM_AS(Uaccum, int32);
+    RETURN_NUM_AS(fl_ctx, Uaccum, int32);
 }
 
-value_t return_from_int64(int64_t Saccum)
+value_t return_from_int64(fl_context_t *fl_ctx, int64_t Saccum)
 {
     if (fits_fixnum(Saccum)) {
         return fixnum((fixnum_t)Saccum);
     }
     if (Saccum > (int64_t)INT_MAX || Saccum < (int64_t)INT_MIN) {
-        RETURN_NUM_AS(Saccum, int64);
+        RETURN_NUM_AS(fl_ctx, Saccum, int64);
     }
-    RETURN_NUM_AS(Saccum, int32);
+    RETURN_NUM_AS(fl_ctx, Saccum, int32);
 }
 
-static value_t fl_add_any(value_t *args, u_int32_t nargs, fixnum_t carryIn)
+static value_t fl_add_any(fl_context_t *fl_ctx, value_t *args, uint32_t nargs, fixnum_t carryIn)
 {
     uint64_t Uaccum=0;
     int64_t Saccum = carryIn;
     double Faccum=0;
     uint32_t i;
-    value_t arg=NIL;
+    value_t arg=fl_ctx->NIL;
 
     FOR_ARGS(i,0,arg,args) {
         if (isfixnum(arg)) {
@@ -982,12 +959,12 @@ static value_t fl_add_any(value_t *args, u_int32_t nargs, fixnum_t carryIn)
             continue;
         }
     add_type_error:
-        type_error("+", "number", arg);
+        type_error(fl_ctx, "+", "number", arg);
     }
     if (Faccum != 0) {
         Faccum += Uaccum;
         Faccum += Saccum;
-        return mk_double(Faccum);
+        return mk_double(fl_ctx, Faccum);
     }
     else if (Saccum < 0) {
         uint64_t negpart = (uint64_t)(-Saccum);
@@ -998,9 +975,9 @@ static value_t fl_add_any(value_t *args, u_int32_t nargs, fixnum_t carryIn)
                 if (fits_fixnum(Saccum)) {
                     return fixnum((fixnum_t)Saccum);
                 }
-                RETURN_NUM_AS(Saccum, int32);
+                RETURN_NUM_AS(fl_ctx, Saccum, int32);
             }
-            RETURN_NUM_AS(Saccum, int64);
+            RETURN_NUM_AS(fl_ctx, Saccum, int64);
         }
         Uaccum -= negpart;
     }
@@ -1008,10 +985,10 @@ static value_t fl_add_any(value_t *args, u_int32_t nargs, fixnum_t carryIn)
         Uaccum += (uint64_t)Saccum;
     }
     // return value in Uaccum
-    return return_from_uint64(Uaccum);
+    return return_from_uint64(fl_ctx, Uaccum);
 }
 
-static value_t fl_neg(value_t n)
+static value_t fl_neg(fl_context_t *fl_ctx, value_t n)
 {
     if (isfixnum(n)) {
         return fixnum(-numval(n));
@@ -1030,32 +1007,32 @@ static value_t fl_neg(value_t n)
         case T_INT32:
             i32 = *(int32_t*)a;
             if (i32 == (int32_t)BIT31)
-                return mk_uint32((uint32_t)BIT31);
-            return mk_int32(-i32);
+                return mk_uint32(fl_ctx, (uint32_t)BIT31);
+            return mk_int32(fl_ctx, -i32);
         case T_UINT32:
             ui32 = *(uint32_t*)a;
-            if (ui32 <= ((uint32_t)INT_MAX)+1) return mk_int32(-(int32_t)ui32);
-            return mk_int64(-(int64_t)ui32);
+            if (ui32 <= ((uint32_t)INT_MAX)+1) return mk_int32(fl_ctx, -(int32_t)ui32);
+            return mk_int64(fl_ctx, -(int64_t)ui32);
         case T_INT64:
             i64 = *(int64_t*)a;
             if (i64 == (int64_t)BIT63)
-                return mk_uint64((uint64_t)BIT63);
-            return mk_int64(-i64);
-        case T_UINT64: return mk_int64(-(int64_t)*(uint64_t*)a);
-        case T_FLOAT:  return mk_float(-*(float*)a);
-        case T_DOUBLE: return mk_double(-*(double*)a);
+                return mk_uint64(fl_ctx, (uint64_t)BIT63);
+            return mk_int64(fl_ctx, -i64);
+        case T_UINT64: return mk_int64(fl_ctx, -(int64_t)*(uint64_t*)a);
+        case T_FLOAT:  return mk_float(fl_ctx, -*(float*)a);
+        case T_DOUBLE: return mk_double(fl_ctx, -*(double*)a);
             break;
         }
     }
-    type_error("-", "number", n);
+    type_error(fl_ctx, "-", "number", n);
 }
 
-static value_t fl_mul_any(value_t *args, u_int32_t nargs, int64_t Saccum)
+static value_t fl_mul_any(fl_context_t *fl_ctx, value_t *args, uint32_t nargs, int64_t Saccum)
 {
     uint64_t Uaccum=1;
     double Faccum=1;
     uint32_t i;
-    value_t arg=NIL;
+    value_t arg=fl_ctx->NIL;
 
     FOR_ARGS(i,0,arg,args) {
         if (isfixnum(arg)) {
@@ -1089,12 +1066,12 @@ static value_t fl_mul_any(value_t *args, u_int32_t nargs, int64_t Saccum)
             continue;
         }
     mul_type_error:
-        type_error("*", "number", arg);
+        type_error(fl_ctx, "*", "number", arg);
     }
     if (Faccum != 1) {
         Faccum *= Uaccum;
         Faccum *= Saccum;
-        return mk_double(Faccum);
+        return mk_double(fl_ctx, Faccum);
     }
     else if (Saccum < 0) {
         Saccum *= (int64_t)Uaccum;
@@ -1102,14 +1079,14 @@ static value_t fl_mul_any(value_t *args, u_int32_t nargs, int64_t Saccum)
             if (fits_fixnum(Saccum)) {
                 return fixnum((fixnum_t)Saccum);
             }
-            RETURN_NUM_AS(Saccum, int32);
+            RETURN_NUM_AS(fl_ctx, Saccum, int32);
         }
-        RETURN_NUM_AS(Saccum, int64);
+        RETURN_NUM_AS(fl_ctx, Saccum, int64);
     }
     else {
         Uaccum *= (uint64_t)Saccum;
     }
-    return return_from_uint64(Uaccum);
+    return return_from_uint64(fl_ctx, Uaccum);
 }
 
 static int num_to_ptr(value_t a, fixnum_t *pi, numerictype_t *pt, void **pp)
@@ -1139,7 +1116,7 @@ static int num_to_ptr(value_t a, fixnum_t *pi, numerictype_t *pt, void **pp)
           inexact not considered equal to exact
   fname: if not NULL, throws type errors, else returns 2 for type errors
 */
-int numeric_compare(value_t a, value_t b, int eq, int eqnans, char *fname)
+int numeric_compare(fl_context_t *fl_ctx, value_t a, value_t b, int eq, int eqnans, char *fname)
 {
     int_t ai, bi;
     numerictype_t ta, tb;
@@ -1151,10 +1128,10 @@ int numeric_compare(value_t a, value_t b, int eq, int eqnans, char *fname)
         return 1;
     }
     if (!num_to_ptr(a, &ai, &ta, &aptr)) {
-        if (fname) type_error(fname, "number", a); else return 2;
+        if (fname) type_error(fl_ctx, fname, "number", a); else return 2;
     }
     if (!num_to_ptr(b, &bi, &tb, &bptr)) {
-        if (fname) type_error(fname, "number", b); else return 2;
+        if (fname) type_error(fl_ctx, fname, "number", b); else return 2;
     }
     if (eq && eqnans && ((ta >= T_FLOAT) != (tb >= T_FLOAT)))
         return 1;
@@ -1167,17 +1144,17 @@ int numeric_compare(value_t a, value_t b, int eq, int eqnans, char *fname)
 }
 
 #if defined(_OS_WINDOWS_)
-__declspec(noreturn) static void DivideByZeroError();
+__declspec(noreturn) static void DivideByZeroError(fl_context_t *fl_ctx);
 #else
-static void DivideByZeroError() __attribute__ ((__noreturn__));
+static void DivideByZeroError(fl_context_t *fl_ctx) __attribute__ ((__noreturn__));
 #endif
 
-static void DivideByZeroError(void)
+static void DivideByZeroError(fl_context_t *fl_ctx)
 {
-    lerror(DivideError, "/: division by zero");
+    lerror(fl_ctx, fl_ctx->DivideError, "/: division by zero");
 }
 
-static value_t fl_div2(value_t a, value_t b)
+static value_t fl_div2(fl_context_t *fl_ctx, value_t a, value_t b)
 {
     double da, db;
     int_t ai, bi;
@@ -1185,24 +1162,24 @@ static value_t fl_div2(value_t a, value_t b)
     void *aptr, *bptr;
 
     if (!num_to_ptr(a, &ai, &ta, &aptr))
-        type_error("/", "number", a);
+        type_error(fl_ctx, "/", "number", a);
     if (!num_to_ptr(b, &bi, &tb, &bptr))
-        type_error("/", "number", b);
+        type_error(fl_ctx, "/", "number", b);
 
     da = conv_to_double(aptr, ta);
     db = conv_to_double(bptr, tb);
 
     if (db == 0 && tb < T_FLOAT)  // exact 0
-        DivideByZeroError();
+        DivideByZeroError(fl_ctx);
 
     da = da/db;
 
     if (ta < T_FLOAT && tb < T_FLOAT && (double)(int64_t)da == da)
-        return return_from_int64((int64_t)da);
-    return mk_double(da);
+        return return_from_int64(fl_ctx, (int64_t)da);
+    return mk_double(fl_ctx, da);
 }
 
-static value_t fl_idiv2(value_t a, value_t b)
+static value_t fl_idiv2(fl_context_t *fl_ctx, value_t a, value_t b)
 {
     int_t ai, bi;
     numerictype_t ta, tb;
@@ -1210,43 +1187,43 @@ static value_t fl_idiv2(value_t a, value_t b)
     int64_t a64, b64;
 
     if (!num_to_ptr(a, &ai, &ta, &aptr))
-        type_error("div0", "number", a);
+        type_error(fl_ctx, "div0", "number", a);
     if (!num_to_ptr(b, &bi, &tb, &bptr))
-        type_error("div0", "number", b);
+        type_error(fl_ctx, "div0", "number", b);
 
     if (ta == T_UINT64) {
         if (tb == T_UINT64) {
             if (*(uint64_t*)bptr == 0) goto div_error;
-            return return_from_uint64(*(uint64_t*)aptr / *(uint64_t*)bptr);
+            return return_from_uint64(fl_ctx, *(uint64_t*)aptr / *(uint64_t*)bptr);
         }
         b64 = conv_to_int64(bptr, tb);
         if (b64 < 0) {
-            return return_from_int64(-(int64_t)(*(uint64_t*)aptr /
-                                                (uint64_t)(-b64)));
+            return return_from_int64(fl_ctx, -(int64_t)(*(uint64_t*)aptr /
+                                                        (uint64_t)(-b64)));
         }
         if (b64 == 0)
             goto div_error;
-        return return_from_uint64(*(uint64_t*)aptr / (uint64_t)b64);
+        return return_from_uint64(fl_ctx, *(uint64_t*)aptr / (uint64_t)b64);
     }
     if (tb == T_UINT64) {
         if (*(uint64_t*)bptr == 0) goto div_error;
         a64 = conv_to_int64(aptr, ta);
         if (a64 < 0) {
-            return return_from_int64(-((int64_t)((uint64_t)(-a64) /
-                                                 *(uint64_t*)bptr)));
+            return return_from_int64(fl_ctx, -((int64_t)((uint64_t)(-a64) /
+                                                         *(uint64_t*)bptr)));
         }
-        return return_from_uint64((uint64_t)a64 / *(uint64_t*)bptr);
+        return return_from_uint64(fl_ctx, (uint64_t)a64 / *(uint64_t*)bptr);
     }
 
     b64 = conv_to_int64(bptr, tb);
     if (b64 == 0) goto div_error;
 
-    return return_from_int64(conv_to_int64(aptr, ta) / b64);
+    return return_from_int64(fl_ctx, conv_to_int64(aptr, ta) / b64);
  div_error:
-    DivideByZeroError();
+    DivideByZeroError(fl_ctx);
 }
 
-static value_t fl_bitwise_op(value_t a, value_t b, int opcode, char *fname)
+static value_t fl_bitwise_op(fl_context_t *fl_ctx, value_t a, value_t b, int opcode, char *fname)
 {
     int_t ai, bi;
     numerictype_t ta, tb, itmp;
@@ -1254,9 +1231,9 @@ static value_t fl_bitwise_op(value_t a, value_t b, int opcode, char *fname)
     int64_t b64;
 
     if (!num_to_ptr(a, &ai, &ta, &aptr) || ta >= T_FLOAT)
-        type_error(fname, "integer", a);
+        type_error(fl_ctx, fname, "integer", a);
     if (!num_to_ptr(b, &bi, &tb, &bptr) || tb >= T_FLOAT)
-        type_error(fname, "integer", b);
+        type_error(fl_ctx, fname, "integer", b);
 
     if (ta < tb) {
         itmp = ta; ta = tb; tb = itmp;
@@ -1271,10 +1248,10 @@ static value_t fl_bitwise_op(value_t a, value_t b, int opcode, char *fname)
     case T_UINT8:  return fixnum(   *(uint8_t *)aptr & (uint8_t )b64);
     case T_INT16:  return fixnum(   *(int16_t*)aptr  & (int16_t )b64);
     case T_UINT16: return fixnum(   *(uint16_t*)aptr & (uint16_t)b64);
-    case T_INT32:  return mk_int32( *(int32_t*)aptr  & (int32_t )b64);
-    case T_UINT32: return mk_uint32(*(uint32_t*)aptr & (uint32_t)b64);
-    case T_INT64:  return mk_int64( *(int64_t*)aptr  & (int64_t )b64);
-    case T_UINT64: return mk_uint64(*(uint64_t*)aptr & (uint64_t)b64);
+    case T_INT32:  return mk_int32(fl_ctx,  *(int32_t*)aptr  & (int32_t )b64);
+    case T_UINT32: return mk_uint32(fl_ctx, *(uint32_t*)aptr & (uint32_t)b64);
+    case T_INT64:  return mk_int64(fl_ctx,  *(int64_t*)aptr  & (int64_t )b64);
+    case T_UINT64: return mk_uint64(fl_ctx, *(uint64_t*)aptr & (uint64_t)b64);
     case T_FLOAT:
     case T_DOUBLE: assert(0);
     }
@@ -1285,10 +1262,10 @@ static value_t fl_bitwise_op(value_t a, value_t b, int opcode, char *fname)
     case T_UINT8:  return fixnum(   *(uint8_t *)aptr | (uint8_t )b64);
     case T_INT16:  return fixnum(   *(int16_t*)aptr  | (int16_t )b64);
     case T_UINT16: return fixnum(   *(uint16_t*)aptr | (uint16_t)b64);
-    case T_INT32:  return mk_int32( *(int32_t*)aptr  | (int32_t )b64);
-    case T_UINT32: return mk_uint32(*(uint32_t*)aptr | (uint32_t)b64);
-    case T_INT64:  return mk_int64( *(int64_t*)aptr  | (int64_t )b64);
-    case T_UINT64: return mk_uint64(*(uint64_t*)aptr | (uint64_t)b64);
+    case T_INT32:  return mk_int32(fl_ctx,  *(int32_t*)aptr  | (int32_t )b64);
+    case T_UINT32: return mk_uint32(fl_ctx, *(uint32_t*)aptr | (uint32_t)b64);
+    case T_INT64:  return mk_int64(fl_ctx,  *(int64_t*)aptr  | (int64_t )b64);
+    case T_UINT64: return mk_uint64(fl_ctx, *(uint64_t*)aptr | (uint64_t)b64);
     case T_FLOAT:
     case T_DOUBLE: assert(0);
     }
@@ -1299,19 +1276,19 @@ static value_t fl_bitwise_op(value_t a, value_t b, int opcode, char *fname)
     case T_UINT8:  return fixnum(   *(uint8_t *)aptr ^ (uint8_t )b64);
     case T_INT16:  return fixnum(   *(int16_t*)aptr  ^ (int16_t )b64);
     case T_UINT16: return fixnum(   *(uint16_t*)aptr ^ (uint16_t)b64);
-    case T_INT32:  return mk_int32( *(int32_t*)aptr  ^ (int32_t )b64);
-    case T_UINT32: return mk_uint32(*(uint32_t*)aptr ^ (uint32_t)b64);
-    case T_INT64:  return mk_int64( *(int64_t*)aptr  ^ (int64_t )b64);
-    case T_UINT64: return mk_uint64(*(uint64_t*)aptr ^ (uint64_t)b64);
+    case T_INT32:  return mk_int32(fl_ctx,  *(int32_t*)aptr  ^ (int32_t )b64);
+    case T_UINT32: return mk_uint32(fl_ctx, *(uint32_t*)aptr ^ (uint32_t)b64);
+    case T_INT64:  return mk_int64(fl_ctx,  *(int64_t*)aptr  ^ (int64_t )b64);
+    case T_UINT64: return mk_uint64(fl_ctx, *(uint64_t*)aptr ^ (uint64_t)b64);
     case T_FLOAT:
     case T_DOUBLE: assert(0);
     }
     }
     assert(0);
-    return NIL;
+    return fl_ctx->NIL;
 }
 
-static value_t fl_logand(value_t *args, u_int32_t nargs)
+static value_t fl_logand(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     value_t v, e;
     int i;
@@ -1322,12 +1299,12 @@ static value_t fl_logand(value_t *args, u_int32_t nargs)
         if (bothfixnums(v, e))
             v = v & e;
         else
-            v = fl_bitwise_op(v, e, 0, "logand");
+            v = fl_bitwise_op(fl_ctx, v, e, 0, "logand");
     }
     return v;
 }
 
-static value_t fl_logior(value_t *args, u_int32_t nargs)
+static value_t fl_logior(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     value_t v, e;
     int i;
@@ -1338,12 +1315,12 @@ static value_t fl_logior(value_t *args, u_int32_t nargs)
         if (bothfixnums(v, e))
             v = v | e;
         else
-            v = fl_bitwise_op(v, e, 1, "logior");
+            v = fl_bitwise_op(fl_ctx, v, e, 1, "logior");
     }
     return v;
 }
 
-static value_t fl_logxor(value_t *args, u_int32_t nargs)
+static value_t fl_logxor(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     value_t v, e;
     int i;
@@ -1354,14 +1331,14 @@ static value_t fl_logxor(value_t *args, u_int32_t nargs)
         if (bothfixnums(v, e))
             v = fixnum(numval(v) ^ numval(e));
         else
-            v = fl_bitwise_op(v, e, 2, "logxor");
+            v = fl_bitwise_op(fl_ctx, v, e, 2, "logxor");
     }
     return v;
 }
 
-static value_t fl_lognot(value_t *args, u_int32_t nargs)
+static value_t fl_lognot(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("lognot", nargs, 1);
+    argcount(fl_ctx, "lognot", nargs, 1);
     value_t a = args[0];
     if (isfixnum(a))
         return fixnum(~numval(a));
@@ -1378,22 +1355,22 @@ static value_t fl_lognot(value_t *args, u_int32_t nargs)
         case T_UINT8:  return fixnum(~*(uint8_t *)aptr);
         case T_INT16:  return fixnum(~*(int16_t *)aptr);
         case T_UINT16: return fixnum(~*(uint16_t*)aptr);
-        case T_INT32:  return mk_int32(~*(int32_t *)aptr);
-        case T_UINT32: return mk_uint32(~*(uint32_t*)aptr);
-        case T_INT64:  return mk_int64(~*(int64_t *)aptr);
-        case T_UINT64: return mk_uint64(~*(uint64_t*)aptr);
+        case T_INT32:  return mk_int32(fl_ctx, ~*(int32_t *)aptr);
+        case T_UINT32: return mk_uint32(fl_ctx, ~*(uint32_t*)aptr);
+        case T_INT64:  return mk_int64(fl_ctx, ~*(int64_t *)aptr);
+        case T_UINT64: return mk_uint64(fl_ctx, ~*(uint64_t*)aptr);
         }
     }
-    type_error("lognot", "integer", a);
+    type_error(fl_ctx, "lognot", "integer", a);
 }
 
-static value_t fl_ash(value_t *args, u_int32_t nargs)
+static value_t fl_ash(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     fixnum_t n;
     int64_t accum;
-    argcount("ash", nargs, 2);
+    argcount(fl_ctx, "ash", nargs, 2);
     value_t a = args[0];
-    n = tofixnum(args[1], "ash");
+    n = tofixnum(fl_ctx, args[1], "ash");
     if (isfixnum(a)) {
         if (n <= 0)
             return fixnum(numval(a)>>(-n));
@@ -1401,7 +1378,7 @@ static value_t fl_ash(value_t *args, u_int32_t nargs)
         if (fits_fixnum(accum))
             return fixnum(accum);
         else
-            return return_from_int64(accum);
+            return return_from_int64(fl_ctx, accum);
     }
     cprim_t *cp;
     int ta;
@@ -1418,21 +1395,21 @@ static value_t fl_ash(value_t *args, u_int32_t nargs)
             case T_UINT8:  return fixnum((*(uint8_t *)aptr) >> n);
             case T_INT16:  return fixnum((*(int16_t *)aptr) >> n);
             case T_UINT16: return fixnum((*(uint16_t*)aptr) >> n);
-            case T_INT32:  return mk_int32((*(int32_t *)aptr) >> n);
-            case T_UINT32: return mk_uint32((*(uint32_t*)aptr) >> n);
-            case T_INT64:  return mk_int64((*(int64_t *)aptr) >> n);
-            case T_UINT64: return mk_uint64((*(uint64_t*)aptr) >> n);
+            case T_INT32:  return mk_int32(fl_ctx, (*(int32_t *)aptr) >> n);
+            case T_UINT32: return mk_uint32(fl_ctx, (*(uint32_t*)aptr) >> n);
+            case T_INT64:  return mk_int64(fl_ctx, (*(int64_t *)aptr) >> n);
+            case T_UINT64: return mk_uint64(fl_ctx, (*(uint64_t*)aptr) >> n);
             }
         }
         else {
             if (ta == T_UINT64)
-                return return_from_uint64((*(uint64_t*)aptr)<<n);
+                return return_from_uint64(fl_ctx, (*(uint64_t*)aptr)<<n);
             else if (ta < T_FLOAT) {
                 int64_t i64 = conv_to_int64(aptr, (numerictype_t)ta);
-                return return_from_int64(i64<<n);
+                return return_from_int64(fl_ctx, i64<<n);
             }
         }
     }
-    type_error("ash", "integer", a);
-    return NIL;
+    type_error(fl_ctx, "ash", "integer", a);
+    return fl_ctx->NIL;
 }
diff --git a/src/flisp/equal.c b/src/flisp/equal.c
index d313ff3965150..3e52529b6a60c 100644
--- a/src/flisp/equal.c
+++ b/src/flisp/equal.c
@@ -4,30 +4,30 @@
 // comparable tag
 #define cmptag(v) (isfixnum(v) ? TAG_NUM : tag(v))
 
-static value_t eq_class(htable_t *table, value_t key)
+static value_t eq_class(fl_context_t *fl_ctx, htable_t *table, value_t key)
 {
     value_t c = (value_t)ptrhash_get(table, (void*)key);
     if (c == (value_t)HT_NOTFOUND)
-        return NIL;
+        return fl_ctx->NIL;
     if (c == key)
         return c;
-    return eq_class(table, c);
+    return eq_class(fl_ctx, table, c);
 }
 
-static void eq_union(htable_t *table, value_t a, value_t b,
-                     value_t c, value_t cb)
+static void eq_union(fl_context_t *fl_ctx, htable_t *table, value_t a,
+                     value_t b, value_t c, value_t cb)
 {
-    value_t ca = (c==NIL ? a : c);
-    if (cb != NIL)
+    value_t ca = (c==fl_ctx->NIL ? a : c);
+    if (cb != fl_ctx->NIL)
         ptrhash_put(table, (void*)cb, (void*)ca);
     ptrhash_put(table, (void*)a, (void*)ca);
     ptrhash_put(table, (void*)b, (void*)ca);
 }
 
-static value_t bounded_compare(value_t a, value_t b, int bound, int eq);
-static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq);
+static value_t bounded_compare(fl_context_t *fl_ctx, value_t a, value_t b, int bound, int eq);
+static value_t cyc_compare(fl_context_t *fl_ctx, value_t a, value_t b, htable_t *table, int eq);
 
-static value_t bounded_vector_compare(value_t a, value_t b, int bound, int eq)
+static value_t bounded_vector_compare(fl_context_t *fl_ctx, value_t a, value_t b, int bound, int eq)
 {
     size_t la = vector_size(a);
     size_t lb = vector_size(b);
@@ -35,9 +35,9 @@ static value_t bounded_vector_compare(value_t a, value_t b, int bound, int eq)
     if (eq && (la!=lb)) return fixnum(1);
     m = la < lb ? la : lb;
     for (i = 0; i < m; i++) {
-        value_t d = bounded_compare(vector_elt(a,i), vector_elt(b,i),
+        value_t d = bounded_compare(fl_ctx, vector_elt(a,i), vector_elt(b,i),
                                     bound-1, eq);
-        if (d==NIL || numval(d)!=0) return d;
+        if (d==fl_ctx->NIL || numval(d)!=0) return d;
     }
     if (la < lb) return fixnum(-1);
     if (la > lb) return fixnum(1);
@@ -46,14 +46,14 @@ static value_t bounded_vector_compare(value_t a, value_t b, int bound, int eq)
 
 // strange comparisons are resolved arbitrarily but consistently.
 // ordering: number < cprim < function < vector < cvalue < symbol < cons
-static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
+static value_t bounded_compare(fl_context_t *fl_ctx, value_t a, value_t b, int bound, int eq)
 {
     value_t d;
 
  compare_top:
     if (a == b) return fixnum(0);
     if (bound <= 0)
-        return NIL;
+        return fl_ctx->NIL;
     int taga = tag(a);
     int tagb = cmptag(b);
     int c;
@@ -64,29 +64,29 @@ static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
             return (numval(a) < numval(b)) ? fixnum(-1) : fixnum(1);
         }
         if (iscprim(b)) {
-            if (cp_class((cprim_t*)ptr(b)) == wchartype)
+            if (cp_class((cprim_t*)ptr(b)) == fl_ctx->wchartype)
                 return fixnum(1);
-            return fixnum(numeric_compare(a, b, eq, 1, NULL));
+            return fixnum(numeric_compare(fl_ctx, a, b, eq, 1, NULL));
         }
         return fixnum(-1);
     case TAG_SYM:
         if (eq) return fixnum(1);
         if (tagb < TAG_SYM) return fixnum(1);
         if (tagb > TAG_SYM) return fixnum(-1);
-        return fixnum(strcmp(symbol_name(a), symbol_name(b)));
+        return fixnum(strcmp(symbol_name(fl_ctx, a), symbol_name(fl_ctx, b)));
     case TAG_VECTOR:
         if (isvector(b))
-            return bounded_vector_compare(a, b, bound, eq);
+            return bounded_vector_compare(fl_ctx, a, b, bound, eq);
         break;
     case TAG_CPRIM:
-        if (cp_class((cprim_t*)ptr(a)) == wchartype) {
-            if (!iscprim(b) || cp_class((cprim_t*)ptr(b)) != wchartype)
+        if (cp_class((cprim_t*)ptr(a)) == fl_ctx->wchartype) {
+            if (!iscprim(b) || cp_class((cprim_t*)ptr(b)) != fl_ctx->wchartype)
                 return fixnum(-1);
         }
-        else if (iscprim(b) && cp_class((cprim_t*)ptr(b)) == wchartype) {
+        else if (iscprim(b) && cp_class((cprim_t*)ptr(b)) == fl_ctx->wchartype) {
             return fixnum(1);
         }
-        c = numeric_compare(a, b, eq, 1, NULL);
+        c = numeric_compare(fl_ctx, a, b, eq, 1, NULL);
         if (c != 2)
             return fixnum(c);
         break;
@@ -102,12 +102,12 @@ static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
             if (uintval(a) > N_BUILTINS && uintval(b) > N_BUILTINS) {
                 function_t *fa = (function_t*)ptr(a);
                 function_t *fb = (function_t*)ptr(b);
-                d = bounded_compare(fa->bcode, fb->bcode, bound-1, eq);
-                if (d==NIL || numval(d) != 0) return d;
-                d = bounded_compare(fa->vals, fb->vals, bound-1, eq);
-                if (d==NIL || numval(d) != 0) return d;
-                d = bounded_compare(fa->env, fb->env, bound-1, eq);
-                if (d==NIL || numval(d) != 0) return d;
+                d = bounded_compare(fl_ctx, fa->bcode, fb->bcode, bound-1, eq);
+                if (d==fl_ctx->NIL || numval(d) != 0) return d;
+                d = bounded_compare(fl_ctx, fa->vals, fb->vals, bound-1, eq);
+                if (d==fl_ctx->NIL || numval(d) != 0) return d;
+                d = bounded_compare(fl_ctx, fa->env, fb->env, bound-1, eq);
+                if (d==fl_ctx->NIL || numval(d) != 0) return d;
                 return fixnum(0);
             }
             return (uintval(a) < uintval(b)) ? fixnum(-1) : fixnum(1);
@@ -115,8 +115,8 @@ static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
         break;
     case TAG_CONS:
         if (tagb < TAG_CONS) return fixnum(1);
-        d = bounded_compare(car_(a), car_(b), bound-1, eq);
-        if (d==NIL || numval(d) != 0) return d;
+        d = bounded_compare(fl_ctx, car_(a), car_(b), bound-1, eq);
+        if (d==fl_ctx->NIL || numval(d) != 0) return d;
         a = cdr_(a); b = cdr_(b);
         bound--;
         goto compare_top;
@@ -124,8 +124,8 @@ static value_t bounded_compare(value_t a, value_t b, int bound, int eq)
     return (taga < tagb) ? fixnum(-1) : fixnum(1);
 }
 
-static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
-                                  int eq)
+static value_t cyc_vector_compare(fl_context_t *fl_ctx, value_t a,
+                                  value_t b, htable_t *table, int eq)
 {
     size_t la = vector_size(a);
     size_t lb = vector_size(b);
@@ -139,8 +139,8 @@ static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
         xa = vector_elt(a,i);
         xb = vector_elt(b,i);
         if (leafp(xa) || leafp(xb)) {
-            d = bounded_compare(xa, xb, 1, eq);
-            if (d!=NIL && numval(d)!=0) return d;
+            d = bounded_compare(fl_ctx, xa, xb, 1, eq);
+            if (d!=fl_ctx->NIL && numval(d)!=0) return d;
         }
         else if (tag(xa) < tag(xb)) {
             return fixnum(-1);
@@ -150,18 +150,18 @@ static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
         }
     }
 
-    ca = eq_class(table, a);
-    cb = eq_class(table, b);
-    if (ca!=NIL && ca==cb)
+    ca = eq_class(fl_ctx, table, a);
+    cb = eq_class(fl_ctx, table, b);
+    if (ca!=fl_ctx->NIL && ca==cb)
         return fixnum(0);
 
-    eq_union(table, a, b, ca, cb);
+    eq_union(fl_ctx, table, a, b, ca, cb);
 
     for (i = 0; i < m; i++) {
         xa = vector_elt(a,i);
         xb = vector_elt(b,i);
         if (!leafp(xa) || tag(xa)==TAG_FUNCTION) {
-            d = cyc_compare(xa, xb, table, eq);
+            d = cyc_compare(fl_ctx, xa, xb, table, eq);
             if (numval(d)!=0)
                 return d;
         }
@@ -172,7 +172,7 @@ static value_t cyc_vector_compare(value_t a, value_t b, htable_t *table,
     return fixnum(0);
 }
 
-static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq)
+static value_t cyc_compare(fl_context_t *fl_ctx, value_t a, value_t b, htable_t *table, int eq)
 {
     value_t d, ca, cb;
  cyc_compare_top:
@@ -185,29 +185,29 @@ static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq)
             int tagaa = tag(aa); int tagda = tag(da);
             int tagab = tag(ab); int tagdb = tag(db);
             if (leafp(aa) || leafp(ab)) {
-                d = bounded_compare(aa, ab, 1, eq);
-                if (d!=NIL && numval(d)!=0) return d;
+                d = bounded_compare(fl_ctx, aa, ab, 1, eq);
+                if (d!=fl_ctx->NIL && numval(d)!=0) return d;
             }
             else if (tagaa < tagab)
                 return fixnum(-1);
             else if (tagaa > tagab)
                 return fixnum(1);
             if (leafp(da) || leafp(db)) {
-                d = bounded_compare(da, db, 1, eq);
-                if (d!=NIL && numval(d)!=0) return d;
+                d = bounded_compare(fl_ctx, da, db, 1, eq);
+                if (d!=fl_ctx->NIL && numval(d)!=0) return d;
             }
             else if (tagda < tagdb)
                 return fixnum(-1);
             else if (tagda > tagdb)
                 return fixnum(1);
 
-            ca = eq_class(table, a);
-            cb = eq_class(table, b);
-            if (ca!=NIL && ca==cb)
+            ca = eq_class(fl_ctx, table, a);
+            cb = eq_class(fl_ctx, table, b);
+            if (ca!=fl_ctx->NIL && ca==cb)
                 return fixnum(0);
 
-            eq_union(table, a, b, ca, cb);
-            d = cyc_compare(aa, ab, table, eq);
+            eq_union(fl_ctx, table, a, b, ca, cb);
+            d = cyc_compare(fl_ctx, aa, ab, table, eq);
             if (numval(d)!=0) return d;
             a = da;
             b = db;
@@ -218,56 +218,55 @@ static value_t cyc_compare(value_t a, value_t b, htable_t *table, int eq)
         }
     }
     else if (isvector(a) && isvector(b)) {
-        return cyc_vector_compare(a, b, table, eq);
+        return cyc_vector_compare(fl_ctx, a, b, table, eq);
     }
     else if (isclosure(a) && isclosure(b)) {
         function_t *fa = (function_t*)ptr(a);
         function_t *fb = (function_t*)ptr(b);
-        d = bounded_compare(fa->bcode, fb->bcode, 1, eq);
+        d = bounded_compare(fl_ctx, fa->bcode, fb->bcode, 1, eq);
         if (numval(d) != 0) return d;
 
-        ca = eq_class(table, a);
-        cb = eq_class(table, b);
-        if (ca!=NIL && ca==cb)
+        ca = eq_class(fl_ctx, table, a);
+        cb = eq_class(fl_ctx, table, b);
+        if (ca!=fl_ctx->NIL && ca==cb)
             return fixnum(0);
 
-        eq_union(table, a, b, ca, cb);
-        d = cyc_compare(fa->vals, fb->vals, table, eq);
+        eq_union(fl_ctx, table, a, b, ca, cb);
+        d = cyc_compare(fl_ctx, fa->vals, fb->vals, table, eq);
         if (numval(d) != 0) return d;
         a = fa->env;
         b = fb->env;
         goto cyc_compare_top;
     }
-    return bounded_compare(a, b, 1, eq);
+    return bounded_compare(fl_ctx, a, b, 1, eq);
 }
 
-static htable_t equal_eq_hashtable;
-void comparehash_init(void)
+void comparehash_init(fl_context_t *fl_ctx)
 {
-    htable_new(&equal_eq_hashtable, 512);
+    htable_new(&fl_ctx->equal_eq_hashtable, 512);
 }
 
 // 'eq' means unordered comparison is sufficient
-static value_t compare_(value_t a, value_t b, int eq)
+static value_t compare_(fl_context_t *fl_ctx, value_t a, value_t b, int eq)
 {
-    value_t guess = bounded_compare(a, b, BOUNDED_COMPARE_BOUND, eq);
-    if (guess == NIL) {
-        guess = cyc_compare(a, b, &equal_eq_hashtable, eq);
-        htable_reset(&equal_eq_hashtable, 512);
+    value_t guess = bounded_compare(fl_ctx, a, b, BOUNDED_COMPARE_BOUND, eq);
+    if (guess == fl_ctx->NIL) {
+        guess = cyc_compare(fl_ctx, a, b, &fl_ctx->equal_eq_hashtable, eq);
+        htable_reset(&fl_ctx->equal_eq_hashtable, 512);
     }
     return guess;
 }
 
-value_t fl_compare(value_t a, value_t b)
+value_t fl_compare(fl_context_t *fl_ctx, value_t a, value_t b)
 {
-    return compare_(a, b, 0);
+    return compare_(fl_ctx, a, b, 0);
 }
 
-value_t fl_equal(value_t a, value_t b)
+value_t fl_equal(fl_context_t *fl_ctx, value_t a, value_t b)
 {
     if (eq_comparable(a, b))
-        return (a == b) ? FL_T : FL_F;
-    return (numval(compare_(a,b,1))==0 ? FL_T : FL_F);
+        return (a == b) ? fl_ctx->T : fl_ctx->F;
+    return (numval(compare_(fl_ctx, a,b,1))==0 ? fl_ctx->T : fl_ctx->F);
 }
 
 /*
@@ -287,7 +286,7 @@ value_t fl_equal(value_t a, value_t b)
 #endif
 
 // *oob: output argument, means we hit the limit specified by 'bound'
-static uptrint_t bounded_hash(value_t a, int bound, int *oob)
+static uintptr_t bounded_hash(fl_context_t *fl_ctx, value_t a, int bound, int *oob)
 {
     *oob = 0;
     union {
@@ -299,7 +298,7 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
     cvalue_t *cv;
     cprim_t *cp;
     void *data;
-    uptrint_t h = 0;
+    uintptr_t h = 0;
     int oob2, tg = tag(a);
     switch(tg) {
     case TAG_NUM :
@@ -308,14 +307,14 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
         return doublehash(u.i64);
     case TAG_FUNCTION:
         if (uintval(a) > N_BUILTINS)
-            return bounded_hash(((function_t*)ptr(a))->bcode, bound, oob);
+            return bounded_hash(fl_ctx, ((function_t*)ptr(a))->bcode, bound, oob);
         return inthash(a);
     case TAG_SYM:
         return ((symbol_t*)ptr(a))->hash;
     case TAG_CPRIM:
         cp = (cprim_t*)ptr(a);
         data = cp_data(cp);
-        if (cp_class(cp) == wchartype)
+        if (cp_class(cp) == fl_ctx->wchartype)
             return inthash(*(int32_t*)data);
         nt = cp_numtype(cp);
         u.d = conv_to_double(data, nt);
@@ -332,7 +331,7 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
         }
         len = vector_size(a);
         for(i=0; i < len; i++) {
-            h = MIX(h, bounded_hash(vector_elt(a,i), bound/2, &oob2)^1);
+            h = MIX(h, bounded_hash(fl_ctx, vector_elt(a,i), bound/2, &oob2)^1);
             if (oob2)
                 bound/=2;
             *oob = *oob || oob2;
@@ -345,7 +344,7 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
                 *oob = 1;
                 return h;
             }
-            h = MIX(h, bounded_hash(car_(a), bound/2, &oob2));
+            h = MIX(h, bounded_hash(fl_ctx, car_(a), bound/2, &oob2));
             // bounds balancing: try to share the bounds efficiently
             // so we can hash better when a list is cdr-deep (a common case)
             if (oob2)
@@ -357,29 +356,29 @@ static uptrint_t bounded_hash(value_t a, int bound, int *oob)
             *oob = *oob || oob2;
             a = cdr_(a);
         } while (iscons(a));
-        h = MIX(h, bounded_hash(a, bound-1, &oob2)^2);
+        h = MIX(h, bounded_hash(fl_ctx, a, bound-1, &oob2)^2);
         *oob = *oob || oob2;
         return h;
     }
     return 0;
 }
 
-int equal_lispvalue(value_t a, value_t b)
+int equal_lispvalue(fl_context_t *fl_ctx, value_t a, value_t b)
 {
     if (eq_comparable(a, b))
         return (a==b);
-    return (numval(compare_(a,b,1))==0);
+    return (numval(compare_(fl_ctx, a, b, 1))==0);
 }
 
-uptrint_t hash_lispvalue(value_t a)
+uintptr_t hash_lispvalue(fl_context_t *fl_ctx, value_t a)
 {
-    int oob=0;
-    uptrint_t n = bounded_hash(a, BOUNDED_HASH_BOUND, &oob);
+    int oob = 0;
+    uintptr_t n = bounded_hash(fl_ctx, a, BOUNDED_HASH_BOUND, &oob);
     return n;
 }
 
-value_t fl_hash(value_t *args, u_int32_t nargs)
+value_t fl_hash(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("hash", nargs, 1);
-    return fixnum(hash_lispvalue(args[0]));
+    argcount(fl_ctx, "hash", nargs, 1);
+    return fixnum(hash_lispvalue(fl_ctx, args[0]));
 }
diff --git a/src/flisp/equalhash.c b/src/flisp/equalhash.c
index 49dc3210c613c..568cc533dc770 100644
--- a/src/flisp/equalhash.c
+++ b/src/flisp/equalhash.c
@@ -10,13 +10,16 @@
 
 #include "htable.inc"
 
-#define _equal_lispvalue_(x,y) equal_lispvalue((value_t)(x),(value_t)(y))
+#define _equal_lispvalue_(x, y, ctx)                                    \
+    equal_lispvalue((fl_context_t*)ctx, (value_t)(x), (value_t)(y))
+#define _hash_lispvalue_(x, ctx)                        \
+    hash_lispvalue((fl_context_t*)ctx, (value_t)(x))
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-HTIMPL(equalhash, hash_lispvalue, _equal_lispvalue_)
+HTIMPL_R(equalhash, _hash_lispvalue_, _equal_lispvalue_)
 
 #ifdef __cplusplus
 }
diff --git a/src/flisp/equalhash.h b/src/flisp/equalhash.h
index 1e52057015963..e4d0379c35f21 100644
--- a/src/flisp/equalhash.h
+++ b/src/flisp/equalhash.h
@@ -7,7 +7,7 @@
 extern "C" {
 #endif
 
-HTPROT(equalhash)
+HTPROT_R(equalhash)
 
 #ifdef __cplusplus
 }
diff --git a/src/flisp/flisp.boot b/src/flisp/flisp.boot
index 5cbccfbedf18b..a94b74ec978ac 100644
--- a/src/flisp/flisp.boot
+++ b/src/flisp/flisp.boot
@@ -59,9 +59,8 @@
   trycatch lambda if and pair? eq? car quote thrown-value cadr caddr raise])  let #fn(">000s1^|C6B0|m62}Mm02}Nm1530]2c0c1L1c2c3|32L1c4}3133c2c5|32g66C0c6g6g7L2L1g6L3540g7g8K;" [#fn(nconc)
   lambda #fn(map) #fn("5000r1|F650|M;|;" [])
   #fn(copy-list) #fn("5000r1|F650|\x84;e040;" [void]) letrec]))
-	  *whitespace* "\t\n\v\f\r \u0085  ᠎           \u2028\u2029  　" 1+
-	  #fn("6000r1|aw;" [] 1+) 1- #fn("6000r1|ax;" [] 1-) 1arg-lambda?
-	  #fn("7000r1|F16T02|Mc0<16J02|NF16B02|\x84F16:02e1|\x84a42;" [lambda
+	  1+ #fn("6000r1|aw;" [] 1+) 1-
+	  #fn("6000r1|ax;" [] 1-) 1arg-lambda? #fn("7000r1|F16T02|Mc0<16J02|NF16B02|\x84F16:02e1|\x84a42;" [lambda
   length=] 1arg-lambda?)
 	  <= #fn("6000r2|}X17602|}W;" [] <=) >
 	  #fn("6000r2}|X;" [] >) >= #fn("6000r2}|X17602|}W;" [] >=)
@@ -129,7 +128,8 @@
   #fn(constant?) #fn(top-level-value) length> 255 compile-in bcode:stack
   compile-arglist emit tcall.l call.l builtin->instruction cadr length= lambda
   inlineable? compile-let compile-builtin-call tcall call] compile-app)
-	  compile-arglist #fn("8000r3e0c1|}q2g2322c2g241;" [for-each #fn("9000r1e0~\x7f^|342e1~a42;" [compile-in
+	  compile-arglist #fn("8000r3c0c1|}q2g2322c2g241;" [#fn(for-each)
+							    #fn("9000r1e0~\x7f^|342e1~a42;" [compile-in
   bcode:stack]) #fn(length)] compile-arglist)
 	  compile-begin #fn("9000r4g3?6?0e0|}g2e13044;g3N?6>0e0|}g2g3M44;e0|}^g3M342e2|c3322e4|}g2g3N44;" [compile-in
   void emit pop compile-begin] compile-begin)
@@ -153,8 +153,8 @@
   compile-in #fn(top-level-value) eof-object loadv in-env? compile-app quote
   self-evaluating? if compile-if begin compile-begin prog1 compile-prog1 lambda
   call-with-values #fn("7000r0e0~\x7f42;" [compile-f-])
-  #fn("9000r2e0~c1|332}\x87K0e2c3~\x7fq2}322e0~c4c5}3143;];" [emit loadv
-							      for-each #fn("9000r1e0~\x7f|^44;" [compile-sym])
+  #fn("9000r2e0~c1|332}\x87K0c2c3~\x7fq2}322e0~c4c5}3143;];" [emit loadv #fn(for-each)
+							      #fn("9000r1e0~\x7f|^44;" [compile-sym])
 							      closure #fn(length)])
   and compile-and or compile-or while compile-while cddr for compile-for caddr
   cadddr return ret set! compile-set! trycatch 1arg-lambda? error "trycatch: second form must be a 1-argument lambda"] compile-in)
@@ -238,9 +238,7 @@
 	  extend-env #fn("8000r3e0}g2`33|K;" [vars-to-env] extend-env) filter
 	  #fn("9000r2]c0|q1m62g6|}_L143;" [#fn("8000r3g2]}F6Q02~}M316?0g2}M_KPNm2530]2}Nm15\x0e/2N;" [] filter-)] filter)
 	  fits-i8 #fn("7000r1|I16F02e0|b\xb03216:02e1|b\xaf42;" [>= <=] fits-i8)
-	  foldl #fn("9000r3g2\x8540};e0||g2M}32g2N43;" [foldl] foldl) for-each
-	  #fn(">000s2]\x8c7g7c0g7q1O2g2\x85I0]}F6@02|}M312}Nm15\x1f/5<0g7M|}g2K322];" [#fn("9000r2}MF6J0|c0c1}32Q22~M|c0c2}3242;];" [#fn(map)
-  #.car #.cdr] for-each-n)] for-each)
+	  foldl #fn("9000r3g2\x8540};e0||g2M}32g2N43;" [foldl] foldl)
 	  get-defined-vars #fn("7000r1e0~M|3141;" [delete-duplicates] [#0=(#fn("8000r1|?640_;|Mc0<16602|NF6d0|\x84C16702|\x84L117S02|\x84F16E02e1|31C16:02e1|31L117402_;|Mc2\x82?0c3c4~M|N32v2;_;" [define
   caadr begin #fn(nconc) #fn(map)] [#0#]))])
 	  identity #fn("5000r1|;" [] identity) in-env?
@@ -323,25 +321,26 @@
 	  nreconc #fn("7000r2e0}|42;" [reverse!-] nreconc) odd?
 	  #fn("6000r1e0|31@;" [even?] odd?) positive? #fn("7000r1e0|`42;" [>] positive?)
 	  princ #fn(";000s0e0^k02c1g5q1c2|q1c3g6q1tg6302;" [*print-readably* #fn("5000r0~k0;" [*print-readably*])
-							    #fn("7000r0e0c1~42;" [for-each
+							    #fn("7000r0c0c1~42;" [#fn(for-each)
   #fn(write)]) #fn("6000r1~302c0|41;" [#fn(raise)])] princ)
-	  print #fn("9000s0e0c1|42;" [for-each #fn(write)] print)
+	  print #fn("9000s0c0c1|42;" [#fn(for-each)
+				      #fn(write)] print)
 	  print-exception #fn("=000r1|F16D02|Mc0<16:02e1|b4326P0e2c3|\x84c4e5|31c6352e7e8|31315!0|F16D02|Mc9<16:02e1|b4326N0e2|\x84c:e8|31c;342e7e5|31315\xea0|F16@02|Mc<<16602|NF6?0e2c=|\x84c>335\xc60|F16802|Mc?<6B0e2c@312e2|NQ25\xa70|F16802|McA<6G0eBe5|31312e2cC|\x84325\x830eD|3116:02e1|b2326c0e7|M312e2cE312|\x84cFg53117602g5C670e2540e7g531\x8e15>0e2cG312e7|312e2eH41;" [type-error
   length= princ "type error: " ": expected " caddr ", got " print cadddr
   bounds-error ": index " " out of bounds for " unbound-error "eval: variable "
   " has no value" error "error: " load-error print-exception "in file " list?
   ": " #fn(string?) "*** Unhandled exception: " *linefeed*] print-exception)
-	  print-stack-trace #fn("?000r1]]\x8c5\x8c6g5c0g5q1O2g6c1g5q1O2e2e3|e4670b5540b43231e5e6c7c8c9303232`\x8c9e:c;g9g6g8q3g742;" [#fn("=000r3c0|31g2Kc1|31c1}31\x82?0c2c3c4g7L341;c5|31`e6c7g83131c8g8~}g7q4u;" [#fn(function:name)
+	  print-stack-trace #fn("?000r1]]\x8c5\x8c6g5c0g5q1O2g6c1g5q1O2e2e3|e4670b5540b43231e5e6c7c8c9303232`\x8c9c:c;g9g6g8q3g742;" [#fn("=000r3c0|31g2Kc1|31c1}31\x82?0c2c3c4g7L341;c5|31`e6c7g83131c8g8~}g7q4u;" [#fn(function:name)
   #fn(function:code) #fn(raise) thrown-value ffound #fn(function:vals) 1- #fn(length)
   #fn("8000r1e0~|[316>0\x7fM~|[i2i343;];" [closure?])] find-in-f)
-  #fn(";000r2c0~|}q3c1tg66I0c2e3c4c5e6g63132c73241;c8;" [#fn("8000r0e0c1~\x7fq2i2322^;" [for-each
+  #fn(";000r2c0~|}q3c1tg66I0c2e3c4c5e6g63132c73241;c8;" [#fn("8000r0c0c1~\x7fq2i2322^;" [#fn(for-each)
   #fn("8000r1~M|\x7f_43;" [])]) #fn("6000r1|F16B02|Mc0<16802|\x84c1<680e2|41;c3|41;" [thrown-value
   ffound caddr #fn(raise)]) #fn(symbol) string.join #fn(map)
 							 #fn(string) reverse!
 							 "/" lambda] fn-name)
   reverse! list-tail *interactive* filter closure? #fn(map)
   #fn("6000r1|E16802c0|41;" [#fn(top-level-value)])
-  #fn(environment) for-each #fn("8000r1e0c1~Mc2332e3\x7fM|`[i232e4|31NK312e5302~~MawO;" [princ
+  #fn(environment) #fn(for-each) #fn("8000r1e0c1~Mc2332e3\x7fM|`[i232e4|31NK312e5302~~MawO;" [princ
   "#" " " print vector->list newline])] print-stack-trace)
 	  print-to-string #fn("8000r1c030c1|g5322c2g541;" [#fn(buffer)
 							   #fn(write)
@@ -371,8 +370,9 @@
 	  simple-sort #fn("9000r1|A17602|NA640|;|Me0c1g5|q2c2g5q142;" [call-with-values
   #fn("7000r0e0c1~q1\x7fN42;" [separate #fn("6000r1|~X;" [])])
   #fn("9000r2c0e1|31~L1e1}3143;" [#fn(nconc) simple-sort])] simple-sort)
-	  string.join #fn("9000r2|\x8550c0;c130c2g6|M322e3c4g6}q2|N322c5g641;" [""
-  #fn(buffer) #fn(io.write) for-each #fn("7000r1c0~\x7f322c0~|42;" [#fn(io.write)])
+	  string.join #fn("9000r2|\x8550c0;c130c2g6|M322c3c4g6}q2|N322c5g641;" [""
+  #fn(buffer) #fn(io.write) #fn(for-each)
+  #fn("7000r1c0~\x7f322c0~|42;" [#fn(io.write)])
   #fn(io.tostring!)] string.join)
 	  string.map #fn("=000r2c030c1}31`]g8g7X6P02c2g6|c3}g83231322c4}g832m85\x0c/\x8e12c5g641;" [#fn(buffer)
   #fn(length) #fn(io.putc) #fn(string.char)
diff --git a/src/flisp/flisp.c b/src/flisp/flisp.c
index e56d7104d649f..f63e60838bf2f 100644
--- a/src/flisp/flisp.c
+++ b/src/flisp/flisp.c
@@ -54,12 +54,12 @@ extern "C" {
 
 #if defined(_OS_WINDOWS_) && !defined(_COMPILER_MINGW_)
 #include <malloc.h>
-DLLEXPORT char * dirname(char *);
+JL_DLLEXPORT char * dirname(char *);
 #else
 #include <libgen.h>
 #endif
 
-static char *builtin_names[] =
+static char *const builtin_names[] =
     { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
       NULL, NULL, NULL, NULL,
       // predicates
@@ -82,7 +82,7 @@ static char *builtin_names[] =
 
 #define ANYARGS -10000
 
-static short builtin_arg_counts[] =
+static const short builtin_arg_counts[] =
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       2, ANYARGS, 1, 1, 2, 2,
@@ -90,37 +90,13 @@ static short builtin_arg_counts[] =
       ANYARGS, -1, ANYARGS, -1, 2,  2, 2, 2,
       ANYARGS, 2, 3 };
 
-static uint32_t N_STACK;
-static value_t *Stack;
-static uint32_t SP = 0;
-static uint32_t curr_frame = 0;
-#define PUSH(v) (Stack[SP++] = (v))
-#define POP()   (Stack[--SP])
-#define POPN(n) (SP-=(n))
-
-#define N_GC_HANDLES 8192
-static value_t *GCHandleStack[N_GC_HANDLES];
-static uint32_t N_GCHND = 0;
-
-value_t FL_NIL, FL_T, FL_F, FL_EOF, QUOTE;
-value_t IOError, ParseError, TypeError, ArgError, UnboundError, OutOfMemoryError;
-value_t DivideError, BoundsError, Error, KeyError, EnumerationError;
-value_t printwidthsym, printreadablysym, printprettysym, printlengthsym;
-value_t printlevelsym, builtins_table_sym;
-
-static value_t NIL, LAMBDA, IF, TRYCATCH;
-static value_t BACKQUOTE, COMMA, COMMAAT, COMMADOT, FUNCTION;
-
-static value_t pairsym, symbolsym, fixnumsym, vectorsym, builtinsym, vu8sym;
-static value_t definesym, defmacrosym, forsym, setqsym;
-static value_t tsym, Tsym, fsym, Fsym, booleansym, nullsym, evalsym, fnsym;
-// for reading characters
-static value_t nulsym, alarmsym, backspacesym, tabsym, linefeedsym, newlinesym;
-static value_t vtabsym, pagesym, returnsym, escsym, spacesym, deletesym;
-
-static value_t apply_cl(uint32_t nargs);
-static value_t *alloc_words(int n);
-static value_t relocate(value_t v);
+#define PUSH(fl_ctx, v) (fl_ctx->Stack[fl_ctx->SP++] = (v))
+#define POP(fl_ctx)   (fl_ctx->Stack[--fl_ctx->SP])
+#define POPN(fl_ctx, n) (fl_ctx->SP-=(n))
+
+static value_t apply_cl(fl_context_t *fl_ctx, uint32_t nargs);
+static value_t *alloc_words(fl_context_t *fl_ctx, int n);
+static value_t relocate(fl_context_t *fl_ctx, value_t v);
 
 typedef struct _fl_readstate_t {
     htable_t backrefs;
@@ -129,145 +105,128 @@ typedef struct _fl_readstate_t {
     struct _fl_readstate_t *prev;
 } fl_readstate_t;
 
-static fl_readstate_t *readstate = NULL;
-
 static void free_readstate(fl_readstate_t *rs)
 {
     htable_free(&rs->backrefs);
     htable_free(&rs->gensyms);
 }
 
-static unsigned char *fromspace;
-static unsigned char *tospace;
-static unsigned char *curheap;
-static unsigned char *lim;
-static uint32_t heapsize;//bytes
-static uint32_t *consflags;
-
 // error utilities ------------------------------------------------------------
 
-// saved execution state for an unwind target
-fl_exception_context_t *fl_ctx = NULL;
-uint32_t fl_throwing_frame=0;  // active frame when exception was thrown
-value_t fl_lasterror;
-
-#define FL_TRY \
+#define FL_TRY(fl_ctx)                           \
   fl_exception_context_t _ctx; int l__tr, l__ca; \
-  _ctx.sp=SP; _ctx.frame=curr_frame; _ctx.rdst=readstate; _ctx.prev=fl_ctx; \
-  _ctx.ngchnd = N_GCHND; fl_ctx = &_ctx;                                    \
+  _ctx.sp=fl_ctx->SP; _ctx.frame=fl_ctx->curr_frame; _ctx.rdst=fl_ctx->readstate; _ctx.prev=fl_ctx->exc_ctx; \
+  _ctx.ngchnd = fl_ctx->N_GCHND; fl_ctx->exc_ctx = &_ctx;                                    \
   if (!setjmp(_ctx.buf)) \
-    for (l__tr=1; l__tr; l__tr=0, (void)(fl_ctx=fl_ctx->prev))
+    for (l__tr=1; l__tr; l__tr=0, (void)(fl_ctx->exc_ctx=fl_ctx->exc_ctx->prev))
 
-#define FL_CATCH \
-  else \
-    for(l__ca=1; l__ca; l__ca=0, \
-      fl_lasterror=FL_NIL,fl_throwing_frame=0,SP=_ctx.sp,curr_frame=_ctx.frame)
+#define FL_CATCH(fl_ctx)                                                \
+    else                                                                \
+        for(l__ca=1; l__ca; l__ca=0,                                    \
+                fl_ctx->lasterror=fl_ctx->NIL,fl_ctx->throwing_frame=0,fl_ctx->SP=_ctx.sp,fl_ctx->curr_frame=_ctx.frame)
 
-void fl_savestate(fl_exception_context_t *_ctx)
+void fl_savestate(fl_context_t *fl_ctx, fl_exception_context_t *_ctx)
 {
-    _ctx->sp = SP;
-    _ctx->frame = curr_frame;
-    _ctx->rdst = readstate;
-    _ctx->prev = fl_ctx;
-    _ctx->ngchnd = N_GCHND;
+    _ctx->sp = fl_ctx->SP;
+    _ctx->frame = fl_ctx->curr_frame;
+    _ctx->rdst = fl_ctx->readstate;
+    _ctx->prev = fl_ctx->exc_ctx;
+    _ctx->ngchnd = fl_ctx->N_GCHND;
 }
 
-void fl_restorestate(fl_exception_context_t *_ctx)
+void fl_restorestate(fl_context_t *fl_ctx, fl_exception_context_t *_ctx)
 {
-    fl_lasterror = FL_NIL;
-    fl_throwing_frame = 0;
-    SP = _ctx->sp;
-    curr_frame = _ctx->frame;
+    fl_ctx->lasterror = fl_ctx->NIL;
+    fl_ctx->throwing_frame = 0;
+    fl_ctx->SP = _ctx->sp;
+    fl_ctx->curr_frame = _ctx->frame;
 }
 
-void fl_raise(value_t e)
+void fl_raise(fl_context_t *fl_ctx, value_t e)
 {
-    fl_lasterror = e;
+    fl_ctx->lasterror = e;
     // unwind read state
-    while (readstate != (fl_readstate_t*)fl_ctx->rdst) {
-        free_readstate(readstate);
-        readstate = readstate->prev;
+    while (fl_ctx->readstate != (fl_readstate_t*)fl_ctx->exc_ctx->rdst) {
+        free_readstate(fl_ctx->readstate);
+        fl_ctx->readstate = fl_ctx->readstate->prev;
     }
-    if (fl_throwing_frame == 0)
-        fl_throwing_frame = curr_frame;
-    N_GCHND = fl_ctx->ngchnd;
-    fl_exception_context_t *thisctx = fl_ctx;
-    if (fl_ctx->prev)   // don't throw past toplevel
-        fl_ctx = fl_ctx->prev;
+    if (fl_ctx->throwing_frame == 0)
+        fl_ctx->throwing_frame = fl_ctx->curr_frame;
+    fl_ctx->N_GCHND = fl_ctx->exc_ctx->ngchnd;
+    fl_exception_context_t *thisctx = fl_ctx->exc_ctx;
+    if (fl_ctx->exc_ctx->prev)   // don't throw past toplevel
+        fl_ctx->exc_ctx = fl_ctx->exc_ctx->prev;
     longjmp(thisctx->buf, 1);
 }
 
-static value_t make_error_msg(char *format, va_list args)
+static value_t make_error_msg(fl_context_t *fl_ctx, char *format, va_list args)
 {
     char msgbuf[512];
     vsnprintf(msgbuf, sizeof(msgbuf), format, args);
-    return string_from_cstr(msgbuf);
+    return string_from_cstr(fl_ctx, msgbuf);
 }
 
-void lerrorf(value_t e, char *format, ...)
+void lerrorf(fl_context_t *fl_ctx, value_t e, char *format, ...)
 {
     va_list args;
-    PUSH(e);
+    PUSH(fl_ctx, e);
     va_start(args, format);
-    value_t msg = make_error_msg(format, args);
+    value_t msg = make_error_msg(fl_ctx, format, args);
     va_end(args);
 
-    e = POP();
-    fl_raise(fl_list2(e, msg));
+    e = POP(fl_ctx);
+    fl_raise(fl_ctx, fl_list2(fl_ctx, e, msg));
 }
 
-void lerror(value_t e, const char *msg)
+void lerror(fl_context_t *fl_ctx, value_t e, const char *msg)
 {
-    PUSH(e);
-    value_t m = cvalue_static_cstring(msg);
-    e = POP();
-    fl_raise(fl_list2(e, m));
+    PUSH(fl_ctx, e);
+    value_t m = cvalue_static_cstring(fl_ctx, msg);
+    e = POP(fl_ctx);
+    fl_raise(fl_ctx, fl_list2(fl_ctx, e, m));
 }
 
-void type_error(char *fname, char *expected, value_t got)
+void type_error(fl_context_t *fl_ctx, char *fname, char *expected, value_t got)
 {
-    fl_raise(fl_listn(4, TypeError, symbol(fname), symbol(expected), got));
+    fl_raise(fl_ctx, fl_listn(fl_ctx, 4, fl_ctx->TypeError, symbol(fl_ctx, fname), symbol(fl_ctx, expected), got));
 }
 
-void bounds_error(char *fname, value_t arr, value_t ind)
+void bounds_error(fl_context_t *fl_ctx, char *fname, value_t arr, value_t ind)
 {
-    fl_raise(fl_listn(4, BoundsError, symbol(fname), arr, ind));
+    fl_raise(fl_ctx, fl_listn(fl_ctx, 4, fl_ctx->BoundsError, symbol(fl_ctx, fname), arr, ind));
 }
 
 // safe cast operators --------------------------------------------------------
 
-#define isstring fl_isstring
-#define SAFECAST_OP(type,ctype,cnvt)                                          \
-ctype to##type(value_t v, char *fname)                                        \
-{                                                                             \
-    if (is##type(v))                                                          \
-        return (ctype)cnvt(v);                                                \
-    type_error(fname, #type, v);                                              \
-}
+#define isstring(v) fl_isstring(fl_ctx, v)
+#define SAFECAST_OP(type,ctype,cnvt)                                    \
+    ctype to##type(fl_context_t *fl_ctx, value_t v, char *fname)        \
+    {                                                                   \
+        if (is##type(v))                                                \
+            return (ctype)cnvt(v);                                      \
+        type_error(fl_ctx, fname, #type, v);                            \
+    }
 SAFECAST_OP(cons,  cons_t*,  ptr)
 SAFECAST_OP(symbol,symbol_t*,ptr)
 SAFECAST_OP(fixnum,fixnum_t, numval)
-SAFECAST_OP(cvalue,cvalue_t*,ptr)
 SAFECAST_OP(string,char*,    cvalue_data)
 #undef isstring
 
 // symbol table ---------------------------------------------------------------
 
-symbol_t *symtab = NULL;
-
 int fl_is_keyword_name(const char *str, size_t len)
 {
     return len>1 && ((str[0] == ':' || str[len-1] == ':') && str[1] != '\0');
 }
 
-#define CHECK_ALIGN8(p) assert((((uptrint_t)(p))&0x7)==0 && "flisp requires malloc to return 8-aligned pointers")
+#define CHECK_ALIGN8(p) assert((((uintptr_t)(p))&0x7)==0 && "flisp requires malloc to return 8-aligned pointers")
 
 static symbol_t *mk_symbol(const char *str)
 {
     symbol_t *sym;
     size_t len = strlen(str);
 
-    sym = (symbol_t*)malloc((sizeof(symbol_t)-sizeof(void*)+len+1+7)&-8);
+    sym = (symbol_t*)malloc((offsetof(symbol_t,name)+len+1+7)&-8);
     CHECK_ALIGN8(sym);
     sym->left = sym->right = NULL;
     sym->flags = 0;
@@ -302,31 +261,26 @@ static symbol_t **symtab_lookup(symbol_t **ptree, const char *str)
     return ptree;
 }
 
-value_t symbol(char *str)
+value_t symbol(fl_context_t *fl_ctx, char *str)
 {
-    symbol_t **pnode = symtab_lookup(&symtab, str);
+    symbol_t **pnode = symtab_lookup(&fl_ctx->symtab, str);
     if (*pnode == NULL)
         *pnode = mk_symbol(str);
     return tagptr(*pnode, TAG_SYM);
 }
 
-static uint32_t _gensym_ctr=0;
-// two static buffers for gensym printing so there can be two
-// gensym names available at a time, mostly for compare()
-static char gsname[2][16];
-static int gsnameno=0;
-value_t fl_gensym(value_t *args, uint32_t nargs)
+value_t fl_gensym(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
 #ifdef MEMDEBUG2
-    gsnameno = 1-gsnameno;
-    char *n = uint2str(gsname[gsnameno]+1, sizeof(gsname[0])-1, _gensym_ctr++, 10);
+    fl_ctx->gsnameno = 1-fl_ctx->gsnameno;
+    char *n = uint2str(fl_ctx->gsname[fl_ctx->gsnameno]+1, sizeof(fl_ctx->gsname[0])-1, fl_ctx->gensym_ctr++, 10);
     *(--n) = 'g';
     return tagptr(mk_symbol(n), TAG_SYM);
 #else
-    argcount("gensym", nargs, 0);
+    argcount(fl_ctx, "gensym", nargs, 0);
     (void)args;
-    gensym_t *gs = (gensym_t*)alloc_words(sizeof(gensym_t)/sizeof(void*));
-    gs->id = _gensym_ctr++;
+    gensym_t *gs = (gensym_t*)alloc_words(fl_ctx, sizeof(gensym_t)/sizeof(void*));
+    gs->id = fl_ctx->gensym_ctr++;
     gs->binding = UNBOUND;
     gs->isconst = 0;
     gs->type = NULL;
@@ -334,27 +288,29 @@ value_t fl_gensym(value_t *args, uint32_t nargs)
 #endif
 }
 
-int fl_isgensym(value_t v)
+int fl_isgensym(fl_context_t *fl_ctx, value_t v)
 {
-    return isgensym(v);
+    return isgensym(fl_ctx, v);
 }
 
-static value_t fl_gensymp(value_t *args, u_int32_t nargs)
+static value_t fl_gensymp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("gensym?", nargs, 1);
-    return isgensym(args[0]) ? FL_T : FL_F;
+    argcount(fl_ctx, "gensym?", nargs, 1);
+    return isgensym(fl_ctx, args[0]) ? fl_ctx->T : fl_ctx->F;
 }
 
-char *symbol_name(value_t v)
+char *symbol_name(fl_context_t *fl_ctx, value_t v)
 {
 #ifndef MEMDEBUG2
-    if (ismanaged(v)) {
+    if (ismanaged(fl_ctx, v)) {
         gensym_t *gs = (gensym_t*)ptr(v);
-        gsnameno = 1-gsnameno;
-        char *n = uint2str(gsname[gsnameno]+1, sizeof(gsname[0])-1, gs->id, 10);
+        fl_ctx->gsnameno = 1-fl_ctx->gsnameno;
+        char *n = uint2str(fl_ctx->gsname[fl_ctx->gsnameno]+1, sizeof(fl_ctx->gsname[0])-1, gs->id, 10);
         *(--n) = 'g';
         return n;
     }
+#else
+    (void)fl_ctx;
 #endif
     return ((symbol_t*)ptr(v))->name;
 }
@@ -362,92 +318,88 @@ char *symbol_name(value_t v)
 // conses ---------------------------------------------------------------------
 
 #ifdef MEMDEBUG2
-static void *tochain=NULL;
-static long long n_allocd=0;
 #define GC_INTERVAL 100000
 #endif
 
-void gc(int mustgrow);
+void gc(fl_context_t *fl_ctx, int mustgrow);
 
-static value_t mk_cons(void)
+static value_t mk_cons(fl_context_t *fl_ctx)
 {
     cons_t *c;
 
 #ifdef MEMDEBUG2
-    if (n_allocd > GC_INTERVAL)
-        gc(0);
+    if (fl_ctx->n_allocd > GC_INTERVAL)
+        gc(fl_ctx, 0);
     c = (cons_t*)((void**)malloc(3*sizeof(void*)) + 1);
     CHECK_ALIGN8(c);
-    ((void**)c)[-1] = tochain;
-    tochain = c;
-    n_allocd += sizeof(cons_t);
+    ((void**)c)[-1] = fl_ctx->tochain;
+    fl_ctx->tochain = c;
+    fl_ctx->n_allocd += sizeof(cons_t);
 #else
-    if (__unlikely(curheap > lim))
-        gc(0);
-    c = (cons_t*)curheap;
-    curheap += sizeof(cons_t);
+    if (__unlikely(fl_ctx->curheap > fl_ctx->lim))
+        gc(fl_ctx, 0);
+    c = (cons_t*)fl_ctx->curheap;
+    fl_ctx->curheap += sizeof(cons_t);
 #endif
     return tagptr(c, TAG_CONS);
 }
 
-static value_t *alloc_words(int n)
+static value_t *alloc_words(fl_context_t *fl_ctx, int n)
 {
     value_t *first;
 
     assert(n > 0);
     n = LLT_ALIGN(n, 2);   // only allocate multiples of 2 words
 #ifdef MEMDEBUG2
-    if (n_allocd > GC_INTERVAL)
-        gc(0);
+    if (fl_ctx->n_allocd > GC_INTERVAL)
+        gc(fl_ctx, 0);
     first = (value_t*)malloc((n+1)*sizeof(value_t)) + 1;
     CHECK_ALIGN8(first);
-    first[-1] = (value_t)tochain;
-    tochain = first;
-    n_allocd += (n*sizeof(value_t));
+    first[-1] = (value_t)fl_ctx->tochain;
+    fl_ctx->tochain = first;
+    fl_ctx->n_allocd += (n*sizeof(value_t));
 #else
-    if (__unlikely((value_t*)curheap > ((value_t*)lim)+2-n)) {
-        gc(0);
-        while ((value_t*)curheap > ((value_t*)lim)+2-n) {
-            gc(1);
+    if (__unlikely((value_t*)fl_ctx->curheap > ((value_t*)fl_ctx->lim)+2-n)) {
+        gc(fl_ctx, 0);
+        while ((value_t*)fl_ctx->curheap > ((value_t*)fl_ctx->lim)+2-n) {
+            gc(fl_ctx, 1);
         }
     }
-    first = (value_t*)curheap;
-    curheap += (n*sizeof(value_t));
+    first = (value_t*)fl_ctx->curheap;
+    fl_ctx->curheap += (n*sizeof(value_t));
 #endif
     return first;
 }
 
 // allocate n consecutive conses
 #ifndef MEMDEBUG2
-#define cons_reserve(n) tagptr(alloc_words((n)*2), TAG_CONS)
+#define cons_reserve(fl_ctx, n) tagptr(alloc_words(fl_ctx, (n)*2), TAG_CONS)
 #endif
 
 #ifndef MEMDEBUG2
-#define cons_index(c)  (((cons_t*)ptr(c))-((cons_t*)fromspace))
+#define cons_index(fl_ctx, c)  (((cons_t*)ptr(c))-((cons_t*)fl_ctx->fromspace))
 #endif
 
 #ifdef MEMDEBUG2
-#define ismarked(c)    ((((value_t*)ptr(c))[-1]&1) != 0)
-#define mark_cons(c)   ((((value_t*)ptr(c))[-1]) |= 1)
-#define unmark_cons(c) ((((value_t*)ptr(c))[-1]) &= (~(value_t)1))
+#define ismarked(fl_ctx, c)    ((((value_t*)ptr(c))[-1]&1) != 0)
+#define mark_cons(fl_ctx, c)   ((((value_t*)ptr(c))[-1]) |= 1)
+#define unmark_cons(fl_ctx, c) ((((value_t*)ptr(c))[-1]) &= (~(value_t)1))
 #else
-#define ismarked(c)    bitvector_get(consflags, cons_index(c))
-#define mark_cons(c)   bitvector_set(consflags, cons_index(c), 1)
-#define unmark_cons(c) bitvector_set(consflags, cons_index(c), 0)
+#define ismarked(fl_ctx, c)    bitvector_get(fl_ctx->consflags, cons_index(fl_ctx, c))
+#define mark_cons(fl_ctx, c)   bitvector_set(fl_ctx->consflags, cons_index(fl_ctx, c), 1)
+#define unmark_cons(fl_ctx, c) bitvector_set(fl_ctx->consflags, cons_index(fl_ctx, c), 0)
 #endif
 
-static value_t the_empty_vector;
-
-value_t alloc_vector(size_t n, int init)
+value_t alloc_vector(fl_context_t *fl_ctx, size_t n, int init)
 {
-    if (n == 0) return the_empty_vector;
-    value_t *c = alloc_words(n+1);
+    if (n == 0) return fl_ctx->the_empty_vector;
+    value_t *c = alloc_words(fl_ctx, n+1);
     value_t v = tagptr(c, TAG_VECTOR);
     vector_setsize(v, n);
     if (init) {
         unsigned int i;
         for(i=0; i < n; i++)
-            vector_elt(v, i) = FL_UNSPECIFIED;
+            vector_elt(v, i) = FL_UNSPECIFIED(fl_ctx);
     }
     return v;
 }
@@ -459,30 +411,45 @@ value_t alloc_vector(size_t n, int init)
 
 // print ----------------------------------------------------------------------
 
-static int isnumtok(char *tok, value_t *pval);
+static int isnumtok(fl_context_t *fl_ctx, char *tok, value_t *pval);
 static inline int symchar(char c);
 
 #include "print.c"
 
 // collector ------------------------------------------------------------------
 
-void fl_gc_handle(value_t *pv)
+void fl_gc_handle(fl_context_t *fl_ctx, value_t *pv)
 {
-    if (N_GCHND >= N_GC_HANDLES)
-        lerror(OutOfMemoryError, "out of gc handles");
-    GCHandleStack[N_GCHND++] = pv;
+    if (fl_ctx->N_GCHND >= FL_N_GC_HANDLES)
+        lerror(fl_ctx, fl_ctx->OutOfMemoryError, "out of gc handles");
+    fl_ctx->GCHandleStack[fl_ctx->N_GCHND++] = pv;
 }
 
-void fl_free_gc_handles(uint32_t n)
+void fl_free_gc_handles(fl_context_t *fl_ctx, uint32_t n)
 {
-    assert(N_GCHND >= n);
-    N_GCHND -= n;
+    assert(fl_ctx->N_GCHND >= n);
+    fl_ctx->N_GCHND -= n;
 }
 
-static value_t relocate(value_t v)
+value_t relocate_lispvalue(fl_context_t *fl_ctx, value_t v)
+{
+    return relocate(fl_ctx, v);
+}
+
+static void trace_globals(fl_context_t *fl_ctx, symbol_t *root)
+{
+    while (root != NULL) {
+        if (root->binding != UNBOUND)
+            root->binding = relocate(fl_ctx, root->binding);
+        trace_globals(fl_ctx, root->left);
+        root = root->right;
+    }
+}
+
+static value_t relocate(fl_context_t *fl_ctx, value_t v)
 {
     value_t a, d, nc, first, *pcdr;
-    uptrint_t t = tag(v);
+    uintptr_t t = tag(v);
 
     if (t == TAG_CONS) {
         // iterative implementation allows arbitrarily long cons chains
@@ -493,25 +460,25 @@ static value_t relocate(value_t v)
                 return first;
             }
 #ifdef MEMDEBUG2
-            *pcdr = nc = mk_cons();
+            *pcdr = nc = mk_cons(fl_ctx);
 #else
-            *pcdr = nc = tagptr((cons_t*)curheap, TAG_CONS);
-            curheap += sizeof(cons_t);
+            *pcdr = nc = tagptr((cons_t*)fl_ctx->curheap, TAG_CONS);
+            fl_ctx->curheap += sizeof(cons_t);
 #endif
             d = cdr_(v);
             car_(v) = TAG_FWD; cdr_(v) = nc;
-            if ((tag(a)&3) == 0 || !ismanaged(a))
+            if ((tag(a)&3) == 0 || !ismanaged(fl_ctx, a))
                 car_(nc) = a;
             else
-                car_(nc) = relocate(a);
+                car_(nc) = relocate(fl_ctx, a);
             pcdr = &cdr_(nc);
             v = d;
         } while (iscons(v));
-        *pcdr = (d==NIL) ? NIL : relocate(d);
+        *pcdr = (d==fl_ctx->NIL) ? fl_ctx->NIL : relocate(fl_ctx, d);
         return first;
     }
 
-    if ((t&3) == 0 || !ismanaged(v)) return v;
+    if ((t&3) == 0 || !ismanaged(fl_ctx, v)) return v;
     if (isforwarded(v)) return forwardloc(v);
 
     if (t == TAG_VECTOR) {
@@ -519,22 +486,22 @@ static value_t relocate(value_t v)
         size_t i, sz = vector_size(v);
         if (vector_elt(v,-1) & 0x1) {
             // grown vector
-            nc = relocate(vector_elt(v,0));
+            nc = relocate(fl_ctx, vector_elt(v,0));
             forward(v, nc);
         }
         else {
-            nc = tagptr(alloc_words(sz+1), TAG_VECTOR);
+            nc = tagptr(alloc_words(fl_ctx, sz+1), TAG_VECTOR);
             vector_setsize(nc, sz);
             a = vector_elt(v,0);
             forward(v, nc);
             if (sz > 0) {
-                vector_elt(nc,0) = relocate(a);
+                vector_elt(nc,0) = relocate(fl_ctx, a);
                 for(i=1; i < sz; i++) {
                     a = vector_elt(v,i);
-                    if ((tag(a)&3) == 0 || !ismanaged(a))
+                    if ((tag(a)&3) == 0 || !ismanaged(fl_ctx, a))
                         vector_elt(nc,i) = a;
                     else
-                        vector_elt(nc,i) = relocate(a);
+                        vector_elt(nc,i) = relocate(fl_ctx, a);
                 }
             }
         }
@@ -543,7 +510,7 @@ static value_t relocate(value_t v)
     else if (t == TAG_CPRIM) {
         cprim_t *pcp = (cprim_t*)ptr(v);
         size_t nw = CPRIM_NWORDS-1+NWORDS(cp_class(pcp)->size);
-        cprim_t *ncp = (cprim_t*)alloc_words(nw);
+        cprim_t *ncp = (cprim_t*)alloc_words(fl_ctx, nw);
         while (nw--)
             ((value_t*)ncp)[nw] = ((value_t*)pcp)[nw];
         nc = tagptr(ncp, TAG_CPRIM);
@@ -551,105 +518,87 @@ static value_t relocate(value_t v)
         return nc;
     }
     else if (t == TAG_CVALUE) {
-        return cvalue_relocate(v);
+        return cvalue_relocate(fl_ctx, v);
     }
     else if (t == TAG_FUNCTION) {
         function_t *fn = (function_t*)ptr(v);
-        function_t *nfn = (function_t*)alloc_words(4);
+        function_t *nfn = (function_t*)alloc_words(fl_ctx, 4);
         nfn->bcode = fn->bcode;
         nfn->vals = fn->vals;
         nc = tagptr(nfn, TAG_FUNCTION);
         forward(v, nc);
-        nfn->env = relocate(fn->env);
-        nfn->vals = relocate(nfn->vals);
-        nfn->bcode = relocate(nfn->bcode);
+        nfn->env = relocate(fl_ctx, fn->env);
+        nfn->vals = relocate(fl_ctx, nfn->vals);
+        nfn->bcode = relocate(fl_ctx, nfn->bcode);
         nfn->name = fn->name;
         return nc;
     }
     else if (t == TAG_SYM) {
         gensym_t *gs = (gensym_t*)ptr(v);
-        gensym_t *ng = (gensym_t*)alloc_words(sizeof(gensym_t)/sizeof(void*));
+        gensym_t *ng = (gensym_t*)alloc_words(fl_ctx, sizeof(gensym_t)/sizeof(void*));
         ng->id = gs->id;
         ng->binding = gs->binding;
         ng->isconst = 0;
         nc = tagptr(ng, TAG_SYM);
         forward(v, nc);
         if (ng->binding != UNBOUND)
-            ng->binding = relocate(ng->binding);
+            ng->binding = relocate(fl_ctx, ng->binding);
         return nc;
     }
     return v;
 }
 
-value_t relocate_lispvalue(value_t v)
-{
-    return relocate(v);
-}
-
-static void trace_globals(symbol_t *root)
-{
-    while (root != NULL) {
-        if (root->binding != UNBOUND)
-            root->binding = relocate(root->binding);
-        trace_globals(root->left);
-        root = root->right;
-    }
-}
-
-static value_t memory_exception_value;
-
-void gc(int mustgrow)
+void gc(fl_context_t *fl_ctx, int mustgrow)
 {
     void *temp;
     uint32_t i, f, top;
     fl_readstate_t *rs;
 #ifdef MEMDEBUG2
-    temp = tochain;
-    tochain = NULL;
-    n_allocd = -100000000000LL;
+    temp = fl_ctx->tochain;
+    fl_ctx->tochain = NULL;
+    fl_ctx->n_allocd = -100000000000LL;
 #else
-    static int grew = 0;
-    size_t hsz = grew ? heapsize*2 : heapsize;
+    size_t hsz = fl_ctx->gc_grew ? fl_ctx->heapsize*2 : fl_ctx->heapsize;
 #ifdef MEMDEBUG
-    tospace = LLT_ALLOC(hsz);
+    fl_ctx->tospace = LLT_ALLOC(hsz);
 #endif
-    curheap = tospace;
-    lim = curheap + hsz - sizeof(cons_t);
+    fl_ctx->curheap = fl_ctx->tospace;
+    fl_ctx->lim = fl_ctx->curheap + hsz - sizeof(cons_t);
 #endif
 
-    if (fl_throwing_frame > curr_frame) {
-        top = fl_throwing_frame - 3;
-        f = Stack[fl_throwing_frame-3];
+    if (fl_ctx->throwing_frame > fl_ctx->curr_frame) {
+        top = fl_ctx->throwing_frame - 3;
+        f = fl_ctx->Stack[fl_ctx->throwing_frame-3];
     }
     else {
-        top = SP;
-        f = curr_frame;
+        top = fl_ctx->SP;
+        f = fl_ctx->curr_frame;
     }
     while (1) {
         for (i=f; i < top; i++)
-            Stack[i] = relocate(Stack[i]);
+            fl_ctx->Stack[i] = relocate(fl_ctx, fl_ctx->Stack[i]);
         if (f == 0) break;
         top = f - 3;
-        f = Stack[f-3];
+        f = fl_ctx->Stack[f-3];
     }
-    for (i=0; i < N_GCHND; i++)
-        *GCHandleStack[i] = relocate(*GCHandleStack[i]);
-    trace_globals(symtab);
-    relocate_typetable();
-    rs = readstate;
+    for (i=0; i < fl_ctx->N_GCHND; i++)
+        *fl_ctx->GCHandleStack[i] = relocate(fl_ctx, *fl_ctx->GCHandleStack[i]);
+    trace_globals(fl_ctx, fl_ctx->symtab);
+    relocate_typetable(fl_ctx);
+    rs = fl_ctx->readstate;
     while (rs) {
         for(i=0; i < rs->backrefs.size; i++)
-            rs->backrefs.table[i] = (void*)relocate((value_t)rs->backrefs.table[i]);
+            rs->backrefs.table[i] = (void*)relocate(fl_ctx, (value_t)rs->backrefs.table[i]);
         for(i=0; i < rs->gensyms.size; i++)
-            rs->gensyms.table[i] = (void*)relocate((value_t)rs->gensyms.table[i]);
-        rs->source = relocate(rs->source);
+            rs->gensyms.table[i] = (void*)relocate(fl_ctx, (value_t)rs->gensyms.table[i]);
+        rs->source = relocate(fl_ctx, rs->source);
         rs = rs->prev;
     }
-    fl_lasterror = relocate(fl_lasterror);
-    memory_exception_value = relocate(memory_exception_value);
-    the_empty_vector = relocate(the_empty_vector);
+    fl_ctx->lasterror = relocate(fl_ctx, fl_ctx->lasterror);
+    fl_ctx->memory_exception_value = relocate(fl_ctx, fl_ctx->memory_exception_value);
+    fl_ctx->the_empty_vector = relocate(fl_ctx, fl_ctx->the_empty_vector);
 
-    sweep_finalizers();
+    sweep_finalizers(fl_ctx);
 
 #ifdef MEMDEBUG2
     while (temp != NULL) {
@@ -657,200 +606,200 @@ void gc(int mustgrow)
         free(&((void**)temp)[-1]);
         temp = next;
     }
-    n_allocd = 0;
+    fl_n_ctx->allocd = 0;
 #else
 #ifdef VERBOSEGC
     printf("GC: found %d/%d live conses\n",
-           (curheap-tospace)/sizeof(cons_t), heapsize/sizeof(cons_t));
+           (fl_ctx->curheap-fl_ctx->tospace)/sizeof(cons_t), fl_ctx->heapsize/sizeof(cons_t));
 #endif
 
-    temp = tospace;
-    tospace = fromspace;
-    fromspace = (unsigned char*)temp;
+    temp = fl_ctx->tospace;
+    fl_ctx->tospace = fl_ctx->fromspace;
+    fl_ctx->fromspace = (unsigned char*)temp;
 
     // if we're using > 80% of the space, resize tospace so we have
     // more space to fill next time. if we grew tospace last time,
     // grow the other half of the heap this time to catch up.
-    if (grew || mustgrow
+    if (fl_ctx->gc_grew || mustgrow
 #ifdef MEMDEBUG
         // GC more often
-        || ((lim-curheap) < (int)(heapsize/128))
+        || ((fl_ctx->lim-fl_ctx->curheap) < (int)(fl_ctx->heapsize/128))
 #else
-        || ((lim-curheap) < (int)(heapsize/5))
+        || ((fl_ctx->lim-fl_ctx->curheap) < (int)(fl_ctx->heapsize/5))
 #endif
         ) {
-        temp = LLT_REALLOC(tospace, heapsize*2);
+        temp = LLT_REALLOC(fl_ctx->tospace, fl_ctx->heapsize*2);
         if (temp == NULL)
-            fl_raise(memory_exception_value);
-        tospace = (unsigned char*)temp;
-        if (grew) {
-            heapsize*=2;
-            temp = bitvector_resize(consflags, 0, heapsize/sizeof(cons_t), 1);
+            fl_raise(fl_ctx, fl_ctx->memory_exception_value);
+        fl_ctx->tospace = (unsigned char*)temp;
+        if (fl_ctx->gc_grew) {
+            fl_ctx->heapsize*=2;
+            temp = bitvector_resize(fl_ctx->consflags, 0, fl_ctx->heapsize/sizeof(cons_t), 1);
             if (temp == NULL)
-                fl_raise(memory_exception_value);
-            consflags = (uint32_t*)temp;
+                fl_raise(fl_ctx, fl_ctx->memory_exception_value);
+            fl_ctx->consflags = (uint32_t*)temp;
         }
-        grew = !grew;
+        fl_ctx->gc_grew = !fl_ctx->gc_grew;
     }
 #ifdef MEMDEBUG
-    LLT_FREE(tospace);
+    LLT_FREE(fl_ctx->tospace);
 #endif
-    if ((value_t*)curheap > ((value_t*)lim)-2) {
+    if ((value_t*)fl_ctx->curheap > ((value_t*)fl_ctx->lim)-2) {
         // all data was live; gc again and grow heap.
         // but also always leave at least 4 words available, so a closure
         // can be allocated without an extra check.
-        gc(0);
+        gc(fl_ctx, 0);
     }
 #endif
 }
 
-static void grow_stack(void)
+static void grow_stack(fl_context_t *fl_ctx)
 {
-    size_t newsz = N_STACK + (N_STACK>>1);
-    value_t *ns = (value_t*)realloc(Stack, newsz*sizeof(value_t));
+    size_t newsz = fl_ctx->N_STACK + (fl_ctx->N_STACK>>1);
+    value_t *ns = (value_t*)realloc(fl_ctx->Stack, newsz*sizeof(value_t));
     if (ns == NULL)
-        lerror(OutOfMemoryError, "stack overflow");
-    Stack = ns;
-    N_STACK = newsz;
+        lerror(fl_ctx, fl_ctx->OutOfMemoryError, "stack overflow");
+    fl_ctx->Stack = ns;
+    fl_ctx->N_STACK = newsz;
 }
 
 // utils ----------------------------------------------------------------------
 
 // apply function with n args on the stack
-static value_t _applyn(uint32_t n)
+static value_t _applyn(fl_context_t *fl_ctx, uint32_t n)
 {
-    value_t f = Stack[SP-n-1];
-    uint32_t saveSP = SP;
+    value_t f = fl_ctx->Stack[fl_ctx->SP-n-1];
+    uint32_t saveSP = fl_ctx->SP;
     value_t v;
-    if (iscbuiltin(f)) {
-        v = ((builtin_t*)ptr(f))[3](&Stack[SP-n], n);
+    if (iscbuiltin(fl_ctx, f)) {
+        v = ((builtin_t*)ptr(f))[3](fl_ctx, &fl_ctx->Stack[fl_ctx->SP-n], n);
     }
     else if (isfunction(f)) {
-        v = apply_cl(n);
+        v = apply_cl(fl_ctx, n);
     }
     else if (isbuiltin(f)) {
-        value_t tab = symbol_value(builtins_table_sym);
-        Stack[SP-n-1] = vector_elt(tab, uintval(f));
-        v = apply_cl(n);
+        value_t tab = symbol_value(fl_ctx->builtins_table_sym);
+        fl_ctx->Stack[fl_ctx->SP-n-1] = vector_elt(tab, uintval(f));
+        v = apply_cl(fl_ctx, n);
     }
     else {
-        type_error("apply", "function", f);
+        type_error(fl_ctx, "apply", "function", f);
     }
-    SP = saveSP;
+    fl_ctx->SP = saveSP;
     return v;
 }
 
-value_t fl_apply(value_t f, value_t l)
+value_t fl_apply(fl_context_t *fl_ctx, value_t f, value_t l)
 {
     value_t v = l;
-    uint32_t n = SP;
+    uint32_t n = fl_ctx->SP;
 
-    PUSH(f);
+    PUSH(fl_ctx, f);
     while (iscons(v)) {
-        if (SP >= N_STACK)
-            grow_stack();
-        PUSH(car_(v));
+        if (fl_ctx->SP >= fl_ctx->N_STACK)
+            grow_stack(fl_ctx);
+        PUSH(fl_ctx, car_(v));
         v = cdr_(v);
     }
-    n = SP - n - 1;
-    v = _applyn(n);
-    POPN(n+1);
+    n = fl_ctx->SP - n - 1;
+    v = _applyn(fl_ctx, n);
+    POPN(fl_ctx, n+1);
     return v;
 }
 
-value_t fl_applyn(uint32_t n, value_t f, ...)
+value_t fl_applyn(fl_context_t *fl_ctx, uint32_t n, value_t f, ...)
 {
     va_list ap;
     va_start(ap, f);
     size_t i;
 
-    PUSH(f);
-    while (SP+n > N_STACK)
-        grow_stack();
+    PUSH(fl_ctx, f);
+    while (fl_ctx->SP+n > fl_ctx->N_STACK)
+        grow_stack(fl_ctx);
     for(i=0; i < n; i++) {
         value_t a = va_arg(ap, value_t);
-        PUSH(a);
+        PUSH(fl_ctx, a);
     }
-    value_t v = _applyn(n);
-    POPN(n+1);
+    value_t v = _applyn(fl_ctx, n);
+    POPN(fl_ctx, n+1);
     va_end(ap);
     return v;
 }
 
-value_t fl_listn(size_t n, ...)
+value_t fl_listn(fl_context_t *fl_ctx, size_t n, ...)
 {
     va_list ap;
     va_start(ap, n);
-    uint32_t si = SP;
+    uint32_t si = fl_ctx->SP;
     size_t i;
 
-    while (SP+n > N_STACK)
-        grow_stack();
+    while (fl_ctx->SP+n > fl_ctx->N_STACK)
+        grow_stack(fl_ctx);
     for(i=0; i < n; i++) {
         value_t a = va_arg(ap, value_t);
-        PUSH(a);
+        PUSH(fl_ctx, a);
     }
 #ifdef MEMDEBUG2
-    si = SP-1;
-    value_t l = NIL;
+    si = fl_ctx->SP-1;
+    value_t l = fl_ctx->NIL;
     for(i=0; i < n; i++) {
-        l = fl_cons(Stack[si--], l);
+        l = fl_cons(fl_ctx, fl_ctx->Stack[si--], l);
     }
-    POPN(n);
+    POPN(fl_ctx, n);
     va_end(ap);
     return l;
 #else
-    cons_t *c = (cons_t*)alloc_words(n*2);
+    cons_t *c = (cons_t*)alloc_words(fl_ctx, n*2);
     cons_t *l = c;
     for(i=0; i < n; i++) {
-        c->car = Stack[si++];
+        c->car = fl_ctx->Stack[si++];
         c->cdr = tagptr(c+1, TAG_CONS);
         c++;
     }
-    (c-1)->cdr = NIL;
-    POPN(n);
+    (c-1)->cdr = fl_ctx->NIL;
+    POPN(fl_ctx, n);
     va_end(ap);
     return tagptr(l, TAG_CONS);
 #endif
 }
 
-value_t fl_list2(value_t a, value_t b)
+value_t fl_list2(fl_context_t *fl_ctx, value_t a, value_t b)
 {
-    PUSH(a);
-    PUSH(b);
+    PUSH(fl_ctx, a);
+    PUSH(fl_ctx, b);
 #ifdef MEMDEBUG2
-    Stack[SP-1] = fl_cons(b, NIL);
-    a = fl_cons(Stack[SP-2], Stack[SP-1]);
-    POPN(2);
+    fl_ctx->Stack[fl_ctx->SP-1] = fl_cons(fl_ctx, b, fl_ctx->NIL);
+    a = fl_cons(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1]);
+    POPN(fl_ctx, 2);
     return a;
 #else
-    cons_t *c = (cons_t*)alloc_words(4);
-    b = POP();
-    a = POP();
+    cons_t *c = (cons_t*)alloc_words(fl_ctx, 4);
+    b = POP(fl_ctx);
+    a = POP(fl_ctx);
     c[0].car = a;
     c[0].cdr = tagptr(c+1, TAG_CONS);
     c[1].car = b;
-    c[1].cdr = NIL;
+    c[1].cdr = fl_ctx->NIL;
     return tagptr(c, TAG_CONS);
 #endif
 }
 
-value_t fl_cons(value_t a, value_t b)
+value_t fl_cons(fl_context_t *fl_ctx, value_t a, value_t b)
 {
-    PUSH(a);
-    PUSH(b);
-    value_t c = mk_cons();
-    cdr_(c) = POP();
-    car_(c) = POP();
+    PUSH(fl_ctx, a);
+    PUSH(fl_ctx, b);
+    value_t c = mk_cons(fl_ctx);
+    cdr_(c) = POP(fl_ctx);
+    car_(c) = POP(fl_ctx);
     return c;
 }
 
-int fl_isnumber(value_t v)
+int fl_isnumber(fl_context_t *fl_ctx, value_t v)
 {
     if (isfixnum(v)) return 1;
     if (iscprim(v)) {
         cprim_t *c = (cprim_t*)ptr(v);
-        return c->type != wchartype;
+        return c->type != fl_ctx->wchartype;
     }
     return 0;
 }
@@ -865,9 +814,9 @@ int fl_isnumber(value_t v)
 
 // eval -----------------------------------------------------------------------
 
-#define list(a,n) _list((a),(n),0)
+#define list(fl_ctx, a,n) _list(fl_ctx, (a), (n), 0)
 
-static value_t _list(value_t *args, uint32_t nargs, int star)
+static value_t _list(fl_context_t *fl_ctx, value_t *args, uint32_t nargs, int star)
 {
     cons_t *c;
     int i;
@@ -876,7 +825,7 @@ static value_t _list(value_t *args, uint32_t nargs, int star)
     value_t n;
     i = nargs-1;
     if (star) {
-        n = mk_cons();
+        n = mk_cons(fl_ctx);
         c = (cons_t*)ptr(n);
         c->car = args[i-1];
         c->cdr = args[i];
@@ -884,19 +833,19 @@ static value_t _list(value_t *args, uint32_t nargs, int star)
         v = n;
     }
     else {
-        v = NIL;
+        v = fl_ctx->NIL;
     }
-    PUSH(v);
+    PUSH(fl_ctx, v);
     for(; i >= 0; i--) {
-        n = mk_cons();
+        n = mk_cons(fl_ctx);
         c = (cons_t*)ptr(n);
         c->car = args[i];
-        c->cdr = Stack[SP-1];
-        Stack[SP-1] = n;
+        c->cdr = fl_ctx->Stack[fl_ctx->SP-1];
+        fl_ctx->Stack[fl_ctx->SP-1] = n;
     }
-    v = POP();
+    v = POP(fl_ctx);
 #else
-    v = cons_reserve(nargs);
+    v = cons_reserve(fl_ctx, nargs);
     c = (cons_t*)ptr(v);
     for(i=0; i < nargs; i++) {
         c->car = args[i];
@@ -906,56 +855,56 @@ static value_t _list(value_t *args, uint32_t nargs, int star)
     if (star)
         (c-2)->cdr = (c-1)->car;
     else
-        (c-1)->cdr = NIL;
+        (c-1)->cdr = fl_ctx->NIL;
 #endif
     return v;
 }
 
-static value_t copy_list(value_t L)
+static value_t copy_list(fl_context_t *fl_ctx, value_t L)
 {
     if (!iscons(L))
-        return NIL;
-    PUSH(NIL);
-    PUSH(L);
-    value_t *plcons = &Stack[SP-2];
-    value_t *pL = &Stack[SP-1];
+        return fl_ctx->NIL;
+    PUSH(fl_ctx, fl_ctx->NIL);
+    PUSH(fl_ctx, L);
+    value_t *plcons = &fl_ctx->Stack[fl_ctx->SP-2];
+    value_t *pL = &fl_ctx->Stack[fl_ctx->SP-1];
     value_t c;
-    c = mk_cons(); PUSH(c);  // save first cons
+    c = mk_cons(fl_ctx); PUSH(fl_ctx, c);  // save first cons
     car_(c) = car_(*pL);
-    cdr_(c) = NIL;
+    cdr_(c) = fl_ctx->NIL;
     *plcons = c;
     *pL = cdr_(*pL);
     while (iscons(*pL)) {
-        c = mk_cons();
+        c = mk_cons(fl_ctx);
         car_(c) = car_(*pL);
-        cdr_(c) = NIL;
+        cdr_(c) = fl_ctx->NIL;
         cdr_(*plcons) = c;
         *plcons = c;
         *pL = cdr_(*pL);
     }
-    c = POP();  // first cons
-    POPN(2);
+    c = POP(fl_ctx);  // first cons
+    POPN(fl_ctx, 2);
     return c;
 }
 
-static value_t do_trycatch(void)
+static value_t do_trycatch(fl_context_t *fl_ctx)
 {
-    uint32_t saveSP = SP;
+    uint32_t saveSP = fl_ctx->SP;
     value_t v;
-    value_t thunk = Stack[SP-2];
-    Stack[SP-2] = Stack[SP-1];
-    Stack[SP-1] = thunk;
+    value_t thunk = fl_ctx->Stack[fl_ctx->SP-2];
+    fl_ctx->Stack[fl_ctx->SP-2] = fl_ctx->Stack[fl_ctx->SP-1];
+    fl_ctx->Stack[fl_ctx->SP-1] = thunk;
 
-    FL_TRY {
-        v = apply_cl(0);
+    FL_TRY(fl_ctx) {
+        v = apply_cl(fl_ctx, 0);
     }
-    FL_CATCH {
-        v = Stack[saveSP-2];
-        PUSH(v);
-        PUSH(fl_lasterror);
-        v = apply_cl(1);
+    FL_CATCH(fl_ctx) {
+        v = fl_ctx->Stack[saveSP-2];
+        PUSH(fl_ctx, v);
+        PUSH(fl_ctx, fl_ctx->lasterror);
+        v = apply_cl(fl_ctx, 1);
     }
-    SP = saveSP;
+    fl_ctx->SP = saveSP;
     return v;
 }
 
@@ -963,24 +912,24 @@ static value_t do_trycatch(void)
   argument layout on stack is
   |--required args--|--opt args--|--kw args--|--rest args...
 */
-static uint32_t process_keys(value_t kwtable,
+static uint32_t process_keys(fl_context_t *fl_ctx, value_t kwtable,
                              uint32_t nreq, uint32_t nkw, uint32_t nopt,
                              uint32_t bp, uint32_t nargs, int va)
 {
-    uptrint_t n;
+    uintptr_t n;
     uint32_t extr = nopt+nkw;
     uint32_t ntot = nreq+extr;
     value_t *args = (value_t*)alloca(extr*sizeof(value_t));
     value_t v;
     uint32_t i, a = 0, nrestargs;
-    value_t s1 = Stack[SP-1];
-    value_t s3 = Stack[SP-3];
-    value_t s4 = Stack[SP-4];
+    value_t s1 = fl_ctx->Stack[fl_ctx->SP-1];
+    value_t s3 = fl_ctx->Stack[fl_ctx->SP-3];
+    value_t s4 = fl_ctx->Stack[fl_ctx->SP-4];
     if (nargs < nreq)
-        lerror(ArgError, "apply: too few arguments");
+        lerror(fl_ctx, fl_ctx->ArgError, "apply: too few arguments");
     for (i=0; i < extr; i++) args[i] = UNBOUND;
     for (i=nreq; i < nargs; i++) {
-        v = Stack[bp+i];
+        v = fl_ctx->Stack[bp+i];
         if (issymbol(v) && iskeyword((symbol_t*)ptr(v)))
             break;
         if (a >= nopt)
@@ -993,41 +942,41 @@ static uint32_t process_keys(value_t kwtable,
     do {
         i++;
         if (i >= nargs)
-            lerrorf(ArgError, "keyword %s requires an argument",
-                    symbol_name(v));
+            lerrorf(fl_ctx, fl_ctx->ArgError, "keyword %s requires an argument",
+                    symbol_name(fl_ctx, v));
         value_t hv = fixnum(((symbol_t*)ptr(v))->hash);
-        uptrint_t x = 2*(labs(numval(hv)) % n);
+        uintptr_t x = 2*(labs(numval(hv)) % n);
         if (vector_elt(kwtable, x) == v) {
-            uptrint_t idx = numval(vector_elt(kwtable, x+1));
+            uintptr_t idx = numval(vector_elt(kwtable, x+1));
             assert(idx < nkw);
             idx += nopt;
             if (args[idx] == UNBOUND) {
                 // if duplicate key, keep first value
-                args[idx] = Stack[bp+i];
+                args[idx] = fl_ctx->Stack[bp+i];
             }
         }
         else {
-            lerrorf(ArgError, "unsupported keyword %s", symbol_name(v));
+            lerrorf(fl_ctx, fl_ctx->ArgError, "unsupported keyword %s", symbol_name(fl_ctx, v));
         }
         i++;
         if (i >= nargs) break;
-        v = Stack[bp+i];
+        v = fl_ctx->Stack[bp+i];
     } while (issymbol(v) && iskeyword((symbol_t*)ptr(v)));
  no_kw:
     nrestargs = nargs - i;
     if (!va && nrestargs > 0)
-        lerror(ArgError, "apply: too many arguments");
+        lerror(fl_ctx, fl_ctx->ArgError, "apply: too many arguments");
     nargs = ntot + nrestargs;
     if (nrestargs)
-        memmove(&Stack[bp+ntot], &Stack[bp+i], nrestargs*sizeof(value_t));
-    memcpy(&Stack[bp+nreq], args, extr*sizeof(value_t));
-    SP = bp + nargs;
-    assert(SP < N_STACK-4);
-    PUSH(s4);
-    PUSH(s3);
-    PUSH(nargs);
-    PUSH(s1);
-    curr_frame = SP;
+        memmove(&fl_ctx->Stack[bp+ntot], &fl_ctx->Stack[bp+i], nrestargs*sizeof(value_t));
+    memcpy(&fl_ctx->Stack[bp+nreq], args, extr*sizeof(value_t));
+    fl_ctx->SP = bp + nargs;
+    assert(fl_ctx->SP < fl_ctx->N_STACK-4);
+    PUSH(fl_ctx, s4);
+    PUSH(fl_ctx, s3);
+    PUSH(fl_ctx, nargs);
+    PUSH(fl_ctx, s1);
+    fl_ctx->curr_frame = fl_ctx->SP;
     return nargs;
 }
 
@@ -1065,18 +1014,18 @@ static uint32_t process_keys(value_t kwtable,
   - put the stack in this state
   - provide arg count
   - respect tail position
-  - restore SP
+  - restore fl_ctx->SP
 
   callee's responsibility:
   - check arg counts
   - allocate vararg array
   - push closed env, set up new environment
 */
-static value_t apply_cl(uint32_t nargs)
+static value_t apply_cl(fl_context_t *fl_ctx, uint32_t nargs)
 {
     VM_LABELS;
     VM_APPLY_LABELS;
-    uint32_t top_frame = curr_frame;
+    uint32_t top_frame = fl_ctx->curr_frame;
     // frame variables
     uint32_t n=0;
     uint32_t bp;
@@ -1089,28 +1038,30 @@ static value_t apply_cl(uint32_t nargs)
 #endif
     uint32_t i;
     symbol_t *sym;
-    static cons_t *c;
-    static value_t *pv;
-    static int64_t accum;
-    static value_t func, v, e;
+#define fl_apply_c fl_ctx->apply_c
+#define fl_apply_pv fl_ctx->apply_pv
+#define fl_apply_accum fl_ctx->apply_accum
+#define fl_apply_func fl_ctx->apply_func
+#define fl_apply_v fl_ctx->apply_v
+#define fl_apply_e fl_ctx->apply_e
 
  apply_cl_top:
-    func = Stack[SP-nargs-1];
-    ip = (uint8_t*)cv_data((cvalue_t*)ptr(fn_bcode(func)));
+    fl_apply_func = fl_ctx->Stack[fl_ctx->SP-nargs-1];
+    ip = (uint8_t*)cv_data((cvalue_t*)ptr(fn_bcode(fl_apply_func)));
 #ifndef MEMDEBUG2
-    assert(!ismanaged((uptrint_t)ip));
+    assert(!ismanaged(fl_ctx, (uintptr_t)ip));
 #endif
-    while (SP+GET_INT32(ip) > N_STACK) {
-        grow_stack();
+    while (fl_ctx->SP+GET_INT32(ip) > fl_ctx->N_STACK) {
+        grow_stack(fl_ctx);
     }
     ip += 4;
 
-    bp = SP-nargs;
-    PUSH(fn_env(func));
-    PUSH(curr_frame);
-    PUSH(nargs);
-    SP++;//PUSH(0); //ip
-    curr_frame = SP;
+    bp = fl_ctx->SP-nargs;
+    PUSH(fl_ctx, fn_env(fl_apply_func));
+    PUSH(fl_ctx, fl_ctx->curr_frame);
+    PUSH(fl_ctx, nargs);
+    fl_ctx->SP++;//PUSH(fl_ctx, 0); //ip
+    fl_ctx->curr_frame = fl_ctx->SP;
 
     {
 #ifdef USE_COMPUTED_GOTO
@@ -1127,9 +1078,9 @@ static value_t apply_cl(uint32_t nargs)
         do_argc:
             if (nargs != n) {
                 if (nargs > n)
-                    lerror(ArgError, "apply: too many arguments");
+                    lerror(fl_ctx, fl_ctx->ArgError, "apply: too many arguments");
                 else
-                    lerror(ArgError, "apply: too few arguments");
+                    lerror(fl_ctx, fl_ctx->ArgError, "apply: too few arguments");
             }
             NEXT_OP;
         OP(OP_VARGC)
@@ -1137,27 +1088,27 @@ static value_t apply_cl(uint32_t nargs)
         do_vargc:
             s = (fixnum_t)nargs - (fixnum_t)i;
             if (s > 0) {
-                v = list(&Stack[bp+i], s);
-                Stack[bp+i] = v;
+                fl_apply_v = list(fl_ctx, &fl_ctx->Stack[bp+i], s);
+                fl_ctx->Stack[bp+i] = fl_apply_v;
                 if (s > 1) {
-                    Stack[bp+i+1] = Stack[bp+nargs+0];
-                    Stack[bp+i+2] = Stack[bp+nargs+1];
-                    Stack[bp+i+3] = i+1;
-                    Stack[bp+i+4] = 0;
-                    SP =  bp+i+5;
-                    curr_frame = SP;
+                    fl_ctx->Stack[bp+i+1] = fl_ctx->Stack[bp+nargs+0];
+                    fl_ctx->Stack[bp+i+2] = fl_ctx->Stack[bp+nargs+1];
+                    fl_ctx->Stack[bp+i+3] = i+1;
+                    fl_ctx->Stack[bp+i+4] = 0;
+                    fl_ctx->SP =  bp+i+5;
+                    fl_ctx->curr_frame = fl_ctx->SP;
                 }
             }
             else if (s < 0) {
-                lerror(ArgError, "apply: too few arguments");
+                lerror(fl_ctx, fl_ctx->ArgError, "apply: too few arguments");
             }
             else {
-                SP++;
-                Stack[SP-2] = i+1;
-                Stack[SP-3] = Stack[SP-4];
-                Stack[SP-4] = Stack[SP-5];
-                Stack[SP-5] = NIL;
-                curr_frame = SP;
+                fl_ctx->SP++;
+                fl_ctx->Stack[fl_ctx->SP-2] = i+1;
+                fl_ctx->Stack[fl_ctx->SP-3] = fl_ctx->Stack[fl_ctx->SP-4];
+                fl_ctx->Stack[fl_ctx->SP-4] = fl_ctx->Stack[fl_ctx->SP-5];
+                fl_ctx->Stack[fl_ctx->SP-5] = fl_ctx->NIL;
+                fl_ctx->curr_frame = fl_ctx->SP;
             }
             nargs = i+1;
             NEXT_OP;
@@ -1169,37 +1120,37 @@ static value_t apply_cl(uint32_t nargs)
             goto do_vargc;
         OP(OP_BRBOUND)
             i = GET_INT32(ip); ip+=4;
-            v = Stack[bp+i];
-            if (v != UNBOUND) PUSH(FL_T);
-            else PUSH(FL_F);
+            fl_apply_v = fl_ctx->Stack[bp+i];
+            if (fl_apply_v != UNBOUND) PUSH(fl_ctx, fl_ctx->T);
+            else PUSH(fl_ctx, fl_ctx->F);
             NEXT_OP;
-        OP(OP_DUP) SP++; Stack[SP-1] = Stack[SP-2]; NEXT_OP;
-        OP(OP_POP) POPN(1); NEXT_OP;
+        OP(OP_DUP) fl_ctx->SP++; fl_ctx->Stack[fl_ctx->SP-1] = fl_ctx->Stack[fl_ctx->SP-2]; NEXT_OP;
+        OP(OP_POP) POPN(fl_ctx, 1); NEXT_OP;
         OP(OP_TCALL)
             n = *ip++;  // nargs
         do_tcall:
-            func = Stack[SP-n-1];
-            if (tag(func) == TAG_FUNCTION) {
-                if (func > (N_BUILTINS<<3)) {
-                    curr_frame = Stack[curr_frame-3];
+            fl_apply_func = fl_ctx->Stack[fl_ctx->SP-n-1];
+            if (tag(fl_apply_func) == TAG_FUNCTION) {
+                if (fl_apply_func > (N_BUILTINS<<3)) {
+                    fl_ctx->curr_frame = fl_ctx->Stack[fl_ctx->curr_frame-3];
                     for(s=-1; s < (fixnum_t)n; s++)
-                        Stack[bp+s] = Stack[SP-n+s];
-                    SP = bp+n;
+                        fl_ctx->Stack[bp+s] = fl_ctx->Stack[fl_ctx->SP-n+s];
+                    fl_ctx->SP = bp+n;
                     nargs = n;
                     goto apply_cl_top;
                 }
                 else {
-                    i = uintval(func);
+                    i = uintval(fl_apply_func);
                     if (i <= OP_ASET) {
                         s = builtin_arg_counts[i];
                         if (s >= 0)
-                            argcount(builtin_names[i], n, s);
+                            argcount(fl_ctx, builtin_names[i], n, s);
                         else if (s != ANYARGS && (signed)n < -s)
-                            argcount(builtin_names[i], n, -s);
+                            argcount(fl_ctx, builtin_names[i], n, -s);
                         // remove function arg
-                        for(s=SP-n-1; s < (int)SP-1; s++)
-                            Stack[s] = Stack[s+1];
-                        SP--;
+                        for(s=fl_ctx->SP-n-1; s < (int)fl_ctx->SP-1; s++)
+                            fl_ctx->Stack[s] = fl_ctx->Stack[s+1];
+                        fl_ctx->SP--;
 #ifdef USE_COMPUTED_GOTO
                         if (i == OP_APPLY)
                             goto apply_tapply;
@@ -1221,37 +1172,37 @@ static value_t apply_cl(uint32_t nargs)
                     }
                 }
             }
-            else if (iscbuiltin(func)) {
-                s = SP;
-                v = ((builtin_t)(((void**)ptr(func))[3]))(&Stack[SP-n], n);
-                SP = s-n;
-                Stack[SP-1] = v;
+            else if (iscbuiltin(fl_ctx, fl_apply_func)) {
+                s = fl_ctx->SP;
+                fl_apply_v = ((builtin_t)(((void**)ptr(fl_apply_func))[3]))(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-n], n);
+                fl_ctx->SP = s-n;
+                fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
                 NEXT_OP;
             }
-            type_error("apply", "function", func);
+            type_error(fl_ctx, "apply", "function", fl_apply_func);
         // WARNING: repeated code ahead
         OP(OP_CALL)
             n = *ip++;  // nargs
         do_call:
-            func = Stack[SP-n-1];
-            if (tag(func) == TAG_FUNCTION) {
-                if (func > (N_BUILTINS<<3)) {
-                    Stack[curr_frame-1] = (uptrint_t)ip;
+            fl_apply_func = fl_ctx->Stack[fl_ctx->SP-n-1];
+            if (tag(fl_apply_func) == TAG_FUNCTION) {
+                if (fl_apply_func > (N_BUILTINS<<3)) {
+                    fl_ctx->Stack[fl_ctx->curr_frame-1] = (uintptr_t)ip;
                     nargs = n;
                     goto apply_cl_top;
                 }
                 else {
-                    i = uintval(func);
+                    i = uintval(fl_apply_func);
                     if (i <= OP_ASET) {
                         s = builtin_arg_counts[i];
                         if (s >= 0)
-                            argcount(builtin_names[i], n, s);
+                            argcount(fl_ctx, builtin_names[i], n, s);
                         else if (s != ANYARGS && (signed)n < -s)
-                            argcount(builtin_names[i], n, -s);
+                            argcount(fl_ctx, builtin_names[i], n, -s);
                         // remove function arg
-                        for(s=SP-n-1; s < (int)SP-1; s++)
-                            Stack[s] = Stack[s+1];
-                        SP--;
+                        for(s=fl_ctx->SP-n-1; s < (int)fl_ctx->SP-1; s++)
+                            fl_ctx->Stack[s] = fl_ctx->Stack[s+1];
+                        fl_ctx->SP--;
 #ifdef USE_COMPUTED_GOTO
                         goto *vm_apply_labels[i];
 #else
@@ -1271,223 +1222,223 @@ static value_t apply_cl(uint32_t nargs)
                     }
                 }
             }
-            else if (iscbuiltin(func)) {
-                s = SP;
-                v = ((builtin_t)(((void**)ptr(func))[3]))(&Stack[SP-n], n);
-                SP = s-n;
-                Stack[SP-1] = v;
+            else if (iscbuiltin(fl_ctx, fl_apply_func)) {
+                s = fl_ctx->SP;
+                fl_apply_v = ((builtin_t)(((void**)ptr(fl_apply_func))[3]))(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-n], n);
+                fl_ctx->SP = s-n;
+                fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
                 NEXT_OP;
             }
-            type_error("apply", "function", func);
+            type_error(fl_ctx, "apply", "function", fl_apply_func);
         OP(OP_TCALLL) n = GET_INT32(ip); ip+=4; goto do_tcall;
         OP(OP_CALLL)  n = GET_INT32(ip); ip+=4; goto do_call;
-        OP(OP_JMP) ip += (ptrint_t)GET_INT16(ip); NEXT_OP;
+        OP(OP_JMP) ip += (intptr_t)GET_INT16(ip); NEXT_OP;
         OP(OP_BRF)
-            v = POP();
-            if (v == FL_F) ip += (ptrint_t)GET_INT16(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v == fl_ctx->F) ip += (intptr_t)GET_INT16(ip);
             else ip += 2;
             NEXT_OP;
         OP(OP_BRT)
-            v = POP();
-            if (v != FL_F) ip += (ptrint_t)GET_INT16(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v != fl_ctx->F) ip += (intptr_t)GET_INT16(ip);
             else ip += 2;
             NEXT_OP;
-        OP(OP_JMPL) ip += (ptrint_t)GET_INT32(ip); NEXT_OP;
+        OP(OP_JMPL) ip += (intptr_t)GET_INT32(ip); NEXT_OP;
         OP(OP_BRFL)
-            v = POP();
-            if (v == FL_F) ip += (ptrint_t)GET_INT32(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v == fl_ctx->F) ip += (intptr_t)GET_INT32(ip);
             else ip += 4;
             NEXT_OP;
         OP(OP_BRTL)
-            v = POP();
-            if (v != FL_F) ip += (ptrint_t)GET_INT32(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v != fl_ctx->F) ip += (intptr_t)GET_INT32(ip);
             else ip += 4;
             NEXT_OP;
         OP(OP_BRNE)
-            if (Stack[SP-2] != Stack[SP-1]) ip += (ptrint_t)GET_INT16(ip);
+            if (fl_ctx->Stack[fl_ctx->SP-2] != fl_ctx->Stack[fl_ctx->SP-1]) ip += (intptr_t)GET_INT16(ip);
             else ip += 2;
-            POPN(2);
+            POPN(fl_ctx, 2);
             NEXT_OP;
         OP(OP_BRNEL)
-            if (Stack[SP-2] != Stack[SP-1]) ip += (ptrint_t)GET_INT32(ip);
+            if (fl_ctx->Stack[fl_ctx->SP-2] != fl_ctx->Stack[fl_ctx->SP-1]) ip += (intptr_t)GET_INT32(ip);
             else ip += 4;
-            POPN(2);
+            POPN(fl_ctx, 2);
             NEXT_OP;
         OP(OP_BRNN)
-            v = POP();
-            if (v != NIL) ip += (ptrint_t)GET_INT16(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v != fl_ctx->NIL) ip += (intptr_t)GET_INT16(ip);
             else ip += 2;
             NEXT_OP;
         OP(OP_BRNNL)
-            v = POP();
-            if (v != NIL) ip += (ptrint_t)GET_INT32(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v != fl_ctx->NIL) ip += (intptr_t)GET_INT32(ip);
             else ip += 4;
             NEXT_OP;
         OP(OP_BRN)
-            v = POP();
-            if (v == NIL) ip += (ptrint_t)GET_INT16(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v == fl_ctx->NIL) ip += (intptr_t)GET_INT16(ip);
             else ip += 2;
             NEXT_OP;
         OP(OP_BRNL)
-            v = POP();
-            if (v == NIL) ip += (ptrint_t)GET_INT32(ip);
+            fl_apply_v = POP(fl_ctx);
+            if (fl_apply_v == fl_ctx->NIL) ip += (intptr_t)GET_INT32(ip);
             else ip += 4;
             NEXT_OP;
         OP(OP_RET)
-            v = POP();
-            SP = curr_frame;
-            curr_frame = Stack[SP-3];
-            if (curr_frame == top_frame) return v;
-            SP -= (4+nargs);
-            ip = (uint8_t*)Stack[curr_frame-1];
-            nargs        = Stack[curr_frame-2];
-            bp           = curr_frame - 4 - nargs;
-            Stack[SP-1] = v;
+            fl_apply_v = POP(fl_ctx);
+            fl_ctx->SP = fl_ctx->curr_frame;
+            fl_ctx->curr_frame = fl_ctx->Stack[fl_ctx->SP-3];
+            if (fl_ctx->curr_frame == top_frame) return fl_apply_v;
+            fl_ctx->SP -= (4+nargs);
+            ip = (uint8_t*)fl_ctx->Stack[fl_ctx->curr_frame-1];
+            nargs        = fl_ctx->Stack[fl_ctx->curr_frame-2];
+            bp           = fl_ctx->curr_frame - 4 - nargs;
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
 
         OP(OP_EQ)
-            Stack[SP-2] = ((Stack[SP-2] == Stack[SP-1]) ? FL_T : FL_F);
-            POPN(1); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-2] = ((fl_ctx->Stack[fl_ctx->SP-2] == fl_ctx->Stack[fl_ctx->SP-1]) ? fl_ctx->T : fl_ctx->F);
+            POPN(fl_ctx, 1); NEXT_OP;
         OP(OP_EQV)
-            if (Stack[SP-2] == Stack[SP-1]) {
-                v = FL_T;
+            if (fl_ctx->Stack[fl_ctx->SP-2] == fl_ctx->Stack[fl_ctx->SP-1]) {
+                fl_apply_v = fl_ctx->T;
             }
-            else if (!leafp(Stack[SP-2]) || !leafp(Stack[SP-1])) {
-                v = FL_F;
+            else if (!leafp(fl_ctx->Stack[fl_ctx->SP-2]) || !leafp(fl_ctx->Stack[fl_ctx->SP-1])) {
+                fl_apply_v = fl_ctx->F;
             }
             else {
-                v = (compare_(Stack[SP-2], Stack[SP-1], 1)==0 ? FL_T : FL_F);
+                fl_apply_v = (compare_(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1], 1)==0 ? fl_ctx->T : fl_ctx->F);
             }
-            Stack[SP-2] = v; POPN(1);
+            fl_ctx->Stack[fl_ctx->SP-2] = fl_apply_v; POPN(fl_ctx, 1);
             NEXT_OP;
         OP(OP_EQUAL)
-            if (Stack[SP-2] == Stack[SP-1]) {
-                v = FL_T;
+            if (fl_ctx->Stack[fl_ctx->SP-2] == fl_ctx->Stack[fl_ctx->SP-1]) {
+                fl_apply_v = fl_ctx->T;
             }
             else {
-                v = (compare_(Stack[SP-2], Stack[SP-1], 1)==0 ? FL_T : FL_F);
+                fl_apply_v = (compare_(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1], 1)==0 ? fl_ctx->T : fl_ctx->F);
             }
-            Stack[SP-2] = v; POPN(1);
+            fl_ctx->Stack[fl_ctx->SP-2] = fl_apply_v; POPN(fl_ctx, 1);
             NEXT_OP;
         OP(OP_PAIRP)
-            Stack[SP-1] = (iscons(Stack[SP-1]) ? FL_T : FL_F); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = (iscons(fl_ctx->Stack[fl_ctx->SP-1]) ? fl_ctx->T : fl_ctx->F); NEXT_OP;
         OP(OP_ATOMP)
-            Stack[SP-1] = (iscons(Stack[SP-1]) ? FL_F : FL_T); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = (iscons(fl_ctx->Stack[fl_ctx->SP-1]) ? fl_ctx->F : fl_ctx->T); NEXT_OP;
         OP(OP_NOT)
-            Stack[SP-1] = ((Stack[SP-1]==FL_F) ? FL_T : FL_F); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = ((fl_ctx->Stack[fl_ctx->SP-1]==fl_ctx->F) ? fl_ctx->T : fl_ctx->F); NEXT_OP;
         OP(OP_NULLP)
-            Stack[SP-1] = ((Stack[SP-1]==NIL) ? FL_T : FL_F); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = ((fl_ctx->Stack[fl_ctx->SP-1]==fl_ctx->NIL) ? fl_ctx->T : fl_ctx->F); NEXT_OP;
         OP(OP_BOOLEANP)
-            v = Stack[SP-1];
-            Stack[SP-1] = ((v == FL_T || v == FL_F) ? FL_T:FL_F); NEXT_OP;
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+            fl_ctx->Stack[fl_ctx->SP-1] = ((fl_apply_v == fl_ctx->T || fl_apply_v == fl_ctx->F) ? fl_ctx->T:fl_ctx->F); NEXT_OP;
         OP(OP_SYMBOLP)
-            Stack[SP-1] = (issymbol(Stack[SP-1]) ? FL_T : FL_F); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = (issymbol(fl_ctx->Stack[fl_ctx->SP-1]) ? fl_ctx->T : fl_ctx->F); NEXT_OP;
         OP(OP_NUMBERP)
-            v = Stack[SP-1];
-            Stack[SP-1] = (fl_isnumber(v) ? FL_T:FL_F); NEXT_OP;
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+            fl_ctx->Stack[fl_ctx->SP-1] = (fl_isnumber(fl_ctx, fl_apply_v) ? fl_ctx->T:fl_ctx->F); NEXT_OP;
         OP(OP_FIXNUMP)
-            Stack[SP-1] = (isfixnum(Stack[SP-1]) ? FL_T : FL_F); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = (isfixnum(fl_ctx->Stack[fl_ctx->SP-1]) ? fl_ctx->T : fl_ctx->F); NEXT_OP;
         OP(OP_BOUNDP)
-            sym = tosymbol(Stack[SP-1], "bound?");
-            Stack[SP-1] = ((sym->binding == UNBOUND) ? FL_F : FL_T);
+            sym = tosymbol(fl_ctx, fl_ctx->Stack[fl_ctx->SP-1], "bound?");
+            fl_ctx->Stack[fl_ctx->SP-1] = ((sym->binding == UNBOUND) ? fl_ctx->F : fl_ctx->T);
             NEXT_OP;
         OP(OP_BUILTINP)
-            v = Stack[SP-1];
-            Stack[SP-1] = (isbuiltin(v) || iscbuiltin(v)) ? FL_T : FL_F;
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+        fl_ctx->Stack[fl_ctx->SP-1] = (isbuiltin(fl_apply_v) || iscbuiltin(fl_ctx, fl_apply_v)) ? fl_ctx->T : fl_ctx->F;
             NEXT_OP;
         OP(OP_FUNCTIONP)
-            v = Stack[SP-1];
-            Stack[SP-1] = ((tag(v)==TAG_FUNCTION &&
-                            (uintval(v)<=OP_ASET || v>(N_BUILTINS<<3))) ||
-                           iscbuiltin(v)) ? FL_T : FL_F;
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+            fl_ctx->Stack[fl_ctx->SP-1] = ((tag(fl_apply_v)==TAG_FUNCTION &&
+                            (uintval(fl_apply_v)<=OP_ASET || fl_apply_v>(N_BUILTINS<<3))) ||
+                                 iscbuiltin(fl_ctx, fl_apply_v)) ? fl_ctx->T : fl_ctx->F;
             NEXT_OP;
         OP(OP_VECTORP)
-            Stack[SP-1] = (isvector(Stack[SP-1]) ? FL_T : FL_F); NEXT_OP;
+            fl_ctx->Stack[fl_ctx->SP-1] = (isvector(fl_ctx->Stack[fl_ctx->SP-1]) ? fl_ctx->T : fl_ctx->F); NEXT_OP;
 
         OP(OP_CONS)
 #ifdef MEMDEBUG2
-            c = (cons_t*)ptr(mk_cons());
+            fl_apply_c = (cons_t*)ptr(mk_cons(fl_ctx));
 #else
-            if (curheap > lim)
-                gc(0);
-            c = (cons_t*)curheap;
-            curheap += sizeof(cons_t);
+            if (fl_ctx->curheap > fl_ctx->lim)
+                gc(fl_ctx, 0);
+            fl_apply_c = (cons_t*)fl_ctx->curheap;
+            fl_ctx->curheap += sizeof(cons_t);
 #endif
-            c->car = Stack[SP-2];
-            c->cdr = Stack[SP-1];
-            Stack[SP-2] = tagptr(c, TAG_CONS);
-            POPN(1); NEXT_OP;
+            fl_apply_c->car = fl_ctx->Stack[fl_ctx->SP-2];
+            fl_apply_c->cdr = fl_ctx->Stack[fl_ctx->SP-1];
+            fl_ctx->Stack[fl_ctx->SP-2] = tagptr(fl_apply_c, TAG_CONS);
+            POPN(fl_ctx, 1); NEXT_OP;
         OP(OP_CAR)
-            v = Stack[SP-1];
-            if (!iscons(v)) type_error("car", "cons", v);
-            Stack[SP-1] = car_(v);
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+            if (!iscons(fl_apply_v)) type_error(fl_ctx, "car", "cons", fl_apply_v);
+            fl_ctx->Stack[fl_ctx->SP-1] = car_(fl_apply_v);
             NEXT_OP;
         OP(OP_CDR)
-            v = Stack[SP-1];
-            if (!iscons(v)) type_error("cdr", "cons", v);
-            Stack[SP-1] = cdr_(v);
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+            if (!iscons(fl_apply_v)) type_error(fl_ctx, "cdr", "cons", fl_apply_v);
+            fl_ctx->Stack[fl_ctx->SP-1] = cdr_(fl_apply_v);
             NEXT_OP;
         OP(OP_CADR)
-            v = Stack[SP-1];
-            if (!iscons(v)) type_error("cdr", "cons", v);
-            v = cdr_(v);
-            if (!iscons(v)) type_error("car", "cons", v);
-            Stack[SP-1] = car_(v);
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
+            if (!iscons(fl_apply_v)) type_error(fl_ctx, "cdr", "cons", fl_apply_v);
+            fl_apply_v = cdr_(fl_apply_v);
+            if (!iscons(fl_apply_v)) type_error(fl_ctx, "car", "cons", fl_apply_v);
+            fl_ctx->Stack[fl_ctx->SP-1] = car_(fl_apply_v);
             NEXT_OP;
         OP(OP_SETCAR)
-            car(Stack[SP-2]) = Stack[SP-1];
-            POPN(1); NEXT_OP;
+            car(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2]) = fl_ctx->Stack[fl_ctx->SP-1];
+            POPN(fl_ctx, 1); NEXT_OP;
         OP(OP_SETCDR)
-            cdr(Stack[SP-2]) = Stack[SP-1];
-            POPN(1); NEXT_OP;
+            cdr(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2]) = fl_ctx->Stack[fl_ctx->SP-1];
+            POPN(fl_ctx, 1); NEXT_OP;
         OP(OP_LIST)
             n = *ip++;
         apply_list:
             if (n > 0) {
-                v = list(&Stack[SP-n], n);
-                POPN(n);
-                PUSH(v);
+                fl_apply_v = list(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-n], n);
+                POPN(fl_ctx, n);
+                PUSH(fl_ctx, fl_apply_v);
             }
             else {
-                PUSH(NIL);
+                PUSH(fl_ctx, fl_ctx->NIL);
             }
             NEXT_OP;
 
         OP(OP_TAPPLY)
             n = *ip++;
         apply_tapply:
-            v = POP();     // arglist
-            n = SP-(n-2);  // n-2 == # leading arguments not in the list
-            while (iscons(v)) {
-                if (SP >= N_STACK)
-                    grow_stack();
-                PUSH(car_(v));
-                v = cdr_(v);
+            fl_apply_v = POP(fl_ctx);     // arglist
+            n = fl_ctx->SP-(n-2);  // n-2 == # leading arguments not in the list
+            while (iscons(fl_apply_v)) {
+                if (fl_ctx->SP >= fl_ctx->N_STACK)
+                    grow_stack(fl_ctx);
+                PUSH(fl_ctx, car_(fl_apply_v));
+                fl_apply_v = cdr_(fl_apply_v);
             }
-            n = SP-n;
+            n = fl_ctx->SP-n;
             goto do_tcall;
         OP(OP_APPLY)
             n = *ip++;
         apply_apply:
-            v = POP();     // arglist
-            n = SP-(n-2);  // n-2 == # leading arguments not in the list
-            while (iscons(v)) {
-                if (SP >= N_STACK)
-                    grow_stack();
-                PUSH(car_(v));
-                v = cdr_(v);
+            fl_apply_v = POP(fl_ctx);     // arglist
+            n = fl_ctx->SP-(n-2);  // n-2 == # leading arguments not in the list
+            while (iscons(fl_apply_v)) {
+                if (fl_ctx->SP >= fl_ctx->N_STACK)
+                    grow_stack(fl_ctx);
+                PUSH(fl_ctx, car_(fl_apply_v));
+                fl_apply_v = cdr_(fl_apply_v);
             }
-            n = SP-n;
+            n = fl_ctx->SP-n;
             goto do_call;
 
         OP(OP_ADD)
             n = *ip++;
         apply_add:
             s = 0;
-            i = SP-n;
-            for (; i < SP; i++) {
-                if (isfixnum(Stack[i])) {
-                    s += numval(Stack[i]);
+            i = fl_ctx->SP-n;
+            for (; i < fl_ctx->SP; i++) {
+                if (isfixnum(fl_ctx->Stack[i])) {
+                    s += numval(fl_ctx->Stack[i]);
                     if (!fits_fixnum(s)) {
                         i++;
                         goto add_ovf;
@@ -1495,400 +1446,400 @@ static value_t apply_cl(uint32_t nargs)
                 }
                 else {
                 add_ovf:
-                    v = fl_add_any(&Stack[i], SP-i, s);
+                    fl_apply_v = fl_add_any(fl_ctx, &fl_ctx->Stack[i], fl_ctx->SP-i, s);
                     break;
                 }
             }
-            if (i==SP)
-                v = fixnum(s);
-            POPN(n);
-            PUSH(v);
+            if (i==fl_ctx->SP)
+                fl_apply_v = fixnum(s);
+            POPN(fl_ctx, n);
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_ADD2)
-            if (bothfixnums(Stack[SP-1], Stack[SP-2])) {
-                s = numval(Stack[SP-1]) + numval(Stack[SP-2]);
+            if (bothfixnums(fl_ctx->Stack[fl_ctx->SP-1], fl_ctx->Stack[fl_ctx->SP-2])) {
+                s = numval(fl_ctx->Stack[fl_ctx->SP-1]) + numval(fl_ctx->Stack[fl_ctx->SP-2]);
                 if (fits_fixnum(s))
-                    v = fixnum(s);
+                    fl_apply_v = fixnum(s);
                 else
-                    v = mk_ptrdiff(s);
+                    fl_apply_v = mk_ptrdiff(fl_ctx, s);
             }
             else {
-                v = fl_add_any(&Stack[SP-2], 2, 0);
+                fl_apply_v = fl_add_any(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-2], 2, 0);
             }
-            POPN(1);
-            Stack[SP-1] = v;
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_SUB)
             n = *ip++;
         apply_sub:
             if (n == 2) goto do_sub2;
             if (n == 1) goto do_neg;
-            i = SP-n;
+            i = fl_ctx->SP-n;
             // we need to pass the full arglist on to fl_add_any
             // so it can handle rest args properly
-            PUSH(Stack[i]);
-            Stack[i] = fixnum(0);
-            Stack[i+1] = fl_neg(fl_add_any(&Stack[i], n, 0));
-            Stack[i] = POP();
-            v = fl_add_any(&Stack[i], 2, 0);
-            POPN(n);
-            PUSH(v);
+            PUSH(fl_ctx, fl_ctx->Stack[i]);
+            fl_ctx->Stack[i] = fixnum(0);
+            fl_ctx->Stack[i+1] = fl_neg(fl_ctx, fl_add_any(fl_ctx, &fl_ctx->Stack[i], n, 0));
+            fl_ctx->Stack[i] = POP(fl_ctx);
+            fl_apply_v = fl_add_any(fl_ctx, &fl_ctx->Stack[i], 2, 0);
+            POPN(fl_ctx, n);
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_NEG)
         do_neg:
-            if (isfixnum(Stack[SP-1]))
-                Stack[SP-1] = fixnum(-numval(Stack[SP-1]));
+            if (isfixnum(fl_ctx->Stack[fl_ctx->SP-1]))
+                fl_ctx->Stack[fl_ctx->SP-1] = fixnum(-numval(fl_ctx->Stack[fl_ctx->SP-1]));
             else
-                Stack[SP-1] = fl_neg(Stack[SP-1]);
+                fl_ctx->Stack[fl_ctx->SP-1] = fl_neg(fl_ctx, fl_ctx->Stack[fl_ctx->SP-1]);
             NEXT_OP;
         OP(OP_SUB2)
         do_sub2:
-            if (bothfixnums(Stack[SP-2], Stack[SP-1])) {
-                s = numval(Stack[SP-2]) - numval(Stack[SP-1]);
+            if (bothfixnums(fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1])) {
+                s = numval(fl_ctx->Stack[fl_ctx->SP-2]) - numval(fl_ctx->Stack[fl_ctx->SP-1]);
                 if (fits_fixnum(s))
-                    v = fixnum(s);
+                    fl_apply_v = fixnum(s);
                 else
-                    v = mk_ptrdiff(s);
+                    fl_apply_v = mk_ptrdiff(fl_ctx, s);
             }
             else {
-                Stack[SP-1] = fl_neg(Stack[SP-1]);
-                v = fl_add_any(&Stack[SP-2], 2, 0);
+                fl_ctx->Stack[fl_ctx->SP-1] = fl_neg(fl_ctx, fl_ctx->Stack[fl_ctx->SP-1]);
+                fl_apply_v = fl_add_any(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-2], 2, 0);
             }
-            POPN(1);
-            Stack[SP-1] = v;
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_MUL)
             n = *ip++;
         apply_mul:
-            accum = 1;
-            i = SP-n;
-            for (; i < SP; i++) {
-                if (isfixnum(Stack[i])) {
-                    accum *= numval(Stack[i]);
+            fl_apply_accum = 1;
+            i = fl_ctx->SP-n;
+            for (; i < fl_ctx->SP; i++) {
+                if (isfixnum(fl_ctx->Stack[i])) {
+                    fl_apply_accum *= numval(fl_ctx->Stack[i]);
                 }
                 else {
-                    v = fl_mul_any(&Stack[i], SP-i, accum);
+                    fl_apply_v = fl_mul_any(fl_ctx, &fl_ctx->Stack[i], fl_ctx->SP-i, fl_apply_accum);
                     break;
                 }
             }
-            if (i == SP) {
-                if (fits_fixnum(accum))
-                    v = fixnum(accum);
+            if (i == fl_ctx->SP) {
+                if (fits_fixnum(fl_apply_accum))
+                    fl_apply_v = fixnum(fl_apply_accum);
                 else
-                    v = return_from_int64(accum);
+                    fl_apply_v = return_from_int64(fl_ctx, fl_apply_accum);
             }
-            POPN(n);
-            PUSH(v);
+            POPN(fl_ctx, n);
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_DIV)
             n = *ip++;
         apply_div:
-            i = SP-n;
+            i = fl_ctx->SP-n;
             if (n == 1) {
-                Stack[SP-1] = fl_div2(fixnum(1), Stack[i]);
+                fl_ctx->Stack[fl_ctx->SP-1] = fl_div2(fl_ctx, fixnum(1), fl_ctx->Stack[i]);
             }
             else {
                 if (n > 2) {
-                    PUSH(Stack[i]);
-                    Stack[i] = fixnum(1);
-                    Stack[i+1] = fl_mul_any(&Stack[i], n, 1);
-                    Stack[i] = POP();
+                    PUSH(fl_ctx, fl_ctx->Stack[i]);
+                    fl_ctx->Stack[i] = fixnum(1);
+                    fl_ctx->Stack[i+1] = fl_mul_any(fl_ctx, &fl_ctx->Stack[i], n, 1);
+                    fl_ctx->Stack[i] = POP(fl_ctx);
                 }
-                v = fl_div2(Stack[i], Stack[i+1]);
-                POPN(n);
-                PUSH(v);
+                fl_apply_v = fl_div2(fl_ctx, fl_ctx->Stack[i], fl_ctx->Stack[i+1]);
+                POPN(fl_ctx, n);
+                PUSH(fl_ctx, fl_apply_v);
             }
             NEXT_OP;
         OP(OP_IDIV)
-            v = Stack[SP-2]; e = Stack[SP-1];
-            if (bothfixnums(v, e)) {
-                if (e==0) DivideByZeroError();
-                v = fixnum(numval(v) / numval(e));
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-2]; fl_apply_e = fl_ctx->Stack[fl_ctx->SP-1];
+            if (bothfixnums(fl_apply_v, fl_apply_e)) {
+                if (fl_apply_e==0) DivideByZeroError(fl_ctx);
+                fl_apply_v = fixnum(numval(fl_apply_v) / numval(fl_apply_e));
             }
             else
-                v = fl_idiv2(v, e);
-            POPN(1);
-            Stack[SP-1] = v;
+                fl_apply_v = fl_idiv2(fl_ctx, fl_apply_v, fl_apply_e);
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_NUMEQ)
-            v = Stack[SP-2]; e = Stack[SP-1];
-            if (bothfixnums(v, e))
-                v = (v == e) ? FL_T : FL_F;
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-2]; fl_apply_e = fl_ctx->Stack[fl_ctx->SP-1];
+            if (bothfixnums(fl_apply_v, fl_apply_e))
+                fl_apply_v = (fl_apply_v == fl_apply_e) ? fl_ctx->T : fl_ctx->F;
             else
-                v = (!numeric_compare(v,e,1,0,"=")) ? FL_T : FL_F;
-            POPN(1);
-            Stack[SP-1] = v;
+                fl_apply_v = (!numeric_compare(fl_ctx,fl_apply_v,fl_apply_e,1,0,"=")) ? fl_ctx->T : fl_ctx->F;
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_LT)
-            if (bothfixnums(Stack[SP-2], Stack[SP-1])) {
-                v = (numval(Stack[SP-2]) < numval(Stack[SP-1])) ? FL_T : FL_F;
+            if (bothfixnums(fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1])) {
+                fl_apply_v = (numval(fl_ctx->Stack[fl_ctx->SP-2]) < numval(fl_ctx->Stack[fl_ctx->SP-1])) ? fl_ctx->T : fl_ctx->F;
             }
             else {
-                v = (numval(fl_compare(Stack[SP-2], Stack[SP-1])) < 0) ?
-                    FL_T : FL_F;
+                fl_apply_v = (numval(fl_compare(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1])) < 0) ?
+                    fl_ctx->T : fl_ctx->F;
             }
-            POPN(1);
-            Stack[SP-1] = v;
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_COMPARE)
-            Stack[SP-2] = compare_(Stack[SP-2], Stack[SP-1], 0);
-            POPN(1);
+            fl_ctx->Stack[fl_ctx->SP-2] = compare_(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], fl_ctx->Stack[fl_ctx->SP-1], 0);
+            POPN(fl_ctx, 1);
             NEXT_OP;
 
         OP(OP_VECTOR)
             n = *ip++;
         apply_vector:
-            v = alloc_vector(n, 0);
+            fl_apply_v = alloc_vector(fl_ctx, n, 0);
             if (n) {
-                memcpy(&vector_elt(v,0), &Stack[SP-n], n*sizeof(value_t));
-                POPN(n);
+                memcpy(&vector_elt(fl_apply_v,0), &fl_ctx->Stack[fl_ctx->SP-n], n*sizeof(value_t));
+                POPN(fl_ctx, n);
             }
-            PUSH(v);
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
 
         OP(OP_AREF)
-            v = Stack[SP-2];
-            if (isvector(v)) {
-                e = Stack[SP-1];
-                if (isfixnum(e))
-                    i = numval(e);
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-2];
+            if (isvector(fl_apply_v)) {
+                fl_apply_e = fl_ctx->Stack[fl_ctx->SP-1];
+                if (isfixnum(fl_apply_e))
+                    i = numval(fl_apply_e);
                 else
-                    i = (uint32_t)tosize(e, "aref");
-                if ((unsigned)i >= vector_size(v))
-                    bounds_error("aref", v, e);
-                v = vector_elt(v, i);
+                    i = (uint32_t)tosize(fl_ctx, fl_apply_e, "aref");
+                if ((unsigned)i >= vector_size(fl_apply_v))
+                    bounds_error(fl_ctx, "aref", fl_apply_v, fl_apply_e);
+                fl_apply_v = vector_elt(fl_apply_v, i);
             }
-            else if (isarray(v)) {
-                v = cvalue_array_aref(&Stack[SP-2]);
+            else if (isarray(fl_apply_v)) {
+                fl_apply_v = cvalue_array_aref(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-2]);
             }
             else {
-                type_error("aref", "sequence", v);
+                type_error(fl_ctx, "aref", "sequence", fl_apply_v);
             }
-            POPN(1);
-            Stack[SP-1] = v;
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_ASET)
-            e = Stack[SP-3];
-            if (isvector(e)) {
-                i = tofixnum(Stack[SP-2], "aset!");
-                if ((unsigned)i >= vector_size(e))
-                    bounds_error("aset!", v, Stack[SP-1]);
-                vector_elt(e, i) = (v=Stack[SP-1]);
+            fl_apply_e = fl_ctx->Stack[fl_ctx->SP-3];
+            if (isvector(fl_apply_e)) {
+                i = tofixnum(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], "aset!");
+                if ((unsigned)i >= vector_size(fl_apply_e))
+                    bounds_error(fl_ctx, "aset!", fl_apply_v, fl_ctx->Stack[fl_ctx->SP-1]);
+                vector_elt(fl_apply_e, i) = (fl_apply_v=fl_ctx->Stack[fl_ctx->SP-1]);
             }
-            else if (isarray(e)) {
-                v = cvalue_array_aset(&Stack[SP-3]);
+            else if (isarray(fl_apply_e)) {
+                fl_apply_v = cvalue_array_aset(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-3]);
             }
             else {
-                type_error("aset!", "sequence", e);
+                type_error(fl_ctx, "aset!", "sequence", fl_apply_e);
             }
-            POPN(2);
-            Stack[SP-1] = v;
+            POPN(fl_ctx, 2);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
         OP(OP_FOR)
-            s  = tofixnum(Stack[SP-3], "for");
-            hi = tofixnum(Stack[SP-2], "for");
-            //f = Stack[SP-1];
-            v = FL_UNSPECIFIED;
-            SP += 2;
-            n = SP;
+            s  = tofixnum(fl_ctx, fl_ctx->Stack[fl_ctx->SP-3], "for");
+            hi = tofixnum(fl_ctx, fl_ctx->Stack[fl_ctx->SP-2], "for");
+            //f = fl_ctx->Stack[fl_ctx->SP-1];
+            fl_apply_v = FL_UNSPECIFIED(fl_ctx);
+            fl_ctx->SP += 2;
+            n = fl_ctx->SP;
             for(; s <= hi; s++) {
-                Stack[SP-2] = Stack[SP-3];
-                Stack[SP-1] = fixnum(s);
-                v = apply_cl(1);
-                SP = n;
+                fl_ctx->Stack[fl_ctx->SP-2] = fl_ctx->Stack[fl_ctx->SP-3];
+                fl_ctx->Stack[fl_ctx->SP-1] = fixnum(s);
+                fl_apply_v = apply_cl(fl_ctx, 1);
+                fl_ctx->SP = n;
             }
-            POPN(4);
-            Stack[SP-1] = v;
+            POPN(fl_ctx, 4);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
 
-        OP(OP_LOADT) PUSH(FL_T); NEXT_OP;
-        OP(OP_LOADF) PUSH(FL_F); NEXT_OP;
-        OP(OP_LOADNIL) PUSH(NIL); NEXT_OP;
-        OP(OP_LOAD0) PUSH(fixnum(0)); NEXT_OP;
-        OP(OP_LOAD1) PUSH(fixnum(1)); NEXT_OP;
-        OP(OP_LOADI8) s = (int8_t)*ip++; PUSH(fixnum(s)); NEXT_OP;
+        OP(OP_LOADT) PUSH(fl_ctx, fl_ctx->T); NEXT_OP;
+        OP(OP_LOADF) PUSH(fl_ctx, fl_ctx->F); NEXT_OP;
+        OP(OP_LOADNIL) PUSH(fl_ctx, fl_ctx->NIL); NEXT_OP;
+        OP(OP_LOAD0) PUSH(fl_ctx, fixnum(0)); NEXT_OP;
+        OP(OP_LOAD1) PUSH(fl_ctx, fixnum(1)); NEXT_OP;
+        OP(OP_LOADI8) s = (int8_t)*ip++; PUSH(fl_ctx, fixnum(s)); NEXT_OP;
         OP(OP_LOADV)
-            v = fn_vals(Stack[bp-1]);
-            assert(*ip < vector_size(v));
-            v = vector_elt(v, *ip); ip++;
-            PUSH(v);
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            assert(*ip < vector_size(fl_apply_v));
+            fl_apply_v = vector_elt(fl_apply_v, *ip); ip++;
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_LOADVL)
-            v = fn_vals(Stack[bp-1]);
-            v = vector_elt(v, GET_INT32(ip)); ip+=4;
-            PUSH(v);
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            fl_apply_v = vector_elt(fl_apply_v, GET_INT32(ip)); ip+=4;
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_LOADGL)
-            v = fn_vals(Stack[bp-1]);
-            v = vector_elt(v, GET_INT32(ip)); ip+=4;
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            fl_apply_v = vector_elt(fl_apply_v, GET_INT32(ip)); ip+=4;
             goto do_loadg;
         OP(OP_LOADG)
-            v = fn_vals(Stack[bp-1]);
-            assert(*ip < vector_size(v));
-            v = vector_elt(v, *ip); ip++;
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            assert(*ip < vector_size(fl_apply_v));
+            fl_apply_v = vector_elt(fl_apply_v, *ip); ip++;
         do_loadg:
-            assert(issymbol(v));
-            sym = (symbol_t*)ptr(v);
+            assert(issymbol(fl_apply_v));
+            sym = (symbol_t*)ptr(fl_apply_v);
             if (sym->binding == UNBOUND)
-                fl_raise(fl_list2(UnboundError, v));
-            PUSH(sym->binding);
+                fl_raise(fl_ctx, fl_list2(fl_ctx, fl_ctx->UnboundError, fl_apply_v));
+            PUSH(fl_ctx, sym->binding);
             NEXT_OP;
 
         OP(OP_SETGL)
-            v = fn_vals(Stack[bp-1]);
-            v = vector_elt(v, GET_INT32(ip)); ip+=4;
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            fl_apply_v = vector_elt(fl_apply_v, GET_INT32(ip)); ip+=4;
             goto do_setg;
         OP(OP_SETG)
-            v = fn_vals(Stack[bp-1]);
-            assert(*ip < vector_size(v));
-            v = vector_elt(v, *ip); ip++;
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            assert(*ip < vector_size(fl_apply_v));
+            fl_apply_v = vector_elt(fl_apply_v, *ip); ip++;
         do_setg:
-            assert(issymbol(v));
-            sym = (symbol_t*)ptr(v);
-            v = Stack[SP-1];
+            assert(issymbol(fl_apply_v));
+            sym = (symbol_t*)ptr(fl_apply_v);
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
             if (!isconstant(sym))
-                sym->binding = v;
+                sym->binding = fl_apply_v;
             NEXT_OP;
 
         OP(OP_LOADA)
             i = *ip++;
-            v = Stack[bp+i];
-            PUSH(v);
+            fl_apply_v = fl_ctx->Stack[bp+i];
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_LOADA0)
-            v = Stack[bp];
-            PUSH(v);
+            fl_apply_v = fl_ctx->Stack[bp];
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_LOADA1)
-            v = Stack[bp+1];
-            PUSH(v);
+            fl_apply_v = fl_ctx->Stack[bp+1];
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_LOADAL)
             i = GET_INT32(ip); ip+=4;
-            v = Stack[bp+i];
-            PUSH(v);
+            fl_apply_v = fl_ctx->Stack[bp+i];
+            PUSH(fl_ctx, fl_apply_v);
             NEXT_OP;
         OP(OP_SETA)
-            v = Stack[SP-1];
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
             i = *ip++;
-            Stack[bp+i] = v;
+            fl_ctx->Stack[bp+i] = fl_apply_v;
             NEXT_OP;
         OP(OP_SETAL)
-            v = Stack[SP-1];
+            fl_apply_v = fl_ctx->Stack[fl_ctx->SP-1];
             i = GET_INT32(ip); ip+=4;
-            Stack[bp+i] = v;
+            fl_ctx->Stack[bp+i] = fl_apply_v;
             NEXT_OP;
 
         OP(OP_BOX)
             i = *ip++;
-            v = mk_cons();
-            car_(v) = Stack[bp+i];
-            cdr_(v) = NIL;
-            Stack[bp+i] = v;
+            fl_apply_v = mk_cons(fl_ctx);
+            car_(fl_apply_v) = fl_ctx->Stack[bp+i];
+            cdr_(fl_apply_v) = fl_ctx->NIL;
+            fl_ctx->Stack[bp+i] = fl_apply_v;
             NEXT_OP;
         OP(OP_BOXL)
             i = GET_INT32(ip); ip+=4;
-            v = mk_cons();
-            car_(v) = Stack[bp+i];
-            cdr_(v) = NIL;
-            Stack[bp+i] = v;
+            fl_apply_v = mk_cons(fl_ctx);
+            car_(fl_apply_v) = fl_ctx->Stack[bp+i];
+            cdr_(fl_apply_v) = fl_ctx->NIL;
+            fl_ctx->Stack[bp+i] = fl_apply_v;
             NEXT_OP;
 
         OP(OP_SHIFT)
             i = *ip++;
-            Stack[SP-1-i] = Stack[SP-1];
-            SP -= i;
+            fl_ctx->Stack[fl_ctx->SP-1-i] = fl_ctx->Stack[fl_ctx->SP-1];
+            fl_ctx->SP -= i;
             NEXT_OP;
 
         OP(OP_LOADC)
             i = *ip++;
-            v = Stack[bp+nargs];
-            assert(isvector(v));
-            assert(i < vector_size(v));
-            PUSH(vector_elt(v, i));
+            fl_apply_v = fl_ctx->Stack[bp+nargs];
+            assert(isvector(fl_apply_v));
+            assert(i < vector_size(fl_apply_v));
+            PUSH(fl_ctx, vector_elt(fl_apply_v, i));
             NEXT_OP;
 
         OP(OP_LOADC0)
-            PUSH(vector_elt(Stack[bp+nargs], 0));
+            PUSH(fl_ctx, vector_elt(fl_ctx->Stack[bp+nargs], 0));
             NEXT_OP;
         OP(OP_LOADC1)
-            PUSH(vector_elt(Stack[bp+nargs], 1));
+            PUSH(fl_ctx, vector_elt(fl_ctx->Stack[bp+nargs], 1));
             NEXT_OP;
 
         OP(OP_LOADCL)
             i = GET_INT32(ip); ip+=4;
-            v = Stack[bp+nargs];
-            PUSH(vector_elt(v, i));
+            fl_apply_v = fl_ctx->Stack[bp+nargs];
+            PUSH(fl_ctx, vector_elt(fl_apply_v, i));
             NEXT_OP;
 
         OP(OP_CLOSURE)
             n = *ip++;
             assert(n > 0);
-            pv = alloc_words(n + 1);
-            v = tagptr(pv, TAG_VECTOR);
-            pv[0] = fixnum(n);
+            fl_apply_pv = alloc_words(fl_ctx, n + 1);
+            fl_apply_v = tagptr(fl_apply_pv, TAG_VECTOR);
+            fl_apply_pv[0] = fixnum(n);
             i = 1;
             do {
-                pv[i] = Stack[SP-n + i-1];
+                fl_apply_pv[i] = fl_ctx->Stack[fl_ctx->SP-n + i-1];
                 i++;
             } while (i<=n);
-            POPN(n);
-            PUSH(v);
+            POPN(fl_ctx, n);
+            PUSH(fl_ctx, fl_apply_v);
 #ifdef MEMDEBUG2
-            pv = alloc_words(4);
+            fl_apply_pv = alloc_words(fl_ctx, 4);
 #else
-            if ((value_t*)curheap > ((value_t*)lim)-2)
-                gc(0);
-            pv = (value_t*)curheap;
-            curheap += (4*sizeof(value_t));
+            if ((value_t*)fl_ctx->curheap > ((value_t*)fl_ctx->lim)-2)
+                gc(fl_ctx, 0);
+            fl_apply_pv = (value_t*)fl_ctx->curheap;
+            fl_ctx->curheap += (4*sizeof(value_t));
 #endif
-            e = Stack[SP-2];  // closure to copy
-            assert(isfunction(e));
-            pv[0] = ((value_t*)ptr(e))[0];
-            pv[1] = ((value_t*)ptr(e))[1];
-            pv[2] = Stack[SP-1];  // env
-            pv[3] = ((value_t*)ptr(e))[3];
-            POPN(1);
-            Stack[SP-1] = tagptr(pv, TAG_FUNCTION);
+            fl_apply_e = fl_ctx->Stack[fl_ctx->SP-2];  // closure to copy
+            assert(isfunction(fl_apply_e));
+            fl_apply_pv[0] = ((value_t*)ptr(fl_apply_e))[0];
+            fl_apply_pv[1] = ((value_t*)ptr(fl_apply_e))[1];
+            fl_apply_pv[2] = fl_ctx->Stack[fl_ctx->SP-1];  // env
+            fl_apply_pv[3] = ((value_t*)ptr(fl_apply_e))[3];
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = tagptr(fl_apply_pv, TAG_FUNCTION);
             NEXT_OP;
 
         OP(OP_TRYCATCH)
-            v = do_trycatch();
-            POPN(1);
-            Stack[SP-1] = v;
+            fl_apply_v = do_trycatch(fl_ctx);
+            POPN(fl_ctx, 1);
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_apply_v;
             NEXT_OP;
 
         OP(OP_OPTARGS)
             i = GET_INT32(ip); ip+=4;
             n = GET_INT32(ip); ip+=4;
             if (nargs < i)
-                lerror(ArgError, "apply: too few arguments");
+                lerror(fl_ctx, fl_ctx->ArgError, "apply: too few arguments");
             if ((int32_t)n > 0) {
                 if (nargs > n)
-                    lerror(ArgError, "apply: too many arguments");
+                    lerror(fl_ctx, fl_ctx->ArgError, "apply: too many arguments");
             }
             else n = -n;
             if (n > nargs) {
                 n -= nargs;
-                SP += n;
-                Stack[SP-1] = Stack[SP-n-1];
-                Stack[SP-2] = nargs+n;
-                Stack[SP-3] = Stack[SP-n-3];
-                Stack[SP-4] = Stack[SP-n-4];
-                curr_frame = SP;
+                fl_ctx->SP += n;
+                fl_ctx->Stack[fl_ctx->SP-1] = fl_ctx->Stack[fl_ctx->SP-n-1];
+                fl_ctx->Stack[fl_ctx->SP-2] = nargs+n;
+                fl_ctx->Stack[fl_ctx->SP-3] = fl_ctx->Stack[fl_ctx->SP-n-3];
+                fl_ctx->Stack[fl_ctx->SP-4] = fl_ctx->Stack[fl_ctx->SP-n-4];
+                fl_ctx->curr_frame = fl_ctx->SP;
                 for(i=0; i < n; i++) {
-                    Stack[bp+nargs+i] = UNBOUND;
+                    fl_ctx->Stack[bp+nargs+i] = UNBOUND;
                 }
                 nargs += n;
             }
             NEXT_OP;
         OP(OP_KEYARGS)
-            v = fn_vals(Stack[bp-1]);
-            v = vector_elt(v, 0);
+            fl_apply_v = fn_vals(fl_ctx->Stack[bp-1]);
+            fl_apply_v = vector_elt(fl_apply_v, 0);
             i = GET_INT32(ip); ip+=4;
             n = GET_INT32(ip); ip+=4;
             s = GET_INT32(ip); ip+=4;
-            nargs = process_keys(v, i, n, llabs(s)-(i+n), bp, nargs, s<0);
+            nargs = process_keys(fl_ctx, fl_apply_v, i, n, llabs(s)-(i+n), bp, nargs, s<0);
             NEXT_OP;
 
 #ifndef USE_COMPUTED_GOTO
@@ -2075,45 +2026,45 @@ static uint32_t compute_maxstack(uint8_t *code, size_t len, int bswap)
 }
 
 // top = top frame pointer to start at
-static value_t _stacktrace(uint32_t top)
+static value_t _stacktrace(fl_context_t *fl_ctx, uint32_t top)
 {
     uint32_t bp, sz;
-    value_t v, lst = NIL;
-    fl_gc_handle(&lst);
+    value_t v, lst = fl_ctx->NIL;
+    fl_gc_handle(fl_ctx, &lst);
     while (top > 0) {
-        sz = Stack[top-2]+1;
+        sz = fl_ctx->Stack[top-2]+1;
         bp = top-4-sz;
-        v = alloc_vector(sz, 0);
-        memcpy(&vector_elt(v,0), &Stack[bp], sz*sizeof(value_t));
-        lst = fl_cons(v, lst);
-        top = Stack[top-3];
+        v = alloc_vector(fl_ctx, sz, 0);
+        memcpy(&vector_elt(v,0), &fl_ctx->Stack[bp], sz*sizeof(value_t));
+        lst = fl_cons(fl_ctx, v, lst);
+        top = fl_ctx->Stack[top-3];
     }
-    fl_free_gc_handles(1);
+    fl_free_gc_handles(fl_ctx, 1);
     return lst;
 }
 
 // builtins -------------------------------------------------------------------
 
-void assign_global_builtins(builtinspec_t *b)
+void assign_global_builtins(fl_context_t *fl_ctx, const builtinspec_t *b)
 {
     while (b->name != NULL) {
-        setc(symbol(b->name), cbuiltin(b->name, b->fptr));
+        setc(symbol(fl_ctx, b->name), cbuiltin(fl_ctx, b->name, b->fptr));
         b++;
     }
 }
 
-static value_t fl_function(value_t *args, uint32_t nargs)
+static value_t fl_function(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs == 1 && issymbol(args[0]))
-        return fl_builtin(args, nargs);
+        return fl_builtin(fl_ctx, args, nargs);
     if (nargs < 2 || nargs > 4)
-        argcount("function", nargs, 2);
-    if (!fl_isstring(args[0]))
-        type_error("function", "string", args[0]);
+        argcount(fl_ctx, "function", nargs, 2);
+    if (!fl_isstring(fl_ctx, args[0]))
+        type_error(fl_ctx, "function", "string", args[0]);
     if (!isvector(args[1]))
-        type_error("function", "vector", args[1]);
+        type_error(fl_ctx, "function", "vector", args[1]);
     cvalue_t *arr = (cvalue_t*)ptr(args[0]);
-    cv_pin(arr);
+    cv_pin(fl_ctx, arr);
     char *data = (char*)cv_data(arr);
     int swap = 0;
     if ((uint8_t)data[4] >= N_OPCODES) {
@@ -2129,12 +2080,12 @@ static value_t fl_function(value_t *args, uint32_t nargs)
     }
     uint32_t ms = compute_maxstack((uint8_t*)data, cv_len(arr), swap);
     PUT_INT32(data, ms);
-    function_t *fn = (function_t*)alloc_words(4);
+    function_t *fn = (function_t*)alloc_words(fl_ctx, 4);
     value_t fv = tagptr(fn, TAG_FUNCTION);
     fn->bcode = args[0];
     fn->vals = args[1];
-    fn->env = NIL;
-    fn->name = LAMBDA;
+    fn->env = fl_ctx->NIL;
+    fn->name = fl_ctx->LAMBDA;
     if (nargs > 2) {
         if (issymbol(args[2])) {
             fn->name = args[2];
@@ -2145,175 +2096,194 @@ static value_t fl_function(value_t *args, uint32_t nargs)
             fn->env = args[2];
             if (nargs > 3) {
                 if (!issymbol(args[3]))
-                    type_error("function", "symbol", args[3]);
+                    type_error(fl_ctx, "function", "symbol", args[3]);
                 fn->name = args[3];
             }
         }
-        if (isgensym(fn->name))
-            lerror(ArgError, "function: name should not be a gensym");
+        if (isgensym(fl_ctx, fn->name))
+            lerror(fl_ctx, fl_ctx->ArgError, "function: name should not be a gensym");
     }
     return fv;
 }
 
-static value_t fl_function_code(value_t *args, uint32_t nargs)
+static value_t fl_function_code(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("function:code", nargs, 1);
+    argcount(fl_ctx, "function:code", nargs, 1);
     value_t v = args[0];
-    if (!isclosure(v)) type_error("function:code", "function", v);
+    if (!isclosure(v)) type_error(fl_ctx, "function:code", "function", v);
     return fn_bcode(v);
 }
-static value_t fl_function_vals(value_t *args, uint32_t nargs)
+static value_t fl_function_vals(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("function:vals", nargs, 1);
+    argcount(fl_ctx, "function:vals", nargs, 1);
     value_t v = args[0];
-    if (!isclosure(v)) type_error("function:vals", "function", v);
+    if (!isclosure(v)) type_error(fl_ctx, "function:vals", "function", v);
     return fn_vals(v);
 }
-static value_t fl_function_env(value_t *args, uint32_t nargs)
+static value_t fl_function_env(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("function:env", nargs, 1);
+    argcount(fl_ctx, "function:env", nargs, 1);
     value_t v = args[0];
-    if (!isclosure(v)) type_error("function:env", "function", v);
+    if (!isclosure(v)) type_error(fl_ctx, "function:env", "function", v);
     return fn_env(v);
 }
-static value_t fl_function_name(value_t *args, uint32_t nargs)
+static value_t fl_function_name(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("function:name", nargs, 1);
+    argcount(fl_ctx, "function:name", nargs, 1);
     value_t v = args[0];
-    if (!isclosure(v)) type_error("function:name", "function", v);
+    if (!isclosure(v)) type_error(fl_ctx, "function:name", "function", v);
     return fn_name(v);
 }
 
-value_t fl_copylist(value_t *args, u_int32_t nargs)
+value_t fl_copylist(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("copy-list", nargs, 1);
-    return copy_list(args[0]);
+    argcount(fl_ctx, "copy-list", nargs, 1);
+    return copy_list(fl_ctx, args[0]);
 }
 
-value_t fl_append(value_t *args, u_int32_t nargs)
+value_t fl_append(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs == 0)
-        return NIL;
-    value_t first=NIL, lst, lastcons=NIL;
-    fl_gc_handle(&first);
-    fl_gc_handle(&lastcons);
+        return fl_ctx->NIL;
+    value_t first=fl_ctx->NIL, lst, lastcons=fl_ctx->NIL;
+    fl_gc_handle(fl_ctx, &first);
+    fl_gc_handle(fl_ctx, &lastcons);
     uint32_t i=0;
     while (1) {
         lst = args[i++];
         if (i >= nargs) break;
         if (iscons(lst)) {
-            lst = copy_list(lst);
-            if (first == NIL)
+            lst = copy_list(fl_ctx, lst);
+            if (first == fl_ctx->NIL)
                 first = lst;
             else
                 cdr_(lastcons) = lst;
 #ifdef MEMDEBUG2
             lastcons = lst;
-            while (cdr_(lastcons) != NIL)
+            while (cdr_(lastcons) != fl_ctx->NIL)
                 lastcons = cdr_(lastcons);
 #else
-            lastcons = tagptr((((cons_t*)curheap)-1), TAG_CONS);
+            lastcons = tagptr((((cons_t*)fl_ctx->curheap)-1), TAG_CONS);
 #endif
         }
-        else if (lst != NIL) {
-            type_error("append", "cons", lst);
+        else if (lst != fl_ctx->NIL) {
+            type_error(fl_ctx, "append", "cons", lst);
         }
     }
-    if (first == NIL)
+    if (first == fl_ctx->NIL)
         first = lst;
     else
         cdr_(lastcons) = lst;
-    fl_free_gc_handles(2);
+    fl_free_gc_handles(fl_ctx, 2);
     return first;
 }
 
-value_t fl_liststar(value_t *args, u_int32_t nargs)
+value_t fl_liststar(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs == 1) return args[0];
-    else if (nargs == 0) argcount("list*", nargs, 1);
-    return _list(args, nargs, 1);
+    else if (nargs == 0) argcount(fl_ctx, "list*", nargs, 1);
+    return _list(fl_ctx, args, nargs, 1);
 }
 
-value_t fl_stacktrace(value_t *args, u_int32_t nargs)
+value_t fl_stacktrace(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     (void)args;
-    argcount("stacktrace", nargs, 0);
-    return _stacktrace(fl_throwing_frame ? fl_throwing_frame : curr_frame);
+    argcount(fl_ctx, "stacktrace", nargs, 0);
+    return _stacktrace(fl_ctx, fl_ctx->throwing_frame ? fl_ctx->throwing_frame : fl_ctx->curr_frame);
 }
 
-value_t fl_map1(value_t *args, u_int32_t nargs)
+value_t fl_map1(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 2)
-        lerror(ArgError, "map: too few arguments");
-    if (!iscons(args[1])) return NIL;
+        lerror(fl_ctx, fl_ctx->ArgError, "map: too few arguments");
+    if (!iscons(args[1])) return fl_ctx->NIL;
     value_t v;
-    uint32_t first, last, argSP = args-Stack;
-    assert(args >= Stack && argSP < N_STACK);
+    uint32_t first, last, argSP = args-fl_ctx->Stack;
+    assert(args >= fl_ctx->Stack && argSP < fl_ctx->N_STACK);
     if (nargs == 2) {
-        if (SP+4 > N_STACK) grow_stack();
-        PUSH(Stack[argSP]);
-        PUSH(car_(Stack[argSP+1]));
-        v = _applyn(1);
-        POPN(2);
-        PUSH(v);
-        v = mk_cons();
-        car_(v) = POP(); cdr_(v) = NIL;
-        PUSH(v);
-        PUSH(v);
-        first = SP-2;
-        last = SP-1;
-        Stack[argSP+1] = cdr_(Stack[argSP+1]);
-        while (iscons(Stack[argSP+1])) {
-            PUSH(Stack[argSP]);
-            PUSH(car_(Stack[argSP+1]));
-            v = _applyn(1);
-            POPN(2);
-            PUSH(v);
-            v = mk_cons();
-            car_(v) = POP(); cdr_(v) = NIL;
-            cdr_(Stack[last]) = v;
-            Stack[last] = v;
-            Stack[argSP+1] = cdr_(Stack[argSP+1]);
+        if (fl_ctx->SP+4 > fl_ctx->N_STACK) grow_stack(fl_ctx);
+        PUSH(fl_ctx, fl_ctx->Stack[argSP]);
+        PUSH(fl_ctx, car_(fl_ctx->Stack[argSP+1]));
+        v = _applyn(fl_ctx, 1);
+        POPN(fl_ctx, 2);
+        PUSH(fl_ctx, v);
+        v = mk_cons(fl_ctx);
+        car_(v) = POP(fl_ctx); cdr_(v) = fl_ctx->NIL;
+        PUSH(fl_ctx, v);
+        PUSH(fl_ctx, v);
+        first = fl_ctx->SP-2;
+        last = fl_ctx->SP-1;
+        fl_ctx->Stack[argSP+1] = cdr_(fl_ctx->Stack[argSP+1]);
+        while (iscons(fl_ctx->Stack[argSP+1])) {
+            PUSH(fl_ctx, fl_ctx->Stack[argSP]);
+            PUSH(fl_ctx, car_(fl_ctx->Stack[argSP+1]));
+            v = _applyn(fl_ctx, 1);
+            POPN(fl_ctx, 2);
+            PUSH(fl_ctx, v);
+            v = mk_cons(fl_ctx);
+            car_(v) = POP(fl_ctx); cdr_(v) = fl_ctx->NIL;
+            cdr_(fl_ctx->Stack[last]) = v;
+            fl_ctx->Stack[last] = v;
+            fl_ctx->Stack[argSP+1] = cdr_(fl_ctx->Stack[argSP+1]);
         }
-        POPN(2);
+        POPN(fl_ctx, 2);
     }
     else {
         size_t i;
-        while (SP+nargs+1 > N_STACK) grow_stack();
-        PUSH(Stack[argSP]);
+        while (fl_ctx->SP+nargs+1 > fl_ctx->N_STACK) grow_stack(fl_ctx);
+        PUSH(fl_ctx, fl_ctx->Stack[argSP]);
         for(i=1; i < nargs; i++) {
-            PUSH(car(Stack[argSP+i]));
-            Stack[argSP+i] = cdr_(Stack[argSP+i]);
+            PUSH(fl_ctx, car(fl_ctx, fl_ctx->Stack[argSP+i]));
+            fl_ctx->Stack[argSP+i] = cdr_(fl_ctx->Stack[argSP+i]);
         }
-        v = _applyn(nargs-1);
-        POPN(nargs);
-        PUSH(v);
-        v = mk_cons();
-        car_(v) = POP(); cdr_(v) = NIL;
-        PUSH(v);
-        PUSH(v);
-        first = SP-2;
-        last = SP-1;
-        while (iscons(Stack[argSP+1])) {
-            PUSH(Stack[argSP]);
+        v = _applyn(fl_ctx, nargs-1);
+        POPN(fl_ctx, nargs);
+        PUSH(fl_ctx, v);
+        v = mk_cons(fl_ctx);
+        car_(v) = POP(fl_ctx); cdr_(v) = fl_ctx->NIL;
+        PUSH(fl_ctx, v);
+        PUSH(fl_ctx, v);
+        first = fl_ctx->SP-2;
+        last = fl_ctx->SP-1;
+        while (iscons(fl_ctx->Stack[argSP+1])) {
+            PUSH(fl_ctx, fl_ctx->Stack[argSP]);
             for(i=1; i < nargs; i++) {
-                PUSH(car(Stack[argSP+i]));
-                Stack[argSP+i] = cdr_(Stack[argSP+i]);
+                PUSH(fl_ctx, car(fl_ctx, fl_ctx->Stack[argSP+i]));
+                fl_ctx->Stack[argSP+i] = cdr_(fl_ctx->Stack[argSP+i]);
             }
-            v = _applyn(nargs-1);
-            POPN(nargs);
-            PUSH(v);
-            v = mk_cons();
-            car_(v) = POP(); cdr_(v) = NIL;
-            cdr_(Stack[last]) = v;
-            Stack[last] = v;
+            v = _applyn(fl_ctx, nargs-1);
+            POPN(fl_ctx, nargs);
+            PUSH(fl_ctx, v);
+            v = mk_cons(fl_ctx);
+            car_(v) = POP(fl_ctx); cdr_(v) = fl_ctx->NIL;
+            cdr_(fl_ctx->Stack[last]) = v;
+            fl_ctx->Stack[last] = v;
         }
-        POPN(2);
+        POPN(fl_ctx, 2);
     }
-    return Stack[first];
+    return fl_ctx->Stack[first];
 }
 
-static builtinspec_t core_builtin_info[] = {
+value_t fl_foreach(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
+{
+    if (nargs != 2)
+        lerror(fl_ctx, fl_ctx->ArgError, "for-each: expected 2 arguments");
+    uint32_t argSP = args-fl_ctx->Stack;
+    assert(args >= fl_ctx->Stack && argSP < fl_ctx->N_STACK);
+    if (fl_ctx->SP+2 > fl_ctx->N_STACK) grow_stack(fl_ctx);
+    PUSH(fl_ctx, fl_ctx->T);
+    PUSH(fl_ctx, fl_ctx->T);
+    while (iscons(fl_ctx->Stack[argSP+1])) {
+        fl_ctx->Stack[fl_ctx->SP-2] = fl_ctx->Stack[argSP];
+        fl_ctx->Stack[fl_ctx->SP-1] = car_(fl_ctx->Stack[argSP+1]);
+        _applyn(fl_ctx, 1);
+        fl_ctx->Stack[argSP+1] = cdr_(fl_ctx->Stack[argSP+1]);
+    }
+    POPN(fl_ctx, 2);
+    return fl_ctx->T;
+}
+
+static const builtinspec_t core_builtin_info[] = {
     { "function", fl_function },
     { "function:code", fl_function_code },
     { "function:vals", fl_function_vals },
@@ -2327,163 +2297,177 @@ static builtinspec_t core_builtin_info[] = {
     { "append", fl_append },
     { "list*", fl_liststar },
     { "map", fl_map1 },
+    { "for-each", fl_foreach },
     { NULL, NULL }
 };
 
 // initialization -------------------------------------------------------------
 
-extern void builtins_init(void);
-extern void comparehash_init(void);
+extern void builtins_init(fl_context_t *fl_ctx);
+extern void comparehash_init(fl_context_t *fl_ctx);
 
-static void lisp_init(size_t initial_heapsize)
+static void lisp_init(fl_context_t *fl_ctx, size_t initial_heapsize)
 {
     int i;
 
     libsupport_init();
 
-    heapsize = initial_heapsize;
+    fl_ctx->SP = 0;
+    fl_ctx->curr_frame = 0;
+    fl_ctx->N_GCHND = 0;
+    fl_ctx->readstate = NULL;
+    fl_ctx->gensym_ctr = 0;
+    fl_ctx->gsnameno = 0;
+
+#ifdef MEMDEBUG2
+    fl_ctx->tochain = NULL;
+    fl_ctx->n_allocd = 0;
+#endif
+
+    fl_ctx->heapsize = initial_heapsize;
 
-    fromspace = (unsigned char*)LLT_ALLOC(heapsize);
+    fl_ctx->fromspace = (unsigned char*)LLT_ALLOC(fl_ctx->heapsize);
 #ifdef MEMDEBUG
-    tospace   = NULL;
+    fl_ctx->tospace   = NULL;
 #else
-    tospace   = (unsigned char*)LLT_ALLOC(heapsize);
+    fl_ctx->tospace   = (unsigned char*)LLT_ALLOC(fl_ctx->heapsize);
 #endif
-    curheap = fromspace;
-    lim = curheap+heapsize-sizeof(cons_t);
-    consflags = bitvector_new(heapsize/sizeof(cons_t), 1);
-    htable_new(&printconses, 32);
-    comparehash_init();
-    N_STACK = 262144;
-    Stack = (value_t*)malloc(N_STACK*sizeof(value_t));
-    CHECK_ALIGN8(Stack);
-
-    FL_NIL = NIL = builtin(OP_THE_EMPTY_LIST);
-    FL_T = builtin(OP_BOOL_CONST_T);
-    FL_F = builtin(OP_BOOL_CONST_F);
-    FL_EOF = builtin(OP_EOF_OBJECT);
-    LAMBDA = symbol("lambda");        FUNCTION = symbol("function");
-    QUOTE = symbol("quote");          TRYCATCH = symbol("trycatch");
-    BACKQUOTE = symbol("quasiquote");       COMMA = symbol("unquote");
-    COMMAAT = symbol("unquote-splicing");   COMMADOT = symbol("unquote-nsplicing");
-    IOError = symbol("io-error");     ParseError = symbol("parse-error");
-    TypeError = symbol("type-error"); ArgError = symbol("arg-error");
-    UnboundError = symbol("unbound-error");
-    KeyError = symbol("key-error");   OutOfMemoryError = symbol("memory-error");
-    BoundsError = symbol("bounds-error");
-    DivideError = symbol("divide-error");
-    EnumerationError = symbol("enumeration-error");
-    Error = symbol("error");          pairsym = symbol("pair");
-    symbolsym = symbol("symbol");     fixnumsym = symbol("fixnum");
-    vectorsym = symbol("vector");     builtinsym = symbol("builtin");
-    booleansym = symbol("boolean");   nullsym = symbol("null");
-    definesym = symbol("define");     defmacrosym = symbol("define-macro");
-    forsym = symbol("for");
-    setqsym = symbol("set!");         evalsym = symbol("eval");
-    vu8sym = symbol("vu8");           fnsym = symbol("fn");
-    nulsym = symbol("nul");           alarmsym = symbol("alarm");
-    backspacesym = symbol("backspace"); tabsym = symbol("tab");
-    linefeedsym = symbol("linefeed"); vtabsym = symbol("vtab");
-    pagesym = symbol("page");         returnsym = symbol("return");
-    escsym = symbol("esc");           spacesym = symbol("space");
-    deletesym = symbol("delete");     newlinesym = symbol("newline");
-    tsym = symbol("t"); Tsym = symbol("T");
-    fsym = symbol("f"); Fsym = symbol("F");
-    set(printprettysym=symbol("*print-pretty*"), FL_T);
-    set(printreadablysym=symbol("*print-readably*"), FL_T);
-    set(printwidthsym=symbol("*print-width*"), fixnum(SCR_WIDTH));
-    set(printlengthsym=symbol("*print-length*"), FL_F);
-    set(printlevelsym=symbol("*print-level*"), FL_F);
-    builtins_table_sym = symbol("*builtins*");
-    fl_lasterror = NIL;
+    fl_ctx->curheap = fl_ctx->fromspace;
+    fl_ctx->lim = fl_ctx->curheap+fl_ctx->heapsize-sizeof(cons_t);
+    fl_ctx->consflags = bitvector_new(fl_ctx->heapsize/sizeof(cons_t), 1);
+    fl_print_init(fl_ctx);
+    comparehash_init(fl_ctx);
+    fl_ctx->N_STACK = 262144;
+    fl_ctx->Stack = (value_t*)malloc(fl_ctx->N_STACK*sizeof(value_t));
+    CHECK_ALIGN8(fl_ctx->Stack);
+
+    fl_ctx->NIL = builtin(OP_THE_EMPTY_LIST);
+    fl_ctx->T = builtin(OP_BOOL_CONST_T);
+    fl_ctx->F = builtin(OP_BOOL_CONST_F);
+    fl_ctx->FL_EOF = builtin(OP_EOF_OBJECT);
+    fl_ctx->LAMBDA = symbol(fl_ctx, "lambda");        fl_ctx->FUNCTION = symbol(fl_ctx, "function");
+    fl_ctx->QUOTE = symbol(fl_ctx, "quote");          fl_ctx->TRYCATCH = symbol(fl_ctx, "trycatch");
+    fl_ctx->BACKQUOTE = symbol(fl_ctx, "quasiquote");       fl_ctx->COMMA = symbol(fl_ctx, "unquote");
+    fl_ctx->COMMAAT = symbol(fl_ctx, "unquote-splicing");   fl_ctx->COMMADOT = symbol(fl_ctx, "unquote-nsplicing");
+    fl_ctx->IOError = symbol(fl_ctx, "io-error");     fl_ctx->ParseError = symbol(fl_ctx, "parse-error");
+    fl_ctx->TypeError = symbol(fl_ctx, "type-error"); fl_ctx->ArgError = symbol(fl_ctx, "arg-error");
+    fl_ctx->UnboundError = symbol(fl_ctx, "unbound-error");
+    fl_ctx->KeyError = symbol(fl_ctx, "key-error");   fl_ctx->OutOfMemoryError = symbol(fl_ctx, "memory-error");
+    fl_ctx->BoundsError = symbol(fl_ctx, "bounds-error");
+    fl_ctx->DivideError = symbol(fl_ctx, "divide-error");
+    fl_ctx->EnumerationError = symbol(fl_ctx, "enumeration-error");
+    fl_ctx->pairsym = symbol(fl_ctx, "pair");
+    fl_ctx->symbolsym = symbol(fl_ctx, "symbol");     fl_ctx->fixnumsym = symbol(fl_ctx, "fixnum");
+    fl_ctx->vectorsym = symbol(fl_ctx, "vector");     fl_ctx->builtinsym = symbol(fl_ctx, "builtin");
+    fl_ctx->booleansym = symbol(fl_ctx, "boolean");   fl_ctx->nullsym = symbol(fl_ctx, "null");
+    fl_ctx->definesym = symbol(fl_ctx, "define");     fl_ctx->defmacrosym = symbol(fl_ctx, "define-macro");
+    fl_ctx->forsym = symbol(fl_ctx, "for");
+    fl_ctx->setqsym = symbol(fl_ctx, "set!");         fl_ctx->evalsym = symbol(fl_ctx, "eval");
+    fl_ctx->vu8sym = symbol(fl_ctx, "vu8");           fl_ctx->fnsym = symbol(fl_ctx, "fn");
+    fl_ctx->nulsym = symbol(fl_ctx, "nul");           fl_ctx->alarmsym = symbol(fl_ctx, "alarm");
+    fl_ctx->backspacesym = symbol(fl_ctx, "backspace"); fl_ctx->tabsym = symbol(fl_ctx, "tab");
+    fl_ctx->linefeedsym = symbol(fl_ctx, "linefeed"); fl_ctx->vtabsym = symbol(fl_ctx, "vtab");
+    fl_ctx->pagesym = symbol(fl_ctx, "page");         fl_ctx->returnsym = symbol(fl_ctx, "return");
+    fl_ctx->escsym = symbol(fl_ctx, "esc");           fl_ctx->spacesym = symbol(fl_ctx, "space");
+    fl_ctx->deletesym = symbol(fl_ctx, "delete");     fl_ctx->newlinesym = symbol(fl_ctx, "newline");
+    fl_ctx->tsym = symbol(fl_ctx, "t"); fl_ctx->Tsym = symbol(fl_ctx, "T");
+    fl_ctx->fsym = symbol(fl_ctx, "f"); fl_ctx->Fsym = symbol(fl_ctx, "F");
+    set(fl_ctx->printprettysym=symbol(fl_ctx, "*print-pretty*"), fl_ctx->T);
+    set(fl_ctx->printreadablysym=symbol(fl_ctx, "*print-readably*"), fl_ctx->T);
+    set(fl_ctx->printwidthsym=symbol(fl_ctx, "*print-width*"), fixnum(fl_ctx->SCR_WIDTH));
+    set(fl_ctx->printlengthsym=symbol(fl_ctx, "*print-length*"), fl_ctx->F);
+    set(fl_ctx->printlevelsym=symbol(fl_ctx, "*print-level*"), fl_ctx->F);
+    fl_ctx->builtins_table_sym = symbol(fl_ctx, "*builtins*");
+    fl_ctx->lasterror = fl_ctx->NIL;
     i = 0;
     for (i=OP_EQ; i <= OP_ASET; i++) {
-        setc(symbol(builtin_names[i]), builtin(i));
+        setc(symbol(fl_ctx, builtin_names[i]), builtin(i));
     }
-    setc(symbol("eq"), builtin(OP_EQ));
-    setc(symbol("procedure?"), builtin(OP_FUNCTIONP));
-    setc(symbol("top-level-bound?"), builtin(OP_BOUNDP));
+    setc(symbol(fl_ctx, "eq"), builtin(OP_EQ));
+    setc(symbol(fl_ctx, "procedure?"), builtin(OP_FUNCTIONP));
+    setc(symbol(fl_ctx, "top-level-bound?"), builtin(OP_BOUNDP));
 
 #if defined(_OS_LINUX_)
-    set(symbol("*os-name*"), symbol("linux"));
+    set(symbol(fl_ctx, "*os-name*"), symbol(fl_ctx, "linux"));
 #elif defined(_OS_WINDOWS_)
-    set(symbol("*os-name*"), symbol("win32"));
+    set(symbol(fl_ctx, "*os-name*"), symbol(fl_ctx, "win32"));
 #elif defined(_OS_DARWIN_)
-    set(symbol("*os-name*"), symbol("macos"));
+    set(symbol(fl_ctx, "*os-name*"), symbol(fl_ctx, "macos"));
 #else
-    set(symbol("*os-name*"), symbol("unknown"));
+    set(symbol(fl_ctx, "*os-name*"), symbol(fl_ctx, "unknown"));
 #endif
 
-    the_empty_vector = tagptr(alloc_words(1), TAG_VECTOR);
-    vector_setsize(the_empty_vector, 0);
+    fl_ctx->jl_sym = symbol(fl_ctx, "julia_value");
+
+    fl_ctx->the_empty_vector = tagptr(alloc_words(fl_ctx, 1), TAG_VECTOR);
+    vector_setsize(fl_ctx->the_empty_vector, 0);
 
-    cvalues_init();
+    cvalues_init(fl_ctx);
 
     char exename[1024];
     size_t exe_size = sizeof(exename) / sizeof(exename[0]);
     if ( uv_exepath(exename, &exe_size) == 0 ) {
-        setc(symbol("*install-dir*"), cvalue_static_cstring(strdup(dirname(exename))));
+        setc(symbol(fl_ctx, "*install-dir*"), cvalue_static_cstring(fl_ctx, strdup(dirname(exename))));
     }
 
-   memory_exception_value = fl_list2(OutOfMemoryError,
-                                      cvalue_static_cstring("out of memory"));
+    fl_ctx->memory_exception_value = fl_list2(fl_ctx, fl_ctx->OutOfMemoryError,
+                                              cvalue_static_cstring(fl_ctx, "out of memory"));
+
+    assign_global_builtins(fl_ctx, core_builtin_info);
 
-    assign_global_builtins(core_builtin_info);
+    fl_read_init(fl_ctx);
 
-    builtins_init();
+    builtins_init(fl_ctx);
 }
 
 // top level ------------------------------------------------------------------
 
-value_t fl_toplevel_eval(value_t expr)
+value_t fl_toplevel_eval(fl_context_t *fl_ctx, value_t expr)
 {
-    return fl_applyn(1, symbol_value(evalsym), expr);
+    return fl_applyn(fl_ctx, 1, symbol_value(fl_ctx->evalsym), expr);
 }
 
-extern void fl_init_julia_extensions(void);
+extern void fl_init_julia_extensions(fl_context_t *fl_ctx);
 
-void fl_init(size_t initial_heapsize)
+void fl_init(fl_context_t *fl_ctx, size_t initial_heapsize)
 {
-    lisp_init(initial_heapsize);
-    fl_init_julia_extensions();
+    lisp_init(fl_ctx, initial_heapsize);
+    fl_init_julia_extensions(fl_ctx);
 }
 
-extern fltype_t *iostreamtype;
-
-int fl_load_system_image_str(char *str, size_t len)
+int fl_load_system_image_str(fl_context_t *fl_ctx, char *str, size_t len)
 {
-    value_t img = cvalue(iostreamtype, sizeof(ios_t));
+    value_t img = cvalue(fl_ctx, fl_ctx->iostreamtype, sizeof(ios_t));
     ios_t *pi = value2c(ios_t*, img);
     ios_static_buffer(pi, str, len);
 
-    return fl_load_system_image(img);
+    return fl_load_system_image(fl_ctx, img);
 }
 
-
-int fl_load_system_image(value_t sys_image_iostream)
+int fl_load_system_image(fl_context_t *fl_ctx, value_t sys_image_iostream)
 {
     value_t e;
     int saveSP;
     symbol_t *sym;
 
-    PUSH(sys_image_iostream);
-    saveSP = SP;
-    FL_TRY {
+    PUSH(fl_ctx, sys_image_iostream);
+    saveSP = fl_ctx->SP;
+    FL_TRY(fl_ctx) {
         while (1) {
-            e = fl_read_sexpr(Stack[SP-1]);
-            if (ios_eof(value2c(ios_t*,Stack[SP-1]))) break;
+            e = fl_read_sexpr(fl_ctx, fl_ctx->Stack[fl_ctx->SP-1]);
+            if (ios_eof(value2c(ios_t*,fl_ctx->Stack[fl_ctx->SP-1]))) break;
             if (isfunction(e)) {
                 // stage 0 format: series of thunks
-                PUSH(e);
-                (void)_applyn(0);
-                SP = saveSP;
+                PUSH(fl_ctx, e);
+                (void)_applyn(fl_ctx, 0);
+                fl_ctx->SP = saveSP;
             }
             else {
                 // stage 1 format: list alternating symbol/value
                 while (iscons(e)) {
-                    sym = tosymbol(car_(e), "bootstrap");
+                    sym = tosymbol(fl_ctx, car_(e), "bootstrap");
                     e = cdr_(e);
-                    (void)tocons(e, "bootstrap");
+                    (void)tocons(fl_ctx, e, "bootstrap");
                     sym->binding = car_(e);
                     e = cdr_(e);
                 }
@@ -2491,14 +2475,14 @@ int fl_load_system_image(value_t sys_image_iostream)
             }
         }
     }
-    FL_CATCH {
+    FL_CATCH(fl_ctx) {
         ios_puts("fatal error during bootstrap:\n", ios_stderr);
-        fl_print(ios_stderr, fl_lasterror);
+        fl_print(fl_ctx, ios_stderr, fl_ctx->lasterror);
         ios_putc('\n', ios_stderr);
         return 1;
     }
-    ios_close(value2c(ios_t*,Stack[SP-1]));
-    POPN(1);
+    ios_close(value2c(ios_t*,fl_ctx->Stack[fl_ctx->SP-1]));
+    POPN(fl_ctx, 1);
     return 0;
 }
 
diff --git a/src/flisp/flisp.h b/src/flisp/flisp.h
index d4fc16b0fa07d..d9ea2e5b8a5d1 100644
--- a/src/flisp/flisp.h
+++ b/src/flisp/flisp.h
@@ -11,7 +11,7 @@
 //#define MEMDEBUG
 //#define MEMDEBUG2
 
-typedef uptrint_t value_t;
+typedef uintptr_t value_t;
 typedef int_t fixnum_t;
 #if NBITS==64
 #define T_FIXNUM T_INT64
@@ -23,14 +23,14 @@ typedef int_t fixnum_t;
 #ifdef __cplusplus
 extern "C" {
 #endif
-
+typedef struct _fl_context_t fl_context_t;
 typedef struct {
     value_t car;
     value_t cdr;
 } cons_t;
 
 typedef struct _symbol_t {
-    uptrint_t flags;
+    uintptr_t flags;
     value_t binding;   // global value binding
     struct _fltype_t *type;
     uint32_t hash;
@@ -38,10 +38,7 @@ typedef struct _symbol_t {
     // below fields are private
     struct _symbol_t *left;
     struct _symbol_t *right;
-    union {
-        char name[1];
-        void *_pad;    // ensure field aligned to pointer size
-    };
+    JL_ATTRIBUTE_ALIGN_PTRSIZE(char name[]);
 } symbol_t;
 
 typedef struct {
@@ -64,7 +61,7 @@ typedef struct {
 #define tag(x) ((x)&0x7)
 #define ptr(x) ((void*)((x)&(~(value_t)0x7)))
 #define tagptr(p,t) (((value_t)(p)) | (t))
-#define fixnum(x) ((value_t)(((uptrint_t)(x))<<2))
+#define fixnum(x) ((value_t)(((uintptr_t)(x))<<2))
 #define numval(x)  (((fixnum_t)(x))>>2)
 #if NBITS==64
 #define fits_fixnum(x) (((x)>>61) == 0 || (~((x)>>61)) == 0)
@@ -101,8 +98,8 @@ typedef struct {
 // functions ending in _ are unsafe, faster versions
 #define car_(v) (((cons_t*)ptr(v))->car)
 #define cdr_(v) (((cons_t*)ptr(v))->cdr)
-#define car(v)  (tocons((v),"car")->car)
-#define cdr(v)  (tocons((v),"cdr")->cdr)
+#define car(fl_ctx, v)  (tocons(fl_ctx, (v),"car")->car)
+#define cdr(fl_ctx, v)  (tocons(fl_ctx, (v),"cdr")->cdr)
 #define fn_bcode(f) (((value_t*)ptr(f))[0])
 #define fn_vals(f) (((value_t*)ptr(f))[1])
 #define fn_env(f) (((value_t*)ptr(f))[2])
@@ -115,19 +112,19 @@ typedef struct {
 #define iskeyword(s) ((s)->flags&0x2)
 #define symbol_value(s) (((symbol_t*)ptr(s))->binding)
 #ifdef MEMDEBUG2
-#define ismanaged(v) (!issymbol(v) && !isfixnum(v) && ((v)>(N_OPCODES<<3)) && !iscbuiltin(v))
+#define ismanaged(ctx, v) (!issymbol(v) && !isfixnum(v) && ((v)>(N_OPCODES<<3)) && !iscbuiltin(ctx, v))
 #else
-#define ismanaged(v) ((((unsigned char*)ptr(v)) >= fromspace) && \
-                      (((unsigned char*)ptr(v)) < fromspace+heapsize))
+#define ismanaged(ctx, v) ((((unsigned char*)ptr(v)) >= ctx->fromspace) && \
+                           (((unsigned char*)ptr(v)) < ctx->fromspace + ctx->heapsize))
 #endif
-#define isgensym(x)  (issymbol(x) && ismanaged(x))
+#define isgensym(ctx, x)  (issymbol(x) && ismanaged(ctx, x))
 
 #define isfunction(x) (tag(x) == TAG_FUNCTION && (x) > (N_BUILTINS<<3))
 #define isclosure(x) isfunction(x)
-#define iscbuiltin(x) (iscvalue(x) && (cv_class((cvalue_t*)ptr(x))==builtintype))
+#define iscbuiltin(ctx, x) (iscvalue(x) && (cv_class((cvalue_t*)ptr(x))==ctx->builtintype))
 
-void fl_gc_handle(value_t *pv);
-void fl_free_gc_handles(uint32_t n);
+void fl_gc_handle(fl_context_t *fl_ctx, value_t *pv);
+void fl_free_gc_handles(fl_context_t *fl_ctx, uint32_t n);
 
 #include "opcodes.h"
 
@@ -139,39 +136,35 @@ void fl_free_gc_handles(uint32_t n);
 
 #define N_BUILTINS ((int)N_OPCODES)
 
-extern value_t FL_NIL, FL_T, FL_F, FL_EOF;
-
-#define FL_UNSPECIFIED FL_T
+#define FL_UNSPECIFIED(fl_ctx) fl_ctx->T
 
 /* read, eval, print main entry points */
-value_t fl_read_sexpr(value_t f);
-void fl_print(ios_t *f, value_t v);
-value_t fl_toplevel_eval(value_t expr);
-value_t fl_apply(value_t f, value_t l);
-value_t fl_applyn(uint32_t n, value_t f, ...);
-
-extern value_t printprettysym, printreadablysym, printwidthsym;
+value_t fl_read_sexpr(fl_context_t *fl_ctx, value_t f);
+void fl_print(fl_context_t *fl_ctx, ios_t *f, value_t v);
+value_t fl_toplevel_eval(fl_context_t *fl_ctx, value_t expr);
+value_t fl_apply(fl_context_t *fl_ctx, value_t f, value_t l);
+value_t fl_applyn(fl_context_t *fl_ctx, uint32_t n, value_t f, ...);
 
 /* object model manipulation */
-value_t fl_cons(value_t a, value_t b);
-value_t fl_list2(value_t a, value_t b);
-value_t fl_listn(size_t n, ...);
-value_t symbol(char *str);
-char *symbol_name(value_t v);
+value_t fl_cons(fl_context_t *fl_ctx, value_t a, value_t b);
+value_t fl_list2(fl_context_t *fl_ctx, value_t a, value_t b);
+value_t fl_listn(fl_context_t *fl_ctx, size_t n, ...);
+value_t symbol(fl_context_t *fl_ctx, char *str);
+char *symbol_name(fl_context_t *fl_ctx, value_t v);
 int fl_is_keyword_name(const char *str, size_t len);
-value_t alloc_vector(size_t n, int init);
+value_t alloc_vector(fl_context_t *fl_ctx, size_t n, int init);
 size_t llength(value_t v);
-value_t fl_compare(value_t a, value_t b);  // -1, 0, or 1
-value_t fl_equal(value_t a, value_t b);    // T or nil
-int equal_lispvalue(value_t a, value_t b);
-uptrint_t hash_lispvalue(value_t a);
-int isnumtok_base(char *tok, value_t *pval, int base);
+value_t fl_compare(fl_context_t *fl_ctx, value_t a, value_t b);  // -1, 0, or 1
+value_t fl_equal(fl_context_t *fl_ctx, value_t a, value_t b);    // T or nil
+int equal_lispvalue(fl_context_t *fl_ctx, value_t a, value_t b);
+uintptr_t hash_lispvalue(fl_context_t *fl_ctx, value_t a);
+int isnumtok_base(fl_context_t *fl_ctx, char *tok, value_t *pval, int base);
 
 /* safe casts */
-cons_t *tocons(value_t v, char *fname);
-symbol_t *tosymbol(value_t v, char *fname);
-fixnum_t tofixnum(value_t v, char *fname);
-char *tostring(value_t v, char *fname);
+cons_t *tocons(fl_context_t *fl_ctx, value_t v, char *fname);
+symbol_t *tosymbol(fl_context_t *fl_ctx, value_t v, char *fname);
+fixnum_t tofixnum(fl_context_t *fl_ctx, value_t v, char *fname);
+char *tostring(fl_context_t *fl_ctx, value_t v, char *fname);
 
 /* error handling */
 typedef struct _ectx_t {
@@ -183,68 +176,55 @@ typedef struct _ectx_t {
     struct _ectx_t *prev;
 } fl_exception_context_t;
 
-extern fl_exception_context_t *fl_ctx;
-extern uint32_t fl_throwing_frame;
-extern value_t fl_lasterror;
-
-#define FL_TRY_EXTERN                                                   \
+#define FL_TRY_EXTERN(fl_ctx)                                           \
   fl_exception_context_t _ctx; int l__tr, l__ca;                        \
-  fl_savestate(&_ctx); fl_ctx = &_ctx;                                  \
+  fl_savestate(fl_ctx, &_ctx); fl_ctx->exc_ctx = &_ctx;                      \
   if (!setjmp(_ctx.buf))                                                \
-    for (l__tr=1; l__tr; l__tr=0, (void)(fl_ctx=fl_ctx->prev))
+      for (l__tr=1; l__tr; l__tr=0, (void)(fl_ctx->exc_ctx=fl_ctx->exc_ctx->prev))
 
-#define FL_CATCH_EXTERN \
-  else \
-    for(l__ca=1; l__ca; l__ca=0, fl_restorestate(&_ctx))
+#define FL_CATCH_EXTERN(fl_ctx)                                         \
+    else                                                                \
+        for(l__ca=1; l__ca; l__ca=0, fl_restorestate(fl_ctx, &_ctx))
 
 #if defined(_OS_WINDOWS_)
-__declspec(noreturn) void lerrorf(value_t e, char *format, ...);
-__declspec(noreturn) void lerror(value_t e, const char *msg);
-__declspec(noreturn) void fl_raise(value_t e);
-__declspec(noreturn) void type_error(char *fname, char *expected, value_t got);
-__declspec(noreturn) void bounds_error(char *fname, value_t arr, value_t ind);
+__declspec(noreturn) void lerrorf(fl_context_t *fl_ctx, value_t e, char *format, ...);
+__declspec(noreturn) void lerror(fl_context_t *fl_ctx, value_t e, const char *msg);
+__declspec(noreturn) void fl_raise(fl_context_t *fl_ctx, value_t e);
+__declspec(noreturn) void type_error(fl_context_t *fl_ctx, char *fname, char *expected, value_t got);
+__declspec(noreturn) void bounds_error(fl_context_t *fl_ctx, char *fname, value_t arr, value_t ind);
 #else
-void lerrorf(value_t e, char *format, ...) __attribute__ ((__noreturn__));
-void lerror(value_t e, const char *msg) __attribute__ ((__noreturn__));
-void fl_raise(value_t e) __attribute__ ((__noreturn__));
-void type_error(char *fname, char *expected, value_t got) __attribute__ ((__noreturn__));
-void bounds_error(char *fname, value_t arr, value_t ind) __attribute__ ((__noreturn__));
+void lerrorf(fl_context_t *fl_ctx, value_t e, char *format, ...) __attribute__ ((__noreturn__));
+void lerror(fl_context_t *fl_ctx, value_t e, const char *msg) __attribute__ ((__noreturn__));
+void fl_raise(fl_context_t *fl_ctx, value_t e) __attribute__ ((__noreturn__));
+void type_error(fl_context_t *fl_ctx, char *fname, char *expected, value_t got) __attribute__ ((__noreturn__));
+void bounds_error(fl_context_t *fl_ctx, char *fname, value_t arr, value_t ind) __attribute__ ((__noreturn__));
 #endif
 
-void fl_savestate(fl_exception_context_t *_ctx);
-void fl_restorestate(fl_exception_context_t *_ctx);
-
-extern value_t ArgError, IOError, KeyError, OutOfMemoryError, EnumerationError;
-extern value_t UnboundError;
-
-static inline void argcount(char *fname, uint32_t nargs, uint32_t c)
-{
-    if (__unlikely(nargs != c))
-        lerrorf(ArgError,"%s: too %s arguments", fname, nargs<c ? "few":"many");
-}
+void fl_savestate(fl_context_t *fl_ctx, fl_exception_context_t *_ctx);
+void fl_restorestate(fl_context_t *fl_ctx, fl_exception_context_t *_ctx);
 
 typedef struct {
-    void (*print)(value_t self, ios_t *f);
-    void (*relocate)(value_t oldv, value_t newv);
-    void (*finalize)(value_t self);
-    void (*print_traverse)(value_t self);
+    void (*print)(fl_context_t *fl_ctx, value_t self, ios_t *f);
+    void (*relocate)(fl_context_t *fl_ctx, value_t oldv, value_t newv);
+    void (*finalize)(fl_context_t *fl_ctx, value_t self);
+    void (*print_traverse)(fl_context_t *fl_ctx, value_t self);
 } cvtable_t;
 
 /* functions needed to implement the value interface (cvtable_t) */
-value_t relocate_lispvalue(value_t v);
-void print_traverse(value_t v);
-void fl_print_chr(char c, ios_t *f);
-void fl_print_str(char *s, ios_t *f);
-void fl_print_child(ios_t *f, value_t v);
+value_t relocate_lispvalue(fl_context_t *fl_ctx, value_t v);
+void print_traverse(fl_context_t *fl_ctx, value_t v);
+void fl_print_chr(fl_context_t *fl_ctx, char c, ios_t *f);
+void fl_print_str(fl_context_t *fl_ctx, char *s, ios_t *f);
+void fl_print_child(fl_context_t *fl_ctx, ios_t *f, value_t v);
 
-typedef int (*cvinitfunc_t)(struct _fltype_t*, value_t, void*);
+typedef int (*cvinitfunc_t)(fl_context_t *fl_ctx, struct _fltype_t*, value_t, void*);
 
 typedef struct _fltype_t {
     value_t type;
     numerictype_t numtype;
     size_t size;
     size_t elsz;
-    cvtable_t *vtable;
+    const cvtable_t *vtable;
     struct _fltype_t *eltype;  // for arrays
     struct _fltype_t *artype;  // (array this)
     int marked;
@@ -280,14 +260,14 @@ typedef struct {
 
 #define CV_OWNED_BIT  0x1
 #define CV_PARENT_BIT 0x2
-#define owned(cv)      ((uptrint_t)(cv)->type & CV_OWNED_BIT)
-#define hasparent(cv)  ((uptrint_t)(cv)->type & CV_PARENT_BIT)
+#define owned(cv)      ((uintptr_t)(cv)->type & CV_OWNED_BIT)
+#define hasparent(cv)  ((uintptr_t)(cv)->type & CV_PARENT_BIT)
 #define isinlined(cv)  ((cv)->data == &(cv)->_space[0])
-#define cv_class(cv)   ((fltype_t*)(((uptrint_t)(cv)->type)&~3))
+#define cv_class(cv)   ((fltype_t*)(((uintptr_t)(cv)->type)&~3))
 #define cv_len(cv)     ((cv)->len)
 #define cv_type(cv)    (cv_class(cv)->type)
 #define cv_data(cv)    ((cv)->data)
-#define cv_isstr(cv)   (cv_class(cv)->eltype == bytetype)
+#define cv_isstr(fl_ctx, cv)   (cv_class(cv)->eltype == fl_ctx->bytetype)
 #define cv_isPOD(cv)   (cv_class(cv)->init != NULL)
 
 #define cvalue_data(v) cv_data((cvalue_t*)ptr(v))
@@ -320,78 +300,193 @@ typedef size_t   fl_size_t;
 typedef double   fl_double_t;
 typedef float    fl_float_t;
 
-typedef value_t (*builtin_t)(value_t*, uint32_t);
-
-extern value_t QUOTE;
-extern value_t int8sym, uint8sym, int16sym, uint16sym, int32sym, uint32sym;
-extern value_t int64sym, uint64sym;
-extern value_t ptrdiffsym, sizesym, bytesym, wcharsym;
-extern value_t arraysym, cfunctionsym, voidsym, pointersym;
-extern value_t stringtypesym, wcstringtypesym, emptystringsym;
-extern value_t floatsym, doublesym;
-extern fltype_t *bytetype, *wchartype;
-extern fltype_t *stringtype, *wcstringtype;
-extern fltype_t *builtintype;
-
-value_t cvalue(fltype_t *type, size_t sz);
-void add_finalizer(cvalue_t *cv);
-void cv_autorelease(cvalue_t *cv);
-void cv_pin(cvalue_t *cv);
-size_t ctype_sizeof(value_t type, int *palign);
-value_t cvalue_copy(value_t v);
-value_t cvalue_from_data(fltype_t *type, void *data, size_t sz);
-value_t cvalue_from_ref(fltype_t *type, void *ptr, size_t sz, value_t parent);
-value_t cbuiltin(char *name, builtin_t f);
+typedef value_t (*builtin_t)(fl_context_t*, value_t*, uint32_t);
+
+value_t cvalue(fl_context_t *fl_ctx, fltype_t *type, size_t sz);
+void add_finalizer(fl_context_t *fl_ctx, cvalue_t *cv);
+void cv_autorelease(fl_context_t *fl_ctx, cvalue_t *cv);
+void cv_pin(fl_context_t *fl_ctx, cvalue_t *cv);
+size_t ctype_sizeof(fl_context_t *fl_ctx, value_t type, int *palign);
+value_t cvalue_copy(fl_context_t *fl_ctx, value_t v);
+value_t cvalue_from_data(fl_context_t *fl_ctx, fltype_t *type, void *data, size_t sz);
+value_t cvalue_from_ref(fl_context_t *fl_ctx, fltype_t *type, void *ptr, size_t sz, value_t parent);
+value_t cbuiltin(fl_context_t *fl_ctx, char *name, builtin_t f);
 size_t cvalue_arraylen(value_t v);
-value_t size_wrap(size_t sz);
-size_t tosize(value_t n, char *fname);
-value_t cvalue_string(size_t sz);
-value_t cvalue_static_cstrn(const char *str, size_t n);
-value_t cvalue_static_cstring(const char *str);
-value_t string_from_cstr(char *str);
-value_t string_from_cstrn(char *str, size_t n);
-int fl_isstring(value_t v);
-int fl_isnumber(value_t v);
-int fl_isgensym(value_t v);
-int fl_isiostream(value_t v);
-ios_t *fl_toiostream(value_t v, char *fname);
+value_t size_wrap(fl_context_t *fl_ctx, size_t sz);
+size_t tosize(fl_context_t *fl_ctx, value_t n, char *fname);
+value_t cvalue_string(fl_context_t *fl_ctx, size_t sz);
+value_t cvalue_static_cstrn(fl_context_t *fl_ctx, const char *str, size_t n);
+value_t cvalue_static_cstring(fl_context_t *fl_ctx, const char *str);
+value_t string_from_cstr(fl_context_t *fl_ctx, char *str);
+value_t string_from_cstrn(fl_context_t *fl_ctx, char *str, size_t n);
+int fl_isstring(fl_context_t *fl_ctx, value_t v);
+int fl_isnumber(fl_context_t *fl_ctx, value_t v);
+int fl_isgensym(fl_context_t *fl_ctx, value_t v);
+int fl_isiostream(fl_context_t *fl_ctx, value_t v);
+ios_t *fl_toiostream(fl_context_t *fl_ctx, value_t v, char *fname);
 value_t cvalue_compare(value_t a, value_t b);
-int numeric_compare(value_t a, value_t b, int eq, int eqnans, char *fname);
+int numeric_compare(fl_context_t *fl_ctx, value_t a, value_t b, int eq, int eqnans, char *fname);
 
-void to_sized_ptr(value_t v, char *fname, char **pdata, size_t *psz);
+void to_sized_ptr(fl_context_t *fl_ctx, value_t v, char *fname, char **pdata, size_t *psz);
 
-fltype_t *get_type(value_t t);
-fltype_t *get_array_type(value_t eltype);
-fltype_t *define_opaque_type(value_t sym, size_t sz, cvtable_t *vtab,
+fltype_t *get_type(fl_context_t *fl_ctx, value_t t);
+fltype_t *get_array_type(fl_context_t *fl_ctx, value_t eltype);
+fltype_t *define_opaque_type(value_t sym, size_t sz, const cvtable_t *vtab,
                              cvinitfunc_t init);
 
-value_t mk_double(fl_double_t n);
-value_t mk_float(fl_float_t n);
-value_t mk_uint32(uint32_t n);
-value_t mk_uint64(uint64_t n);
-value_t mk_wchar(int32_t n);
-value_t return_from_uint64(uint64_t Uaccum);
-value_t return_from_int64(int64_t Saccum);
+value_t mk_double(fl_context_t *fl_ctx, fl_double_t n);
+value_t mk_float(fl_context_t *fl_ctx, fl_float_t n);
+value_t mk_uint32(fl_context_t *fl_ctx, uint32_t n);
+value_t mk_uint64(fl_context_t *fl_ctx, uint64_t n);
+value_t mk_wchar(fl_context_t *fl_ctx, int32_t n);
+value_t return_from_uint64(fl_context_t *fl_ctx, uint64_t Uaccum);
+value_t return_from_int64(fl_context_t *fl_ctx, int64_t Saccum);
 
 typedef struct {
     char *name;
     builtin_t fptr;
 } builtinspec_t;
 
-void assign_global_builtins(builtinspec_t *b);
+void assign_global_builtins(fl_context_t *fl_ctx, const builtinspec_t *b);
 
 /* builtins */
-value_t fl_hash(value_t *args, u_int32_t nargs);
-value_t cvalue_byte(value_t *args, uint32_t nargs);
-value_t cvalue_wchar(value_t *args, uint32_t nargs);
+value_t fl_hash(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+value_t cvalue_byte(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+value_t cvalue_wchar(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
 
-void fl_init(size_t initial_heapsize);
-int fl_load_system_image(value_t ios);
-int fl_load_system_image_str(char* str, size_t len);
+void fl_init(fl_context_t *fl_ctx, size_t initial_heapsize);
+int fl_load_system_image(fl_context_t *fl_ctx, value_t ios);
+int fl_load_system_image_str(fl_context_t *fl_ctx, char* str, size_t len);
 
 /* julia extensions */
-DLLEXPORT int jl_id_char(uint32_t wc);
-DLLEXPORT int jl_id_start_char(uint32_t wc);
+JL_DLLEXPORT int jl_id_char(uint32_t wc);
+JL_DLLEXPORT int jl_id_start_char(uint32_t wc);
+
+struct _fl_context_t {
+    symbol_t *symtab;
+    value_t NIL, T, F, FL_EOF, QUOTE;
+    value_t int8sym, uint8sym, int16sym, uint16sym, int32sym, uint32sym;
+    value_t int64sym, uint64sym;
+
+    value_t ptrdiffsym, sizesym, bytesym, wcharsym;
+    value_t floatsym, doublesym;
+    value_t stringtypesym, wcstringtypesym;
+    value_t emptystringsym;
+
+    value_t arraysym, cfunctionsym, voidsym, pointersym;
+
+    htable_t TypeTable;
+    htable_t reverse_dlsym_lookup_table;
+
+    fltype_t *int8type, *uint8type;
+    fltype_t *int16type, *uint16type;
+    fltype_t *int32type, *uint32type;
+    fltype_t *int64type, *uint64type;
+    fltype_t *ptrdifftype, *sizetype;
+    fltype_t *floattype, *doubletype;
+    fltype_t *bytetype, *wchartype;
+    fltype_t *stringtype, *wcstringtype;
+    fltype_t *builtintype;
+
+    htable_t equal_eq_hashtable;
+
+    value_t tablesym;
+    fltype_t *tabletype;
+    cvtable_t table_vtable;
+
+    uint32_t readtoktype;
+    value_t readtokval;
+    char readbuf[256];
+
+    htable_t printconses;
+    uint32_t printlabel;
+    int print_pretty;
+    int print_princ;
+    fixnum_t print_length;
+    fixnum_t print_level;
+    fixnum_t P_LEVEL;
+    int SCR_WIDTH;
+    int HPOS, VPOS;
+
+    value_t iostreamsym, rdsym, wrsym, apsym, crsym, truncsym;
+    value_t instrsym, outstrsym;
+    fltype_t *iostreamtype;
+
+    size_t malloc_pressure;
+    cvalue_t **Finalizers;
+    size_t nfinalizers;
+    size_t maxfinalizers;
+
+    uint32_t N_STACK;
+    value_t *Stack;
+    uint32_t SP;
+    uint32_t curr_frame;
+
+#define FL_N_GC_HANDLES 8192
+    value_t *GCHandleStack[FL_N_GC_HANDLES];
+    uint32_t N_GCHND;
+
+    value_t IOError, ParseError, TypeError, ArgError, UnboundError, KeyError;
+    value_t OutOfMemoryError, DivideError, BoundsError, EnumerationError;
+    value_t printwidthsym, printreadablysym, printprettysym, printlengthsym;
+    value_t printlevelsym, builtins_table_sym;
+
+    value_t LAMBDA, IF, TRYCATCH;
+    value_t BACKQUOTE, COMMA, COMMAAT, COMMADOT, FUNCTION;
+
+    value_t pairsym, symbolsym, fixnumsym, vectorsym, builtinsym, vu8sym;
+    value_t definesym, defmacrosym, forsym, setqsym;
+    value_t tsym, Tsym, fsym, Fsym, booleansym, nullsym, evalsym, fnsym;
+    // for reading characters
+    value_t nulsym, alarmsym, backspacesym, tabsym, linefeedsym, newlinesym;
+    value_t vtabsym, pagesym, returnsym, escsym, spacesym, deletesym;
+
+    struct _fl_readstate_t *readstate;
+
+    unsigned char *fromspace;
+    unsigned char *tospace;
+    unsigned char *curheap;
+    unsigned char *lim;
+    uint32_t heapsize;//bytes
+    uint32_t *consflags;
+
+    // error utilities --------------------------------------------------
+
+    // saved execution state for an unwind target
+    fl_exception_context_t *exc_ctx;
+    uint32_t throwing_frame;  // active frame when exception was thrown
+    value_t lasterror;
+
+    uint32_t gensym_ctr;
+    // two static buffers for gensym printing so there can be two
+    // gensym names available at a time, mostly for compare()
+    char gsname[2][16];
+    int gsnameno;
+
+    void *tochain;
+    long long n_allocd;
+
+    value_t the_empty_vector;
+    value_t memory_exception_value;
+
+    int gc_grew;
+    cons_t *apply_c;
+    value_t *apply_pv;
+    int64_t apply_accum;
+    value_t apply_func, apply_v, apply_e;
+
+    value_t jl_sym;
+    // persistent buffer (avoid repeated malloc/free)
+    // for julia_extensions.c: normalize
+    size_t jlbuflen;
+    void *jlbuf;
+};
+
+static inline void argcount(fl_context_t *fl_ctx, char *fname, uint32_t nargs, uint32_t c)
+{
+    if (__unlikely(nargs != c))
+        lerrorf(fl_ctx, fl_ctx->ArgError,"%s: too %s arguments", fname, nargs<c ? "few":"many");
+}
 
 #ifdef __cplusplus
 }
diff --git a/src/flisp/flmain.c b/src/flisp/flmain.c
index e9f00476b4697..401905cc7a7a8 100644
--- a/src/flisp/flmain.c
+++ b/src/flisp/flmain.c
@@ -8,30 +8,33 @@
 extern "C" {
 #endif
 
-static value_t argv_list(int argc, char *argv[])
+static value_t argv_list(fl_context_t *fl_ctx, int argc, char *argv[])
 {
     int i;
-    value_t lst=FL_NIL, temp;
-    fl_gc_handle(&lst);
-    fl_gc_handle(&temp);
+    value_t lst=fl_ctx->NIL, temp;
+    fl_gc_handle(fl_ctx, &lst);
+    fl_gc_handle(fl_ctx, &temp);
     for(i=argc-1; i >= 0; i--) {
-        temp = cvalue_static_cstring(argv[i]);
-        lst = fl_cons(temp, lst);
+        temp = cvalue_static_cstring(fl_ctx, argv[i]);
+        lst = fl_cons(fl_ctx, temp, lst);
     }
-    fl_free_gc_handles(2);
+    fl_free_gc_handles(fl_ctx, 2);
     return lst;
 }
 
-extern value_t fl_file(value_t *args, uint32_t nargs);
+extern value_t fl_file(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+
+static fl_context_t fl_global_ctx;
 
 int main(int argc, char *argv[])
 {
     char fname_buf[1024];
+    fl_context_t *fl_ctx = &fl_global_ctx;
 
-    fl_init(512*1024);
+    fl_init(fl_ctx, 512*1024);
 
     fname_buf[0] = '\0';
-    value_t str = symbol_value(symbol("*install-dir*"));
+    value_t str = symbol_value(symbol(fl_ctx, "*install-dir*"));
     char *exedir = (char*)(str == UNBOUND ? NULL : cvalue_data(str));
     if (exedir != NULL) {
         strcat(fname_buf, exedir);
@@ -40,23 +43,23 @@ int main(int argc, char *argv[])
     strcat(fname_buf, "flisp.boot");
 
     value_t args[2];
-    fl_gc_handle(&args[0]);
-    fl_gc_handle(&args[1]);
-    FL_TRY_EXTERN {
-        args[0] = cvalue_static_cstring(fname_buf);
-        args[1] = symbol(":read");
-        value_t f = fl_file(&args[0], 2);
-        fl_free_gc_handles(2);
+    fl_gc_handle(fl_ctx, &args[0]);
+    fl_gc_handle(fl_ctx, &args[1]);
+    FL_TRY_EXTERN(fl_ctx) {
+        args[0] = cvalue_static_cstring(fl_ctx, fname_buf);
+        args[1] = symbol(fl_ctx, ":read");
+        value_t f = fl_file(fl_ctx, &args[0], 2);
+        fl_free_gc_handles(fl_ctx, 2);
 
-        if (fl_load_system_image(f))
+        if (fl_load_system_image(fl_ctx, f))
             return 1;
 
-        (void)fl_applyn(1, symbol_value(symbol("__start")),
-                        argv_list(argc, argv));
+        (void)fl_applyn(fl_ctx, 1, symbol_value(symbol(fl_ctx, "__start")),
+                        argv_list(fl_ctx, argc, argv));
     }
-    FL_CATCH_EXTERN {
+    FL_CATCH_EXTERN(fl_ctx) {
         ios_puts("fatal error:\n", ios_stderr);
-        fl_print(ios_stderr, fl_lasterror);
+        fl_print(fl_ctx, ios_stderr, fl_ctx->lasterror);
         ios_putc('\n', ios_stderr);
         return 1;
     }
diff --git a/src/flisp/iostream.c b/src/flisp/iostream.c
index 3eb2895e4ecef..111f9c4c4019b 100644
--- a/src/flisp/iostream.c
+++ b/src/flisp/iostream.c
@@ -11,24 +11,22 @@
 extern "C" {
 #endif
 
-static value_t iostreamsym, rdsym, wrsym, apsym, crsym, truncsym;
-static value_t instrsym, outstrsym;
-fltype_t *iostreamtype;
-
-void print_iostream(value_t v, ios_t *f)
+void print_iostream(fl_context_t *fl_ctx, value_t v, ios_t *f)
 {
     (void)v;
-    fl_print_str("#<io stream>", f);
+    fl_print_str(fl_ctx, "#<io stream>", f);
 }
 
-void free_iostream(value_t self)
+void free_iostream(fl_context_t *fl_ctx, value_t self)
 {
+    (void)fl_ctx;
     ios_t *s = value2c(ios_t*, self);
     ios_close(s);
 }
 
-void relocate_iostream(value_t oldv, value_t newv)
+void relocate_iostream(fl_context_t *fl_ctx, value_t oldv, value_t newv)
 {
+    (void)fl_ctx;
     ios_t *olds = value2c(ios_t*, oldv);
     ios_t *news = value2c(ios_t*, newv);
     if (news->buf == &olds->local[0]) {
@@ -36,349 +34,349 @@ void relocate_iostream(value_t oldv, value_t newv)
     }
 }
 
-cvtable_t iostream_vtable = { print_iostream, relocate_iostream,
-                              free_iostream, NULL };
+const cvtable_t iostream_vtable = { print_iostream, relocate_iostream,
+                                    free_iostream, NULL };
 
-int fl_isiostream(value_t v)
+int fl_isiostream(fl_context_t *fl_ctx, value_t v)
 {
-    return iscvalue(v) && cv_class((cvalue_t*)ptr(v)) == iostreamtype;
+    return iscvalue(v) && cv_class((cvalue_t*)ptr(v)) == fl_ctx->iostreamtype;
 }
 
-value_t fl_iostreamp(value_t *args, uint32_t nargs)
+value_t fl_iostreamp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("iostream?", nargs, 1);
-    return fl_isiostream(args[0]) ? FL_T : FL_F;
+    argcount(fl_ctx, "iostream?", nargs, 1);
+    return fl_isiostream(fl_ctx, args[0]) ? fl_ctx->T : fl_ctx->F;
 }
 
-value_t fl_eof_object(value_t *args, uint32_t nargs)
+value_t fl_eof_object(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     (void)args;
-    argcount("eof-object", nargs, 0);
-    return FL_EOF;
+    argcount(fl_ctx, "eof-object", nargs, 0);
+    return fl_ctx->FL_EOF;
 }
 
-value_t fl_eof_objectp(value_t *args, uint32_t nargs)
+value_t fl_eof_objectp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("eof-object?", nargs, 1);
-    return (FL_EOF == args[0]) ? FL_T : FL_F;
+    argcount(fl_ctx, "eof-object?", nargs, 1);
+    return (fl_ctx->FL_EOF == args[0]) ? fl_ctx->T : fl_ctx->F;
 }
 
-static ios_t *toiostream(value_t v, char *fname)
+static ios_t *toiostream(fl_context_t *fl_ctx, value_t v, char *fname)
 {
-    if (!fl_isiostream(v))
-        type_error(fname, "iostream", v);
+    if (!fl_isiostream(fl_ctx, v))
+        type_error(fl_ctx, fname, "iostream", v);
     return value2c(ios_t*, v);
 }
 
-ios_t *fl_toiostream(value_t v, char *fname)
+ios_t *fl_toiostream(fl_context_t *fl_ctx, value_t v, char *fname)
 {
-    return toiostream(v, fname);
+    return toiostream(fl_ctx, v, fname);
 }
 
-value_t fl_file(value_t *args, uint32_t nargs)
+value_t fl_file(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 1)
-        argcount("file", nargs, 1);
+        argcount(fl_ctx, "file", nargs, 1);
     int i, r=0, w=0, c=0, t=0, a=0;
     for(i=1; i < (int)nargs; i++) {
-        if      (args[i] == wrsym)    w = 1;
-        else if (args[i] == apsym)    { a = 1; w = 1; }
-        else if (args[i] == crsym)    { c = 1; w = 1; }
-        else if (args[i] == truncsym) { t = 1; w = 1; }
-        else if (args[i] == rdsym)    r = 1;
+        if      (args[i] == fl_ctx->wrsym)    w = 1;
+        else if (args[i] == fl_ctx->apsym)    { a = 1; w = 1; }
+        else if (args[i] == fl_ctx->crsym)    { c = 1; w = 1; }
+        else if (args[i] == fl_ctx->truncsym) { t = 1; w = 1; }
+        else if (args[i] == fl_ctx->rdsym)    r = 1;
     }
     if ((r|w|c|t|a) == 0) r = 1;  // default to reading
-    value_t f = cvalue(iostreamtype, sizeof(ios_t));
-    char *fname = tostring(args[0], "file");
+    value_t f = cvalue(fl_ctx, fl_ctx->iostreamtype, sizeof(ios_t));
+    char *fname = tostring(fl_ctx, args[0], "file");
     ios_t *s = value2c(ios_t*, f);
     if (ios_file(s, fname, r, w, c, t) == NULL)
-        lerrorf(IOError, "file: could not open \"%s\"", fname);
+        lerrorf(fl_ctx, fl_ctx->IOError, "file: could not open \"%s\"", fname);
     if (a) ios_seek_end(s);
     return f;
 }
 
-value_t fl_buffer(value_t *args, u_int32_t nargs)
+value_t fl_buffer(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("buffer", nargs, 0);
+    argcount(fl_ctx, "buffer", nargs, 0);
     (void)args;
-    value_t f = cvalue(iostreamtype, sizeof(ios_t));
+    value_t f = cvalue(fl_ctx, fl_ctx->iostreamtype, sizeof(ios_t));
     ios_t *s = value2c(ios_t*, f);
     if (ios_mem(s, 0) == NULL)
-        lerror(OutOfMemoryError, "buffer: could not allocate stream");
+        lerror(fl_ctx, fl_ctx->OutOfMemoryError, "buffer: could not allocate stream");
     return f;
 }
 
-value_t fl_read(value_t *args, u_int32_t nargs)
+value_t fl_read(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     value_t arg = 0;
     if (nargs > 1) {
-        argcount("read", nargs, 1);
+        argcount(fl_ctx, "read", nargs, 1);
     }
     else if (nargs == 0) {
-        arg = symbol_value(instrsym);
+        arg = symbol_value(fl_ctx->instrsym);
     }
     else {
         arg = args[0];
     }
-    (void)toiostream(arg, "read");
-    fl_gc_handle(&arg);
-    value_t v = fl_read_sexpr(arg);
-    fl_free_gc_handles(1);
+    (void)toiostream(fl_ctx, arg, "read");
+    fl_gc_handle(fl_ctx, &arg);
+    value_t v = fl_read_sexpr(fl_ctx, arg);
+    fl_free_gc_handles(fl_ctx, 1);
     if (ios_eof(value2c(ios_t*,arg)))
-        return FL_EOF;
+        return fl_ctx->FL_EOF;
     return v;
 }
 
-value_t fl_iogetc(value_t *args, u_int32_t nargs)
+value_t fl_iogetc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.getc", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.getc");
+    argcount(fl_ctx, "io.getc", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.getc");
     uint32_t wc;
     if (ios_getutf8(s, &wc) == IOS_EOF)
-        //lerror(IOError, "io.getc: end of file reached");
-        return FL_EOF;
-    return mk_wchar(wc);
+        //lerror(fl_ctx, IOError, "io.getc: end of file reached");
+        return fl_ctx->FL_EOF;
+    return mk_wchar(fl_ctx, wc);
 }
 
-value_t fl_iopeekc(value_t *args, u_int32_t nargs)
+value_t fl_iopeekc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.peekc", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.peekc");
+    argcount(fl_ctx, "io.peekc", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.peekc");
     uint32_t wc;
     if (ios_peekutf8(s, &wc) == IOS_EOF)
-        return FL_EOF;
-    return mk_wchar(wc);
+        return fl_ctx->FL_EOF;
+    return mk_wchar(fl_ctx, wc);
 }
 
-value_t fl_ioputc(value_t *args, u_int32_t nargs)
+value_t fl_ioputc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.putc", nargs, 2);
-    ios_t *s = toiostream(args[0], "io.putc");
-    if (!iscprim(args[1]) || ((cprim_t*)ptr(args[1]))->type != wchartype)
-        type_error("io.putc", "wchar", args[1]);
+    argcount(fl_ctx, "io.putc", nargs, 2);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.putc");
+    if (!iscprim(args[1]) || ((cprim_t*)ptr(args[1]))->type != fl_ctx->wchartype)
+        type_error(fl_ctx, "io.putc", "wchar", args[1]);
     uint32_t wc = *(uint32_t*)cp_data((cprim_t*)ptr(args[1]));
     return fixnum(ios_pututf8(s, wc));
 }
 
-value_t fl_ioungetc(value_t *args, u_int32_t nargs)
+value_t fl_ioungetc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.ungetc", nargs, 2);
-    ios_t *s = toiostream(args[0], "io.ungetc");
-    if (!iscprim(args[1]) || ((cprim_t*)ptr(args[1]))->type != wchartype)
-        type_error("io.ungetc", "wchar", args[1]);
+    argcount(fl_ctx, "io.ungetc", nargs, 2);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.ungetc");
+    if (!iscprim(args[1]) || ((cprim_t*)ptr(args[1]))->type != fl_ctx->wchartype)
+        type_error(fl_ctx, "io.ungetc", "wchar", args[1]);
     uint32_t wc = *(uint32_t*)cp_data((cprim_t*)ptr(args[1]));
     if (wc >= 0x80) {
-        lerror(ArgError, "io_ungetc: unicode not yet supported");
+        lerror(fl_ctx, fl_ctx->ArgError, "io_ungetc: unicode not yet supported");
     }
     return fixnum(ios_ungetc((int)wc,s));
 }
 
-value_t fl_ioflush(value_t *args, u_int32_t nargs)
+value_t fl_ioflush(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.flush", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.flush");
+    argcount(fl_ctx, "io.flush", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.flush");
     if (ios_flush(s) != 0)
-        return FL_F;
-    return FL_T;
+        return fl_ctx->F;
+    return fl_ctx->T;
 }
 
-value_t fl_ioclose(value_t *args, u_int32_t nargs)
+value_t fl_ioclose(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.close", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.close");
+    argcount(fl_ctx, "io.close", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.close");
     ios_close(s);
-    return FL_T;
+    return fl_ctx->T;
 }
 
-value_t fl_iopurge(value_t *args, u_int32_t nargs)
+value_t fl_iopurge(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.discardbuffer", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.discardbuffer");
+    argcount(fl_ctx, "io.discardbuffer", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.discardbuffer");
     ios_purge(s);
-    return FL_T;
+    return fl_ctx->T;
 }
 
-value_t fl_ioeof(value_t *args, u_int32_t nargs)
+value_t fl_ioeof(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.eof?", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.eof?");
-    return (ios_eof(s) ? FL_T : FL_F);
+    argcount(fl_ctx, "io.eof?", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.eof?");
+    return (ios_eof(s) ? fl_ctx->T : fl_ctx->F);
 }
 
-value_t fl_iolineno(value_t *args, u_int32_t nargs)
+value_t fl_iolineno(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("input-port-line", nargs, 1);
-    ios_t *s = toiostream(args[0], "input-port-line");
-    return size_wrap(s->lineno);
+    argcount(fl_ctx, "input-port-line", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "input-port-line");
+    return size_wrap(fl_ctx, s->lineno);
 }
 
-value_t fl_ioseek(value_t *args, u_int32_t nargs)
+value_t fl_ioseek(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.seek", nargs, 2);
-    ios_t *s = toiostream(args[0], "io.seek");
-    size_t pos = tosize(args[1], "io.seek");
-    off_t res = ios_seek(s, (off_t)pos);
+    argcount(fl_ctx, "io.seek", nargs, 2);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.seek");
+    size_t pos = tosize(fl_ctx, args[1], "io.seek");
+    int64_t res = ios_seek(s, pos);
     if (res < 0)
-        return FL_F;
-    return FL_T;
+        return fl_ctx->F;
+    return fl_ctx->T;
 }
 
-value_t fl_iopos(value_t *args, u_int32_t nargs)
+value_t fl_iopos(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.pos", nargs, 1);
-    ios_t *s = toiostream(args[0], "io.pos");
-    off_t res = ios_pos(s);
+    argcount(fl_ctx, "io.pos", nargs, 1);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.pos");
+    int64_t res = ios_pos(s);
     if (res == -1)
-        return FL_F;
-    return size_wrap((size_t)res);
+        return fl_ctx->F;
+    return size_wrap(fl_ctx, (size_t)res);
 }
 
-value_t fl_write(value_t *args, u_int32_t nargs)
+value_t fl_write(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 1 || nargs > 2)
-        argcount("write", nargs, 1);
+        argcount(fl_ctx, "write", nargs, 1);
     ios_t *s;
     if (nargs == 2)
-        s = toiostream(args[1], "write");
+        s = toiostream(fl_ctx, args[1], "write");
     else
-        s = toiostream(symbol_value(outstrsym), "write");
-    fl_print(s, args[0]);
+        s = toiostream(fl_ctx, symbol_value(fl_ctx->outstrsym), "write");
+    fl_print(fl_ctx, s, args[0]);
     return args[0];
 }
 
-value_t fl_ioread(value_t *args, u_int32_t nargs)
+value_t fl_ioread(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs != 3)
-        argcount("io.read", nargs, 2);
-    (void)toiostream(args[0], "io.read");
+        argcount(fl_ctx, "io.read", nargs, 2);
+    (void)toiostream(fl_ctx, args[0], "io.read");
     size_t n;
     fltype_t *ft;
     if (nargs == 3) {
         // form (io.read s type count)
-        ft = get_array_type(args[1]);
-        n = tosize(args[2], "io.read") * ft->elsz;
+        ft = get_array_type(fl_ctx, args[1]);
+        n = tosize(fl_ctx, args[2], "io.read") * ft->elsz;
     }
     else {
-        ft = get_type(args[1]);
+        ft = get_type(fl_ctx, args[1]);
         if (ft->eltype != NULL && !iscons(cdr_(cdr_(args[1]))))
-            lerror(ArgError, "io.read: incomplete type");
+            lerror(fl_ctx, fl_ctx->ArgError, "io.read: incomplete type");
         n = ft->size;
     }
-    value_t cv = cvalue(ft, n);
+    value_t cv = cvalue(fl_ctx, ft, n);
     char *data;
     if (iscvalue(cv)) data = (char*)cv_data((cvalue_t*)ptr(cv));
     else data = cp_data((cprim_t*)ptr(cv));
     size_t got = ios_read(value2c(ios_t*,args[0]), data, n);
     if (got < n)
-        //lerror(IOError, "io.read: end of input reached");
-        return FL_EOF;
+        //lerror(fl_ctx, IOError, "io.read: end of input reached");
+        return fl_ctx->FL_EOF;
     return cv;
 }
 
 // args must contain data[, offset[, count]]
-static void get_start_count_args(value_t *args, uint32_t nargs, size_t sz,
+static void get_start_count_args(fl_context_t *fl_ctx, value_t *args, uint32_t nargs, size_t sz,
                                  size_t *offs, size_t *nb, char *fname)
 {
     if (nargs > 1) {
-        *offs = tosize(args[1], fname);
+        *offs = tosize(fl_ctx, args[1], fname);
         if (nargs > 2)
-            *nb = tosize(args[2], fname);
+            *nb = tosize(fl_ctx, args[2], fname);
         else
             *nb = sz - *offs;
         if (*offs >= sz || *offs + *nb > sz)
-            bounds_error(fname, args[0], args[1]);
+            bounds_error(fl_ctx, fname, args[0], args[1]);
     }
 }
 
-value_t fl_iowrite(value_t *args, u_int32_t nargs)
+value_t fl_iowrite(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 2 || nargs > 4)
-        argcount("io.write", nargs, 2);
-    ios_t *s = toiostream(args[0], "io.write");
-    if (iscprim(args[1]) && ((cprim_t*)ptr(args[1]))->type == wchartype) {
+        argcount(fl_ctx, "io.write", nargs, 2);
+    ios_t *s = toiostream(fl_ctx, args[0], "io.write");
+    if (iscprim(args[1]) && ((cprim_t*)ptr(args[1]))->type == fl_ctx->wchartype) {
         if (nargs > 2)
-            lerror(ArgError,
+            lerror(fl_ctx, fl_ctx->ArgError,
                    "io.write: offset argument not supported for characters");
         uint32_t wc = *(uint32_t*)cp_data((cprim_t*)ptr(args[1]));
         return fixnum(ios_pututf8(s, wc));
     }
     char *data;
     size_t sz, offs=0;
-    to_sized_ptr(args[1], "io.write", &data, &sz);
+    to_sized_ptr(fl_ctx, args[1], "io.write", &data, &sz);
     size_t nb = sz;
     if (nargs > 2) {
-        get_start_count_args(&args[1], nargs-1, sz, &offs, &nb, "io.write");
+        get_start_count_args(fl_ctx, &args[1], nargs-1, sz, &offs, &nb, "io.write");
         data += offs;
     }
-    return size_wrap(ios_write(s, data, nb));
+    return size_wrap(fl_ctx, ios_write(s, data, nb));
 }
 
-static char get_delim_arg(value_t arg, char *fname)
+static char get_delim_arg(fl_context_t *fl_ctx, value_t arg, char *fname)
 {
-    size_t uldelim = tosize(arg, fname);
+    size_t uldelim = tosize(fl_ctx, arg, fname);
     if (uldelim > 0x7f) {
         // wchars > 0x7f, or anything else > 0xff, are out of range
-        if ((iscprim(arg) && cp_class((cprim_t*)ptr(arg))==wchartype) ||
+        if ((iscprim(arg) && cp_class((cprim_t*)ptr(arg))==fl_ctx->wchartype) ||
             uldelim > 0xff)
-            lerrorf(ArgError, "%s: delimiter out of range", fname);
+            lerrorf(fl_ctx, fl_ctx->ArgError, "%s: delimiter out of range", fname);
     }
     return (char)uldelim;
 }
 
-value_t fl_ioreaduntil(value_t *args, u_int32_t nargs)
+value_t fl_ioreaduntil(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.readuntil", nargs, 2);
-    value_t str = cvalue_string(80);
+    argcount(fl_ctx, "io.readuntil", nargs, 2);
+    value_t str = cvalue_string(fl_ctx, 80);
     cvalue_t *cv = (cvalue_t*)ptr(str);
     char *data = (char*)cv_data(cv);
     ios_t dest;
     ios_mem(&dest, 0);
     ios_setbuf(&dest, data, 80, 0);
-    char delim = get_delim_arg(args[1], "io.readuntil");
-    ios_t *src = toiostream(args[0], "io.readuntil");
+    char delim = get_delim_arg(fl_ctx, args[1], "io.readuntil");
+    ios_t *src = toiostream(fl_ctx, args[0], "io.readuntil");
     size_t n = ios_copyuntil(&dest, src, delim);
     cv->len = n;
     if (dest.buf != data) {
         // outgrew initial space
         cv->data = dest.buf;
-        cv_autorelease(cv);
+        cv_autorelease(fl_ctx, cv);
     }
     ((char*)cv->data)[n] = '\0';
     if (n == 0 && ios_eof(src))
-        return FL_EOF;
+        return fl_ctx->FL_EOF;
     return str;
 }
 
-value_t fl_iocopyuntil(value_t *args, u_int32_t nargs)
+value_t fl_iocopyuntil(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.copyuntil", nargs, 3);
-    ios_t *dest = toiostream(args[0], "io.copyuntil");
-    ios_t *src = toiostream(args[1], "io.copyuntil");
-    char delim = get_delim_arg(args[2], "io.copyuntil");
-    return size_wrap(ios_copyuntil(dest, src, delim));
+    argcount(fl_ctx, "io.copyuntil", nargs, 3);
+    ios_t *dest = toiostream(fl_ctx, args[0], "io.copyuntil");
+    ios_t *src = toiostream(fl_ctx, args[1], "io.copyuntil");
+    char delim = get_delim_arg(fl_ctx, args[2], "io.copyuntil");
+    return size_wrap(fl_ctx, ios_copyuntil(dest, src, delim));
 }
 
-value_t fl_iocopy(value_t *args, u_int32_t nargs)
+value_t fl_iocopy(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 2 || nargs > 3)
-        argcount("io.copy", nargs, 2);
-    ios_t *dest = toiostream(args[0], "io.copy");
-    ios_t *src = toiostream(args[1], "io.copy");
+        argcount(fl_ctx, "io.copy", nargs, 2);
+    ios_t *dest = toiostream(fl_ctx, args[0], "io.copy");
+    ios_t *src = toiostream(fl_ctx, args[1], "io.copy");
     if (nargs == 3) {
-        size_t n = tosize(args[2], "io.copy");
-        return size_wrap(ios_copy(dest, src, n));
+        size_t n = tosize(fl_ctx, args[2], "io.copy");
+        return size_wrap(fl_ctx, ios_copy(dest, src, n));
     }
-    return size_wrap(ios_copyall(dest, src));
+    return size_wrap(fl_ctx, ios_copyall(dest, src));
 }
 
-value_t stream_to_string(value_t *ps)
+value_t stream_to_string(fl_context_t *fl_ctx, value_t *ps)
 {
     value_t str;
     size_t n;
     ios_t *st = value2c(ios_t*,*ps);
     if (st->buf == &st->local[0]) {
-        n = st->size;
-        str = cvalue_string(n);
+        n = (size_t)st->size;
+        str = cvalue_string(fl_ctx, n);
         st = value2c(ios_t*,*ps); // reload after allocating str
         memcpy(cvalue_data(str), st->buf, n);
         ios_trunc(st, 0);
@@ -386,22 +384,22 @@ value_t stream_to_string(value_t *ps)
     else {
         char *b = ios_takebuf(st, &n); n--;
         b[n] = '\0';
-        str = cvalue_from_ref(stringtype, b, n, FL_NIL);
-        cv_autorelease((cvalue_t*)ptr(str));
+        str = cvalue_from_ref(fl_ctx, fl_ctx->stringtype, b, n, fl_ctx->NIL);
+        cv_autorelease(fl_ctx, (cvalue_t*)ptr(str));
     }
     return str;
 }
 
-value_t fl_iotostring(value_t *args, u_int32_t nargs)
+value_t fl_iotostring(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("io.tostring!", nargs, 1);
-    ios_t *src = toiostream(args[0], "io.tostring!");
+    argcount(fl_ctx, "io.tostring!", nargs, 1);
+    ios_t *src = toiostream(fl_ctx, args[0], "io.tostring!");
     if (src->bm != bm_mem)
-        lerror(ArgError, "io.tostring!: requires memory stream");
-    return stream_to_string(&args[0]);
+        lerror(fl_ctx, fl_ctx->ArgError, "io.tostring!: requires memory stream");
+    return stream_to_string(fl_ctx, &args[0]);
 }
 
-static builtinspec_t iostreamfunc_info[] = {
+static const builtinspec_t iostreamfunc_info[] = {
     { "iostream?", fl_iostreamp },
     { "eof-object", fl_eof_object },
     { "eof-object?", fl_eof_objectp },
@@ -430,26 +428,26 @@ static builtinspec_t iostreamfunc_info[] = {
     { NULL, NULL }
 };
 
-void iostream_init(void)
-{
-    iostreamsym = symbol("iostream");
-    rdsym = symbol(":read");
-    wrsym = symbol(":write");
-    apsym = symbol(":append");
-    crsym = symbol(":create");
-    truncsym = symbol(":truncate");
-    instrsym = symbol("*input-stream*");
-    outstrsym = symbol("*output-stream*");
-    iostreamtype = define_opaque_type(iostreamsym, sizeof(ios_t),
-                                      &iostream_vtable, NULL);
-    assign_global_builtins(iostreamfunc_info);
-
-    setc(symbol("*stdout*"), cvalue_from_ref(iostreamtype, ios_stdout,
-                                             sizeof(ios_t), FL_NIL));
-    setc(symbol("*stderr*"), cvalue_from_ref(iostreamtype, ios_stderr,
-                                             sizeof(ios_t), FL_NIL));
-    setc(symbol("*stdin*" ), cvalue_from_ref(iostreamtype, ios_stdin,
-                                             sizeof(ios_t), FL_NIL));
+void iostream_init(fl_context_t *fl_ctx)
+{
+    fl_ctx->iostreamsym = symbol(fl_ctx, "iostream");
+    fl_ctx->rdsym = symbol(fl_ctx, ":read");
+    fl_ctx->wrsym = symbol(fl_ctx, ":write");
+    fl_ctx->apsym = symbol(fl_ctx, ":append");
+    fl_ctx->crsym = symbol(fl_ctx, ":create");
+    fl_ctx->truncsym = symbol(fl_ctx, ":truncate");
+    fl_ctx->instrsym = symbol(fl_ctx, "*input-stream*");
+    fl_ctx->outstrsym = symbol(fl_ctx, "*output-stream*");
+    fl_ctx->iostreamtype = define_opaque_type(fl_ctx->iostreamsym, sizeof(ios_t),
+                                              &iostream_vtable, NULL);
+    assign_global_builtins(fl_ctx, iostreamfunc_info);
+
+    setc(symbol(fl_ctx, "*stdout*"), cvalue_from_ref(fl_ctx, fl_ctx->iostreamtype, ios_stdout,
+                                                     sizeof(ios_t), fl_ctx->NIL));
+    setc(symbol(fl_ctx, "*stderr*"), cvalue_from_ref(fl_ctx, fl_ctx->iostreamtype, ios_stderr,
+                                                     sizeof(ios_t), fl_ctx->NIL));
+    setc(symbol(fl_ctx, "*stdin*" ), cvalue_from_ref(fl_ctx, fl_ctx->iostreamtype, ios_stdin,
+                                                     sizeof(ios_t), fl_ctx->NIL));
 }
 
 #ifdef __cplusplus
diff --git a/src/flisp/julia_extensions.c b/src/flisp/julia_extensions.c
index 86f58762662a0..61746cc39c0ba 100644
--- a/src/flisp/julia_extensions.c
+++ b/src/flisp/julia_extensions.c
@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "utf8proc.h"
-#undef DLLEXPORT /* avoid conflicting definition */
+#undef JL_DLLEXPORT /* avoid conflicting definition */
 
 #include "flisp.h"
 
@@ -26,22 +26,22 @@ static int is_bom(uint32_t wc)
     return wc == 0xFEFF;
 }
 
-value_t fl_skipws(value_t *args, u_int32_t nargs)
+value_t fl_skipws(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("skip-ws", nargs, 2);
-    ios_t *s = fl_toiostream(args[0], "skip-ws");
-    int newlines = (args[1]!=FL_F);
+    argcount(fl_ctx, "skip-ws", nargs, 2);
+    ios_t *s = fl_toiostream(fl_ctx, args[0], "skip-ws");
+    int newlines = (args[1]!=fl_ctx->F);
     uint32_t wc=0;
-    value_t skipped = FL_F;
+    value_t skipped = fl_ctx->F;
     while (1) {
         if (ios_peekutf8(s, &wc) == IOS_EOF) {
             ios_getutf8(s, &wc);  // to set EOF flag if this is a true EOF
             if (!ios_eof(s))
-                lerror(symbol("error"), "incomplete character");
-            return FL_EOF;
+                lerror(fl_ctx, symbol(fl_ctx, "error"), "incomplete character");
+            return fl_ctx->FL_EOF;
         }
         if (!ios_eof(s) && (is_uws(wc) || is_bom(wc)) && (newlines || wc!=10)) {
-            skipped = FL_T;
+            skipped = fl_ctx->T;
             ios_getutf8(s, &wc);
         }
         else {
@@ -104,7 +104,7 @@ static int is_wc_cat_id_start(uint32_t wc, utf8proc_propval_t cat)
             (wc >= 0x309B && wc <= 0x309C)); // katakana-hiragana sound marks
 }
 
-DLLEXPORT int jl_id_start_char(uint32_t wc)
+JL_DLLEXPORT int jl_id_start_char(uint32_t wc)
 {
     if ((wc >= 'A' && wc <= 'Z') || (wc >= 'a' && wc <= 'z') || wc == '_')
         return 1;
@@ -114,7 +114,7 @@ DLLEXPORT int jl_id_start_char(uint32_t wc)
     return is_wc_cat_id_start(wc, prop->category);
 }
 
-DLLEXPORT int jl_id_char(uint32_t wc)
+JL_DLLEXPORT int jl_id_char(uint32_t wc)
 {
     if ((wc >= 'A' && wc <= 'Z') || (wc >= 'a' && wc <= 'z') || wc == '_' ||
         (wc >= '0' && wc <= '9') || wc == '!')
@@ -136,29 +136,27 @@ DLLEXPORT int jl_id_char(uint32_t wc)
     return 0;
 }
 
-value_t fl_julia_identifier_char(value_t *args, u_int32_t nargs)
+value_t fl_julia_identifier_char(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("identifier-char?", nargs, 1);
-    if (!iscprim(args[0]) || ((cprim_t*)ptr(args[0]))->type != wchartype)
-        type_error("identifier-char?", "wchar", args[0]);
+    argcount(fl_ctx, "identifier-char?", nargs, 1);
+    if (!iscprim(args[0]) || ((cprim_t*)ptr(args[0]))->type != fl_ctx->wchartype)
+        type_error(fl_ctx, "identifier-char?", "wchar", args[0]);
     uint32_t wc = *(uint32_t*)cp_data((cprim_t*)ptr(args[0]));
-    return jl_id_char(wc) ? FL_T : FL_F;
+    return jl_id_char(wc) ? fl_ctx->T : fl_ctx->F;
 }
 
-value_t fl_julia_identifier_start_char(value_t *args, u_int32_t nargs)
+value_t fl_julia_identifier_start_char(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("identifier-start-char?", nargs, 1);
-    if (!iscprim(args[0]) || ((cprim_t*)ptr(args[0]))->type != wchartype)
-        type_error("identifier-start-char?", "wchar", args[0]);
+    argcount(fl_ctx, "identifier-start-char?", nargs, 1);
+    if (!iscprim(args[0]) || ((cprim_t*)ptr(args[0]))->type != fl_ctx->wchartype)
+        type_error(fl_ctx, "identifier-start-char?", "wchar", args[0]);
     uint32_t wc = *(uint32_t*)cp_data((cprim_t*)ptr(args[0]));
-    return jl_id_start_char(wc) ? FL_T : FL_F;
+    return jl_id_start_char(wc) ? fl_ctx->T : fl_ctx->F;
 }
 
 // return NFC-normalized UTF8-encoded version of s
-static char *normalize(char *s)
+static char *normalize(fl_context_t *fl_ctx, char *s)
 {
-    static size_t buflen = 0;
-    static void *buf = NULL; // persistent buffer (avoid repeated malloc/free)
     // options equivalent to utf8proc_NFC:
     const int options = UTF8PROC_NULLTERM|UTF8PROC_STABLE|UTF8PROC_COMPOSE;
     ssize_t result;
@@ -166,31 +164,33 @@ static char *normalize(char *s)
     result = utf8proc_decompose((uint8_t*) s, 0, NULL, 0, (utf8proc_option_t)options);
     if (result < 0) goto error;
     newlen = result * sizeof(int32_t) + 1;
-    if (newlen > buflen) {
-        buflen = newlen * 2;
-        buf = realloc(buf, buflen);
-        if (!buf) lerror(OutOfMemoryError, "error allocating UTF8 buffer");
+    if (newlen > fl_ctx->jlbuflen) {
+        fl_ctx->jlbuflen = newlen * 2;
+        fl_ctx->jlbuf = realloc(fl_ctx->jlbuf, fl_ctx->jlbuflen);
+        if (!fl_ctx->jlbuf) lerror(fl_ctx, fl_ctx->OutOfMemoryError, "error allocating UTF8 buffer");
     }
-    result = utf8proc_decompose((uint8_t*)s,0, (int32_t*)buf,result, (utf8proc_option_t)options);
+    result = utf8proc_decompose((uint8_t*)s,0, (int32_t*)fl_ctx->jlbuf,result, (utf8proc_option_t)options);
     if (result < 0) goto error;
-    result = utf8proc_reencode((int32_t*)buf,result, (utf8proc_option_t)options);
+    result = utf8proc_reencode((int32_t*)fl_ctx->jlbuf,result, (utf8proc_option_t)options);
     if (result < 0) goto error;
-    return (char*) buf;
+    return (char*) fl_ctx->jlbuf;
 error:
-    lerrorf(symbol("error"), "error normalizing identifier %s: %s", s,
+    lerrorf(fl_ctx, symbol(fl_ctx, "error"), "error normalizing identifier %s: %s", s,
             utf8proc_errmsg(result));
 }
 
-value_t fl_accum_julia_symbol(value_t *args, u_int32_t nargs)
+value_t fl_accum_julia_symbol(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("accum-julia-symbol", nargs, 2);
-    ios_t *s = fl_toiostream(args[1], "accum-julia-symbol");
-    if (!iscprim(args[0]) || ((cprim_t*)ptr(args[0]))->type != wchartype)
-        type_error("accum-julia-symbol", "wchar", args[0]);
+    argcount(fl_ctx, "accum-julia-symbol", nargs, 2);
+    ios_t *s = fl_toiostream(fl_ctx, args[1], "accum-julia-symbol");
+    if (!iscprim(args[0]) || ((cprim_t*)ptr(args[0]))->type != fl_ctx->wchartype)
+        type_error(fl_ctx, "accum-julia-symbol", "wchar", args[0]);
     uint32_t wc = *(uint32_t*)cp_data((cprim_t*)ptr(args[0]));
     ios_t str;
+    int allascii=1;
     ios_mem(&str, 0);
-    while (jl_id_char(wc)) {
+    do {
+        allascii &= (wc <= 0x7f);
         ios_getutf8(s, &wc);
         if (wc == '!') {
             uint32_t nwc;
@@ -204,12 +204,12 @@ value_t fl_accum_julia_symbol(value_t *args, u_int32_t nargs)
         ios_pututf8(&str, wc);
         if (ios_peekutf8(s, &wc) == IOS_EOF)
             break;
-    }
+    } while (jl_id_char(wc));
     ios_pututf8(&str, 0);
-    return symbol(normalize(str.buf));
+    return symbol(fl_ctx, allascii ? str.buf : normalize(fl_ctx, str.buf));
 }
 
-static builtinspec_t julia_flisp_func_info[] = {
+static const builtinspec_t julia_flisp_func_info[] = {
     { "skip-ws", fl_skipws },
     { "accum-julia-symbol", fl_accum_julia_symbol },
     { "identifier-char?", fl_julia_identifier_char },
@@ -217,9 +217,9 @@ static builtinspec_t julia_flisp_func_info[] = {
     { NULL, NULL }
 };
 
-void fl_init_julia_extensions(void)
+void fl_init_julia_extensions(fl_context_t *fl_ctx)
 {
-    assign_global_builtins(julia_flisp_func_info);
+    assign_global_builtins(fl_ctx, julia_flisp_func_info);
 }
 
 #ifdef __cplusplus
diff --git a/src/flisp/opcodes.h b/src/flisp/opcodes.h
index 6b95994b879f8..d888627689e8e 100644
--- a/src/flisp/opcodes.h
+++ b/src/flisp/opcodes.h
@@ -36,8 +36,8 @@ enum {
 
 #ifdef USE_COMPUTED_GOTO
 #define VM_LABELS                                                       \
-    static void *vm_labels[] = {                                        \
-NULL, &&L_OP_DUP, &&L_OP_POP, &&L_OP_CALL, &&L_OP_TCALL, &&L_OP_JMP, \
+    static const void *vm_labels[] = {                                  \
+    NULL, &&L_OP_DUP, &&L_OP_POP, &&L_OP_CALL, &&L_OP_TCALL, &&L_OP_JMP,\
     &&L_OP_BRF, &&L_OP_BRT,                                             \
     &&L_OP_JMPL, &&L_OP_BRFL, &&L_OP_BRTL, &&L_OP_RET,                  \
                                                                         \
diff --git a/src/flisp/print.c b/src/flisp/print.c
index 4bdafc77ec63b..f39472b1f505a 100644
--- a/src/flisp/print.c
+++ b/src/flisp/print.c
@@ -1,42 +1,32 @@
 extern void *memrchr(const void *s, int c, size_t n);
 
-static htable_t printconses;
-static u_int32_t printlabel;
-static int print_pretty;
-static int print_princ;
-static fixnum_t print_length;
-static fixnum_t print_level;
-static fixnum_t P_LEVEL;
-static int SCR_WIDTH = 80;
-
-static int HPOS=0, VPOS;
-static void outc(char c, ios_t *f)
+static void outc(fl_context_t *fl_ctx, char c, ios_t *f)
 {
     ios_putc(c, f);
     if (c == '\n')
-        HPOS = 0;
+        fl_ctx->HPOS = 0;
     else
-        HPOS++;
+        fl_ctx->HPOS++;
 }
-static void outs(char *s, ios_t *f)
+static void outs(fl_context_t *fl_ctx, char *s, ios_t *f)
 {
     ios_puts(s, f);
-    HPOS += u8_strwidth(s);
+    fl_ctx->HPOS += u8_strwidth(s);
 }
-static void outsn(char *s, ios_t *f, size_t n)
+static void outsn(fl_context_t *fl_ctx, char *s, ios_t *f, size_t n)
 {
     ios_write(f, s, n);
-    HPOS += u8_strwidth(s);
+    fl_ctx->HPOS += u8_strwidth(s);
 }
-static int outindent(int n, ios_t *f)
+static int outindent(fl_context_t *fl_ctx, int n, ios_t *f)
 {
     // move back to left margin if we get too indented
-    if (n > SCR_WIDTH-12)
+    if (n > fl_ctx->SCR_WIDTH-12)
         n = 2;
     int n0 = n;
     ios_putc('\n', f);
-    VPOS++;
-    HPOS = n;
+    fl_ctx->VPOS++;
+    fl_ctx->HPOS = n;
     while (n >= 8) {
         ios_putc('\t', f);
         n -= 8;
@@ -48,75 +38,75 @@ static int outindent(int n, ios_t *f)
     return n0;
 }
 
-void fl_print_chr(char c, ios_t *f)
+void fl_print_chr(fl_context_t *fl_ctx, char c, ios_t *f)
 {
-    outc(c, f);
+    outc(fl_ctx, c, f);
 }
 
-void fl_print_str(char *s, ios_t *f)
+void fl_print_str(fl_context_t *fl_ctx, char *s, ios_t *f)
 {
-    outs(s, f);
+    outs(fl_ctx, s, f);
 }
 
-void print_traverse(value_t v)
+void print_traverse(fl_context_t *fl_ctx, value_t v)
 {
     value_t *bp;
     while (iscons(v)) {
-        if (ismarked(v)) {
-            bp = (value_t*)ptrhash_bp(&printconses, (void*)v);
+        if (ismarked(fl_ctx, v)) {
+            bp = (value_t*)ptrhash_bp(&fl_ctx->printconses, (void*)v);
             if (*bp == (value_t)HT_NOTFOUND)
-                *bp = fixnum(printlabel++);
+                *bp = fixnum(fl_ctx->printlabel++);
             return;
         }
-        mark_cons(v);
-        print_traverse(car_(v));
+        mark_cons(fl_ctx, v);
+        print_traverse(fl_ctx, car_(v));
         v = cdr_(v);
     }
-    if (!ismanaged(v) || issymbol(v))
+    if (!ismanaged(fl_ctx, v) || issymbol(v))
         return;
-    if (ismarked(v)) {
-        bp = (value_t*)ptrhash_bp(&printconses, (void*)v);
+    if (ismarked(fl_ctx, v)) {
+        bp = (value_t*)ptrhash_bp(&fl_ctx->printconses, (void*)v);
         if (*bp == (value_t)HT_NOTFOUND)
-            *bp = fixnum(printlabel++);
+            *bp = fixnum(fl_ctx->printlabel++);
         return;
     }
     if (isvector(v)) {
         if (vector_size(v) > 0)
-            mark_cons(v);
+            mark_cons(fl_ctx, v);
         unsigned int i;
         for(i=0; i < vector_size(v); i++)
-            print_traverse(vector_elt(v,i));
+            print_traverse(fl_ctx, vector_elt(v,i));
     }
     else if (iscprim(v)) {
-        mark_cons(v);
+        mark_cons(fl_ctx, v);
     }
     else if (isclosure(v)) {
-        mark_cons(v);
+        mark_cons(fl_ctx, v);
         function_t *f = (function_t*)ptr(v);
-        print_traverse(f->bcode);
-        print_traverse(f->vals);
-        print_traverse(f->env);
+        print_traverse(fl_ctx, f->bcode);
+        print_traverse(fl_ctx, f->vals);
+        print_traverse(fl_ctx, f->env);
     }
     else {
         assert(iscvalue(v));
         cvalue_t *cv = (cvalue_t*)ptr(v);
         // don't consider shared references to ""
-        if (!cv_isstr(cv) || cv_len(cv)!=0)
-            mark_cons(v);
+        if (!cv_isstr(fl_ctx, cv) || cv_len(cv)!=0)
+            mark_cons(fl_ctx, v);
         fltype_t *t = cv_class(cv);
         if (t->vtable != NULL && t->vtable->print_traverse != NULL)
-            t->vtable->print_traverse(v);
+            t->vtable->print_traverse(fl_ctx, v);
     }
 }
 
-static void print_symbol_name(ios_t *f, char *name)
+static void print_symbol_name(fl_context_t *fl_ctx, ios_t *f, char *name)
 {
     int i, escape=0, charescape=0;
 
     if ((name[0] == '\0') ||
         (name[0] == '.' && name[1] == '\0') ||
         (name[0] == '#') ||
-        isnumtok(name, NULL))
+        isnumtok(fl_ctx, name, NULL))
         escape = 1;
     i=0;
     while (name[i]) {
@@ -131,24 +121,24 @@ static void print_symbol_name(ios_t *f, char *name)
     }
     if (escape) {
         if (charescape) {
-            outc('|', f);
+            outc(fl_ctx, '|', f);
             i=0;
             while (name[i]) {
                 if (name[i]=='|' || name[i]=='\\')
-                    outc('\\', f);
-                outc(name[i], f);
+                    outc(fl_ctx, '\\', f);
+                outc(fl_ctx, name[i], f);
                 i++;
             }
-            outc('|', f);
+            outc(fl_ctx, '|', f);
         }
         else {
-            outc('|', f);
-            outs(name, f);
-            outc('|', f);
+            outc(fl_ctx, '|', f);
+            outs(fl_ctx, name, f);
+            outc(fl_ctx, '|', f);
         }
     }
     else {
-        outs(name, f);
+        outs(fl_ctx, name, f);
     }
 }
 
@@ -162,58 +152,58 @@ static void print_symbol_name(ios_t *f, char *name)
   to print anyway.
 */
 #define SMALL_STR_LEN 20
-static inline int tinyp(value_t v)
+static inline int tinyp(fl_context_t *fl_ctx, value_t v)
 {
     if (issymbol(v))
-        return (u8_strwidth(symbol_name(v)) < SMALL_STR_LEN);
-    if (fl_isstring(v))
+        return (u8_strwidth(symbol_name(fl_ctx, v)) < SMALL_STR_LEN);
+    if (fl_isstring(fl_ctx, v))
         return (cv_len((cvalue_t*)ptr(v)) < SMALL_STR_LEN);
-    return (isfixnum(v) || isbuiltin(v) || v==FL_F || v==FL_T || v==FL_NIL ||
-            v == FL_EOF);
+    return (isfixnum(v) || isbuiltin(v) || v==fl_ctx->F || v==fl_ctx->T || v==fl_ctx->NIL ||
+            v == fl_ctx->FL_EOF);
 }
 
-static int smallp(value_t v)
+static int smallp(fl_context_t *fl_ctx, value_t v)
 {
-    if (tinyp(v)) return 1;
-    if (fl_isnumber(v)) return 1;
+    if (tinyp(fl_ctx, v)) return 1;
+    if (fl_isnumber(fl_ctx, v)) return 1;
     if (iscons(v)) {
-        if (tinyp(car_(v)) && (tinyp(cdr_(v)) ||
-                               (iscons(cdr_(v)) && tinyp(car_(cdr_(v))) &&
-                                cdr_(cdr_(v))==NIL)))
+        if (tinyp(fl_ctx, car_(v)) && (tinyp(fl_ctx, cdr_(v)) ||
+                               (iscons(cdr_(v)) && tinyp(fl_ctx, car_(cdr_(v))) &&
+                                cdr_(cdr_(v))==fl_ctx->NIL)))
             return 1;
         return 0;
     }
     if (isvector(v)) {
         size_t s = vector_size(v);
-        return (s == 0 || (tinyp(vector_elt(v,0)) &&
+        return (s == 0 || (tinyp(fl_ctx, vector_elt(v,0)) &&
                            (s == 1 || (s == 2 &&
-                                       tinyp(vector_elt(v,1))))));
+                                       tinyp(fl_ctx, vector_elt(v,1))))));
     }
     return 0;
 }
 
-static int specialindent(value_t head)
+static int specialindent(fl_context_t *fl_ctx, value_t head)
 {
     // indent these forms 2 spaces, not lined up with the first argument
-    if (head == LAMBDA || head == TRYCATCH || head == definesym ||
-        head == defmacrosym || head == forsym)
+    if (head == fl_ctx->LAMBDA || head == fl_ctx->TRYCATCH || head == fl_ctx->definesym ||
+        head == fl_ctx->defmacrosym || head == fl_ctx->forsym)
         return 2;
     return -1;
 }
 
-static int lengthestimate(value_t v)
+static int lengthestimate(fl_context_t *fl_ctx, value_t v)
 {
     // get the width of an expression if we can do so cheaply
     if (issymbol(v))
-        return u8_strwidth(symbol_name(v));
+        return u8_strwidth(symbol_name(fl_ctx, v));
     return -1;
 }
 
-static int allsmallp(value_t v)
+static int allsmallp(fl_context_t *fl_ctx, value_t v)
 {
     int n = 1;
     while (iscons(v)) {
-        if (!smallp(car_(v)))
+        if (!smallp(fl_ctx, car_(v)))
             return 0;
         v = cdr_(v);
         n++;
@@ -223,102 +213,102 @@ static int allsmallp(value_t v)
     return n;
 }
 
-static int indentafter3(value_t head, value_t v)
+static int indentafter3(fl_context_t *fl_ctx, value_t head, value_t v)
 {
     // for certain X always indent (X a b c) after b
-    return ((head == forsym) && !allsmallp(cdr_(v)));
+    return ((head == fl_ctx->forsym) && !allsmallp(fl_ctx, cdr_(v)));
 }
 
-static int indentafter2(value_t head, value_t v)
+static int indentafter2(fl_context_t *fl_ctx, value_t head, value_t v)
 {
     // for certain X always indent (X a b) after a
-    return ((head == definesym || head == defmacrosym) &&
-            !allsmallp(cdr_(v)));
+    return ((head == fl_ctx->definesym || head == fl_ctx->defmacrosym) &&
+            !allsmallp(fl_ctx, cdr_(v)));
 }
 
-static int indentevery(value_t v)
+static int indentevery(fl_context_t *fl_ctx, value_t v)
 {
     // indent before every subform of a special form, unless every
     // subform is "small"
     value_t c = car_(v);
-    if (c == LAMBDA || c == setqsym)
+    if (c == fl_ctx->LAMBDA || c == fl_ctx->setqsym)
         return 0;
-    if (c == IF) // TODO: others
-        return !allsmallp(cdr_(v));
+    if (c == fl_ctx->IF) // TODO: others
+        return !allsmallp(fl_ctx, cdr_(v));
     return 0;
 }
 
-static int blockindent(value_t v)
+static int blockindent(fl_context_t *fl_ctx, value_t v)
 {
     // in this case we switch to block indent mode, where the head
     // is no longer considered special:
     // (a b c d e
     //  f g h i j)
-    return (allsmallp(v) > 9);
+    return (allsmallp(fl_ctx, v) > 9);
 }
 
-static void print_pair(ios_t *f, value_t v)
+static void print_pair(fl_context_t *fl_ctx, ios_t *f, value_t v)
 {
     value_t cd;
     char *op = NULL;
-    if (iscons(cdr_(v)) && cdr_(cdr_(v)) == NIL &&
-        !ptrhash_has(&printconses, (void*)cdr_(v)) &&
-        (((car_(v) == QUOTE)     && (op = "'"))  ||
-         ((car_(v) == BACKQUOTE) && (op = "`"))  ||
-         ((car_(v) == COMMA)     && (op = ","))  ||
-         ((car_(v) == COMMAAT)   && (op = ",@")) ||
-         ((car_(v) == COMMADOT)  && (op = ",.")))) {
+    if (iscons(cdr_(v)) && cdr_(cdr_(v)) == fl_ctx->NIL &&
+        !ptrhash_has(&fl_ctx->printconses, (void*)cdr_(v)) &&
+        (((car_(v) == fl_ctx->QUOTE)     && (op = "'"))  ||
+         ((car_(v) == fl_ctx->BACKQUOTE) && (op = "`"))  ||
+         ((car_(v) == fl_ctx->COMMA)     && (op = ","))  ||
+         ((car_(v) == fl_ctx->COMMAAT)   && (op = ",@")) ||
+         ((car_(v) == fl_ctx->COMMADOT)  && (op = ",.")))) {
         // special prefix syntax
-        unmark_cons(v);
-        unmark_cons(cdr_(v));
-        outs(op, f);
-        fl_print_child(f, car_(cdr_(v)));
+        unmark_cons(fl_ctx, v);
+        unmark_cons(fl_ctx, cdr_(v));
+        outs(fl_ctx, op, f);
+        fl_print_child(fl_ctx, f, car_(cdr_(v)));
         return;
     }
-    int startpos = HPOS;
-    outc('(', f);
-    int newindent=HPOS, blk=blockindent(v);
+    int startpos = fl_ctx->HPOS;
+    outc(fl_ctx, '(', f);
+    int newindent=fl_ctx->HPOS, blk=blockindent(fl_ctx, v);
     int lastv, n=0, si, ind=0, est, always=0, nextsmall, thistiny;
-    if (!blk) always = indentevery(v);
+    if (!blk) always = indentevery(fl_ctx, v);
     value_t head = car_(v);
-    int after3 = indentafter3(head, v);
-    int after2 = indentafter2(head, v);
+    int after3 = indentafter3(fl_ctx, head, v);
+    int after2 = indentafter2(fl_ctx, head, v);
     int n_unindented = 1;
     while (1) {
         cd = cdr_(v);
-        if (print_length >= 0 && n >= print_length && cd!=NIL) {
-            outsn("...)", f, 4);
+        if (fl_ctx->print_length >= 0 && n >= fl_ctx->print_length && cd!=fl_ctx->NIL) {
+            outsn(fl_ctx, "...)", f, 4);
             break;
         }
-        lastv = VPOS;
-        unmark_cons(v);
-        fl_print_child(f, car_(v));
-        if (!iscons(cd) || ptrhash_has(&printconses, (void*)cd)) {
-            if (cd != NIL) {
-                outsn(" . ", f, 3);
-                fl_print_child(f, cd);
+        lastv = fl_ctx->VPOS;
+        unmark_cons(fl_ctx, v);
+        fl_print_child(fl_ctx, f, car_(v));
+        if (!iscons(cd) || ptrhash_has(&fl_ctx->printconses, (void*)cd)) {
+            if (cd != fl_ctx->NIL) {
+                outsn(fl_ctx, " . ", f, 3);
+                fl_print_child(fl_ctx, f, cd);
             }
-            outc(')', f);
+            outc(fl_ctx, ')', f);
             break;
         }
 
-        if (!print_pretty ||
-            ((head == LAMBDA) && n == 0)) {
+        if (!fl_ctx->print_pretty ||
+            ((head == fl_ctx->LAMBDA) && n == 0)) {
             // never break line before lambda-list
             ind = 0;
         }
         else {
-            est = lengthestimate(car_(cd));
-            nextsmall = smallp(car_(cd));
-            thistiny = tinyp(car_(v));
-            ind = (((VPOS > lastv) ||
-                    (HPOS>SCR_WIDTH/2 && !nextsmall && !thistiny && n>0)) ||
+            est = lengthestimate(fl_ctx, car_(cd));
+            nextsmall = smallp(fl_ctx, car_(cd));
+            thistiny = tinyp(fl_ctx, car_(v));
+            ind = (((fl_ctx->VPOS > lastv) ||
+                    (fl_ctx->HPOS>fl_ctx->SCR_WIDTH/2 && !nextsmall && !thistiny && n>0)) ||
 
-                   (HPOS > SCR_WIDTH-4) ||
+                   (fl_ctx->HPOS > fl_ctx->SCR_WIDTH-4) ||
 
-                   (est!=-1 && (HPOS+est > SCR_WIDTH-2)) ||
+                   (est!=-1 && (fl_ctx->HPOS+est > fl_ctx->SCR_WIDTH-2)) ||
 
-                   ((head == LAMBDA) && !nextsmall) ||
+                   ((head == fl_ctx->LAMBDA) && !nextsmall) ||
 
                    (n > 0 && always) ||
 
@@ -327,23 +317,23 @@ static void print_pair(ios_t *f, value_t v)
 
                    (n_unindented >= 3 && !nextsmall) ||
 
-                   (n == 0 && !smallp(head)));
+                   (n == 0 && !smallp(fl_ctx, head)));
         }
 
         if (ind) {
-            newindent = outindent(newindent, f);
+            newindent = outindent(fl_ctx, newindent, f);
             n_unindented = 1;
         }
         else {
             n_unindented++;
-            outc(' ', f);
+            outc(fl_ctx, ' ', f);
             if (n==0) {
                 // set indent level after printing head
-                si = specialindent(head);
+                si = specialindent(fl_ctx, head);
                 if (si != -1)
                     newindent = startpos + si;
                 else if (!blk)
-                    newindent = HPOS;
+                    newindent = fl_ctx->HPOS;
             }
         }
         n++;
@@ -351,190 +341,190 @@ static void print_pair(ios_t *f, value_t v)
     }
 }
 
-static void cvalue_print(ios_t *f, value_t v);
+static void cvalue_print(fl_context_t *fl_ctx, ios_t *f, value_t v);
 
-static int print_circle_prefix(ios_t *f, value_t v)
+static int print_circle_prefix(fl_context_t *fl_ctx, ios_t *f, value_t v)
 {
     value_t label;
     char buf[64];
     char *str;
-    if ((label=(value_t)ptrhash_get(&printconses, (void*)v)) !=
+    if ((label=(value_t)ptrhash_get(&fl_ctx->printconses, (void*)v)) !=
         (value_t)HT_NOTFOUND) {
-        if (!ismarked(v)) {
-            //HPOS+=ios_printf(f, "#%ld#", numval(label));
-            outc('#', f);
+        if (!ismarked(fl_ctx, v)) {
+            //fl_ctx->HPOS+=ios_printf(f, "#%ld#", numval(label));
+            outc(fl_ctx, '#', f);
             str = uint2str(buf, sizeof(buf)-1, numval(label), 10);
-            outs(str, f);
-            outc('#', f);
+            outs(fl_ctx, str, f);
+            outc(fl_ctx, '#', f);
             return 1;
         }
-        //HPOS+=ios_printf(f, "#%ld=", numval(label));
-        outc('#', f);
+        //fl_ctx->HPOS+=ios_printf(f, "#%ld=", numval(label));
+        outc(fl_ctx, '#', f);
         str = uint2str(buf, sizeof(buf)-1, numval(label), 10);
-        outs(str, f);
-        outc('=', f);
+        outs(fl_ctx, str, f);
+        outc(fl_ctx, '=', f);
     }
-    if (ismanaged(v))
-        unmark_cons(v);
+    if (ismanaged(fl_ctx, v))
+        unmark_cons(fl_ctx, v);
     return 0;
 }
 
-void fl_print_child(ios_t *f, value_t v)
+void fl_print_child(fl_context_t *fl_ctx, ios_t *f, value_t v)
 {
     char *name, *str;
     char buf[64];
-    if (print_level >= 0 && P_LEVEL >= print_level &&
+    if (fl_ctx->print_level >= 0 && fl_ctx->P_LEVEL >= fl_ctx->print_level &&
         (iscons(v) || isvector(v) || isclosure(v))) {
-        outc('#', f);
+        outc(fl_ctx, '#', f);
         return;
     }
-    P_LEVEL++;
+    fl_ctx->P_LEVEL++;
 
     switch (tag(v)) {
     case TAG_NUM :
-    case TAG_NUM1: //HPOS+=ios_printf(f, "%ld", numval(v)); break;
+    case TAG_NUM1: //fl_ctx->HPOS+=ios_printf(f, "%ld", numval(v)); break;
         str = uint2str(&buf[1], sizeof(buf)-1, labs(numval(v)), 10);
         if (numval(v)<0)
             *(--str) = '-';
-        outs(str, f);
+        outs(fl_ctx, str, f);
         break;
     case TAG_SYM:
-        name = symbol_name(v);
-        if (print_princ)
-            outs(name, f);
-        else if (ismanaged(v)) {
-            outsn("#:", f, 2);
-            outs(name, f);
+        name = symbol_name(fl_ctx, v);
+        if (fl_ctx->print_princ)
+            outs(fl_ctx, name, f);
+        else if (ismanaged(fl_ctx, v)) {
+            outsn(fl_ctx, "#:", f, 2);
+            outs(fl_ctx, name, f);
         }
         else
-            print_symbol_name(f, name);
+            print_symbol_name(fl_ctx, f, name);
         break;
     case TAG_FUNCTION:
-        if (v == FL_T) {
-            outsn("#t", f, 2);
+        if (v == fl_ctx->T) {
+            outsn(fl_ctx, "#t", f, 2);
         }
-        else if (v == FL_F) {
-            outsn("#f", f, 2);
+        else if (v == fl_ctx->F) {
+            outsn(fl_ctx, "#f", f, 2);
         }
-        else if (v == FL_NIL) {
-            outsn("()", f, 2);
+        else if (v == fl_ctx->NIL) {
+            outsn(fl_ctx, "()", f, 2);
         }
-        else if (v == FL_EOF) {
-            outsn("#<eof>", f, 6);
+        else if (v == fl_ctx->FL_EOF) {
+            outsn(fl_ctx, "#<eof>", f, 6);
         }
         else if (isbuiltin(v)) {
-            if (!print_princ)
-                outsn("#.", f, 2);
-            outs(builtin_names[uintval(v)], f);
+            if (!fl_ctx->print_princ)
+                outsn(fl_ctx, "#.", f, 2);
+            outs(fl_ctx, builtin_names[uintval(v)], f);
         }
         else {
             assert(isclosure(v));
-            if (!print_princ) {
-                if (print_circle_prefix(f, v)) break;
+            if (!fl_ctx->print_princ) {
+                if (print_circle_prefix(fl_ctx, f, v)) break;
                 function_t *fn = (function_t*)ptr(v);
-                outs("#fn(", f);
+                outs(fl_ctx, "#fn(", f);
                 char *data = (char*)cvalue_data(fn->bcode);
                 size_t i, sz = cvalue_len(fn->bcode);
                 for(i=0; i < sz; i++) data[i] += 48;
-                fl_print_child(f, fn->bcode);
+                fl_print_child(fl_ctx, f, fn->bcode);
                 for(i=0; i < sz; i++) data[i] -= 48;
-                outc(' ', f);
-                fl_print_child(f, fn->vals);
-                if (fn->env != NIL) {
-                    outc(' ', f);
-                    fl_print_child(f, fn->env);
+                outc(fl_ctx, ' ', f);
+                fl_print_child(fl_ctx, f, fn->vals);
+                if (fn->env != fl_ctx->NIL) {
+                    outc(fl_ctx, ' ', f);
+                    fl_print_child(fl_ctx, f, fn->env);
                 }
-                if (fn->name != LAMBDA) {
-                    outc(' ', f);
-                    fl_print_child(f, fn->name);
+                if (fn->name != fl_ctx->LAMBDA) {
+                    outc(fl_ctx, ' ', f);
+                    fl_print_child(fl_ctx, f, fn->name);
                 }
-                outc(')', f);
+                outc(fl_ctx, ')', f);
             }
             else {
-                outs("#<function>", f);
+                outs(fl_ctx, "#<function>", f);
             }
         }
         break;
     case TAG_CVALUE:
     case TAG_CPRIM:
-        if (v == UNBOUND) { outs("#<undefined>", f); break; }
+        if (v == UNBOUND) { outs(fl_ctx, "#<undefined>", f); break; }
     case TAG_VECTOR:
     case TAG_CONS:
-        if (print_circle_prefix(f, v)) break;
+        if (print_circle_prefix(fl_ctx, f, v)) break;
         if (isvector(v)) {
-            outc('[', f);
-            int newindent = HPOS, est;
+            outc(fl_ctx, '[', f);
+            int newindent = fl_ctx->HPOS, est;
             int i, sz = vector_size(v);
             for(i=0; i < sz; i++) {
-                if (print_length >= 0 && i >= print_length && i < sz-1) {
-                    outsn("...", f, 3);
+                if (fl_ctx->print_length >= 0 && i >= fl_ctx->print_length && i < sz-1) {
+                    outsn(fl_ctx, "...", f, 3);
                     break;
                 }
-                fl_print_child(f, vector_elt(v,i));
+                fl_print_child(fl_ctx, f, vector_elt(v,i));
                 if (i < sz-1) {
-                    if (!print_pretty) {
-                        outc(' ', f);
+                    if (!fl_ctx->print_pretty) {
+                        outc(fl_ctx, ' ', f);
                     }
                     else {
-                        est = lengthestimate(vector_elt(v,i+1));
-                        if (HPOS > SCR_WIDTH-4 ||
-                            (est!=-1 && (HPOS+est > SCR_WIDTH-2)) ||
-                            (HPOS > SCR_WIDTH/2 &&
-                             !smallp(vector_elt(v,i+1)) &&
-                             !tinyp(vector_elt(v,i))))
-                            newindent = outindent(newindent, f);
+                        est = lengthestimate(fl_ctx, vector_elt(v,i+1));
+                        if (fl_ctx->HPOS > fl_ctx->SCR_WIDTH-4 ||
+                            (est!=-1 && (fl_ctx->HPOS+est > fl_ctx->SCR_WIDTH-2)) ||
+                            (fl_ctx->HPOS > fl_ctx->SCR_WIDTH/2 &&
+                             !smallp(fl_ctx, vector_elt(v,i+1)) &&
+                             !tinyp(fl_ctx, vector_elt(v,i))))
+                            newindent = outindent(fl_ctx, newindent, f);
                         else
-                            outc(' ', f);
+                            outc(fl_ctx, ' ', f);
                     }
                 }
             }
-            outc(']', f);
+            outc(fl_ctx, ']', f);
             break;
         }
         if (iscvalue(v) || iscprim(v))
-            cvalue_print(f, v);
+            cvalue_print(fl_ctx, f, v);
         else
-            print_pair(f, v);
+            print_pair(fl_ctx, f, v);
         break;
     }
-    P_LEVEL--;
+    fl_ctx->P_LEVEL--;
 }
 
-static void print_string(ios_t *f, char *str, size_t sz)
+static void print_string(fl_context_t *fl_ctx, ios_t *f, char *str, size_t sz)
 {
     char buf[512];
     size_t i = 0;
     uint8_t c;
-    static char hexdig[] = "0123456789abcdef";
+    static const char hexdig[] = "0123456789abcdef";
 
-    outc('"', f);
+    outc(fl_ctx, '"', f);
     if (!u8_isvalid(str, sz)) {
         // alternate print algorithm that preserves data if it's not UTF-8
         for(i=0; i < sz; i++) {
             c = str[i];
             if (c == '\\')
-                outsn("\\\\", f, 2);
+                outsn(fl_ctx, "\\\\", f, 2);
             else if (c == '"')
-                outsn("\\\"", f, 2);
+                outsn(fl_ctx, "\\\"", f, 2);
             else if (c >= 32 && c < 0x7f)
-                outc(c, f);
+                outc(fl_ctx, c, f);
             else {
-                outsn("\\x", f, 2);
-                outc(hexdig[c>>4], f);
-                outc(hexdig[c&0xf], f);
+                outsn(fl_ctx, "\\x", f, 2);
+                outc(fl_ctx, hexdig[c>>4], f);
+                outc(fl_ctx, hexdig[c&0xf], f);
             }
         }
     }
     else {
         while (i < sz) {
             size_t n = u8_escape(buf, sizeof(buf), str, &i, sz, 1, 0);
-            outsn(buf, f, n-1);
+            outsn(fl_ctx, buf, f, n-1);
         }
     }
-    outc('"', f);
+    outc(fl_ctx, '"', f);
 }
 
-static numerictype_t sym_to_numtype(value_t type);
+static numerictype_t sym_to_numtype(fl_context_t *fl_ctx, value_t type);
 #ifndef _OS_WINDOWS_
 #define __USE_GNU
 #include <dlfcn.h>
@@ -548,49 +538,49 @@ static numerictype_t sym_to_numtype(value_t type);
 // for example #int32(0) can be printed as just 0. this is used
 // printing in a context where a type is already implied, e.g. inside
 // an array.
-static void cvalue_printdata(ios_t *f, void *data, size_t len, value_t type,
-                             int weak)
+static void cvalue_printdata(fl_context_t *fl_ctx, ios_t *f, void *data,
+                             size_t len, value_t type, int weak)
 {
-    if (type == bytesym) {
+    if (type == fl_ctx->bytesym) {
         unsigned char ch = *(unsigned char*)data;
-        if (print_princ)
-            outc(ch, f);
+        if (fl_ctx->print_princ)
+            outc(fl_ctx, ch, f);
         else if (weak)
-            HPOS+=ios_printf(f, "0x%hhx", ch);
+            fl_ctx->HPOS+=ios_printf(f, "0x%hhx", ch);
         else
-            HPOS+=ios_printf(f, "#byte(0x%hhx)", ch);
+            fl_ctx->HPOS+=ios_printf(f, "#byte(0x%hhx)", ch);
     }
-    else if (type == wcharsym) {
+    else if (type == fl_ctx->wcharsym) {
         uint32_t wc = *(uint32_t*)data;
         char seq[8];
         size_t nb = u8_toutf8(seq, sizeof(seq), &wc, 1);
         seq[nb] = '\0';
-        if (print_princ) {
+        if (fl_ctx->print_princ) {
             // TODO: better multibyte handling
-            outs(seq, f);
+            outs(fl_ctx, seq, f);
         }
         else {
-            outsn("#\\", f, 2);
-            if      (wc == 0x00) outsn("nul", f, 3);
-            else if (wc == 0x07) outsn("alarm", f, 5);
-            else if (wc == 0x08) outsn("backspace", f, 9);
-            else if (wc == 0x09) outsn("tab", f, 3);
-            else if (wc == 0x0A) outsn("linefeed", f, 8);
-            //else if (wc == 0x0A) outsn("newline", f, 7);
-            else if (wc == 0x0B) outsn("vtab", f, 4);
-            else if (wc == 0x0C) outsn("page", f, 4);
-            else if (wc == 0x0D) outsn("return", f, 6);
-            else if (wc == 0x1B) outsn("esc", f, 3);
-            else if (wc == 0x20) outsn("space", f, 5);
-            else if (wc == 0x7F) outsn("delete", f, 6);
-            else if (iswprint(wc)) outs(seq, f);
-            else HPOS+=ios_printf(f, "x%04x", (int)wc);
+            outsn(fl_ctx, "#\\", f, 2);
+            if      (wc == 0x00) outsn(fl_ctx, "nul", f, 3);
+            else if (wc == 0x07) outsn(fl_ctx, "alarm", f, 5);
+            else if (wc == 0x08) outsn(fl_ctx, "backspace", f, 9);
+            else if (wc == 0x09) outsn(fl_ctx, "tab", f, 3);
+            else if (wc == 0x0A) outsn(fl_ctx, "linefeed", f, 8);
+            //else if (wc == 0x0A) outsn(fl_ctx, "newline", f, 7);
+            else if (wc == 0x0B) outsn(fl_ctx, "vtab", f, 4);
+            else if (wc == 0x0C) outsn(fl_ctx, "page", f, 4);
+            else if (wc == 0x0D) outsn(fl_ctx, "return", f, 6);
+            else if (wc == 0x1B) outsn(fl_ctx, "esc", f, 3);
+            else if (wc == 0x20) outsn(fl_ctx, "space", f, 5);
+            else if (wc == 0x7F) outsn(fl_ctx, "delete", f, 6);
+            else if (iswprint(wc)) outs(fl_ctx, seq, f);
+            else fl_ctx->HPOS+=ios_printf(f, "x%04x", (int)wc);
         }
     }
-    else if (type == floatsym || type == doublesym) {
+    else if (type == fl_ctx->floatsym || type == fl_ctx->doublesym) {
         char buf[64];
         double d;
-        if (type == floatsym) { d = (double)*(float*)data; }
+        if (type == fl_ctx->floatsym) { d = (double)*(float*)data; }
         else { d = *(double*)data; }
         if (!DFINITE(d)) {
             char *rep;
@@ -598,18 +588,18 @@ static void cvalue_printdata(ios_t *f, void *data, size_t len, value_t type,
                 rep = (char*)(sign_bit(d) ? "-nan.0" : "+nan.0");
             else
                 rep = (char*)(sign_bit(d) ? "-inf.0" : "+inf.0");
-            if (type == floatsym && !print_princ && !weak)
-                HPOS+=ios_printf(f, "#%s(%s)", symbol_name(type), rep);
+            if (type == fl_ctx->floatsym && !fl_ctx->print_princ && !weak)
+                fl_ctx->HPOS+=ios_printf(f, "#%s(%s)", symbol_name(fl_ctx, type), rep);
             else
-                outs(rep, f);
+                outs(fl_ctx, rep, f);
         }
         else if (d == 0) {
             if (sign_bit(d))
-                outsn("-0.0", f, 4);
+                outsn(fl_ctx, "-0.0", f, 4);
             else
-                outsn("0.0", f, 3);
-            if (type == floatsym && !print_princ && !weak)
-                outc('f', f);
+                outsn(fl_ctx, "0.0", f, 3);
+            if (type == fl_ctx->floatsym && !fl_ctx->print_princ && !weak)
+                outc(fl_ctx, 'f', f);
         }
         else {
             double ad = d < 0 ? -d : d;
@@ -617,195 +607,201 @@ static void cvalue_printdata(ios_t *f, void *data, size_t len, value_t type,
                 snprintf(buf, sizeof(buf), "%g", d);
             }
             else {
-                if (type == floatsym)
+                if (type == fl_ctx->floatsym)
                     snprintf(buf, sizeof(buf), "%.8g", d);
                 else
                     snprintf(buf, sizeof(buf), "%.16g", d);
             }
             int hasdec = (strpbrk(buf, ".eE") != NULL);
-            outs(buf, f);
-            if (!hasdec) outsn(".0", f, 2);
-            if (type == floatsym && !print_princ && !weak)
-                outc('f', f);
+            outs(fl_ctx, buf, f);
+            if (!hasdec) outsn(fl_ctx, ".0", f, 2);
+            if (type == fl_ctx->floatsym && !fl_ctx->print_princ && !weak)
+                outc(fl_ctx, 'f', f);
         }
     }
-    else if (type == uint64sym
+    else if (type == fl_ctx->uint64sym
 #ifdef _P64
-             || type == sizesym
+             || type == fl_ctx->sizesym
 #endif
              ) {
         uint64_t ui64 = *(uint64_t*)data;
-        if (weak || print_princ)
-            HPOS += ios_printf(f, "%llu", ui64);
+        if (weak || fl_ctx->print_princ)
+            fl_ctx->HPOS += ios_printf(f, "%llu", ui64);
         else
-            HPOS += ios_printf(f, "#%s(%llu)", symbol_name(type), ui64);
+            fl_ctx->HPOS += ios_printf(f, "#%s(%llu)", symbol_name(fl_ctx, type), ui64);
     }
     else if (issymbol(type)) {
         // handle other integer prims. we know it's smaller than uint64
         // at this point, so int64 is big enough to capture everything.
-        numerictype_t nt = sym_to_numtype(type);
+        numerictype_t nt = sym_to_numtype(fl_ctx, type);
         if (nt == N_NUMTYPES) {
-            static size_t (*jl_static_print)(ios_t*, void*) = 0;
-            static int init = 0;
-            static value_t jl_sym = 0;
+            // These states should be context independent.
+            static size_t (*volatile jl_static_print)(ios_t*, void*) = 0;
+            static volatile int init = 0;
             if (init == 0) {
-                init = 1;
 #if defined(RTLD_SELF)
                 jl_static_print = (size_t (*)(ios_t *, void *)) dlsym(RTLD_SELF, "jl_static_show");
 #elif defined(RTLD_DEFAULT)
                 jl_static_print = (size_t (*)(ios_t *, void *)) dlsym(RTLD_DEFAULT, "jl_static_show");
 #endif
-                jl_sym = symbol("julia_value");
+                init = 1;
             }
-            if (jl_static_print != 0 && jl_sym == type) {
-                HPOS += ios_printf(f, "#<julia: ");
-                HPOS += jl_static_print(f, *(void**)data);
-                HPOS += ios_printf(f, ">");
+            if (jl_static_print != 0 && fl_ctx->jl_sym == type) {
+                fl_ctx->HPOS += ios_printf(f, "#<julia: ");
+                fl_ctx->HPOS += jl_static_print(f, *(void**)data);
+                fl_ctx->HPOS += ios_printf(f, ">");
             }
             else
-                HPOS += ios_printf(f, "#<%s>", symbol_name(type));
+                fl_ctx->HPOS += ios_printf(f, "#<%s>", symbol_name(fl_ctx, type));
         }
         else {
             int64_t i64 = conv_to_int64(data, nt);
-            if (weak || print_princ)
-                HPOS += ios_printf(f, "%lld", i64);
+            if (weak || fl_ctx->print_princ)
+                fl_ctx->HPOS += ios_printf(f, "%lld", i64);
             else
-                HPOS += ios_printf(f, "#%s(%lld)", symbol_name(type), i64);
+                fl_ctx->HPOS += ios_printf(f, "#%s(%lld)", symbol_name(fl_ctx, type), i64);
         }
     }
     else if (iscons(type)) {
-        if (car_(type) == arraysym) {
-            value_t eltype = car(cdr_(type));
+        if (car_(type) == fl_ctx->arraysym) {
+            value_t eltype = car(fl_ctx, cdr_(type));
             size_t cnt, elsize;
             if (iscons(cdr_(cdr_(type)))) {
-                cnt = tosize(car_(cdr_(cdr_(type))), "length");
+                cnt = tosize(fl_ctx, car_(cdr_(cdr_(type))), "length");
                 elsize = cnt ? len/cnt : 0;
             }
             else {
                 // incomplete array type
                 int junk;
-                elsize = ctype_sizeof(eltype, &junk);
+                elsize = ctype_sizeof(fl_ctx, eltype, &junk);
                 cnt = elsize ? len/elsize : 0;
             }
-            if (eltype == bytesym) {
-                if (print_princ) {
+            if (eltype == fl_ctx->bytesym) {
+                if (fl_ctx->print_princ) {
                     ios_write(f, (char*)data, len);
                     /*
                     char *nl = memrchr(data, '\n', len);
                     if (nl)
-                        HPOS = u8_strwidth(nl+1);
+                        fl_ctx->HPOS = u8_strwidth(nl+1);
                     else
-                        HPOS += u8_strwidth(data);
+                        fl_ctx->HPOS += u8_strwidth(data);
                     */
                 }
                 else {
-                    print_string(f, (char*)data, len);
+                    print_string(fl_ctx, f, (char*)data, len);
                 }
                 return;
             }
-            else if (eltype == wcharsym) {
+            else if (eltype == fl_ctx->wcharsym) {
                 // TODO wchar
             }
             else {
             }
             size_t i;
             if (!weak) {
-                if (eltype == uint8sym) {
-                    outsn("#vu8(", f, 5);
+                if (eltype == fl_ctx->uint8sym) {
+                    outsn(fl_ctx, "#vu8(", f, 5);
                 }
                 else {
-                    outsn("#array(", f, 7);
-                    fl_print_child(f, eltype);
+                    outsn(fl_ctx, "#array(", f, 7);
+                    fl_print_child(fl_ctx, f, eltype);
                     if (cnt > 0)
-                        outc(' ', f);
+                        outc(fl_ctx, ' ', f);
                 }
             }
             else {
-                outc('[', f);
+                outc(fl_ctx, '[', f);
             }
             for(i=0; i < cnt; i++) {
                 if (i > 0)
-                    outc(' ', f);
-                cvalue_printdata(f, data, elsize, eltype, 1);
+                    outc(fl_ctx, ' ', f);
+                cvalue_printdata(fl_ctx, f, data, elsize, eltype, 1);
                 data = (char *)data + elsize;
             }
             if (!weak)
-                outc(')', f);
+                outc(fl_ctx, ')', f);
             else
-                outc(']', f);
+                outc(fl_ctx, ']', f);
         }
     }
 }
 
-static void cvalue_print(ios_t *f, value_t v)
+static void cvalue_print(fl_context_t *fl_ctx, ios_t *f, value_t v)
 {
     cvalue_t *cv = (cvalue_t*)ptr(v);
     void *data = cptr(v);
     value_t label;
 
-    if (cv_class(cv) == builtintype) {
+    if (cv_class(cv) == fl_ctx->builtintype) {
         void *fptr = *(void**)data;
-        label = (value_t)ptrhash_get(&reverse_dlsym_lookup_table, cv);
+        label = (value_t)ptrhash_get(&fl_ctx->reverse_dlsym_lookup_table, cv);
         if (label == (value_t)HT_NOTFOUND) {
-            HPOS += ios_printf(f, "#<builtin @0x%08zx>",
-                               (size_t)(builtin_t)fptr);
+            fl_ctx->HPOS += ios_printf(f, "#<builtin @0x%08zx>",
+                                  (size_t)(builtin_t)fptr);
         }
         else {
-            if (print_princ) {
-                outs(symbol_name(label), f);
+            if (fl_ctx->print_princ) {
+                outs(fl_ctx, symbol_name(fl_ctx, label), f);
             }
             else {
-                outsn("#fn(", f, 4);
-                outs(symbol_name(label), f);
-                outc(')', f);
+                outsn(fl_ctx, "#fn(", f, 4);
+                outs(fl_ctx, symbol_name(fl_ctx, label), f);
+                outc(fl_ctx, ')', f);
             }
         }
     }
     else if (cv_class(cv)->vtable != NULL &&
              cv_class(cv)->vtable->print != NULL) {
-        cv_class(cv)->vtable->print(v, f);
+        cv_class(cv)->vtable->print(fl_ctx, v, f);
     }
     else {
         value_t type = cv_type(cv);
         size_t len = iscprim(v) ? cv_class(cv)->size : cv_len(cv);
-        cvalue_printdata(f, data, len, type, 0);
+        cvalue_printdata(fl_ctx, f, data, len, type, 0);
     }
 }
 
-static void set_print_width(void)
+static void set_print_width(fl_context_t *fl_ctx)
 {
-    value_t pw = symbol_value(printwidthsym);
+    value_t pw = symbol_value(fl_ctx->printwidthsym);
     if (!isfixnum(pw)) return;
-    SCR_WIDTH = numval(pw);
+    fl_ctx->SCR_WIDTH = numval(pw);
 }
 
-void fl_print(ios_t *f, value_t v)
+void fl_print(fl_context_t *fl_ctx, ios_t *f, value_t v)
 {
-    print_pretty = (symbol_value(printprettysym) != FL_F);
-    if (print_pretty)
-        set_print_width();
-    print_princ = (symbol_value(printreadablysym) == FL_F);
+    fl_ctx->print_pretty = (symbol_value(fl_ctx->printprettysym) != fl_ctx->F);
+    if (fl_ctx->print_pretty)
+        set_print_width(fl_ctx);
+    fl_ctx->print_princ = (symbol_value(fl_ctx->printreadablysym) == fl_ctx->F);
 
-    value_t pl = symbol_value(printlengthsym);
-    if (isfixnum(pl)) print_length = numval(pl);
-    else print_length = -1;
-    pl = symbol_value(printlevelsym);
-    if (isfixnum(pl)) print_level = numval(pl);
-    else print_level = -1;
-    P_LEVEL = 0;
+    value_t pl = symbol_value(fl_ctx->printlengthsym);
+    if (isfixnum(pl)) fl_ctx->print_length = numval(pl);
+    else fl_ctx->print_length = -1;
+    pl = symbol_value(fl_ctx->printlevelsym);
+    if (isfixnum(pl)) fl_ctx->print_level = numval(pl);
+    else fl_ctx->print_level = -1;
+    fl_ctx->P_LEVEL = 0;
 
-    printlabel = 0;
-    print_traverse(v);
-    HPOS = VPOS = 0;
+    fl_ctx->printlabel = 0;
+    print_traverse(fl_ctx, v);
+    fl_ctx->HPOS = fl_ctx->VPOS = 0;
 
-    fl_print_child(f, v);
+    fl_print_child(fl_ctx, f, v);
 
-    if (print_level >= 0 || print_length >= 0) {
-        memset(consflags, 0, 4*bitvector_nwords(heapsize/sizeof(cons_t)));
+    if (fl_ctx->print_level >= 0 || fl_ctx->print_length >= 0) {
+        memset(fl_ctx->consflags, 0, 4*bitvector_nwords(fl_ctx->heapsize/sizeof(cons_t)));
     }
 
     if ((iscons(v) || isvector(v) || isfunction(v) || iscvalue(v)) &&
-        !fl_isstring(v) && v!=FL_T && v!=FL_F && v!=FL_NIL) {
-        htable_reset(&printconses, 32);
+        !fl_isstring(fl_ctx, v) && v!=fl_ctx->T && v!=fl_ctx->F && v!=fl_ctx->NIL) {
+        htable_reset(&fl_ctx->printconses, 32);
     }
 }
+
+void fl_print_init(fl_context_t *fl_ctx)
+{
+    htable_new(&fl_ctx->printconses, 32);
+    fl_ctx->SCR_WIDTH = 80;
+    fl_ctx->HPOS = 0;
+}
diff --git a/src/flisp/read.c b/src/flisp/read.c
index 1764f7da5701c..6eec757a84294 100644
--- a/src/flisp/read.c
+++ b/src/flisp/read.c
@@ -5,7 +5,7 @@ enum {
     TOK_OPENB, TOK_CLOSEB, TOK_SHARPSYM, TOK_GENSYM, TOK_DOUBLEQUOTE
 };
 
-#define F value2c(ios_t*,readstate->source)
+#define readF(fl_ctx) value2c(ios_t*,fl_ctx->readstate->source)
 
 // defines which characters are ordinary symbol characters.
 // exceptions are '.', which is an ordinary symbol character
@@ -13,7 +13,7 @@ enum {
 // an ordinary symbol character unless it's the first character.
 static inline int symchar(char c)
 {
-    static char *special = "()[]'\";`,\\| \f\n\r\t\v";
+    static const char *special = "()[]'\";`,\\| \f\n\r\t\v";
     return !strchr(special, c);
 }
 
@@ -29,7 +29,7 @@ static unsigned long long strtoull_0b0o(const char *nptr, char **endptr, int bas
     return strtoull(nptr, endptr, base);
 }
 
-int isnumtok_base(char *tok, value_t *pval, int base)
+int isnumtok_base(fl_context_t *fl_ctx, char *tok, value_t *pval, int base)
 {
     char *end;
     int64_t i64;
@@ -39,53 +39,53 @@ int isnumtok_base(char *tok, value_t *pval, int base)
         return 0;
     if (!((tok[0]=='0' && tok[1]=='x') || (base >= 15)) &&
         strpbrk(tok, ".eEpP")) {
-        d = strtod_c(tok, &end);
+        d = jl_strtod_c(tok, &end);
         if (*end == '\0') {
-            if (pval) *pval = mk_double(d);
+            if (pval) *pval = mk_double(fl_ctx, d);
             return 1;
         }
         // floats can end in f or f0
         if (end > tok && end[0] == 'f' &&
             (end[1] == '\0' ||
              (end[1] == '0' && end[2] == '\0'))) {
-            if (pval) *pval = mk_float((float)d);
+            if (pval) *pval = mk_float(fl_ctx, (float)d);
             return 1;
         }
     }
     // hexadecimal float literals
     else if (((tok[0]=='0' && tok[1]=='x') || (base == 16)) &&
         strpbrk(tok, "pP")) {
-        d = strtod_c(tok, &end);
+        d = jl_strtod_c(tok, &end);
         if (*end == '\0') {
-            if (pval) *pval = mk_double(d);
+            if (pval) *pval = mk_double(fl_ctx, d);
             return 1;
         }
         // floats can end in f or f0
         if (end > tok && end[0] == 'f' &&
             (end[1] == '\0' ||
              (end[1] == '0' && end[2] == '\0'))) {
-            if (pval) *pval = mk_float((float)d);
+            if (pval) *pval = mk_float(fl_ctx, (float)d);
             return 1;
         }
     }
 
     if (tok[0] == '+') {
         if (!strcmp(tok,"+NaN") || !strcasecmp(tok,"+nan.0")) {
-            if (pval) *pval = mk_double(D_PNAN);
+            if (pval) *pval = mk_double(fl_ctx, D_PNAN);
             return 1;
         }
         if (!strcmp(tok,"+Inf") || !strcasecmp(tok,"+inf.0")) {
-            if (pval) *pval = mk_double(D_PINF);
+            if (pval) *pval = mk_double(fl_ctx, D_PINF);
             return 1;
         }
     }
     else if (tok[0] == '-') {
         if (!strcmp(tok,"-NaN") || !strcasecmp(tok,"-nan.0")) {
-            if (pval) *pval = mk_double(D_NNAN);
+            if (pval) *pval = mk_double(fl_ctx, D_NNAN);
             return 1;
         }
         if (!strcmp(tok,"-Inf") || !strcasecmp(tok,"-inf.0")) {
-            if (pval) *pval = mk_double(D_NINF);
+            if (pval) *pval = mk_double(fl_ctx, D_NINF);
             return 1;
         }
         errno = 0;
@@ -93,7 +93,7 @@ int isnumtok_base(char *tok, value_t *pval, int base)
         if (errno)
             return 0;
         int done = (*end == '\0');  // must access *end before alloc
-        if (pval) *pval = return_from_int64(i64);
+        if (pval) *pval = return_from_int64(fl_ctx, i64);
         return done;
     }
     errno = 0;
@@ -101,34 +101,30 @@ int isnumtok_base(char *tok, value_t *pval, int base)
     if (errno)
         return 0;
     int done = (*end == '\0');  // must access *end before alloc
-    if (pval) *pval = return_from_uint64(ui64);
+    if (pval) *pval = return_from_uint64(fl_ctx, ui64);
     return done;
 }
 
-static int isnumtok(char *tok, value_t *pval)
+static int isnumtok(fl_context_t *fl_ctx, char *tok, value_t *pval)
 {
-    return isnumtok_base(tok, pval, 0);
+    return isnumtok_base(fl_ctx, tok, pval, 0);
 }
 
-static int read_numtok(char *tok, value_t *pval, int base)
+static int read_numtok(fl_context_t *fl_ctx, char *tok, value_t *pval, int base)
 {
     int result;
     errno = 0;
-    result = isnumtok_base(tok, pval, base);
+    result = isnumtok_base(fl_ctx, tok, pval, base);
     if (errno == ERANGE)
-        lerrorf(ParseError, "read: overflow in numeric constant %s", tok);
+        lerrorf(fl_ctx, fl_ctx->ParseError, "read: overflow in numeric constant %s", tok);
     return result;
 }
 
-static u_int32_t toktype = TOK_NONE;
-static value_t tokval;
-static char buf[256];
-
-static char nextchar(void)
+static char nextchar(fl_context_t *fl_ctx)
 {
     int ch;
     char c;
-    ios_t *f = F;
+    ios_t *f = readF(fl_ctx);
 
     do {
         if (f->bpos < f->size) {
@@ -153,26 +149,26 @@ static char nextchar(void)
     return c;
 }
 
-static void take(void)
+static void take(fl_context_t *fl_ctx)
 {
-    toktype = TOK_NONE;
+    fl_ctx->readtoktype = TOK_NONE;
 }
 
-static void accumchar(char c, int *pi)
+static void accumchar(fl_context_t *fl_ctx, char c, int *pi)
 {
-    buf[(*pi)++] = c;
-    if (*pi >= (int)(sizeof(buf)-1))
-        lerror(ParseError, "read: token too long");
+    fl_ctx->readbuf[(*pi)++] = c;
+    if (*pi >= (int)(sizeof(fl_ctx->readbuf)-1))
+        lerror(fl_ctx, fl_ctx->ParseError, "read: token too long");
 }
 
 // return: 1 if escaped (forced to be symbol)
-static int read_token(char c, int digits)
+static int read_token(fl_context_t *fl_ctx, char c, int digits)
 {
     int i=0, ch, escaped=0, issym=0, first=1;
 
     while (1) {
         if (!first) {
-            ch = ios_getc(F);
+            ch = ios_getc(readF(fl_ctx));
             if (ch == IOS_EOF)
                 goto terminate;
             c = (char)ch;
@@ -184,141 +180,141 @@ static int read_token(char c, int digits)
         }
         else if (c == '\\') {
             issym = 1;
-            ch = ios_getc(F);
+            ch = ios_getc(readF(fl_ctx));
             if (ch == IOS_EOF)
                 goto terminate;
-            accumchar((char)ch, &i);
+            accumchar(fl_ctx, (char)ch, &i);
         }
         else if (!escaped && !(symchar(c) && (!digits || isdigit(c)))) {
             break;
         }
         else {
-            accumchar(c, &i);
+            accumchar(fl_ctx, c, &i);
         }
     }
-    ios_ungetc(c, F);
+    ios_ungetc(c, readF(fl_ctx));
  terminate:
-    buf[i++] = '\0';
+    fl_ctx->readbuf[i++] = '\0';
     return issym;
 }
 
-static value_t do_read_sexpr(value_t label);
+static value_t do_read_sexpr(fl_context_t *fl_ctx, value_t label);
 
-static u_int32_t peek(void)
+static uint32_t peek(fl_context_t *fl_ctx)
 {
     char c, *end;
     fixnum_t x;
     int ch, base;
 
-    if (toktype != TOK_NONE)
-        return toktype;
-    c = nextchar();
-    if (ios_eof(F)) return TOK_NONE;
+    if (fl_ctx->readtoktype != TOK_NONE)
+        return fl_ctx->readtoktype;
+    c = nextchar(fl_ctx);
+    if (ios_eof(readF(fl_ctx))) return TOK_NONE;
     if (c == '(') {
-        toktype = TOK_OPEN;
+        fl_ctx->readtoktype = TOK_OPEN;
     }
     else if (c == ')') {
-        toktype = TOK_CLOSE;
+        fl_ctx->readtoktype = TOK_CLOSE;
     }
     else if (c == '[') {
-        toktype = TOK_OPENB;
+        fl_ctx->readtoktype = TOK_OPENB;
     }
     else if (c == ']') {
-        toktype = TOK_CLOSEB;
+        fl_ctx->readtoktype = TOK_CLOSEB;
     }
     else if (c == '\'') {
-        toktype = TOK_QUOTE;
+        fl_ctx->readtoktype = TOK_QUOTE;
     }
     else if (c == '`') {
-        toktype = TOK_BQ;
+        fl_ctx->readtoktype = TOK_BQ;
     }
     else if (c == '"') {
-        toktype = TOK_DOUBLEQUOTE;
+        fl_ctx->readtoktype = TOK_DOUBLEQUOTE;
     }
     else if (c == '#') {
-        ch = ios_getc(F); c = (char)ch;
+        ch = ios_getc(readF(fl_ctx)); c = (char)ch;
         if (ch == IOS_EOF)
-            lerror(ParseError, "read: invalid read macro");
+            lerror(fl_ctx, fl_ctx->ParseError, "read: invalid read macro");
         if (c == '.') {
-            toktype = TOK_SHARPDOT;
+            fl_ctx->readtoktype = TOK_SHARPDOT;
         }
         else if (c == '\'') {
-            toktype = TOK_SHARPQUOTE;
+            fl_ctx->readtoktype = TOK_SHARPQUOTE;
         }
         else if (c == '\\') {
             uint32_t cval;
-            if (ios_getutf8(F, &cval) == IOS_EOF)
-                lerror(ParseError, "read: end of input in character constant");
+            if (ios_getutf8(readF(fl_ctx), &cval) == IOS_EOF)
+                lerror(fl_ctx, fl_ctx->ParseError, "read: end of input in character constant");
             if (cval == (uint32_t)'u' || cval == (uint32_t)'U' ||
                 cval == (uint32_t)'x') {
-                read_token('u', 0);
-                if (buf[1] != '\0') {  // not a solitary 'u','U','x'
-                    if (!read_numtok(&buf[1], &tokval, 16))
-                        lerror(ParseError,
+                read_token(fl_ctx, 'u', 0);
+                if (fl_ctx->readbuf[1] != '\0') {  // not a solitary 'u','U','x'
+                    if (!read_numtok(fl_ctx, &fl_ctx->readbuf[1], &fl_ctx->readtokval, 16))
+                        lerror(fl_ctx, fl_ctx->ParseError,
                                "read: invalid hex character constant");
-                    cval = numval(tokval);
+                    cval = numval(fl_ctx->readtokval);
                 }
             }
             else if (cval >= 'a' && cval <= 'z') {
-                read_token((char)cval, 0);
-                tokval = symbol(buf);
-                if (buf[1] == '\0')       /* one character */;
-                else if (tokval == nulsym)        cval = 0x00;
-                else if (tokval == alarmsym)      cval = 0x07;
-                else if (tokval == backspacesym)  cval = 0x08;
-                else if (tokval == tabsym)        cval = 0x09;
-                else if (tokval == linefeedsym)   cval = 0x0A;
-                else if (tokval == newlinesym)    cval = 0x0A;
-                else if (tokval == vtabsym)       cval = 0x0B;
-                else if (tokval == pagesym)       cval = 0x0C;
-                else if (tokval == returnsym)     cval = 0x0D;
-                else if (tokval == escsym)        cval = 0x1B;
-                else if (tokval == spacesym)      cval = 0x20;
-                else if (tokval == deletesym)     cval = 0x7F;
+                read_token(fl_ctx, (char)cval, 0);
+                fl_ctx->readtokval = symbol(fl_ctx, fl_ctx->readbuf);
+                if (fl_ctx->readbuf[1] == '\0')       /* one character */;
+                else if (fl_ctx->readtokval == fl_ctx->nulsym)        cval = 0x00;
+                else if (fl_ctx->readtokval == fl_ctx->alarmsym)      cval = 0x07;
+                else if (fl_ctx->readtokval == fl_ctx->backspacesym)  cval = 0x08;
+                else if (fl_ctx->readtokval == fl_ctx->tabsym)        cval = 0x09;
+                else if (fl_ctx->readtokval == fl_ctx->linefeedsym)   cval = 0x0A;
+                else if (fl_ctx->readtokval == fl_ctx->newlinesym)    cval = 0x0A;
+                else if (fl_ctx->readtokval == fl_ctx->vtabsym)       cval = 0x0B;
+                else if (fl_ctx->readtokval == fl_ctx->pagesym)       cval = 0x0C;
+                else if (fl_ctx->readtokval == fl_ctx->returnsym)     cval = 0x0D;
+                else if (fl_ctx->readtokval == fl_ctx->escsym)        cval = 0x1B;
+                else if (fl_ctx->readtokval == fl_ctx->spacesym)      cval = 0x20;
+                else if (fl_ctx->readtokval == fl_ctx->deletesym)     cval = 0x7F;
                 else
-                    lerrorf(ParseError, "read: unknown character #\\%s", buf);
+                    lerrorf(fl_ctx, fl_ctx->ParseError, "read: unknown character #\\%s", fl_ctx->readbuf);
             }
-            toktype = TOK_NUM;
-            tokval = mk_wchar(cval);
+            fl_ctx->readtoktype = TOK_NUM;
+            fl_ctx->readtokval = mk_wchar(fl_ctx, cval);
         }
         else if (c == '(') {
-            toktype = TOK_SHARPOPEN;
+            fl_ctx->readtoktype = TOK_SHARPOPEN;
         }
         else if (c == '<') {
-            lerror(ParseError, "read: unreadable object");
+            lerror(fl_ctx, fl_ctx->ParseError, "read: unreadable object");
         }
         else if (isdigit(c)) {
-            read_token(c, 1);
-            c = (char)ios_getc(F);
+            read_token(fl_ctx, c, 1);
+            c = (char)ios_getc(readF(fl_ctx));
             if (c == '#')
-                toktype = TOK_BACKREF;
+                fl_ctx->readtoktype = TOK_BACKREF;
             else if (c == '=')
-                toktype = TOK_LABEL;
+                fl_ctx->readtoktype = TOK_LABEL;
             else
-                lerror(ParseError, "read: invalid label");
+                lerror(fl_ctx, fl_ctx->ParseError, "read: invalid label");
             errno = 0;
-            x = strtol(buf, &end, 10);
+            x = strtol(fl_ctx->readbuf, &end, 10);
             if (*end != '\0' || errno)
-                lerror(ParseError, "read: invalid label");
-            tokval = fixnum(x);
+                lerror(fl_ctx, fl_ctx->ParseError, "read: invalid label");
+            fl_ctx->readtokval = fixnum(x);
         }
         else if (c == '!') {
             // #! single line comment for shbang script support
             do {
-                ch = ios_getc(F);
+                ch = ios_getc(readF(fl_ctx));
             } while (ch != IOS_EOF && (char)ch != '\n');
-            return peek();
+            return peek(fl_ctx);
         }
         else if (c == '|') {
             // multiline comment
             int commentlevel=1;
             while (1) {
-                ch = ios_getc(F);
+                ch = ios_getc(readF(fl_ctx));
             hashpipe_gotc:
                 if (ch == IOS_EOF)
-                    lerror(ParseError, "read: eof within comment");
+                    lerror(fl_ctx, fl_ctx->ParseError, "read: eof within comment");
                 if ((char)ch == '|') {
-                    ch = ios_getc(F);
+                    ch = ios_getc(readF(fl_ctx));
                     if ((char)ch == '#') {
                         commentlevel--;
                         if (commentlevel == 0)
@@ -329,7 +325,7 @@ static u_int32_t peek(void)
                     goto hashpipe_gotc;
                 }
                 else if ((char)ch == '#') {
-                    ch = ios_getc(F);
+                    ch = ios_getc(readF(fl_ctx));
                     if ((char)ch == '|')
                         commentlevel++;
                     else
@@ -337,131 +333,131 @@ static u_int32_t peek(void)
                 }
             }
             // this was whitespace, so keep peeking
-            return peek();
+            return peek(fl_ctx);
         }
         else if (c == ';') {
             // datum comment
-            (void)do_read_sexpr(UNBOUND); // skip
-            return peek();
+            (void)do_read_sexpr(fl_ctx, UNBOUND); // skip
+            return peek(fl_ctx);
         }
         else if (c == ':') {
             // gensym
-            ch = ios_getc(F);
+            ch = ios_getc(readF(fl_ctx));
             if ((char)ch == 'g')
-                ch = ios_getc(F);
-            read_token((char)ch, 0);
+                ch = ios_getc(readF(fl_ctx));
+            read_token(fl_ctx, (char)ch, 0);
             errno = 0;
-            x = strtol(buf, &end, 10);
-            if (*end != '\0' || buf[0] == '\0' || errno)
-                lerror(ParseError, "read: invalid gensym label");
-            toktype = TOK_GENSYM;
-            tokval = fixnum(x);
+            x = strtol(fl_ctx->readbuf, &end, 10);
+            if (*end != '\0' || fl_ctx->readbuf[0] == '\0' || errno)
+                lerror(fl_ctx, fl_ctx->ParseError, "read: invalid gensym label");
+            fl_ctx->readtoktype = TOK_GENSYM;
+            fl_ctx->readtokval = fixnum(x);
         }
         else if (symchar(c)) {
-            read_token(ch, 0);
+            read_token(fl_ctx, ch, 0);
 
             if (((c == 'b' && (base= 2)) ||
                  (c == 'o' && (base= 8)) ||
                  (c == 'd' && (base=10)) ||
                  (c == 'x' && (base=16))) &&
-                (isdigit_base(buf[1],base) ||
-                 buf[1]=='-')) {
-                if (!read_numtok(&buf[1], &tokval, base))
-                    lerrorf(ParseError, "read: invalid base %d constant", base);
-                return (toktype=TOK_NUM);
+                (isdigit_base(fl_ctx->readbuf[1],base) ||
+                 fl_ctx->readbuf[1]=='-')) {
+                if (!read_numtok(fl_ctx, &fl_ctx->readbuf[1], &fl_ctx->readtokval, base))
+                    lerrorf(fl_ctx, fl_ctx->ParseError, "read: invalid base %d constant", base);
+                return (fl_ctx->readtoktype=TOK_NUM);
             }
 
-            toktype = TOK_SHARPSYM;
-            tokval = symbol(buf);
+            fl_ctx->readtoktype = TOK_SHARPSYM;
+            fl_ctx->readtokval = symbol(fl_ctx, fl_ctx->readbuf);
         }
         else {
-            lerror(ParseError, "read: unknown read macro");
+            lerror(fl_ctx, fl_ctx->ParseError, "read: unknown read macro");
         }
     }
     else if (c == ',') {
-        toktype = TOK_COMMA;
-        ch = ios_getc(F);
+        fl_ctx->readtoktype = TOK_COMMA;
+        ch = ios_getc(readF(fl_ctx));
         if (ch == IOS_EOF)
-            return toktype;
+            return fl_ctx->readtoktype;
         if ((char)ch == '@')
-            toktype = TOK_COMMAAT;
+            fl_ctx->readtoktype = TOK_COMMAAT;
         else if ((char)ch == '.')
-            toktype = TOK_COMMADOT;
+            fl_ctx->readtoktype = TOK_COMMADOT;
         else
-            ios_ungetc((char)ch, F);
+            ios_ungetc((char)ch, readF(fl_ctx));
     }
     else {
-        if (!read_token(c, 0)) {
-            if (buf[0]=='.' && buf[1]=='\0') {
-                return (toktype=TOK_DOT);
+        if (!read_token(fl_ctx, c, 0)) {
+            if (fl_ctx->readbuf[0]=='.' && fl_ctx->readbuf[1]=='\0') {
+                return (fl_ctx->readtoktype=TOK_DOT);
             }
             else {
-                if (read_numtok(buf, &tokval, 0))
-                    return (toktype=TOK_NUM);
+                if (read_numtok(fl_ctx, fl_ctx->readbuf, &fl_ctx->readtokval, 0))
+                    return (fl_ctx->readtoktype=TOK_NUM);
             }
         }
-        toktype = TOK_SYM;
-        tokval = symbol(buf);
+        fl_ctx->readtoktype = TOK_SYM;
+        fl_ctx->readtokval = symbol(fl_ctx, fl_ctx->readbuf);
     }
-    return toktype;
+    return fl_ctx->readtoktype;
 }
 
 // NOTE: this is NOT an efficient operation. it is only used by the
 // reader, and requires at least 1 and up to 3 garbage collections!
-static value_t vector_grow(value_t v, int rewrite_refs)
+static value_t vector_grow(fl_context_t *fl_ctx, value_t v, int rewrite_refs)
 {
     size_t i, s = vector_size(v);
     size_t d = vector_grow_amt(s);
-    PUSH(v);
-    value_t newv = alloc_vector(s+d, 1);
-    v = Stack[SP-1];
+    PUSH(fl_ctx, v);
+    value_t newv = alloc_vector(fl_ctx, s+d, 1);
+    v = fl_ctx->Stack[fl_ctx->SP-1];
     for(i=0; i < s; i++)
         vector_elt(newv, i) = vector_elt(v, i);
     // use gc to rewrite references from the old vector to the new
-    Stack[SP-1] = newv;
+    fl_ctx->Stack[fl_ctx->SP-1] = newv;
     if (s > 0 && rewrite_refs) {
         ((size_t*)ptr(v))[0] |= 0x1;
         vector_elt(v, 0) = newv;
-        gc(0);
+        gc(fl_ctx, 0);
     }
-    return POP();
+    return POP(fl_ctx);
 }
 
-static value_t read_vector(value_t label, u_int32_t closer)
+static value_t read_vector(fl_context_t *fl_ctx, value_t label, uint32_t closer)
 {
-    value_t v=the_empty_vector, elt;
-    u_int32_t i=0;
-    PUSH(v);
+    value_t v=fl_ctx->the_empty_vector, elt;
+    uint32_t i=0;
+    PUSH(fl_ctx, v);
     if (label != UNBOUND)
-        ptrhash_put(&readstate->backrefs, (void*)label, (void*)v);
-    while (peek() != closer) {
-        if (ios_eof(F))
-            lerror(ParseError, "read: unexpected end of input");
-        v = Stack[SP-1]; // reload after possible alloc in peek()
+        ptrhash_put(&fl_ctx->readstate->backrefs, (void*)label, (void*)v);
+    while (peek(fl_ctx) != closer) {
+        if (ios_eof(readF(fl_ctx)))
+            lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected end of input");
+        v = fl_ctx->Stack[fl_ctx->SP-1]; // reload after possible alloc in peek()
         if (i >= vector_size(v)) {
-            v = Stack[SP-1] = vector_grow(v, label != UNBOUND);
+            v = fl_ctx->Stack[fl_ctx->SP-1] = vector_grow(fl_ctx, v, label != UNBOUND);
             if (label != UNBOUND)
-                ptrhash_put(&readstate->backrefs, (void*)label, (void*)v);
+                ptrhash_put(&fl_ctx->readstate->backrefs, (void*)label, (void*)v);
         }
-        elt = do_read_sexpr(UNBOUND);
-        v = Stack[SP-1];
+        elt = do_read_sexpr(fl_ctx, UNBOUND);
+        v = fl_ctx->Stack[fl_ctx->SP-1];
         vector_elt(v,i) = elt;
         i++;
     }
-    take();
+    take(fl_ctx);
     if (i > 0)
         vector_setsize(v, i);
-    return POP();
+    return POP(fl_ctx);
 }
 
-static value_t read_string(void)
+static value_t read_string(fl_context_t *fl_ctx)
 {
     char *buf, *temp;
     char eseq[10];
     size_t i=0, j, sz = 64, ndig;
     int c;
     value_t s;
-    u_int32_t wc=0;
+    uint32_t wc=0;
 
     buf = (char*)malloc(sz);
     while (1) {
@@ -470,30 +466,30 @@ static value_t read_string(void)
             temp = (char*)realloc(buf, sz);
             if (temp == NULL) {
                 free(buf);
-                lerror(ParseError, "read: out of memory reading string");
+                lerror(fl_ctx, fl_ctx->ParseError, "read: out of memory reading string");
             }
             buf = temp;
         }
-        c = ios_getc(F);
+        c = ios_getc(readF(fl_ctx));
         if (c == IOS_EOF) {
             free(buf);
-            lerror(ParseError, "read: unexpected end of input in string");
+            lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected end of input in string");
         }
         if (c == '"')
             break;
         else if (c == '\\') {
-            c = ios_getc(F);
+            c = ios_getc(readF(fl_ctx));
             if (c == IOS_EOF) {
                 free(buf);
-                lerror(ParseError, "read: end of input in escape sequence");
+                lerror(fl_ctx, fl_ctx->ParseError, "read: end of input in escape sequence");
             }
             j=0;
             if (octal_digit(c)) {
                 do {
                     eseq[j++] = c;
-                    c = ios_getc(F);
+                    c = ios_getc(readF(fl_ctx));
                 } while (octal_digit(c) && j<3 && (c!=IOS_EOF));
-                if (c!=IOS_EOF) ios_ungetc(c, F);
+                if (c!=IOS_EOF) ios_ungetc(c, readF(fl_ctx));
                 eseq[j] = '\0';
                 wc = strtol(eseq, NULL, 8);
                 // \DDD and \xXX read bytes, not characters
@@ -502,17 +498,17 @@ static value_t read_string(void)
             else if ((c=='x' && (ndig=2)) ||
                      (c=='u' && (ndig=4)) ||
                      (c=='U' && (ndig=8))) {
-                c = ios_getc(F);
+                c = ios_getc(readF(fl_ctx));
                 while (hex_digit(c) && j<ndig && (c!=IOS_EOF)) {
                     eseq[j++] = c;
-                    c = ios_getc(F);
+                    c = ios_getc(readF(fl_ctx));
                 }
-                if (c!=IOS_EOF) ios_ungetc(c, F);
+                if (c!=IOS_EOF) ios_ungetc(c, readF(fl_ctx));
                 eseq[j] = '\0';
                 if (j) wc = strtol(eseq, NULL, 16);
                 if (!j || wc > 0x10ffff) {
                     free(buf);
-                    lerror(ParseError, "read: invalid escape sequence");
+                    lerror(fl_ctx, fl_ctx->ParseError, "read: invalid escape sequence");
                 }
                 if (ndig == 2)
                     buf[i++] = ((char)wc);
@@ -527,7 +523,7 @@ static value_t read_string(void)
             buf[i++] = c;
         }
     }
-    s = cvalue_string(i);
+    s = cvalue_string(fl_ctx, i);
     memcpy(cvalue_data(s), buf, i);
     free(buf);
     return s;
@@ -536,183 +532,190 @@ static value_t read_string(void)
 // build a list of conses. this is complicated by the fact that all conses
 // can move whenever a new cons is allocated. we have to refer to every cons
 // through a handle to a relocatable pointer (i.e. a pointer on the stack).
-static void read_list(value_t *pval, value_t label)
+static void read_list(fl_context_t *fl_ctx, value_t *pval, value_t label)
 {
     value_t c, *pc;
-    u_int32_t t;
+    uint32_t t;
 
-    PUSH(NIL);
-    pc = &Stack[SP-1];  // to keep track of current cons cell
-    t = peek();
+    PUSH(fl_ctx, fl_ctx->NIL);
+    pc = &fl_ctx->Stack[fl_ctx->SP-1];  // to keep track of current cons cell
+    t = peek(fl_ctx);
     while (t != TOK_CLOSE) {
-        if (ios_eof(F))
-            lerror(ParseError, "read: unexpected end of input");
-        c = mk_cons(); car_(c) = cdr_(c) = NIL;
+        if (ios_eof(readF(fl_ctx)))
+            lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected end of input");
+        c = mk_cons(fl_ctx); car_(c) = cdr_(c) = fl_ctx->NIL;
         if (iscons(*pc)) {
             cdr_(*pc) = c;
         }
         else {
             *pval = c;
             if (label != UNBOUND)
-                ptrhash_put(&readstate->backrefs, (void*)label, (void*)c);
+                ptrhash_put(&fl_ctx->readstate->backrefs, (void*)label, (void*)c);
         }
         *pc = c;
-        c = do_read_sexpr(UNBOUND); // must be on separate lines due to
+        c = do_read_sexpr(fl_ctx, UNBOUND); // must be on separate lines due to
         car_(*pc) = c;              // undefined evaluation order
 
-        t = peek();
+        t = peek(fl_ctx);
         if (t == TOK_DOT) {
-            take();
-            c = do_read_sexpr(UNBOUND);
+            take(fl_ctx);
+            c = do_read_sexpr(fl_ctx, UNBOUND);
             cdr_(*pc) = c;
-            t = peek();
-            if (ios_eof(F))
-                lerror(ParseError, "read: unexpected end of input");
+            t = peek(fl_ctx);
+            if (ios_eof(readF(fl_ctx)))
+                lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected end of input");
             if (t != TOK_CLOSE)
-                lerror(ParseError, "read: expected ')'");
+                lerror(fl_ctx, fl_ctx->ParseError, "read: expected ')'");
         }
     }
-    take();
-    (void)POP();
+    take(fl_ctx);
+    (void)POP(fl_ctx);
 }
 
 // label is the backreference we'd like to fix up with this read
-static value_t do_read_sexpr(value_t label)
+static value_t do_read_sexpr(fl_context_t *fl_ctx, value_t label)
 {
     value_t v, sym, oldtokval, *head;
     value_t *pv;
-    u_int32_t t;
+    uint32_t t;
     char c;
 
-    t = peek();
-    take();
+    t = peek(fl_ctx);
+    take(fl_ctx);
     switch (t) {
     case TOK_CLOSE:
-        lerror(ParseError, "read: unexpected ')'");
+        lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected ')'");
     case TOK_CLOSEB:
-        lerror(ParseError, "read: unexpected ']'");
+        lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected ']'");
     case TOK_DOT:
-        lerror(ParseError, "read: unexpected '.'");
+        lerror(fl_ctx, fl_ctx->ParseError, "read: unexpected '.'");
     case TOK_SYM:
     case TOK_NUM:
-        return tokval;
+        return fl_ctx->readtokval;
     case TOK_COMMA:
-        head = &COMMA; goto listwith;
+        head = &fl_ctx->COMMA; goto listwith;
     case TOK_COMMAAT:
-        head = &COMMAAT; goto listwith;
+        head = &fl_ctx->COMMAAT; goto listwith;
     case TOK_COMMADOT:
-        head = &COMMADOT; goto listwith;
+        head = &fl_ctx->COMMADOT; goto listwith;
     case TOK_BQ:
-        head = &BACKQUOTE; goto listwith;
+        head = &fl_ctx->BACKQUOTE; goto listwith;
     case TOK_QUOTE:
-        head = &QUOTE;
+        head = &fl_ctx->QUOTE;
     listwith:
 #ifdef MEMDEBUG2
-        v = fl_list2(*head, NIL);
+        v = fl_list2(fl_ctx, *head, fl_ctx->NIL);
 #else
-        v = cons_reserve(2);
+        v = cons_reserve(fl_ctx, 2);
         car_(v) = *head;
         cdr_(v) = tagptr(((cons_t*)ptr(v))+1, TAG_CONS);
-        car_(cdr_(v)) = cdr_(cdr_(v)) = NIL;
+        car_(cdr_(v)) = cdr_(cdr_(v)) = fl_ctx->NIL;
 #endif
-        PUSH(v);
+        PUSH(fl_ctx, v);
         if (label != UNBOUND)
-            ptrhash_put(&readstate->backrefs, (void*)label, (void*)v);
-        v = do_read_sexpr(UNBOUND);
-        car_(cdr_(Stack[SP-1])) = v;
-        return POP();
+            ptrhash_put(&fl_ctx->readstate->backrefs, (void*)label, (void*)v);
+        v = do_read_sexpr(fl_ctx, UNBOUND);
+        car_(cdr_(fl_ctx->Stack[fl_ctx->SP-1])) = v;
+        return POP(fl_ctx);
     case TOK_SHARPQUOTE:
         // femtoLisp doesn't need symbol-function, so #' does nothing
-        return do_read_sexpr(label);
+        return do_read_sexpr(fl_ctx, label);
     case TOK_OPEN:
-        PUSH(NIL);
-        read_list(&Stack[SP-1], label);
-        return POP();
+        PUSH(fl_ctx, fl_ctx->NIL);
+        read_list(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-1], label);
+        return POP(fl_ctx);
     case TOK_SHARPSYM:
-        sym = tokval;
-        if (sym == tsym || sym == Tsym)
-            return FL_T;
-        else if (sym == fsym || sym == Fsym)
-            return FL_F;
+        sym = fl_ctx->readtokval;
+        if (sym == fl_ctx->tsym || sym == fl_ctx->Tsym)
+            return fl_ctx->T;
+        else if (sym == fl_ctx->fsym || sym == fl_ctx->Fsym)
+            return fl_ctx->F;
         // constructor notation
-        c = nextchar();
+        c = nextchar(fl_ctx);
         if (c != '(') {
-            take();
-            lerrorf(ParseError, "read: expected argument list for %s",
-                    symbol_name(tokval));
+            take(fl_ctx);
+            lerrorf(fl_ctx, fl_ctx->ParseError, "read: expected argument list for %s",
+                    symbol_name(fl_ctx, fl_ctx->readtokval));
         }
-        PUSH(NIL);
-        read_list(&Stack[SP-1], UNBOUND);
-        if (sym == vu8sym) {
-            sym = arraysym;
-            Stack[SP-1] = fl_cons(uint8sym, Stack[SP-1]);
+        PUSH(fl_ctx, fl_ctx->NIL);
+        read_list(fl_ctx, &fl_ctx->Stack[fl_ctx->SP-1], UNBOUND);
+        if (sym == fl_ctx->vu8sym) {
+            sym = fl_ctx->arraysym;
+            fl_ctx->Stack[fl_ctx->SP-1] = fl_cons(fl_ctx, fl_ctx->uint8sym, fl_ctx->Stack[fl_ctx->SP-1]);
         }
-        else if (sym == fnsym) {
-            sym = FUNCTION;
+        else if (sym == fl_ctx->fnsym) {
+            sym = fl_ctx->FUNCTION;
         }
         v = symbol_value(sym);
         if (v == UNBOUND)
-            fl_raise(fl_list2(UnboundError, sym));
-        return fl_apply(v, POP());
+            fl_raise(fl_ctx, fl_list2(fl_ctx, fl_ctx->UnboundError, sym));
+        return fl_apply(fl_ctx, v, POP(fl_ctx));
     case TOK_OPENB:
-        return read_vector(label, TOK_CLOSEB);
+        return read_vector(fl_ctx, label, TOK_CLOSEB);
     case TOK_SHARPOPEN:
-        return read_vector(label, TOK_CLOSE);
+        return read_vector(fl_ctx, label, TOK_CLOSE);
     case TOK_SHARPDOT:
         // eval-when-read
         // evaluated expressions can refer to existing backreferences, but they
         // cannot see pending labels. in other words:
         // (... #2=#.#0# ... )    OK
         // (... #2=#.(#2#) ... )  DO NOT WANT
-        sym = do_read_sexpr(UNBOUND);
+        sym = do_read_sexpr(fl_ctx, UNBOUND);
         if (issymbol(sym)) {
             v = symbol_value(sym);
             if (v == UNBOUND)
-                fl_raise(fl_list2(UnboundError, sym));
+                fl_raise(fl_ctx, fl_list2(fl_ctx, fl_ctx->UnboundError, sym));
             return v;
         }
-        return fl_toplevel_eval(sym);
+        return fl_toplevel_eval(fl_ctx, sym);
     case TOK_LABEL:
         // create backreference label
-        if (ptrhash_has(&readstate->backrefs, (void*)tokval))
-            lerrorf(ParseError, "read: label %ld redefined", numval(tokval));
-        oldtokval = tokval;
-        v = do_read_sexpr(tokval);
-        ptrhash_put(&readstate->backrefs, (void*)oldtokval, (void*)v);
+        if (ptrhash_has(&fl_ctx->readstate->backrefs, (void*)fl_ctx->readtokval))
+            lerrorf(fl_ctx, fl_ctx->ParseError, "read: label %ld redefined", numval(fl_ctx->readtokval));
+        oldtokval = fl_ctx->readtokval;
+        v = do_read_sexpr(fl_ctx, fl_ctx->readtokval);
+        ptrhash_put(&fl_ctx->readstate->backrefs, (void*)oldtokval, (void*)v);
         return v;
     case TOK_BACKREF:
         // look up backreference
-        v = (value_t)ptrhash_get(&readstate->backrefs, (void*)tokval);
+        v = (value_t)ptrhash_get(&fl_ctx->readstate->backrefs, (void*)fl_ctx->readtokval);
         if (v == (value_t)HT_NOTFOUND)
-            lerrorf(ParseError, "read: undefined label %ld", numval(tokval));
+            lerrorf(fl_ctx, fl_ctx->ParseError, "read: undefined label %ld", numval(fl_ctx->readtokval));
         return v;
     case TOK_GENSYM:
-        pv = (value_t*)ptrhash_bp(&readstate->gensyms, (void*)tokval);
+        pv = (value_t*)ptrhash_bp(&fl_ctx->readstate->gensyms, (void*)fl_ctx->readtokval);
         if (*pv == (value_t)HT_NOTFOUND)
-            *pv = fl_gensym(NULL, 0);
+            *pv = fl_gensym(fl_ctx, NULL, 0);
         return *pv;
     case TOK_DOUBLEQUOTE:
-        return read_string();
+        return read_string(fl_ctx);
     }
-    return FL_UNSPECIFIED;
+    return FL_UNSPECIFIED(fl_ctx);
 }
 
-value_t fl_read_sexpr(value_t f)
+value_t fl_read_sexpr(fl_context_t *fl_ctx, value_t f)
 {
     value_t v;
     fl_readstate_t state;
-    state.prev = readstate;
+    state.prev = fl_ctx->readstate;
     htable_new(&state.backrefs, 8);
     htable_new(&state.gensyms, 8);
     state.source = f;
-    readstate = &state;
-    assert(toktype == TOK_NONE);
-    fl_gc_handle(&tokval);
+    fl_ctx->readstate = &state;
+    assert(fl_ctx->readtoktype == TOK_NONE);
+    fl_gc_handle(fl_ctx, &fl_ctx->readtokval);
 
-    v = do_read_sexpr(UNBOUND);
+    v = do_read_sexpr(fl_ctx, UNBOUND);
 
-    fl_free_gc_handles(1);
-    readstate = state.prev;
+    fl_free_gc_handles(fl_ctx, 1);
+    fl_ctx->readstate = state.prev;
     free_readstate(&state);
     return v;
 }
+
+static void fl_read_init(fl_context_t *fl_ctx)
+{
+    fl_ctx->readtoktype = TOK_NONE;
+    fl_ctx->readtokval = 0;
+    memset(fl_ctx->readbuf, 0, sizeof(fl_ctx->readbuf));
+}
diff --git a/src/flisp/string.c b/src/flisp/string.c
index 7c00b9e2c40a0..3454801ae1b55 100644
--- a/src/flisp/string.c
+++ b/src/flisp/string.c
@@ -19,262 +19,262 @@
 #include <sys/time.h>
 #endif /* !_OS_WINDOWS_ */
 
-#undef DLLEXPORT /* avoid conflicting definition */
+#undef JL_DLLEXPORT /* avoid conflicting definition */
 #include "utf8proc.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-value_t fl_stringp(value_t *args, u_int32_t nargs)
+value_t fl_stringp(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("string?", nargs, 1);
-    return fl_isstring(args[0]) ? FL_T : FL_F;
+    argcount(fl_ctx, "string?", nargs, 1);
+    return fl_isstring(fl_ctx, args[0]) ? fl_ctx->T : fl_ctx->F;
 }
 
-value_t fl_string_count(value_t *args, u_int32_t nargs)
+value_t fl_string_count(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     size_t start = 0;
     if (nargs < 1 || nargs > 3)
-        argcount("string.count", nargs, 1);
-    if (!fl_isstring(args[0]))
-        type_error("string.count", "string", args[0]);
+        argcount(fl_ctx, "string.count", nargs, 1);
+    if (!fl_isstring(fl_ctx, args[0]))
+        type_error(fl_ctx, "string.count", "string", args[0]);
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
     size_t stop = len;
     if (nargs > 1) {
-        start = tosize(args[1], "string.count");
+        start = tosize(fl_ctx, args[1], "string.count");
         if (start > len)
-            bounds_error("string.count", args[0], args[1]);
+            bounds_error(fl_ctx, "string.count", args[0], args[1]);
         if (nargs > 2) {
-            stop = tosize(args[2], "string.count");
+            stop = tosize(fl_ctx, args[2], "string.count");
             if (stop > len)
-                bounds_error("string.count", args[0], args[2]);
+                bounds_error(fl_ctx, "string.count", args[0], args[2]);
             if (stop <= start)
                 return fixnum(0);
         }
     }
     char *str = (char*)cvalue_data(args[0]);
-    return size_wrap(u8_charnum(str+start, stop-start));
+    return size_wrap(fl_ctx, u8_charnum(str+start, stop-start));
 }
 
-extern value_t fl_buffer(value_t *args, u_int32_t nargs);
-extern value_t stream_to_string(value_t *ps);
+extern value_t fl_buffer(fl_context_t *fl_ctx, value_t *args, uint32_t nargs);
+extern value_t stream_to_string(fl_context_t *fl_ctx, value_t *ps);
 
-value_t fl_string(value_t *args, u_int32_t nargs)
+value_t fl_string(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    if (nargs == 1 && fl_isstring(args[0]))
+    if (nargs == 1 && fl_isstring(fl_ctx, args[0]))
         return args[0];
-    value_t arg, buf = fl_buffer(NULL, 0);
-    fl_gc_handle(&buf);
+    value_t arg, buf = fl_buffer(fl_ctx, NULL, 0);
+    fl_gc_handle(fl_ctx, &buf);
     ios_t *s = value2c(ios_t*,buf);
     uint32_t i;
-    value_t oldpr = symbol_value(printreadablysym);
-    value_t oldpp = symbol_value(printprettysym);
-    set(printreadablysym, FL_F);
-    set(printprettysym, FL_F);
+    value_t oldpr = symbol_value(fl_ctx->printreadablysym);
+    value_t oldpp = symbol_value(fl_ctx->printprettysym);
+    set(fl_ctx->printreadablysym, fl_ctx->F);
+    set(fl_ctx->printprettysym, fl_ctx->F);
     FOR_ARGS(i,0,arg,args) {
-        fl_print(s, args[i]);
+        fl_print(fl_ctx, s, args[i]);
     }
-    set(printreadablysym, oldpr);
-    set(printprettysym, oldpp);
-    value_t outp = stream_to_string(&buf);
-    fl_free_gc_handles(1);
+    set(fl_ctx->printreadablysym, oldpr);
+    set(fl_ctx->printprettysym, oldpp);
+    value_t outp = stream_to_string(fl_ctx, &buf);
+    fl_free_gc_handles(fl_ctx, 1);
     return outp;
 }
 
-value_t fl_string_sub(value_t *args, u_int32_t nargs)
+value_t fl_string_sub(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs != 2)
-        argcount("string.sub", nargs, 3);
-    char *s = tostring(args[0], "string.sub");
+        argcount(fl_ctx, "string.sub", nargs, 3);
+    char *s = tostring(fl_ctx, args[0], "string.sub");
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
     size_t i1, i2;
-    i1 = tosize(args[1], "string.sub");
+    i1 = tosize(fl_ctx, args[1], "string.sub");
     if (i1 > len)
-        bounds_error("string.sub", args[0], args[1]);
+        bounds_error(fl_ctx, "string.sub", args[0], args[1]);
     if (nargs == 3) {
-        i2 = tosize(args[2], "string.sub");
+        i2 = tosize(fl_ctx, args[2], "string.sub");
         if (i2 > len)
-            bounds_error("string.sub", args[0], args[2]);
+            bounds_error(fl_ctx, "string.sub", args[0], args[2]);
     }
     else {
         i2 = len;
     }
     if (i2 <= i1)
-        return cvalue_string(0);
-    value_t ns = cvalue_string(i2-i1);
+        return cvalue_string(fl_ctx, 0);
+    value_t ns = cvalue_string(fl_ctx, i2-i1);
     s = (char*)cvalue_data(args[0]); // reload after alloc
     memcpy(cv_data((cvalue_t*)ptr(ns)), &s[i1], i2-i1);
     return ns;
 }
 
-value_t fl_string_char(value_t *args, u_int32_t nargs)
+value_t fl_string_char(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("string.char", nargs, 2);
-    char *s = tostring(args[0], "string.char");
+    argcount(fl_ctx, "string.char", nargs, 2);
+    char *s = tostring(fl_ctx, args[0], "string.char");
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
-    size_t i = tosize(args[1], "string.char");
+    size_t i = tosize(fl_ctx, args[1], "string.char");
     if (i >= len)
-        bounds_error("string.char", args[0], args[1]);
+        bounds_error(fl_ctx, "string.char", args[0], args[1]);
     size_t sl = u8_seqlen(&s[i]);
     if (sl > len || i > len-sl)
-        bounds_error("string.char", args[0], args[1]);
-    return mk_wchar(u8_nextchar(s, &i));
+        bounds_error(fl_ctx, "string.char", args[0], args[1]);
+    return mk_wchar(fl_ctx, u8_nextchar(s, &i));
 }
 
-static value_t mem_find_byte(char *s, char c, size_t start, size_t len)
+static value_t mem_find_byte(fl_context_t *fl_ctx, char *s, char c, size_t start, size_t len)
 {
     char *p = (char*)memchr(s+start, c, len-start);
     if (p == NULL)
-        return FL_F;
-    return size_wrap((size_t)(p - s));
+        return fl_ctx->F;
+    return size_wrap(fl_ctx, (size_t)(p - s));
 }
 
-value_t fl_string_find(value_t *args, u_int32_t nargs)
+value_t fl_string_find(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     char cbuf[8];
     size_t start = 0;
     if (nargs == 3)
-        start = tosize(args[2], "string.find");
+        start = tosize(fl_ctx, args[2], "string.find");
     else
-        argcount("string.find", nargs, 2);
-    char *s = tostring(args[0], "string.find");
+        argcount(fl_ctx, "string.find", nargs, 2);
+    char *s = tostring(fl_ctx, args[0], "string.find");
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
     if (start > len)
-        bounds_error("string.find", args[0], args[2]);
+        bounds_error(fl_ctx, "string.find", args[0], args[2]);
     char *needle; size_t needlesz;
 
     value_t v = args[1];
     cprim_t *cp = (cprim_t*)ptr(v);
-    if (iscprim(v) && cp_class(cp) == wchartype) {
+    if (iscprim(v) && cp_class(cp) == fl_ctx->wchartype) {
         uint32_t c = *(uint32_t*)cp_data(cp);
         if (c <= 0x7f)
-            return mem_find_byte(s, (char)c, start, len);
+            return mem_find_byte(fl_ctx, s, (char)c, start, len);
         needlesz = u8_toutf8(cbuf, sizeof(cbuf), &c, 1);
         needle = cbuf;
     }
-    else if (iscprim(v) && cp_class(cp) == bytetype) {
-        return mem_find_byte(s, *(char*)cp_data(cp), start, len);
+    else if (iscprim(v) && cp_class(cp) == fl_ctx->bytetype) {
+        return mem_find_byte(fl_ctx, s, *(char*)cp_data(cp), start, len);
     }
-    else if (fl_isstring(v)) {
+    else if (fl_isstring(fl_ctx, v)) {
         cvalue_t *cv = (cvalue_t*)ptr(v);
         needlesz = cv_len(cv);
         needle = (char*)cv_data(cv);
     }
     else {
-        type_error("string.find", "string", args[1]);
+        type_error(fl_ctx, "string.find", "string", args[1]);
     }
     if (needlesz > len-start)
-        return FL_F;
+        return fl_ctx->F;
     else if (needlesz == 1)
-        return mem_find_byte(s, needle[0], start, len);
+        return mem_find_byte(fl_ctx, s, needle[0], start, len);
     else if (needlesz == 0)
-        return size_wrap(start);
+        return size_wrap(fl_ctx, start);
     size_t i;
     for(i=start; i < len-needlesz+1; i++) {
         if (s[i] == needle[0]) {
             if (!memcmp(&s[i+1], needle+1, needlesz-1))
-                return size_wrap(i);
+                return size_wrap(fl_ctx, i);
         }
     }
-    return FL_F;
+    return fl_ctx->F;
 }
 
-value_t fl_string_inc(value_t *args, u_int32_t nargs)
+value_t fl_string_inc(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 2 || nargs > 3)
-        argcount("string.inc", nargs, 2);
-    char *s = tostring(args[0], "string.inc");
+        argcount(fl_ctx, "string.inc", nargs, 2);
+    char *s = tostring(fl_ctx, args[0], "string.inc");
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
-    size_t i = tosize(args[1], "string.inc");
+    size_t i = tosize(fl_ctx, args[1], "string.inc");
     size_t cnt = 1;
     if (nargs == 3)
-        cnt = tosize(args[2], "string.inc");
+        cnt = tosize(fl_ctx, args[2], "string.inc");
     while (cnt--) {
         if (i >= len)
-            bounds_error("string.inc", args[0], args[1]);
+            bounds_error(fl_ctx, "string.inc", args[0], args[1]);
         (void)(isutf(s[++i]) || isutf(s[++i]) || isutf(s[++i]) || ++i);
     }
-    return size_wrap(i);
+    return size_wrap(fl_ctx, i);
 }
 
-value_t fl_string_dec(value_t *args, u_int32_t nargs)
+value_t fl_string_dec(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 2 || nargs > 3)
-        argcount("string.dec", nargs, 2);
-    char *s = tostring(args[0], "string.dec");
+        argcount(fl_ctx, "string.dec", nargs, 2);
+    char *s = tostring(fl_ctx, args[0], "string.dec");
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
-    size_t i = tosize(args[1], "string.dec");
+    size_t i = tosize(fl_ctx, args[1], "string.dec");
     size_t cnt = 1;
     if (nargs == 3)
-        cnt = tosize(args[2], "string.dec");
+        cnt = tosize(fl_ctx, args[2], "string.dec");
     // note: i is allowed to start at index len
     if (i > len)
-        bounds_error("string.dec", args[0], args[1]);
+        bounds_error(fl_ctx, "string.dec", args[0], args[1]);
     while (cnt--) {
         if (i == 0)
-            bounds_error("string.dec", args[0], args[1]);
+            bounds_error(fl_ctx, "string.dec", args[0], args[1]);
         (void)(isutf(s[--i]) || isutf(s[--i]) || isutf(s[--i]) || --i);
     }
-    return size_wrap(i);
+    return size_wrap(fl_ctx, i);
 }
 
-static unsigned long get_radix_arg(value_t arg, char *fname)
+static unsigned long get_radix_arg(fl_context_t *fl_ctx, value_t arg, char *fname)
 {
-    unsigned long radix = (unsigned long)tosize(arg, fname);
+    unsigned long radix = (unsigned long)tosize(fl_ctx, arg, fname);
     if (radix < 2 || radix > 36)
-        lerrorf(ArgError, "%s: invalid radix", fname);
+        lerrorf(fl_ctx, fl_ctx->ArgError, "%s: invalid radix", fname);
     return radix;
 }
 
-value_t fl_numbertostring(value_t *args, u_int32_t nargs)
+value_t fl_numbertostring(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 1 || nargs > 2)
-        argcount("number->string", nargs, 2);
+        argcount(fl_ctx, "number->string", nargs, 2);
     value_t n = args[0];
     int neg = 0;
     uint64_t num;
     if (isfixnum(n))      num = numval(n);
-    else if (!iscprim(n)) type_error("number->string", "integer", n);
+    else if (!iscprim(n)) type_error(fl_ctx, "number->string", "integer", n);
     else num = conv_to_uint64(cp_data((cprim_t*)ptr(n)),
                               cp_numtype((cprim_t*)ptr(n)));
-    if (numval(fl_compare(args[0],fixnum(0))) < 0) {
+    if (numval(fl_compare(fl_ctx, args[0],fixnum(0))) < 0) {
         num = -num;
         neg = 1;
     }
     unsigned long radix = 10;
     if (nargs == 2)
-        radix = get_radix_arg(args[1], "number->string");
+        radix = get_radix_arg(fl_ctx, args[1], "number->string");
     char buf[128];
     char *str = uint2str(buf, sizeof(buf), num, radix);
     if (neg && str > &buf[0])
         *(--str) = '-';
-    return string_from_cstr(str);
+    return string_from_cstr(fl_ctx, str);
 }
 
-value_t fl_stringtonumber(value_t *args, uint32_t nargs)
+value_t fl_stringtonumber(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs < 1 || nargs > 2)
-        argcount("string->number", nargs, 2);
-    char *str = tostring(args[0], "string->number");
+        argcount(fl_ctx, "string->number", nargs, 2);
+    char *str = tostring(fl_ctx, args[0], "string->number");
     value_t n;
     unsigned long radix = 0;
     if (nargs == 2)
-        radix = get_radix_arg(args[1], "string->number");
-    if (!isnumtok_base(str, &n, (int)radix))
-        return FL_F;
+        radix = get_radix_arg(fl_ctx, args[1], "string->number");
+    if (!isnumtok_base(fl_ctx, str, &n, (int)radix))
+        return fl_ctx->F;
     return n;
 }
 
-value_t fl_string_isutf8(value_t *args, u_int32_t nargs)
+value_t fl_string_isutf8(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("string.isutf8", nargs, 1);
-    char *s = tostring(args[0], "string.isutf8");
+    argcount(fl_ctx, "string.isutf8", nargs, 1);
+    char *s = tostring(fl_ctx, args[0], "string.isutf8");
     size_t len = cv_len((cvalue_t*)ptr(args[0]));
-    return u8_isvalid(s, len) ? FL_T : FL_F;
+    return u8_isvalid(s, len) ? fl_ctx->T : fl_ctx->F;
 }
 
-static builtinspec_t stringfunc_info[] = {
+static const builtinspec_t stringfunc_info[] = {
     { "string", fl_string },
     { "string?", fl_stringp },
     { "string.count", fl_string_count },
@@ -291,9 +291,9 @@ static builtinspec_t stringfunc_info[] = {
     { NULL, NULL }
 };
 
-void stringfuncs_init(void)
+void stringfuncs_init(fl_context_t *fl_ctx)
 {
-    assign_global_builtins(stringfunc_info);
+    assign_global_builtins(fl_ctx, stringfunc_info);
 }
 
 #ifdef __cplusplus
diff --git a/src/flisp/system.lsp b/src/flisp/system.lsp
index 995c8f689ab2d..e3c196730d181 100644
--- a/src/flisp/system.lsp
+++ b/src/flisp/system.lsp
@@ -472,18 +472,6 @@
 
 (define (iota n) (map-int identity n))
 
-(define (for-each f l . lsts)
-  (define (for-each-n f lsts)
-    (if (pair? (car lsts))
-	(begin (apply f (map car lsts))
-	       (for-each-n f (map cdr lsts)))))
-  (if (null? lsts)
-      (while (pair? l)
-	     (begin (f (car l))
-		    (set! l (cdr l))))
-      (for-each-n f (cons l lsts)))
-  #t)
-
 (define-macro (with-bindings binds . body)
   (let ((vars (map car binds))
 	(vals (map cadr binds))
@@ -640,11 +628,6 @@
 
 (define (string.tail s n) (string.sub s (string.inc s 0 n)))
 
-(define *whitespace*
-  (string.encode #array(wchar 9 10 11 12 13 32 133 160 5760 6158 8192
-			      8193 8194 8195 8196 8197 8198 8199 8200
-			      8201 8202 8232 8233 8239 8287 12288)))
-
 #;(define (string.trim s at-start at-end)
   (define (trim-start s chars i L)
     (if (and (< i L)
diff --git a/src/flisp/table.c b/src/flisp/table.c
index 154ab7d5cf520..cee884dd2f281 100644
--- a/src/flisp/table.c
+++ b/src/flisp/table.c
@@ -12,46 +12,44 @@
 extern "C" {
 #endif
 
-static value_t tablesym;
-static fltype_t *tabletype;
-
-void print_htable(value_t v, ios_t *f)
+void print_htable(fl_context_t *fl_ctx, value_t v, ios_t *f)
 {
     htable_t *h = (htable_t*)cv_data((cvalue_t*)ptr(v));
     size_t i;
     int first=1;
-    fl_print_str("#table(", f);
+    fl_print_str(fl_ctx, "#table(", f);
     for(i=0; i < h->size; i+=2) {
         if (h->table[i+1] != HT_NOTFOUND) {
-            if (!first) fl_print_str("  ", f);
-            fl_print_child(f, (value_t)h->table[i]);
-            fl_print_chr(' ', f);
-            fl_print_child(f, (value_t)h->table[i+1]);
+            if (!first) fl_print_str(fl_ctx, "  ", f);
+            fl_print_child(fl_ctx, f, (value_t)h->table[i]);
+            fl_print_chr(fl_ctx, ' ', f);
+            fl_print_child(fl_ctx, f, (value_t)h->table[i+1]);
             first = 0;
         }
     }
-    fl_print_chr(')', f);
+    fl_print_chr(fl_ctx, ')', f);
 }
 
-void print_traverse_htable(value_t self)
+void print_traverse_htable(fl_context_t *fl_ctx, value_t self)
 {
     htable_t *h = (htable_t*)cv_data((cvalue_t*)ptr(self));
     size_t i;
     for(i=0; i < h->size; i+=2) {
         if (h->table[i+1] != HT_NOTFOUND) {
-            print_traverse((value_t)h->table[i]);
-            print_traverse((value_t)h->table[i+1]);
+            print_traverse(fl_ctx, (value_t)h->table[i]);
+            print_traverse(fl_ctx, (value_t)h->table[i+1]);
         }
     }
 }
 
-void free_htable(value_t self)
+void free_htable(fl_context_t *fl_ctx, value_t self)
 {
+    (void)fl_ctx;
     htable_t *h = (htable_t*)cv_data((cvalue_t*)ptr(self));
     htable_free(h);
 }
 
-void relocate_htable(value_t oldv, value_t newv)
+void relocate_htable(fl_context_t *fl_ctx, value_t oldv, value_t newv)
 {
     htable_t *oldh = (htable_t*)cv_data((cvalue_t*)ptr(oldv));
     htable_t *h = (htable_t*)cv_data((cvalue_t*)ptr(newv));
@@ -60,53 +58,50 @@ void relocate_htable(value_t oldv, value_t newv)
     size_t i;
     for(i=0; i < h->size; i++) {
         if (h->table[i] != HT_NOTFOUND)
-            h->table[i] = (void*)relocate_lispvalue((value_t)h->table[i]);
+            h->table[i] = (void*)relocate_lispvalue(fl_ctx, (value_t)h->table[i]);
     }
 }
 
-cvtable_t table_vtable = { print_htable, relocate_htable, free_htable,
-                           print_traverse_htable };
-
-int ishashtable(value_t v)
+static int ishashtable(fl_context_t *fl_ctx, value_t v)
 {
-    return iscvalue(v) && cv_class((cvalue_t*)ptr(v)) == tabletype;
+    return iscvalue(v) && cv_class((cvalue_t*)ptr(v)) == fl_ctx->tabletype;
 }
 
-value_t fl_tablep(value_t *args, uint32_t nargs)
+value_t fl_tablep(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("table?", nargs, 1);
-    return ishashtable(args[0]) ? FL_T : FL_F;
+    argcount(fl_ctx, "table?", nargs, 1);
+    return ishashtable(fl_ctx, args[0]) ? fl_ctx->T : fl_ctx->F;
 }
 
-static htable_t *totable(value_t v, char *fname)
+static htable_t *totable(fl_context_t *fl_ctx, value_t v, char *fname)
 {
-    if (!ishashtable(v))
-        type_error(fname, "table", v);
+    if (!ishashtable(fl_ctx, v))
+        type_error(fl_ctx, fname, "table", v);
     return (htable_t*)cv_data((cvalue_t*)ptr(v));
 }
 
-value_t fl_table(value_t *args, uint32_t nargs)
+value_t fl_table(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     size_t cnt = (size_t)nargs;
     if (cnt & 1)
-        lerror(ArgError, "table: arguments must come in pairs");
+        lerror(fl_ctx, fl_ctx->ArgError, "table: arguments must come in pairs");
     value_t nt;
     // prevent small tables from being added to finalizer list
     if (cnt <= HT_N_INLINE) {
-        tabletype->vtable->finalize = NULL;
-        nt = cvalue(tabletype, sizeof(htable_t));
-        tabletype->vtable->finalize = free_htable;
+        fl_ctx->table_vtable.finalize = NULL;
+        nt = cvalue(fl_ctx, fl_ctx->tabletype, sizeof(htable_t));
+        fl_ctx->table_vtable.finalize = free_htable;
     }
     else {
-        nt = cvalue(tabletype, 2*sizeof(void*));
+        nt = cvalue(fl_ctx, fl_ctx->tabletype, 2*sizeof(void*));
     }
     htable_t *h = (htable_t*)cv_data((cvalue_t*)ptr(nt));
     htable_new(h, cnt/2);
     uint32_t i;
-    value_t k=FL_NIL, arg=FL_NIL;
+    value_t k=fl_ctx->NIL, arg=fl_ctx->NIL;
     FOR_ARGS(i,0,arg,args) {
         if (i&1)
-            equalhash_put(h, (void*)k, (void*)arg);
+            equalhash_put_r(h, (void*)k, (void*)arg, (void*)fl_ctx);
         else
             k = arg;
     }
@@ -114,87 +109,87 @@ value_t fl_table(value_t *args, uint32_t nargs)
 }
 
 // (put! table key value)
-value_t fl_table_put(value_t *args, uint32_t nargs)
+value_t fl_table_put(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("put!", nargs, 3);
-    htable_t *h = totable(args[0], "put!");
+    argcount(fl_ctx, "put!", nargs, 3);
+    htable_t *h = totable(fl_ctx, args[0], "put!");
     void **table0 = h->table;
-    equalhash_put(h, (void*)args[1], (void*)args[2]);
+    equalhash_put_r(h, (void*)args[1], (void*)args[2], (void*)fl_ctx);
     // register finalizer if we outgrew inline space
     if (table0 == &h->_space[0] && h->table != &h->_space[0]) {
         cvalue_t *cv = (cvalue_t*)ptr(args[0]);
-        add_finalizer(cv);
+        add_finalizer(fl_ctx, cv);
         cv->len = 2*sizeof(void*);
     }
     return args[0];
 }
 
-static void key_error(char *fname, value_t key)
+static void key_error(fl_context_t *fl_ctx, char *fname, value_t key)
 {
-    lerrorf(fl_list2(KeyError, key), "%s: key not found", fname);
+    lerrorf(fl_ctx, fl_list2(fl_ctx, fl_ctx->KeyError, key), "%s: key not found", fname);
 }
 
 // (get table key [default])
-value_t fl_table_get(value_t *args, uint32_t nargs)
+value_t fl_table_get(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
     if (nargs != 3)
-        argcount("get", nargs, 2);
-    htable_t *h = totable(args[0], "get");
-    value_t v = (value_t)equalhash_get(h, (void*)args[1]);
+        argcount(fl_ctx, "get", nargs, 2);
+    htable_t *h = totable(fl_ctx, args[0], "get");
+    value_t v = (value_t)equalhash_get_r(h, (void*)args[1], (void*)fl_ctx);
     if (v == (value_t)HT_NOTFOUND) {
         if (nargs == 3)
             return args[2];
-        key_error("get", args[1]);
+        key_error(fl_ctx, "get", args[1]);
     }
     return v;
 }
 
 // (has? table key)
-value_t fl_table_has(value_t *args, uint32_t nargs)
+value_t fl_table_has(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("has", nargs, 2);
-    htable_t *h = totable(args[0], "has");
-    return equalhash_has(h, (void*)args[1]) ? FL_T : FL_F;
+    argcount(fl_ctx, "has", nargs, 2);
+    htable_t *h = totable(fl_ctx, args[0], "has");
+    return equalhash_has_r(h, (void*)args[1], (void*)fl_ctx) ? fl_ctx->T : fl_ctx->F;
 }
 
 // (del! table key)
-value_t fl_table_del(value_t *args, uint32_t nargs)
+value_t fl_table_del(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("del!", nargs, 2);
-    htable_t *h = totable(args[0], "del!");
-    if (!equalhash_remove(h, (void*)args[1]))
-        key_error("del!", args[1]);
+    argcount(fl_ctx, "del!", nargs, 2);
+    htable_t *h = totable(fl_ctx, args[0], "del!");
+    if (!equalhash_remove_r(h, (void*)args[1], (void*)fl_ctx))
+        key_error(fl_ctx, "del!", args[1]);
     return args[0];
 }
 
-value_t fl_table_foldl(value_t *args, uint32_t nargs)
+value_t fl_table_foldl(fl_context_t *fl_ctx, value_t *args, uint32_t nargs)
 {
-    argcount("table.foldl", nargs, 3);
+    argcount(fl_ctx, "table.foldl", nargs, 3);
     value_t f=args[0], zero=args[1], t=args[2];
-    htable_t *h = totable(t, "table.foldl");
+    htable_t *h = totable(fl_ctx, t, "table.foldl");
     size_t i, n = h->size;
     void **table = h->table;
-    fl_gc_handle(&f);
-    fl_gc_handle(&zero);
-    fl_gc_handle(&t);
+    fl_gc_handle(fl_ctx, &f);
+    fl_gc_handle(fl_ctx, &zero);
+    fl_gc_handle(fl_ctx, &t);
     for(i=0; i < n; i+=2) {
         if (table[i+1] != HT_NOTFOUND) {
-            zero = fl_applyn(3, f,
+            zero = fl_applyn(fl_ctx, 3, f,
                              (value_t)table[i],
                              (value_t)table[i+1],
                              zero);
             // reload pointer
             h = (htable_t*)cv_data((cvalue_t*)ptr(t));
             if (h->size != n)
-                lerror(EnumerationError, "table.foldl: table modified");
+                lerror(fl_ctx, fl_ctx->EnumerationError, "table.foldl: table modified");
             table = h->table;
         }
     }
-    fl_free_gc_handles(3);
+    fl_free_gc_handles(fl_ctx, 3);
     return zero;
 }
 
-static builtinspec_t tablefunc_info[] = {
+static const builtinspec_t tablefunc_info[] = {
     { "table", fl_table },
     { "table?", fl_tablep },
     { "put!", fl_table_put },
@@ -205,12 +200,17 @@ static builtinspec_t tablefunc_info[] = {
     { NULL, NULL }
 };
 
-void table_init(void)
+void table_init(fl_context_t *fl_ctx)
 {
-    tablesym = symbol("table");
-    tabletype = define_opaque_type(tablesym, sizeof(htable_t),
-                                   &table_vtable, NULL);
-    assign_global_builtins(tablefunc_info);
+    fl_ctx->table_vtable.print = print_htable;
+    fl_ctx->table_vtable.relocate = relocate_htable;
+    fl_ctx->table_vtable.finalize = free_htable;
+    fl_ctx->table_vtable.print_traverse = print_traverse_htable;
+
+    fl_ctx->tablesym = symbol(fl_ctx, "table");
+    fl_ctx->tabletype = define_opaque_type(fl_ctx->tablesym, sizeof(htable_t),
+                                           &fl_ctx->table_vtable, NULL);
+    assign_global_builtins(fl_ctx, tablefunc_info);
 }
 
 #ifdef __cplusplus
diff --git a/src/flisp/types.c b/src/flisp/types.c
index 734506bd07f80..945dce9ecc731 100644
--- a/src/flisp/types.c
+++ b/src/flisp/types.c
@@ -1,6 +1,6 @@
 #include "equalhash.h"
 
-fltype_t *get_type(value_t t)
+fltype_t *get_type(fl_context_t *fl_ctx, value_t t)
 {
     fltype_t *ft;
     if (issymbol(t)) {
@@ -8,24 +8,24 @@ fltype_t *get_type(value_t t)
         if (ft != NULL)
             return ft;
     }
-    void **bp = equalhash_bp(&TypeTable, (void*)t);
+    void **bp = equalhash_bp_r(&fl_ctx->TypeTable, (void*)t, (void*)fl_ctx);
     if (*bp != HT_NOTFOUND)
         return (fltype_t*)*bp;
 
-    int align, isarray=(iscons(t) && car_(t) == arraysym && iscons(cdr_(t)));
+    int align, isarray=(iscons(t) && car_(t) == fl_ctx->arraysym && iscons(cdr_(t)));
     size_t sz;
     if (isarray && !iscons(cdr_(cdr_(t)))) {
         // special case: incomplete array type
         sz = 0;
     }
     else {
-        sz = ctype_sizeof(t, &align);
+        sz = ctype_sizeof(fl_ctx, t, &align);
     }
 
     ft = (fltype_t*)malloc(sizeof(fltype_t));
     ft->type = t;
     if (issymbol(t)) {
-        ft->numtype = sym_to_numtype(t);
+        ft->numtype = sym_to_numtype(fl_ctx, t);
         ((symbol_t*)ptr(t))->type = ft;
     }
     else {
@@ -40,10 +40,10 @@ fltype_t *get_type(value_t t)
     ft->init = NULL;
     if (iscons(t)) {
         if (isarray) {
-            fltype_t *eltype = get_type(car_(cdr_(t)));
+            fltype_t *eltype = get_type(fl_ctx, car_(cdr_(t)));
             if (eltype->size == 0) {
                 free(ft);
-                lerror(ArgError, "invalid array element type");
+                lerror(fl_ctx, fl_ctx->ArgError, "invalid array element type");
             }
             ft->elsz = eltype->size;
             ft->eltype = eltype;
@@ -55,15 +55,15 @@ fltype_t *get_type(value_t t)
     return ft;
 }
 
-fltype_t *get_array_type(value_t eltype)
+fltype_t *get_array_type(fl_context_t *fl_ctx, value_t eltype)
 {
-    fltype_t *et = get_type(eltype);
+    fltype_t *et = get_type(fl_ctx, eltype);
     if (et->artype != NULL)
         return et->artype;
-    return get_type(fl_list2(arraysym, eltype));
+    return get_type(fl_ctx, fl_list2(fl_ctx, fl_ctx->arraysym, eltype));
 }
 
-fltype_t *define_opaque_type(value_t sym, size_t sz, cvtable_t *vtab,
+fltype_t *define_opaque_type(value_t sym, size_t sz, const cvtable_t *vtab,
                              cvinitfunc_t init)
 {
     fltype_t *ft = (fltype_t*)malloc(sizeof(fltype_t));
@@ -79,14 +79,14 @@ fltype_t *define_opaque_type(value_t sym, size_t sz, cvtable_t *vtab,
     return ft;
 }
 
-void relocate_typetable(void)
+void relocate_typetable(fl_context_t *fl_ctx)
 {
-    htable_t *h = &TypeTable;
+    htable_t *h = &fl_ctx->TypeTable;
     size_t i;
     void *nv;
     for(i=0; i < h->size; i+=2) {
         if (h->table[i] != HT_NOTFOUND) {
-            nv = (void*)relocate((value_t)h->table[i]);
+            nv = (void*)relocate(fl_ctx, (value_t)h->table[i]);
             h->table[i] = nv;
             if (h->table[i+1] != HT_NOTFOUND)
                 ((fltype_t*)h->table[i+1])->type = (value_t)nv;
diff --git a/src/gc-debug.c b/src/gc-debug.c
index 3743f2a4c72c4..274dd37dd6494 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -16,8 +16,7 @@ region_t *jl_gc_find_region(void *ptr, int maybe)
 // singleton object), this usually returns the same pointer which points to
 // the next object but it can also return NULL if the pointer is pointing to
 // the end of the page.
-DLLEXPORT jl_taggedvalue_t *jl_gc_find_taggedvalue_pool(char *p,
-                                                        size_t *osize_p)
+JL_DLLEXPORT jl_taggedvalue_t *jl_gc_find_taggedvalue_pool(char *p, size_t *osize_p)
 {
     region_t *r = find_region(p, 1);
     // Not in the pool
@@ -55,12 +54,12 @@ void jl_(void *jl_value);
 
 // mark verification
 #ifdef GC_VERIFY
-static jl_value_t* lostval = 0;
+static jl_value_t *lostval = 0;
 static arraylist_t lostval_parents;
 static arraylist_t lostval_parents_done;
 static int verifying;
 
-static void add_lostval_parent(jl_value_t* parent)
+static void add_lostval_parent(jl_value_t *parent)
 {
     for(int i = 0; i < lostval_parents_done.len; i++) {
         if ((jl_value_t*)lostval_parents_done.items[i] == parent)
@@ -139,21 +138,27 @@ static void clear_mark(int bits)
             bits_save[i].len = 0;
         }
     }
-    void *current_heap = NULL;
-    bigval_t *bigs[2];
-    bigs[0] = big_objects;
-    bigs[1] = big_objects_marked;
-    for (int i = 0; i < 2; i++) {
-        bigval_t *v = bigs[i];
+    bigval_t *v;
+    FOR_EACH_HEAP () {
+        v = big_objects;
         while (v != NULL) {
-            void* gcv = &v->header;
+            void *gcv = &v->header;
             if (!verifying) arraylist_push(&bits_save[gc_bits(gcv)], gcv);
             gc_bits(gcv) = bits;
             v = v->next;
         }
     }
+
+    v = big_objects_marked;
+    while (v != NULL) {
+        void *gcv = &v->header;
+        if (!verifying) arraylist_push(&bits_save[gc_bits(gcv)], gcv);
+        gc_bits(gcv) = bits;
+        v = v->next;
+    }
+
     for (int h = 0; h < REGION_COUNT; h++) {
-        region_t* region = regions[h];
+        region_t *region = regions[h];
         if (!region) break;
         for (int pg_i = 0; pg_i < REGION_PG_COUNT/32; pg_i++) {
             uint32_t line = region->freemap[pg_i];
@@ -161,7 +166,9 @@ static void clear_mark(int bits)
                 for (int j = 0; j < 32; j++) {
                     if (!((line >> j) & 1)) {
                         gcpage_t *pg = page_metadata(&region->pages[pg_i*32 + j][0] + GC_PAGE_OFFSET);
-                        pool_t *pool = &norm_pools[pg->pool_n];
+                        pool_t *pool;
+                        FOR_HEAP (pg->thread_n)
+                            pool = &pools[pg->pool_n];
                         pv = (gcval_t*)(pg->data + GC_PAGE_OFFSET);
                         char *lim = (char*)pv + GC_PAGE_SZ - GC_PAGE_OFFSET - pool->osize;
                         while ((char*)pv <= lim) {
@@ -198,12 +205,12 @@ static void gc_verify_track(void)
             jl_printf(JL_STDERR, "Could not find the missing link. We missed a toplevel root. This is odd.\n");
             break;
         }
-        jl_value_t* lostval_parent = NULL;
+        jl_value_t *lostval_parent = NULL;
         for(int i = 0; i < lostval_parents.len; i++) {
             lostval_parent = (jl_value_t*)lostval_parents.items[i];
             int clean_len = bits_save[GC_CLEAN].len;
             for(int j = 0; j < clean_len + bits_save[GC_QUEUED].len; j++) {
-                void* p = bits_save[j >= clean_len ? GC_QUEUED : GC_CLEAN].items[j >= clean_len ? j - clean_len : j];
+                void *p = bits_save[j >= clean_len ? GC_QUEUED : GC_CLEAN].items[j >= clean_len ? j - clean_len : j];
                 if (jl_valueof(p) == lostval_parent) {
                     lostval = lostval_parent;
                     lostval_parent = NULL;
@@ -213,7 +220,7 @@ static void gc_verify_track(void)
             if (lostval_parent != NULL) break;
         }
         if (lostval_parent == NULL) { // all parents of lostval were also scheduled for deletion
-            lostval = arraylist_pop(&lostval_parents);
+            lostval = (jl_value_t*)arraylist_pop(&lostval_parents);
         }
         else {
             jl_printf(JL_STDERR, "Missing write barrier found !\n");
@@ -238,7 +245,7 @@ static void gc_verify(void)
     post_mark(&finalizer_list_marked, 1);
     int clean_len = bits_save[GC_CLEAN].len;
     for(int i = 0; i < clean_len + bits_save[GC_QUEUED].len; i++) {
-        gcval_t* v = (gcval_t*)bits_save[i >= clean_len ? GC_QUEUED : GC_CLEAN].items[i >= clean_len ? i - clean_len : i];
+        gcval_t *v = (gcval_t*)bits_save[i >= clean_len ? GC_QUEUED : GC_CLEAN].items[i >= clean_len ? i - clean_len : i];
         if (gc_marked(v)) {
             jl_printf(JL_STDERR, "Error. Early free of %p type :", v);
             jl_(jl_typeof(jl_valueof(v)));
@@ -256,6 +263,8 @@ static void gc_verify(void)
     }
     restore();
     gc_verify_track();
+    gc_debug_print_status();
+    gc_debug_critical_error();
     abort();
 }
 
@@ -276,21 +285,27 @@ typedef struct {
     uint64_t max;
 } jl_alloc_num_t;
 
-DLLEXPORT struct {
+typedef struct {
     int sweep_mask;
+    int wait_for_debugger;
     jl_alloc_num_t pool;
     jl_alloc_num_t other;
     jl_alloc_num_t print;
-} gc_debug_env = {GC_MARKED_NOESC,
-                  {0, 0, 0, 0},
-                  {0, 0, 0, 0},
-                  {0, 0, 0, 0}};
+} jl_gc_debug_env_t;
+
+JL_DLLEXPORT jl_gc_debug_env_t jl_gc_debug_env = {
+    GC_MARKED_NOESC,
+    0,
+    {0, 0, 0, 0},
+    {0, 0, 0, 0},
+    {0, 0, 0, 0}
+};
 
 static void gc_debug_alloc_init(jl_alloc_num_t *num, const char *name)
 {
     // Not very generic and robust but good enough for a debug option
     char buff[128];
-    sprintf(buff, "JL_GC_ALLOC_%s", name);
+    sprintf(buff, "JULIA_GC_ALLOC_%s", name);
     char *env = getenv(buff);
     if (!env)
         return;
@@ -309,42 +324,52 @@ static int gc_debug_alloc_check(jl_alloc_num_t *num)
 }
 
 static char *gc_stack_lo;
-static void gc_debug_init()
+static void gc_debug_init(void)
 {
     gc_stack_lo = (char*)gc_get_stack_ptr();
-    char *env = getenv("JL_GC_NO_GENERATIONAL");
-    if (env && strcmp(env, "0") != 0) {
-        gc_debug_env.sweep_mask = GC_MARKED;
-    }
-    gc_debug_alloc_init(&gc_debug_env.pool, "POOL");
-    gc_debug_alloc_init(&gc_debug_env.other, "OTHER");
-    gc_debug_alloc_init(&gc_debug_env.print, "PRINT");
+    char *env = getenv("JULIA_GC_NO_GENERATIONAL");
+    if (env && strcmp(env, "0") != 0)
+        jl_gc_debug_env.sweep_mask = GC_MARKED;
+    env = getenv("JULIA_GC_WAIT_FOR_DEBUGGER");
+    jl_gc_debug_env.wait_for_debugger = env && strcmp(env, "0") != 0;
+    gc_debug_alloc_init(&jl_gc_debug_env.pool, "POOL");
+    gc_debug_alloc_init(&jl_gc_debug_env.other, "OTHER");
+    gc_debug_alloc_init(&jl_gc_debug_env.print, "PRINT");
 }
 
-static inline int gc_debug_check_pool()
+static inline int gc_debug_check_pool(void)
 {
-    return gc_debug_alloc_check(&gc_debug_env.pool);
+    return gc_debug_alloc_check(&jl_gc_debug_env.pool);
 }
 
-static inline int gc_debug_check_other()
+static inline int gc_debug_check_other(void)
 {
-    return gc_debug_alloc_check(&gc_debug_env.other);
+    return gc_debug_alloc_check(&jl_gc_debug_env.other);
 }
 
-void gc_debug_print_status()
+void gc_debug_print_status(void)
 {
-    uint64_t pool_count = gc_debug_env.pool.num;
-    uint64_t other_count = gc_debug_env.other.num;
-    jl_printf(JL_STDOUT,
-              "Allocations: %" PRIu64 " "
-              "(Pool: %" PRIu64 "; Other: %" PRIu64 "); GC: %d\n",
-              pool_count + other_count, pool_count, other_count,
-              n_pause);
+    uint64_t pool_count = jl_gc_debug_env.pool.num;
+    uint64_t other_count = jl_gc_debug_env.other.num;
+    jl_safe_printf("Allocations: %" PRIu64 " "
+                   "(Pool: %" PRIu64 "; Other: %" PRIu64 "); GC: %d\n",
+                   pool_count + other_count, pool_count, other_count, n_pause);
 }
 
-static inline void gc_debug_print()
+void gc_debug_critical_error(void)
 {
-    if (!gc_debug_alloc_check(&gc_debug_env.print))
+    gc_debug_print_status();
+    if (!jl_gc_debug_env.wait_for_debugger)
+        return;
+    jl_safe_printf("Waiting for debugger to attach\n");
+    while (1) {
+        sleep(1000);
+    }
+}
+
+static inline void gc_debug_print(void)
+{
+    if (!gc_debug_alloc_check(&jl_gc_debug_env.print))
         return;
     gc_debug_print_status();
 }
@@ -382,21 +407,35 @@ static void gc_scrub(char *stack_hi)
 
 #else
 
-static inline int gc_debug_check_other()
+static inline int gc_debug_check_other(void)
 {
     return 0;
 }
 
-static inline int gc_debug_check_pool()
+static inline int gc_debug_check_pool(void)
 {
     return 0;
 }
 
-static inline void gc_debug_print()
+void gc_debug_print_status(void)
+{
+    // May not be accurate but should be helpful enough
+    uint64_t pool_count = gc_num.poolalloc;
+    uint64_t big_count = gc_num.bigalloc;
+    jl_safe_printf("Allocations: %" PRIu64 " "
+                   "(Pool: %" PRIu64 "; Big: %" PRIu64 "); GC: %d\n",
+                   pool_count + big_count, pool_count, big_count, n_pause);
+}
+
+void gc_debug_critical_error(void)
+{
+}
+
+static inline void gc_debug_print(void)
 {
 }
 
-static inline void gc_debug_init()
+static inline void gc_debug_init(void)
 {
 }
 
diff --git a/src/gc.c b/src/gc.c
index 30cc8da014119..75f51b4898880 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -21,9 +21,10 @@
 #include <inttypes.h>
 #include "julia.h"
 #include "julia_internal.h"
+#include "threading.h"
 #ifndef _OS_WINDOWS_
 #include <sys/mman.h>
-#ifdef _OS_DARWIN_
+#if defined(_OS_DARWIN_) && !defined(MAP_ANONYMOUS)
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 #endif
@@ -32,6 +33,42 @@
 extern "C" {
 #endif
 
+JL_DEFINE_MUTEX(pagealloc)
+// Protect all access to `finalizer_list`, `finalizer_list_marked` and
+// `to_finalize`.
+JL_DEFINE_MUTEX(finalizers)
+
+/**
+ * Note about GC synchronization:
+ *
+ * When entering `jl_gc_collect()`, `jl_gc_running` is atomically changed from
+ * `0` to `1` to make sure that only one thread can be running the GC. Other
+ * threads that enters `jl_gc_collect()` at the same time (or later calling
+ * from unmanaged code) will wait in `jl_gc_collect()` until the GC is finished.
+ *
+ * Before starting the mark phase the GC thread calls `jl_gc_signal_begin()`
+ * to make sure all the thread are in a safe state for the GC. The function
+ * activates the safepoint and wait for all the threads to get ready for the
+ * GC (`gc_state != 0`). It also acquires the `finalizers` lock so that no
+ * other thread will access them when the GC is running.
+ *
+ * During the mark and sweep phase of the GC, the threads that are not running
+ * the GC should either be running unmanaged code (or code section that does
+ * not have a GC critical region mainly including storing to the stack or
+ * another object) or paused at a safepoint and wait for the GC to finish.
+ * If a thread want to switch from running unmanaged code to running managed
+ * code, it has to perform a GC safepoint check after setting the `gc_state`
+ * flag (see `jl_gc_state_save_and_set()`. it is possible that the thread might
+ * have `gc_state == 0` in the middle of the GC transition back before entering
+ * the safepoint. This is fine since the thread won't be executing any GC
+ * critical region during that time).
+ *
+ * The finalizers are run after the GC finishes in normal mode (the `gc_state`
+ * when `jl_gc_collect` is called) with `jl_in_finalizer = 1`. (TODO:) When we
+ * have proper support of GC transition in codegen, we should execute the
+ * finalizers in unmanaged (GC safe) mode.
+ */
+
 // manipulating mark bits
 
 #define GC_CLEAN 0 // freshly allocated
@@ -39,8 +76,6 @@ extern "C" {
 #define GC_QUEUED 2 // if it is reachable it will be marked as old
 #define GC_MARKED_NOESC (GC_MARKED | GC_QUEUED) // reachable and young
 
-#define jl_valueof(v) (&((jl_taggedvalue_t*)(v))->value)
-
 // This struct must be kept in sync with the Julia type of the same name in base/util.jl
 typedef struct {
     int64_t     allocd;
@@ -74,7 +109,7 @@ typedef struct _buff_t {
     union {
         uintptr_t header;
         struct _buff_t *next;
-        uptrint_t flags;
+        uintptr_t flags;
         jl_value_t *type; // 16-bytes aligned
         struct {
             uintptr_t gc_bits:2;
@@ -98,13 +133,13 @@ typedef struct _bigval_t {
     struct _bigval_t **prev; // pointer to the next field of the prev entry
     union {
         size_t sz;
-        uptrint_t age : 2;
+        uintptr_t age : 2;
     };
     //struct buff_t <>;
     union {
-        uptrint_t header;
-        uptrint_t flags;
-        uptrint_t gc_bits:2;
+        uintptr_t header;
+        uintptr_t flags;
+        uintptr_t gc_bits:2;
     };
     // Work around a bug affecting gcc up to (at least) version 4.4.7
     // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=36839
@@ -150,6 +185,7 @@ typedef struct _gcpage_t {
     uint16_t osize; // size of each object in this page
     uint16_t fl_begin_offset; // offset of first free object in this page
     uint16_t fl_end_offset;   // offset of last free object in this page
+    uint16_t thread_n;        // index (into jl_thread_heap) of heap that owns this page
     char *data;
     uint8_t *ages;
 } gcpage_t;
@@ -178,7 +214,7 @@ typedef struct {
     uint32_t freemap[REGION_PG_COUNT/32];
     gcpage_t meta[REGION_PG_COUNT];
 } region_t
-#ifndef _COMPILER_MICROSOFT_
+#if !defined(_COMPILER_MICROSOFT_) && !(defined(_COMPILER_MINGW_) && defined(_COMPILER_CLANG_))
 __attribute__((aligned(GC_PAGE_SZ)))
 #endif
 ;
@@ -189,60 +225,88 @@ static int regions_lb[REGION_COUNT] = {0};
 // an upper bound of the last non-free page
 static int regions_ub[REGION_COUNT] = {REGION_PG_COUNT/32-1};
 
-// Variables that become fields of a thread-local struct in the thread-safe
-// version.
-
-#define HEAP_DECL static
-
-// variable for tracking preserved values.
-HEAP_DECL arraylist_t preserved_values;
+// Variables that become fields of a thread-local struct in the thread-safe version.
+typedef struct _jl_thread_heap_t {
+    // variable for tracking weak references
+    arraylist_t weak_refs;
 
-// variable for tracking weak references
-HEAP_DECL arraylist_t weak_refs;
+    // variables for tracking malloc'd arrays
+    mallocarray_t *mallocarrays;
+    mallocarray_t *mafreelist;
 
-// variables for tracking malloc'd arrays
-HEAP_DECL mallocarray_t *mallocarrays;
-HEAP_DECL mallocarray_t *mafreelist;
+    // variables for tracking big objects
+    bigval_t *big_objects;
 
-// variables for tracking big objects
-HEAP_DECL bigval_t *big_objects;
+    // variables for tracking "remembered set"
+    arraylist_t rem_bindings;
+    arraylist_t _remset[2]; // contains jl_value_t*
+    // lower bound of the number of pointers inside remembered values
+    int remset_nptr;
+    arraylist_t *remset;
+    arraylist_t *last_remset;
 
-// variables for tracking "remembered set"
-HEAP_DECL arraylist_t rem_bindings;
-HEAP_DECL arraylist_t _remset[2]; // contains jl_value_t*
-// lower bound of the number of pointers inside remembered values
-static int remset_nptr;
-HEAP_DECL arraylist_t *remset;
-HEAP_DECL arraylist_t *last_remset;
-
-// variables for allocating objects from pools
+    // variables for allocating objects from pools
 #ifdef _P64
 #define N_POOLS 41
 #else
 #define N_POOLS 43
 #endif
-HEAP_DECL pool_t norm_pools[N_POOLS];
+    pool_t norm_pools[N_POOLS];
+} jl_thread_heap_t;
 
-// End of Variables that become fields of a thread-local struct in the thread-safe version.
+typedef struct {
+    int index;
+    jl_thread_heap_t *heap;
+} jl_each_heap_index_t;
+
+typedef struct {
+    int i;
+    jl_thread_heap_t *heap;
+} jl_single_heap_index_t;
+
+#define current_heap __current_heap_idx.heap
+#define current_heap_index __current_heap_idx.index
+// This chould trigger a false positive warning with both gcc and clang
+// since the compiler couldn't figure out that the loop is executed at least
+// once.
+// gcc bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68336
+// clang bug: https://llvm.org/bugs/show_bug.cgi?id=25521
+#define _FOR_SINGLE_HEAP(heap)                                          \
+    for (jl_single_heap_index_t __current_heap_idx = {1, heap};         \
+         --__current_heap_idx.i >= 0;)
+#define FOR_CURRENT_HEAP() _FOR_SINGLE_HEAP(jl_thread_heap)
 
 // The following macros are used for accessing these variables.
-// In the future multi-threaded version, they establish the desired thread context.
+// In the multi-threaded version, they establish the desired thread context.
 // In the single-threaded version, they are essentially noops, but nonetheless
 // serve to check that the thread context macros are being used.
-#define FOR_CURRENT_HEAP {void *current_heap=NULL;
-#define END }
-#define FOR_EACH_HEAP {void *current_heap=NULL;
-/*}*/
-#define HEAP(x) (*((void)current_heap,&(x)))
-#define preserved_values HEAP(preserved_values)
+#ifdef JULIA_ENABLE_THREADING
+#define jl_thread_heap (jl_get_ptls_states()->heap)
+#define FOR_EACH_HEAP()                                                 \
+    for (jl_each_heap_index_t __current_heap_idx = {jl_n_threads, NULL}; \
+         --current_heap_index >= 0 &&                                   \
+             ((current_heap = jl_all_heaps[current_heap_index]), 1);)
+#define FOR_HEAP(t_n) _FOR_SINGLE_HEAP(jl_all_heaps[t_n])
+/*}}*/
+#else
+static jl_thread_heap_t _jl_thread_heap;
+static jl_thread_heap_t *const jl_thread_heap = &_jl_thread_heap;
+#define FOR_EACH_HEAP()                                                 \
+    for (jl_each_heap_index_t __current_heap_idx = {1, jl_thread_heap}; \
+         --current_heap_index >= 0;)
+#define FOR_HEAP(t_n) _FOR_SINGLE_HEAP(jl_thread_heap)
+#endif
+
+#define HEAP(x) (current_heap->x)
 #define weak_refs HEAP(weak_refs)
 #define big_objects HEAP(big_objects)
 #define mallocarrays HEAP(mallocarrays)
 #define mafreelist HEAP(mafreelist)
 #define remset HEAP(remset)
+#define remset_nptr HEAP(remset_nptr)
 #define last_remset HEAP(last_remset)
 #define rem_bindings HEAP(rem_bindings)
-#define pools norm_pools
+#define pools HEAP(norm_pools)
 
 // List of marked big objects.  Not per-thread.  Accessed only by master thread.
 static bigval_t *big_objects_marked = NULL;
@@ -268,7 +332,7 @@ static region_t *find_region(void *ptr, int maybe);
     ((GC_PAGE_DATA((data) - GC_PAGE_OFFSET) - \
       &(region)->pages[0][0])/GC_PAGE_SZ)
 
-NOINLINE static uintptr_t gc_get_stack_ptr()
+NOINLINE static uintptr_t gc_get_stack_ptr(void)
 {
     void *dummy = NULL;
     // The mask is to suppress the compiler warning about returning
@@ -278,39 +342,109 @@ NOINLINE static uintptr_t gc_get_stack_ptr()
 
 #include "gc-debug.c"
 
-int jl_in_gc; // referenced from switchto task.c
-static int jl_gc_finalizers_inhibited; // don't run finalizers during codegen #11956
+// Only one thread can be doing the collection right now. That thread set
+// `jl_running_gc` to one on entering the GC and set it back afterward.
+static volatile uint64_t jl_gc_running = 0;
 
-// malloc wrappers, aligned allocation
+#ifdef JULIA_ENABLE_THREADING
+JL_DLLEXPORT volatile size_t *jl_gc_signal_page = NULL;
 
-#if defined(_P64) || defined(__APPLE__)
-#define malloc_a16(sz) malloc(sz)
-#define realloc_a16(p, sz, oldsz) realloc((p), (sz))
-#define free_a16(p) free(p)
+static void jl_wait_for_gc(void)
+{
+    while (jl_gc_running) {
+        jl_cpu_pause(); // yield?
+    }
+}
 
-#elif defined(_OS_WINDOWS_) /* 32-bit OS is implicit here. */
-#define malloc_a16(sz) _aligned_malloc((sz)?(sz):1, 16)
-#define realloc_a16(p, sz, oldsz) _aligned_realloc((p), (sz)?(sz):1, 16)
-#define free_a16(p) _aligned_free(p)
+void jl_gc_signal_wait(void)
+{
+    int8_t state = jl_gc_state();
+    jl_get_ptls_states()->gc_state = JL_GC_STATE_WAITING;
+    jl_wait_for_gc();
+    jl_get_ptls_states()->gc_state = state;
+}
 
-#else
-static inline void *malloc_a16(size_t sz)
+static void jl_gc_wait_for_the_world(void)
 {
-    void *ptr;
-    if (posix_memalign(&ptr, 16, sz))
-        return NULL;
-    return ptr;
+    for (int i = 0;i < jl_n_threads;i++) {
+        jl_tls_states_t *ptls = jl_all_task_states[i].ptls;
+        while (!ptls->gc_state) {
+            jl_cpu_pause(); // yield?
+        }
+    }
 }
-static inline void *realloc_a16(void *d, size_t sz, size_t oldsz)
+
+void jl_gc_signal_init(void)
 {
-    void *b = malloc_a16(sz);
-    if (b != NULL) {
-        memcpy(b, d, oldsz);
-        free(d);
+    // jl_page_size isn't available yet.
+#ifdef _OS_WINDOWS_
+    jl_gc_signal_page = (size_t*)VirtualAlloc(NULL, jl_getpagesize(),
+                                              MEM_COMMIT, PAGE_READONLY);
+#else
+    jl_gc_signal_page = (size_t*)mmap(0, jl_getpagesize(), PROT_READ,
+                                      MAP_NORESERVE | MAP_PRIVATE |
+                                      MAP_ANONYMOUS, -1, 0);
+    if (jl_gc_signal_page == MAP_FAILED)
+        jl_gc_signal_page = NULL;
+#endif
+    if (jl_gc_signal_page == NULL) {
+        jl_printf(JL_STDERR, "could not allocate GC synchronization page\n");
+        gc_debug_critical_error();
+        abort();
     }
-    return b;
 }
+
+static void jl_gc_signal_begin(void)
+{
+#ifdef __APPLE__
+    // This needs to be after setting `jl_gc_running` so that only one thread
+    // can talk to the signal handler
+    jl_mach_gc_begin();
+#endif
+#ifdef _OS_WINDOWS_
+    DWORD old_prot;
+    VirtualProtect((void*)jl_gc_signal_page, jl_page_size,
+                   PAGE_NOACCESS, &old_prot);
+#else
+    mprotect((void*)jl_gc_signal_page, jl_page_size, PROT_NONE);
+#endif
+    jl_gc_wait_for_the_world();
+    JL_LOCK_NOGC(finalizers);
+}
+
+static void jl_gc_signal_end(void)
+{
+    JL_UNLOCK_NOGC(finalizers);
+#ifdef _OS_WINDOWS_
+    DWORD old_prot;
+    VirtualProtect((void*)jl_gc_signal_page, jl_page_size,
+                   PAGE_READONLY, &old_prot);
+#else
+    mprotect((void*)jl_gc_signal_page, jl_page_size, PROT_READ);
+#endif
+#ifdef __APPLE__
+    jl_mach_gc_end();
+#endif
+}
+#else
+
+#define jl_gc_signal_begin()
+#define jl_gc_signal_end()
+
+#endif
+
+static int jl_gc_finalizers_inhibited; // don't run finalizers during codegen #11956
+
+// malloc wrappers, aligned allocation
+
+#if defined(_P64) || defined(__APPLE__)
+#define malloc_a16(sz) malloc(sz)
+#define realloc_a16(p, sz, oldsz) realloc((p), (sz))
 #define free_a16(p) free(p)
+#else
+#define malloc_a16(sz) jl_malloc_aligned(sz, 16)
+#define realloc_a16(p, sz, oldsz) jl_realloc_aligned(p, sz, oldsz, 16)
+#define free_a16(p) jl_free_aligned(p)
 #endif
 
 static void schedule_finalization(void *o, void *f)
@@ -321,10 +455,9 @@ static void schedule_finalization(void *o, void *f)
 
 static void run_finalizer(jl_value_t *o, jl_value_t *ff)
 {
-    jl_function_t *f = (jl_function_t*)ff;
-    assert(jl_is_function(f));
+    jl_value_t *args[2] = {ff,o};
     JL_TRY {
-        jl_apply(f, (jl_value_t**)&o, 1);
+        jl_apply(args, 2);
     }
     JL_CATCH {
         jl_printf(JL_STDERR, "error in running finalizer: ");
@@ -333,51 +466,82 @@ static void run_finalizer(jl_value_t *o, jl_value_t *ff)
     }
 }
 
-static int finalize_object(jl_value_t *o)
+static void finalize_object(arraylist_t *list, jl_value_t *o,
+                            arraylist_t *copied_list)
 {
-    int success = 0;
-    jl_value_t *f = NULL;
-    JL_GC_PUSH1(&f);
-    for(int i = 0; i < finalizer_list.len; i+=2) {
-        if (o == (jl_value_t*)finalizer_list.items[i]) {
-            f = (jl_value_t*)finalizer_list.items[i+1];
-            if (i < finalizer_list.len - 2) {
-                finalizer_list.items[i] = finalizer_list.items[finalizer_list.len-2];
-                finalizer_list.items[i+1] = finalizer_list.items[finalizer_list.len-1];
+    for(int i = 0; i < list->len; i+=2) {
+        if (o == (jl_value_t*)list->items[i]) {
+            void *f = list->items[i+1];
+            if (i < list->len - 2) {
+                list->items[i] = list->items[list->len-2];
+                list->items[i+1] = list->items[list->len-1];
                 i -= 2;
             }
-            finalizer_list.len -= 2;
-            run_finalizer(o, f);
-            success = 1;
+            list->len -= 2;
+            arraylist_push(copied_list, o);
+            arraylist_push(copied_list, f);
         }
     }
+}
+
+// The first two entries are assumed to be empty and the rest are assumed to
+// be pointers to `jl_value_t` objects
+static void jl_gc_push_arraylist(arraylist_t *list)
+{
+    list->items[0] = (void*)(((uintptr_t)list->len - 2) << 1);
+    list->items[1] = jl_pgcstack;
+    jl_pgcstack = (jl_gcframe_t*)list->items;
+}
+
+// Same assumption as `jl_gc_push_arraylist`. Requires the finalizers lock
+// to be hold for the current thread and will release the lock when the
+// function returns.
+static void jl_gc_run_finalizers_in_list(arraylist_t *list)
+{
+    size_t len = list->len;
+    jl_value_t **items = (jl_value_t**)list->items;
+    jl_gc_push_arraylist(list);
+    JL_UNLOCK_NOGC(finalizers);
+    for (size_t i = 2;i < len;i += 2) {
+        run_finalizer(items[i], items[i + 1]);
+    }
     JL_GC_POP();
-    return success;
 }
 
 static void run_finalizers(void)
 {
-    void *o = NULL, *f = NULL;
-    JL_GC_PUSH2(&o, &f);
-    while (to_finalize.len > 0) {
-        f = arraylist_pop(&to_finalize);
-        o = arraylist_pop(&to_finalize);
-        run_finalizer((jl_value_t*)o, (jl_value_t*)f);
+    JL_LOCK_NOGC(finalizers);
+    if (to_finalize.len == 0) {
+        JL_UNLOCK_NOGC(finalizers);
+        return;
     }
-    JL_GC_POP();
+    arraylist_t copied_list;
+    memcpy(&copied_list, &to_finalize, sizeof(copied_list));
+    if (to_finalize.items == to_finalize._space) {
+        copied_list.items = copied_list._space;
+    }
+    arraylist_new(&to_finalize, 0);
+    // empty out the first two entries for the GC frame
+    arraylist_push(&copied_list, copied_list.items[0]);
+    arraylist_push(&copied_list, copied_list.items[1]);
+    // This releases the finalizers lock.
+    jl_gc_run_finalizers_in_list(&copied_list);
+    arraylist_free(&copied_list);
 }
 
 void jl_gc_inhibit_finalizers(int state)
 {
-    if (jl_gc_finalizers_inhibited && !state && !jl_in_gc) {
-        jl_in_gc = 1;
+    // NOTE: currently only called with the codegen lock held, but might need
+    // more synchronization in the future
+    if (jl_gc_finalizers_inhibited && !state && !jl_in_finalizer) {
+        jl_in_finalizer = 1;
         run_finalizers();
-        jl_in_gc = 0;
+        jl_in_finalizer = 0;
     }
     jl_gc_finalizers_inhibited = state;
 }
 
-static void schedule_all_finalizers(arraylist_t* flist)
+static void schedule_all_finalizers(arraylist_t *flist)
 {
     // Multi-thread version should steal the entire list while holding a lock.
     for(size_t i=0; i < flist->len; i+=2) {
@@ -391,20 +555,43 @@ static void schedule_all_finalizers(arraylist_t* flist)
 
 void jl_gc_run_all_finalizers(void)
 {
+    JL_LOCK_NOGC(finalizers);
     schedule_all_finalizers(&finalizer_list);
     schedule_all_finalizers(&finalizer_list_marked);
+    JL_UNLOCK_NOGC(finalizers);
     run_finalizers();
 }
 
-DLLEXPORT void jl_gc_add_finalizer(jl_value_t *v, jl_function_t *f)
+JL_DLLEXPORT void jl_gc_add_finalizer(jl_value_t *v, jl_function_t *f)
 {
+    JL_LOCK_NOGC(finalizers);
     arraylist_push(&finalizer_list, (void*)v);
     arraylist_push(&finalizer_list, (void*)f);
-}
-
-void jl_finalize(jl_value_t *o)
-{
-    (void)finalize_object(o);
+    JL_UNLOCK_NOGC(finalizers);
+}
+
+JL_DLLEXPORT void jl_finalize(jl_value_t *o)
+{
+    JL_LOCK_NOGC(finalizers);
+    // Copy the finalizers into a temporary list so that code in the finalizer
+    // won't change the list as we loop through them.
+    // This list is also used as the GC frame when we are running the finalizers
+    arraylist_t copied_list;
+    arraylist_new(&copied_list, 0);
+    arraylist_push(&copied_list, NULL); // GC frame size to be filled later
+    arraylist_push(&copied_list, NULL); // pgcstack to be filled later
+    // No need to check the to_finalize list since the user is apparently
+    // still holding a reference to the object
+    finalize_object(&finalizer_list, o, &copied_list);
+    finalize_object(&finalizer_list_marked, o, &copied_list);
+    if (copied_list.len > 2) {
+        // This releases the finalizers lock.
+        jl_gc_run_finalizers_in_list(&copied_list);
+    }
+    else {
+        JL_UNLOCK_NOGC(finalizers);
+    }
+    arraylist_free(&copied_list);
 }
 
 static region_t *find_region(void *ptr, int maybe)
@@ -462,7 +649,7 @@ static htable_t obj_counts[3];
 static htable_t obj_sizes[3];
 #endif
 
-DLLEXPORT size_t jl_gc_total_freed_bytes=0;
+JL_DLLEXPORT size_t jl_gc_total_freed_bytes=0;
 #ifdef GC_FINAL_STATS
 static uint64_t max_pause = 0;
 static uint64_t total_sweep_time = 0;
@@ -518,29 +705,27 @@ static int64_t perm_scanned_bytes; // old bytes scanned while marking
 static int prev_sweep_mask = GC_MARKED;
 static size_t scanned_bytes_goal;
 
-#ifdef OBJPROFILE
-static void *BUFFTY = (void*)0xdeadb00f;
-#endif
-static void *MATY = (void*)0xdeadaa01;
+static const uintptr_t jl_buff_tag = 0x4eade800;
+static void *const jl_malloc_tag = (void*)0xdeadaa01;
 static size_t array_nbytes(jl_array_t*);
-static inline void objprofile_count(void* ty, int old, int sz)
+static inline void objprofile_count(void *ty, int old, int sz)
 {
 #ifdef OBJPROFILE
 #ifdef GC_VERIFY
     if (verifying) return;
 #endif
     if ((intptr_t)ty <= 0x10)
-        ty = BUFFTY;
+        ty = (void*)jl_buff_tag;
     void **bp = ptrhash_bp(&obj_counts[old], ty);
     if (*bp == HT_NOTFOUND)
         *bp = (void*)2;
     else
-        (*((ptrint_t*)bp))++;
+        (*((intptr_t*)bp))++;
     bp = ptrhash_bp(&obj_sizes[old], ty);
     if (*bp == HT_NOTFOUND)
-        *bp = (void*)(1 + sz);
+        *bp = (void*)(intptr_t)(1 + sz);
     else
-        *((ptrint_t*)bp) += sz;
+        *((intptr_t*)bp) += sz;
 #endif
 }
 
@@ -553,67 +738,65 @@ static inline void objprofile_count(void* ty, int old, int sz)
 
 #define inc_sat(v,s) v = (v) >= s ? s : (v)+1
 
-static inline int gc_setmark_big(void *o, int mark_mode)
+static inline int gc_setmark_big(void *o, int bits)
 {
+    int mark_mode = GC_MARKED_NOESC;
 #ifdef GC_VERIFY
     if (verifying) {
         _gc_setmark(o, mark_mode);
         return 0;
     }
 #endif
+    assert(find_region(o,1) == NULL);
     bigval_t* hdr = bigval_header(o);
-    int bits = gc_bits(o);
     if (bits == GC_QUEUED || bits == GC_MARKED)
         mark_mode = GC_MARKED;
-    if ((mark_mode == GC_MARKED) & (bits != GC_MARKED)) {
-        // Move hdr from big_objects list to big_objects_marked list
-        *hdr->prev = hdr->next;
-        if (hdr->next)
-            hdr->next->prev = hdr->prev;
-        hdr->next = big_objects_marked;
-        hdr->prev = &big_objects_marked;
-        if (big_objects_marked)
-            big_objects_marked->prev = &hdr->next;
-        big_objects_marked = hdr;
-    }
     if (!(bits & GC_MARKED)) {
+        if ((mark_mode == GC_MARKED) & (bits != GC_MARKED)) {
+            // Move hdr from big_objects list to big_objects_marked list
+            *hdr->prev = hdr->next;
+            if (hdr->next)
+                hdr->next->prev = hdr->prev;
+            hdr->next = big_objects_marked;
+            hdr->prev = &big_objects_marked;
+            if (big_objects_marked)
+                big_objects_marked->prev = &hdr->next;
+            big_objects_marked = hdr;
+        }
         if (mark_mode == GC_MARKED)
             perm_scanned_bytes += hdr->sz&~3;
         else
             scanned_bytes += hdr->sz&~3;
-#ifdef OBJPROFILE
-        objprofile_count(jl_typeof(o), mark_mode == GC_MARKED, hdr->sz&~3);
-#endif
+        objprofile_count(jl_typeof(jl_valueof(o)),
+                         mark_mode == GC_MARKED, hdr->sz&~3);
+        _gc_setmark(o, mark_mode);
     }
-    _gc_setmark(o, mark_mode);
     verify_val(jl_valueof(o));
     return mark_mode;
 }
 
-static inline int gc_setmark_pool(void *o, int mark_mode)
+static inline int gc_setmark_pool(void *o, int bits)
 {
+    int mark_mode = GC_MARKED_NOESC;
 #ifdef GC_VERIFY
     if (verifying) {
         _gc_setmark(o, mark_mode);
         return mark_mode;
     }
 #endif
-    gcpage_t* page = page_metadata(o);
-    int bits = gc_bits(o);
-    if (bits == GC_QUEUED || bits == GC_MARKED) {
+    if (bits == GC_QUEUED || bits == GC_MARKED)
         mark_mode = GC_MARKED;
-    }
     if (!(bits & GC_MARKED)) {
+        gcpage_t* page = page_metadata(o);
         if (mark_mode == GC_MARKED)
             perm_scanned_bytes += page->osize;
         else
             scanned_bytes += page->osize;
-#ifdef OBJPROFILE
-        objprofile_count(jl_typeof(o), mark_mode == GC_MARKED, page->osize);
-#endif
+        objprofile_count(jl_typeof(jl_valueof(o)),
+                         mark_mode == GC_MARKED, page->osize);
+        _gc_setmark(o, mark_mode);
+        page->gc_bits |= mark_mode;
     }
-    _gc_setmark(o, mark_mode);
-    page->gc_bits |= mark_mode;
     verify_val(jl_valueof(o));
     return mark_mode;
 }
@@ -638,36 +821,43 @@ static inline int gc_setmark(jl_value_t *v, int sz, int mark_mode)
 inline void gc_setmark_buf(void *o, int mark_mode)
 {
     buff_t *buf = gc_val_buf(o);
+    int bits = gc_bits(buf);
+    if (mark_mode == GC_MARKED && bits != GC_MARKED) {
+        _gc_setmark(buf, GC_QUEUED);
+        bits = GC_QUEUED;
+    }
 #ifdef MEMDEBUG
-    gc_setmark_big(buf, mark_mode);
+    gc_setmark_big(buf, bits);
     return;
 #endif
     if (buf->pooled)
-        gc_setmark_pool(buf, mark_mode);
+        gc_setmark_pool(buf, bits);
     else
-        gc_setmark_big(buf, mark_mode);
+        gc_setmark_big(buf, bits);
 }
 
 static NOINLINE void *malloc_page(void)
 {
     void *ptr = (void*)0;
     int i;
-    region_t* region;
+    region_t *region;
     int region_i = 0;
+    JL_LOCK_NOGC(pagealloc);
     while(region_i < REGION_COUNT) {
         region = regions[region_i];
         if (region == NULL) {
             size_t alloc_size = sizeof(region_t);
 #ifdef _OS_WINDOWS_
-            char* mem = (char*)VirtualAlloc(NULL, sizeof(region_t) + GC_PAGE_SZ, MEM_RESERVE, PAGE_READWRITE);
+            char *mem = (char*)VirtualAlloc(NULL, sizeof(region_t) + GC_PAGE_SZ, MEM_RESERVE, PAGE_READWRITE);
 #else
             if (GC_PAGE_SZ > jl_page_size)
                 alloc_size += GC_PAGE_SZ;
-            char* mem = (char*)mmap(0, alloc_size, PROT_READ | PROT_WRITE, MAP_NORESERVE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+            char *mem = (char*)mmap(0, alloc_size, PROT_READ | PROT_WRITE, MAP_NORESERVE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
             mem = mem == MAP_FAILED ? NULL : mem;
 #endif
             if (mem == NULL) {
                 jl_printf(JL_STDERR, "could not allocate pools\n");
+                gc_debug_critical_error();
                 abort();
             }
             if (GC_PAGE_SZ > jl_page_size) {
@@ -698,6 +888,7 @@ static NOINLINE void *malloc_page(void)
     }
     if (region_i >= REGION_COUNT) {
         jl_printf(JL_STDERR, "increase REGION_COUNT or allocate less memory\n");
+        gc_debug_critical_error();
         abort();
     }
     if (regions_lb[region_i] < i)
@@ -721,6 +912,7 @@ static NOINLINE void *malloc_page(void)
 #endif
     current_pg_count++;
     max_pg_count = max_pg_count < current_pg_count ? current_pg_count : max_pg_count;
+    JL_UNLOCK_NOGC(pagealloc);
     return ptr;
 }
 
@@ -770,56 +962,32 @@ static inline int maybe_collect(void)
         jl_gc_collect(0);
         return 1;
     }
+    jl_gc_safepoint();
     return 0;
 }
 
-
-// preserved values
-
-DLLEXPORT int jl_gc_n_preserved_values(void)
-{
-    FOR_CURRENT_HEAP
-        return preserved_values.len;
-    END
-}
-
-DLLEXPORT void jl_gc_preserve(jl_value_t *v)
-{
-    FOR_CURRENT_HEAP
-        arraylist_push(&preserved_values, (void*)v);
-    END
-}
-
-DLLEXPORT void jl_gc_unpreserve(void)
-{
-    FOR_CURRENT_HEAP
-        (void)arraylist_pop(&preserved_values);
-    END
-}
-
 // weak references
 
-DLLEXPORT jl_weakref_t *jl_gc_new_weakref(jl_value_t *value)
+JL_DLLEXPORT jl_weakref_t *jl_gc_new_weakref(jl_value_t *value)
 {
     jl_weakref_t *wr = (jl_weakref_t*)jl_gc_alloc_1w();
     jl_set_typeof(wr, jl_weakref_type);
-    wr->value = value;
-    FOR_CURRENT_HEAP
+    wr->value = value;  // NOTE: wb not needed here
+    FOR_CURRENT_HEAP ()
         arraylist_push(&weak_refs, wr);
-    END
     return wr;
 }
 
 static void sweep_weak_refs(void)
 {
-    FOR_EACH_HEAP
+    FOR_EACH_HEAP () {
         size_t n=0, ndel=0, l=weak_refs.len;
         jl_weakref_t *wr;
         void **lst = weak_refs.items;
         void *tmp;
 #define SWAP_wr(a,b) (tmp=a,a=b,b=tmp,1)
         if (l == 0)
-            return;
+            continue;
         do {
             wr = (jl_weakref_t*)lst[n];
             if (gc_marked(jl_astaggedvalue(wr))) {
@@ -834,7 +1002,7 @@ static void sweep_weak_refs(void)
         } while ((n < l-ndel) && SWAP_wr(lst[n],lst[n+ndel]));
 
         weak_refs.len -= ndel;
-    END
+    }
 }
 
 // big value list
@@ -849,7 +1017,7 @@ static NOINLINE void *alloc_big(size_t sz)
     bigval_t *v = (bigval_t*)malloc_a16(allocsz);
     if (v == NULL)
         jl_throw(jl_memory_exception);
-    allocd_bytes += allocsz;
+    jl_atomic_fetch_add(&allocd_bytes, allocsz);
     gc_num.bigalloc++;
 #ifdef MEMDEBUG
     memset(v, 0xee, allocsz);
@@ -857,13 +1025,13 @@ static NOINLINE void *alloc_big(size_t sz)
     v->sz = allocsz;
     v->flags = 0;
     v->age = 0;
-    FOR_CURRENT_HEAP
+    FOR_CURRENT_HEAP () {
         v->next = big_objects;
         v->prev = &big_objects;
         if (v->next)
             v->next->prev = &v->next;
         big_objects = v;
-    END
+    }
     return (void*)&v->header;
 }
 
@@ -873,7 +1041,7 @@ static int big_reset;
 
 // Sweep list rooted at *pv, removing and freeing any unmarked objects.
 // Return pointer to last `next` field in the culled list.
-static bigval_t** sweep_big_list(int sweep_mask, bigval_t** pv)
+static bigval_t **sweep_big_list(int sweep_mask, bigval_t **pv)
 {
     bigval_t *v = *pv;
     while (v != NULL) {
@@ -917,20 +1085,19 @@ static bigval_t** sweep_big_list(int sweep_mask, bigval_t** pv)
 
 static void sweep_big(int sweep_mask)
 {
-    FOR_EACH_HEAP
+    FOR_EACH_HEAP ()
         sweep_big_list(sweep_mask, &big_objects);
-    END
     if (sweep_mask == GC_MARKED) {
-        bigval_t** last_next = sweep_big_list(sweep_mask, &big_objects_marked);
+        bigval_t **last_next = sweep_big_list(sweep_mask, &big_objects_marked);
         // Move all survivors from big_objects_marked list to big_objects list.
-        FOR_CURRENT_HEAP
+        FOR_CURRENT_HEAP () {
             if (big_objects)
                 big_objects->prev = last_next;
             *last_next = big_objects;
             big_objects = big_objects_marked;
             if (big_objects)
                 big_objects->prev = &big_objects;
-        END
+        }
         big_objects_marked = NULL;
     }
 }
@@ -939,7 +1106,7 @@ static void sweep_big(int sweep_mask)
 
 void jl_gc_track_malloced_array(jl_array_t *a)
 {
-    FOR_CURRENT_HEAP
+    FOR_CURRENT_HEAP () {
         mallocarray_t *ma;
         if (mafreelist == NULL) {
             ma = (mallocarray_t*)malloc(sizeof(mallocarray_t));
@@ -951,7 +1118,7 @@ void jl_gc_track_malloced_array(jl_array_t *a)
         ma->a = a;
         ma->next = mallocarrays;
         mallocarrays = ma;
-    END
+    }
 }
 
 void jl_gc_count_allocd(size_t sz)
@@ -969,11 +1136,11 @@ static size_t array_nbytes(jl_array_t *a)
     return sz;
 }
 
-void jl_gc_free_array(jl_array_t *a)
+static void jl_gc_free_array(jl_array_t *a)
 {
-    if (a->how == 2) {
+    if (a->flags.how == 2) {
         char *d = (char*)a->data - a->offset*a->elsize;
-        if (a->isaligned)
+        if (a->flags.isaligned)
             free_a16(d);
         else
             free(d);
@@ -987,7 +1154,7 @@ static int mallocd_array_freed;
 
 static void sweep_malloced_arrays(void)
 {
-    FOR_EACH_HEAP
+    FOR_EACH_HEAP () {
         mallocarray_t *ma = mallocarrays;
         mallocarray_t **pma = &mallocarrays;
         while (ma != NULL) {
@@ -997,7 +1164,7 @@ static void sweep_malloced_arrays(void)
             }
             else {
                 *pma = nxt;
-                assert(ma->a->how == 2);
+                assert(ma->a->flags.how == 2);
                 jl_gc_free_array(ma->a);
                 ma->next = mafreelist;
                 mafreelist = ma;
@@ -1006,7 +1173,7 @@ static void sweep_malloced_arrays(void)
             mallocd_array_total++;
             ma = nxt;
         }
-    END
+    }
 }
 
 // pool allocation
@@ -1014,7 +1181,8 @@ static inline gcval_t *reset_page(pool_t *p, gcpage_t *pg, gcval_t *fl)
 {
     pg->gc_bits = 0;
     pg->nfree = (GC_PAGE_SZ - GC_PAGE_OFFSET) / p->osize;
-    pg->pool_n = p - norm_pools;
+    FOR_HEAP (pg->thread_n)
+        pg->pool_n = p - pools;
     memset(page_age(pg), 0, LLT_ALIGN(GC_PAGE_SZ / p->osize, 8));
     gcval_t *beg = (gcval_t*)(pg->data + GC_PAGE_OFFSET);
     gcval_t *end = (gcval_t*)((char*)beg + (pg->nfree - 1)*p->osize);
@@ -1034,30 +1202,38 @@ static NOINLINE void add_page(pool_t *p)
     pg->data = data;
     pg->osize = p->osize;
     pg->ages = (uint8_t*)malloc(LLT_ALIGN(GC_PAGE_SZ / p->osize, 8));
+    pg->thread_n = ti_tid;
     gcval_t *fl = reset_page(p, pg, p->newpages);
     p->newpages = fl;
 }
 
-static inline void *__pool_alloc(pool_t* p, int osize, int end_offset)
+static inline void *__pool_alloc(pool_t *p, int osize, int end_offset)
 {
+#ifdef MEMDEBUG
+    assert(0 && "Should not be using pools in MEMDEBUG mode");
+#endif
     gcval_t *v, *end;
+    // FIXME - need JL_ATOMIC_FETCH_AND_ADD here
     if (__unlikely((allocd_bytes += osize) >= 0) || gc_debug_check_pool()) {
         //allocd_bytes -= osize;
         jl_gc_collect(0);
         //allocd_bytes += osize;
     }
+    else {
+        jl_gc_safepoint();
+    }
     gc_num.poolalloc++;
     // first try to use the freelist
     v = p->freelist;
     if (v) {
-        gcval_t* next = v->next;
+        gcval_t *next = v->next;
         v->flags = 0;
         p->nfree--;
         p->freelist = next;
         if (__unlikely(GC_PAGE_DATA(v) != GC_PAGE_DATA(next))) {
             // we only update pg's fields when the freelist changes page
             // since pg's metadata is likely not in cache
-            gcpage_t* pg = page_metadata(v);
+            gcpage_t *pg = page_metadata(v);
             assert(pg->osize == p->osize);
             pg->nfree = 0;
             pg->allocd = 1;
@@ -1078,7 +1254,7 @@ static inline void *__pool_alloc(pool_t* p, int osize, int end_offset)
     }
     else {
         // like the freelist case, but only update the page metadata when it is full
-        gcpage_t* pg = page_metadata(v);
+        gcpage_t *pg = page_metadata(v);
         assert(pg->osize == p->osize);
         pg->nfree = 0;
         pg->allocd = 1;
@@ -1161,10 +1337,10 @@ static int total_pages = 0;
 static int freed_pages = 0;
 static int lazy_freed_pages = 0;
 static int page_done = 0;
-static gcval_t** sweep_page(pool_t* p, gcpage_t* pg, gcval_t **pfl,int,int);
-static void sweep_pool_region(gcval_t **pfl[N_POOLS], int region_i, int sweep_mask)
+static gcval_t **sweep_page(pool_t *p, gcpage_t *pg, gcval_t **pfl,int,int);
+static void sweep_pool_region(gcval_t ***pfl, int region_i, int sweep_mask)
 {
-    region_t* region = regions[region_i];
+    region_t *region = regions[region_i];
 
     // the actual sweeping
     int ub = 0;
@@ -1177,9 +1353,12 @@ static void sweep_pool_region(gcval_t **pfl[N_POOLS], int region_i, int sweep_ma
                 if (!((line >> j) & 1)) {
                     gcpage_t *pg = &region->meta[pg_i*32 + j];
                     int p_n = pg->pool_n;
-                    pool_t *p = &norm_pools[p_n];
+                    int t_n = pg->thread_n;
+                    pool_t *p = NULL;
+                    FOR_HEAP (t_n)
+                        p = &pools[p_n];
                     int osize = pg->osize;
-                    pfl[p_n] = sweep_page(p, pg, pfl[p_n], sweep_mask, osize);
+                    pfl[t_n * N_POOLS + p_n] = sweep_page(p, pg, pfl[t_n * N_POOLS + p_n], sweep_mask, osize);
                 }
             }
         }
@@ -1192,7 +1371,7 @@ static void sweep_pool_region(gcval_t **pfl[N_POOLS], int region_i, int sweep_ma
 }
 
 // Returns pointer to terminal pointer of list rooted at *pfl.
-static gcval_t** sweep_page(pool_t* p, gcpage_t* pg, gcval_t **pfl, int sweep_mask, int osize)
+static gcval_t **sweep_page(pool_t *p, gcpage_t *pg, gcval_t **pfl, int sweep_mask, int osize)
 {
 #ifdef FREE_PAGES_EAGER
     int freedall;
@@ -1278,11 +1457,12 @@ static gcval_t** sweep_page(pool_t* p, gcpage_t* pg, gcval_t **pfl, int sweep_ma
     // the eager one uses less memory.
     pg_total++;
     if (freedall) {
+        // FIXME - need to do accounting on a per-thread basis
         // on quick sweeps, keep a few pages empty but allocated for performance
         if (sweep_mask == GC_MARKED_NOESC && lazy_freed_pages <= default_collect_interval/GC_PAGE_SZ) {
             gcval_t *begin = reset_page(p, pg, 0);
-            gcval_t** pend = (gcval_t**)((char*)begin + ((int)pg->nfree - 1)*osize);
-            gcval_t* npg = p->newpages;
+            gcval_t **pend = (gcval_t**)((char*)begin + ((int)pg->nfree - 1)*osize);
+            gcval_t *npg = p->newpages;
             *pend = npg;
             p->newpages = begin;
             begin->next = (gcval_t*)0;
@@ -1316,32 +1496,24 @@ static gcval_t** sweep_page(pool_t* p, gcpage_t* pg, gcval_t **pfl, int sweep_ma
     return pfl;
 }
 
-//extern void jl_unmark_symbols(void);
-
 static void gc_sweep_once(int sweep_mask)
 {
 #ifdef GC_TIME
-    double t0 = clock_now();
+    double t0 = jl_clock_now();
     mallocd_array_total = 0;
     mallocd_array_freed = 0;
 #endif
     sweep_malloced_arrays();
 #ifdef GC_TIME
-    jl_printf(JL_STDOUT, "GC sweep arrays %.2f (freed %d/%d)\n", (clock_now() - t0)*1000, mallocd_array_freed, mallocd_array_total);
-    t0 = clock_now();
+    jl_printf(JL_STDOUT, "GC sweep arrays %.2f (freed %d/%d)\n", (jl_clock_now() - t0)*1000, mallocd_array_freed, mallocd_array_total);
+    t0 = jl_clock_now();
     big_total = 0;
     big_freed = 0;
     big_reset = 0;
 #endif
     sweep_big(sweep_mask);
 #ifdef GC_TIME
-    jl_printf(JL_STDOUT, "GC sweep big %.2f (freed %d/%d with %d rst)\n", (clock_now() - t0)*1000, big_freed, big_total, big_reset);
-    t0 = clock_now();
-#endif
-    //if (sweep_mask == GC_MARKED)
-    //    jl_unmark_symbols();
-#ifdef GC_TIME
-    jl_printf(JL_STDOUT, "GC sweep symbols %.2f\n", (clock_now() - t0)*1000);
+    jl_printf(JL_STDOUT, "GC sweep big %.2f (freed %d/%d with %d rst)\n", (jl_clock_now() - t0)*1000, big_freed, big_total, big_reset);
 #endif
 }
 
@@ -1349,7 +1521,7 @@ static void gc_sweep_once(int sweep_mask)
 static int gc_sweep_inc(int sweep_mask)
 {
 #ifdef GC_TIME
-    double t0 = clock_now();
+    double t0 = jl_clock_now();
 #endif
     skipped_pages = 0;
     total_pages = 0;
@@ -1358,31 +1530,31 @@ static int gc_sweep_inc(int sweep_mask)
     page_done = 0;
     int finished = 1;
 
-    gcval_t **pfl[N_POOLS];
+    gcval_t ***pfl = (gcval_t ***) alloca(jl_n_threads * N_POOLS * sizeof(gcval_t**));
 
     // update metadata of pages that were pointed to by freelist or newpages from a pool
     // i.e. pages being the current allocation target
-    FOR_EACH_HEAP
+    FOR_EACH_HEAP () {
         for (int i = 0; i < N_POOLS; i++) {
-            pool_t* p = &HEAP(norm_pools)[i];
-            gcval_t* last = p->freelist;
+            pool_t *p = &pools[i];
+            gcval_t *last = p->freelist;
             if (last) {
-                gcpage_t* pg = page_metadata(last);
+                gcpage_t *pg = page_metadata(last);
                 pg->allocd = 1;
                 pg->nfree = p->nfree;
             }
             p->freelist =  NULL;
-            pfl[i] = &p->freelist;
+            pfl[current_heap_index * N_POOLS + i] = &p->freelist;
 
             last = p->newpages;
             if (last) {
-                gcpage_t* pg = page_metadata(last);
+                gcpage_t *pg = page_metadata(last);
                 pg->nfree = (GC_PAGE_SZ - ((char*)last - GC_PAGE_DATA(last))) / p->osize;
                 pg->allocd = 1;
             }
             p->newpages = NULL;
         }
-    END
+    }
 
     for (int i = 0; i < REGION_COUNT; i++) {
         if (regions[i])
@@ -1391,18 +1563,18 @@ static int gc_sweep_inc(int sweep_mask)
 
 
     // null out terminal pointers of free lists and cache back pg->nfree in the pool_t
-    FOR_EACH_HEAP
+    FOR_EACH_HEAP () {
         for (int i = 0; i < N_POOLS; i++) {
-            pool_t* p = &HEAP(norm_pools)[i];
-            *pfl[i] = NULL;
+            pool_t *p = &pools[i];
+            *pfl[current_heap_index * N_POOLS + i] = NULL;
             if (p->freelist) {
                 p->nfree = page_metadata(p->freelist)->nfree;
             }
         }
-    END
+    }
 
 #ifdef GC_TIME
-    double sweep_pool_sec = clock_now() - t0;
+    double sweep_pool_sec = jl_clock_now() - t0;
     double sweep_speed = ((((double)total_pages)*GC_PAGE_SZ)/(1024*1024*1024))/sweep_pool_sec;
     jl_printf(JL_STDOUT, "GC sweep pools %s %.2f at %.1f GB/s (skipped %d%% of %d, done %d pgs, %d freed with %d lazily) mask %d\n", finished ? "end" : "inc", sweep_pool_sec*1000, sweep_speed, total_pages ? (skipped_pages*100)/total_pages : 0, total_pages, page_done, freed_pages, lazy_freed_pages,  sweep_mask);
 #endif
@@ -1435,34 +1607,46 @@ static int max_msp = 0;
 
 static void reset_remset(void)
 {
-    FOR_EACH_HEAP
+    FOR_EACH_HEAP () {
         arraylist_t *tmp = remset;
         remset = last_remset;
         last_remset = tmp;
         remset->len = 0;
         remset_nptr = 0;
-    END
+    }
 }
 
-DLLEXPORT void jl_gc_queue_root(jl_value_t *ptr)
+JL_DLLEXPORT void jl_gc_queue_root(jl_value_t *ptr)
 {
-    FOR_CURRENT_HEAP
+    FOR_CURRENT_HEAP () {
         jl_taggedvalue_t *o = jl_astaggedvalue(ptr);
+#ifndef JULIA_ENABLE_THREADING
+        // Disable this assert since it can happen with multithreading (same
+        // with the ones in gc_queue_binding) when two threads are writing
+        // to the same object.
         assert(gc_bits(o) != GC_QUEUED);
+#endif
+        // The modification of the `gc_bits` is not atomic but it
+        // should be safe here since GC is not allowed to run here and we only
+        // write GC_QUEUED to the GC bits outside GC. This could cause
+        // duplicated objects in the remset but that shouldn't be a problem.
         gc_bits(o) = GC_QUEUED;
         arraylist_push(remset, ptr);
         remset_nptr++; // conservative
-    END
+    }
 }
 
 void gc_queue_binding(jl_binding_t *bnd)
 {
-    FOR_CURRENT_HEAP
+    FOR_CURRENT_HEAP () {
         buff_t *buf = gc_val_buf(bnd);
+#ifndef JULIA_ENABLE_THREADING
+        // Will fail for multithreading. See `jl_gc_queue_root`
         assert(gc_bits(buf) != GC_QUEUED);
+#endif
         gc_bits(buf) = GC_QUEUED;
         arraylist_push(&rem_bindings, bnd);
-    END
+    }
 }
 
 static int push_root(jl_value_t *v, int d, int);
@@ -1476,7 +1660,7 @@ static inline int gc_push_root(void *v, int d) // v isa jl_value_t*
         jl_raise_debugger();
 #endif
     assert(v != NULL);
-    jl_taggedvalue_t* o = jl_astaggedvalue(v);
+    jl_taggedvalue_t *o = jl_astaggedvalue(v);
     verify_val(v);
     int bits = gc_bits(o);
     if (!gc_marked(o)) {
@@ -1490,18 +1674,22 @@ void jl_gc_setmark(jl_value_t *v) // TODO rename this as it is misleading now
     //    int64_t s = perm_scanned_bytes;
     jl_taggedvalue_t *o = jl_astaggedvalue(v);
     if (!gc_marked(o)) {
-        //        objprofile_count(jl_typeof(v), 1, 16);
 #ifdef MEMDEBUG
-        gc_setmark_big(o, GC_MARKED_NOESC);
+        gc_setmark_big(o, gc_bits(o));
 #else
-        gc_setmark_pool(o, GC_MARKED_NOESC);
+        gc_setmark_pool(o, gc_bits(o));
 #endif
     }
     //    perm_scanned_bytes = s;
 }
 
-static void gc_mark_stack(jl_value_t* ta, jl_gcframe_t *s, ptrint_t offset, int d)
+static char* gc_stack_top;
+static char* gc_stack_bot;
+static void gc_mark_stack(jl_value_t* ta, jl_gcframe_t *s, intptr_t offset, int d)
 {
+    jl_task_t *task = (jl_task_t*)ta;
+    char *stkbuf = task == jl_current_task ? gc_stack_top : task->stkbuf;
+    char *stkend = task == jl_current_task ? gc_stack_bot : stkbuf + task->ssize;
     while (s != NULL) {
         s = (jl_gcframe_t*)((char*)s + offset);
         jl_value_t ***rts = (jl_value_t***)(((void**)s)+2);
@@ -1515,9 +1703,17 @@ static void gc_mark_stack(jl_value_t* ta, jl_gcframe_t *s, ptrint_t offset, int
         }
         else {
             for(size_t i=0; i < nr; i++) {
-                if (rts[i] != NULL) {
+                void *v = rts[i];
+                if (v != NULL) {
                     verify_parent2("task", ta, &rts[i], "stack(%d)", (int)i);
-                    gc_push_root(rts[i], d);
+                    if (stkbuf <= (char*)v && (char*)v <= stkend) {
+                        // if v is on the stack it is kept permanently marked
+                        // but we still need to scan it once
+                        push_root(v, d, gc_bits(jl_astaggedvalue(v)));
+                    }
+                    else {
+                        gc_push_root(v, d);
+                    }
                 }
             }
         }
@@ -1535,11 +1731,12 @@ NOINLINE static int gc_mark_module(jl_module_t *m, int d)
             jl_binding_t *b = (jl_binding_t*)table[i];
             gc_setmark_buf(b, gc_bits(jl_astaggedvalue(m)));
 #ifdef GC_VERIFY
-            void* vb = gc_val_buf(b);
+            void *vb = gc_val_buf(b);
             verify_parent1("module", m, &vb, "binding_buff");
 #endif
             if (b->value != NULL) {
-                verify_parent2("module", m, &b->value, "binding(%s)", b->name->name);
+                verify_parent2("module", m, &b->value, "binding(%s)",
+                               jl_symbol_name(b->name));
                 refyoung |= gc_push_root(b->value, d);
             }
             if (b->globalref != NULL)
@@ -1553,10 +1750,6 @@ NOINLINE static int gc_mark_module(jl_module_t *m, int d)
     for(i=0; i < m->usings.len; i++) {
         refyoung |= gc_push_root(m->usings.items[i], d);
     }
-    if (m->constant_table) {
-        verify_parent1("module", m, &m->constant_table, "constant_table");
-        refyoung |= gc_push_root(m->constant_table, d);
-    }
 
     if (m->parent) {
         refyoung |= gc_push_root(m->parent, d);
@@ -1567,30 +1760,32 @@ NOINLINE static int gc_mark_module(jl_module_t *m, int d)
 
 static void gc_mark_task_stack(jl_task_t *ta, int d)
 {
-    if (ta->stkbuf != NULL || ta == jl_current_task) {
-        if (ta->stkbuf != NULL) {
-            gc_setmark_buf(ta->stkbuf, gc_bits(jl_astaggedvalue(ta)));
-        }
+    int stkbuf = (ta->stkbuf != (void*)(intptr_t)-1 && ta->stkbuf != NULL);
+    int16_t tid = ta->tid;
+    jl_tls_states_t *ptls = jl_all_task_states[tid].ptls;
+    if (stkbuf) {
+#ifndef COPY_STACKS
+        if (ta != ptls->root_task) // stkbuf isn't owned by julia for the root task
+#endif
+        gc_setmark_buf(ta->stkbuf, gc_bits(jl_astaggedvalue(ta)));
+    }
+    if (ta == ptls->current_task) {
+        gc_mark_stack((jl_value_t*)ta, ptls->pgcstack, 0, d);
+    }
+    else if (stkbuf) {
+        intptr_t offset;
 #ifdef COPY_STACKS
-        ptrint_t offset;
-        if (ta == jl_current_task) {
-            offset = 0;
-            gc_mark_stack((jl_value_t*)ta, jl_pgcstack, offset, d);
-        }
-        else {
-            offset = (char *)ta->stkbuf - ((char *)jl_stackbase - ta->ssize);
-            gc_mark_stack((jl_value_t*)ta, ta->gcstack, offset, d);
-        }
+        offset = (char *)ta->stkbuf - ((char *)ptls->stackbase - ta->ssize);
 #else
-        gc_mark_stack((jl_value_t*)ta, ta->gcstack, 0, d);
+        offset = 0;
 #endif
+        gc_mark_stack((jl_value_t*)ta, ta->gcstack, offset, d);
     }
 }
 
 NOINLINE static void gc_mark_task(jl_task_t *ta, int d)
 {
     if (ta->parent) gc_push_root(ta->parent, d);
-    if (ta->last) gc_push_root(ta->last, d);
     gc_push_root(ta->tls, d);
     gc_push_root(ta->consumers, d);
     gc_push_root(ta->donenotify, d);
@@ -1605,7 +1800,7 @@ NOINLINE static void gc_mark_task(jl_task_t *ta, int d)
 // for chasing down unwanted references
 /*
 static jl_value_t *lookforme = NULL;
-DLLEXPORT void jl_gc_lookfor(jl_value_t *v) { lookforme = v; }
+JL_DLLEXPORT void jl_gc_lookfor(jl_value_t *v) { lookforme = v; }
 */
 
 #define MAX_MARK_DEPTH 400
@@ -1619,12 +1814,12 @@ static int push_root(jl_value_t *v, int d, int bits)
     int refyoung = 0, nptr = 0;
 
     if (vt == (jl_value_t*)jl_weakref_type) {
-        bits = gc_setmark(v, sizeof(jl_weakref_t), GC_MARKED_NOESC);
+        bits = gc_setmark(v, sizeof(jl_weakref_t), bits);
         goto ret;
     }
     if ((jl_is_datatype(vt) && ((jl_datatype_t*)vt)->pointerfree)) {
         int sz = jl_datatype_size(vt);
-        bits = gc_setmark(v, sz, GC_MARKED_NOESC);
+        bits = gc_setmark(v, sz, bits);
         goto ret;
     }
 #define MARK(v, s) do {                         \
@@ -1640,8 +1835,9 @@ static int push_root(jl_value_t *v, int d, int bits)
     // some values have special representations
     if (vt == (jl_value_t*)jl_simplevector_type) {
         size_t l = jl_svec_len(v);
-        MARK(v, bits = gc_setmark(v, l*sizeof(void*) + sizeof(jl_svec_t), GC_MARKED_NOESC));
-        jl_value_t **data = ((jl_svec_t*)v)->data;
+        MARK(v, bits = gc_setmark(v, l * sizeof(void*) +
+                                  sizeof(jl_svec_t), bits));
+        jl_value_t **data = jl_svec_data(v);
         nptr += l;
         for(size_t i=0; i < l; i++) {
             jl_value_t *elt = data[i];
@@ -1655,16 +1851,16 @@ static int push_root(jl_value_t *v, int d, int bits)
         jl_array_t *a = (jl_array_t*)v;
         jl_taggedvalue_t *o = jl_astaggedvalue(v);
         int todo = !(bits & GC_MARKED);
-        if (a->pooled)
+        if (a->flags.pooled)
 #ifdef MEMDEBUG
 #define _gc_setmark_pool gc_setmark_big
 #else
 #define _gc_setmark_pool gc_setmark_pool
 #endif
             MARK(a,
-                 bits = _gc_setmark_pool(o, GC_MARKED_NOESC);
-                 if (a->how == 2 && todo) {
-                     objprofile_count(MATY, gc_bits(o) == GC_MARKED, array_nbytes(a));
+                 bits = _gc_setmark_pool(o, bits);
+                 if (a->flags.how == 2 && todo) {
+                     objprofile_count(jl_malloc_tag, gc_bits(o) == GC_MARKED, array_nbytes(a));
                      if (gc_bits(o) == GC_MARKED)
                          perm_scanned_bytes += array_nbytes(a);
                      else
@@ -1672,27 +1868,27 @@ static int push_root(jl_value_t *v, int d, int bits)
                  });
         else
             MARK(a,
-                 bits = gc_setmark_big(o, GC_MARKED_NOESC);
-                 if (a->how == 2 && todo) {
-                     objprofile_count(MATY, gc_bits(o) == GC_MARKED, array_nbytes(a));
+                 bits = gc_setmark_big(o, bits);
+                 if (a->flags.how == 2 && todo) {
+                     objprofile_count(jl_malloc_tag, gc_bits(o) == GC_MARKED, array_nbytes(a));
                      if (gc_bits(o) == GC_MARKED)
                          perm_scanned_bytes += array_nbytes(a);
                      else
                          scanned_bytes += array_nbytes(a);
                  });
-        if (a->how == 3) {
+        if (a->flags.how == 3) {
             jl_value_t *owner = jl_array_data_owner(a);
             refyoung |= gc_push_root(owner, d);
             goto ret;
         }
-        else if (a->how == 1) {
+        else if (a->flags.how == 1) {
 #ifdef GC_VERIFY
-            void* val_buf = gc_val_buf((char*)a->data - a->offset*a->elsize);
+            void *val_buf = gc_val_buf((char*)a->data - a->offset*a->elsize);
             verify_parent1("array", v, &val_buf, "buffer ('loc' addr is meaningless)");
 #endif
             gc_setmark_buf((char*)a->data - a->offset*a->elsize, gc_bits(o));
         }
-        if (a->ptrarray && a->data!=NULL) {
+        if (a->flags.ptrarray && a->data!=NULL) {
             size_t l = jl_array_len(a);
             if (l > 100000 && d > MAX_MARK_DEPTH-10) {
                 // don't mark long arrays at high depth, to try to avoid
@@ -1716,12 +1912,12 @@ static int push_root(jl_value_t *v, int d, int bits)
     }
     else if (vt == (jl_value_t*)jl_module_type) {
         // should increase nptr here
-        MARK(v, bits = gc_setmark(v, sizeof(jl_module_t), GC_MARKED_NOESC));
+        MARK(v, bits = gc_setmark(v, sizeof(jl_module_t), bits));
         refyoung |= gc_mark_module((jl_module_t*)v, d);
     }
     else if (vt == (jl_value_t*)jl_task_type) {
         // ditto nptr
-        MARK(v, bits = gc_setmark(v, sizeof(jl_task_t), GC_MARKED_NOESC));
+        MARK(v, bits = gc_setmark(v, sizeof(jl_task_t), bits));
         gc_mark_task((jl_task_t*)v, d);
         // tasks should always be remarked since we do not trigger the write barrier
         // for stores to stack slots
@@ -1734,21 +1930,26 @@ static int push_root(jl_value_t *v, int d, int bits)
     else if (gc_typeof(vt) == (jl_value_t*)jl_datatype_type) {
         jl_datatype_t *dt = (jl_datatype_t*)vt;
         size_t dtsz;
-        if (dt == jl_datatype_type)
-            dtsz = NWORDS(sizeof(jl_datatype_t) + jl_datatype_nfields(v)*sizeof(jl_fielddesc_t))*sizeof(void*);
-        else
+        if (dt == jl_datatype_type) {
+            size_t fieldsize =
+                jl_fielddesc_size(((jl_datatype_t*)v)->fielddesc_type);
+            dtsz = NWORDS(sizeof(jl_datatype_t) +
+                          jl_datatype_nfields(v) * fieldsize) * sizeof(void*);
+        }
+        else {
             dtsz = jl_datatype_size(dt);
-        MARK(v, bits = gc_setmark(v, dtsz, GC_MARKED_NOESC));
+        }
+        MARK(v, bits = gc_setmark(v, dtsz, bits));
         int nf = (int)jl_datatype_nfields(dt);
         // TODO check if there is a perf improvement for objects with a lot of fields
         // int fdsz = sizeof(void*)*nf;
         // void** children = alloca(fdsz);
         // int ci = 0;
-        jl_fielddesc_t* fields = dt->fields;
         for(int i=0; i < nf; i++) {
-            if (fields[i].isptr) {
+            if (jl_field_isptr(dt, i)) {
                 nptr++;
-                jl_value_t **slot = (jl_value_t**)((char*)v + fields[i].offset);
+                jl_value_t **slot = (jl_value_t**)((char*)v +
+                                                   jl_field_offset(dt, i));
                 jl_value_t *fld = *slot;
                 if (fld) {
                     verify_parent2("object", v, slot, "field(%d)", i);
@@ -1762,7 +1963,9 @@ static int push_root(jl_value_t *v, int d, int bits)
     }
     else {
         jl_printf(JL_STDOUT, "GC error (probable corruption) :\n");
+        gc_debug_print_status();
         jl_(vt);
+        gc_debug_critical_error();
         abort();
     }
 
@@ -1771,11 +1974,11 @@ static int push_root(jl_value_t *v, int d, int bits)
     if (verifying) return bits;
 #endif
     if ((bits == GC_MARKED) && (refyoung == GC_MARKED_NOESC)) {
-        remset_nptr += nptr;
-        FOR_CURRENT_HEAP
+        FOR_CURRENT_HEAP () {
+            remset_nptr += nptr;
             // v is an old object referencing young objects
             arraylist_push(remset, v);
-        END
+        }
     }
     return bits;
 
@@ -1791,7 +1994,7 @@ static int push_root(jl_value_t *v, int d, int bits)
 static void visit_mark_stack_inc(int mark_mode)
 {
     while(mark_sp > 0 && !should_timeout()) {
-        jl_value_t* v = mark_stack[--mark_sp];
+        jl_value_t *v = mark_stack[--mark_sp];
         assert(gc_bits(jl_astaggedvalue(v)) == GC_QUEUED ||
                gc_bits(jl_astaggedvalue(v)) == GC_MARKED ||
                gc_bits(jl_astaggedvalue(v)) == GC_MARKED_NOESC);
@@ -1810,9 +2013,8 @@ static void visit_mark_stack(int mark_mode)
 
 void jl_mark_box_caches(void);
 
-extern JL_THREAD jl_value_t * volatile jl_task_arg_in_transit;
 #if defined(GCTIME) || defined(GC_FINAL_STATS)
-double clock_now(void);
+double jl_clock_now(void);
 #endif
 
 extern jl_module_t *jl_old_base_module;
@@ -1826,36 +2028,34 @@ static void pre_mark(void)
 {
     // modules
     gc_push_root(jl_main_module, 0);
-    gc_push_root(jl_current_module, 0);
     if (jl_old_base_module) gc_push_root(jl_old_base_module, 0);
     gc_push_root(jl_internal_main_module, 0);
-    gc_push_root(jl_root_task, 0);
-    gc_push_root(jl_current_task, 0);
+
+    size_t i;
+    for(i=0; i < jl_n_threads; i++) {
+        jl_tls_states_t *ptls = jl_all_task_states[i].ptls;
+        // current_module might not have a value when the thread is not
+        // running.
+        if (ptls->current_module)
+            gc_push_root(ptls->current_module, 0);
+        gc_push_root(ptls->current_task, 0);
+        gc_push_root(ptls->root_task, 0);
+        gc_push_root(ptls->exception_in_transit, 0);
+        gc_push_root(ptls->task_arg_in_transit, 0);
+    }
 
     // invisible builtin values
     if (jl_an_empty_cell) gc_push_root(jl_an_empty_cell, 0);
-    gc_push_root(jl_exception_in_transit, 0);
-    gc_push_root(jl_task_arg_in_transit, 0);
     if (jl_module_init_order != NULL)
         gc_push_root(jl_module_init_order, 0);
 
-    size_t i;
-
-    // stuff randomly preserved
-    FOR_EACH_HEAP
-        for(i=0; i < preserved_values.len; i++) {
-            gc_push_root((jl_value_t*)preserved_values.items[i], 0);
-        }
-    END
-
     // objects currently being finalized
     for(i=0; i < to_finalize.len; i++) {
         gc_push_root(to_finalize.items[i], 0);
     }
 
     jl_mark_box_caches();
-    gc_push_root(jl_unprotect_stack_func, 0);
-    gc_push_root(jl_bottom_func, 0);
+    //gc_push_root(jl_unprotect_stack_func, 0);
     gc_push_root(jl_typetype_type, 0);
 
     // constants
@@ -1910,21 +2110,35 @@ static void post_mark(arraylist_t *list, int dryrun)
 }
 
 // collector entry point and control
+static volatile uint64_t jl_gc_disable_counter = 0;
 
-static int is_gc_enabled = 1;
-DLLEXPORT int jl_gc_enable(int on)
+JL_DLLEXPORT int jl_gc_enable(int on)
 {
-    int prev = is_gc_enabled;
-    is_gc_enabled = (on!=0);
+    jl_tls_states_t *ptls = jl_get_ptls_states();
+    int prev = !ptls->disable_gc;
+    ptls->disable_gc = (on == 0);
+    if (on && !prev) {
+        // disable -> enable
+        jl_atomic_fetch_add(&jl_gc_disable_counter, -1);
+    }
+    else if (prev && !on) {
+        // enable -> disable
+        jl_atomic_fetch_add(&jl_gc_disable_counter, 1);
+        // check if the GC is running and wait for it to finish
+        jl_gc_safepoint();
+    }
     return prev;
 }
-DLLEXPORT int jl_gc_is_enabled(void) { return is_gc_enabled; }
+JL_DLLEXPORT int jl_gc_is_enabled(void)
+{
+    return !jl_get_ptls_states()->disable_gc;
+}
 
-DLLEXPORT int64_t jl_gc_total_bytes(void) { return total_allocd_bytes + allocd_bytes + collect_interval; }
-DLLEXPORT uint64_t jl_gc_total_hrtime(void) { return total_gc_time; }
-DLLEXPORT GC_Num jl_gc_num(void) { return gc_num; }
+JL_DLLEXPORT int64_t jl_gc_total_bytes(void) { return total_allocd_bytes + allocd_bytes + collect_interval; }
+JL_DLLEXPORT uint64_t jl_gc_total_hrtime(void) { return total_gc_time; }
+JL_DLLEXPORT GC_Num jl_gc_num(void) { return gc_num; }
 
-DLLEXPORT int64_t jl_gc_diff_total_bytes(void)
+JL_DLLEXPORT int64_t jl_gc_diff_total_bytes(void)
 {
     int64_t oldtb = last_gc_total_bytes;
     int64_t newtb = jl_gc_total_bytes();
@@ -1939,7 +2153,7 @@ static void big_obj_stats(void);
 #endif
 
 #ifdef OBJPROFILE
-static void reset_obj_profile()
+static void reset_obj_profile(void)
 {
     for(int g=0; g < 3; g++) {
         htable_reset(&obj_counts[g], 0);
@@ -1951,13 +2165,14 @@ static void print_obj_profile(htable_t nums, htable_t sizes)
 {
     for(int i=0; i < nums.size; i+=2) {
         if (nums.table[i+1] != HT_NOTFOUND) {
-            void* ty = nums.table[i];
-            int num = (int)nums.table[i+1] - 1;
-            size_t sz = (int)ptrhash_get(&sizes, ty) - 1;
-            jl_printf(JL_STDERR, "   %6d : %4d kB of ", num, sz/1024);
-            if (ty == BUFFTY)
+            void *ty = nums.table[i];
+            int num = (intptr_t)nums.table[i + 1] - 1;
+            size_t sz = (uintptr_t)ptrhash_get(&sizes, ty) - 1;
+            jl_printf(JL_STDERR, "   %6d : %4d kB of (%p) ",
+                      num, (int)(sz / 1024), ty);
+            if (ty == (void*)jl_buff_tag)
                 jl_printf(JL_STDERR, "buffer");
-            else if (ty == MATY)
+            else if (ty == jl_malloc_tag)
                 jl_printf(JL_STDERR, "malloc");
             else
                 jl_static_show(JL_STDERR, (jl_value_t*)ty);
@@ -1966,7 +2181,7 @@ static void print_obj_profile(htable_t nums, htable_t sizes)
     }
 }
 
-void print_obj_profiles(void)
+static void print_obj_profiles(void)
 {
     jl_printf(JL_STDERR, "Transient mark :\n");
     print_obj_profile(obj_counts[0], obj_sizes[0]);
@@ -1983,21 +2198,11 @@ static int saved_mark_sp = 0;
 static int sweep_mask = GC_MARKED;
 #define MIN_SCAN_BYTES 1024*1024
 
-static void gc_mark_task_stack(jl_task_t*,int);
-
-void prepare_sweep(void)
+// Only one thread should be running in this function
+static void _jl_gc_collect(int full, char *stack_hi)
 {
-}
-
-void jl_gc_collect(int full)
-{
-    if (!is_gc_enabled) return;
-    if (jl_in_gc) return;
-    char *stack_hi = (char*)gc_get_stack_ptr();
-    gc_debug_print();
-    JL_SIGATOMIC_BEGIN();
-    jl_in_gc = 1;
     uint64_t t0 = jl_hrtime();
+    gc_stack_top = (char*)&t0;
     int recollect = 0;
 #if defined(GC_TIME)
     int wb_activations = mark_sp - saved_mark_sp;
@@ -2016,7 +2221,7 @@ void jl_gc_collect(int full)
 
         // 1. mark every object in the remset
         reset_remset();
-        FOR_EACH_HEAP
+        FOR_EACH_HEAP () {
             // avoid counting remembered objects & bindings twice in perm_scanned_bytes
             for(int i = 0; i < last_remset->len; i++) {
                 jl_value_t *item = (jl_value_t*)last_remset->items[i];
@@ -2032,11 +2237,11 @@ void jl_gc_collect(int full)
                 jl_value_t *item = (jl_value_t*)last_remset->items[i];
                 push_root(item, 0, GC_MARKED);
             }
-        END
+        }
 
         // 2. mark every object in a remembered binding
-        int n_bnd_refyoung = 0;
-        FOR_EACH_HEAP
+        FOR_EACH_HEAP () {
+            int n_bnd_refyoung = 0;
             for (int i = 0; i < rem_bindings.len; i++) {
                 jl_binding_t *ptr = (jl_binding_t*)rem_bindings.items[i];
                 // A null pointer can happen here when the binding is cleaned up
@@ -2048,7 +2253,7 @@ void jl_gc_collect(int full)
                 }
             }
             rem_bindings.len = n_bnd_refyoung;
-        END
+        }
 
         // 3. walk roots
         pre_mark();
@@ -2060,9 +2265,9 @@ void jl_gc_collect(int full)
         uint64_t mark_pause = jl_hrtime() - t0;
 #endif
 #ifdef GC_TIME
-        FOR_EACH_HEAP
+        FOR_EACH_HEAP () {
             jl_printf(JL_STDOUT, "GC mark pause %.2f ms | scanned %ld kB = %ld + %ld | stack %d -> %d (wb %d) | remset %d %d\n", NS2MS(mark_pause), (scanned_bytes + perm_scanned_bytes)/1024, scanned_bytes/1024, perm_scanned_bytes/1024, saved_mark_sp, mark_sp, wb_activations, last_remset->len, remset_nptr);
-        END
+        }
         saved_mark_sp = mark_sp;
 #endif
 #ifdef GC_FINAL_STATS
@@ -2075,7 +2280,7 @@ void jl_gc_collect(int full)
     int64_t estimate_freed = -1;
 
 #if defined(GC_TIME) || defined(GC_FINAL_STATS)
-    uint64_t post_time = 0, finalize_time = 0;
+    uint64_t post_time = 0;
 #endif
     if (mark_sp == 0 || sweeping) {
 #if defined(GC_TIME) || defined(GC_FINAL_STATS)
@@ -2112,7 +2317,10 @@ void jl_gc_collect(int full)
                 promoted_bytes += perm_scanned_bytes - last_perm_scanned_bytes;
             // 5. next collection decision
             int not_freed_enough = estimate_freed < (7*(actual_allocd/10));
-            int large_frontier = remset_nptr*sizeof(void*) >= default_collect_interval; // many pointers in the intergen frontier => "quick" mark is not quick
+            int nptr = 0;
+            FOR_EACH_HEAP ()
+                nptr += remset_nptr;
+            int large_frontier = nptr*sizeof(void*) >= default_collect_interval; // many pointers in the intergen frontier => "quick" mark is not quick
             if ((full || large_frontier || ((not_freed_enough || promoted_bytes >= collect_interval) && (promoted_bytes >= default_collect_interval || prev_sweep_mask == GC_MARKED))) && n_pause > 1) {
                 if (prev_sweep_mask != GC_MARKED || full) {
                     if (full) recollect = 1; // TODO enable this?
@@ -2134,7 +2342,7 @@ void jl_gc_collect(int full)
             else {
                 collect_interval = default_collect_interval/2;
 #ifdef GC_DEBUG_ENV
-                sweep_mask = gc_debug_env.sweep_mask;
+                sweep_mask = jl_gc_debug_env.sweep_mask;
 #else
                 sweep_mask = GC_MARKED_NOESC;
 #endif
@@ -2152,7 +2360,7 @@ void jl_gc_collect(int full)
             // sweeping is over
             // 6. if it is a quick sweep, put back the remembered objects in queued state
             // so that we don't trigger the barrier again on them.
-            FOR_EACH_HEAP
+            FOR_EACH_HEAP () {
                 if (sweep_mask == GC_MARKED_NOESC) {
                     for (int i = 0; i < remset->len; i++) {
                         gc_bits(jl_astaggedvalue(remset->items[i])) = GC_QUEUED;
@@ -2167,7 +2375,7 @@ void jl_gc_collect(int full)
                     rem_bindings.len = 0;
                     n_full_sweep++;
                 }
-            END
+            }
 
             sweeping = 0;
 #ifdef GC_TIME
@@ -2184,26 +2392,16 @@ void jl_gc_collect(int full)
             allocd_bytes_since_sweep = 0;
             jl_gc_total_freed_bytes += freed_bytes;
             freed_bytes = 0;
-
-#if defined(GC_FINAL_STATS) || defined(GC_TIME)
-            finalize_time = jl_hrtime();
-#endif
-            if (!jl_gc_finalizers_inhibited) {
-                run_finalizers();
-            }
-#if defined(GC_FINAL_STATS) || defined(GC_TIME)
-            finalize_time = jl_hrtime() - finalize_time;
-#endif
         }
 #if defined(GC_FINAL_STATS) || defined(GC_TIME)
         uint64_t sweep_pause = jl_hrtime() - sweep_t0;
 #endif
 #ifdef GC_FINAL_STATS
-        total_sweep_time += sweep_pause - finalize_time - post_time;
-        total_fin_time += finalize_time + post_time;
+        total_sweep_time += sweep_pause - post_time;
+        total_fin_time += + post_time;
 #endif
 #ifdef GC_TIME
-        jl_printf(JL_STDOUT, "GC sweep pause %.2f ms live %ld kB (freed %d kB EST %d kB [error %d] = %d%% of allocd %d kB b/r %ld/%ld) (%.2f ms in post_mark, %.2f ms in %d fin) (marked in %d inc) mask %d | next in %d kB\n", NS2MS(sweep_pause), live_bytes/1024, SAVE2/1024, estimate_freed/1024, (SAVE2 - estimate_freed), pct, SAVE3/1024, bonus/1024, SAVE/1024, NS2MS(post_time), NS2MS(finalize_time), n_finalized, inc_count, sweep_mask, -allocd_bytes/1024);
+        jl_printf(JL_STDOUT, "GC sweep pause %.2f ms live %ld kB (freed %d kB EST %d kB [error %d] = %d%% of allocd %d kB b/r %ld/%ld) (%.2f ms in post_mark) (marked in %d inc) mask %d | next in %d kB\n", NS2MS(sweep_pause), live_bytes/1024, SAVE2/1024, estimate_freed/1024, (SAVE2 - estimate_freed), pct, SAVE3/1024, bonus/1024, SAVE/1024, NS2MS(post_time), inc_count, sweep_mask, -allocd_bytes/1024);
 #endif
     }
     n_pause++;
@@ -2212,8 +2410,7 @@ void jl_gc_collect(int full)
 #ifdef GC_FINAL_STATS
     max_pause = max_pause < pause ? pause : max_pause;
 #endif
-    jl_in_gc = 0;
-    JL_SIGATOMIC_END();
+
 #ifdef GC_TIME
     if (estimate_freed != SAVE2) {
         // this should not happen but it does
@@ -2222,7 +2419,54 @@ void jl_gc_collect(int full)
 #endif
     if (recollect) {
         n_pause--;
-        jl_gc_collect(0);
+        _jl_gc_collect(0, stack_hi);
+    }
+}
+
+JL_DLLEXPORT void jl_gc_collect(int full)
+{
+    if (jl_gc_disable_counter)
+        return;
+    char *stack_hi = (char*)gc_get_stack_ptr();
+    gc_debug_print();
+    JL_SIGATOMIC_BEGIN();
+
+    int8_t old_state = jl_gc_state();
+    jl_get_ptls_states()->gc_state = JL_GC_STATE_WAITING;
+    // In case multiple threads enter the GC at the same time, only allow
+    // one of them to actually run the collection. We can't just let the
+    // master thread do the GC since it might be running unmanaged code
+    // and can take arbitrarily long time before hitting a safe point.
+    if (jl_atomic_compare_exchange(&jl_gc_running, 0, 1) != 0) {
+#ifdef JULIA_ENABLE_THREADING
+        JL_SIGATOMIC_END();
+        jl_wait_for_gc();
+        jl_gc_state_set(old_state, JL_GC_STATE_WAITING);
+#else
+        // For single thread, GC should not call itself (in finalizers) before
+        // setting jl_gc_running to false so this should never happen.
+        assert(0 && "GC synchronization failure");
+#endif
+        return;
+    }
+    jl_gc_signal_begin();
+
+    if (!jl_gc_disable_counter)
+        _jl_gc_collect(full, stack_hi);
+
+    // Need to reset the page protection before resetting the flag since
+    // the thread will trigger a segfault immediately after returning from
+    // the signal handler.
+    jl_gc_signal_end();
+    jl_gc_running = 0;
+    JL_SIGATOMIC_END();
+    jl_gc_state_set(old_state, JL_GC_STATE_WAITING);
+
+    if (!jl_gc_finalizers_inhibited) {
+        int8_t was_in_finalizer = jl_in_finalizer;
+        jl_in_finalizer = 1;
+        run_finalizers();
+        jl_in_finalizer = was_in_finalizer;
     }
 }
 
@@ -2230,23 +2474,24 @@ void jl_gc_collect(int full)
 
 void *allocb(size_t sz)
 {
-    buff_t *b;
+    buff_t *b = NULL;
     size_t allocsz = sz + sizeof(buff_t);
     if (allocsz < sz)  // overflow in adding offs, size was "negative"
         jl_throw(jl_memory_exception);
 #ifdef MEMDEBUG
     b = (buff_t*)alloc_big(allocsz);
-    b->header = 0x4EADE800;
+    b->header = jl_buff_tag;
     b->pooled = 0;
 #else
     if (allocsz > GC_MAX_SZCLASS + sizeof(buff_t)) {
         b = (buff_t*)alloc_big(allocsz);
-        b->header = 0x4EADE800;
+        b->header = jl_buff_tag;
         b->pooled = 0;
     }
     else {
-        b = (buff_t*)pool_alloc(&pools[szclass(allocsz)]);
-        b->header = 0x4EADE800;
+        FOR_CURRENT_HEAP ()
+            b = (buff_t*)pool_alloc(&pools[szclass(allocsz)]);
+        b->header = jl_buff_tag;
         b->pooled = 1;
     }
 #endif
@@ -2276,7 +2521,7 @@ void *reallocb(void *b, size_t sz)
 }
 */
 
-DLLEXPORT jl_value_t *jl_gc_allocobj(size_t sz)
+JL_DLLEXPORT jl_value_t *jl_gc_allocobj(size_t sz)
 {
     size_t allocsz = sz + sizeof_jl_taggedvalue_t;
     if (allocsz < sz) // overflow in adding offs, size was "negative"
@@ -2284,46 +2529,64 @@ DLLEXPORT jl_value_t *jl_gc_allocobj(size_t sz)
 #ifdef MEMDEBUG
     return jl_valueof(alloc_big(allocsz));
 #endif
-    if (allocsz <= GC_MAX_SZCLASS + sizeof(buff_t))
-        return jl_valueof(pool_alloc(&pools[szclass(allocsz)]));
-    else
-        return jl_valueof(alloc_big(allocsz));
+    if (allocsz <= GC_MAX_SZCLASS + sizeof(buff_t)) {
+        FOR_CURRENT_HEAP () {
+            return jl_valueof(pool_alloc(&pools[szclass(allocsz)]));
+        }
+    }
+    return jl_valueof(alloc_big(allocsz));
 }
 
-DLLEXPORT jl_value_t *jl_gc_alloc_0w(void)
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_0w(void)
 {
     const int sz = sizeof_jl_taggedvalue_t;
+    void *tag = NULL;
 #ifdef MEMDEBUG
-    return jl_valueof(alloc_big(sz));
+    tag = alloc_big(sz);
+#else
+    FOR_CURRENT_HEAP ()
+        tag = _pool_alloc(&pools[szclass(sz)], sz);
 #endif
-    return jl_valueof(_pool_alloc(&pools[szclass(sz)], sz));
+    return jl_valueof(tag);
 }
 
-DLLEXPORT jl_value_t *jl_gc_alloc_1w(void)
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_1w(void)
 {
     const int sz = LLT_ALIGN(sizeof_jl_taggedvalue_t + sizeof(void*), 16);
+    void *tag = NULL;
 #ifdef MEMDEBUG
-    return jl_valueof(alloc_big(sz));
+    tag = alloc_big(sz);
+#else
+    FOR_CURRENT_HEAP ()
+        tag = _pool_alloc(&pools[szclass(sz)], sz);
 #endif
-    return jl_valueof(_pool_alloc(&pools[szclass(sz)], sz));
+    return jl_valueof(tag);
 }
 
-DLLEXPORT jl_value_t *jl_gc_alloc_2w(void)
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_2w(void)
 {
     const int sz = LLT_ALIGN(sizeof_jl_taggedvalue_t + sizeof(void*) * 2, 16);
+    void *tag = NULL;
 #ifdef MEMDEBUG
-    return jl_valueof(alloc_big(sz));
+    tag = alloc_big(sz);
+#else
+    FOR_CURRENT_HEAP ()
+        tag = _pool_alloc(&pools[szclass(sz)], sz);
 #endif
-    return jl_valueof(_pool_alloc(&pools[szclass(sz)], sz));
+    return jl_valueof(tag);
 }
 
-DLLEXPORT jl_value_t *jl_gc_alloc_3w(void)
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_3w(void)
 {
     const int sz = LLT_ALIGN(sizeof_jl_taggedvalue_t + sizeof(void*) * 3, 16);
+    void *tag = NULL;
 #ifdef MEMDEBUG
-    return jl_valueof(alloc_big(sz));
+    tag = alloc_big(sz);
+#else
+    FOR_CURRENT_HEAP ()
+        tag = _pool_alloc(&pools[szclass(sz)], sz);
 #endif
-    return jl_valueof(_pool_alloc(&pools[szclass(sz)], sz));
+    return jl_valueof(tag);
 }
 
 #ifdef GC_FINAL_STATS
@@ -2333,7 +2596,7 @@ void jl_print_gc_stats(JL_STREAM *s)
 {
     double gct = total_gc_time/1e9;
     malloc_stats();
-    double ptime = clock_now()-process_t0;
+    double ptime = jl_clock_now()-process_t0;
     jl_printf(s, "exec time\t%.5f sec\n", ptime);
     if (n_pause > 0) {
         jl_printf(s, "gc time  \t%.5f sec (%2.1f%%) in %d (%d full) collections\n",
@@ -2357,10 +2620,16 @@ void jl_print_gc_stats(JL_STREAM *s)
 #endif
 
 // Per-thread initialization (when threading is fully implemented)
-static void jl_mk_thread_heap(void) {
-    FOR_CURRENT_HEAP
-        const int* szc = sizeclasses;
-        pool_t *p = HEAP(norm_pools);
+jl_thread_heap_t *jl_mk_thread_heap(void)
+{
+#ifdef JULIA_ENABLE_THREADING
+    // Cache-aligned malloc
+    jl_thread_heap =
+        (jl_thread_heap_t*)jl_malloc_aligned(sizeof(jl_thread_heap_t), 64);
+#endif
+    FOR_CURRENT_HEAP () {
+        const int *szc = sizeclasses;
+        pool_t *p = pools;
         for(int i=0; i < N_POOLS; i++) {
             assert((szc[i] < 16 && szc[i] % sizeof(void*) == 0) ||
                    (szc[i] % 16 == 0));
@@ -2369,7 +2638,6 @@ static void jl_mk_thread_heap(void) {
             p[i].newpages = NULL;
             p[i].end_offset = GC_POOL_END_OFS(szc[i]);
         }
-        arraylist_new(&preserved_values, 0);
         arraylist_new(&weak_refs, 0);
         mallocarrays = NULL;
         mafreelist = NULL;
@@ -2379,14 +2647,14 @@ static void jl_mk_thread_heap(void) {
         last_remset = &HEAP(_remset)[1];
         arraylist_new(remset, 0);
         arraylist_new(last_remset, 0);
-    END
+    }
+    return jl_thread_heap;
 }
 
 // System-wide initializations
 void jl_gc_init(void)
 {
     gc_debug_init();
-    jl_mk_thread_heap();
 
     arraylist_new(&finalizer_list, 0);
     arraylist_new(&finalizer_list_marked, 0);
@@ -2410,7 +2678,7 @@ void jl_gc_init(void)
     }
 #endif
 #ifdef GC_FINAL_STATS
-    process_t0 = clock_now();
+    process_t0 = jl_clock_now();
 #endif
 
 #ifdef _P64
@@ -2419,6 +2687,8 @@ void jl_gc_init(void)
     if (maxmem > max_collect_interval)
         max_collect_interval = maxmem;
 #endif
+    char _dummy;
+    gc_stack_bot = &_dummy;
 }
 
 // GC summary stats
@@ -2475,13 +2745,15 @@ static void all_pool_stats(void)
     int i;
     size_t nb=0, w, tw=0, no=0,tp=0, nold=0,noldbytes=0, b, np, nol;
     for(i=0; i < N_POOLS; i++) {
-        b = pool_stats(&norm_pools[i], &w, &np, &nol);
-        nb += b;
-        no += (b/norm_pools[i].osize);
-        tw += w;
-        tp += np;
-        nold += nol;
-        noldbytes += nol*norm_pools[i].osize;
+        FOR_EACH_HEAP () {
+            b = pool_stats(&pools[i], &w, &np, &nol);
+            nb += b;
+            no += (b/pools[i].osize);
+            tw += w;
+            tp += np;
+            nold += nol;
+            noldbytes += nol*pools[i].osize;
+        }
     }
     jl_printf(JL_STDOUT,
               "%d objects (%d%% old), %d kB (%d%% old) total allocated, %d total fragments (%d%% overhead), in %d pages\n",
@@ -2522,7 +2794,7 @@ static void big_obj_stats(void)
 }
 #endif //MEMPROFILE
 
-DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
+JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
 {
     maybe_collect();
     allocd_bytes += sz;
@@ -2533,7 +2805,7 @@ DLLEXPORT void *jl_gc_counted_malloc(size_t sz)
     return b;
 }
 
-DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
+JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
 {
     maybe_collect();
     allocd_bytes += nm*sz;
@@ -2544,14 +2816,15 @@ DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz)
     return b;
 }
 
-DLLEXPORT void jl_gc_counted_free(void *p, size_t sz)
+JL_DLLEXPORT void jl_gc_counted_free(void *p, size_t sz)
 {
     free(p);
     freed_bytes += sz;
     gc_num.freecall++;
 }
 
-DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t sz)
+JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old,
+                                                       size_t sz)
 {
     maybe_collect();
 
@@ -2566,14 +2839,14 @@ DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t
     return b;
 }
 
-DLLEXPORT void *jl_malloc(size_t sz)
+JL_DLLEXPORT void *jl_malloc(size_t sz)
 {
     int64_t *p = (int64_t *)jl_gc_counted_malloc(sz + 16);
     p[0] = sz;
     return (void *)(p + 2);
 }
 
-DLLEXPORT void *jl_calloc(size_t nm, size_t sz)
+JL_DLLEXPORT void *jl_calloc(size_t nm, size_t sz)
 {
     int64_t *p;
     size_t nmsz = nm*sz;
@@ -2582,23 +2855,31 @@ DLLEXPORT void *jl_calloc(size_t nm, size_t sz)
     return (void *)(p + 2);
 }
 
-DLLEXPORT void jl_free(void *p)
+JL_DLLEXPORT void jl_free(void *p)
 {
     int64_t *pp = (int64_t *)p - 2;
     size_t sz = pp[0];
     jl_gc_counted_free(pp, sz + 16);
 }
 
-DLLEXPORT void *jl_realloc(void *p, size_t sz)
+JL_DLLEXPORT void *jl_realloc(void *p, size_t sz)
 {
-    int64_t *pp = (int64_t *)p - 2;
-    size_t szold = pp[0];
+    int64_t *pp;
+    size_t szold;
+    if (p == NULL) {
+        pp = NULL;
+        szold = 0;
+    }
+    else {
+        pp = (int64_t *)p - 2;
+        szold = pp[0];
+    }
     int64_t *pnew = (int64_t *)jl_gc_counted_realloc_with_old_size(pp, szold + 16, sz + 16);
     pnew[0] = sz;
     return (void *)(pnew + 2);
 }
 
-DLLEXPORT void *jl_gc_managed_malloc(size_t sz)
+JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz)
 {
     maybe_collect();
     size_t allocsz = LLT_ALIGN(sz, 16);
@@ -2612,7 +2893,8 @@ DLLEXPORT void *jl_gc_managed_malloc(size_t sz)
     return b;
 }
 
-DLLEXPORT void *jl_gc_managed_realloc(void *d, size_t sz, size_t oldsz, int isaligned, jl_value_t* owner)
+JL_DLLEXPORT void *jl_gc_managed_realloc(void *d, size_t sz, size_t oldsz,
+                                         int isaligned, jl_value_t *owner)
 {
     maybe_collect();
 
diff --git a/src/gf.c b/src/gf.c
index 5b88689620f04..71cade9922094 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -11,11 +11,11 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
-#ifdef _OS_WINDOWS_
-#include <malloc.h>
-#endif
 #include "julia.h"
 #include "julia_internal.h"
+#ifndef _OS_WINDOWS_
+#include <unistd.h>
+#endif
 
 // ::ANY has no effect if the number of overlapping methods is greater than this
 #define MAX_UNSPECIALIZED_CONFLICTS 10
@@ -24,41 +24,6 @@
 extern "C" {
 #endif
 
-static jl_value_t *jl_apply_unspecialized(jl_function_t *meth, jl_value_t **args, uint32_t nargs)
-{
-    jl_function_t *unspecialized = meth->linfo->unspecialized;
-    assert(unspecialized != jl_bottom_func);
-    if (meth->env == (jl_value_t*)jl_emptysvec) {
-        return jl_apply(unspecialized, args, nargs);
-    }
-    else {
-        jl_function_t *closuremeth = jl_new_closure(unspecialized->fptr, meth->env, unspecialized->linfo);
-        JL_GC_PUSH1(&closuremeth);
-        jl_value_t *v = jl_apply(closuremeth, args, nargs);
-        JL_GC_POP();
-        return v;
-    }
-}
-
-
-static jl_methtable_t *new_method_table(jl_sym_t *name, jl_module_t *module)
-{
-    jl_methtable_t *mt = (jl_methtable_t*)jl_gc_allocobj(sizeof(jl_methtable_t));
-    jl_set_typeof(mt, jl_methtable_type);
-    mt->name = name;
-    mt->module = module;
-    mt->defs = (jl_methlist_t*)jl_nothing;
-    mt->cache = (jl_methlist_t*)jl_nothing;
-    mt->cache_arg1 = (jl_array_t*)jl_nothing;
-    mt->cache_targ = (jl_array_t*)jl_nothing;
-    mt->max_args = 0;
-    mt->kwsorter = NULL;
-#ifdef JL_GF_PROFILE
-    mt->ncalls = 0;
-#endif
-    return mt;
-}
-
 static int cache_match_by_type(jl_value_t **types, size_t n, jl_tupletype_t *sig, int va)
 {
     if (!va && n > jl_datatype_nfields(sig))
@@ -103,12 +68,12 @@ static int cache_match_by_type(jl_value_t **types, size_t n, jl_tupletype_t *sig
     return 1;
 }
 
-static inline int cache_match(jl_value_t **args, size_t n, jl_tupletype_t *sig,
+static inline int cache_match(jl_value_t **args, size_t n, jl_value_t **sig,
                               int va, size_t lensig)
 {
     // NOTE: This function is a huge performance hot spot!!
     for(size_t i=0; i < n; i++) {
-        jl_value_t *decl = jl_field_type(sig, i);
+        jl_value_t *decl = sig[i];
         if (i == lensig-1) {
             if (va) {
                 jl_value_t *t = jl_tparam0(decl);
@@ -148,12 +113,12 @@ static inline int cache_match(jl_value_t **args, size_t n, jl_tupletype_t *sig,
 }
 
 static inline
-jl_methlist_t *mtcache_hash_lookup(jl_array_t *a, jl_value_t *ty, int tparam)
+jl_methlist_t *mtcache_hash_lookup(jl_array_t *a, jl_value_t *ty, int8_t tparam, int8_t offs)
 {
-    uptrint_t uid = ((jl_datatype_t*)ty)->uid;
+    uintptr_t uid = ((jl_datatype_t*)ty)->uid;
     jl_methlist_t *ml = (jl_methlist_t*)jl_cellref(a, uid & (a->nrows-1));
     if (ml && ml!=(void*)jl_nothing) {
-        jl_value_t *t = jl_field_type(ml->sig, 0);
+        jl_value_t *t = jl_field_type(ml->sig, offs);
         if (tparam) t = jl_tparam0(t);
         if (t == ty)
             return ml;
@@ -161,7 +126,7 @@ jl_methlist_t *mtcache_hash_lookup(jl_array_t *a, jl_value_t *ty, int tparam)
     return (jl_methlist_t*)jl_nothing;
 }
 
-static void mtcache_rehash(jl_array_t **pa, jl_value_t* parent)
+static void mtcache_rehash(jl_array_t **pa, jl_value_t *parent, int8_t offs)
 {
     size_t len = (*pa)->nrows;
     jl_value_t **d = (jl_value_t**)(*pa)->data;
@@ -171,10 +136,10 @@ static void mtcache_rehash(jl_array_t **pa, jl_value_t* parent)
     for(i=0; i < len; i++) {
         jl_methlist_t *ml = (jl_methlist_t*)d[i];
         if (ml && ml!=(jl_methlist_t*)jl_nothing) {
-            jl_value_t *t = jl_field_type(ml->sig,0);
+            jl_value_t *t = jl_field_type(ml->sig, offs);
             if (jl_is_type_type(t))
                 t = jl_tparam0(t);
-            uptrint_t uid = ((jl_datatype_t*)t)->uid;
+            uintptr_t uid = ((jl_datatype_t*)t)->uid;
             nd[uid & (len*2-1)] = (jl_value_t*)ml;
         }
     }
@@ -183,9 +148,9 @@ static void mtcache_rehash(jl_array_t **pa, jl_value_t* parent)
 }
 
 static jl_methlist_t **mtcache_hash_bp(jl_array_t **pa, jl_value_t *ty,
-                                       int tparam, jl_value_t* parent)
+                                       int8_t tparam, int8_t offs, jl_value_t *parent)
 {
-    uptrint_t uid;
+    uintptr_t uid;
     if (jl_is_datatype(ty) && (uid = ((jl_datatype_t*)ty)->uid)) {
         while (1) {
             jl_methlist_t **pml = &((jl_methlist_t**)jl_array_data(*pa))[uid & ((*pa)->nrows-1)];
@@ -193,11 +158,11 @@ static jl_methlist_t **mtcache_hash_bp(jl_array_t **pa, jl_value_t *ty,
                 *pml = (jl_methlist_t*)jl_nothing;
                 return pml;
             }
-            jl_value_t *t = jl_field_type((*pml)->sig,0);
+            jl_value_t *t = jl_field_type((*pml)->sig, offs);
             if (tparam) t = jl_tparam0(t);
             if (t == ty)
                 return pml;
-            mtcache_rehash(pa, parent);
+            mtcache_rehash(pa, parent, offs);
         }
     }
     return NULL;
@@ -208,69 +173,82 @@ static jl_methlist_t **mtcache_hash_bp(jl_array_t **pa, jl_value_t *ty,
   the first argument is a singleton kind (Type{Foo}), one indexed by the
   UID of the first argument's type in normal cases, and a fallback
   table of everything else.
+
+  Note that the "primary key" is the type of the first *argument*, since
+  there tends to be lots of variation there. The type of the 0th argument
+  (the function) is always the same for most functions.
 */
-static jl_function_t *jl_method_table_assoc_exact_by_type(jl_methtable_t *mt, jl_tupletype_t *types)
+static jl_lambda_info_t *jl_method_table_assoc_exact_by_type(jl_methtable_t *mt, jl_tupletype_t *types)
 {
+    // called object is the primary key for constructors, otherwise first argument
+    int8_t offs = (mt == jl_type_type->name->mt) ? 0 : 1;
     jl_methlist_t *ml = (jl_methlist_t*)jl_nothing;
-    if (jl_datatype_nfields(types) > 0) {
-        jl_value_t *ty = jl_tparam0(types);
+    if (jl_datatype_nfields(types) > offs) {
+        jl_value_t *ty = jl_tparam(types, offs);
         if (jl_is_type_type(ty)) {
             jl_value_t *a0 = jl_tparam0(ty);
             if (mt->cache_targ != (void*)jl_nothing && jl_is_datatype(a0)) {
-                ml = mtcache_hash_lookup(mt->cache_targ, a0, 1);
+                ml = mtcache_hash_lookup(mt->cache_targ, a0, 1, offs);
                 if (ml!=(jl_methlist_t*)jl_nothing)
                     goto mt_assoc_bt_lkup;
             }
         }
         if (mt->cache_arg1 != (void*)jl_nothing && jl_is_datatype(ty)) {
-            ml = mtcache_hash_lookup(mt->cache_arg1, ty, 0);
+            ml = mtcache_hash_lookup(mt->cache_arg1, ty, 0, offs);
         }
     }
     if (ml == (void*)jl_nothing)
         ml = mt->cache;
  mt_assoc_bt_lkup:
     while (ml != (void*)jl_nothing) {
-        if (cache_match_by_type(jl_svec_data(types->parameters), jl_datatype_nfields(types),
+        if (cache_match_by_type(jl_svec_data(types->parameters),
+                                jl_datatype_nfields(types),
                                 ml->sig, ml->va)) {
             return ml->func;
         }
         // see corresponding code in jl_method_table_assoc_exact
-        if (ml->func == jl_bottom_func && jl_subtype((jl_value_t*)types, (jl_value_t*)ml->sig, 0))
-            return jl_bottom_func;
+        if (ml->func == NULL && jl_subtype((jl_value_t*)types, (jl_value_t*)ml->sig, 0))
+            return NULL;
         ml = ml->next;
     }
-    return jl_bottom_func;
+    return NULL;
 }
 
-static jl_function_t *jl_method_table_assoc_exact(jl_methtable_t *mt, jl_value_t **args, size_t n)
+static jl_lambda_info_t *jl_method_table_assoc_exact(jl_methtable_t *mt, jl_value_t **args, size_t n)
 {
     // NOTE: This function is a huge performance hot spot!!
+    int8_t offs = (mt == jl_type_type->name->mt) ? 0 : 1;
     jl_methlist_t *ml = (jl_methlist_t*)jl_nothing;
-    if (n > 0) {
-        jl_value_t *a0 = args[0];
-        jl_value_t *ty = (jl_value_t*)jl_typeof(a0);
-        if (mt->cache_targ != (void*)jl_nothing && ty == (jl_value_t*)jl_datatype_type) {
-            ml = mtcache_hash_lookup(mt->cache_targ, a0, 1);
+    if (n > offs) {
+        jl_value_t *a1 = args[offs];
+        jl_value_t *ty = (jl_value_t*)jl_typeof(a1);
+        if (ty == (jl_value_t*)jl_datatype_type && mt->cache_targ != (void*)jl_nothing) {
+            ml = mtcache_hash_lookup(mt->cache_targ, a1, 1, offs);
             if (ml != (void*)jl_nothing)
                 goto mt_assoc_lkup;
         }
         assert(jl_is_datatype(ty));
         if (mt->cache_arg1 != (void*)jl_nothing) {
-            ml = mtcache_hash_lookup(mt->cache_arg1, ty, 0);
+            ml = mtcache_hash_lookup(mt->cache_arg1, ty, 0, offs);
             if (ml != (void*)jl_nothing) {
-                if (ml->next==(void*)jl_nothing && n==1 && jl_datatype_nfields(ml->sig)==1)
+                jl_value_t *a0 = args[1-offs];
+                jl_value_t *t0 = (jl_value_t*)jl_typeof(a0);
+                if (ml->next==(void*)jl_nothing && n==2 && jl_datatype_nfields(ml->sig)==2 &&
+                    jl_tparam(ml->sig,1-offs)==t0)
                     return ml->func;
-                if (n==2) {
+                if (n==3) {
                     // some manually-unrolled common special cases
-                    jl_value_t *a1 = args[1];
-                    if (!jl_is_tuple(a1)) {  // issue #6426
+                    jl_value_t *a2 = args[2];
+                    if (!jl_is_tuple(a2)) {  // issue #6426
                         jl_methlist_t *mn = ml;
-                        if (jl_datatype_nfields(mn->sig)==2 &&
-                            jl_tparam(mn->sig,1)==(jl_value_t*)jl_typeof(a1))
+                        if (jl_datatype_nfields(mn->sig)==3 &&
+                            jl_tparam(mn->sig,1-offs)==t0 &&
+                            jl_tparam(mn->sig,2)==(jl_value_t*)jl_typeof(a2))
                             return mn->func;
                         mn = mn->next;
-                        if (mn!=(void*)jl_nothing && jl_datatype_nfields(mn->sig)==2 &&
-                            jl_tparam(mn->sig,1)==(jl_value_t*)jl_typeof(a1))
+                        if (mn!=(void*)jl_nothing && jl_datatype_nfields(mn->sig)==3 &&
+                            jl_tparam(mn->sig,1-offs)==t0 &&
+                            jl_tparam(mn->sig,2)==(jl_value_t*)jl_typeof(a2))
                             return mn->func;
                     }
                 }
@@ -283,89 +261,107 @@ static jl_function_t *jl_method_table_assoc_exact(jl_methtable_t *mt, jl_value_t
     while (ml != (void*)jl_nothing) {
         size_t lensig = jl_datatype_nfields(ml->sig);
         if (lensig == n || (ml->va && lensig <= n+1)) {
-            if (cache_match(args, n, ml->sig, ml->va, lensig)) {
+            if (cache_match(args, n, jl_svec_data(ml->sig->parameters), ml->va, lensig)) {
                 return ml->func;
             }
-            // if we hit a guard entry (ml->func == jl_bottom_func), do a more
+            // if we hit a guard entry (ml->func == NULL), do a more
             // expensive subtype check, since guard entries added for ANY might be
             // abstract. this fixed issue #12967.
-            if (ml->func == jl_bottom_func && jl_tuple_subtype(args, n, ml->sig, 1))
-                return jl_bottom_func;
+            if (ml->func == NULL && jl_tuple_subtype(args, n, ml->sig, 1))
+                return NULL;
         }
         ml = ml->next;
     }
-    return jl_bottom_func;
+    return NULL;
 }
 
 // return a new lambda-info that has some extra static parameters merged in.
-jl_lambda_info_t *jl_add_static_parameters(jl_lambda_info_t *l, jl_svec_t *sp)
+static jl_lambda_info_t *jl_add_static_parameters(jl_lambda_info_t *l, jl_svec_t *sp, jl_tupletype_t *types)
 {
     JL_GC_PUSH1(&sp);
-    if (jl_svec_len(l->sparams) > 0)
-        sp = jl_svec_append(sp, l->sparams);
-    jl_lambda_info_t *nli = jl_new_lambda_info(l->ast, sp, l->module);
-    nli->name = l->name;
-    nli->fptr = l->fptr;
-    nli->file = l->file;
-    nli->line = l->line;
-    nli->def  = l->def;
-    JL_GC_POP();
-    return nli;
-}
-
-jl_function_t *jl_instantiate_method(jl_function_t *f, jl_svec_t *sp)
-{
-    if (f->linfo == NULL)
-        return f;
-    jl_function_t *nf = jl_new_closure(f->fptr, f->env, NULL);
-    JL_GC_PUSH1(&nf);
-    nf->linfo = jl_add_static_parameters(f->linfo, sp);
-    jl_gc_wb(nf, nf->linfo);
-    JL_GC_POP();
-    return nf;
-}
-
-// append values of static parameters to closure environment
-static jl_function_t *with_appended_env(jl_function_t *meth, jl_svec_t *sparams)
-{
-    if (sparams == jl_emptysvec)
-        return meth;
-    jl_value_t *temp = (jl_value_t*)jl_alloc_svec(jl_svec_len(sparams)/2);
-    JL_GC_PUSH1(&temp);
-    size_t i;
-    for(i=0; i < jl_svec_len(temp); i++) {
-        jl_svecset(temp, i, jl_svecref(sparams,i*2+1));
+    assert(jl_svec_len(l->sparam_syms) == jl_svec_len(sp) || sp == jl_emptysvec);
+    assert(l->sparam_vals == jl_emptysvec);
+    assert(l->specTypes == NULL);
+    jl_lambda_info_t *nli = jl_copy_lambda_info(l);
+    nli->sparam_vals = sp; // no gc_wb needed
+    nli->tfunc = jl_nothing;
+    nli->specializations = NULL;
+    nli->specTypes = types;
+    if (types) jl_gc_wb(nli, types);
+
+    /* "method" itself should never get compiled,
+      for example, if an unspecialized method is needed,
+      the slow compiled code should be associated with
+      method->unspecialized, not method */
+    assert(!nli->ast ||
+           (nli->fptr == NULL &&
+            nli->jlcall_api == 0 &&
+            nli->functionObjects.functionObject == NULL &&
+            nli->functionObjects.specFunctionObject == NULL &&
+            nli->functionObjects.cFunctionList == NULL &&
+            nli->functionID == 0 &&
+            nli->specFunctionID == 0));
+    if (jl_options.compile_enabled == JL_OPTIONS_COMPILE_OFF || jl_options.compile_enabled == JL_OPTIONS_COMPILE_MIN) {
+        // copy fptr from the unspecialized method definition
+        jl_lambda_info_t *unspec = l->unspecialized;
+        if (unspec != NULL) {
+            nli->fptr = unspec->fptr;
+            nli->jlcall_api = unspec->jlcall_api;
+            nli->functionObjects.functionObject = unspec->functionObjects.functionObject;
+            nli->functionObjects.specFunctionObject = unspec->functionObjects.specFunctionObject;
+            nli->functionID = unspec->functionID;
+            nli->specFunctionID = unspec->functionID;
+        }
+        if (jl_options.compile_enabled == JL_OPTIONS_COMPILE_OFF && nli->fptr == NULL) {
+            jl_printf(JL_STDERR,"code missing for ");
+            jl_static_show(JL_STDERR, (jl_value_t*)nli);
+            jl_printf(JL_STDERR, "  sysimg may not have been built with --compile=all\n");
+        }
     }
-    temp = (jl_value_t*)jl_svec_append((jl_svec_t*)meth->env, (jl_svec_t*)temp);
-    meth = jl_new_closure(meth->fptr, temp, meth->linfo);
     JL_GC_POP();
-    return meth;
+    return nli;
 }
 
-// make a new method that calls the generated code from the given linfo
-jl_function_t *jl_reinstantiate_method(jl_function_t *f, jl_lambda_info_t *li)
+jl_lambda_info_t *jl_get_unspecialized(jl_lambda_info_t *method)
 {
-    return jl_new_closure(NULL, f->env, li);
+    // one unspecialized version of a function can be shared among all cached specializations
+    jl_lambda_info_t *def = method->def;
+    if (method->unspecialized != NULL)
+        return method->unspecialized;
+    if (method->specTypes && def->needs_sparam_vals_ducttape) {
+        // a method is a specialization iff it has specTypes
+        // but method->unspecialized points to the definition in that case
+        // and definition->unspecialized points to the thing to call
+        method->unspecialized = jl_add_static_parameters(def, method->sparam_vals, method->specTypes);
+        jl_gc_wb(method, method->unspecialized);
+        method->unspecialized->unspecialized = method->unspecialized;
+        def = method;
+    }
+    if (def->unspecialized == NULL) {
+        def->unspecialized = jl_add_static_parameters(def, jl_emptysvec, jl_anytuple_type);
+        jl_gc_wb(def, def->unspecialized);
+    }
+    return def->unspecialized;
 }
 
-static
-jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
-                                     jl_function_t *method, jl_svec_t *tvars,
-                                     int check_amb, int8_t isstaged, jl_value_t *parent);
+static jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
+                                            jl_lambda_info_t *method, jl_svec_t *tvars,
+                                            int check_amb, int8_t isstaged, jl_value_t *parent);
 
-jl_function_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tupletype_t *type,
-                                      jl_function_t *method)
+jl_lambda_info_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tupletype_t *type,
+                                         jl_lambda_info_t *method)
 {
+    int8_t offs = (mt == jl_type_type->name->mt) ? 0 : 1;
     jl_methlist_t **pml = &mt->cache;
-    jl_value_t* cache_array = NULL;
-    if (jl_datatype_nfields(type) > 0) {
-        jl_value_t *t0 = jl_tparam0(type);
-        uptrint_t uid=0;
-        // if t0 != jl_typetype_type and the argument is Type{...}, this
+    jl_value_t *cache_array = NULL;
+    if (jl_datatype_nfields(type) > offs) {
+        jl_value_t *t1 = jl_tparam(type, offs);
+        uintptr_t uid=0;
+        // if t1 != jl_typetype_type and the argument is Type{...}, this
         // method has specializations for singleton kinds and we use
         // the table indexed for that purpose.
-        if (t0 != (jl_value_t*)jl_typetype_type && jl_is_type_type(t0)) {
-            jl_value_t *a0 = jl_tparam0(t0);
+        if (t1 != (jl_value_t*)jl_typetype_type && jl_is_type_type(t1)) {
+            jl_value_t *a0 = jl_tparam0(t1);
             if (jl_is_datatype(a0))
                 uid = ((jl_datatype_t*)a0)->uid;
             if (uid > 0) {
@@ -373,19 +369,19 @@ jl_function_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tupletype_t *type,
                     mt->cache_targ = jl_alloc_cell_1d(16);
                     jl_gc_wb(mt, mt->cache_targ);
                 }
-                pml = mtcache_hash_bp(&mt->cache_targ, a0, 1, (jl_value_t*)mt);
+                pml = mtcache_hash_bp(&mt->cache_targ, a0, 1, offs, (jl_value_t*)mt);
                 cache_array = (jl_value_t*)mt->cache_targ;
                 goto ml_do_insert;
             }
         }
-        if (jl_is_datatype(t0))
-            uid = ((jl_datatype_t*)t0)->uid;
+        if (jl_is_datatype(t1))
+            uid = ((jl_datatype_t*)t1)->uid;
         if (uid > 0) {
             if (mt->cache_arg1 == (void*)jl_nothing) {
                 mt->cache_arg1 = jl_alloc_cell_1d(16);
                 jl_gc_wb(mt, mt->cache_arg1);
             }
-            pml = mtcache_hash_bp(&mt->cache_arg1, t0, 0, (jl_value_t*)mt);
+            pml = mtcache_hash_bp(&mt->cache_arg1, t1, 0, offs, (jl_value_t*)mt);
             cache_array = (jl_value_t*)mt->cache_arg1;
         }
     }
@@ -399,8 +395,9 @@ jl_function_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tupletype_t *type,
   can be equal to "li" if not applicable.
 */
 int jl_in_inference = 0;
-void jl_type_infer(jl_lambda_info_t *li, jl_tupletype_t *argtypes, jl_lambda_info_t *def)
+void jl_type_infer(jl_lambda_info_t *li, jl_lambda_info_t *def)
 {
+    JL_LOCK(codegen); // Might GC
     int last_ii = jl_in_inference;
     jl_in_inference = 1;
     if (jl_typeinf_func != NULL) {
@@ -410,24 +407,29 @@ void jl_type_infer(jl_lambda_info_t *li, jl_tupletype_t *argtypes, jl_lambda_inf
         assert(li->inInference == 0);
         li->inInference = 1;
         jl_value_t *fargs[4];
-        fargs[0] = (jl_value_t*)li;
-        fargs[1] = (jl_value_t*)argtypes;
-        fargs[2] = (jl_value_t*)jl_emptysvec;
+        fargs[0] = (jl_value_t*)jl_typeinf_func;
+        fargs[1] = (jl_value_t*)li;
+        fargs[2] = (jl_value_t*)li->specTypes;
         fargs[3] = (jl_value_t*)def;
 #ifdef TRACE_INFERENCE
-        jl_printf(JL_STDERR,"inference on %s", li->name->name);
+        jl_printf(JL_STDERR,"inference on ");
         jl_static_show_func_sig(JL_STDERR, (jl_value_t*)argtypes);
         jl_printf(JL_STDERR, "\n");
 #endif
 #ifdef ENABLE_INFERENCE
-        jl_value_t *newast = jl_apply(jl_typeinf_func, fargs, 4);
+        jl_value_t *newast = jl_apply(fargs, 4);
+        jl_value_t *defast = def->ast;
         li->ast = jl_fieldref(newast, 0);
         jl_gc_wb(li, li->ast);
-        li->inferred = 1;
+        li->rettype = jl_fieldref(newast, 1);
+        jl_gc_wb(li, li->rettype);
+        // if type inference bails out it returns def->ast
+        li->inferred = li->ast != defast;
 #endif
         li->inInference = 0;
     }
     jl_in_inference = last_ii;
+    JL_UNLOCK(codegen);
 }
 
 jl_value_t *jl_nth_slot_type(jl_tupletype_t *sig, size_t i)
@@ -461,15 +463,19 @@ static int is_kind(jl_value_t *v)
 static jl_value_t *ml_matches(jl_methlist_t *ml, jl_value_t *type,
                               jl_sym_t *name, int lim);
 
-static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
-                                   jl_function_t *method, jl_tupletype_t *decl,
-                                   jl_svec_t *sparams, int8_t isstaged)
+static jl_lambda_info_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
+                                      jl_lambda_info_t *method, jl_methlist_t *m,
+                                      jl_svec_t *sparams)
 {
+    JL_LOCK(codegen); // Might GC
     size_t i;
+    jl_tupletype_t *decl = m->sig;
+    int8_t isstaged = m->isstaged;
     int need_guard_entries = 0;
+    int cache_as_orig = 0;
     jl_value_t *temp=NULL;
     jl_value_t *temp2=NULL;
-    jl_function_t *newmeth=NULL;
+    jl_lambda_info_t *newmeth=NULL;
     jl_svec_t *newparams=NULL;
     jl_svec_t *limited=NULL;
     jl_tupletype_t *origtype = type;  // TODO: root?
@@ -502,18 +508,27 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
         }
 
         int set_to_any = 0;
-        if (decl_i == jl_ANY_flag) {
+        int notcalled_func = (i>0 && i<=8 && !(method->called&(1<<(i-1))) &&
+                              jl_subtype(elt,(jl_value_t*)jl_function_type,0));
+        if (decl_i == jl_ANY_flag ||
+            (notcalled_func && (decl_i == (jl_value_t*)jl_any_type ||
+                                decl_i == (jl_value_t*)jl_function_type ||
+                                (!jl_is_typevar(decl_i) &&
+                                 jl_subtype((jl_value_t*)jl_function_type, decl_i, 0) &&
+                                 jl_subtype((jl_value_t*)jl_datatype_type, decl_i, 0) &&
+                                 jl_is_uniontype(decl_i) && jl_svec_len(((jl_uniontype_t*)decl_i)->types)==2)))) {
             // don't specialize on slots marked ANY
             jl_svecset(newparams, i, (jl_value_t*)jl_any_type);
             temp2 = (jl_value_t*)jl_svec_copy(newparams);
             temp2 = (jl_value_t*)jl_apply_tuple_type((jl_svec_t*)temp2);
             int nintr=0;
             jl_methlist_t *curr = mt->defs;
+            int specific_decl =
+                decl_i != (jl_value_t*)jl_any_type && decl_i != (jl_value_t*)jl_ANY_flag;
             // if this method is the only match even with the current slot
             // set to Any, then it is safe to cache it that way.
-            while (curr != (void*)jl_nothing && curr->func!=method) {
-                if (jl_type_intersection((jl_value_t*)curr->sig,
-                                         (jl_value_t*)temp2) !=
+            while (curr != (void*)jl_nothing && (curr->func != method || specific_decl)) {
+                if (jl_type_intersection((jl_value_t*)curr->sig, (jl_value_t*)temp2) !=
                     (jl_value_t*)jl_bottom_type) {
                     nintr++;
                     if (nintr > MAX_UNSPECIALIZED_CONFLICTS) break;
@@ -527,8 +542,12 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
             }
             else {
                 set_to_any = 1;
-                if (nintr > 0)
-                    need_guard_entries = 1;
+                if (nintr > 0) {
+                    if (specific_decl)
+                        cache_as_orig = 1;
+                    else
+                        need_guard_entries = 1;
+                }
             }
         }
         if (set_to_any || isstaged) {
@@ -702,17 +721,24 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
         }
         else {
             jl_value_t *lastdeclt = jl_tparam(decl,jl_nparams(decl)-1);
-            if (jl_svec_len(sparams) > 0) {
-                lastdeclt = (jl_value_t*)
-                    jl_instantiate_type_with((jl_value_t*)lastdeclt,
-                                             sparams->data,
-                                             jl_svec_len(sparams)/2);
+            int nsp = jl_svec_len(sparams);
+            if (nsp > 0) {
+                temp2 = (jl_value_t*)jl_alloc_svec_uninit(2*nsp);
+                for(j=0; j < nsp; j++) {
+                    if (j==0 && jl_is_typevar(m->tvars))
+                        jl_svecset(temp2, 0, m->tvars);
+                    else
+                        jl_svecset(temp2, j*2, jl_svecref(m->tvars, j));
+                    jl_svecset(temp2, j*2+1, jl_svecref(sparams,j));
+                }
+                lastdeclt = (jl_value_t*)jl_instantiate_type_with((jl_value_t*)lastdeclt,
+                                                                  jl_svec_data(temp2), nsp);
             }
             jl_svecset(limited, i, lastdeclt);
         }
         type = jl_apply_tuple_type(limited);
         temp2 = (jl_value_t*)type;
-        // now there is a problem: the computed signature is more
+        // now there is a problem: the widened signature is more
         // general than just the given arguments, so it might conflict
         // with another definition that doesn't have cache instances yet.
         // to fix this, we insert guard cache entries for all intersections
@@ -732,7 +758,7 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
         for(i=0; i < jl_array_len(temp); i++) {
             jl_value_t *m = jl_cellref(temp, i);
             jl_value_t *env = jl_svecref(m,1);
-            for(int k=1; k < jl_svec_len(env); k+=2) {
+            for(int k=0; k < jl_svec_len(env); k++) {
                 if (jl_is_typevar(jl_svecref(env,k))) {
                     unmatched_tvars = 1; break;
                 }
@@ -748,7 +774,7 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
             for(i=0; i < jl_array_len(temp); i++) {
                 jl_value_t *m = jl_cellref(temp, i);
                 if (((jl_methlist_t*)jl_svecref(m,2))->func != method) {
-                    jl_method_cache_insert(mt, (jl_tupletype_t*)jl_svecref(m, 0), jl_bottom_func);
+                    jl_method_cache_insert(mt, (jl_tupletype_t*)jl_svecref(m, 0), NULL);
                 }
             }
         }
@@ -757,11 +783,11 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
     // here we infer types and specialize the method
     jl_array_t *lilist=NULL;
     jl_lambda_info_t *li=NULL;
-    if (method->linfo && method->linfo->specializations!=NULL) {
+    if (method->specializations != NULL) {
         // reuse code already generated for this combination of lambda and
         // arguments types. this happens for inner generic functions where
         // a new closure is generated on each call to the enclosing function.
-        lilist = method->linfo->specializations;
+        lilist = method->specializations;
         int k;
         for(k=0; k < lilist->nrows; k++) {
             li = (jl_lambda_info_t*)jl_cellref(lilist, k);
@@ -772,86 +798,40 @@ static jl_function_t *cache_method(jl_methtable_t *mt, jl_tupletype_t *type,
     }
     if (lilist != NULL && !li->inInference) {
         assert(li);
-        newmeth = jl_reinstantiate_method(method, li);
-        (void)jl_method_cache_insert(mt, type, newmeth);
+        newmeth = li;
+        if (cache_as_orig)
+            (void)jl_method_cache_insert(mt, origtype, newmeth);
+        else
+            (void)jl_method_cache_insert(mt, type, newmeth);
         JL_GC_POP();
+        JL_UNLOCK(codegen);
         return newmeth;
     }
-    else {
-        if (jl_options.compile_enabled == JL_OPTIONS_COMPILE_OFF) {
-            if (method->linfo->unspecialized == NULL) {
-                jl_printf(JL_STDERR,"code missing for %s", method->linfo->name->name);
-                jl_static_show_func_sig(JL_STDERR, (jl_value_t*)type);
-                jl_printf(JL_STDERR, "  sysimg may not have been built with --compile=all\n");
-                exit(1);
-            }
-            jl_function_t *unspec = method->linfo->unspecialized;
-            if (method->env == (jl_value_t*)jl_emptysvec)
-                newmeth = unspec;
-            else
-                newmeth = jl_new_closure(unspec->fptr, method->env, unspec->linfo);
-
-            if (sparams != jl_emptysvec)
-                newmeth = with_appended_env(newmeth, sparams);
-
-            (void)jl_method_cache_insert(mt, type, newmeth);
-            JL_GC_POP();
-            return newmeth;
-        }
-        else {
-            newmeth = jl_instantiate_method(method, sparams);
-        }
-    }
-    /*
-      if "method" itself can ever be compiled, for example for use as
-      an unspecialized method (see below), then newmeth->fptr might point
-      to some slow compiled code instead of jl_trampoline, meaning our
-      type-inferred code would never get compiled. this can be fixed with
-      the commented-out snippet below.
-
-      NOTE: this is now needed when we start with a system image compiled
-      with --compile=all.
-    */
-    /*
-    assert(!(newmeth->linfo && newmeth->linfo->ast) ||
-           newmeth->fptr == &jl_trampoline);
-    */
-    if (newmeth->linfo && newmeth->linfo->ast && newmeth->fptr != &jl_trampoline) {
-        newmeth->fptr = &jl_trampoline;
-    }
 
-    (void)jl_method_cache_insert(mt, type, newmeth);
+    newmeth = jl_add_static_parameters(method, sparams, type);
 
-    if (newmeth->linfo != NULL && newmeth->linfo->sparams == jl_emptysvec) {
-        // when there are no static parameters, one unspecialized version
-        // of a function can be shared among all cached specializations.
-        if (method->linfo->unspecialized == NULL) {
-            method->linfo->unspecialized =
-                jl_instantiate_method(method, jl_emptysvec);
-            if (method->env != (jl_value_t*)jl_emptysvec)
-                method->linfo->unspecialized->env = NULL;
-            jl_gc_wb(method->linfo, method->linfo->unspecialized);
-        }
-        newmeth->linfo->unspecialized = method->linfo->unspecialized;
-        jl_gc_wb(newmeth->linfo, newmeth->linfo->unspecialized);
-    }
+    if (cache_as_orig)
+        (void)jl_method_cache_insert(mt, origtype, newmeth);
+    else
+        (void)jl_method_cache_insert(mt, type, newmeth);
 
-    if (newmeth->linfo != NULL && newmeth->linfo->ast != NULL) {
-        newmeth->linfo->specTypes = type;
-        jl_gc_wb(newmeth->linfo, type);
-        jl_array_t *spe = method->linfo->specializations;
+    if (newmeth->ast != NULL) {
+        jl_array_t *spe = method->specializations;
         if (spe == NULL) {
             spe = jl_alloc_cell_1d(1);
-            jl_cellset(spe, 0, newmeth->linfo);
+            jl_cellset(spe, 0, newmeth);
         }
         else {
-            jl_cell_1d_push(spe, (jl_value_t*)newmeth->linfo);
+            jl_cell_1d_push(spe, (jl_value_t*)newmeth);
         }
-        method->linfo->specializations = spe;
-        jl_gc_wb(method->linfo, method->linfo->specializations);
-        jl_type_infer(newmeth->linfo, type, method->linfo);
+        method->specializations = spe;
+        jl_gc_wb(method, method->specializations);
+        if (jl_options.compile_enabled != JL_OPTIONS_COMPILE_OFF) // don't bother with typeinf if compile is off
+            if (jl_symbol_name(newmeth->name)[0] != '@')  // don't bother with typeinf on macros
+                jl_type_infer(newmeth, method);
     }
     JL_GC_POP();
+    JL_UNLOCK(codegen);
     return newmeth;
 }
 
@@ -863,116 +843,98 @@ static jl_value_t *lookup_match(jl_value_t *a, jl_value_t *b, jl_svec_t **penv,
         return ti;
     JL_GC_PUSH1(&ti);
     assert(jl_is_svec(*penv));
-    jl_value_t **ee = (jl_value_t**)alloca(sizeof(void*) * jl_svec_len(*penv));
-    int n=0;
-    // only keep vars in tvars list
-    jl_value_t **tvs;
-    int tvarslen;
-    if (jl_is_typevar(tvars)) {
-        tvs = (jl_value_t**)&tvars;
-        tvarslen = 1;
-    }
-    else {
-        tvs = jl_svec_data(tvars);
-        tvarslen = jl_svec_len(tvars);
-    }
     int l = jl_svec_len(*penv);
-    for(int i=0; i < l; i+=2) {
-        jl_value_t *v = jl_svecref(*penv,i);
-        jl_value_t *val = jl_svecref(*penv,i+1);
-        for(int j=0; j < tvarslen; j++) {
-            if (v == tvs[j]) {
-                ee[n++] = v;
-                ee[n++] = val;
-                /*
-                  since "a" is a concrete type, we assume that
-                  (a∩b != Union{}) => a<:b. However if a static parameter is
-                  forced to equal Union{}, then part of "b" might become Union{},
-                  and therefore a subtype of "a". For example
-                  (Type{Union{}},Int) ∩ (Type{T},T)
-                  issue #5254
-                */
-                if (val == (jl_value_t*)jl_bottom_type) {
-                    if (!jl_subtype(a, ti, 0)) {
-                        JL_GC_POP();
-                        return (jl_value_t*)jl_bottom_type;
-                    }
-                }
+    for(int i=0; i < l; i++) {
+        jl_value_t *val = jl_svecref(*penv,i);
+        /*
+          since "a" is a concrete type, we assume that
+          (a∩b != Union{}) => a<:b. However if a static parameter is
+          forced to equal Union{}, then part of "b" might become Union{},
+          and therefore a subtype of "a". For example
+          (Type{Union{}},Int) ∩ (Type{T},T)
+          issue #5254
+        */
+        if (val == (jl_value_t*)jl_bottom_type) {
+            if (!jl_subtype(a, ti, 0)) {
+                JL_GC_POP();
+                return (jl_value_t*)jl_bottom_type;
             }
         }
     }
-    if (n != l) {
-        jl_svec_t *en = jl_alloc_svec_uninit(n);
-        memcpy(en->data, ee, n*sizeof(void*));
-        *penv = en;
-    }
     JL_GC_POP();
     return ti;
 }
 
-DLLEXPORT jl_function_t *jl_instantiate_staged(jl_methlist_t *m, jl_tupletype_t *tt, jl_svec_t *env)
+// invoke (compiling if necessary) the jlcall function pointer for an unspecialized method
+static jl_value_t *jl_call_unspecialized(jl_svec_t *sparam_vals, jl_lambda_info_t *meth,
+                                         jl_value_t **args, uint32_t nargs)
+{
+    if (__unlikely(meth->fptr == NULL)) {
+        jl_compile_linfo(meth, NULL);
+        jl_generate_fptr(meth);
+    }
+    assert(jl_svec_len(meth->sparam_syms) == jl_svec_len(sparam_vals));
+    if (__likely(meth->jlcall_api == 0))
+        return meth->fptr(args[0], &args[1], nargs-1);
+    else
+        return ((jl_fptr_sparam_t)meth->fptr)(sparam_vals, args[0], &args[1], nargs-1);
+}
+
+JL_DLLEXPORT jl_lambda_info_t *jl_instantiate_staged(jl_lambda_info_t *generator, jl_tupletype_t *tt, jl_svec_t *env)
 {
     jl_expr_t *ex = NULL;
-    jl_expr_t *oldast = NULL;
-    jl_function_t *func = NULL;
     jl_value_t *linenum = NULL;
-    JL_GC_PUSH4(&ex, &oldast, &func, &linenum);
-    if (jl_is_expr(m->func->linfo->ast))
-        oldast = (jl_expr_t*)m->func->linfo->ast;
-    else
-        oldast = (jl_expr_t*)jl_uncompress_ast(m->func->linfo, m->func->linfo->ast);
-    assert(oldast->head == lambda_sym);
-    ex = jl_exprn(arrow_sym, 2);
-    jl_array_t *oldargnames = jl_lam_args(oldast);
-    jl_expr_t *argnames = jl_exprn(tuple_sym, jl_array_len(oldargnames));
+    jl_svec_t *sparam_vals = env;
+    JL_GC_PUSH3(&ex, &linenum, &sparam_vals);
+
+    assert(generator->sparam_vals == jl_emptysvec);
+    assert(jl_svec_len(generator->sparam_syms) == jl_svec_len(sparam_vals));
+    assert(generator->unspecialized == NULL && generator->specTypes == jl_anytuple_type);
+    //if (!generated->inferred)
+    //    jl_type_infer(generator, generator);  // this doesn't help all that much
+
+    ex = jl_exprn(lambda_sym, 2);
+
+    jl_expr_t *generatorast = (jl_expr_t*)generator->ast;
+    if (!jl_is_expr(generatorast))
+        generatorast = (jl_expr_t*)jl_uncompress_ast(generator, (jl_value_t*)generatorast);
+    jl_array_t *argnames = jl_lam_args(generatorast);
     jl_cellset(ex->args, 0, argnames);
-    for (size_t i = 0; i < jl_array_len(oldargnames); ++i) {
-        jl_value_t *arg = jl_cellref(oldargnames,i);
-        if (jl_is_expr(arg)) {
-            assert(((jl_expr_t*)arg)->head == colons_sym);
-            arg = jl_cellref(((jl_expr_t*)arg)->args,0);
-            assert(jl_is_symbol(arg));
-            jl_expr_t *dd_expr = jl_exprn(dots_sym,1);
-            jl_cellset(dd_expr->args,0,arg);
-            jl_cellset(argnames->args,i,dd_expr);
-        }
-        else {
-            assert(jl_is_symbol(arg));
-            jl_cellset(argnames->args,i,arg);
-        }
-    }
-    func = with_appended_env(m->func, env);
+
+    jl_expr_t *scopeblock = jl_exprn(jl_symbol("scope-block"), 1);
+    jl_cellset(ex->args, 1, scopeblock);
+
     jl_expr_t *body = jl_exprn(jl_symbol("block"), 2);
-    jl_cellset(ex->args, 1, body);
-    linenum = jl_box_long(m->func->linfo->line);
-    jl_value_t *linenode = jl_new_struct(jl_linenumbernode_type,
-                                         m->func->linfo->file,
-                                         linenum
-                                         );
+    jl_cellset(((jl_expr_t*)jl_exprarg(ex,1))->args, 0, body);
+
+    linenum = jl_box_long(generator->line);
+    jl_value_t *linenode = jl_new_struct(jl_linenumbernode_type, generator->file, linenum);
     jl_cellset(body->args, 0, linenode);
-    jl_cellset(body->args, 1, jl_apply(func, jl_svec_data(tt->parameters), jl_nparams(tt)));
-    if (m->tvars != jl_emptysvec) {
+
+    // invoke code generator
+    assert(jl_nparams(tt) == jl_array_len(argnames) ||
+           (jl_is_rest_arg(jl_cellref(argnames, jl_array_len(argnames)-1)) &&
+            (jl_nparams(tt) >= jl_array_len(argnames) - 1)));
+    jl_cellset(body->args, 1, jl_call_unspecialized(sparam_vals, generator, jl_svec_data(tt->parameters), jl_nparams(tt)));
+
+    if (generator->sparam_syms != jl_emptysvec) {
         // mark this function as having the same static parameters as the generator
-        size_t nsp = jl_is_typevar(m->tvars) ? 1 : jl_svec_len(m->tvars);
-        oldast = jl_exprn(jl_symbol("with-static-parameters"), nsp+1);
-        jl_exprarg(oldast,0) = (jl_value_t*)ex;
+        size_t i, nsp = jl_svec_len(generator->sparam_syms);
+        jl_expr_t *newast = jl_exprn(jl_symbol("with-static-parameters"), nsp + 1);
+        jl_exprarg(newast, 0) = (jl_value_t*)ex;
         // (with-static-parameters func_expr sp_1 sp_2 ...)
-        if (jl_is_typevar(m->tvars)) {
-            jl_exprarg(oldast,1) = (jl_value_t*)((jl_tvar_t*)m->tvars)->name;
-        }
-        else {
-            for(size_t i=0; i < nsp; i++)
-                jl_exprarg(oldast,i+1) = (jl_value_t*)((jl_tvar_t*)jl_svecref(m->tvars,i))->name;
-        }
-        ex = oldast;
+        for (i = 0; i < nsp; i++)
+            jl_exprarg(newast, i+1) = jl_svecref(generator->sparam_syms, i);
+        ex = newast;
     }
-    func = (jl_function_t*)jl_toplevel_eval_in(m->func->linfo->module, (jl_value_t*)ex, 1); // need to eval macros in the right module, but not give a warning for the `eval` call unless that results in a call to `eval`
-    func->linfo->name = m->func->linfo->name;
+    // need to eval macros in the right module, but not give a warning for the `eval` call unless that results in a call to `eval`
+    jl_lambda_info_t *func = (jl_lambda_info_t*)jl_toplevel_eval_in_warn(generator->module, (jl_value_t*)ex, 1);
+    func->name = generator->name;
     JL_GC_POP();
     return func;
 }
 
-static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype_t *tt, int cache, int inexact)
+static jl_lambda_info_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype_t *tt, int cache, int inexact)
 {
     jl_methlist_t *m = mt->defs;
     size_t nargs = jl_nparams(tt);
@@ -980,7 +942,7 @@ static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype_t *tt,
     jl_value_t *ti=(jl_value_t*)jl_bottom_type;
     jl_tupletype_t *newsig=NULL;
     jl_svec_t *env = jl_emptysvec;
-    jl_function_t *func = NULL;
+    jl_lambda_info_t *func = NULL;
     JL_GC_PUSH3(&env, &newsig, &func);
 
     while (m != (void*)jl_nothing) {
@@ -989,7 +951,7 @@ static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype_t *tt,
             if (ti != (jl_value_t*)jl_bottom_type) {
                 // parametric methods only match if all typevars are matched by
                 // non-typevars.
-                for(i=1; i < jl_svec_len(env); i+=2) {
+                for(i=0; i < jl_svec_len(env); i++) {
                     if (jl_is_typevar(jl_svecref(env,i))) {
                         if (inexact) {
                             // "inexact" means the given type is compile-time,
@@ -997,7 +959,7 @@ static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype_t *tt,
                             // static parameter is inconclusive.
                             // this is issue #3182, see test/core.jl
                             JL_GC_POP();
-                            return jl_bottom_func;
+                            return NULL;
                         }
                         break;
                     }
@@ -1017,44 +979,44 @@ static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_datatype_t *tt,
         if (m != (void*)jl_nothing) {
             func = m->func;
             if (m->isstaged)
-                func = jl_instantiate_staged(m,tt,env);
+                func = jl_instantiate_staged(func, tt, env);
             if (!cache) {
                 JL_GC_POP();
                 return func;
             }
-            jl_function_t *res = cache_method(mt, tt, func, m->sig, jl_emptysvec, m->isstaged);
+            // make sure the argument is rooted in `cache_method`
+            // in case another thread changed it.
+            newsig = m->sig;
+            jl_lambda_info_t *res = cache_method(mt, tt, func, m, jl_emptysvec);
             JL_GC_POP();
             return res;
         }
         JL_GC_POP();
-        return jl_bottom_func;
+        return NULL;
     }
 
     assert(jl_is_svec(env));
     func = m->func;
 
+    if (inexact && !jl_types_equal(ti, (jl_value_t*)tt)) {
+        // the compiler might attempt jl_get_specialization on e.g.
+        // convert(::Type{Type{Int}}, ::DataType), which is concrete but might not
+        // equal the run time type. in this case ti would be {Type{Type{Int}}, Type{Int}}
+        // but tt would be {Type{Type{Int}}, DataType}.
+        JL_GC_POP();
+        return NULL;
+    }
+
     if (m->isstaged)
-        func = jl_instantiate_staged(m,tt,env);
+        func = jl_instantiate_staged(func, tt, env);
 
-    // don't bother computing this if no arguments are tuples
-    for(i=0; i < jl_nparams(tt); i++) {
-        if (jl_is_tuple_type(jl_tparam(tt,i)))
-            break;
-    }
-    if (i < jl_nparams(tt)) {
-        newsig = (jl_tupletype_t*)jl_instantiate_type_with((jl_value_t*)m->sig,
-                                                           jl_svec_data(env),
-                                                           jl_svec_len(env)/2);
-    }
-    else {
-        newsig = m->sig;
-    }
+    newsig = m->sig;
     assert(jl_is_tuple_type(newsig));
-    jl_function_t *nf;
+    jl_lambda_info_t *nf;
     if (!cache)
         nf = func;
     else
-        nf = cache_method(mt, tt, func, newsig, env, m->isstaged);
+        nf = cache_method(mt, tt, func, m, env);
     JL_GC_POP();
     return nf;
 }
@@ -1069,7 +1031,7 @@ static int sigs_eq(jl_value_t *a, jl_value_t *b, int useenv)
     return jl_subtype(a, b, 0) && jl_subtype(b, a, 0);
 }
 
-DLLEXPORT int jl_args_morespecific(jl_value_t *a, jl_value_t *b)
+JL_DLLEXPORT int jl_args_morespecific(jl_value_t *a, jl_value_t *b)
 {
     int msp = jl_type_morespecific(a,b);
     int btv = jl_has_typevars(b);
@@ -1150,22 +1112,20 @@ static void check_ambiguous(jl_methlist_t *ml, jl_tupletype_t *type,
             return;
         }
         jl_methlist_t *l = ml;
-        char *n;
         JL_STREAM *s;
         while (l != (void*)jl_nothing) {
             if (sigs_eq(isect, (jl_value_t*)l->sig, 0))
                 goto done_chk_amb;  // ok, intersection is covered
             l = l->next;
         }
-        n = fname->name;
         s = JL_STDERR;
-        jl_printf(s, "WARNING: New definition \n    %s", n);
+        jl_printf(s, "WARNING: New definition \n    ");
         jl_static_show_func_sig(s, (jl_value_t*)type);
         print_func_loc(s, linfo);
-        jl_printf(s, "\nis ambiguous with: \n    %s", n);
+        jl_printf(s, "\nis ambiguous with: \n    ");
         jl_static_show_func_sig(s, (jl_value_t*)sig);
-        print_func_loc(s, oldmeth->func->linfo);
-        jl_printf(s, ".\nTo fix, define \n    %s", n);
+        print_func_loc(s, oldmeth->func);
+        jl_printf(s, ".\nTo fix, define \n    ");
         jl_static_show_func_sig(s, isect);
         jl_printf(s, "\nbefore the new definition.\n");
     done_chk_amb:
@@ -1187,7 +1147,7 @@ static int has_unions(jl_tupletype_t *type)
 
 static
 jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
-                                     jl_function_t *method, jl_svec_t *tvars,
+                                     jl_lambda_info_t *method, jl_svec_t *tvars,
                                      int check_amb, int8_t isstaged, jl_value_t *parent)
 {
     jl_methlist_t *l, **pl;
@@ -1197,17 +1157,21 @@ jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
     while (l != (void*)jl_nothing) {
         if (((l->tvars==jl_emptysvec) == (tvars==jl_emptysvec)) &&
             sigs_eq((jl_value_t*)type, (jl_value_t*)l->sig, 1)) {
+            if (method == NULL)  // don't overwrite with guard entries
+                return l;
             // method overwritten
-            if (check_amb && l->func->linfo && method->linfo &&
-                (l->func->linfo->module != method->linfo->module)) {
-                jl_module_t *newmod = method->linfo->module;
+            if (check_amb && l->func && method) {
+                jl_module_t *newmod = method->module;
+                jl_module_t *oldmod = l->func->module;
                 JL_STREAM *s = JL_STDERR;
-                jl_printf(s, "WARNING: Method definition %s", method->linfo->name->name);
+                jl_printf(s, "WARNING: Method definition ");
                 jl_static_show_func_sig(s, (jl_value_t*)type);
-                jl_printf(s, " in module %s", l->func->linfo->module->name->name);
-                print_func_loc(s, l->func->linfo);
-                jl_printf(s, " overwritten in module %s", newmod->name->name);
-                print_func_loc(s, method->linfo);
+                jl_printf(s, " in module %s", jl_symbol_name(oldmod->name));
+                print_func_loc(s, l->func);
+                jl_printf(s, " overwritten");
+                if (oldmod != newmod)
+                    jl_printf(s, " in module %s", jl_symbol_name(newmod->name));
+                print_func_loc(s, method);
                 jl_printf(s, ".\n");
             }
             JL_SIGATOMIC_BEGIN();
@@ -1218,8 +1182,10 @@ jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
             l->va = jl_is_va_tuple(type);
             l->isstaged = isstaged;
             l->invokes = (struct _jl_methtable_t *)jl_nothing;
+            // TODO: `l->func` or `l->func->roots` might need to be rooted
             l->func = method;
-            jl_gc_wb(l, l->func);
+            if (l->func)
+                jl_gc_wb(l, l->func);
             JL_SIGATOMIC_END();
             return l;
         }
@@ -1232,9 +1198,7 @@ jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
         if (jl_args_morespecific((jl_value_t*)type, (jl_value_t*)l->sig))
             break;
         if (check_amb) {
-            check_ambiguous(*pml, type, l,
-                            method->linfo ? method->linfo->name :
-                            anonymous_sym, method->linfo);
+            check_ambiguous(*pml, type, l, method->name, method);
         }
         pl = &l->next;
         pa = (jl_value_t*)l;
@@ -1256,8 +1220,8 @@ jl_methlist_t *jl_method_list_insert(jl_methlist_t **pml, jl_tupletype_t *type,
     // if this contains Union types, methods after it might actually be
     // more specific than it. we need to re-sort them.
     if (has_unions(type)) {
-        jl_value_t* item_parent = (jl_value_t*)newrec;
-        jl_value_t* next_parent = 0;
+        jl_value_t *item_parent = (jl_value_t*)newrec;
+        jl_value_t *next_parent = 0;
         jl_methlist_t *item = newrec->next, *next;
         jl_methlist_t **pitem = &newrec->next, **pnext;
         while (item != (void*)jl_nothing) {
@@ -1320,11 +1284,15 @@ static void update_max_args(jl_methtable_t *mt, jl_tupletype_t *type)
 }
 
 jl_methlist_t *jl_method_table_insert(jl_methtable_t *mt, jl_tupletype_t *type,
-                                      jl_function_t *method, jl_svec_t *tvars,
+                                      jl_lambda_info_t *method, jl_svec_t *tvars,
                                       int8_t isstaged)
 {
     if (jl_svec_len(tvars) == 1)
         tvars = (jl_svec_t*)jl_svecref(tvars,0);
+    if (isstaged) // staged function definitions will be compiled directly. mark them accordingly.
+        method->specTypes = jl_anytuple_type;
+    else // otherwise, the method will be compiled via unspecialized or the method cache, never directly
+        assert(!method->specTypes);
     JL_SIGATOMIC_BEGIN();
     jl_methlist_t *ml = jl_method_list_insert(&mt->defs,type,method,tvars,1,isstaged,(jl_value_t*)mt);
     // invalidate cached methods that overlap this definition
@@ -1353,26 +1321,36 @@ jl_methlist_t *jl_method_table_insert(jl_methtable_t *mt, jl_tupletype_t *type,
     return ml;
 }
 
-void NORETURN jl_no_method_error_bare(jl_function_t *f, jl_value_t *args)
+void JL_NORETURN jl_no_method_error_bare(jl_function_t *f, jl_value_t *args)
 {
     jl_value_t *fargs[3] = {
         (jl_value_t*)jl_methoderror_type,
         (jl_value_t*)f,
         args
     };
-    jl_throw(jl_apply(jl_module_call_func(jl_base_module), fargs, 3));
+    if (jl_base_module) {
+        jl_throw(jl_apply_generic(fargs, 3));
+    }
+    else {
+        jl_printf((JL_STREAM*)STDERR_FILENO, "A method error occurred before the base module was defined. Aborting...\n");
+        jl_static_show((JL_STREAM*)STDERR_FILENO,(jl_value_t*)f); jl_printf((JL_STREAM*)STDERR_FILENO,"\n");
+        jl_static_show((JL_STREAM*)STDERR_FILENO,args); jl_printf((JL_STREAM*)STDERR_FILENO,"\n");
+        jl_bt_size = rec_backtrace(jl_bt_data, JL_MAX_BT_SIZE);
+        jl_critical_error(0, NULL, jl_bt_data, &jl_bt_size);
+        abort();
+    }
     // not reached
 }
 
-void NORETURN jl_no_method_error(jl_function_t *f, jl_value_t **args, size_t na)
+void JL_NORETURN jl_no_method_error(jl_function_t *f, jl_value_t **args, size_t na)
 {
-    jl_value_t *argtup = jl_f_tuple(NULL, args, na);
+    jl_value_t *argtup = jl_f_tuple(NULL, args+1, na-1);
     JL_GC_PUSH1(&argtup);
     jl_no_method_error_bare(f, argtup);
     // not reached
 }
 
-static jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs)
+jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs)
 {
     jl_tupletype_t *tt;
     size_t i;
@@ -1405,21 +1383,26 @@ static jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs)
     return tt;
 }
 
-jl_function_t *jl_method_lookup_by_type(jl_methtable_t *mt, jl_tupletype_t *types,
-                                        int cache, int inexact)
+jl_lambda_info_t *jl_method_lookup_by_type(jl_methtable_t *mt, jl_tupletype_t *types,
+                                           int cache, int inexact)
 {
-    jl_function_t *sf = jl_method_table_assoc_exact_by_type(mt, types);
-    if (sf == jl_bottom_func) {
+    jl_lambda_info_t *sf = jl_method_table_assoc_exact_by_type(mt, types);
+    if (sf == NULL) {
         if (jl_is_leaf_type((jl_value_t*)types)) cache=1;
         sf = jl_mt_assoc_by_type(mt, types, cache, inexact);
     }
     return sf;
 }
 
-jl_function_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t nargs, int cache)
+JL_DLLEXPORT int jl_method_exists(jl_methtable_t *mt, jl_tupletype_t *types)
+{
+    return jl_method_lookup_by_type(mt, types, 0, 0) != NULL;
+}
+
+jl_lambda_info_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t nargs, int cache)
 {
-    jl_function_t *sf = jl_method_table_assoc_exact(mt, args, nargs);
-    if (sf == jl_bottom_func) {
+    jl_lambda_info_t *sf = jl_method_table_assoc_exact(mt, args, nargs);
+    if (sf == NULL) {
         jl_tupletype_t *tt = arg_type_tuple(args, nargs);
         JL_GC_PUSH1(&tt);
         sf = jl_mt_assoc_by_type(mt, tt, cache, 0);
@@ -1428,14 +1411,15 @@ jl_function_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t na
     return sf;
 }
 
-DLLEXPORT jl_value_t *jl_matching_methods(jl_function_t *gf, jl_value_t *type, int lim);
+JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_value_t *types, int lim);
 
 // compile-time method lookup
-jl_function_t *jl_get_specialization(jl_function_t *f, jl_tupletype_t *types)
+jl_lambda_info_t *jl_get_specialization1(jl_tupletype_t *types, void *cyclectx)
 {
+    assert(jl_nparams(types) > 0);
     if (!jl_is_leaf_type((jl_value_t*)types))
         return NULL;
-    assert(jl_is_gf(f));
+    assert(jl_is_datatype(jl_tparam0(types)));
 
     // make sure exactly 1 method matches (issue #7302).
     int i;
@@ -1445,15 +1429,15 @@ jl_function_t *jl_get_specialization(jl_function_t *f, jl_tupletype_t *types)
         // might match. also be conservative with tuples rather than trying
         // to analyze them in detail.
         if (ti == (jl_value_t*)jl_datatype_type || jl_is_tuple_type(ti)) {
-            jl_value_t *matches = jl_matching_methods(f, (jl_value_t*)types, 1);
+            jl_value_t *matches = jl_matching_methods((jl_value_t*)types, 1);
             if (matches == jl_false)
                 return NULL;
             break;
         }
     }
 
-    jl_methtable_t *mt = jl_gf_mtable(f);
-    jl_function_t *sf = NULL;
+    jl_methtable_t *mt = ((jl_datatype_t*)jl_tparam0(types))->name->mt;
+    jl_lambda_info_t *sf = NULL;
     // most of the time sf is rooted in mt, but if the method is staged it may
     // not be the case
     JL_GC_PUSH1(&sf);
@@ -1462,17 +1446,12 @@ jl_function_t *jl_get_specialization(jl_function_t *f, jl_tupletype_t *types)
     } JL_CATCH {
         goto not_found;
     }
-    if (sf == jl_bottom_func) {
-        goto not_found;
-    }
-    if (sf->linfo == NULL || sf->linfo->ast == NULL) {
+    if (sf == NULL || sf->ast == NULL || sf->inInference)
         goto not_found;
-    }
-    if (sf->linfo->inInference) goto not_found;
-    if (sf->linfo->functionObject == NULL) {
-        if (sf->fptr != &jl_trampoline)
+    if (sf->functionObjects.functionObject == NULL) {
+        if (sf->fptr != NULL)
             goto not_found;
-        jl_compile(sf);
+        jl_compile_linfo(sf, cyclectx);
     }
     JL_GC_POP();
     return sf;
@@ -1481,147 +1460,330 @@ jl_function_t *jl_get_specialization(jl_function_t *f, jl_tupletype_t *types)
     return NULL;
 }
 
-void jl_trampoline_compile_function(jl_function_t *f, int always_infer, jl_tupletype_t *sig);
+// add type of `f` to front of argument tuple type
+jl_tupletype_t *jl_argtype_with_function(jl_function_t *f, jl_tupletype_t *types)
+{
+    size_t l = jl_nparams(types);
+    jl_value_t *tt = (jl_value_t*)jl_alloc_svec(1+l);
+    size_t i;
+    JL_GC_PUSH1(&tt);
+    if (jl_is_type(f))
+        jl_svecset(tt, 0, jl_wrap_Type(f));
+    else
+        jl_svecset(tt, 0, jl_typeof(f));
+    for(i=0; i < l; i++)
+        jl_svecset(tt, i+1, jl_tparam(types,i));
+    tt = (jl_value_t*)jl_apply_tuple_type((jl_svec_t*)tt);
+    JL_GC_POP();
+    return (jl_tupletype_t*)tt;
+}
+
+static int tupletype_any_bottom(jl_value_t *sig)
+{
+    jl_svec_t *types = ((jl_tupletype_t*)sig)->types;
+    size_t i, l = jl_svec_len(types);
+    for (i = 0; i < l; i++) {
+        if (jl_svecref(types, i) == jl_bottom_type)
+            return 1;
+    }
+    return 0;
+}
 
-static void parameters_to_closureenv(jl_value_t *ast, jl_svec_t *tvars)
+static int _compile_all_tvar_union(jl_methlist_t *meth, jl_tupletype_t *methsig)
 {
-    jl_array_t *closed = jl_lam_capt((jl_expr_t*)ast);
-    jl_value_t **tvs;
+    // f{<:Union{...}}(...) is a common pattern
+    // and expanding the Union may give a leaf function
+    jl_tvar_t **tvs;
     int tvarslen;
-    if (jl_is_typevar(tvars)) {
-        tvs = (jl_value_t**)&tvars;
+    if (jl_is_typevar(meth->tvars)) {
+        tvs = (jl_tvar_t**)&meth->tvars;
         tvarslen = 1;
     }
     else {
-        tvs = jl_svec_data(tvars);
-        tvarslen = jl_svec_len(tvars);
+        tvs = (jl_tvar_t**)jl_svec_data(meth->tvars);
+        tvarslen = jl_svec_len(meth->tvars);
+        if (tvarslen == 0) {
+            if (jl_is_leaf_type((jl_value_t*)methsig)) {
+                // usually can create a specialized version of the function,
+                // if the signature is already a leaftype
+                jl_lambda_info_t *spec = jl_get_specialization1(methsig, NULL);
+                if (spec) {
+                    if (methsig == meth->sig) {
+                        // replace unspecialized func with newly specialized version
+                        meth->func->unspecialized = spec;
+                        jl_gc_wb(meth->func, spec);
+                    }
+                    return 1;
+                }
+            }
+            return 0;
+        }
     }
-    if (jl_in_vinfo_array(closed, ((jl_tvar_t*)tvs[0])->name))
-        return;
-    size_t i;
-    jl_array_t *vi=NULL;
-    JL_GC_PUSH1(&vi);
-    for(i=0; i < tvarslen; i++) {
-        vi = jl_alloc_cell_1d(3);
-        jl_cellset(vi, 0, ((jl_tvar_t*)tvs[i])->name);
-        jl_cellset(vi, 1, jl_any_type);
-        jl_cellset(vi, 2, jl_box_long(1));
-        jl_cell_1d_push(closed, (jl_value_t*)vi);
+
+    int complete = 1;
+    jl_value_t **env;
+    JL_GC_PUSHARGS(env, 2 * tvarslen);
+    int *idx = (int*)alloca(sizeof(int) * tvarslen);
+    int i;
+    for (i = 0; i < tvarslen; i++) {
+        idx[i] = 0;
+        env[2 * i] = (jl_value_t*)tvs[i];
+        env[2 * i + 1] = jl_bottom_type; // initialize the list with Union{}, since T<:Union{} is always a valid option
+    }
+
+    for (i = 0; i < tvarslen; /* incremented by inner loop */) {
+        jl_value_t *sig;
+        JL_TRY {
+            sig = (jl_value_t*)
+                jl_instantiate_type_with((jl_value_t*)methsig, env, tvarslen);
+        }
+        JL_CATCH {
+            goto getnext; // sigh, we found an invalid type signature. should we warn the user?
+        }
+        assert(jl_is_tuple_type(sig));
+        if (sig == jl_bottom_type || tupletype_any_bottom(sig)) {
+            goto getnext; // signature wouldn't be callable / is invalid -- skip it
+        }
+        if (jl_is_leaf_type(sig)) {
+            if (jl_get_specialization1((jl_tupletype_t*)sig, NULL)) {
+                if (!jl_has_typevars((jl_value_t*)sig)) goto getnext; // success
+            }
+        }
+        complete = 0;
+
+getnext:
+        for (i = 0; i < tvarslen; i++) {
+            jl_tvar_t *tv = tvs[i];
+            if (jl_is_uniontype(tv->ub)) {
+                jl_uniontype_t *ub = (jl_uniontype_t*)tv->ub;
+                size_t l = jl_svec_len(ub->types);
+                size_t j = idx[i];
+                if (j == l) {
+                    env[2 * i + 1] = jl_bottom_type;
+                    idx[i] = 0;
+                }
+                else {
+                    jl_value_t *ty = jl_svecref(ub->types, j);
+                    if (!jl_is_leaf_type(ty))
+                        ty = (jl_value_t*)jl_new_typevar(tv->name, tv->lb, ty);
+                    env[2 * i + 1] = ty;
+                    idx[i] = j + 1;
+                    break;
+                }
+            }
+            else {
+                env[2 * i + 1] = (jl_value_t*)tv;
+                complete = 0;
+            }
+        }
     }
     JL_GC_POP();
+    return complete;
 }
 
-static void all_p2c(jl_value_t *ast, jl_svec_t *tvars)
+static int _compile_all_union(jl_methlist_t *meth)
 {
-    if (jl_is_lambda_info(ast)) {
-        jl_lambda_info_t *li = (jl_lambda_info_t*)ast;
-        li->ast = jl_prepare_ast(li, jl_emptysvec);
-        jl_gc_wb(li, li->ast);
-        parameters_to_closureenv(li->ast, tvars);
-        all_p2c(li->ast, tvars);
-    }
-    else if (jl_is_expr(ast)) {
-        jl_expr_t *e = (jl_expr_t*)ast;
-        for(size_t i=0; i < jl_array_len(e->args); i++)
-            all_p2c(jl_exprarg(e,i), tvars);
+    // f(::Union{...}, ...) is a common pattern
+    // and expanding the Union may give a leaf function
+    jl_tupletype_t *sig = meth->sig;
+    int complete = 1;
+    size_t count_unions = 0;
+    size_t i, l = jl_svec_len(sig->parameters);
+    jl_svec_t *p = NULL;
+    jl_tupletype_t *methsig = NULL;
+
+    for (i = 0; i < l; i++) {
+        jl_value_t *ty = jl_svecref(sig->parameters, i);
+        if (jl_is_uniontype(ty)) {
+            jl_svec_t *utypes = ((jl_uniontype_t*)ty)->types;
+            size_t l = jl_svec_len(utypes);
+            if (l == 0)
+                return 1; // why does this method exist?
+            ++count_unions;
+        }
+    }
+
+    if (count_unions == 0)
+        return _compile_all_tvar_union(meth, sig);
+
+    int *idx = (int*)alloca(sizeof(int) * count_unions);
+    for (i = 0; i < count_unions; i++) {
+        idx[i] = 0;
+    }
+
+    JL_GC_PUSH2(&p, &methsig);
+    int idx_ctr = 0, incr = 0;
+    while (!incr) {
+        jl_svec_t *p = jl_alloc_svec_uninit(l);
+        for (i = 0, idx_ctr = 0, incr = 1; i < l; i++) {
+            jl_value_t *ty = jl_svecref(sig->parameters, i);
+            if (jl_is_uniontype(ty)) {
+                jl_svec_t *utypes = ((jl_uniontype_t*)ty)->types;
+                size_t l = jl_svec_len(utypes);
+                size_t j = idx[idx_ctr];
+                jl_svecset(p, i, jl_svecref(utypes, j));
+                ++j;
+                if (incr) {
+                    if (j == l) {
+                        idx[idx_ctr] = 0;
+                    }
+                    else {
+                        idx[idx_ctr] = j;
+                        incr = 0;
+                    }
+                }
+                ++idx_ctr;
+            }
+            else {
+                jl_svecset(p, i, ty);
+            }
+        }
+        methsig = jl_apply_tuple_type(p);
+        if (!_compile_all_tvar_union(meth, methsig))
+            complete = 0;
     }
+
+    JL_GC_POP();
+    return complete;
 }
 
-static void precompile_unspecialized(jl_function_t *func, jl_tupletype_t *sig, jl_svec_t *tvars)
+static void _compile_all_deq(jl_array_t *found)
 {
-    assert(sig);
-    func->linfo->specTypes = sig;
-    jl_gc_wb(func->linfo, sig);
-    if (tvars != jl_emptysvec) {
-        // add static parameter names to end of closure env; compile
-        // assuming they are there. method cache will fill them in when
-        // it constructs closures for new "specializations".
-        all_p2c((jl_value_t*)func->linfo, tvars);
-    }
-    jl_trampoline_compile_function(func, 1, sig);
+    size_t found_i, found_l = jl_array_len(found);
+    jl_printf(JL_STDERR, "found %d uncompiled methods for compile-all\n", (int)found_l);
+    for (found_i = 0; found_i < found_l; found_i++) {
+        jl_printf(JL_STDERR, " %zd / %zd\r", found_i + 1, found_l);
+        jl_methlist_t *meth = (jl_methlist_t*)jl_cellref(found, found_i);
+        jl_lambda_info_t *linfo = meth->func;
+
+        if (!linfo)
+            return; // XXX: how does this happen
+        if (!linfo->specTypes)
+            linfo = jl_get_unspecialized(linfo);
+        if (!linfo->inferred) {
+            // force this function to be recompiled
+            jl_type_infer(linfo, linfo->def);
+            linfo->functionObjects.functionObject = NULL;
+            linfo->functionObjects.specFunctionObject = NULL;
+            linfo->functionObjects.cFunctionList = NULL;
+            linfo->functionID = 0;
+            linfo->specFunctionID = 0;
+            linfo->jlcall_api = 0;
+        }
+
+        // keep track of whether all possible signatures have been cached (and thus whether it can skip trying to compile the unspecialized function)
+        // this is necessary because many intrinsics try to call static_eval and thus are not compilable unspecialized
+        int complete = _compile_all_union(meth);
+        if (complete) {
+            if (!linfo->functionID)
+                // indicate that this method doesn't need a functionID because it was fully covered above
+                linfo->functionID = -1;
+        }
+        else {
+            jl_compile_linfo(linfo, NULL);
+            assert(linfo->functionID > 0);
+        }
+    }
+    jl_printf(JL_STDERR, "\n");
 }
 
-void jl_compile_all_defs(jl_function_t *gf)
+static void _compile_all_enq_mt(jl_methtable_t *mt, jl_array_t *found);
+static void _compile_all_enq_ml(jl_methlist_t *ml, jl_array_t *found)
 {
-    assert(jl_is_gf(gf));
-    jl_methtable_t *mt = jl_gf_mtable(gf);
-    if (mt->kwsorter != NULL)
-        jl_compile_all_defs(mt->kwsorter);
-    jl_methlist_t *m = mt->defs;
-    jl_function_t *func = NULL;
-    JL_GC_PUSH1(&func);
-    while (m != (void*)jl_nothing) {
-        if (jl_is_leaf_type((jl_value_t*)m->sig)) {
-            if (jl_get_specialization(gf, m->sig)) {
-                m = m->next;
-                continue;
+    while (ml != NULL && (jl_value_t*)ml != jl_nothing) {
+        if (ml->func != NULL) {
+            // found a method (not a placeholder guard)
+            jl_lambda_info_t *linfo = ml->func;
+            if (!linfo->specTypes) {
+                // method definition -- compile via unspecialized field
+                if (linfo->fptr != NULL)
+                    return; // builtin function
+                linfo = jl_get_unspecialized(linfo);
+            }
+            if (!linfo->functionID) {
+                // and it still needs to be compiled
+                if (!ml->isstaged)
+                    jl_cell_1d_push(found, (jl_value_t*)ml);
             }
         }
-        if (m->func->linfo->unspecialized == NULL) {
-            func = jl_instantiate_method(m->func, jl_emptysvec);
-            if (func->env != (jl_value_t*)jl_emptysvec)
-                func->env = NULL;
-            m->func->linfo->unspecialized = func;
-            jl_gc_wb(m->func->linfo, func);
-            precompile_unspecialized(func, m->sig, m->tvars);
+        _compile_all_enq_mt(ml->invokes, found);
+        ml = ml->next;
+    }
+}
+
+static void _compile_all_enq_mt(jl_methtable_t *mt, jl_array_t *found)
+{
+    jl_array_t *a;
+    if (mt == NULL || (jl_value_t*)mt == jl_nothing) return;
+    _compile_all_enq_ml(mt->defs, found);
+    _compile_all_enq_ml(mt->cache, found);
+
+    a = mt->cache_arg1;
+    if ((jl_value_t*)a != jl_nothing) {
+        size_t i, l = jl_array_len(a);
+        for (i = 0; i < l; i++) {
+            _compile_all_enq_ml((jl_methlist_t*)jl_cellref(a, i), found);
+        }
+    }
+
+    a = mt->cache_targ;
+    if ((jl_value_t*)a != jl_nothing) {
+        size_t i, l = jl_array_len(a);
+        for (i = 0; i < l; i++) {
+            _compile_all_enq_ml((jl_methlist_t*)jl_cellref(a, i), found);
         }
-        m = m->next;
     }
-    JL_GC_POP();
 }
 
-static void _compile_all(jl_module_t *m, htable_t *h)
+static void _compile_all_enq_module(jl_module_t *m, jl_array_t *found)
 {
-    size_t i;
-    size_t sz = m->bindings.size;
-    void **table = (void**) malloc(sz * sizeof(void*));
-    memcpy(table, m->bindings.table, sz*sizeof(void*));
-    ptrhash_put(h, m, m);
+    // scan through all types reachable from 'v' and
+    // record all jl_lambda_info_t objects and signatures in their method tables
+    size_t i, sz = m->bindings.size;
     for(i=1; i < sz; i+=2) {
-        if (table[i] != HT_NOTFOUND) {
-            jl_binding_t *b = (jl_binding_t*)table[i];
-            if (b->value != NULL) {
+        if (m->bindings.table[i] != HT_NOTFOUND) {
+            jl_binding_t *b = (jl_binding_t*)m->bindings.table[i];
+            if (b->owner == m && b->value && b->constp) {
                 jl_value_t *v = b->value;
-                if (jl_is_gf(v)) {
-                    jl_compile_all_defs((jl_function_t*)v);
+                if (jl_is_datatype(v)) {
+                    jl_typename_t *tn = ((jl_datatype_t*)v)->name;
+                    if (tn->module == m && tn->name == b->name) {
+                        _compile_all_enq_mt(tn->mt, found);
+                    }
                 }
                 else if (jl_is_module(v)) {
-                    if (!ptrhash_has(h, v)) {
-                        _compile_all((jl_module_t*)v, h);
+                    jl_module_t *child = (jl_module_t*)b->value;
+                    if (child != m && child->parent == m && child->name == b->name) {
+                        // this is the original/primary binding for the submodule
+                        _compile_all_enq_module(child, found);
                     }
                 }
             }
         }
     }
-    free(table);
-
-    if (m->constant_table != NULL) {
-        for(i=0; i < jl_array_len(m->constant_table); i++) {
-            jl_value_t *el = jl_cellref(m->constant_table,i);
-            if (jl_is_lambda_info(el)) {
-                jl_lambda_info_t *li = (jl_lambda_info_t*)el;
-                jl_function_t *func = li->unspecialized;
-                if (func == NULL) {
-                    func = jl_new_closure(li->fptr, (jl_value_t*)jl_emptysvec, li);
-                    li->unspecialized = func;
-                    jl_gc_wb(li, func);
-                }
-                precompile_unspecialized(func, li->specTypes ? li->specTypes : jl_anytuple_type, jl_emptysvec);
-            }
-        }
-    }
 }
 
 void jl_compile_all(void)
 {
-    htable_t h;
-    htable_new(&h, 0);
-    _compile_all(jl_main_module, &h);
+    // this "found" array will contain
+    // LambdaInfos that need to be compiled
+    // and (generic-function, method) pairs that may be optimized (and need to be compiled)
+    jl_array_t *m = jl_alloc_cell_1d(0);
+    JL_GC_PUSH1(&m);
+    while (1) {
+        _compile_all_enq_module(jl_main_module, m);
+        size_t changes = jl_array_len(m);
+        if (!changes)
+            break;
+        _compile_all_deq(m);
+        jl_array_del_end(m, changes);
+    }
+    JL_GC_POP();
 }
 
-DLLEXPORT void jl_compile_hint(jl_function_t *f, jl_tupletype_t *types)
+JL_DLLEXPORT void jl_compile_hint(jl_tupletype_t *types)
 {
-    (void)jl_get_specialization(f, types);
+    (void)jl_get_specialization1(types, NULL);
 }
 
 #ifdef JL_TRACE
@@ -1630,7 +1792,7 @@ static int error_en = 1;
 static void __attribute__ ((unused)) enable_trace(int x) { trace_en=x; }
 static void show_call(jl_value_t *F, jl_value_t **args, uint32_t nargs)
 {
-    jl_printf(JL_STDOUT, "%s(",  jl_gf_name(F)->name);
+    jl_printf(JL_STDOUT, "%s(",  jl_symbol_name(jl_gf_name(F)));
     for(size_t i=0; i < nargs; i++) {
         if (i > 0) jl_printf(JL_STDOUT, ", ");
         jl_static_show(JL_STDOUT, jl_typeof(args[i]));
@@ -1639,9 +1801,15 @@ static void show_call(jl_value_t *F, jl_value_t **args, uint32_t nargs)
 }
 #endif
 
-JL_CALLABLE(jl_apply_generic)
+static jl_value_t *verify_type(jl_value_t *v)
 {
-    assert(jl_is_gf(F));
+    assert(jl_typeof(jl_typeof(v)));
+    return v;
+}
+
+JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs)
+{
+    jl_value_t *F = args[0];
     jl_methtable_t *mt = jl_gf_mtable(F);
 #ifdef JL_GF_PROFILE
     mt->ncalls++;
@@ -1649,7 +1817,7 @@ JL_CALLABLE(jl_apply_generic)
 #ifdef JL_TRACE
     int traceen = trace_en; //&& ((char*)&mt < jl_stack_hi-6000000);
     if (traceen)
-        show_call(F, args, nargs);
+        show_call(F, &args[1], nargs-1);
 #endif
     /*
       search order:
@@ -1660,28 +1828,20 @@ JL_CALLABLE(jl_apply_generic)
       if no generic match, use the concrete one even if inexact
       otherwise instantiate the generic method and use it
     */
-    jl_function_t *mfunc = jl_method_table_assoc_exact(mt, args, nargs);
+    jl_lambda_info_t *mfunc = jl_method_table_assoc_exact(mt, args, nargs);
 
-    if (mfunc != jl_bottom_func) {
+    if (mfunc != NULL) {
 #ifdef JL_TRACE
         if (traceen)
-            jl_printf(JL_STDOUT, " at %s:%d\n", mfunc->linfo->file->name, mfunc->linfo->line);
+            jl_printf(JL_STDOUT, " at %s:%d\n", jl_symbol_name(mfunc->file), mfunc->line);
 #endif
-        if (mfunc->linfo != NULL &&
-            (mfunc->linfo->inInference || mfunc->linfo->inCompile)) {
+        if (mfunc->inInference || mfunc->inCompile) {
             // if inference is running on this function, return a copy
             // of the function to be compiled without inference and run.
-            jl_lambda_info_t *li = mfunc->linfo;
-            if (li->unspecialized == NULL) {
-                li->unspecialized = jl_instantiate_method(mfunc, li->sparams);
-                if (mfunc->env != (jl_value_t*)jl_emptysvec)
-                    li->unspecialized->env = NULL;
-                jl_gc_wb(li, li->unspecialized);
-            }
-            return jl_apply_unspecialized(mfunc, args, nargs);
+            return verify_type(jl_call_unspecialized(mfunc->sparam_vals, jl_get_unspecialized(mfunc), args, nargs));
         }
-        assert(!mfunc->linfo || !mfunc->linfo->inInference);
-        return jl_apply(mfunc, args, nargs);
+        assert(!mfunc->inInference);
+        return verify_type(jl_call_method_internal(mfunc, args, nargs));
     }
 
     // cache miss case
@@ -1691,7 +1851,7 @@ JL_CALLABLE(jl_apply_generic)
     JL_GC_PUSH2(&tt, &mfunc);
     mfunc = jl_mt_assoc_by_type(mt, tt, 1, 0);
 
-    if (mfunc == jl_bottom_func) {
+    if (mfunc == NULL) {
 #ifdef JL_TRACE
         if (error_en)
             show_call(F, args, nargs);
@@ -1702,26 +1862,25 @@ JL_CALLABLE(jl_apply_generic)
     }
 #ifdef JL_TRACE
     if (traceen)
-        jl_printf(JL_STDOUT, " at %s:%d\n", mfunc->linfo->file->name, mfunc->linfo->line);
+        jl_printf(JL_STDOUT, " at %s:%d\n", jl_symbol_name(mfunc->file), mfunc->line);
 #endif
-    assert(!mfunc->linfo || !mfunc->linfo->inInference);
-    jl_value_t *res = jl_apply(mfunc, args, nargs);
+    assert(!mfunc->inInference);
+    jl_value_t *res = jl_call_method_internal(mfunc, args, nargs);
     JL_GC_POP();
-    return res;
+    return verify_type(res);
 }
 
-DLLEXPORT jl_value_t *jl_gf_invoke_lookup(jl_function_t *gf, jl_datatype_t *types)
+JL_DLLEXPORT jl_value_t *jl_gf_invoke_lookup(jl_datatype_t *types)
 {
-    assert(jl_is_gf(gf));
-    jl_methtable_t *mt = jl_gf_mtable(gf);
+    jl_methtable_t *mt = ((jl_datatype_t*)jl_tparam0(types))->name->mt;
     jl_methlist_t *m = mt->defs;
     size_t typelen = jl_nparams(types);
-    jl_value_t *env = (jl_value_t*)jl_false;
 
     while (m != (void*)jl_nothing) {
         if (m->tvars!=jl_emptysvec) {
-            env = jl_type_match((jl_value_t*)types, (jl_value_t*)m->sig);
-            if (env != (jl_value_t*)jl_false) break;
+            if (jl_type_match((jl_value_t*)types,
+                              (jl_value_t*)m->sig) != (jl_value_t*)jl_false)
+                break;
         }
         else if (jl_tuple_subtype(jl_svec_data(types->parameters), typelen, m->sig, 0)) {
             break;
@@ -1743,130 +1902,146 @@ DLLEXPORT jl_value_t *jl_gf_invoke_lookup(jl_function_t *gf, jl_datatype_t *type
 // every definition has its own private method table for this purpose.
 //
 // NOTE: assumes argument type is a subtype of the lookup type.
-jl_value_t *jl_gf_invoke(jl_function_t *gf, jl_tupletype_t *types,
-                         jl_value_t **args, size_t nargs)
+jl_value_t *jl_gf_invoke(jl_tupletype_t *types0, jl_value_t **args, size_t nargs)
 {
-    assert(jl_is_gf(gf));
+    jl_svec_t *tpenv=jl_emptysvec;
+    jl_tupletype_t *newsig=NULL;
+    jl_tupletype_t *tt=NULL;
+    jl_tupletype_t *types=NULL;
+    JL_GC_PUSH4(&types, &tpenv, &newsig, &tt);
+    jl_value_t *gf = args[0];
+    types = (jl_datatype_t*)jl_argtype_with_function(gf, (jl_tupletype_t*)types0);
     jl_methtable_t *mt = jl_gf_mtable(gf);
-    jl_methlist_t *m = (jl_methlist_t*)jl_gf_invoke_lookup(gf, types);
-    size_t i;
+    jl_methlist_t *m = (jl_methlist_t*)jl_gf_invoke_lookup(types);
 
     if ((jl_value_t*)m == jl_nothing) {
-        jl_no_method_error_bare(gf, (jl_value_t*)types);
+        jl_no_method_error_bare(gf, (jl_value_t*)types0);
         // unreachable
     }
 
     // now we have found the matching definition.
     // next look for or create a specialization of this definition.
 
-    jl_function_t *mfunc;
+    jl_lambda_info_t *mfunc;
     if (m->invokes == (void*)jl_nothing)
-        mfunc = jl_bottom_func;
+        mfunc = NULL;
     else
         mfunc = jl_method_table_assoc_exact(m->invokes, args, nargs);
-    if (mfunc != jl_bottom_func) {
-        if (mfunc->linfo != NULL &&
-            (mfunc->linfo->inInference || mfunc->linfo->inCompile)) {
+    if (mfunc != NULL) {
+        if (mfunc->inInference || mfunc->inCompile) {
             // if inference is running on this function, return a copy
             // of the function to be compiled without inference and run.
-            jl_lambda_info_t *li = mfunc->linfo;
-            if (li->unspecialized == NULL) {
-                li->unspecialized = jl_instantiate_method(mfunc, li->sparams);
-                if (mfunc->env != (jl_value_t*)jl_emptysvec)
-                    li->unspecialized->env = NULL;
-                jl_gc_wb(li, li->unspecialized);
-            }
-            return jl_apply_unspecialized(mfunc, args, nargs);
+            JL_GC_POP();
+            return jl_call_unspecialized(mfunc->sparam_vals, jl_get_unspecialized(mfunc), args, nargs);
         }
     }
     else {
-        jl_svec_t *tpenv=jl_emptysvec;
-        jl_tupletype_t *newsig=NULL;
-        jl_tupletype_t *tt=NULL;
-        JL_GC_PUSH3(&tpenv, &newsig, &tt);
         tt = arg_type_tuple(args, nargs);
         if (m->invokes == (void*)jl_nothing) {
-            m->invokes = new_method_table(mt->name, mt->module);
+            m->invokes = jl_new_method_table(mt->name, mt->module);
             jl_gc_wb(m, m->invokes);
             update_max_args(m->invokes, tt);
             // this private method table has just this one definition
-            jl_method_list_insert(&m->invokes->defs,m->sig,m->func,m->tvars,0,0,(jl_value_t*)m->invokes);
+            jl_method_list_insert(&m->invokes->defs,m->sig,m->func,m->tvars,0,m->isstaged,(jl_value_t*)m->invokes);
         }
 
-        newsig = m->sig;
-
         if (m->tvars != jl_emptysvec) {
             jl_value_t *ti =
                 lookup_match((jl_value_t*)tt, (jl_value_t*)m->sig, &tpenv, m->tvars);
             assert(ti != (jl_value_t*)jl_bottom_type);
             (void)ti;
-            // don't bother computing this if no arguments are tuples
-            for(i=0; i < jl_nparams(tt); i++) {
-                if (jl_is_tuple_type(jl_tparam(tt,i)))
-                    break;
-            }
-            if (i < jl_nparams(tt)) {
-                newsig = (jl_tupletype_t*)jl_instantiate_type_with((jl_value_t*)m->sig,
-                                                                   jl_svec_data(tpenv),
-                                                                   jl_svec_len(tpenv)/2);
-            }
         }
-        mfunc = cache_method(m->invokes, tt, m->func, newsig, tpenv, m->isstaged);
-        JL_GC_POP();
+        jl_lambda_info_t *func = m->func;
+        if (m->isstaged)
+            func = jl_instantiate_staged(func, tt, tpenv);
+
+        mfunc = cache_method(m->invokes, tt, func, m, tpenv);
     }
 
-    return jl_apply(mfunc, args, nargs);
+    JL_GC_POP();
+    return jl_call_method_internal(mfunc, args, nargs);
 }
 
 void print_func_loc(JL_STREAM *s, jl_lambda_info_t *li)
 {
     long lno = li->line;
     if (lno > 0) {
-        char *fname = ((jl_sym_t*)li->file)->name;
+        char *fname = jl_symbol_name((jl_sym_t*)li->file);
         jl_printf(s, " at %s:%ld", fname, lno);
     }
 }
 
-jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module)
+JL_DLLEXPORT jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_t *module, jl_datatype_t *st, int iskw)
 {
-    jl_function_t *f = jl_new_closure(jl_apply_generic, NULL, NULL);
-    JL_GC_PUSH1(&f);
-    f->fptr = jl_apply_generic;
-    f->env = (jl_value_t*)new_method_table(name, module);
-    jl_gc_wb(f, f->env);
+    // type name is function name prefixed with #
+    size_t l = strlen(jl_symbol_name(name));
+    char *prefixed;
+    if (iskw) {
+        prefixed = (char*)malloc(l+5);
+        strcpy(&prefixed[0], "#kw#");
+        strcpy(&prefixed[4], jl_symbol_name(name));
+    }
+    else {
+        prefixed = (char*)malloc(l+2);
+        prefixed[0] = '#';
+        strcpy(&prefixed[1], jl_symbol_name(name));
+    }
+    jl_sym_t *tname = jl_symbol(prefixed);
+    free(prefixed);
+    jl_datatype_t *ftype = jl_new_datatype(tname, st, jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 0, 0);
+    JL_GC_PUSH1(&ftype);
+    ftype->name->mt->name = name; jl_gc_wb(ftype->name->mt, name);
+    ftype->name->module = module; jl_gc_wb(ftype->name, module);
+    ftype->name->mt->module = module; jl_gc_wb(ftype->name->mt, module);
+    jl_set_const(module, tname, (jl_value_t*)ftype);
+    jl_value_t *f = jl_new_struct(ftype);
+    ftype->instance = f; jl_gc_wb(ftype, f);
     JL_GC_POP();
-    return f;
+    return (jl_function_t*)f;
 }
 
-DLLEXPORT jl_function_t *jl_new_gf_internal(jl_value_t *env)
+JL_DLLEXPORT jl_function_t *jl_get_kwsorter(jl_typename_t *tn)
 {
-    return jl_new_closure(jl_apply_generic, env, NULL);
+    jl_methtable_t *mt = tn->mt;
+    if (!mt->kwsorter) {
+        mt->kwsorter = jl_new_generic_function_with_supertype(tn->name, mt->module, jl_function_type, 1);
+        jl_gc_wb(mt, mt->kwsorter);
+    }
+    return mt->kwsorter;
 }
 
-void jl_add_method(jl_function_t *gf, jl_tupletype_t *types, jl_function_t *meth,
-                   jl_svec_t *tvars, int8_t isstaged)
+JL_DLLEXPORT jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module)
+{
+    return jl_new_generic_function_with_supertype(name, module, jl_function_type, 0);
+}
+
+void jl_add_method_to_table(jl_methtable_t *mt, jl_tupletype_t *types, jl_lambda_info_t *meth,
+                            jl_svec_t *tvars, int8_t isstaged)
 {
-    assert(jl_is_function(gf));
     assert(jl_is_tuple_type(types));
-    assert(jl_is_func(meth));
-    assert(jl_is_mtable(jl_gf_mtable(gf)));
+    assert(jl_is_lambda_info(meth));
+    assert(jl_is_mtable(mt));
     JL_GC_PUSH1(&meth);
-    if (meth->linfo != NULL) {
-        jl_sym_t *n = jl_gf_name(gf);
-        if (meth->linfo->name != anonymous_sym && meth->linfo->name != n) {
-            // already used by another GF; make a copy (issue #10373)
-            meth = jl_instantiate_method(meth, jl_emptysvec);
-        }
-        meth->linfo->name = n;
-    }
-    if (isstaged && tvars != jl_emptysvec) {
-        all_p2c((jl_value_t*)meth->linfo, tvars);
-    }
-    (void)jl_method_table_insert(jl_gf_mtable(gf), types, meth, tvars, isstaged);
+    jl_sym_t *n = mt->name;
+    if (meth->name != anonymous_sym && meth->name != n) {
+        // already used by another GF; make a copy (issue #10373)
+        assert(meth->sparam_vals == jl_emptysvec);
+        meth = jl_add_static_parameters(meth, jl_emptysvec, NULL);
+        meth->unspecialized = NULL;
+    }
+    meth->name = n;
+    (void)jl_method_table_insert(mt, types, meth, tvars, isstaged);
     JL_GC_POP();
 }
 
-DLLEXPORT jl_svec_t *jl_match_method(jl_value_t *type, jl_value_t *sig, jl_svec_t *tvars)
+void jl_add_method(jl_function_t *gf, jl_tupletype_t *types, jl_lambda_info_t *meth,
+                   jl_svec_t *tvars, int8_t isstaged)
+{
+    jl_add_method_to_table(jl_gf_mtable(gf), types, meth, tvars, isstaged);
+}
+
+JL_DLLEXPORT jl_svec_t *jl_match_method(jl_value_t *type, jl_value_t *sig,
+                                        jl_svec_t *tvars)
 {
     jl_svec_t *env = jl_emptysvec;
     jl_value_t *ti=NULL;
@@ -1921,7 +2096,7 @@ static jl_value_t *ml_matches(jl_methlist_t *ml, jl_value_t *type,
         env = jl_emptysvec;
         ti = lookup_match(type, (jl_value_t*)ml->sig, &env, ml->tvars);
         if (ti != (jl_value_t*)jl_bottom_type) {
-            assert(ml->func->linfo);  // no builtin methods
+            assert(ml->func);
             assert(jl_is_svec(env));
 
             int skip = 0;
@@ -1970,11 +2145,16 @@ static jl_value_t *ml_matches(jl_methlist_t *ml, jl_value_t *type,
                 */
                 int matched_all_typevars = 1;
                 size_t l = jl_svec_len(env);
-                for(i=1; i < l; i+=2) {
+                for(i=0; i < l; i++) {
+                    jl_value_t *tv;
+                    if (jl_is_typevar(ml->tvars))
+                        tv = (jl_value_t*)ml->tvars;
+                    else
+                        tv = jl_svecref(ml->tvars, i);
                     if (jl_is_typevar(jl_svecref(env,i)) &&
                         // if tvar is at the top level it will definitely be matched.
                         // see issue #5575
-                        !tvar_exists_at_top_level(jl_svecref(env,i-1), ml->sig, 1)) {
+                        !tvar_exists_at_top_level(tv, ml->sig, 1)) {
                         matched_all_typevars = 0;
                         break;
                     }
@@ -2005,20 +2185,21 @@ static jl_value_t *ml_matches(jl_methlist_t *ml, jl_value_t *type,
 // return a cell array of svecs, each describing a method match:
 // {svec(t, spvals, li, cenv), ...}
 // t is the intersection of the type argument and the method signature,
-// spvals is any matched static parameter values, li is the LambdaStaticData,
+// spvals is any matched static parameter values, li is the LambdaInfo,
 // and cenv is the closure environment or ().
 //
 // lim is the max # of methods to return. if there are more return jl_false.
 // -1 for no limit.
-DLLEXPORT
-jl_value_t *jl_matching_methods(jl_function_t *gf, jl_value_t *type, int lim)
+JL_DLLEXPORT jl_value_t *jl_matching_methods(jl_value_t *types, int lim)
 {
-    assert(jl_is_func(gf));
-    if (!jl_is_gf(gf)) {
-        return (jl_value_t*)jl_an_empty_cell;
-    }
-    jl_methtable_t *mt = jl_gf_mtable(gf);
-    return ml_matches(mt->defs, type, jl_gf_name(gf), lim);
+    assert(jl_nparams(types) > 0);
+    if (jl_tparam0(types) == jl_bottom_type)
+        return (jl_value_t*)jl_alloc_cell_1d(0);
+    assert(jl_is_datatype(jl_tparam0(types)));
+    jl_methtable_t *mt = ((jl_datatype_t*)jl_tparam0(types))->name->mt;
+    if (mt == NULL)
+        return (jl_value_t*)jl_alloc_cell_1d(0);
+    return ml_matches(mt->defs, types, mt->name, lim);
 }
 
 #ifdef __cplusplus
diff --git a/src/init.c b/src/init.c
index 5debfbbe0176b..ffff1b1962cbc 100644
--- a/src/init.c
+++ b/src/init.c
@@ -20,13 +20,17 @@
 
 #include "julia.h"
 #include "julia_internal.h"
+#define DEFINE_BUILTIN_GLOBALS
+#include "builtin_proto.h"
+#undef DEFINE_BUILTIN_GLOBALS
+#include "threading.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifdef _MSC_VER
-DLLEXPORT char * dirname(char *);
+JL_DLLEXPORT char *dirname(char *);
 #else
 #include <libgen.h>
 #endif
@@ -63,7 +67,7 @@ jl_options_t jl_options = { 0,    // quiet
                             JL_OPTIONS_COMPILE_DEFAULT, // compile_enabled
                             0,    // code_coverage
                             0,    // malloc_log
-                            0,    // opt_level
+                            2,    // opt_level
                             JL_OPTIONS_CHECK_BOUNDS_DEFAULT, // check_bounds
                             1,    // depwarn
                             1,    // can_inline
@@ -76,6 +80,7 @@ jl_options_t jl_options = { 0,    // quiet
 #else
                             JL_OPTIONS_USE_PRECOMPILED_YES,
 #endif
+                            JL_OPTIONS_USE_COMPILECACHE_YES,
                             NULL, // bindto
                             NULL, // outputbc
                             NULL, // outputo
@@ -84,19 +89,88 @@ jl_options_t jl_options = { 0,    // quiet
 };
 
 int jl_boot_file_loaded = 0;
-char *jl_stack_lo;
-char *jl_stack_hi;
 size_t jl_page_size;
 
+void jl_init_stack_limits(int ismaster)
+{
+#ifdef _OS_WINDOWS_
+    (void)ismaster;
+#  ifdef _COMPILER_MICROSOFT_
+#    ifdef _P64
+    void **tib = (void**)__readgsqword(0x30);
+#    else
+    void **tib = (void**)__readfsdword(0x18);
+#    endif
+#  else
+    void **tib;
+#    ifdef _P64
+    __asm__("movq %%gs:0x30, %0" : "=r" (tib) : : );
+#    else
+    __asm__("movl %%fs:0x18, %0" : "=r" (tib) : : );
+#    endif
+#  endif
+    // https://en.wikipedia.org/wiki/Win32_Thread_Information_Block
+    jl_stack_hi = (char*)tib[1]; // Stack Base / Bottom of stack (high address)
+    jl_stack_lo = (char*)tib[2]; // Stack Limit / Ceiling of stack (low address)
+#else
+#  ifdef JULIA_ENABLE_THREADING
+    // Only use pthread_*_np functions to get stack address for non-master
+    // threads since it seems to return bogus values for master thread on Linux
+    // and possibly OSX.
+    if (!ismaster) {
+#    if defined(_OS_LINUX_)
+        pthread_attr_t attr;
+        pthread_getattr_np(pthread_self(), &attr);
+        void *stackaddr;
+        size_t stacksize;
+        pthread_attr_getstack(&attr, &stackaddr, &stacksize);
+        pthread_attr_destroy(&attr);
+        jl_stack_lo = (char*)stackaddr;
+        jl_stack_hi = (char*)stackaddr + stacksize;
+        return;
+#    elif defined(_OS_DARWIN_)
+        extern void *pthread_get_stackaddr_np(pthread_t thread);
+        extern size_t pthread_get_stacksize_np(pthread_t thread);
+        pthread_t thread = pthread_self();
+        void *stackaddr = pthread_get_stackaddr_np(thread);
+        size_t stacksize = pthread_get_stacksize_np(thread);
+        jl_stack_lo = (char*)stackaddr;
+        jl_stack_hi = (char*)stackaddr + stacksize;
+        return;
+#    elif defined(_OS_FREEBSD_)
+        pthread_attr_t attr;
+        pthread_attr_init(&attr);
+        pthread_attr_get_np(pthread_self(), &attr);
+        void *stackaddr;
+        size_t stacksize;
+        pthread_attr_getstack(&attr, &stackaddr, &stacksize);
+        pthread_attr_destroy(&attr);
+        jl_stack_lo = (char*)stackaddr;
+        jl_stack_hi = (char*)stackaddr + stacksize;
+        return;
+#    else
+#      warning "Getting stack size for thread is not supported."
+#    endif
+    }
+#  else
+    (void)ismaster;
+#  endif
+    struct rlimit rl;
+    getrlimit(RLIMIT_STACK, &rl);
+    size_t stack_size = rl.rlim_cur;
+    jl_stack_hi = (char*)&stack_size;
+    jl_stack_lo = jl_stack_hi - stack_size;
+#endif
+}
+
 static void jl_find_stack_bottom(void)
 {
-    size_t stack_size;
-#ifndef _OS_WINDOWS_
+#if !defined(_OS_WINDOWS_) && defined(__has_feature)
+#if __has_feature(memory_sanitizer) || __has_feature(address_sanitizer)
     struct rlimit rl;
 
-    // When using memory sanitizer, increase stack size because msan bloats stack usage
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
+    // When using the sanitizers, increase stack size because they bloat
+    // stack usage
     const rlim_t kStackSize = 32 * 1024 * 1024;   // 32MB stack
     int result;
 
@@ -112,14 +186,7 @@ static void jl_find_stack_bottom(void)
     }
 #endif
 #endif
-
-    getrlimit(RLIMIT_STACK, &rl);
-    stack_size = rl.rlim_cur;
-#else
-    stack_size = 262144;  // guess
-#endif
-    jl_stack_hi = (char*)&stack_size;
-    jl_stack_lo = jl_stack_hi - stack_size;
+    jl_init_stack_limits(1);
 }
 
 struct uv_shutdown_queue_item { uv_handle_t *h; struct uv_shutdown_queue_item *next; };
@@ -152,7 +219,7 @@ static struct uv_shutdown_queue_item *next_shutdown_queue_item(struct uv_shutdow
     return rv;
 }
 
-DLLEXPORT void jl_atexit_hook(int exitcode)
+JL_DLLEXPORT void jl_atexit_hook(int exitcode)
 {
     if (exitcode == 0) julia_save();
     jl_print_gc_stats(JL_STDERR);
@@ -162,9 +229,9 @@ DLLEXPORT void jl_atexit_hook(int exitcode)
         jl_write_malloc_log();
     if (jl_base_module) {
         jl_value_t *f = jl_get_global(jl_base_module, jl_symbol("_atexit"));
-        if (f!=NULL && jl_is_function(f)) {
+        if (f != NULL) {
             JL_TRY {
-                jl_apply((jl_function_t*)f, NULL, 0);
+                jl_apply(&f, 1);
             }
             JL_CATCH {
                 jl_printf(JL_STDERR, "\natexit hook threw an error: ");
@@ -247,27 +314,21 @@ DLLEXPORT void jl_atexit_hook(int exitcode)
 }
 
 void jl_get_builtin_hooks(void);
+void jl_get_builtins(void);
 
-DLLEXPORT uv_lib_t *jl_dl_handle;
-uv_lib_t _jl_RTLD_DEFAULT_handle;
-uv_lib_t *jl_RTLD_DEFAULT_handle=&_jl_RTLD_DEFAULT_handle;
+JL_DLLEXPORT void *jl_dl_handle;
+void *jl_RTLD_DEFAULT_handle;
 #ifdef _OS_WINDOWS_
-uv_lib_t _jl_ntdll_handle;
-uv_lib_t _jl_exe_handle;
-uv_lib_t _jl_kernel32_handle;
-uv_lib_t _jl_crtdll_handle;
-uv_lib_t _jl_winsock_handle;
-
-DLLEXPORT uv_lib_t *jl_exe_handle=&_jl_exe_handle;
-uv_lib_t *jl_ntdll_handle=&_jl_ntdll_handle;
-uv_lib_t *jl_kernel32_handle=&_jl_kernel32_handle;
-uv_lib_t *jl_crtdll_handle=&_jl_crtdll_handle;
-uv_lib_t *jl_winsock_handle=&_jl_winsock_handle;
+JL_DLLEXPORT void *jl_exe_handle;
+void *jl_ntdll_handle;
+void *jl_kernel32_handle;
+void *jl_crtdll_handle;
+void *jl_winsock_handle;
 #endif
 
 uv_loop_t *jl_io_loop;
 
-void *init_stdio_handle(uv_file fd,int readable)
+static void *init_stdio_handle(uv_file fd,int readable)
 {
     void *handle;
     uv_handle_type type = uv_guess_handle(fd);
@@ -333,7 +394,7 @@ void *init_stdio_handle(uv_file fd,int readable)
     return handle;
 }
 
-void init_stdio()
+void init_stdio(void)
 {   //order must be 2,1,0
     JL_STDERR = (uv_stream_t*)init_stdio_handle(STDERR_FILENO,0);
     JL_STDOUT = (uv_stream_t*)init_stdio_handle(STDOUT_FILENO,0);
@@ -346,6 +407,10 @@ void init_stdio()
 char jl_using_intel_jitevents; // Non-zero if running under Intel VTune Amplifier
 #endif
 
+#ifdef JL_USE_OPROFILE_JITEVENTS
+char jl_using_oprofile_jitevents = 0; // Non-zero if running under OProfile
+#endif
+
 int isabspath(const char *in)
 {
 #ifdef _OS_WINDOWS_
@@ -464,6 +529,11 @@ static void jl_resolve_sysimg_location(JL_IMAGE_SEARCH rel)
 
 void _julia_init(JL_IMAGE_SEARCH rel)
 {
+#ifdef JULIA_ENABLE_THREADING
+    // Make sure we finalize the tls callback before starting any threads.
+    jl_get_ptls_states_getter();
+    jl_gc_signal_init();
+#endif
     libsupport_init();
     jl_io_loop = uv_default_loop(); // this loop will internal events (spawning process etc.),
                                     // best to call this first, since it also initializes libuv
@@ -481,36 +551,30 @@ void _julia_init(JL_IMAGE_SEARCH rel)
     }
     jl_arr_xtralloc_limit = total_mem / 100;  // Extra allocation limited to 1% of total RAM
     jl_find_stack_bottom();
-    jl_dl_handle = (uv_lib_t *) jl_load_dynamic_library(NULL, JL_RTLD_DEFAULT);
+    jl_dl_handle = jl_load_dynamic_library(NULL, JL_RTLD_DEFAULT);
 #ifdef RTLD_DEFAULT
-    jl_RTLD_DEFAULT_handle->handle = RTLD_DEFAULT;
+    jl_RTLD_DEFAULT_handle = RTLD_DEFAULT;
 #else
-    jl_RTLD_DEFAULT_handle->handle = jl_dl_handle->handle;
+    jl_RTLD_DEFAULT_handle = jl_dl_handle;
 #endif
 #ifdef _OS_WINDOWS_
-    uv_dlopen("ntdll.dll", jl_ntdll_handle); // bypass julia's pathchecking for system dlls
-    uv_dlopen("kernel32.dll", jl_kernel32_handle);
-#if _MSC_VER == 1800
-    uv_dlopen("msvcr120.dll", jl_crtdll_handle);
+    jl_ntdll_handle = jl_dlopen("ntdll.dll", 0); // bypass julia's pathchecking for system dlls
+    jl_kernel32_handle = jl_dlopen("kernel32.dll", 0);
+#if defined(_MSC_VER) && _MSC_VER == 1800
+    jl_crtdll_handle = jl_dlopen("msvcr120.dll", 0);
 #else
-    uv_dlopen("msvcrt.dll", jl_crtdll_handle);
+    jl_crtdll_handle = jl_dlopen("msvcrt.dll", 0);
 #endif
-    uv_dlopen("ws2_32.dll", jl_winsock_handle);
-    _jl_exe_handle.handle = GetModuleHandleA(NULL);
-    if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
-                         GetCurrentProcess(), (PHANDLE)&hMainThread, 0,
-                         TRUE, DUPLICATE_SAME_ACCESS)) {
-        jl_printf(JL_STDERR, "WARNING: failed to access handle to main thread\n");
-    }
+    jl_winsock_handle = jl_dlopen("ws2_32.dll", 0);
+    jl_exe_handle = GetModuleHandleA(NULL);
     SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES);
     if (!SymInitialize(GetCurrentProcess(), NULL, 1)) {
         jl_printf(JL_STDERR, "WARNING: failed to initialize stack walk info\n");
     }
     needsSymRefreshModuleList = 0;
-    uv_lib_t jl_dbghelp;
-    uv_dlopen("dbghelp.dll",&jl_dbghelp);
-    if (uv_dlsym(&jl_dbghelp, "SymRefreshModuleList", (void**)&hSymRefreshModuleList))
-        hSymRefreshModuleList = 0;
+    HMODULE jl_dbghelp = (HMODULE) jl_dlopen("dbghelp.dll", 0);
+    if (jl_dbghelp)
+        hSymRefreshModuleList = (BOOL (WINAPI*)(HANDLE)) jl_dlsym(jl_dbghelp, "SymRefreshModuleList");
 #endif
 
 #if defined(JL_USE_INTEL_JITEVENTS)
@@ -520,6 +584,28 @@ void _julia_init(JL_IMAGE_SEARCH rel)
     }
 #endif
 
+#if defined(JL_USE_OPROFILE_JITEVENTS)
+    const char *jit_profiling = getenv("ENABLE_JITPROFILING");
+    if (jit_profiling && atoi(jit_profiling)) {
+        jl_using_oprofile_jitevents = 1;
+    }
+#endif
+
+
+#if defined(__linux__)
+    int ncores = jl_cpu_cores();
+    if (ncores > 1) {
+        cpu_set_t cpumask;
+        CPU_ZERO(&cpumask);
+        for(int i=0; i < ncores; i++) {
+            CPU_SET(i, &cpumask);
+        }
+        sched_setaffinity(0, sizeof(cpu_set_t), &cpumask);
+    }
+#endif
+
+    jl_init_threading();
+
     jl_gc_init();
     jl_gc_enable(0);
     jl_init_frontend();
@@ -531,20 +617,29 @@ void _julia_init(JL_IMAGE_SEARCH rel)
     // libuv stdio cleanup depends on jl_init_tasks() because JL_TRY is used in jl_atexit_hook()
 
     jl_init_codegen();
+
+    jl_start_threads();
+
     jl_an_empty_cell = (jl_value_t*)jl_alloc_cell_1d(0);
     jl_init_serializer();
 
     if (!jl_options.image_file) {
         jl_core_module = jl_new_module(jl_symbol("Core"));
+        jl_type_type->name->mt->module = jl_core_module;
         jl_top_module = jl_core_module;
+        jl_current_module = jl_core_module;
         jl_init_intrinsic_functions();
         jl_init_primitives();
+        jl_get_builtins();
 
         jl_new_main_module();
         jl_internal_main_module = jl_main_module;
 
         jl_current_module = jl_core_module;
-        jl_root_task->current_module = jl_current_module;
+        for (int t = 0;t < jl_n_threads;t++) {
+            jl_all_task_states[t].ptls->root_task->current_module =
+                jl_current_module;
+        }
 
         jl_load("boot.jl", sizeof("boot.jl"));
         jl_get_builtin_hooks();
@@ -573,6 +668,8 @@ void _julia_init(JL_IMAGE_SEARCH rel)
             if (b->value && jl_is_datatype(b->value)) {
                 jl_datatype_t *tt = (jl_datatype_t*)b->value;
                 tt->name->module = jl_core_module;
+                if (tt->name->mt)
+                    tt->name->mt->module = jl_core_module;
             }
         }
     }
@@ -583,17 +680,19 @@ void _julia_init(JL_IMAGE_SEARCH rel)
     if (jl_base_module != NULL) {
         jl_add_standard_imports(jl_main_module);
     }
-    // eval() uses Main by default, so Main.eval === Core.eval
-    jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
     jl_current_module = jl_main_module;
-    jl_root_task->current_module = jl_current_module;
+    for(int t = 0;t < jl_n_threads;t++) {
+        jl_all_task_states[t].ptls->root_task->current_module =
+            jl_current_module;
+    }
 
+    // This needs to be after jl_start_threads
     if (jl_options.handle_signals == JL_OPTIONS_HANDLE_SIGNALS_ON)
         jl_install_default_signal_handlers();
 
     jl_gc_enable(1);
 
-    if (jl_options.image_file) {
+    if (jl_options.image_file && (!jl_generating_output() || jl_options.incremental)) {
         jl_array_t *temp = jl_module_init_order;
         JL_GC_PUSH1(&temp);
         jl_module_init_order = NULL;
@@ -607,24 +706,38 @@ void _julia_init(JL_IMAGE_SEARCH rel)
 
 extern int asprintf(char **str, const char *fmt, ...);
 
-DLLEXPORT int jl_generating_output()
+JL_DLLEXPORT int jl_generating_output(void)
 {
     return jl_options.outputo || jl_options.outputbc || jl_options.outputji;
 }
 
 void jl_compile_all(void);
 
-static void julia_save()
+static void julia_save(void)
 {
+    if (!jl_generating_output())
+        return;
+
     if (jl_options.compile_enabled == JL_OPTIONS_COMPILE_ALL)
         jl_compile_all();
 
-    if (jl_options.incremental) {
-        jl_array_t *worklist = jl_module_init_order;
-        if (!worklist) {
-            jl_printf(JL_STDERR, "WARNING: incremental output requested, but no modules defined during run\n");
-            return;
+    if (!jl_module_init_order) {
+        jl_printf(JL_STDERR, "WARNING: --output requested, but no modules defined during run\n");
+        return;
+    }
+
+    jl_array_t *worklist = jl_module_init_order;
+    JL_GC_PUSH1(&worklist);
+    jl_module_init_order = jl_alloc_cell_1d(0);
+    int i, l = jl_array_len(worklist);
+    for (i = 0; i < l; i++) {
+        jl_value_t *m = jl_arrayref(worklist, i);
+        if (jl_module_get_initializer((jl_module_t*)m)) {
+            jl_cell_1d_push(jl_module_init_order, m);
         }
+    }
+
+    if (jl_options.incremental) {
         if (jl_options.outputji)
             if (jl_save_incremental(jl_options.outputji, worklist))
                 jl_exit(1);
@@ -646,25 +759,24 @@ static void julia_save()
                 ios_t f;
                 if (ios_file(&f, jl_options.outputji, 1, 1, 1, 1) == NULL)
                     jl_errorf("cannot open system image file \"%s\" for writing", jl_options.outputji);
-                ios_write(&f, (const char*)s->buf, s->size);
+                ios_write(&f, (const char*)s->buf, (size_t)s->size);
                 ios_close(&f);
             }
         }
 
         if (jl_options.outputbc)
-            jl_dump_bitcode((char*)jl_options.outputbc, (const char*)s->buf, s->size);
+            jl_dump_bitcode((char*)jl_options.outputbc, (const char*)s->buf, (size_t)s->size);
 
         if (jl_options.outputo)
-            jl_dump_objfile((char*)jl_options.outputo, 0, (const char*)s->buf, s->size);
+            jl_dump_objfile((char*)jl_options.outputo, 0, (const char*)s->buf, (size_t)s->size);
     }
+    JL_GC_POP();
 }
 
 jl_function_t *jl_typeinf_func=NULL;
 
-DLLEXPORT void jl_set_typeinf_func(jl_value_t* f)
+JL_DLLEXPORT void jl_set_typeinf_func(jl_value_t *f)
 {
-    if (!jl_is_function(f))
-        jl_error("jl_set_typeinf_func must set a jl_function_t*");
     jl_typeinf_func = (jl_function_t*)f;
 }
 
@@ -681,11 +793,14 @@ static jl_value_t *basemod(char *name)
 // fetch references to things defined in boot.jl
 void jl_get_builtin_hooks(void)
 {
-    jl_root_task->tls = jl_nothing;
-    jl_root_task->consumers = jl_nothing;
-    jl_root_task->donenotify = jl_nothing;
-    jl_root_task->exception = jl_nothing;
-    jl_root_task->result = jl_nothing;
+    int t;
+    for(t=0; t < jl_n_threads; t++) {
+        jl_all_task_states[t].ptls->root_task->tls = jl_nothing;
+        jl_all_task_states[t].ptls->root_task->consumers = jl_nothing;
+        jl_all_task_states[t].ptls->root_task->donenotify = jl_nothing;
+        jl_all_task_states[t].ptls->root_task->exception = jl_nothing;
+        jl_all_task_states[t].ptls->root_task->result = jl_nothing;
+    }
 
     jl_char_type    = (jl_datatype_t*)core("Char");
     jl_int8_type    = (jl_datatype_t*)core("Int8");
@@ -695,6 +810,7 @@ void jl_get_builtin_hooks(void)
     jl_uint32_type  = (jl_datatype_t*)core("UInt32");
     jl_uint64_type  = (jl_datatype_t*)core("UInt64");
 
+    jl_float16_type = (jl_datatype_t*)core("Float16");
     jl_float32_type = (jl_datatype_t*)core("Float32");
     jl_float64_type = (jl_datatype_t*)core("Float64");
     jl_floatingpoint_type = (jl_datatype_t*)core("AbstractFloat");
@@ -727,7 +843,7 @@ void jl_get_builtin_hooks(void)
                                         jl_svec2(jl_uint8_type, jl_box_long(1)));
 }
 
-DLLEXPORT void jl_get_system_hooks(void)
+JL_DLLEXPORT void jl_get_system_hooks(void)
 {
     if (jl_errorexception_type) return; // only do this once
 
@@ -739,6 +855,21 @@ DLLEXPORT void jl_get_system_hooks(void)
     jl_complex_type = (jl_datatype_t*)basemod("Complex");
 }
 
+void jl_get_builtins(void)
+{
+    jl_builtin_throw = core("throw");           jl_builtin_is = core("is");
+    jl_builtin_typeof = core("typeof");         jl_builtin_sizeof = core("sizeof");
+    jl_builtin_issubtype = core("issubtype");   jl_builtin_isa = core("isa");
+    jl_builtin_typeassert = core("typeassert"); jl_builtin__apply = core("_apply");
+    jl_builtin_isdefined = core("isdefined");   jl_builtin_nfields = core("nfields");
+    jl_builtin_tuple = core("tuple");           jl_builtin_svec = core("svec");
+    jl_builtin_getfield = core("getfield");     jl_builtin_setfield = core("setfield!");
+    jl_builtin_fieldtype = core("fieldtype");   jl_builtin_arrayref = core("arrayref");
+    jl_builtin_arrayset = core("arrayset");     jl_builtin_arraysize = core("arraysize");
+    jl_builtin_apply_type = core("apply_type"); jl_builtin_applicable = core("applicable");
+    jl_builtin_invoke = core("invoke");         jl_builtin__expr = core("_expr");
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/interpreter.c b/src/interpreter.c
index e4e12e0aa5495..1380267ede6b6 100644
--- a/src/interpreter.c
+++ b/src/interpreter.c
@@ -14,8 +14,6 @@
 extern "C" {
 #endif
 
-extern int jl_lineno;
-
 static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ngensym);
 static jl_value_t *eval_body(jl_array_t *stmts, jl_value_t **locals, size_t nl, size_t ngensym,
                              int start, int toplevel);
@@ -27,12 +25,20 @@ jl_value_t *jl_interpret_toplevel_expr(jl_value_t *e)
     return eval(e, NULL, 0, 0);
 }
 
-DLLEXPORT jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m, jl_value_t *e,
-                                                    jl_value_t **locals, size_t nl)
+JL_DLLEXPORT jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m,
+                                                       jl_value_t *e,
+                                                       jl_svec_t *local_syms,
+                                                       jl_svec_t *local_vals)
 {
     jl_value_t *v=NULL;
     jl_module_t *last_m = jl_current_module;
     jl_module_t *task_last_m = jl_current_task->current_module;
+    size_t i, nl = jl_svec_len(local_syms);
+    jl_value_t **locals = (jl_value_t**)alloca(sizeof(jl_value_t*) * 2 * nl);
+    for (i = 0; i < nl; i++) {
+        locals[2 * i] = jl_svecref(local_syms, i);
+        locals[2 * i + 1] = jl_svec_len(local_vals) > 0 ? jl_svecref(local_vals, i) : NULL;
+    }
     JL_TRY {
         jl_current_task->current_module = jl_current_module = m;
         v = eval(e, locals, nl, 0);
@@ -48,21 +54,15 @@ DLLEXPORT jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m, jl_value_t *
     return v;
 }
 
-static jl_value_t *do_call(jl_function_t *f, jl_value_t **args, size_t nargs,
-                           jl_value_t *eval0, jl_value_t **locals, size_t nl, size_t ngensym)
+static jl_value_t *do_call(jl_value_t **args, size_t nargs,
+                           jl_value_t **locals, size_t nl, size_t ngensym)
 {
     jl_value_t **argv;
-    JL_GC_PUSHARGS(argv, nargs+1);
+    JL_GC_PUSHARGS(argv, nargs);
     size_t i;
-    argv[0] = (jl_value_t*)f;
-    i = 0;
-    if (eval0) { /* 0-th argument has already been evaluated */
-        argv[1] = eval0; i++;
-    }
-    for(; i < nargs; i++) {
-        argv[i+1] = eval(args[i], locals, nl, ngensym);
-    }
-    jl_value_t *result = jl_apply(f, &argv[1], nargs);
+    for(i=0; i < nargs; i++)
+        argv[i] = eval(args[i], locals, nl, ngensym);
+    jl_value_t *result = jl_apply_generic(argv, nargs);
     JL_GC_POP();
     return result;
 }
@@ -75,10 +75,6 @@ jl_value_t *jl_eval_global_var(jl_module_t *m, jl_sym_t *e)
     return v;
 }
 
-void jl_check_static_parameter_conflicts(jl_lambda_info_t *li, jl_svec_t *t, jl_sym_t *fname);
-
-int jl_has_intrinsics(jl_expr_t *ast, jl_expr_t *e, jl_module_t *m);
-
 extern int jl_boot_file_loaded;
 extern int inside_typedef;
 
@@ -102,13 +98,31 @@ static int equiv_type(jl_datatype_t *dta, jl_datatype_t *dtb)
 static void check_can_assign_type(jl_binding_t *b)
 {
     if (b->constp && b->value != NULL && !jl_is_datatype(b->value))
-        jl_errorf("invalid redefinition of constant %s", b->name->name);
+        jl_errorf("invalid redefinition of constant %s",
+                  jl_symbol_name(b->name));
+}
+
+void jl_reinstantiate_inner_types(jl_datatype_t *t);
+
+void jl_set_datatype_super(jl_datatype_t *tt, jl_value_t *super)
+{
+    if (!jl_is_datatype(super) || !jl_is_abstracttype(super) ||
+        tt->name == ((jl_datatype_t*)super)->name ||
+        jl_subtype(super,(jl_value_t*)jl_vararg_type,0) ||
+        jl_is_tuple_type(super) ||
+        jl_subtype(super,(jl_value_t*)jl_type_type,0) ||
+        super == (jl_value_t*)jl_builtin_type) {
+        jl_errorf("invalid subtyping in definition of %s",
+                  jl_symbol_name(tt->name->name));
+    }
+    tt->super = (jl_datatype_t*)super;
+    jl_gc_wb(tt, tt->super);
 }
 
 static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ngensym)
 {
     if (jl_is_symbol(e)) {
-        jl_value_t *v;
+        jl_value_t *v = NULL;
         size_t i;
         for(i=0; i < nl; i++) {
             if (locals[i*2] == e) {
@@ -116,12 +130,10 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
                 break;
             }
         }
-        if (i >= nl) {
+        if (i >= nl)
             v = jl_get_global(jl_current_module, (jl_sym_t*)e);
-        }
-        if (v == NULL) {
+        if (v == NULL)
             jl_undefined_var_error((jl_sym_t*)e);
-        }
         return v;
     }
     if (jl_is_symbolnode(e)) {
@@ -147,15 +159,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
     if (!jl_is_expr(e)) {
         if (jl_is_globalref(e)) {
             jl_value_t *gfargs[2] = {(jl_value_t*)jl_globalref_mod(e), (jl_value_t*)jl_globalref_name(e)};
-            return jl_f_get_field(NULL, gfargs, 2);
-        }
-        if (jl_is_lambda_info(e)) {
-            jl_lambda_info_t *li = (jl_lambda_info_t*)e;
-            if (jl_boot_file_loaded && li->ast && jl_is_expr(li->ast)) {
-                li->ast = jl_compress_ast(li, li->ast);
-                jl_gc_wb(li, li->ast);
-            }
-            return (jl_value_t*)jl_new_closure(NULL, (jl_value_t*)jl_emptysvec, li);
+            return jl_f_getfield(NULL, gfargs, 2);
         }
         if (jl_is_linenode(e)) {
             jl_lineno = jl_linenode_line(e);
@@ -178,41 +182,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
     jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
     size_t nargs = jl_array_len(ex->args);
     if (ex->head == call_sym) {
-        if (jl_is_lambda_info(args[0])) {
-            // directly calling an inner function ("let")
-            jl_lambda_info_t *li = (jl_lambda_info_t*)args[0];
-            if (jl_is_expr(li->ast) && !jl_lam_vars_captured((jl_expr_t*)li->ast) &&
-                !jl_has_intrinsics((jl_expr_t*)li->ast, (jl_expr_t*)li->ast, jl_current_module)) {
-                size_t na = nargs-1;
-                if (na == 0)
-                    return jl_interpret_toplevel_thunk(li);
-                jl_array_t *formals = jl_lam_args((jl_expr_t*)li->ast);
-                size_t nreq = jl_array_len(formals);
-                if (nreq==0 || !jl_is_rest_arg(jl_cellref(formals,nreq-1))) {
-                    jl_value_t **ar;
-                    JL_GC_PUSHARGS(ar, na*2);
-                    for(int i=0; i < na; i++) {
-                        ar[i*2+1] = eval(args[i+1], locals, nl, ngensym);
-                        jl_gc_wb(ex->args, ar[i*2+1]);
-                    }
-                    if (na != nreq) {
-                        jl_error("wrong number of arguments");
-                    }
-                    for(int i=0; i < na; i++) {
-                        jl_value_t *v = jl_cellref(formals, i);
-                        ar[i*2] = (jl_is_gensym(v)) ? v : (jl_value_t*)jl_decl_var(v);
-                    }
-                    jl_value_t *ret = jl_interpret_toplevel_thunk_with(li, ar, na);
-                    JL_GC_POP();
-                    return ret;
-                }
-            }
-        }
-        jl_function_t *f = (jl_function_t*)eval(args[0], locals, nl, ngensym);
-        if (jl_is_func(f))
-            return do_call(f, &args[1], nargs-1, NULL, locals, nl, ngensym);
-        else
-            return do_call(jl_module_call_func(jl_current_module), args, nargs, (jl_value_t*)f, locals, nl, ngensym);
+        return do_call(args, nargs, locals, nl, ngensym);
     }
     else if (ex->head == assign_sym) {
         jl_value_t *sym = args[0];
@@ -245,7 +215,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
         JL_GC_POP();
         return rhs;
     }
-    else if (ex->head == new_sym) {
+    else if (ex->head == new_sym || ex->head == stknew_sym) {
         jl_value_t *thetype = eval(args[0], locals, nl, ngensym);
         jl_value_t *v=NULL;
         JL_GC_PUSH2(&thetype, &v);
@@ -271,23 +241,12 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
     }
     else if (ex->head == method_sym) {
         jl_sym_t *fname = (jl_sym_t*)args[0];
-        jl_value_t **bp=NULL;
-        jl_value_t *bp_owner=NULL;
-        jl_binding_t *b=NULL;
-        jl_value_t *gf=NULL;
-        int kw=0;
-        if (jl_is_expr(fname) || jl_is_globalref(fname)) {
-            if (jl_is_expr(fname) && ((jl_expr_t*)fname)->head == kw_sym) {
-                kw = 1;
-                fname = (jl_sym_t*)jl_exprarg(fname, 0);
-            }
-            gf = eval((jl_value_t*)fname, locals, nl, ngensym);
-            if (jl_is_expr(fname))
-                fname = (jl_sym_t*)jl_fieldref(jl_exprarg(fname, 2), 0);
-            bp = &gf;
-            assert(jl_is_symbol(fname));
-        }
-        else {
+        assert(jl_expr_nargs(ex) != 1 || jl_is_symbol(fname));
+
+        if (jl_is_symbol(fname)) {
+            jl_value_t **bp=NULL;
+            jl_value_t *bp_owner=NULL;
+            jl_binding_t *b=NULL;
             for (size_t i=0; i < nl; i++) {
                 if (locals[i*2] == (jl_value_t*)fname) {
                     bp = &locals[i*2+1];
@@ -299,19 +258,18 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
                 bp = &b->value;
                 bp_owner = (jl_value_t*)jl_current_module;
             }
+            jl_value_t *gf = jl_generic_function_def(fname, bp, bp_owner, b);
+            if (jl_expr_nargs(ex) == 1)
+                return gf;
         }
-        if (jl_expr_nargs(ex) == 1)
-            return jl_generic_function_def(fname, bp, bp_owner, b);
+
         jl_value_t *atypes=NULL, *meth=NULL;
         JL_GC_PUSH2(&atypes, &meth);
         atypes = eval(args[1], locals, nl, ngensym);
-        if (jl_is_lambda_info(args[2])) {
-            jl_check_static_parameter_conflicts((jl_lambda_info_t*)args[2], (jl_svec_t*)jl_svecref(atypes,1), fname);
-        }
         meth = eval(args[2], locals, nl, ngensym);
-        jl_method_def(fname, bp, bp_owner, b, (jl_svec_t*)atypes, (jl_function_t*)meth, args[3], NULL, kw);
+        jl_method_def((jl_svec_t*)atypes, (jl_lambda_info_t*)meth, args[3]);
         JL_GC_POP();
-        return *bp;
+        return jl_nothing;
     }
     else if (ex->head == copyast_sym) {
         return jl_copy_ast(eval(args[0], locals, nl, ngensym));
@@ -354,6 +312,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
         jl_gc_wb_binding(b, dt);
         super = eval(args[2], locals, nl, ngensym);
         jl_set_datatype_super(dt, super);
+        jl_reinstantiate_inner_types(dt);
         b->value = temp;
         if (temp==NULL || !equiv_type(dt, (jl_datatype_t*)temp)) {
             jl_checked_assignment(b, (jl_value_t*)dt);
@@ -371,11 +330,12 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
         assert(jl_is_svec(para));
         vnb  = eval(args[2], locals, nl, ngensym);
         if (!jl_is_long(vnb))
-            jl_errorf("invalid declaration of bits type %s", ((jl_sym_t*)name)->name);
+            jl_errorf("invalid declaration of bits type %s",
+                      jl_symbol_name((jl_sym_t*)name));
         ssize_t nb = jl_unbox_long(vnb);
         if (nb < 1 || nb>=(1<<23) || (nb&7) != 0)
             jl_errorf("invalid number of bits in type %s",
-                      ((jl_sym_t*)name)->name);
+                      jl_symbol_name((jl_sym_t*)name));
         dt = jl_new_bitstype(name, jl_any_type, (jl_svec_t*)para, nb);
         jl_binding_t *b = jl_get_binding_wr(jl_current_module, (jl_sym_t*)name);
         temp = b->value;
@@ -384,6 +344,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
         jl_gc_wb_binding(b, dt);
         super = eval(args[3], locals, nl, ngensym);
         jl_set_datatype_super(dt, super);
+        jl_reinstantiate_inner_types(dt);
         b->value = temp;
         if (temp==NULL || !equiv_type(dt, (jl_datatype_t*)temp)) {
             jl_checked_assignment(b, (jl_value_t*)dt);
@@ -413,6 +374,8 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
         jl_gc_wb_binding(b,dt);
 
         JL_TRY {
+            super = eval(args[3], locals, nl, ngensym);
+            jl_set_datatype_super(dt, super);
             // operations that can fail
             inside_typedef = 1;
             dt->types = (jl_svec_t*)eval(args[4], locals, nl, ngensym);
@@ -421,10 +384,11 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
             for(size_t i=0; i < jl_svec_len(dt->types); i++) {
                 jl_value_t *elt = jl_svecref(dt->types, i);
                 if (!jl_is_type(elt) && !jl_is_typevar(elt))
-                    jl_type_error_rt(dt->name->name->name, "type definition", (jl_value_t*)jl_type_type, elt);
+                    jl_type_error_rt(jl_symbol_name(dt->name->name),
+                                     "type definition",
+                                     (jl_value_t*)jl_type_type, elt);
             }
-            super = eval(args[3], locals, nl, ngensym);
-            jl_set_datatype_super(dt, super);
+            jl_reinstantiate_inner_types(dt);
         }
         JL_CATCH {
             b->value = temp;
@@ -450,23 +414,6 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
         JL_GC_POP();
         return (jl_value_t*)jl_nothing;
     }
-    else if (ex->head == macro_sym) {
-        jl_sym_t *nm = (jl_sym_t*)args[0];
-        assert(jl_is_symbol(nm));
-        jl_function_t *f = (jl_function_t*)eval(args[1], locals, nl, ngensym);
-        JL_GC_PUSH1(&f);
-        assert(jl_is_function(f));
-        if (jl_boot_file_loaded &&
-            f->linfo && f->linfo->ast && jl_is_expr(f->linfo->ast)) {
-            jl_lambda_info_t *li = f->linfo;
-            li->ast = jl_compress_ast(li, li->ast);
-            jl_gc_wb(li, li->ast);
-            li->name = nm;
-        }
-        jl_set_global(jl_current_module, nm, (jl_value_t*)f);
-        JL_GC_POP();
-        return (jl_value_t*)jl_nothing;
-    }
     else if (ex->head == line_sym) {
         jl_lineno = jl_unbox_long(jl_exprarg(ex,0));
         return (jl_value_t*)jl_nothing;
@@ -484,6 +431,9 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
     else if (ex->head == boundscheck_sym) {
         return (jl_value_t*)jl_nothing;
     }
+    else if (ex->head == inbounds_sym) {
+        return (jl_value_t*)jl_nothing;
+    }
     else if (ex->head == fastmath_sym) {
         return (jl_value_t*)jl_nothing;
     }
@@ -493,14 +443,19 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl, size_t ng
     else if (ex->head == meta_sym) {
         return (jl_value_t*)jl_nothing;
     }
-    jl_errorf("unsupported or misplaced expression %s", ex->head->name);
+    else if (ex->head == inert_sym) {
+        return args[0];
+    }
+    else if (ex->head == thunk_sym) {
+        return jl_toplevel_eval((jl_value_t*)ex);
+    }
+    jl_errorf("unsupported or misplaced expression %s", jl_symbol_name(ex->head));
     return (jl_value_t*)jl_nothing;
 }
 
-static int label_idx(jl_value_t *tgt, jl_array_t *stmts)
+static int label_idx(long ltgt, jl_array_t *stmts)
 {
     size_t j;
-    long ltgt = jl_unbox_long(tgt);
     for(j=0; j < stmts->nrows; j++) {
         jl_value_t *l = jl_cellref(stmts,j);
         if (jl_is_labelnode(l) && jl_labelnode_label(l)==ltgt)
@@ -533,12 +488,14 @@ static jl_value_t *eval_body(jl_array_t *stmts, jl_value_t **locals, size_t nl,
                              int start, int toplevel)
 {
     jl_handler_t __eh;
-    size_t i=start;
+    size_t i=start, ns = jl_array_len(stmts);
 
     while (1) {
+        if (i >= ns)
+            jl_error("`body` expression must terminate in `return`. Use `block` instead.");
         jl_value_t *stmt = jl_cellref(stmts,i);
         if (jl_is_gotonode(stmt)) {
-            i = label_idx(jl_fieldref(stmt,0), stmts);
+            i = label_idx(jl_gotonode_label(stmt), stmts);
             continue;
         }
         if (jl_is_expr(stmt)) {
@@ -546,7 +503,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, jl_value_t **locals, size_t nl,
             if (head == goto_ifnot_sym) {
                 jl_value_t *cond = eval(jl_exprarg(stmt,0), locals, nl, ngensym);
                 if (cond == jl_false) {
-                    i = label_idx(jl_exprarg(stmt,1), stmts);
+                    i = label_idx(jl_unbox_long(jl_exprarg(stmt, 1)), stmts);
                     continue;
                 }
                 else if (cond != jl_true) {
@@ -571,7 +528,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, jl_value_t **locals, size_t nl,
                     if (jl_exception_in_transit == jl_stackovf_exception)
                         _resetstkoflw();
 #endif
-                    i = label_idx(jl_exprarg(stmt,0), stmts);
+                    i = label_idx(jl_unbox_long(jl_exprarg(stmt,0)), stmts);
                     continue;
                 }
             }
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
index d3a75ddb391f7..b920850f803b0 100644
--- a/src/intrinsics.cpp
+++ b/src/intrinsics.cpp
@@ -1,58 +1,52 @@
 // This file is a part of Julia. License is MIT: http://julialang.org/license
 
 namespace JL_I {
-    enum intrinsic {
-        // wrap and unwrap
-        box=0, unbox,
-        // arithmetic
-        neg_int, add_int, sub_int, mul_int,
-        sdiv_int, udiv_int, srem_int, urem_int, smod_int,
-        neg_float, add_float, sub_float, mul_float, div_float, rem_float,
-        fma_float, muladd_float,
-        // fast arithmetic
-        neg_float_fast, add_float_fast, sub_float_fast,
-        mul_float_fast, div_float_fast, rem_float_fast,
-        // same-type comparisons
-        eq_int,  ne_int,
-        slt_int, ult_int,
-        sle_int, ule_int,
-        eq_float, ne_float,
-        lt_float, le_float,
-        eq_float_fast, ne_float_fast,
-        lt_float_fast, le_float_fast,
-        fpiseq, fpislt,
-        // bitwise operators
-        and_int, or_int, xor_int, not_int, shl_int, lshr_int, ashr_int,
-        bswap_int, ctpop_int, ctlz_int, cttz_int,
-        // conversion
-        sext_int, zext_int, trunc_int,
-        fptoui, fptosi, uitofp, sitofp,
-        fptrunc, fpext,
-        // checked conversion
-        checked_fptosi, checked_fptoui,
-        checked_trunc_sint, checked_trunc_uint, check_top_bit,
-        // checked arithmetic
-        checked_sadd, checked_uadd, checked_ssub, checked_usub,
-        checked_smul, checked_umul,
-        nan_dom_err,
-        // functions
-        abs_float, copysign_float, flipsign_int, select_value,
-        ceil_llvm, floor_llvm, trunc_llvm, rint_llvm,
-        sqrt_llvm, powi_llvm,
-        sqrt_llvm_fast,
-        // pointer access
-        pointerref, pointerset,
-        // c interface
-        ccall, cglobal, jl_alloca, llvmcall
-    };
-};
+#include "intrinsics.h"
+}
+
+#include "ccall.cpp"
 
 using namespace JL_I;
+static Function *runtime_func[num_intrinsics];
+static void jl_init_intrinsic_functions_codegen(Module *m)
+{
+    std::vector<Type *> args1(0); \
+    args1.push_back(T_pjlvalue); \
+    std::vector<Type *> args2(0); \
+    args2.push_back(T_pjlvalue); \
+    args2.push_back(T_pjlvalue); \
+    std::vector<Type *> args3(0); \
+    args3.push_back(T_pjlvalue); \
+    args3.push_back(T_pjlvalue); \
+    args3.push_back(T_pjlvalue);
+
+#define ADD_I(name, nargs) do { \
+        Function *func = Function::Create(FunctionType::get(T_pjlvalue, args##nargs, false), \
+                                          Function::ExternalLinkage, "jl_"#name, m); \
+        runtime_func[name] = func; \
+        add_named_global(func, &jl_##name); \
+    } while (0);
+#define ADD_HIDDEN ADD_I
+#define ALIAS(alias, base) runtime_func[alias] = runtime_func[base];
+    ADD_HIDDEN(reinterpret, 2);
+    INTRINSICS
+#undef ADD_I
+#undef ADD_HIDDEN
+#undef ALIAS
+}
 
-#include "ccall.cpp"
+extern "C" JL_DLLEXPORT uint32_t jl_get_LLVM_VERSION(void);
+JL_DLLEXPORT uint32_t jl_get_LLVM_VERSION(void)
+{
+    return 10000 * LLVM_VERSION_MAJOR + 100 * LLVM_VERSION_MINOR
+#ifdef LLVM_VERSION_PATCH
+        + LLVM_VERSION_PATCH
+#endif
+        ;
+}
 
 /*
-  low-level intrinsics design:
+  low-level intrinsics design: TODO: fix description below
   functions like add_int expect unboxed values of matching bit-length.
   every operation that can return an unboxed value does so.
   this maximizes opportunities for composing functions without
@@ -67,15 +61,15 @@ static Type *FTnbits(size_t nb)
 {
 #ifndef DISABLE_FLOAT16
     if (nb == 16)
-        return Type::getHalfTy(jl_LLVMContext);
+        return T_float16;
     else
 #endif
     if (nb == 32)
-        return Type::getFloatTy(jl_LLVMContext);
+        return T_float32;
     else if (nb == 64)
-        return Type::getDoubleTy(jl_LLVMContext);
+        return T_float64;
     else if (nb == 128)
-        return Type::getFP128Ty(jl_LLVMContext);
+        return T_float128;
     else
         jl_error("Unsupported Float Size");
 }
@@ -107,12 +101,22 @@ static Type *JL_INTT(Type *t)
     assert(t == T_void);
     return T_void;
 }
-static jl_value_t *JL_JLINTT(Type *t)
+// convert float type to same-size int type (as a Julia type)
+static jl_value_t *JL_JLUINTT(Type *t)
+{
+    assert(!t->isIntegerTy());
+    if (t == T_float32) return (jl_value_t*)jl_uint32_type;
+    if (t == T_float64) return (jl_value_t*)jl_uint64_type;
+    if (t == T_float16) return (jl_value_t*)jl_uint16_type;
+    assert(t == T_void);
+    return jl_bottom_type;
+}
+static jl_value_t *JL_JLSINTT(Type *t)
 {
     assert(!t->isIntegerTy());
-    if (t == T_float32) return (jl_value_t*)jl_float32_type;
-    if (t == T_float64) return (jl_value_t*)jl_float64_type;
-    if (t == Type::getHalfTy(jl_LLVMContext)) return jl_get_global(jl_base_module, jl_symbol("Float16"));
+    if (t == T_float32) return (jl_value_t*)jl_int32_type;
+    if (t == T_float64) return (jl_value_t*)jl_int64_type;
+    if (t == T_float16) return (jl_value_t*)jl_int16_type;
     assert(t == T_void);
     return jl_bottom_type;
 }
@@ -231,7 +235,7 @@ static Constant *julia_const_to_llvm(jl_value_t *e, bool nested=false)
         }
         JL_GC_POP();
 
-        Type *t = julia_struct_to_llvm(jt);
+        Type *t = julia_struct_to_llvm(jt, NULL);
         if (type_is_ghost(t))
             return UndefValue::get(NoopType);
         if (t->isVectorTy())
@@ -251,19 +255,12 @@ static Constant *julia_const_to_llvm(jl_value_t *e, bool nested=false)
     return NULL;
 }
 
-static jl_cgval_t emit_unboxed(jl_value_t *e, jl_codectx_t *ctx)
-{
-    Constant *c = julia_const_to_llvm(e);
-    if (c) return mark_julia_type(c, expr_type(e, ctx));
-    return emit_expr(e, ctx, false);
-}
-
 static jl_cgval_t ghostValue(jl_value_t *ty);
 
 // emit code to unpack a raw value from a box into registers
 static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt)
 {
-    assert(to != jl_pvalue_llvmt);
+    assert(to != T_pjlvalue);
     // TODO: fully validate that x.typ == jt?
     if (x.isghost) {
         if (type_is_ghost(to)) {
@@ -272,17 +269,10 @@ static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt)
         //emit_error("emit_unbox: a type mismatch error in occurred during codegen", ctx);
         return UndefValue::get(to); // type mismatch error
     }
-    if (!x.isboxed) { // already unboxed, but sometimes need conversion
-        Value *unboxed;
-        if (x.ispointer) {
-            if (jt == (jl_value_t*)jl_bool_type && to != T_int1)
-                return builder.CreateZExt(builder.CreateLoad(builder.CreatePointerCast(x.V, T_int1->getPointerTo())), to);
-            else
-                return builder.CreateLoad(builder.CreatePointerCast(x.V, to->getPointerTo()));
-        }
-        else {
-            unboxed = x.V;
-        }
+
+    Constant *c = x.constant ? julia_const_to_llvm(x.constant) : NULL;
+    if (!x.ispointer || c) { // already unboxed, but sometimes need conversion
+        Value *unboxed = c ? c : x.V;
         Type *ty = unboxed->getType();
         // bools are stored internally as int8 (for now)
         if (ty == T_int1 && to == T_int8)
@@ -304,18 +294,24 @@ static Value *emit_unbox(Type *to, const jl_cgval_t &x, jl_value_t *jt)
         }
         return unboxed;
     }
-    Value *p = x.V;
-    if (to == T_int1) {
-        // bools stored as int8, so an extra Trunc is needed to get an int1
-        return builder.CreateTrunc(
-                builder.CreateLoad(builder.CreateBitCast(p, T_pint8)),
-                T_int1);
-    }
-    return builder.CreateAlignedLoad(builder.CreateBitCast(p, to->getPointerTo()), 16); // julia's gc gives 16-byte aligned addresses
+
+    // bools stored as int8, so an extra Trunc is needed to get an int1
+    Value *p = x.constant ? literal_pointer_val(x.constant) : x.V;
+    Type *ptype = (to == T_int1 ? T_pint8 : to->getPointerTo());
+    if (p->getType() != ptype)
+        p = builder.CreateBitCast(p, ptype);
+    if (to == T_int1)
+        return builder.CreateTrunc(builder.CreateLoad(p), T_int1);
+    if (jt == (jl_value_t*)jl_bool_type)
+        return builder.CreateZExt(builder.CreateTrunc(builder.CreateLoad(p), T_int1), to);
+
+    if (!x.isboxed) // stack has default alignment
+        return builder.CreateLoad(p);
+    return builder.CreateAlignedLoad(p, 16); // julia's gc gives 16-byte aligned addresses
 }
 
 // unbox, trying to determine correct bitstype automatically
-// returns some sort of raw, unboxed numeric type (in registers)
+// returns some sort of raw, unboxed numeric type (e.g. in registers)
 static Value *auto_unbox(const jl_cgval_t &v, jl_codectx_t *ctx)
 {
     jl_value_t *bt = v.typ;
@@ -325,8 +321,9 @@ static Value *auto_unbox(const jl_cgval_t &v, jl_codectx_t *ctx)
         emit_error("auto_unbox: unable to determine argument type", ctx);
         return UndefValue::get(T_void);
     }
-    Type *to = julia_type_to_llvm(v.typ);
-    if (to == NULL || to == jl_pvalue_llvmt) {
+    bool isboxed;
+    Type *to = julia_type_to_llvm(v.typ, &isboxed);
+    if (to == NULL || isboxed) {
         // might be some sort of incomplete (but valid) Ptr{T} type, for example
         unsigned int nb = jl_datatype_size(bt)*8;
         to = IntegerType::get(jl_LLVMContext, nb);
@@ -339,7 +336,7 @@ static Value *auto_unbox(const jl_cgval_t &v, jl_codectx_t *ctx)
 }
 static Value *auto_unbox(jl_value_t *x, jl_codectx_t *ctx)
 {
-    jl_cgval_t v = emit_unboxed(x, ctx);
+    jl_cgval_t v = emit_expr(x, ctx);
     return auto_unbox(v, ctx);
 }
 
@@ -353,16 +350,10 @@ static jl_value_t *staticeval_bitstype(jl_value_t *targ, const char *fname, jl_c
         bt = jl_tparam0(et);
     }
     else {
-        JL_TRY { // TODO: change this to an actual call to staticeval rather than actually executing code
-            bt = jl_interpret_toplevel_expr_in(ctx->module, targ,
-                                               jl_svec_data(ctx->sp),
-                                               jl_svec_len(ctx->sp)/2);
-        }
-        JL_CATCH {
-            bt = NULL;
-        }
+        bt = try_eval(targ, ctx, NULL); // TODO: change this to an actual call to staticeval rather than actually executing code
+        if (bt) jl_add_linfo_root(ctx->linfo, bt);
     }
-    if (fname && !jl_is_bitstype(bt)) {
+    if (fname && (!bt || !jl_is_bitstype(bt))) {
         jl_errorf("%s: expected bits type as first argument", fname);
         return NULL;
     }
@@ -372,8 +363,9 @@ static jl_value_t *staticeval_bitstype(jl_value_t *targ, const char *fname, jl_c
 static Type *staticeval_bitstype(jl_value_t *bt)
 {
     assert(jl_is_bitstype(bt));
-    Type *to = julia_type_to_llvm(bt);
-    if (to == NULL || to == jl_pvalue_llvmt) {
+    bool isboxed;
+    Type *to = julia_type_to_llvm(bt, &isboxed);
+    if (to == NULL || isboxed) {
         unsigned int nb = jl_datatype_size(bt)*8;
         to = IntegerType::get(jl_LLVMContext, nb);
     }
@@ -382,7 +374,7 @@ static Type *staticeval_bitstype(jl_value_t *bt)
 }
 
 // figure out how many bits a bitstype has at compile time
-int get_bitstype_nbits(jl_value_t *bt)
+static int get_bitstype_nbits(jl_value_t *bt)
 {
     assert(jl_is_bitstype(bt));
     if (bt == (jl_value_t*)jl_bool_type)
@@ -392,12 +384,102 @@ int get_bitstype_nbits(jl_value_t *bt)
 
 // put a bits type tag on some value (despite the name, this doesn't necessarily actually "box" the value however)
 static jl_cgval_t generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
+{
+    // Examine the first argument //
+    jl_value_t *bt = static_eval(targ, ctx, true, true);
+    if (bt) jl_add_linfo_root(ctx->linfo, bt);
+
+    if (!bt || !jl_is_bitstype(bt)) {
+        // it's easier to throw a good error from C than llvm
+        if (bt) targ = bt;
+        Value *arg1 = boxed(emit_expr(targ, ctx), ctx);
+        Value *arg2 = boxed(emit_expr(x, ctx), ctx);
+        Value *func = prepare_call(runtime_func[reinterpret]);
+#ifdef LLVM37
+        Value *r = builder.CreateCall(func, {arg1, arg2});
+#else
+        Value *r = builder.CreateCall2(func, arg1, arg2);
+#endif
+        jl_value_t *et = expr_type(targ, ctx);
+        return mark_julia_type(r, true, jl_is_type_type(et) ? jl_tparam0(et) : (jl_value_t*)jl_any_type, ctx);
+    }
+
+    Type *llvmt = staticeval_bitstype(bt);
+    int nb = jl_datatype_size(bt);
+
+    // Examine the second argument //
+    jl_cgval_t v = emit_expr(x, ctx);
+    bool isboxed;
+    Type *vxt = julia_type_to_llvm(v.typ, &isboxed);
+
+    if (!jl_is_datatype(v.typ)
+        || !jl_is_bitstype(v.typ)
+        || jl_datatype_size(v.typ) != nb) {
+        Value *typ = emit_typeof(v);
+        if (!jl_is_bitstype(v.typ)) {
+            if (isboxed) {
+                Value *isbits = emit_datatype_isbitstype(typ);
+                error_unless(isbits, "reinterpret: expected bitstype value for second argument", ctx);
+            }
+            else {
+                emit_error("reinterpret: expected bitstype value for second argument", ctx);
+                return jl_cgval_t();
+            }
+        }
+        if (jl_datatype_size(v.typ) != nb) {
+            if (isboxed) {
+                Value *size = emit_datatype_size(typ);
+                error_unless(builder.CreateICmpEQ(size, ConstantInt::get(T_int32, nb)),
+                            "reinterpret: argument size does not match size of target type", ctx);
+            }
+            else {
+                emit_error("reinterpret: argument size does not match size of target type", ctx);
+                return jl_cgval_t();
+            }
+        }
+    }
+
+    assert(!v.isghost);
+    Value *vx = NULL;
+    if (!v.ispointer)
+        vx = v.V;
+    else if (v.constant)
+        vx = julia_const_to_llvm(v.constant);
+
+    if (v.ispointer && vx == NULL) {
+        // try to load as original Type, to preserve llvm optimizations
+        // but if the v.typ is not well known, use llvmt
+        if (isboxed)
+            vxt = llvmt;
+        vx = builder.CreateLoad(data_pointer(v, ctx,
+                    vxt == T_int1 ? T_pint8 : vxt->getPointerTo()));
+    }
+
+    vxt = vx->getType();
+    if (vxt != llvmt) {
+        if (llvmt == T_int1)
+            vx = builder.CreateTrunc(vx, llvmt);
+        else if (vxt == T_int1 && llvmt == T_int8)
+            vx = builder.CreateZExt(vx, llvmt);
+        else if (vxt->isPointerTy() && !llvmt->isPointerTy())
+            vx = builder.CreatePtrToInt(vx, llvmt);
+        else if (!vxt->isPointerTy() && llvmt->isPointerTy())
+            vx = builder.CreateIntToPtr(vx, llvmt);
+        else
+            vx = builder.CreateBitCast(vx, llvmt);
+    }
+
+    return mark_julia_type(vx, false, bt, ctx);
+}
+
+// put a bits type tag on some value
+static jl_cgval_t generic_unbox(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
 {
     // Examine the first argument //
     jl_value_t *bt = staticeval_bitstype(targ, NULL, ctx);
 
     // Examine the second argument //
-    jl_cgval_t v = emit_unboxed(x, ctx);
+    jl_cgval_t v = emit_expr(x, ctx);
 
     if (bt == NULL || !jl_is_leaf_type(bt)) {
         // dynamically-determined type; evaluate.
@@ -413,7 +495,7 @@ static jl_cgval_t generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx
             if (!jl_is_leaf_type(v.typ) && !jl_is_bitstype(v.typ)) {
                 // TODO: currently doesn't handle the case where the type of neither argument is understood at compile time
                 // since codegen has no idea what size it might have
-                jl_error("codegen: failed during evaluation of a call to reinterpret");
+                jl_error("codegen: failed during evaluation of a call to unbox");
                 return jl_cgval_t();
             }
             nb = jl_datatype_size(v.typ);
@@ -425,16 +507,19 @@ static jl_cgval_t generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx
 
         Value *newobj = emit_allocobj(nb);
         builder.CreateStore(runtime_bt, emit_typeptr_addr(newobj));
-        if (!v.ispointer)
+        if (!v.ispointer) {
             builder.CreateAlignedStore(emit_unbox(llvmt, v, v.typ), builder.CreatePointerCast(newobj, llvmt->getPointerTo()), alignment);
-        else
-            builder.CreateMemCpy(newobj, builder.CreateBitCast(v.V, T_pint8), nb, alignment);
-        return mark_julia_type(newobj, bt ? bt : (jl_value_t*)jl_any_type);
+        }
+        else {
+            prepare_call(builder.CreateMemCpy(newobj, data_pointer(v, ctx, T_pint8), nb, alignment)->getCalledValue());
+            mark_gc_use(v);
+        }
+        return mark_julia_type(newobj, true, bt ? bt : (jl_value_t*)jl_any_type, ctx);
     }
 
     if (!jl_is_bitstype(bt)) {
         // TODO: to accept arbitrary types, replace this function with a call to llvm_type_rewrite
-        emit_error("reinterpret: expected bits type as first argument", ctx);
+        emit_error("unbox: expected bits type as first argument", ctx);
         return jl_cgval_t();
     }
 
@@ -445,17 +530,17 @@ static jl_cgval_t generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx
     Value *vx;
     if (v.ispointer) {
         // TODO: validate the size and type of the pointer contents
-        if (v.isimmutable && !v.needsgcroot) { // wrong type, but can lazy load this later as needed
+        if (v.isimmutable && !v.constant) { // wrong type, but can lazy load this later as needed
             v.typ = bt;
             v.isboxed = false;
             return v;
         }
-        vx = builder.CreateLoad(builder.CreateBitCast(v.V, llvmt->getPointerTo()));
+        vx = builder.CreateLoad(data_pointer(v, ctx, llvmt->getPointerTo()));
     }
     else {
         vx = v.V;
         if (!jl_is_bitstype(v.typ)) {
-            emit_error("reinterpret: expected bits type value for second argument", ctx);
+            emit_error("unbox: expected bits type value for second argument", ctx);
             return jl_cgval_t();
         }
     }
@@ -473,7 +558,7 @@ static jl_cgval_t generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx
         if (vxt->getPrimitiveSizeInBits() != llvmt->getPrimitiveSizeInBits() &&
             !(vxt->isPointerTy() && llvmt->getPrimitiveSizeInBits() == sizeof(void*)*8) &&
             !(llvmt->isPointerTy() && vxt->getPrimitiveSizeInBits() == sizeof(void*)*8)) {
-            emit_error("box: argument is of incorrect size", ctx);
+            emit_error("unbox: argument is of incorrect size", ctx);
             return jl_cgval_t();
         }
         if (vxt->isPointerTy() && !llvmt->isPointerTy())
@@ -484,7 +569,7 @@ static jl_cgval_t generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx
             vx = builder.CreateBitCast(vx, llvmt);
     }
 
-    return mark_julia_type(vx, bt);
+    return mark_julia_type(vx, false, bt, ctx);
 }
 
 // NOTE: signd (signed) only relevant if check == true
@@ -502,7 +587,7 @@ static jl_cgval_t generic_trunc(jl_value_t *targ, jl_value_t *x, jl_codectx_t *c
         raise_exception_unless(builder.CreateICmpEQ(back, ix),
                                prepare_global(jlinexacterr_var), ctx);
     }
-    return mark_julia_type(ans, jlto);
+    return mark_julia_type(ans, false, jlto, ctx);
 }
 
 static jl_cgval_t generic_sext(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
@@ -513,7 +598,7 @@ static jl_cgval_t generic_sext(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ct
     Value *ix = JL_INT(auto_unbox(x, ctx));
     if (ix->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
     Value *ans = builder.CreateSExt(ix, to);
-    return mark_julia_type(ans, jlto);
+    return mark_julia_type(ans, false, jlto, ctx);
 }
 
 static jl_cgval_t generic_zext(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
@@ -524,7 +609,7 @@ static jl_cgval_t generic_zext(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ct
     Value *ix = JL_INT(auto_unbox(x, ctx));
     if (ix->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
     Value *ans = builder.CreateZExt(ix, to);
-    return mark_julia_type(ans, jlto);
+    return mark_julia_type(ans, false, jlto, ctx);
 }
 
 static Value *emit_eqfsi(Value *x, Value *y)
@@ -578,7 +663,7 @@ static jl_cgval_t emit_checked_fptosi(jl_value_t *targ, jl_value_t *x, jl_codect
     else {
         raise_exception_unless(emit_eqfsi(fx, ans), prepare_global(jlinexacterr_var), ctx);
     }
-    return mark_julia_type(ans, jlto);
+    return mark_julia_type(ans, false, jlto, ctx);
 }
 
 static jl_cgval_t emit_checked_fptoui(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
@@ -598,23 +683,18 @@ static jl_cgval_t emit_checked_fptoui(jl_value_t *targ, jl_value_t *x, jl_codect
     else {
         raise_exception_unless(emit_eqfui(fx, ans), prepare_global(jlinexacterr_var), ctx);
     }
-    return mark_julia_type(ans, jlto);
+    return mark_julia_type(ans, false, jlto, ctx);
 }
 
 static jl_cgval_t emit_runtime_pointerref(jl_value_t *e, jl_value_t *i, jl_codectx_t *ctx)
 {
-    Value *preffunc = // TODO: move this to the codegen initialization code section
-        jl_Module->getOrInsertFunction("jl_pointerref",
-                                       FunctionType::get(jl_pvalue_llvmt, two_pvalue_llvmt, false));
-    int ldepth = ctx->gc.argDepth;
-    jl_cgval_t parg = emit_boxed_rooted(e, ctx);
+    jl_cgval_t parg = emit_expr(e, ctx);
     Value *iarg = boxed(emit_expr(i, ctx), ctx);
 #ifdef LLVM37
-    Value *ret = builder.CreateCall(prepare_call(preffunc), { parg.V, iarg });
+    Value *ret = builder.CreateCall(prepare_call(jlpref_func), { boxed(parg, ctx), iarg });
 #else
-    Value *ret = builder.CreateCall2(prepare_call(preffunc), parg.V, iarg);
+    Value *ret = builder.CreateCall2(prepare_call(jlpref_func), boxed(parg, ctx), iarg);
 #endif
-    ctx->gc.argDepth = ldepth;
     jl_value_t *ety;
     if (jl_is_cpointer_type(parg.typ)) {
         ety = jl_tparam0(parg.typ);
@@ -622,7 +702,7 @@ static jl_cgval_t emit_runtime_pointerref(jl_value_t *e, jl_value_t *i, jl_codec
     else {
         ety = (jl_value_t*)jl_any_type;
     }
-    return jl_cgval_t(ret, ety);
+    return mark_julia_type(ret, true, ety, ctx);
 }
 
 static jl_cgval_t emit_pointerref(jl_value_t *e, jl_value_t *i, jl_codectx_t *ctx)
@@ -639,32 +719,31 @@ static jl_cgval_t emit_pointerref(jl_value_t *e, jl_value_t *i, jl_codectx_t *ct
         return emit_runtime_pointerref(e, i, ctx);
         //jl_error("pointerref: invalid index type");
     Value *thePtr = auto_unbox(e,ctx);
-    Value *idx = emit_unbox(T_size, emit_unboxed(i, ctx), (jl_value_t*)jl_long_type);
+    Value *idx = emit_unbox(T_size, emit_expr(i, ctx), (jl_value_t*)jl_long_type);
     Value *im1 = builder.CreateSub(idx, ConstantInt::get(T_size, 1));
     if (!jl_isbits(ety)) {
         if (ety == (jl_value_t*)jl_any_type)
             return mark_julia_type(
                     builder.CreateLoad(builder.CreateGEP(
-                        builder.CreateBitCast(thePtr, jl_ppvalue_llvmt),
+                        builder.CreateBitCast(thePtr, T_ppjlvalue),
                         im1)),
-                    ety);
+                    true,
+                    ety, ctx);
         if (!jl_is_structtype(ety) || jl_is_array_type(ety) || !jl_is_leaf_type(ety)) {
             emit_error("pointerref: invalid pointer type", ctx);
             return jl_cgval_t();
         }
         assert(jl_is_datatype(ety));
         uint64_t size = jl_datatype_size(ety);
-        Value *strct =
-            builder.CreateCall(prepare_call(jlallocobj_func),
-                               ConstantInt::get(T_size, size));
+        Value *strct = emit_allocobj(size);
         builder.CreateStore(literal_pointer_val((jl_value_t*)ety),
                             emit_typeptr_addr(strct));
         im1 = builder.CreateMul(im1, ConstantInt::get(T_size,
                     LLT_ALIGN(size, ((jl_datatype_t*)ety)->alignment)));
         thePtr = builder.CreateGEP(builder.CreateBitCast(thePtr, T_pint8), im1);
-        builder.CreateMemCpy(builder.CreateBitCast(strct, T_pint8),
-                             thePtr, size, 1);
-        return mark_julia_type(strct, ety);
+        prepare_call(builder.CreateMemCpy(builder.CreateBitCast(strct, T_pint8),
+                             thePtr, size, 1)->getCalledValue());
+        return mark_julia_type(strct, true, ety, ctx);
     }
     // TODO: alignment?
     return typed_load(thePtr, im1, ety, ctx, tbaa_user, 1);
@@ -672,19 +751,14 @@ static jl_cgval_t emit_pointerref(jl_value_t *e, jl_value_t *i, jl_codectx_t *ct
 
 static jl_cgval_t emit_runtime_pointerset(jl_value_t *e, jl_value_t *x, jl_value_t *i, jl_codectx_t *ctx)
 {
-    Value *psetfunc = // TODO: move this to the codegen initialization code section
-        jl_Module->getOrInsertFunction("jl_pointerset",
-                                       FunctionType::get(T_void, three_pvalue_llvmt, false));
-    int ldepth = ctx->gc.argDepth;
-    jl_cgval_t parg = emit_boxed_rooted(e, ctx);
-    Value *iarg = emit_boxed_rooted(i, ctx).V;
+    jl_cgval_t parg = emit_expr(e, ctx);
+    Value *iarg = boxed(emit_expr(i, ctx), ctx);
     Value *xarg = boxed(emit_expr(x, ctx), ctx);
 #ifdef LLVM37
-    builder.CreateCall(prepare_call(psetfunc), { parg.V, xarg, iarg });
+    builder.CreateCall(prepare_call(jlpset_func), { boxed(parg, ctx), xarg, iarg });
 #else
-    builder.CreateCall3(prepare_call(psetfunc), parg.V, xarg, iarg);
+    builder.CreateCall3(prepare_call(jlpset_func), boxed(parg, ctx), xarg, iarg);
 #endif
-    ctx->gc.argDepth = ldepth;
     return parg;
 }
 
@@ -710,7 +784,7 @@ static jl_cgval_t emit_pointerset(jl_value_t *e, jl_value_t *x, jl_value_t *i, j
     if (expr_type(i, ctx) != (jl_value_t*)jl_long_type)
         return emit_runtime_pointerset(e, x, i, ctx);
         //jl_error("pointerset: invalid index type");
-    Value *idx = emit_unbox(T_size, emit_unboxed(i, ctx),(jl_value_t*)jl_long_type);
+    Value *idx = emit_unbox(T_size, emit_expr(i, ctx),(jl_value_t*)jl_long_type);
     Value *im1 = builder.CreateSub(idx, ConstantInt::get(T_size, 1));
     Value *thePtr = auto_unbox(e,ctx);
     if (!jl_isbits(ety) && ety != (jl_value_t*)jl_any_type) {
@@ -719,29 +793,26 @@ static jl_cgval_t emit_pointerset(jl_value_t *e, jl_value_t *x, jl_value_t *i, j
             return jl_cgval_t();
         }
         if (!emitted)
-            val = emit_expr(x,ctx,true,true);
+            val = emit_expr(x, ctx);
         assert(val.isboxed);
         assert(jl_is_datatype(ety));
         uint64_t size = ((jl_datatype_t*)ety)->size;
         im1 = builder.CreateMul(im1, ConstantInt::get(T_size,
                     LLT_ALIGN(size, ((jl_datatype_t*)ety)->alignment)));
-        builder.CreateMemCpy(builder.CreateGEP(builder.CreateBitCast(thePtr, T_pint8), im1),
-                             builder.CreateBitCast(val.V, T_pint8), size, 1);
+        prepare_call(builder.CreateMemCpy(builder.CreateGEP(builder.CreateBitCast(thePtr, T_pint8), im1),
+                             data_pointer(val, ctx, T_pint8), size, 1)->getCalledValue());
     }
     else {
         if (!emitted) {
-            if (ety == (jl_value_t*)jl_any_type)
-                val = emit_expr(x,ctx);
-            else
-                val = emit_unboxed(x,ctx);
+            val = emit_expr(x, ctx);
         }
         // TODO: alignment?
         typed_store(thePtr, im1, val, ety, ctx, tbaa_user, NULL, 1);
     }
-    return mark_julia_type(thePtr, aty);
+    return mark_julia_type(thePtr, false, aty, ctx);
 }
 
-static Value *emit_srem(Value *x, Value *den, jl_codectx_t *ctx)
+static Value *emit_checked_srem_int(Value *x, Value *den, jl_codectx_t *ctx)
 {
     Type *t = den->getType();
     raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
@@ -776,157 +847,171 @@ struct math_builder {
              jl_options.fast_math == JL_OPTIONS_FAST_MATH_ON)) {
             FastMathFlags fmf;
             fmf.setUnsafeAlgebra();
+#ifdef LLVM38
+            builder.setFastMathFlags(fmf);
+#else
             builder.SetFastMathFlags(fmf);
+#endif
         }
     }
     IRBuilder<>& operator()() const { return builder; }
     ~math_builder() {
+#ifdef LLVM38
+        builder.setFastMathFlags(old_fmf);
+#else
         builder.SetFastMathFlags(old_fmf);
+#endif
     }
 };
 
-static Value *emit_smod(Value *x, Value *den, jl_codectx_t *ctx)
-{
-    Type *t = den->getType();
-    raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
-                           prepare_global(jldiverr_var), ctx);
-    BasicBlock *m1BB = BasicBlock::Create(getGlobalContext(),"minus1",ctx->f);
-    BasicBlock *okBB = BasicBlock::Create(getGlobalContext(),"oksmod",ctx->f);
-    BasicBlock *cont = BasicBlock::Create(getGlobalContext(),"after_smod",ctx->f);
-    PHINode *ret = PHINode::Create(t, 2);
-    builder.CreateCondBr(builder.CreateICmpEQ(den,ConstantInt::get(t,-1,true)),
-                         m1BB, okBB);
-    builder.SetInsertPoint(m1BB);
-    builder.CreateBr(cont);
-    builder.SetInsertPoint(okBB);
-
-    Value *rem = builder.CreateSRem(x,den);
-    Value *smodval =
-        builder.
-        CreateSelect(builder.CreateICmpEQ(builder.CreateICmpSLT(x,ConstantInt::get(t,0)),
-                                          builder.CreateICmpSLT(den,ConstantInt::get(t,0))),
-                     // mod == rem for arguments with same sign
-                     rem,
-                     builder.CreateSRem(builder.CreateAdd(den,rem),den));
-
-    builder.CreateBr(cont);
-    builder.SetInsertPoint(cont);
-    ret->addIncoming(// rem(typemin, -1) is undefined
-                     ConstantInt::get(t,0), m1BB);
-    ret->addIncoming(smodval, okBB);
-    builder.Insert(ret);
-    return ret;
-}
-
-#define HANDLE(intr,n)                                                  \
-    case intr: if (nargs!=n) jl_error(#intr": wrong number of arguments");
-
 static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z, size_t nargs,
-                                       jl_codectx_t *ctx, jl_datatype_t* *newtyp);
+                                     jl_codectx_t *ctx, jl_datatype_t **newtyp);
 static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
-                                       jl_codectx_t *ctx)
+                                 jl_codectx_t *ctx)
 {
+    assert(f < num_intrinsics);
+    if (f == fptoui && nargs == 1)
+        f = fptoui_auto;
+    if (f == fptosi && nargs == 1)
+        f = fptosi_auto;
+    unsigned expected_nargs = intrinsic_nargs[f];
+    if (expected_nargs && expected_nargs != nargs) {
+        jl_errorf("intrinsic #%d %s: wrong number of arguments", f, JL_I::jl_intrinsic_name((int)f));
+    }
+
     switch (f) {
     case ccall: return emit_ccall(args, nargs, ctx);
     case cglobal: return emit_cglobal(args, nargs, ctx);
     case llvmcall: return emit_llvmcall(args, nargs, ctx);
-
-    HANDLE(pointerref,2)
+    case arraylen:
+        return mark_julia_type(emit_arraylen(emit_expr(args[1], ctx), args[1], ctx), false,
+                               jl_long_type, ctx);
+#if 0 // this section enables runtime-intrinsics (e.g. for testing), and disables their llvm counterparts
+    default:
+        Value *r;
+        Value *func = prepare_call(runtime_func[f]);
+        if (nargs == 1) {
+            Value *x = boxed(emit_expr(args[1], ctx), ctx);
+#ifdef LLVM37
+            r = builder.CreateCall(func, {x});
+#else
+            r = builder.CreateCall(func, x);
+#endif
+        }
+        else if (nargs == 2) {
+            Value *x = boxed(emit_expr(args[1], ctx), ctx);
+            Value *y = boxed(emit_expr(args[2], ctx), ctx);
+#ifdef LLVM37
+            r = builder.CreateCall(func, {x, y});
+#else
+            r = builder.CreateCall2(func, x, y);
+#endif
+        }
+        else if (nargs == 3) {
+            Value *x = boxed(emit_expr(args[1], ctx), ctx);
+            Value *y = boxed(emit_expr(args[2], ctx), ctx);
+            Value *z = boxed(emit_expr(args[3], ctx), ctx);
+#ifdef LLVM37
+            r = builder.CreateCall(func, {x, y, z});
+#else
+            r = builder.CreateCall3(func, x, y, z);
+#endif
+        }
+        else {
+            assert(0);
+        }
+        return mark_julia_type(r, true, (jl_value_t*)jl_any_type, ctx);
+#else
+    case pointerref:
         return emit_pointerref(args[1], args[2], ctx);
-    HANDLE(pointerset,3)
+    case pointerset:
         return emit_pointerset(args[1], args[2], args[3], ctx);
-    HANDLE(box,2)
-        return generic_box(args[1], args[2], ctx);
-    HANDLE(unbox,2) // TODO: deprecate this
+    case box:
         return generic_box(args[1], args[2], ctx);
-    HANDLE(trunc_int,2)
+    case unbox:
+        return generic_unbox(args[1], args[2], ctx); // TODO: replace with generic_box
+    case trunc_int:
         return generic_trunc(args[1], args[2], ctx, false, false);
-    HANDLE(checked_trunc_sint,2)
+    case checked_trunc_sint:
         return generic_trunc(args[1], args[2], ctx, true, true);
-    HANDLE(checked_trunc_uint,2)
+    case checked_trunc_uint:
         return generic_trunc(args[1], args[2], ctx, true, false);
-    HANDLE(sext_int,2)
+    case sext_int:
         return generic_sext(args[1], args[2], ctx);
-    HANDLE(zext_int,2)
+    case zext_int:
         return generic_zext(args[1], args[2], ctx);
-    HANDLE(checked_fptosi,2)
+    case checked_fptosi:
         return emit_checked_fptosi(args[1], args[2], ctx);
-    HANDLE(checked_fptoui,2)
+    case checked_fptoui:
         return emit_checked_fptoui(args[1], args[2], ctx);
 
-    HANDLE(uitofp,2) {
+    case uitofp: {
         jl_value_t *bt = staticeval_bitstype(args[1], "uitofp", ctx);
         if (!bt) return jl_cgval_t();
         int nb = get_bitstype_nbits(bt);
         Value *xi = JL_INT(auto_unbox(args[2],ctx));
         if (xi->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-        return mark_julia_type(builder.CreateUIToFP(xi, FTnbits(nb)), bt);
+        return mark_julia_type(builder.CreateUIToFP(xi, FTnbits(nb)), false, bt, ctx);
     }
 
-    HANDLE(sitofp,2) {
+    case sitofp: {
         jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
         if (!bt) return jl_cgval_t();
         int nb = get_bitstype_nbits(bt);
         Value *xi = JL_INT(auto_unbox(args[2],ctx));
         if (xi->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-        return mark_julia_type(builder.CreateSIToFP(xi, FTnbits(nb)), bt);
+        return mark_julia_type(builder.CreateSIToFP(xi, FTnbits(nb)), false, bt, ctx);
     }
 
-    case fptoui:
-        if (nargs == 1) {
-            Value *x = FP(auto_unbox(args[1], ctx));
-            if (x->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-            return mark_julia_type(
-                    builder.CreateFPToUI(FP(x), JL_INTT(x->getType())),
-                    JL_JLINTT(x->getType()));
-        }
-        else if (nargs == 2) {
-            jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
-            if (!bt) return jl_cgval_t();
-            int nb = get_bitstype_nbits(bt);
-            Value *xf = FP(auto_unbox(args[2],ctx));
-            if (xf->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-            return mark_julia_type(builder.CreateFPToUI(xf, Type::getIntNTy(jl_LLVMContext, nb)), bt);
-        }
-        else {
-            jl_error("fptoui: wrong number of arguments");
-        }
+    case fptoui_auto: {
+        Value *x = FP(auto_unbox(args[1], ctx));
+        if (x->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
+        return mark_julia_type(
+                builder.CreateFPToUI(FP(x), JL_INTT(x->getType())),
+                false,
+                JL_JLUINTT(x->getType()), ctx);
+    }
+    case fptoui: {
+        jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
+        if (!bt) return jl_cgval_t();
+        int nb = get_bitstype_nbits(bt);
+        Value *xf = FP(auto_unbox(args[2],ctx));
+        if (xf->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
+        return mark_julia_type(builder.CreateFPToUI(xf, Type::getIntNTy(jl_LLVMContext, nb)), false, bt, ctx);
+    }
 
-    case fptosi:
-        if (nargs == 1) {
-            Value *x = FP(auto_unbox(args[1], ctx));
-            return mark_julia_type(
-                    builder.CreateFPToSI(FP(x), JL_INTT(x->getType())),
-                    JL_JLINTT(x->getType()));
-        }
-        else if (nargs == 2) {
-            jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
-            if (!bt) return jl_cgval_t();
-            int nb = get_bitstype_nbits(bt);
-            Value *xf = FP(auto_unbox(args[2],ctx));
-            if (xf->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-            return mark_julia_type(builder.CreateFPToSI(xf, Type::getIntNTy(jl_LLVMContext, nb)), bt);
-        }
-        else {
-            jl_error("fptosi: wrong number of arguments");
-        }
+    case fptosi_auto: {
+        Value *x = FP(auto_unbox(args[1], ctx));
+        return mark_julia_type(
+                builder.CreateFPToSI(FP(x), JL_INTT(x->getType())),
+                false,
+                JL_JLSINTT(x->getType()), ctx);
+    }
+    case fptosi: {
+        jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
+        if (!bt) return jl_cgval_t();
+        int nb = get_bitstype_nbits(bt);
+        Value *xf = FP(auto_unbox(args[2],ctx));
+        if (xf->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
+        return mark_julia_type(builder.CreateFPToSI(xf, Type::getIntNTy(jl_LLVMContext, nb)), false, bt, ctx);
+    }
 
-    HANDLE(fptrunc,2) {
+    case fptrunc: {
         jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
         if (!bt) return jl_cgval_t();
         int nb = get_bitstype_nbits(bt);
         Value *xf = FP(auto_unbox(args[2],ctx));
         if (xf->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-        return mark_julia_type(builder.CreateFPTrunc(xf, FTnbits(nb)), bt);
+        return mark_julia_type(builder.CreateFPTrunc(xf, FTnbits(nb)), false, bt, ctx);
     }
 
-    HANDLE(fpext,2) {
+    case fpext: {
         jl_value_t *bt = staticeval_bitstype(args[1], "sitofp", ctx);
         if (!bt) return jl_cgval_t();
         int nb = get_bitstype_nbits(bt);
         Value *x = auto_unbox(args[2],ctx);
         if (x->getType() == T_void) return jl_cgval_t(); // auto_unbox threw an error
-#if JL_NEED_FLOATTEMP_VAR
+#ifdef JL_NEED_FLOATTEMP_VAR
         // Target platform might carry extra precision.
         // Force rounding to single precision first. The reason is that it's
         // fine to keep working in extended precision as long as it's
@@ -936,55 +1021,60 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
         builder.CreateStore(FP(x), builder.CreateBitCast(prepare_global(jlfloattemp_var),FT(x->getType())->getPointerTo()), true);
         x  = builder.CreateLoad(builder.CreateBitCast(prepare_global(jlfloattemp_var),FT(x->getType())->getPointerTo()), true);
 #endif
-        return mark_julia_type(
-                builder.CreateFPExt(x, FTnbits(nb)),
-                bt);
+        return mark_julia_type(builder.CreateFPExt(x, FTnbits(nb)), false, bt, ctx);
     }
 
-    HANDLE(select_value,3) {
+    case select_value: {
         Value *isfalse = emit_condition(args[1], "select_value", ctx); // emit the first argument
         jl_value_t *t1 = expr_type(args[2], ctx);
         jl_value_t *t2 = expr_type(args[3], ctx);
-        Type *llt1 = julia_type_to_llvm(t1);
+        bool isboxed;
+        Type *llt1 = julia_type_to_llvm(t1, &isboxed);
         Value *ifelse_result;
-        if (llt1 != jl_pvalue_llvmt && t1 == t2) {
+        if (!isboxed && t1 == t2) {
             // emit X and Y arguments
-            jl_cgval_t x = emit_unboxed(args[2], ctx);
-            jl_cgval_t y = emit_unboxed(args[3], ctx);
+            jl_cgval_t x = emit_expr(args[2], ctx);
+            jl_cgval_t y = emit_expr(args[3], ctx);
             // check the return value was valid
             if (type_is_ghost(llt1))
                 return x;
-            if (x.V->getType() == T_void && y.V->getType() == T_void)
+            if (x.typ == jl_bottom_type && y.typ == jl_bottom_type)
                 return jl_cgval_t(); // undefined
-            if (x.V->getType() == T_void)
+            if (x.typ == jl_bottom_type)
                 return y;
-            if (y.V->getType() == T_void)
+            if (y.typ == jl_bottom_type)
                 return x;
             // ensure that X and Y have the same llvm Type
-            Value *vx = x.V, *vy = y.V;
+            Value *vx, *vy;
             if (x.ispointer) // TODO: elid this load if unnecessary
-                vx = builder.CreateLoad(builder.CreatePointerCast(vx, llt1->getPointerTo(0)));
+                vx = builder.CreateLoad(data_pointer(x, ctx, llt1->getPointerTo(0)));
+            else
+                vx = x.V;
             if (y.ispointer) // TODO: elid this load if unnecessary
-                vy = builder.CreateLoad(builder.CreatePointerCast(vy, llt1->getPointerTo(0)));
+                vy = builder.CreateLoad(data_pointer(y, ctx, llt1->getPointerTo(0)));
+            else
+                vy = y.V;
             ifelse_result = builder.CreateSelect(isfalse, vy, vx);
-            return mark_julia_type(ifelse_result, t2);
+            mark_gc_use(x);
+            mark_gc_use(y);
+            return mark_julia_type(ifelse_result, false, t2, ctx);
         }
         else {
-            int argStart = ctx->gc.argDepth;
-            Value *arg1 = boxed(emit_expr(args[2],ctx,false), ctx, expr_type(args[2],ctx));
-            // TODO: if (arg1->getType() != jl_pvalue_llvmt)
-                make_gcroot(arg1, ctx);
-            Value *arg2 = boxed(emit_expr(args[3],ctx,false), ctx, expr_type(args[3],ctx));
-            ifelse_result = builder.CreateSelect(isfalse, arg2, arg1);
-            ctx->gc.argDepth = argStart;
+            jl_cgval_t arg1 = emit_expr(args[2],ctx);
+            jl_cgval_t arg2 = emit_expr(args[3],ctx);
+            ifelse_result = builder.CreateSelect(isfalse,
+                    boxed(arg2, ctx),
+                    boxed(arg1, ctx));
             jl_value_t *jt = (t1 == t2 ? t1 : (jl_value_t*)jl_any_type);
-            return mark_julia_type(ifelse_result, jt);
+            mark_gc_use(arg1);
+            mark_gc_use(arg2);
+            return mark_julia_type(ifelse_result, true, jt, ctx);
         }
     }
 
     default: {
         if (nargs < 1) jl_error("invalid intrinsic call");
-        jl_cgval_t xinfo = emit_unboxed(args[1], ctx);
+        jl_cgval_t xinfo = emit_expr(args[1], ctx);
         Value *x = auto_unbox(xinfo, ctx);
         if (!x || type_is_ghost(x->getType())) {
             emit_error("invalid intrinsic argument at 1", ctx);
@@ -1012,97 +1102,70 @@ static jl_cgval_t emit_intrinsic(intrinsic f, jl_value_t **args, size_t nargs,
         if (!newtyp && r->getType() != x->getType())
             // cast back to the exact original type (e.g. float vs. int) before remarking as a julia type
             r = builder.CreateBitCast(r, x->getType());
-        return mark_julia_type(r, newtyp ?: xinfo.typ);
+        return mark_julia_type(r, false, newtyp ? newtyp : xinfo.typ, ctx);
     }
+#endif
     }
     assert(0);
 }
 
 static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z, size_t nargs,
-                                       jl_codectx_t *ctx, jl_datatype_t* *newtyp)
+                                       jl_codectx_t *ctx, jl_datatype_t **newtyp)
 {
     Type *t = x->getType();
     Value *fy;
     Value *den;
     Value *typemin;
     switch (f) {
-    HANDLE(neg_int,1) return builder.CreateSub(ConstantInt::get(t, 0), JL_INT(x));
-    HANDLE(add_int,2) return builder.CreateAdd(JL_INT(x), JL_INT(y));
-    HANDLE(sub_int,2) return builder.CreateSub(JL_INT(x), JL_INT(y));
-    HANDLE(mul_int,2) return builder.CreateMul(JL_INT(x), JL_INT(y));
-    HANDLE(sdiv_int,2)
-        den = JL_INT(y);
-        t = den->getType();
-        x = JL_INT(x);
-
-        typemin = builder.CreateShl(ConstantInt::get(t,1),
-                                    x->getType()->getPrimitiveSizeInBits()-1);
-        raise_exception_unless(builder.
-                               CreateAnd(builder.
-                                         CreateICmpNE(den, ConstantInt::get(t,0)),
-                                         builder.
-                                         CreateOr(builder.
-                                                  CreateICmpNE(den,
-                                                               ConstantInt::get(t,-1,true)),
-                                                  builder.CreateICmpNE(x, typemin))),
-                               prepare_global(jldiverr_var), ctx);
-
-        return builder.CreateSDiv(x, den);
-    HANDLE(udiv_int,2)
-        den = JL_INT(y);
-        t = den->getType();
-        raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
-                               prepare_global(jldiverr_var), ctx);
-        return builder.CreateUDiv(JL_INT(x), den);
-
-    HANDLE(srem_int,2)
-        return emit_srem(JL_INT(x), JL_INT(y), ctx);
-
-    HANDLE(urem_int,2)
-        den = JL_INT(y);
-        t = den->getType();
-        raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
-                               prepare_global(jldiverr_var), ctx);
-        return builder.CreateURem(JL_INT(x), den);
-
-    HANDLE(smod_int,2)
-        return emit_smod(JL_INT(x), JL_INT(y), ctx);
+    case neg_int:
+#ifdef LLVM37
+     return builder.CreateNeg(JL_INT(x));
+#else
+     return builder.CreateSub(ConstantInt::get(t, 0), JL_INT(x));
+#endif
+    case add_int: return builder.CreateAdd(JL_INT(x), JL_INT(y));
+    case sub_int: return builder.CreateSub(JL_INT(x), JL_INT(y));
+    case mul_int: return builder.CreateMul(JL_INT(x), JL_INT(y));
+    case sdiv_int: return builder.CreateSDiv(JL_INT(x), JL_INT(y));
+    case udiv_int: return builder.CreateUDiv(JL_INT(x), JL_INT(y));
+    case srem_int: return builder.CreateSRem(JL_INT(x), JL_INT(y));
+    case urem_int: return builder.CreateURem(JL_INT(x), JL_INT(y));
 
 // Implements IEEE negate. Unfortunately there is no compliant way
 // to implement this in LLVM 3.4, though there are two different idioms
 // that do the correct thing on LLVM <= 3.3 and >= 3.5 respectively.
 // See issue #7868
 #ifdef LLVM35
-    HANDLE(neg_float,1) return math_builder(ctx)().CreateFSub(ConstantFP::get(FT(t), -0.0), FP(x));
-    HANDLE(neg_float_fast,1) return math_builder(ctx, true)().CreateFNeg(FP(x));
+    case neg_float: return math_builder(ctx)().CreateFSub(ConstantFP::get(FT(t), -0.0), FP(x));
+    case neg_float_fast: return math_builder(ctx, true)().CreateFNeg(FP(x));
 #else
-    HANDLE(neg_float,1)
+    case neg_float:
         return math_builder(ctx)().CreateFMul(ConstantFP::get(FT(t), -1.0), FP(x));
-    HANDLE(neg_float_fast,1)
+    case neg_float_fast:
         return math_builder(ctx, true)().CreateFMul(ConstantFP::get(FT(t), -1.0), FP(x));
 #endif
-    HANDLE(add_float,2) return math_builder(ctx)().CreateFAdd(FP(x), FP(y));
-    HANDLE(sub_float,2) return math_builder(ctx)().CreateFSub(FP(x), FP(y));
-    HANDLE(mul_float,2) return math_builder(ctx)().CreateFMul(FP(x), FP(y));
-    HANDLE(div_float,2) return math_builder(ctx)().CreateFDiv(FP(x), FP(y));
-    HANDLE(rem_float,2) return math_builder(ctx)().CreateFRem(FP(x), FP(y));
-    HANDLE(add_float_fast,2) return math_builder(ctx, true)().CreateFAdd(FP(x), FP(y));
-    HANDLE(sub_float_fast,2) return math_builder(ctx, true)().CreateFSub(FP(x), FP(y));
-    HANDLE(mul_float_fast,2) return math_builder(ctx, true)().CreateFMul(FP(x), FP(y));
-    HANDLE(div_float_fast,2) return math_builder(ctx, true)().CreateFDiv(FP(x), FP(y));
-    HANDLE(rem_float_fast,2) return math_builder(ctx, true)().CreateFRem(FP(x), FP(y));
-    HANDLE(fma_float,3) {
+    case add_float: return math_builder(ctx)().CreateFAdd(FP(x), FP(y));
+    case sub_float: return math_builder(ctx)().CreateFSub(FP(x), FP(y));
+    case mul_float: return math_builder(ctx)().CreateFMul(FP(x), FP(y));
+    case div_float: return math_builder(ctx)().CreateFDiv(FP(x), FP(y));
+    case rem_float: return math_builder(ctx)().CreateFRem(FP(x), FP(y));
+    case add_float_fast: return math_builder(ctx, true)().CreateFAdd(FP(x), FP(y));
+    case sub_float_fast: return math_builder(ctx, true)().CreateFSub(FP(x), FP(y));
+    case mul_float_fast: return math_builder(ctx, true)().CreateFMul(FP(x), FP(y));
+    case div_float_fast: return math_builder(ctx, true)().CreateFDiv(FP(x), FP(y));
+    case rem_float_fast: return math_builder(ctx, true)().CreateFRem(FP(x), FP(y));
+    case fma_float: {
       assert(y->getType() == x->getType());
       assert(z->getType() == y->getType());
-      Value *fmaintr = Intrinsic::getDeclaration(jl_Module, Intrinsic::fma,
+      Value *fmaintr = Intrinsic::getDeclaration(builtins_module, Intrinsic::fma,
                                    ArrayRef<Type*>(x->getType()));
 #ifdef LLVM37
-      return builder.CreateCall(fmaintr,{ FP(x), FP(y), FP(z) });
+      return builder.CreateCall(prepare_call(fmaintr),{ FP(x), FP(y), FP(z) });
 #else
-      return builder.CreateCall3(fmaintr, FP(x), FP(y), FP(z));
+      return builder.CreateCall3(prepare_call(fmaintr), FP(x), FP(y), FP(z));
 #endif
     }
-    HANDLE(muladd_float,3)
+    case muladd_float:
 #ifdef LLVM34
     {
       assert(y->getType() == x->getType());
@@ -1112,8 +1175,8 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
 #else
       return builder.CreateCall3
 #endif
-        (Intrinsic::getDeclaration(jl_Module, Intrinsic::fmuladd,
-                                   ArrayRef<Type*>(x->getType())),
+        (prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::fmuladd,
+                                   ArrayRef<Type*>(x->getType()))),
          #ifdef LLVM37
          {FP(x), FP(y), FP(z)}
          #else
@@ -1126,39 +1189,74 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
         CreateFAdd(builder.CreateFMul(FP(x), FP(y)), FP(z));
 #endif
 
-    HANDLE(checked_sadd,2)
-    HANDLE(checked_uadd,2)
-    HANDLE(checked_ssub,2)
-    HANDLE(checked_usub,2)
-    HANDLE(checked_smul,2)
-    HANDLE(checked_umul,2) {
+    case checked_sadd_int:
+    case checked_uadd_int:
+    case checked_ssub_int:
+    case checked_usub_int:
+    case checked_smul_int:
+    case checked_umul_int: {
         Value *ix = JL_INT(x); Value *iy = JL_INT(y);
         assert(ix->getType() == iy->getType());
         Value *intr =
-            Intrinsic::getDeclaration(jl_Module,
-               f==checked_sadd ?
-               Intrinsic::sadd_with_overflow :
-               (f==checked_uadd ?
-                Intrinsic::uadd_with_overflow :
-                (f==checked_ssub ?
-                 Intrinsic::ssub_with_overflow :
-                 (f==checked_usub ?
-                  Intrinsic::usub_with_overflow :
-                  (f==checked_smul ?
-                   Intrinsic::smul_with_overflow :
-                   Intrinsic::umul_with_overflow)))),
-               ArrayRef<Type*>(ix->getType()));
+            Intrinsic::getDeclaration(builtins_module,
+                f==checked_sadd_int ?
+                Intrinsic::sadd_with_overflow :
+                (f==checked_uadd_int ?
+                 Intrinsic::uadd_with_overflow :
+                 (f==checked_ssub_int ?
+                  Intrinsic::ssub_with_overflow :
+                  (f==checked_usub_int ?
+                   Intrinsic::usub_with_overflow :
+                   (f==checked_smul_int ?
+                    Intrinsic::smul_with_overflow :
+                    Intrinsic::umul_with_overflow)))),
+                ArrayRef<Type*>(ix->getType()));
 #ifdef LLVM37
-        Value *res = builder.CreateCall(intr,{ix, iy});
+        Value *res = builder.CreateCall(prepare_call(intr),{ix, iy});
 #else
-        Value *res = builder.CreateCall2(intr, ix, iy);
+        Value *res = builder.CreateCall2(prepare_call(intr), ix, iy);
 #endif
         Value *obit = builder.CreateExtractValue(res, ArrayRef<unsigned>(1));
         raise_exception_if(obit, prepare_global(jlovferr_var), ctx);
         return builder.CreateExtractValue(res, ArrayRef<unsigned>(0));
     }
 
-    HANDLE(check_top_bit,1)
+    case checked_sdiv_int:
+        den = JL_INT(y);
+        t = den->getType();
+        x = JL_INT(x);
+
+        typemin = builder.CreateShl(ConstantInt::get(t,1),
+                                    x->getType()->getPrimitiveSizeInBits()-1);
+        raise_exception_unless(builder.
+                               CreateAnd(builder.
+                                         CreateICmpNE(den, ConstantInt::get(t,0)),
+                                         builder.
+                                         CreateOr(builder.
+                                                  CreateICmpNE(den,
+                                                               ConstantInt::get(t,-1,true)),
+                                                  builder.CreateICmpNE(x, typemin))),
+                               prepare_global(jldiverr_var), ctx);
+
+        return builder.CreateSDiv(x, den);
+    case checked_udiv_int:
+        den = JL_INT(y);
+        t = den->getType();
+        raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
+                               prepare_global(jldiverr_var), ctx);
+        return builder.CreateUDiv(JL_INT(x), den);
+
+    case checked_srem_int:
+        return emit_checked_srem_int(JL_INT(x), JL_INT(y), ctx);
+
+    case checked_urem_int:
+        den = JL_INT(y);
+        t = den->getType();
+        raise_exception_unless(builder.CreateICmpNE(den, ConstantInt::get(t,0)),
+                               prepare_global(jldiverr_var), ctx);
+        return builder.CreateURem(JL_INT(x), den);
+
+    case check_top_bit:
         // raise InexactError if argument's top bit is set
         x = JL_INT(x);
         raise_exception_if(builder.
@@ -1168,24 +1266,24 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
                            prepare_global(jlinexacterr_var), ctx);
         return x;
 
-    HANDLE(eq_int,2)  *newtyp = jl_bool_type; return builder.CreateICmpEQ(JL_INT(x), JL_INT(y));
-    HANDLE(ne_int,2)  *newtyp = jl_bool_type; return builder.CreateICmpNE(JL_INT(x), JL_INT(y));
-    HANDLE(slt_int,2) *newtyp = jl_bool_type; return builder.CreateICmpSLT(JL_INT(x), JL_INT(y));
-    HANDLE(ult_int,2) *newtyp = jl_bool_type; return builder.CreateICmpULT(JL_INT(x), JL_INT(y));
-    HANDLE(sle_int,2) *newtyp = jl_bool_type; return builder.CreateICmpSLE(JL_INT(x), JL_INT(y));
-    HANDLE(ule_int,2) *newtyp = jl_bool_type; return builder.CreateICmpULE(JL_INT(x), JL_INT(y));
+    case eq_int:  *newtyp = jl_bool_type; return builder.CreateICmpEQ(JL_INT(x), JL_INT(y));
+    case ne_int:  *newtyp = jl_bool_type; return builder.CreateICmpNE(JL_INT(x), JL_INT(y));
+    case slt_int: *newtyp = jl_bool_type; return builder.CreateICmpSLT(JL_INT(x), JL_INT(y));
+    case ult_int: *newtyp = jl_bool_type; return builder.CreateICmpULT(JL_INT(x), JL_INT(y));
+    case sle_int: *newtyp = jl_bool_type; return builder.CreateICmpSLE(JL_INT(x), JL_INT(y));
+    case ule_int: *newtyp = jl_bool_type; return builder.CreateICmpULE(JL_INT(x), JL_INT(y));
 
-    HANDLE(eq_float,2) *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOEQ(FP(x), FP(y));
-    HANDLE(ne_float,2) *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpUNE(FP(x), FP(y));
-    HANDLE(lt_float,2) *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOLT(FP(x), FP(y));
-    HANDLE(le_float,2) *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOLE(FP(x), FP(y));
+    case eq_float: *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOEQ(FP(x), FP(y));
+    case ne_float: *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpUNE(FP(x), FP(y));
+    case lt_float: *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOLT(FP(x), FP(y));
+    case le_float: *newtyp = jl_bool_type; return math_builder(ctx)().CreateFCmpOLE(FP(x), FP(y));
 
-    HANDLE(eq_float_fast,2) *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpOEQ(FP(x), FP(y));
-    HANDLE(ne_float_fast,2) *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpUNE(FP(x), FP(y));
-    HANDLE(lt_float_fast,2) *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpOLT(FP(x), FP(y));
-    HANDLE(le_float_fast,2) *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpOLE(FP(x), FP(y));
+    case eq_float_fast: *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpOEQ(FP(x), FP(y));
+    case ne_float_fast: *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpUNE(FP(x), FP(y));
+    case lt_float_fast: *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpOLT(FP(x), FP(y));
+    case le_float_fast: *newtyp = jl_bool_type; return math_builder(ctx, true)().CreateFCmpOLE(FP(x), FP(y));
 
-    HANDLE(fpiseq,2) {
+    case fpiseq: {
         *newtyp = jl_bool_type;
         Value *xi = JL_INT(x);
         Value *yi = JL_INT(y);
@@ -1196,7 +1294,7 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
                                 builder.CreateICmpEQ(xi, yi));
     }
 
-    HANDLE(fpislt,2) {
+    case fpislt: {
         *newtyp = jl_bool_type;
         Value *xi = JL_INT(x);
         Value *yi = JL_INT(y);
@@ -1223,11 +1321,11 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
         );
     }
 
-    HANDLE(and_int,2) return builder.CreateAnd(JL_INT(x), JL_INT(y));
-    HANDLE(or_int,2)  return builder.CreateOr(JL_INT(x), JL_INT(y));
-    HANDLE(xor_int,2) return builder.CreateXor(JL_INT(x), JL_INT(y));
-    HANDLE(not_int,1) return builder.CreateXor(JL_INT(x), ConstantInt::get(t, -1, true));
-    HANDLE(shl_int,2)
+    case and_int: return builder.CreateAnd(JL_INT(x), JL_INT(y));
+    case or_int:  return builder.CreateOr(JL_INT(x), JL_INT(y));
+    case xor_int: return builder.CreateXor(JL_INT(x), JL_INT(y));
+    case not_int: return builder.CreateXor(JL_INT(x), ConstantInt::get(t, -1, true));
+    case shl_int:
         x = JL_INT(x); y = JL_INT(y);
         return builder.
             CreateSelect(builder.
@@ -1235,7 +1333,7 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
                                                            x->getType()->getPrimitiveSizeInBits())),
                          ConstantInt::get(x->getType(),0),
                          builder.CreateShl(x, uint_cnvt(t,y)));
-    HANDLE(lshr_int,2)
+    case lshr_int:
         x = JL_INT(x); y = JL_INT(y);
         return builder.
             CreateSelect(builder.
@@ -1243,7 +1341,7 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
                                                            x->getType()->getPrimitiveSizeInBits())),
                          ConstantInt::get(x->getType(),0),
                          builder.CreateLShr(x, uint_cnvt(t,y)));
-    HANDLE(ashr_int,2)
+    case ashr_int:
         x = JL_INT(x); y = JL_INT(y);
         return builder.
             CreateSelect(builder.
@@ -1252,39 +1350,39 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
                          builder.CreateAShr(x, ConstantInt::get(x->getType(),
                                                                 x->getType()->getPrimitiveSizeInBits()-1)),
                          builder.CreateAShr(x, uint_cnvt(t,y)));
-    HANDLE(bswap_int,1)
+    case bswap_int:
         x = JL_INT(x);
-        return builder.CreateCall(
-            Intrinsic::getDeclaration(jl_Module, Intrinsic::bswap,
-                                      ArrayRef<Type*>(x->getType())), x);
-    HANDLE(ctpop_int,1)
+        return builder.CreateCall(prepare_call(
+            Intrinsic::getDeclaration(builtins_module, Intrinsic::bswap,
+                                      ArrayRef<Type*>(x->getType()))), x);
+    case ctpop_int:
         x = JL_INT(x);
-        return builder.CreateCall(
-            Intrinsic::getDeclaration(jl_Module, Intrinsic::ctpop,
-                                      ArrayRef<Type*>(x->getType())), x);
-    HANDLE(ctlz_int,1) {
+        return builder.CreateCall(prepare_call(
+            Intrinsic::getDeclaration(builtins_module, Intrinsic::ctpop,
+                                      ArrayRef<Type*>(x->getType()))), x);
+    case ctlz_int: {
         x = JL_INT(x);
         Type *types[1] = {x->getType()};
-        Value *ctlz = Intrinsic::getDeclaration(jl_Module, Intrinsic::ctlz,
+        Value *ctlz = Intrinsic::getDeclaration(builtins_module, Intrinsic::ctlz,
                                       ArrayRef<Type*>(types));
 #ifdef LLVM37
-        return builder.CreateCall(ctlz, {x, ConstantInt::get(T_int1,0)});
+        return builder.CreateCall(prepare_call(ctlz), {x, ConstantInt::get(T_int1,0)});
 #else
-        return builder.CreateCall2(ctlz, x, ConstantInt::get(T_int1,0));
+        return builder.CreateCall2(prepare_call(ctlz), x, ConstantInt::get(T_int1,0));
 #endif
     }
-    HANDLE(cttz_int,1) {
+    case cttz_int: {
         x = JL_INT(x);
         Type *types[1] = {x->getType()};
-        Value *cttz = Intrinsic::getDeclaration(jl_Module, Intrinsic::cttz, ArrayRef<Type*>(types));
+        Value *cttz = Intrinsic::getDeclaration(builtins_module, Intrinsic::cttz, ArrayRef<Type*>(types));
 #ifdef LLVM37
-        return builder.CreateCall(cttz, {x, ConstantInt::get(T_int1, 0)});
+        return builder.CreateCall(prepare_call(cttz), {x, ConstantInt::get(T_int1, 0)});
 #else
-        return builder.CreateCall2(cttz, x, ConstantInt::get(T_int1, 0));
+        return builder.CreateCall2(prepare_call(cttz), x, ConstantInt::get(T_int1, 0));
 #endif
     }
 
-    HANDLE(nan_dom_err,2) {
+    case nan_dom_err: {
         // nan_dom_err(f, x) throw DomainError if isnan(f)&&!isnan(x)
         Value *f = FP(x); x = FP(y);
         raise_exception_unless(builder.CreateOr(builder.CreateFCmpORD(f,f),
@@ -1293,12 +1391,13 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
         return f;
     }
 
-    HANDLE(abs_float,1)
+    case abs_float:
     {
         x = FP(x);
 #ifdef LLVM34
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::fabs,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(
+            Intrinsic::getDeclaration(builtins_module, Intrinsic::fabs,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
 #else
         Type *intt = JL_INTT(x->getType());
@@ -1309,7 +1408,7 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
         return builder.CreateBitCast(absbits, x->getType());
 #endif
     }
-    HANDLE(copysign_float,2)
+    case copysign_float:
     {
         x = FP(x);
         fy = FP(y);
@@ -1328,7 +1427,7 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
                                                                 signbit0)));
         return builder.CreateBitCast(rbits, x->getType());
     }
-    HANDLE(flipsign_int,2)
+    case flipsign_int:
     {
         x = JL_INT(x);
         fy = JL_INT(y);
@@ -1347,71 +1446,64 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
         Value *tmp = builder.CreateAShr(fy, ConstantInt::get(intt,((IntegerType*)intt)->getBitWidth()-1));
         return builder.CreateXor(builder.CreateAdd(x,tmp),tmp);
     }
-    HANDLE(jl_alloca,1) {
-        *newtyp = jl_voidpointer_type;
-        AllocaInst *AI = builder.CreateAlloca(T_int8, JL_INT(x));
-        AI->setAlignment(16);
-        return AI;
-    }
-    HANDLE(ceil_llvm,1) {
+    case ceil_llvm: {
         x = FP(x);
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::ceil,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::ceil,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
     }
-    HANDLE(floor_llvm,1) {
+    case floor_llvm: {
         x = FP(x);
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::floor,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::floor,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
     }
-    HANDLE(trunc_llvm,1) {
+    case trunc_llvm: {
         x = FP(x);
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::trunc,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::trunc,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
     }
-    HANDLE(rint_llvm,1) {
+    case rint_llvm: {
         x = FP(x);
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::rint,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::rint,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
     }
-    HANDLE(sqrt_llvm,1) {
+    case sqrt_llvm: {
         x = FP(x);
         raise_exception_unless(builder.CreateFCmpUGE(x, ConstantFP::get(x->getType(),0.0)),
                                prepare_global(jldomerr_var), ctx);
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::sqrt,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
     }
-    HANDLE(powi_llvm,2) {
+    case powi_llvm: {
         x = FP(x);
         y = JL_INT(y);
-        Type *tx = x->getType();
+        Type *tx = x->getType(); // TODO: LLVM expects this to be i32
 #ifdef LLVM36
         Type *ts[1] = { tx };
-        Value *powi = Intrinsic::getDeclaration(jl_Module, Intrinsic::powi,
+        Value *powi = Intrinsic::getDeclaration(builtins_module, Intrinsic::powi,
             ArrayRef<Type*>(ts));
 #ifdef LLVM37
-        return builder.CreateCall(powi, {x, y});
+        return builder.CreateCall(prepare_call(powi), {x, y});
 #else
-        return builder.CreateCall2(powi, x, y);
+        return builder.CreateCall2(prepare_call(powi), x, y);
 #endif
 #else
         // issue #6506
-        Type *ts[2] = { tx, tx };
-        Value *pow = jl_Module->getOrInsertFunction(
-            tx==T_float64 ? "pow" : "powf", FunctionType::get(tx, ts, false));
-        return builder.CreateCall2(pow, x, builder.CreateSIToFP(y, tx));
+        return builder.CreateCall2(prepare_call(tx == T_float64 ? jlpow_func : jlpowf_func),
+                x, builder.CreateSIToFP(y, tx));
 #endif
     }
-    HANDLE(sqrt_llvm_fast,1) {
+    case sqrt_llvm_fast: {
         x = FP(x);
-        return builder.CreateCall(Intrinsic::getDeclaration(jl_Module, Intrinsic::sqrt,
-                                                            ArrayRef<Type*>(x->getType())),
+        return builder.CreateCall(prepare_call(Intrinsic::getDeclaration(builtins_module, Intrinsic::sqrt,
+                                                            ArrayRef<Type*>(x->getType()))),
                                   x);
     }
+
     default:
         assert(false);
     }
@@ -1419,10 +1511,16 @@ static Value *emit_untyped_intrinsic(intrinsic f, Value *x, Value *y, Value *z,
     return NULL;
 }
 
-#undef HANDLE
+#define BOX_F(ct,jl_ct)                                                 \
+    box_##ct##_func = boxfunc_llvm(ft1arg(T_pjlvalue, T_##jl_ct),       \
+                                   "jl_box_"#ct, &jl_box_##ct, m);
 
+#define SBOX_F(ct,jl_ct) BOX_F(ct,jl_ct); box_##ct##_func->addAttribute(1, Attribute::SExt);
+#define UBOX_F(ct,jl_ct) BOX_F(ct,jl_ct); box_##ct##_func->addAttribute(1, Attribute::ZExt);
+
+template<typename T>
 static Function *boxfunc_llvm(FunctionType *ft, const std::string &cname,
-                              void *addr, Module *m)
+                              T *addr, Module *m)
 {
     Function *f =
         Function::Create(ft, Function::ExternalLinkage, cname, m);
@@ -1444,67 +1542,3 @@ static FunctionType *ft2arg(Type *ret, Type *arg1, Type *arg2)
     args2.push_back(arg2);
     return FunctionType::get(ret, args2, false);
 }
-
-#define BOX_F(ct,jl_ct)                                                    \
-    box_##ct##_func = boxfunc_llvm(ft1arg(jl_pvalue_llvmt, T_##jl_ct),     \
-                                   "jl_box_"#ct, (void*)&jl_box_##ct, m);
-
-#define SBOX_F(ct,jl_ct) BOX_F(ct,jl_ct); box_##ct##_func->addAttribute(1, Attribute::SExt);
-#define UBOX_F(ct,jl_ct) BOX_F(ct,jl_ct); box_##ct##_func->addAttribute(1, Attribute::ZExt);
-
-static void add_intrinsic(jl_module_t *m, const std::string &name, intrinsic f)
-{
-    jl_value_t *i = jl_box32(jl_intrinsic_type, (int32_t)f);
-    jl_sym_t *sym = jl_symbol(const_cast<char*>(name.c_str()));
-    jl_set_const(m, sym, i);
-    jl_module_export(m, sym);
-}
-
-#define ADD_I(name) add_intrinsic(inm, #name, name)
-
-extern "C" void jl_init_intrinsic_functions(void)
-{
-    jl_module_t *inm = jl_new_module(jl_symbol("Intrinsics"));
-    inm->parent = jl_core_module;
-    jl_set_const(jl_core_module, jl_symbol("Intrinsics"), (jl_value_t*)inm);
-    ADD_I(box); ADD_I(unbox);
-    ADD_I(neg_int); ADD_I(add_int); ADD_I(sub_int); ADD_I(mul_int);
-    ADD_I(sdiv_int); ADD_I(udiv_int); ADD_I(srem_int); ADD_I(urem_int);
-    ADD_I(smod_int);
-    ADD_I(neg_float); ADD_I(add_float); ADD_I(sub_float); ADD_I(mul_float);
-    ADD_I(div_float); ADD_I(rem_float); ADD_I(fma_float); ADD_I(muladd_float);
-    ADD_I(neg_float_fast); ADD_I(add_float_fast); ADD_I(sub_float_fast);
-    ADD_I(mul_float_fast); ADD_I(div_float_fast); ADD_I(rem_float_fast);
-    ADD_I(eq_int); ADD_I(ne_int);
-    ADD_I(slt_int); ADD_I(ult_int);
-    ADD_I(sle_int); ADD_I(ule_int);
-    ADD_I(eq_float); ADD_I(ne_float);
-    ADD_I(lt_float); ADD_I(le_float);
-    ADD_I(eq_float_fast); ADD_I(ne_float_fast);
-    ADD_I(lt_float_fast); ADD_I(le_float_fast);
-    ADD_I(fpiseq); ADD_I(fpislt);
-    ADD_I(and_int); ADD_I(or_int); ADD_I(xor_int); ADD_I(not_int);
-    ADD_I(shl_int); ADD_I(lshr_int); ADD_I(ashr_int); ADD_I(bswap_int);
-    ADD_I(ctpop_int); ADD_I(ctlz_int); ADD_I(cttz_int);
-    ADD_I(sext_int); ADD_I(zext_int); ADD_I(trunc_int);
-    ADD_I(fptoui); ADD_I(fptosi);
-    ADD_I(uitofp); ADD_I(sitofp);
-    ADD_I(fptrunc); ADD_I(fpext);
-    ADD_I(abs_float); ADD_I(copysign_float);
-    ADD_I(flipsign_int); ADD_I(select_value);
-    ADD_I(ceil_llvm); ADD_I(floor_llvm); ADD_I(trunc_llvm); ADD_I(rint_llvm);
-    ADD_I(sqrt_llvm); ADD_I(powi_llvm);
-    ADD_I(sqrt_llvm_fast);
-    ADD_I(pointerref); ADD_I(pointerset);
-    ADD_I(checked_sadd); ADD_I(checked_uadd);
-    ADD_I(checked_ssub); ADD_I(checked_usub);
-    ADD_I(checked_smul); ADD_I(checked_umul);
-    ADD_I(checked_fptosi); ADD_I(checked_fptoui);
-    ADD_I(checked_trunc_sint);
-    ADD_I(checked_trunc_uint);
-    ADD_I(check_top_bit);
-    ADD_I(nan_dom_err);
-    ADD_I(ccall); ADD_I(cglobal);
-    ADD_I(jl_alloca);
-    ADD_I(llvmcall);
-}
diff --git a/src/intrinsics.h b/src/intrinsics.h
new file mode 100644
index 0000000000000..523929a7ae7ea
--- /dev/null
+++ b/src/intrinsics.h
@@ -0,0 +1,217 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#define INTRINSICS \
+    /*  wrap and unwrap */ \
+    ALIAS(box, reinterpret) \
+    ALIAS(unbox, reinterpret) \
+    /*  arithmetic */ \
+    ADD_I(neg_int, 1) \
+    ADD_I(add_int, 2) \
+    ADD_I(sub_int, 2) \
+    ADD_I(mul_int, 2) \
+    ADD_I(sdiv_int, 2) \
+    ADD_I(udiv_int, 2) \
+    ADD_I(srem_int, 2) \
+    ADD_I(urem_int, 2) \
+    ADD_I(neg_float, 1) \
+    ADD_I(add_float, 2) \
+    ADD_I(sub_float, 2) \
+    ADD_I(mul_float, 2) \
+    ADD_I(div_float, 2) \
+    ADD_I(rem_float, 2) \
+    ADD_I(fma_float, 3) \
+    ADD_I(muladd_float, 3) \
+    /*  fast arithmetic */ \
+    ALIAS(neg_float_fast, neg_float) \
+    ALIAS(add_float_fast, add_float) \
+    ALIAS(sub_float_fast, sub_float) \
+    ALIAS(mul_float_fast, mul_float) \
+    ALIAS(div_float_fast, div_float) \
+    ALIAS(rem_float_fast, rem_float) \
+    /*  same-type comparisons */ \
+    ADD_I(eq_int, 2) \
+    ADD_I(ne_int, 2) \
+    ADD_I(slt_int, 2) \
+    ADD_I(ult_int, 2) \
+    ADD_I(sle_int, 2) \
+    ADD_I(ule_int, 2) \
+    ADD_I(eq_float, 2) \
+    ADD_I(ne_float, 2) \
+    ADD_I(lt_float, 2) \
+    ADD_I(le_float, 2) \
+    ALIAS(eq_float_fast, eq_float) \
+    ALIAS(ne_float_fast, ne_float) \
+    ALIAS(lt_float_fast, lt_float) \
+    ALIAS(le_float_fast, le_float) \
+    ADD_I(fpiseq, 2) \
+    ADD_I(fpislt, 2) \
+    /*  bitwise operators */ \
+    ADD_I(and_int, 2) \
+    ADD_I(or_int, 2) \
+    ADD_I(xor_int, 2) \
+    ADD_I(not_int, 1) \
+    ADD_I(shl_int, 2) \
+    ADD_I(lshr_int, 2) \
+    ADD_I(ashr_int, 2) \
+    ADD_I(bswap_int, 1) \
+    ADD_I(ctpop_int, 1) \
+    ADD_I(ctlz_int, 1) \
+    ADD_I(cttz_int, 1) \
+    /*  conversion */ \
+    ADD_I(sext_int, 2) \
+    ADD_I(zext_int, 2) \
+    ADD_I(trunc_int, 2) \
+    ADD_I(fptoui, 2) \
+    ADD_I(fptosi, 2) \
+    ADD_I(uitofp, 2) \
+    ADD_I(sitofp, 2) \
+    ADD_I(fptrunc, 2) \
+    ADD_I(fpext, 2) \
+    /*  checked conversion */ \
+    ADD_I(checked_fptosi, 2) \
+    ADD_I(checked_fptoui, 2) \
+    ADD_I(checked_trunc_sint, 2) \
+    ADD_I(checked_trunc_uint, 2) \
+    ADD_I(check_top_bit, 1) \
+    /*  checked arithmetic */ \
+    ADD_I(checked_sadd_int, 2) \
+    ADD_I(checked_uadd_int, 2) \
+    ADD_I(checked_ssub_int, 2) \
+    ADD_I(checked_usub_int, 2) \
+    ADD_I(checked_smul_int, 2) \
+    ADD_I(checked_umul_int, 2) \
+    ADD_I(checked_sdiv_int, 2) \
+    ADD_I(checked_udiv_int, 2) \
+    ADD_I(checked_srem_int, 2) \
+    ADD_I(checked_urem_int, 2) \
+    ADD_I(nan_dom_err, 2) \
+    /*  functions */ \
+    ADD_I(abs_float, 1) \
+    ADD_I(copysign_float, 2) \
+    ADD_I(flipsign_int, 2) \
+    ADD_I(select_value, 3) \
+    ADD_I(ceil_llvm, 1) \
+    ADD_I(floor_llvm, 1) \
+    ADD_I(trunc_llvm, 1) \
+    ADD_I(rint_llvm, 1) \
+    ADD_I(sqrt_llvm, 1) \
+    ADD_I(powi_llvm, 2) \
+    ALIAS(sqrt_llvm_fast, sqrt_llvm) \
+    /*  pointer access */ \
+    ADD_I(pointerref, 2) \
+    ADD_I(pointerset, 3) \
+    /* c interface */ \
+    ALIAS(ccall, ccall) \
+    ALIAS(cglobal, cglobal) \
+    ALIAS(llvmcall, llvmcall) \
+    /* object access */ \
+    ADD_I(arraylen, 1) \
+    /*  hidden intrinsics */ \
+    ADD_HIDDEN(fptoui_auto, 1) \
+    ADD_HIDDEN(fptosi_auto, 1)
+
+enum intrinsic {
+#define ADD_I(func, nargs) func,
+#define ADD_HIDDEN ADD_I
+#define ALIAS ADD_I
+    INTRINSICS
+#undef ADD_I
+#undef ADD_HIDDEN
+#undef ALIAS
+    num_intrinsics,
+    reinterpret = box
+};
+
+#ifdef __cplusplus
+extern "C"
+#endif
+const char *jl_intrinsic_name(int f)
+{
+    switch ((enum intrinsic)f) {
+    default: return "invalid";
+#define ADD_I(func, nargs) case func: return #func;
+#define ADD_HIDDEN ADD_I
+#define ALIAS ADD_I
+    INTRINSICS
+#undef ADD_I
+#undef ADD_HIDDEN
+#undef ALIAS
+    }
+}
+
+static void (*runtime_fp[num_intrinsics])(void);
+static unsigned intrinsic_nargs[num_intrinsics];
+
+typedef jl_value_t *(*intrinsic_call_1_arg)(jl_value_t*);
+typedef jl_value_t *(*intrinsic_call_2_arg)(jl_value_t*, jl_value_t*);
+typedef jl_value_t *(*intrinsic_call_3_arg)(jl_value_t*, jl_value_t*, jl_value_t*);
+#define jl_is_intrinsic(v)       jl_typeis(v,jl_intrinsic_type)
+
+#ifdef __cplusplus
+extern "C"
+#endif
+JL_CALLABLE(jl_f_intrinsic_call)
+{
+    JL_NARGSV(intrinsic_call, 1);
+    JL_TYPECHK(intrinsic_call, intrinsic, args[0]);
+    enum intrinsic f = (enum intrinsic)*(uint32_t*)jl_data_ptr(args[0]);
+    if (f == fptoui && nargs == 1)
+        f = fptoui_auto;
+    if (f == fptosi && nargs == 1)
+        f = fptosi_auto;
+    unsigned fargs = intrinsic_nargs[f];
+    JL_NARGS(intrinsic_call, 1 + fargs, 1 + fargs);
+    switch (fargs) {
+        case 1:
+            return ((intrinsic_call_1_arg)runtime_fp[f])(args[1]);
+        case 2:
+            return ((intrinsic_call_2_arg)runtime_fp[f])(args[1], args[2]);
+        case 3:
+            return ((intrinsic_call_3_arg)runtime_fp[f])(args[1], args[2], args[3]);
+        default:
+            assert(0 && "unexpected number of arguments to an intrinsic function");
+    }
+    gc_debug_critical_error();
+    abort();
+}
+
+static void add_intrinsic_properties(enum intrinsic f, unsigned nargs, void (*pfunc)(void))
+{
+    intrinsic_nargs[f] = nargs;
+    runtime_fp[f] = pfunc;
+}
+
+static void add_intrinsic(jl_module_t *inm, const char *name, enum intrinsic f)
+{
+    jl_value_t *i = jl_box32(jl_intrinsic_type, (int32_t)f);
+    jl_sym_t *sym = jl_symbol(name);
+    jl_set_const(inm, sym, i);
+    jl_module_export(inm, sym);
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+jl_value_t *jl_mk_builtin_func(const char *name, jl_fptr_t fptr);
+
+#ifdef __cplusplus
+extern "C"
+#endif
+void jl_init_intrinsic_functions()
+{
+    jl_module_t *inm = jl_new_module(jl_symbol("Intrinsics"));
+    inm->parent = jl_core_module;
+    jl_set_const(jl_core_module, jl_symbol("Intrinsics"), (jl_value_t*)inm);
+
+#define ADD_I(name, nargs) add_intrinsic(inm, #name, name); add_intrinsic_properties(name, nargs, (void(*)(void))&jl_##name);
+#define ADD_HIDDEN(name, nargs) add_intrinsic_properties(name, nargs, (void(*)(void))&jl_##name);
+#define ALIAS(alias, base) add_intrinsic(inm, #alias, alias); add_intrinsic_properties(alias, intrinsic_nargs[base], runtime_fp[base]);
+    ADD_HIDDEN(reinterpret, 2);
+    INTRINSICS
+#undef ADD_I
+#undef ADD_HIDDEN
+#undef ALIAS
+
+    jl_set_const(inm, jl_symbol("intrinsic_call"),
+                 jl_mk_builtin_func("intrinsic_call", jl_f_intrinsic_call));
+}
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
new file mode 100644
index 0000000000000..42331e0d6ae77
--- /dev/null
+++ b/src/jitlayers.cpp
@@ -0,0 +1,420 @@
+// This file is part of Julia.
+// Parts of this file are copied from LLVM, under the UIUC license.
+
+template <class T>
+static void addOptimizationPasses(T *PM)
+{
+#ifdef __has_feature
+#   if __has_feature(address_sanitizer)
+#   if defined(LLVM37) && !defined(LLVM38)
+    // LLVM 3.7 BUG: ASAN pass doesn't properly initialize its dependencies
+    initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
+#   endif
+    PM->add(createAddressSanitizerFunctionPass());
+#   endif
+#   if __has_feature(memory_sanitizer)
+    PM->add(llvm::createMemorySanitizerPass(true));
+#   endif
+#endif
+    if (jl_options.opt_level <= 1) {
+        return;
+    }
+#ifdef LLVM37
+    PM->add(createTargetTransformInfoWrapperPass(jl_TargetMachine->getTargetIRAnalysis()));
+#else
+    jl_TargetMachine->addAnalysisPasses(*PM);
+#endif
+#ifdef LLVM38
+    PM->add(createTypeBasedAAWrapperPass());
+#else
+    PM->add(createTypeBasedAliasAnalysisPass());
+#endif
+    if (jl_options.opt_level >= 3) {
+#ifdef LLVM38
+        PM->add(createBasicAAWrapperPass());
+#else
+        PM->add(createBasicAliasAnalysisPass());
+#endif
+    }
+    // list of passes from vmkit
+    PM->add(createCFGSimplificationPass()); // Clean up disgusting code
+    PM->add(createPromoteMemoryToRegisterPass());// Kill useless allocas
+
+#ifndef INSTCOMBINE_BUG
+    PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
+#endif
+    PM->add(createSROAPass());                 // Break up aggregate allocas
+#ifndef INSTCOMBINE_BUG
+    PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
+#endif
+    PM->add(createJumpThreadingPass());        // Thread jumps.
+    // NOTE: CFG simp passes after this point seem to hurt native codegen.
+    // See issue #6112. Should be re-evaluated when we switch to MCJIT.
+    //PM->add(createCFGSimplificationPass());    // Merge & remove BBs
+#ifndef INSTCOMBINE_BUG
+    PM->add(createInstructionCombiningPass()); // Combine silly seq's
+#endif
+
+    //PM->add(createCFGSimplificationPass());    // Merge & remove BBs
+    PM->add(createReassociatePass());          // Reassociate expressions
+
+    // this has the potential to make some things a bit slower
+    //PM->add(createBBVectorizePass());
+
+    PM->add(createEarlyCSEPass()); //// ****
+
+    PM->add(createLoopIdiomPass()); //// ****
+    PM->add(createLoopRotatePass());           // Rotate loops.
+    // LoopRotate strips metadata from terminator, so run LowerSIMD afterwards
+    PM->add(createLowerSimdLoopPass());        // Annotate loop marked with "simdloop" as LLVM parallel loop
+    PM->add(createLICMPass());                 // Hoist loop invariants
+    PM->add(createLoopUnswitchPass());         // Unswitch loops.
+    // Subsequent passes not stripping metadata from terminator
+#ifndef INSTCOMBINE_BUG
+    PM->add(createInstructionCombiningPass());
+#endif
+    PM->add(createIndVarSimplifyPass());       // Canonicalize indvars
+    PM->add(createLoopDeletionPass());         // Delete dead loops
+#if defined(LLVM35)
+    PM->add(createSimpleLoopUnrollPass());     // Unroll small loops
+#else
+    PM->add(createLoopUnrollPass());           // Unroll small loops
+#endif
+#if !defined(LLVM35) && !defined(INSTCOMBINE_BUG)
+    PM->add(createLoopVectorizePass());        // Vectorize loops
+#endif
+    //PM->add(createLoopStrengthReducePass());   // (jwb added)
+
+#ifndef INSTCOMBINE_BUG
+    PM->add(createInstructionCombiningPass()); // Clean up after the unroller
+#endif
+    PM->add(createGVNPass());                  // Remove redundancies
+    //PM->add(createMemCpyOptPass());            // Remove memcpy / form memset
+    PM->add(createSCCPPass());                 // Constant prop with SCCP
+
+    // Run instcombine after redundancy elimination to exploit opportunities
+    // opened up by them.
+    PM->add(createSinkingPass()); ////////////// ****
+    PM->add(createInstructionSimplifierPass());///////// ****
+#ifndef INSTCOMBINE_BUG
+    PM->add(createInstructionCombiningPass());
+#endif
+    PM->add(createJumpThreadingPass());         // Thread jumps
+    PM->add(createDeadStoreEliminationPass());  // Delete dead stores
+#if !defined(INSTCOMBINE_BUG)
+    if (jl_options.opt_level >= 3)
+        PM->add(createSLPVectorizerPass());     // Vectorize straight-line code
+#endif
+
+    PM->add(createAggressiveDCEPass());         // Delete dead instructions
+#if !defined(INSTCOMBINE_BUG)
+    if (jl_options.opt_level >= 3)
+        PM->add(createInstructionCombiningPass());   // Clean up after SLP loop vectorizer
+#endif
+#if defined(LLVM35)
+    PM->add(createLoopVectorizePass());         // Vectorize loops
+    PM->add(createInstructionCombiningPass());  // Clean up after loop vectorizer
+#endif
+    //PM->add(createCFGSimplificationPass());     // Merge & remove BBs
+}
+
+#ifdef USE_ORCJIT
+
+// ------------------------ TEMPORARILY COPIED FROM LLVM -----------------
+// This must be kept in sync with gdb/gdb/jit.h .
+extern "C" {
+
+  typedef enum {
+    JIT_NOACTION = 0,
+    JIT_REGISTER_FN,
+    JIT_UNREGISTER_FN
+  } jit_actions_t;
+
+  struct jit_code_entry {
+    struct jit_code_entry *next_entry;
+    struct jit_code_entry *prev_entry;
+    const char *symfile_addr;
+    uint64_t symfile_size;
+  };
+
+  struct jit_descriptor {
+    uint32_t version;
+    // This should be jit_actions_t, but we want to be specific about the
+    // bit-width.
+    uint32_t action_flag;
+    struct jit_code_entry *relevant_entry;
+    struct jit_code_entry *first_entry;
+  };
+
+  // We put information about the JITed function in this global, which the
+  // debugger reads.  Make sure to specify the version statically, because the
+  // debugger checks the version before we can set it during runtime.
+  extern struct jit_descriptor __jit_debug_descriptor;
+
+  LLVM_ATTRIBUTE_NOINLINE extern void __jit_debug_register_code();
+}
+
+extern JL_DLLEXPORT void ORCNotifyObjectEmitted(JITEventListener *Listener,
+                                      const object::ObjectFile &obj,
+                                      const object::ObjectFile &debugObj,
+                                      const RuntimeDyld::LoadedObjectInfo &L);
+
+#if defined(_OS_DARWIN_) && defined(LLVM37) && defined(LLVM_SHLIB)
+#define CUSTOM_MEMORY_MANAGER createRTDyldMemoryManagerOSX
+extern RTDyldMemoryManager *createRTDyldMemoryManagerOSX();
+#elif defined(_OS_LINUX_) && defined(LLVM37) && defined(JL_UNW_HAS_FORMAT_IP)
+#define CUSTOM_MEMORY_MANAGER createRTDyldMemoryManagerUnix
+extern RTDyldMemoryManager *createRTDyldMemoryManagerUnix();
+#endif
+
+namespace {
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::orc;
+
+/// Do the registration.
+void NotifyDebugger(jit_code_entry *JITCodeEntry)
+{
+    __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
+
+    // Insert this entry at the head of the list.
+    JITCodeEntry->prev_entry = nullptr;
+    jit_code_entry *NextEntry = __jit_debug_descriptor.first_entry;
+    JITCodeEntry->next_entry = NextEntry;
+    if (NextEntry) {
+        NextEntry->prev_entry = JITCodeEntry;
+    }
+    __jit_debug_descriptor.first_entry = JITCodeEntry;
+    __jit_debug_descriptor.relevant_entry = JITCodeEntry;
+    __jit_debug_register_code();
+}
+
+// --------------------------------------------------------------------------
+
+class DebugObjectRegistrar {
+private:
+    void NotifyGDB(OwningBinary<ObjectFile> &DebugObj)
+    {
+      const char *Buffer = DebugObj.getBinary()->getMemoryBufferRef().getBufferStart();
+      size_t      Size = DebugObj.getBinary()->getMemoryBufferRef().getBufferSize();
+
+      assert(Buffer && "Attempt to register a null object with a debugger.");
+      jit_code_entry *JITCodeEntry = new jit_code_entry();
+
+      if (!JITCodeEntry) {
+          jl_printf(JL_STDERR, "WARNING: Allocation failed when registering a JIT entry!\n");
+      }
+      else {
+          JITCodeEntry->symfile_addr = Buffer;
+          JITCodeEntry->symfile_size = Size;
+
+          NotifyDebugger(JITCodeEntry);
+      }
+    }
+
+    std::vector<OwningBinary<ObjectFile>> SavedObjects;
+    std::unique_ptr<JITEventListener> JuliaListener;
+
+public:
+    DebugObjectRegistrar() : JuliaListener(CreateJuliaJITEventListener()) {}
+
+    template <typename ObjSetT, typename LoadResult>
+    void operator()(ObjectLinkingLayerBase::ObjSetHandleT, const ObjSetT &Objects,
+                    const LoadResult &LOS)
+    {
+        auto oit = Objects.begin();
+        auto lit = LOS.begin();
+        while (oit != Objects.end()) {
+#ifdef LLVM39
+            const auto &Object = (*oit)->getBinary();
+#else
+            auto &Object = *oit;
+#endif
+            auto &LO = *lit;
+
+            OwningBinary<ObjectFile> SavedObject = LO->getObjectForDebug(*Object);
+
+            // If the debug object is unavailable, save (a copy of) the original object
+            // for our backtraces
+            if (!SavedObject.getBinary()) {
+                // This is unfortunate, but there doesn't seem to be a way to take
+                // ownership of the original buffer
+                auto NewBuffer = MemoryBuffer::getMemBufferCopy(Object->getData(), Object->getFileName());
+                auto NewObj = ObjectFile::createObjectFile(NewBuffer->getMemBufferRef());
+                SavedObject = OwningBinary<ObjectFile>(std::move(*NewObj),std::move(NewBuffer));
+            }
+            else {
+                NotifyGDB(SavedObject);
+            }
+
+            SavedObjects.push_back(std::move(SavedObject));
+            ORCNotifyObjectEmitted(JuliaListener.get(),*Object,*SavedObjects.back().getBinary(),*LO);
+
+            ++oit;
+            ++lit;
+        }
+    }
+};
+
+class JuliaOJIT {
+public:
+    typedef orc::ObjectLinkingLayer<DebugObjectRegistrar> ObjLayerT;
+    typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
+    typedef CompileLayerT::ModuleSetHandleT ModuleHandleT;
+    typedef StringMap<void*> GlobalSymbolTableT;
+    typedef object::OwningBinary<object::ObjectFile> OwningObj;
+
+    JuliaOJIT(TargetMachine &TM)
+      : TM(TM),
+        DL(TM.createDataLayout()),
+        ObjStream(ObjBufferSV),
+        MemMgr(
+#ifdef CUSTOM_MEMORY_MANAGER
+            CUSTOM_MEMORY_MANAGER()
+#else
+            new SectionMemoryManager
+#endif
+            ) {
+#ifdef JL_DEBUG_BUILD
+            PM.add(createVerifierPass());
+#endif
+            addOptimizationPasses(&PM);
+            if (TM.addPassesToEmitMC(PM, Ctx, ObjStream))
+                llvm_unreachable("Target does not support MC emission.");
+
+            CompileLayer = std::unique_ptr<CompileLayerT>{new CompileLayerT(ObjectLayer,
+                [&](Module &M) {
+                    PM.run(M);
+                    std::unique_ptr<MemoryBuffer> ObjBuffer(
+                        new ObjectMemoryBuffer(std::move(ObjBufferSV)));
+                    ErrorOr<std::unique_ptr<object::ObjectFile>> Obj =
+                        object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef());
+
+                    if (!Obj) {
+                        M.dump();
+                        llvm::report_fatal_error("FATAL: Unable to compile LLVM Module.\n"
+                            "The module's content was printed above. Please file a bug report");
+                    }
+
+                    return OwningObj(std::move(*Obj), std::move(ObjBuffer));
+                }
+            )};
+            // Make sure SectionMemoryManager::getSymbolAddressInProcess can resolve
+            // symbols in the program as well. The nullptr argument to the function
+            // tells DynamicLibrary to load the program, not a library.
+
+            std::string *ErrorStr = nullptr;
+            if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr, ErrorStr))
+                report_fatal_error("FATAL: unable to dlopen self\n" + *ErrorStr);
+        }
+
+    std::string mangle(const std::string &Name)
+    {
+        std::string MangledName;
+        {
+            raw_string_ostream MangledNameStream(MangledName);
+            Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
+        }
+        return MangledName;
+    }
+
+    void addGlobalMapping(StringRef Name, void *Addr)
+    {
+       GlobalSymbolTable[mangle(Name)] = Addr;
+    }
+
+    ModuleHandleT addModule(Module *M)
+    {
+        // We need a memory manager to allocate memory and resolve symbols for this
+        // new module. Create one that resolves symbols by looking back into the
+        // JIT.
+        auto Resolver = orc::createLambdaResolver(
+                          [&](const std::string &Name) {
+                            // TODO: consider moving the FunctionMover resolver here
+                            // Step 0: ObjectLinkingLayer has checked whether it is in the current module
+                            // Step 1: See if it's something known to the ExecutionEngine
+                            if (auto Sym = findSymbol(Name, true))
+                              return RuntimeDyld::SymbolInfo(Sym.getAddress(),
+                                                             Sym.getFlags());
+                            // Step 2: Search the program symbols
+                            if (uint64_t addr = SectionMemoryManager::getSymbolAddressInProcess(Name))
+                                return RuntimeDyld::SymbolInfo(addr, JITSymbolFlags::Exported);
+                            // Return failure code
+                            return RuntimeDyld::SymbolInfo(nullptr);
+                          },
+                          [](const std::string &S) { return nullptr; }
+                        );
+        SmallVector<std::unique_ptr<Module>,1> Ms;
+        Ms.push_back(std::unique_ptr<Module>{M});
+        return CompileLayer->addModuleSet(std::move(Ms),
+                                          MemMgr,
+                                          std::move(Resolver));
+    }
+
+    void removeModule(ModuleHandleT H) { CompileLayer->removeModuleSet(H); }
+
+    orc::JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly)
+    {
+        if (ExportedSymbolsOnly) {
+            // Step 1: Check against list of known external globals
+            GlobalSymbolTableT::const_iterator pos = GlobalSymbolTable.find(Name);
+            if (pos != GlobalSymbolTable.end())
+                return orc::JITSymbol((uintptr_t)pos->second, JITSymbolFlags::Exported);
+        }
+        // Step 2: Search all previously emitted symbols
+        return CompileLayer->findSymbol(Name, ExportedSymbolsOnly);
+    }
+
+    orc::JITSymbol findUnmangledSymbol(const std::string Name)
+    {
+        return findSymbol(mangle(Name), true);
+    }
+
+    uint64_t getGlobalValueAddress(const std::string &Name)
+    {
+        return findSymbol(mangle(Name), false).getAddress();
+    }
+
+    uint64_t getFunctionAddress(const std::string &Name)
+    {
+        return findSymbol(mangle(Name), false).getAddress();
+    }
+
+    Function *FindFunctionNamed(const std::string &Name)
+    {
+        return 0; // Functions are not kept around
+    }
+
+    void RegisterJITEventListener(JITEventListener *L)
+    {
+        // TODO
+    }
+
+    const DataLayout& getDataLayout() const
+    {
+        return DL;
+    }
+
+    const Triple& getTargetTriple() const
+    {
+        return TM.getTargetTriple();
+    }
+
+private:
+    TargetMachine &TM;
+    const DataLayout DL;
+    // Should be big enough that in the common case, The
+    // object fits in its entirety
+    SmallVector<char, 4096> ObjBufferSV;
+    raw_svector_ostream ObjStream;
+    legacy::PassManager PM;
+    MCContext *Ctx;
+    RTDyldMemoryManager *MemMgr;
+    ObjLayerT ObjectLayer;
+    std::unique_ptr<CompileLayerT> CompileLayer;
+    GlobalSymbolTableT GlobalSymbolTable;
+};
+
+}
+#endif
diff --git a/src/jl_uv.c b/src/jl_uv.c
index 2cb47ac708b9a..cc1d8bddc4492 100644
--- a/src/jl_uv.c
+++ b/src/jl_uv.c
@@ -50,7 +50,7 @@ extern "C" {
 extern jl_module_t *jl_old_base_module;
 static jl_value_t *close_cb = NULL;
 
-static void jl_uv_call_close_callback(void *val)
+static void jl_uv_call_close_callback(jl_value_t *val)
 {
     jl_value_t *cb;
     if (!jl_old_base_module) {
@@ -61,11 +61,12 @@ static void jl_uv_call_close_callback(void *val)
     else {
         cb = jl_get_global(jl_base_relative_to(((jl_datatype_t*)jl_typeof(val))->name->module), jl_symbol("_uv_hook_close"));
     }
-    assert(cb && jl_is_function(cb));
-    jl_apply((jl_function_t*)cb, (jl_value_t**)&val, 1);
+    assert(cb);
+    jl_value_t *args[2] = {cb,val};
+    jl_apply(args, 2);
 }
 
-DLLEXPORT void jl_uv_closeHandle(uv_handle_t *handle)
+JL_DLLEXPORT void jl_uv_closeHandle(uv_handle_t *handle)
 {
     // if the user killed a stdio handle,
     // revert back to direct stdio FILE* writes
@@ -78,16 +79,16 @@ DLLEXPORT void jl_uv_closeHandle(uv_handle_t *handle)
         JL_STDERR = (JL_STREAM*)STDERR_FILENO;
     // also let the client app do its own cleanup
     if (handle->type != UV_FILE && handle->data)
-        jl_uv_call_close_callback(handle->data);
+        jl_uv_call_close_callback((jl_value_t*)handle->data);
     free(handle);
 }
 
-DLLEXPORT void jl_uv_shutdownCallback(uv_shutdown_t *req, int status)
+JL_DLLEXPORT void jl_uv_shutdownCallback(uv_shutdown_t *req, int status)
 {
     /*
      * This happens if the remote machine closes the connecition while we're
-     * in the shutdown request (in that case we call uv_close, thus cancelling this)
-     * request.
+     * in the shutdown request (in that case we call uv_close, thus cancelling
+     * this request).
      */
     if (status != UV__ECANCELED && !uv_is_closing((uv_handle_t*)req->handle)) {
         uv_close((uv_handle_t*)req->handle, &jl_uv_closeHandle);
@@ -96,20 +97,20 @@ DLLEXPORT void jl_uv_shutdownCallback(uv_shutdown_t *req, int status)
 }
 
 // getters and setters
-DLLEXPORT void *jl_uv_process_data(uv_process_t *p) { return p->data; }
-DLLEXPORT void *jl_uv_buf_base(const uv_buf_t *buf) { return buf->base; }
-DLLEXPORT size_t jl_uv_buf_len(const uv_buf_t *buf) { return buf->len; }
-DLLEXPORT void jl_uv_buf_set_base(uv_buf_t *buf, char *b) { buf->base = b; }
-DLLEXPORT void jl_uv_buf_set_len(uv_buf_t *buf, size_t n) { buf->len = n; }
-DLLEXPORT void *jl_uv_connect_handle(uv_connect_t *connect) { return connect->handle; }
-DLLEXPORT void *jl_uv_getaddrinfo_data(uv_getaddrinfo_t *req) { return req->data; }
-DLLEXPORT uv_file jl_uv_file_handle(jl_uv_file_t *f) { return f->file; }
-DLLEXPORT void *jl_uv_req_data(uv_req_t *req) { return req->data; }
-DLLEXPORT void jl_uv_req_set_data(uv_req_t *req, void *data) { req->data = data; }
-DLLEXPORT void *jl_uv_handle_data(uv_handle_t *handle) { return handle->data; }
-DLLEXPORT void *jl_uv_write_handle(uv_write_t *req) { return req->handle; }
-
-DLLEXPORT int jl_run_once(uv_loop_t *loop)
+JL_DLLEXPORT void *jl_uv_process_data(uv_process_t *p) { return p->data; }
+JL_DLLEXPORT void *jl_uv_buf_base(const uv_buf_t *buf) { return buf->base; }
+JL_DLLEXPORT size_t jl_uv_buf_len(const uv_buf_t *buf) { return buf->len; }
+JL_DLLEXPORT void jl_uv_buf_set_base(uv_buf_t *buf, char *b) { buf->base = b; }
+JL_DLLEXPORT void jl_uv_buf_set_len(uv_buf_t *buf, size_t n) { buf->len = n; }
+JL_DLLEXPORT void *jl_uv_connect_handle(uv_connect_t *connect) { return connect->handle; }
+JL_DLLEXPORT void *jl_uv_getaddrinfo_data(uv_getaddrinfo_t *req) { return req->data; }
+JL_DLLEXPORT uv_file jl_uv_file_handle(jl_uv_file_t *f) { return f->file; }
+JL_DLLEXPORT void *jl_uv_req_data(uv_req_t *req) { return req->data; }
+JL_DLLEXPORT void jl_uv_req_set_data(uv_req_t *req, void *data) { req->data = data; }
+JL_DLLEXPORT void *jl_uv_handle_data(uv_handle_t *handle) { return handle->data; }
+JL_DLLEXPORT void *jl_uv_write_handle(uv_write_t *req) { return req->handle; }
+
+JL_DLLEXPORT int jl_run_once(uv_loop_t *loop)
 {
     if (loop) {
         loop->stop_flag = 0;
@@ -118,7 +119,7 @@ DLLEXPORT int jl_run_once(uv_loop_t *loop)
     else return 0;
 }
 
-DLLEXPORT void jl_run_event_loop(uv_loop_t *loop)
+JL_DLLEXPORT void jl_run_event_loop(uv_loop_t *loop)
 {
     if (loop) {
         loop->stop_flag = 0;
@@ -126,7 +127,7 @@ DLLEXPORT void jl_run_event_loop(uv_loop_t *loop)
     }
 }
 
-DLLEXPORT int jl_process_events(uv_loop_t *loop)
+JL_DLLEXPORT int jl_process_events(uv_loop_t *loop)
 {
     if (loop) {
         loop->stop_flag = 0;
@@ -135,7 +136,8 @@ DLLEXPORT int jl_process_events(uv_loop_t *loop)
     else return 0;
 }
 
-DLLEXPORT int jl_init_pipe(uv_pipe_t *pipe, int writable, int readable, int julia_only)
+JL_DLLEXPORT int jl_init_pipe(uv_pipe_t *pipe, int writable, int readable,
+                              int julia_only)
 {
      int flags = 0;
      if (writable)
@@ -148,7 +150,7 @@ DLLEXPORT int jl_init_pipe(uv_pipe_t *pipe, int writable, int readable, int juli
      return err;
 }
 
-DLLEXPORT void jl_close_uv(uv_handle_t *handle)
+JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle)
 {
     if (handle->type == UV_FILE) {
         uv_fs_t req;
@@ -192,27 +194,28 @@ DLLEXPORT void jl_close_uv(uv_handle_t *handle)
     }
 }
 
-DLLEXPORT void jl_forceclose_uv(uv_handle_t *handle)
+JL_DLLEXPORT void jl_forceclose_uv(uv_handle_t *handle)
 {
     uv_close(handle,&jl_uv_closeHandle);
 }
 
-DLLEXPORT void jl_uv_associate_julia_struct(uv_handle_t *handle, jl_value_t *data)
+JL_DLLEXPORT void jl_uv_associate_julia_struct(uv_handle_t *handle,
+                                               jl_value_t *data)
 {
     handle->data = data;
 }
 
-DLLEXPORT void jl_uv_disassociate_julia_struct(uv_handle_t *handle)
+JL_DLLEXPORT void jl_uv_disassociate_julia_struct(uv_handle_t *handle)
 {
     handle->data = NULL;
 }
 
-DLLEXPORT int jl_spawn(char *name, char **argv, uv_loop_t *loop,
-                       uv_process_t *proc, jl_value_t *julia_struct,
-                       uv_handle_type stdin_type, uv_pipe_t *stdin_pipe,
-                       uv_handle_type stdout_type, uv_pipe_t *stdout_pipe,
-                       uv_handle_type stderr_type, uv_pipe_t *stderr_pipe,
-                       int detach, char **env, char *cwd, uv_exit_cb cb)
+JL_DLLEXPORT int jl_spawn(char *name, char **argv, uv_loop_t *loop,
+                          uv_process_t *proc, jl_value_t *julia_struct,
+                          uv_handle_type stdin_type, uv_pipe_t *stdin_pipe,
+                          uv_handle_type stdout_type, uv_pipe_t *stdout_pipe,
+                          uv_handle_type stderr_type, uv_pipe_t *stderr_pipe,
+                          int flags, char **env, char *cwd, uv_exit_cb cb)
 {
     uv_process_options_t opts;
     uv_stdio_container_t stdio[3];
@@ -220,14 +223,12 @@ DLLEXPORT int jl_spawn(char *name, char **argv, uv_loop_t *loop,
     opts.file = name;
     opts.env = env;
 #ifdef _OS_WINDOWS_
-    opts.flags = 0;
+    opts.flags = flags;
 #else
-    opts.flags = UV_PROCESS_RESET_SIGPIPE;
+    opts.flags = flags | UV_PROCESS_RESET_SIGPIPE;
 #endif
     opts.cwd = cwd;
     opts.args = argv;
-    if (detach)
-        opts.flags |= UV_PROCESS_DETACHED;
     opts.stdio = stdio;
     opts.stdio_count = 3;
     stdio[0].type = stdin_type;
@@ -243,7 +244,7 @@ DLLEXPORT int jl_spawn(char *name, char **argv, uv_loop_t *loop,
 
 #ifdef _OS_WINDOWS_
 #include <time.h>
-DLLEXPORT struct tm* localtime_r(const time_t *t, struct tm *tm)
+JL_DLLEXPORT struct tm *localtime_r(const time_t *t, struct tm *tm)
 {
     struct tm *tmp = localtime(t); //localtime is reentrant on windows
     if (tmp)
@@ -252,12 +253,12 @@ DLLEXPORT struct tm* localtime_r(const time_t *t, struct tm *tm)
 }
 #endif
 
-DLLEXPORT uv_loop_t *jl_global_event_loop(void)
+JL_DLLEXPORT uv_loop_t *jl_global_event_loop(void)
 {
     return jl_io_loop;
 }
 
-DLLEXPORT int jl_fs_unlink(char *path)
+JL_DLLEXPORT int jl_fs_unlink(char *path)
 {
     uv_fs_t req;
     JL_SIGATOMIC_BEGIN();
@@ -267,7 +268,7 @@ DLLEXPORT int jl_fs_unlink(char *path)
     return ret;
 }
 
-DLLEXPORT int jl_fs_rename(const char *src_path, const char *dst_path)
+JL_DLLEXPORT int jl_fs_rename(const char *src_path, const char *dst_path)
 {
     uv_fs_t req;
     JL_SIGATOMIC_BEGIN();
@@ -277,8 +278,8 @@ DLLEXPORT int jl_fs_rename(const char *src_path, const char *dst_path)
     return ret;
 }
 
-DLLEXPORT int jl_fs_sendfile(int src_fd, int dst_fd,
-                             int64_t in_offset, size_t len)
+JL_DLLEXPORT int jl_fs_sendfile(int src_fd, int dst_fd,
+                                int64_t in_offset, size_t len)
 {
     uv_fs_t req;
     JL_SIGATOMIC_BEGIN();
@@ -289,7 +290,7 @@ DLLEXPORT int jl_fs_sendfile(int src_fd, int dst_fd,
     return ret;
 }
 
-DLLEXPORT int jl_fs_symlink(char *path, char *new_path, int flags)
+JL_DLLEXPORT int jl_fs_symlink(char *path, char *new_path, int flags)
 {
     uv_fs_t req;
     int ret = uv_fs_symlink(jl_io_loop, &req, path, new_path, flags, NULL);
@@ -297,7 +298,7 @@ DLLEXPORT int jl_fs_symlink(char *path, char *new_path, int flags)
     return ret;
 }
 
-DLLEXPORT int jl_fs_chmod(char *path, int mode)
+JL_DLLEXPORT int jl_fs_chmod(char *path, int mode)
 {
     uv_fs_t req;
     int ret = uv_fs_chmod(jl_io_loop, &req, path, mode, NULL);
@@ -305,9 +306,20 @@ DLLEXPORT int jl_fs_chmod(char *path, int mode)
     return ret;
 }
 
-DLLEXPORT int jl_fs_write(int handle, const char *data, size_t len, int64_t offset)
+JL_DLLEXPORT int jl_fs_chown(char *path, int uid, int gid)
 {
     uv_fs_t req;
+    int ret = uv_fs_chown(jl_io_loop, &req, path, uid, gid, NULL);
+    uv_fs_req_cleanup(&req);
+    return ret;
+}
+
+JL_DLLEXPORT int jl_fs_write(int handle, const char *data, size_t len,
+                             int64_t offset)
+{
+    if (jl_safe_restore)
+        return write(handle, data, len);
+    uv_fs_t req;
     uv_buf_t buf[1];
     buf[0].base = (char*)data;
     buf[0].len = len;
@@ -316,7 +328,7 @@ DLLEXPORT int jl_fs_write(int handle, const char *data, size_t len, int64_t offs
     return ret;
 }
 
-DLLEXPORT int jl_fs_read(int handle, char *data, size_t len)
+JL_DLLEXPORT int jl_fs_read(int handle, char *data, size_t len)
 {
     uv_fs_t req;
     uv_buf_t buf[1];
@@ -327,7 +339,7 @@ DLLEXPORT int jl_fs_read(int handle, char *data, size_t len)
     return ret;
 }
 
-DLLEXPORT int jl_fs_read_byte(int handle)
+JL_DLLEXPORT int jl_fs_read_byte(int handle)
 {
     uv_fs_t req;
     char c;
@@ -336,12 +348,17 @@ DLLEXPORT int jl_fs_read_byte(int handle)
     buf[0].len = 1;
     int ret = uv_fs_read(jl_io_loop, &req, handle, buf, 1, -1, NULL);
     uv_fs_req_cleanup(&req);
-    if (ret == -1)
-        return ret;
-    return (int)c;
+    switch (ret) {
+    case -1: return ret;
+    case  0: jl_eof_error();
+    case  1: return (int)c;
+    default:
+        assert(0 && "jl_fs_read_byte: Invalid return value from uv_fs_read");
+        return -1;
+    }
 }
 
-DLLEXPORT int jl_fs_close(int handle)
+JL_DLLEXPORT int jl_fs_close(int handle)
 {
     uv_fs_t req;
     int ret = uv_fs_close(jl_io_loop, &req, handle, NULL);
@@ -349,7 +366,8 @@ DLLEXPORT int jl_fs_close(int handle)
     return ret;
 }
 
-DLLEXPORT int jl_uv_write(uv_stream_t *stream, const char *data, size_t n, uv_write_t *uvw, void *writecb)
+JL_DLLEXPORT int jl_uv_write(uv_stream_t *stream, const char *data, size_t n,
+                             uv_write_t *uvw, void *writecb)
 {
     uv_buf_t buf[1];
     buf[0].base = (char*)data;
@@ -360,7 +378,7 @@ DLLEXPORT int jl_uv_write(uv_stream_t *stream, const char *data, size_t n, uv_wr
     return err;
 }
 
-DLLEXPORT void jl_uv_writecb(uv_write_t *req, int status)
+JL_DLLEXPORT void jl_uv_writecb(uv_write_t *req, int status)
 {
     free(req);
     if (status < 0) {
@@ -421,7 +439,7 @@ static void jl_write(uv_stream_t *stream, const char *str, size_t n)
 
 extern int vasprintf(char **str, const char *fmt, va_list ap);
 
-int jl_vprintf(uv_stream_t *s, const char *format, va_list args)
+JL_DLLEXPORT int jl_vprintf(uv_stream_t *s, const char *format, va_list args)
 {
     char *str=NULL;
     int c;
@@ -442,7 +460,7 @@ int jl_vprintf(uv_stream_t *s, const char *format, va_list args)
     return c;
 }
 
-int jl_printf(uv_stream_t *s, const char *format, ...)
+JL_DLLEXPORT int jl_printf(uv_stream_t *s, const char *format, ...)
 {
     va_list args;
     int c;
@@ -453,7 +471,7 @@ int jl_printf(uv_stream_t *s, const char *format, ...)
     return c;
 }
 
-DLLEXPORT void jl_safe_printf(const char *fmt, ...)
+JL_DLLEXPORT void jl_safe_printf(const char *fmt, ...)
 {
     static char buf[1000];
     buf[0] = '\0';
@@ -470,14 +488,14 @@ DLLEXPORT void jl_safe_printf(const char *fmt, ...)
     }
 }
 
-DLLEXPORT void jl_exit(int exitcode)
+JL_DLLEXPORT void jl_exit(int exitcode)
 {
     uv_tty_reset_mode();
     jl_atexit_hook(exitcode);
     exit(exitcode);
 }
 
-DLLEXPORT int jl_getpid()
+JL_DLLEXPORT int jl_getpid(void)
 {
 #ifdef _OS_WINDOWS_
     return GetCurrentProcessId();
@@ -487,7 +505,8 @@ DLLEXPORT int jl_getpid()
 }
 
 //NOTE: These function expects port/host to be in network byte-order (Big Endian)
-DLLEXPORT int jl_tcp_bind(uv_tcp_t *handle, uint16_t port, uint32_t host, unsigned int flags)
+JL_DLLEXPORT int jl_tcp_bind(uv_tcp_t *handle, uint16_t port, uint32_t host,
+                             unsigned int flags)
 {
     struct sockaddr_in addr;
     memset(&addr, 0, sizeof(struct sockaddr_in));
@@ -497,7 +516,8 @@ DLLEXPORT int jl_tcp_bind(uv_tcp_t *handle, uint16_t port, uint32_t host, unsign
     return uv_tcp_bind(handle, (struct sockaddr*)&addr, flags);
 }
 
-DLLEXPORT int jl_tcp_bind6(uv_tcp_t *handle, uint16_t port, void *host, unsigned int flags)
+JL_DLLEXPORT int jl_tcp_bind6(uv_tcp_t *handle, uint16_t port, void *host,
+                              unsigned int flags)
 {
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(struct sockaddr_in6));
@@ -507,7 +527,58 @@ DLLEXPORT int jl_tcp_bind6(uv_tcp_t *handle, uint16_t port, void *host, unsigned
     return uv_tcp_bind(handle, (struct sockaddr*)&addr, flags);
 }
 
-DLLEXPORT int jl_udp_bind(uv_udp_t *handle, uint16_t port, uint32_t host, uint32_t flags)
+JL_DLLEXPORT int jl_tcp_getsockname(uv_tcp_t *handle, uint16_t *port,
+                                    void *host, uint32_t *family)
+{
+    int namelen;
+    struct sockaddr_storage addr;
+    memset(&addr, 0, sizeof(struct sockaddr_storage));
+    namelen = sizeof addr;
+    int res = uv_tcp_getsockname(handle, (struct sockaddr*)&addr, &namelen);
+    *family = addr.ss_family;
+    if (addr.ss_family == AF_INET) {
+        struct sockaddr_in *addr4 = (struct sockaddr_in*)&addr;
+        *port = addr4->sin_port;
+        memcpy(host, &(addr4->sin_addr), 4);
+    }
+    else if (addr.ss_family == AF_INET6) {
+        struct sockaddr_in6 *addr6 = (struct sockaddr_in6*)&addr;
+        *port = addr6->sin6_port;
+        memcpy(host, &(addr6->sin6_addr), 16);
+    }
+    else {
+        return -1;
+    }
+    return res;
+}
+
+JL_DLLEXPORT int jl_tcp_getpeername(uv_tcp_t *handle, uint16_t *port,
+                                    void *host, uint32_t *family)
+{
+    int namelen;
+    struct sockaddr_storage addr;
+    memset(&addr, 0, sizeof(struct sockaddr_storage));
+    namelen = sizeof addr;
+    int res = uv_tcp_getpeername(handle, (struct sockaddr*)&addr, &namelen);
+    *family = addr.ss_family;
+    if (addr.ss_family == AF_INET) {
+        struct sockaddr_in *addr4 = (struct sockaddr_in*)&addr;
+        *port = addr4->sin_port;
+        memcpy(host, &(addr4->sin_addr), 4);
+    }
+    else if (addr.ss_family == AF_INET6) {
+        struct sockaddr_in6 *addr6 = (struct sockaddr_in6*)&addr;
+        *port = addr6->sin6_port;
+        memcpy(host, &(addr6->sin6_addr), 16);
+    }
+    else {
+        return -1;
+    }
+    return res;
+}
+
+JL_DLLEXPORT int jl_udp_bind(uv_udp_t *handle, uint16_t port, uint32_t host,
+                             uint32_t flags)
 {
     struct sockaddr_in addr;
     memset(&addr, 0, sizeof(struct sockaddr_in));
@@ -517,7 +588,8 @@ DLLEXPORT int jl_udp_bind(uv_udp_t *handle, uint16_t port, uint32_t host, uint32
     return uv_udp_bind(handle, (struct sockaddr*)&addr, flags);
 }
 
-DLLEXPORT int jl_udp_bind6(uv_udp_t *handle, uint16_t port, void *host, uint32_t flags)
+JL_DLLEXPORT int jl_udp_bind6(uv_udp_t *handle, uint16_t port, void *host,
+                              uint32_t flags)
 {
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(struct sockaddr_in6));
@@ -527,7 +599,8 @@ DLLEXPORT int jl_udp_bind6(uv_udp_t *handle, uint16_t port, void *host, uint32_t
     return uv_udp_bind(handle, (struct sockaddr*)&addr, flags);
 }
 
-DLLEXPORT int jl_udp_send(uv_udp_t *handle, uint16_t port, uint32_t host, void *data, uint32_t size, uv_udp_send_cb cb)
+JL_DLLEXPORT int jl_udp_send(uv_udp_t *handle, uint16_t port, uint32_t host,
+                             void *data, uint32_t size, uv_udp_send_cb cb)
 {
     struct sockaddr_in addr;
     memset(&addr, 0, sizeof(struct sockaddr_in));
@@ -542,7 +615,8 @@ DLLEXPORT int jl_udp_send(uv_udp_t *handle, uint16_t port, uint32_t host, void *
     return uv_udp_send(req, handle, buf, 1, (struct sockaddr*)&addr, cb);
 }
 
-DLLEXPORT int jl_udp_send6(uv_udp_t *handle, uint16_t port, void *host, void *data, uint32_t size, uv_udp_send_cb cb)
+JL_DLLEXPORT int jl_udp_send6(uv_udp_t *handle, uint16_t port, void *host,
+                              void *data, uint32_t size, uv_udp_send_cb cb)
 {
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(struct sockaddr_in6));
@@ -557,27 +631,30 @@ DLLEXPORT int jl_udp_send6(uv_udp_t *handle, uint16_t port, void *host, void *da
     return uv_udp_send(req, handle, buf, 1, (struct sockaddr*)&addr, cb);
 }
 
-DLLEXPORT int jl_uv_sizeof_interface_address()
+JL_DLLEXPORT int jl_uv_sizeof_interface_address(void)
 {
     return sizeof(uv_interface_address_t);
 }
 
-DLLEXPORT int jl_uv_interface_addresses(uv_interface_address_t **ifAddrStruct,int *count)
+JL_DLLEXPORT int jl_uv_interface_addresses(uv_interface_address_t **ifAddrStruct,
+                                           int *count)
 {
     return uv_interface_addresses(ifAddrStruct,count);
 }
 
-DLLEXPORT int jl_uv_interface_address_is_internal(uv_interface_address_t *addr)
+JL_DLLEXPORT int jl_uv_interface_address_is_internal(uv_interface_address_t *addr)
 {
     return addr->is_internal;
 }
 
-DLLEXPORT struct sockaddr_in *jl_uv_interface_address_sockaddr(uv_interface_address_t *ifa)
+JL_DLLEXPORT struct sockaddr_in *jl_uv_interface_address_sockaddr(uv_interface_address_t *ifa)
 {
     return &ifa->address.address4;
 }
 
-DLLEXPORT int jl_getaddrinfo(uv_loop_t *loop, const char *host, const char *service, jl_function_t *cb, uv_getaddrinfo_cb uvcb)
+JL_DLLEXPORT int jl_getaddrinfo(uv_loop_t *loop, const char *host,
+                                const char *service, jl_function_t *cb,
+                                uv_getaddrinfo_cb uvcb)
 {
     uv_getaddrinfo_t *req = (uv_getaddrinfo_t*)malloc(sizeof(uv_getaddrinfo_t));
     struct addrinfo hints;
@@ -592,47 +669,48 @@ DLLEXPORT int jl_getaddrinfo(uv_loop_t *loop, const char *host, const char *serv
     return uv_getaddrinfo(loop,req,uvcb,host,service,&hints);
 }
 
-DLLEXPORT struct sockaddr *jl_sockaddr_from_addrinfo(struct addrinfo *addrinfo)
+JL_DLLEXPORT struct sockaddr *jl_sockaddr_from_addrinfo(struct addrinfo *addrinfo)
 {
     return addrinfo->ai_addr;
 }
-DLLEXPORT struct addrinfo *jl_next_from_addrinfo(struct addrinfo *addrinfo)
+JL_DLLEXPORT struct addrinfo *jl_next_from_addrinfo(struct addrinfo *addrinfo)
 {
     return addrinfo->ai_next;
 }
 
-DLLEXPORT int jl_sockaddr_in_is_ip4(struct sockaddr_in *addr)
+JL_DLLEXPORT int jl_sockaddr_in_is_ip4(struct sockaddr_in *addr)
 {
     return (addr->sin_family==AF_INET);
 }
 
-DLLEXPORT int jl_sockaddr_in_is_ip6(struct sockaddr_in *addr)
+JL_DLLEXPORT int jl_sockaddr_in_is_ip6(struct sockaddr_in *addr)
 {
     return (addr->sin_family==AF_INET6);
 }
 
-DLLEXPORT int jl_sockaddr_is_ip4(struct sockaddr_storage *addr)
+JL_DLLEXPORT int jl_sockaddr_is_ip4(struct sockaddr_storage *addr)
 {
     return (addr->ss_family==AF_INET);
 }
 
-DLLEXPORT int jl_sockaddr_is_ip6(struct sockaddr_storage *addr)
+JL_DLLEXPORT int jl_sockaddr_is_ip6(struct sockaddr_storage *addr)
 {
     return (addr->ss_family==AF_INET6);
 }
 
-DLLEXPORT unsigned int jl_sockaddr_host4(struct sockaddr_in *addr)
+JL_DLLEXPORT unsigned int jl_sockaddr_host4(struct sockaddr_in *addr)
 {
     return addr->sin_addr.s_addr;
 }
 
-DLLEXPORT unsigned int jl_sockaddr_host6(struct sockaddr_in6 *addr, char *host)
+JL_DLLEXPORT unsigned int jl_sockaddr_host6(struct sockaddr_in6 *addr, char *host)
 {
     memcpy(host, &addr->sin6_addr, 16);
     return addr->sin6_scope_id;
 }
 
-DLLEXPORT void jl_sockaddr_set_port(struct sockaddr_storage *addr,uint16_t port)
+JL_DLLEXPORT void jl_sockaddr_set_port(struct sockaddr_storage *addr,
+                                       uint16_t port)
 {
     if (addr->ss_family==AF_INET)
         ((struct sockaddr_in*)addr)->sin_port = port;
@@ -640,7 +718,8 @@ DLLEXPORT void jl_sockaddr_set_port(struct sockaddr_storage *addr,uint16_t port)
         ((struct sockaddr_in6*)addr)->sin6_port = port;
 }
 
-DLLEXPORT int jl_tcp4_connect(uv_tcp_t *handle,uint32_t host, uint16_t port, uv_connect_cb cb)
+JL_DLLEXPORT int jl_tcp4_connect(uv_tcp_t *handle,uint32_t host, uint16_t port,
+                                 uv_connect_cb cb)
 {
     struct sockaddr_in addr;
     uv_connect_t *req = (uv_connect_t*)malloc(sizeof(uv_connect_t));
@@ -652,7 +731,8 @@ DLLEXPORT int jl_tcp4_connect(uv_tcp_t *handle,uint32_t host, uint16_t port, uv_
     return uv_tcp_connect(req,handle,(struct sockaddr*)&addr,cb);
 }
 
-DLLEXPORT int jl_tcp6_connect(uv_tcp_t *handle, void *host, uint16_t port, uv_connect_cb cb)
+JL_DLLEXPORT int jl_tcp6_connect(uv_tcp_t *handle, void *host, uint16_t port,
+                                 uv_connect_cb cb)
 {
     struct sockaddr_in6 addr;
     uv_connect_t *req = (uv_connect_t*)malloc(sizeof(uv_connect_t));
@@ -664,7 +744,8 @@ DLLEXPORT int jl_tcp6_connect(uv_tcp_t *handle, void *host, uint16_t port, uv_co
     return uv_tcp_connect(req,handle,(struct sockaddr*)&addr,cb);
 }
 
-DLLEXPORT int jl_connect_raw(uv_tcp_t *handle,struct sockaddr_storage *addr, uv_connect_cb cb)
+JL_DLLEXPORT int jl_connect_raw(uv_tcp_t *handle,struct sockaddr_storage *addr,
+                                uv_connect_cb cb)
 {
     uv_connect_t *req = (uv_connect_t*)malloc(sizeof(uv_connect_t));
     req->data = 0;
@@ -672,7 +753,7 @@ DLLEXPORT int jl_connect_raw(uv_tcp_t *handle,struct sockaddr_storage *addr, uv_
 }
 
 #ifdef _OS_LINUX_
-DLLEXPORT int jl_tcp_quickack(uv_tcp_t *handle, int on)
+JL_DLLEXPORT int jl_tcp_quickack(uv_tcp_t *handle, int on)
 {
     int fd = (handle)->io_watcher.fd;
     if (fd != -1) {
@@ -685,7 +766,7 @@ DLLEXPORT int jl_tcp_quickack(uv_tcp_t *handle, int on)
 
 #endif
 
-DLLEXPORT int jl_tcp_reuseport(uv_tcp_t *handle)
+JL_DLLEXPORT int jl_tcp_reuseport(uv_tcp_t *handle)
 {
 #if defined(SO_REUSEPORT)
     int fd = (handle)->io_watcher.fd;
@@ -699,22 +780,10 @@ DLLEXPORT int jl_tcp_reuseport(uv_tcp_t *handle)
 #endif
 }
 
-DLLEXPORT int jl_tcp_getsockname_v4(uv_tcp_t *handle, uint32_t * ip, uint16_t * port)
-{
-    struct sockaddr_in name;
-    int len = sizeof(name);
-    if (uv_tcp_getsockname(handle, (struct sockaddr *)&name, &len)) {
-        return -1;
-    }
-
-    *ip = ntohl(name.sin_addr.s_addr);
-    *port = ntohs(name.sin_port);
-    return 0;
-}
-
 #ifndef _OS_WINDOWS_
 
-DLLEXPORT int jl_uv_unix_fd_is_watched(int fd, uv_poll_t *handle, uv_loop_t *loop)
+JL_DLLEXPORT int jl_uv_unix_fd_is_watched(int fd, uv_poll_t *handle,
+                                          uv_loop_t *loop)
 {
     if (fd >= loop->nwatchers)
         return 0;
@@ -735,7 +804,7 @@ static inline int ishexchar(char c)
    return 0;
 }
 
-DLLEXPORT int jl_ispty(uv_pipe_t *pipe)
+JL_DLLEXPORT int jl_ispty(uv_pipe_t *pipe)
 {
     if (pipe->type != UV_NAMED_PIPE) return 0;
     size_t len = 0;
@@ -766,7 +835,7 @@ DLLEXPORT int jl_ispty(uv_pipe_t *pipe)
 }
 #endif
 
-DLLEXPORT uv_handle_type jl_uv_handle_type(uv_handle_t *handle)
+JL_DLLEXPORT uv_handle_type jl_uv_handle_type(uv_handle_t *handle)
 {
 #ifdef _OS_WINDOWS_
     if (jl_ispty((uv_pipe_t*)handle))
@@ -775,12 +844,58 @@ DLLEXPORT uv_handle_type jl_uv_handle_type(uv_handle_t *handle)
     return handle->type;
 }
 
-DLLEXPORT int jl_tty_set_mode(uv_tty_t *handle, int mode)
+JL_DLLEXPORT int jl_tty_set_mode(uv_tty_t *handle, int mode)
 {
     if (handle->type != UV_TTY) return 0;
     return uv_tty_set_mode(handle, mode);
 }
 
+typedef int (*work_cb_t)(void *, void *);
+typedef void (*notify_cb_t)(int);
+
+struct work_baton {
+    uv_work_t req;
+    work_cb_t work_func;
+    void      *work_args;
+    void      *work_retval;
+    notify_cb_t notify_func;
+    int       tid;
+    int       notify_idx;
+};
+
+#ifdef _OS_LINUX_
+#include <sys/syscall.h>
+#endif
+
+void jl_work_wrapper(uv_work_t *req)
+{
+    struct work_baton *baton = (struct work_baton*) req->data;
+    baton->work_func(baton->work_args, baton->work_retval);
+}
+
+void jl_work_notifier(uv_work_t *req, int status)
+{
+    struct work_baton *baton = (struct work_baton*) req->data;
+    baton->notify_func(baton->notify_idx);
+    free(baton);
+}
+
+JL_DLLEXPORT int jl_queue_work(void *work_func, void *work_args, void *work_retval,
+                               void *notify_func, int notify_idx)
+{
+    struct work_baton *baton = (struct work_baton*) malloc(sizeof(struct work_baton));
+    baton->req.data = (void*) baton;
+    baton->work_func = (work_cb_t)work_func;
+    baton->work_args = work_args;
+    baton->work_retval = work_retval;
+    baton->notify_func = (notify_cb_t)notify_func;
+    baton->notify_idx = notify_idx;
+
+    uv_queue_work(jl_io_loop, &baton->req, jl_work_wrapper, jl_work_notifier);
+
+    return 0;
+}
+
 #ifndef _OS_WINDOWS_
 #if defined(__APPLE__)
 int uv___stream_fd(uv_stream_t *handle);
@@ -788,12 +903,12 @@ int uv___stream_fd(uv_stream_t *handle);
 #else
 #define uv__stream_fd(handle) ((handle)->io_watcher.fd)
 #endif /* defined(__APPLE__) */
-DLLEXPORT int jl_uv_handle(uv_stream_t *handle)
+JL_DLLEXPORT int jl_uv_handle(uv_stream_t *handle)
 {
     return uv__stream_fd(handle);
 }
 #else
-DLLEXPORT HANDLE jl_uv_handle(uv_stream_t *handle)
+JL_DLLEXPORT HANDLE jl_uv_handle(uv_stream_t *handle)
 {
     switch (handle->type) {
     case UV_TTY:
diff --git a/src/jlapi.c b/src/jlapi.c
index a654d743d7afe..756336e6dbf49 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -18,14 +18,12 @@ extern "C" {
 #endif
 
 #if defined(_OS_WINDOWS_) && !defined(_COMPILER_MINGW_)
-DLLEXPORT char * __cdecl dirname(char *);
+JL_DLLEXPORT char * __cdecl dirname(char *);
 #else
 #include <libgen.h>
 #endif
 
-DLLEXPORT void *jl_eval_string(const char *str);
-
-int jl_is_initialized(void) { return jl_main_module!=NULL; }
+JL_DLLEXPORT int jl_is_initialized(void) { return jl_main_module!=NULL; }
 
 // First argument is the usr/lib directory where libjulia is, or NULL to guess.
 // if that doesn't work, try the full path to the "lib" directory that
@@ -33,7 +31,8 @@ int jl_is_initialized(void) { return jl_main_module!=NULL; }
 // Second argument is the path of a system image file (*.ji) relative to the
 // first argument path, or relative to the default julia home dir. The default
 // is something like ../lib/julia/sys.ji
-DLLEXPORT void jl_init_with_image(const char *julia_home_dir, const char *image_relative_path)
+JL_DLLEXPORT void jl_init_with_image(const char *julia_home_dir,
+                                     const char *image_relative_path)
 {
     if (jl_is_initialized()) return;
     libsupport_init();
@@ -44,12 +43,12 @@ DLLEXPORT void jl_init_with_image(const char *julia_home_dir, const char *image_
     jl_exception_clear();
 }
 
-DLLEXPORT void jl_init(const char *julia_home_dir)
+JL_DLLEXPORT void jl_init(const char *julia_home_dir)
 {
     jl_init_with_image(julia_home_dir, NULL);
 }
 
-DLLEXPORT void *jl_eval_string(const char *str)
+JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
 {
     jl_value_t *r;
     JL_TRY {
@@ -66,63 +65,61 @@ DLLEXPORT void *jl_eval_string(const char *str)
     return r;
 }
 
-DLLEXPORT jl_value_t *jl_exception_occurred(void)
+JL_DLLEXPORT jl_value_t *jl_exception_occurred(void)
 {
     return jl_exception_in_transit == jl_nothing ? NULL :
         jl_exception_in_transit;
 }
 
-DLLEXPORT void jl_exception_clear(void)
+JL_DLLEXPORT void jl_exception_clear(void)
 {
     jl_exception_in_transit = jl_nothing;
 }
 
 // get the name of a type as a string
-DLLEXPORT const char *jl_typename_str(jl_value_t *v)
+JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v)
 {
     if (!jl_is_datatype(v))
         return NULL;
-    return ((jl_datatype_t*)v)->name->name->name;
+    return jl_symbol_name(((jl_datatype_t*)v)->name->name);
 }
 
 // get the name of typeof(v) as a string
-DLLEXPORT const char *jl_typeof_str(jl_value_t *v)
+JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v)
 {
     return jl_typename_str((jl_value_t*)jl_typeof(v));
 }
 
-DLLEXPORT void *jl_array_eltype(jl_value_t *a)
+JL_DLLEXPORT void *jl_array_eltype(jl_value_t *a)
 {
     return jl_tparam0(jl_typeof(a));
 }
 
-DLLEXPORT int jl_array_rank(jl_value_t *a)
+JL_DLLEXPORT int jl_array_rank(jl_value_t *a)
 {
     return jl_array_ndims(a);
 }
 
-DLLEXPORT size_t jl_array_size(jl_value_t *a, int d)
+JL_DLLEXPORT size_t jl_array_size(jl_value_t *a, int d)
 {
     return jl_array_dim(a, d);
 }
 
-DLLEXPORT void *jl_array_ptr(jl_array_t *a);
-
-DLLEXPORT const char *jl_bytestring_ptr(jl_value_t *s)
+JL_DLLEXPORT const char *jl_bytestring_ptr(jl_value_t *s)
 {
     return jl_string_data(s);
 }
 
-DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs)
+JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs)
 {
     jl_value_t *v;
     JL_TRY {
         jl_value_t **argv;
         JL_GC_PUSHARGS(argv, nargs+1);
-        argv[0] = (jl_value_t*) f;
+        argv[0] = (jl_value_t*)f;
         for(int i=1; i<nargs+1; i++)
             argv[i] = args[i-1];
-        v = jl_apply(f, args, nargs);
+        v = jl_apply(argv, nargs+1);
         JL_GC_POP();
         jl_exception_clear();
     }
@@ -132,12 +129,12 @@ DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs
     return v;
 }
 
-DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
+JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
 {
     jl_value_t *v;
     JL_TRY {
         JL_GC_PUSH1(&f);
-        v = jl_apply(f, NULL, 0);
+        v = jl_apply(&f, 1);
         JL_GC_POP();
         jl_exception_clear();
     }
@@ -147,12 +144,14 @@ DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
     return v;
 }
 
-DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
+JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
 {
     jl_value_t *v;
     JL_TRY {
-        JL_GC_PUSH2(&f,&a);
-        v = jl_apply(f, &a, 1);
+        jl_value_t **argv;
+        JL_GC_PUSHARGS(argv, 2);
+        argv[0] = f; argv[1] = a;
+        v = jl_apply(argv, 2);
         JL_GC_POP();
         jl_exception_clear();
     }
@@ -162,13 +161,14 @@ DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
     return v;
 }
 
-DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b)
+JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b)
 {
     jl_value_t *v;
     JL_TRY {
-        JL_GC_PUSH3(&f,&a,&b);
-        jl_value_t *args[2] = {a,b};
-        v = jl_apply(f, args, 2);
+        jl_value_t **argv;
+        JL_GC_PUSHARGS(argv, 3);
+        argv[0] = f; argv[1] = a; argv[2] = b;
+        v = jl_apply(argv, 3);
         JL_GC_POP();
         jl_exception_clear();
     }
@@ -178,13 +178,15 @@ DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b)
     return v;
 }
 
-DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a, jl_value_t *b, jl_value_t *c)
+JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
+                                  jl_value_t *b, jl_value_t *c)
 {
     jl_value_t *v;
     JL_TRY {
-        JL_GC_PUSH4(&f,&a,&b,&c);
-        jl_value_t *args[3] = {a,b,c};
-        v = jl_apply(f, args, 3);
+        jl_value_t **argv;
+        JL_GC_PUSHARGS(argv, 4);
+        argv[0] = f; argv[1] = a; argv[2] = b; argv[3] = c;
+        v = jl_apply(argv, 4);
         JL_GC_POP();
         jl_exception_clear();
     }
@@ -194,16 +196,16 @@ DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a, jl_value_t *b, j
     return v;
 }
 
-DLLEXPORT void jl_yield()
+JL_DLLEXPORT void jl_yield(void)
 {
     static jl_function_t *yieldfunc = NULL;
     if (yieldfunc == NULL)
         yieldfunc = (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("yield"));
-    if (yieldfunc != NULL && jl_is_func(yieldfunc))
+    if (yieldfunc != NULL)
         jl_call0(yieldfunc);
 }
 
-DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
+JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
 {
     jl_value_t *v;
     JL_TRY {
@@ -218,19 +220,19 @@ DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
     return v;
 }
 
-DLLEXPORT void jl_sigatomic_begin(void)
+JL_DLLEXPORT void jl_sigatomic_begin(void)
 {
     JL_SIGATOMIC_BEGIN();
 }
 
-DLLEXPORT void jl_sigatomic_end(void)
+JL_DLLEXPORT void jl_sigatomic_end(void)
 {
     if (jl_defer_signal == 0)
         jl_error("sigatomic_end called in non-sigatomic region");
     JL_SIGATOMIC_END();
 }
 
-DLLEXPORT int jl_is_debugbuild(void)
+JL_DLLEXPORT int jl_is_debugbuild(void)
 {
 #ifdef JL_DEBUG_BUILD
     return 1;
@@ -239,48 +241,49 @@ DLLEXPORT int jl_is_debugbuild(void)
 #endif
 }
 
-DLLEXPORT jl_value_t *jl_get_julia_home(void)
+JL_DLLEXPORT jl_value_t *jl_get_julia_home(void)
 {
     return jl_cstr_to_string(jl_options.julia_home);
 }
 
-DLLEXPORT jl_value_t *jl_get_julia_bin(void)
+JL_DLLEXPORT jl_value_t *jl_get_julia_bin(void)
 {
     return jl_cstr_to_string(jl_options.julia_bin);
 }
 
-DLLEXPORT jl_value_t *jl_get_image_file(void)
+JL_DLLEXPORT jl_value_t *jl_get_image_file(void)
 {
     return jl_cstr_to_string(jl_options.image_file);
 }
 
-DLLEXPORT int jl_ver_major(void)
+JL_DLLEXPORT int jl_ver_major(void)
 {
     return JULIA_VERSION_MAJOR;
 }
 
-DLLEXPORT int jl_ver_minor(void)
+JL_DLLEXPORT int jl_ver_minor(void)
 {
     return JULIA_VERSION_MINOR;
 }
 
-DLLEXPORT int jl_ver_patch(void)
+JL_DLLEXPORT int jl_ver_patch(void)
 {
     return JULIA_VERSION_PATCH;
 }
 
-DLLEXPORT int jl_ver_is_release(void)
+JL_DLLEXPORT int jl_ver_is_release(void)
 {
     return JULIA_VERSION_IS_RELEASE;
 }
 
-DLLEXPORT const char* jl_ver_string(void)
+JL_DLLEXPORT const char *jl_ver_string(void)
 {
    return JULIA_VERSION_STRING;
 }
 
 // return char* from ByteString field in Base.GIT_VERSION_INFO
-static const char *git_info_string(const char *fld) {
+static const char *git_info_string(const char *fld)
+{
     static jl_value_t *GIT_VERSION_INFO = NULL;
     if (!GIT_VERSION_INFO)
         GIT_VERSION_INFO = jl_get_global(jl_base_module, jl_symbol("GIT_VERSION_INFO"));
@@ -289,14 +292,14 @@ static const char *git_info_string(const char *fld) {
     return jl_string_data(f);
 }
 
-DLLEXPORT const char *jl_git_branch()
+JL_DLLEXPORT const char *jl_git_branch(void)
 {
     static const char *branch = NULL;
     if (!branch) branch = git_info_string("branch");
     return branch;
 }
 
-DLLEXPORT const char *jl_git_commit()
+JL_DLLEXPORT const char *jl_git_commit(void)
 {
     static const char *commit = NULL;
     if (!commit) commit = git_info_string("commit");
@@ -304,16 +307,49 @@ DLLEXPORT const char *jl_git_commit()
 }
 
 // Create function versions of some useful macros
-#undef jl_astaggedvalue
-DLLEXPORT jl_taggedvalue_t *jl_astaggedvalue(jl_value_t *v)
+JL_DLLEXPORT jl_taggedvalue_t *(jl_astaggedvalue)(jl_value_t *v)
+{
+    return jl_astaggedvalue(v);
+}
+
+JL_DLLEXPORT jl_value_t *(jl_valueof)(jl_taggedvalue_t *v)
+{
+    return jl_valueof(v);
+}
+
+JL_DLLEXPORT jl_value_t *(jl_typeof)(jl_value_t *v)
+{
+    return jl_typeof(v);
+}
+
+JL_DLLEXPORT int8_t (jl_gc_unsafe_enter)(void)
+{
+    return jl_gc_unsafe_enter();
+}
+
+JL_DLLEXPORT void (jl_gc_unsafe_leave)(int8_t state)
+{
+    jl_gc_unsafe_leave(state);
+}
+
+JL_DLLEXPORT int8_t (jl_gc_safe_enter)(void)
+{
+    return jl_gc_safe_enter();
+}
+
+JL_DLLEXPORT void (jl_gc_safe_leave)(int8_t state)
+{
+    jl_gc_safe_leave(state);
+}
+
+JL_DLLEXPORT void (jl_cpu_pause)(void)
 {
-    return jl_astaggedvalue__MACRO(v);
+    jl_cpu_pause();
 }
 
-#undef jl_typeof
-DLLEXPORT jl_value_t *jl_typeof(jl_value_t *v)
+JL_DLLEXPORT void (jl_cpu_wake)(void)
 {
-    return jl_typeof__MACRO(v);
+    jl_cpu_wake();
 }
 
 #ifdef __cplusplus
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 41fa7bd740898..d97dd3d3995dc 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -1,6 +1,8 @@
 (load "./flisp/aliases.scm")
 (load "utils.scm")
+(load "ast.scm")
 (load "match.scm")
+(load "macroexpand.scm")
 (load "julia-parser.scm")
 (load "julia-syntax.scm")
 
@@ -36,9 +38,9 @@
                                       (put! tab n #t)
                                       tab)))
                 ((lambda)       tab)
-                ((local local!) tab)
+                ((local)        tab)
                 ((break-block)  (find-possible-globals- (caddr e) tab))
-		((module)       '())
+                ((module toplevel) '())
                 (else
                  (for-each (lambda (x) (find-possible-globals- x tab))
                            (cdr e))
@@ -65,78 +67,56 @@
      (find-decls 'global e)
      ;; vars assigned anywhere, if they have been defined as global
      (filter defined-julia-global (find-possible-globals e))))
-   (append
-    (find-decls 'local e)
-    (find-decls 'local! e))))
+   (find-decls 'local e)))
 
 ;; return a lambda expression representing a thunk for a top-level expression
 ;; note: expansion of stuff inside module is delayed, so the contents obey
 ;; toplevel expansion order (don't expand until stuff before is evaluated).
 (define (expand-toplevel-expr-- e)
-  (cond ((or (boolean? e) (eof-object? e)
-             ;; special top-level expressions left alone
-             (and (pair? e) (or (eq? (car e) 'line) (eq? (car e) 'module))))
-         e)
-        ((and (pair? e) (memq (car e) '(import importall using export)))
-         e)
-        ((and (pair? e) (eq? (car e) 'global) (every symbol? (cdr e)))
-         e)
-        (else
-         (let ((ex0 (julia-expand-macros e)))
-           (if (and (pair? ex0) (eq? (car ex0) 'toplevel))
-               `(toplevel ,@(map expand-toplevel-expr (cdr ex0)))
-               (let* ((ex (julia-expand01 ex0))
-                      (gv (toplevel-expr-globals ex))
-                      (th (julia-expand1
-                           `(lambda ()
-                              (scope-block
-                               (block ,@(map (lambda (v) `(implicit-global ,v)) gv)
-                                      ,ex))))))
-                 (if (null? (car (caddr th)))
-                     ;; if no locals, return just body of function
-                     (cadddr th)
-                     `(thunk ,th))))))))
-
-;; (body (= v _) (return v)) => (= v _)
-(define (simple-assignment? e)
-  (and (length= e 3) (eq? (car e) 'body)
-       (pair? (cadr e)) (eq? (caadr e) '=) (symbol? (cadadr e))
-       (eq? (cadr (caddr e)) (cadadr e))))
-
-(define (expand-toplevel-expr- e)
-  (let ((ex (expand-toplevel-expr-- e)))
-    (cond ((contains (lambda (x) (equal? x '(top ccall))) ex) ex)
-          ((simple-assignment? ex)  (cadr ex))
-          ((and (length= ex 2) (eq? (car ex) 'body))
-           ;; (body (return x)) => x
-           (cadadr ex))
-          (else ex))))
+  (let ((ex0 (julia-expand-macros e)))
+    (if (and (pair? ex0) (eq? (car ex0) 'toplevel))
+        `(toplevel ,@(map expand-toplevel-expr (cdr ex0)))
+        (let* ((ex (julia-expand0 ex0))
+               (gv (toplevel-expr-globals ex))
+               (th (julia-expand1
+                    `(lambda () ()
+                             (scope-block
+                              (block ,@(map (lambda (v) `(implicit-global ,v)) gv)
+                                     ,ex))))))
+          (if (and (null? (car (caddr th)))
+                   (= 0 (caddr (caddr th))))
+              ;; if no locals, return just body of function
+              (cadddr th)
+              `(thunk ,th))))))
 
 (define *in-expand* #f)
 
 (define (expand-toplevel-expr e)
-  (if (and (pair? e) (eq? (car e) 'toplevel))
-      ;;`(toplevel ,@(map expand-toplevel-expr (cdr e)))
-      ;; delay expansion so defined global variables take effect for later
-      ;; toplevel expressions.
-      e
-      (let ((last *in-expand*))
-        (if (not last)
-            (begin (reset-gensyms)
-                   (set! *in-expand* #t)))
-        (let ((ex (expand-toplevel-expr- e)))
-          (set! *in-expand* last)
-          ex))))
+  (cond ((or (atom? e)
+             (and (pair? e)
+                  (or (memq (car e) '(toplevel line module import importall using export))
+                      (and (eq? (car e) 'global) (every symbol? (cdr e))))))
+         e)
+        (else
+         (let ((last *in-expand*))
+           (if (not last)
+               (begin (reset-gensyms)
+                      (set! *in-expand* #t)))
+           (let ((ex (expand-toplevel-expr-- e)))
+             (set! *in-expand* last)
+             (if (and (length= ex 2) (eq? (car ex) 'body))
+                 ;; (body (return x)) => x
+                 (cadadr ex)
+                 ex))))))
 
 ;; parse only, returning end position, no expansion.
 (define (jl-parse-one-string s pos0 greedy)
   (let ((inp (open-input-string s)))
     (io.seek inp pos0)
-    (let ((expr
-           (parser-wrap (lambda ()
-                          (if greedy
-                              (julia-parse inp)
-                              (julia-parse inp parse-atom))))))
+    (let ((expr (parser-wrap (lambda ()
+                               (if greedy
+                                   (julia-parse inp)
+                                   (julia-parse inp parse-atom))))))
       (cons expr (io.pos inp)))))
 
 (define (jl-parse-string s)
@@ -156,39 +136,37 @@
                                (loop (nreconc (cdr expr) exprs))
                                (loop (cons expr exprs))))))))))
 
+(define (jl-parse-all io filename)
+  (unwind-protect
+   (with-bindings ((current-filename (symbol filename)))
+    (let ((stream (make-token-stream io)))
+      (let loop ((exprs '()))
+        (let ((lineno (parser-wrap
+                       (lambda ()
+                         (skip-ws-and-comments (ts:port stream))
+                         (input-port-line (ts:port stream))))))
+          (if (pair? lineno)
+              (cons 'toplevel (reverse! (cons lineno exprs)))
+              (let ((expr (parser-wrap
+                           (lambda ()
+                             (julia-parse stream)))))
+                (if (eof-object? expr)
+                    (cons 'toplevel (reverse! exprs))
+                    (let ((next (list* expr `(line ,lineno) exprs)))
+                      (if (and (pair? expr) (eq? (car expr) 'error))
+                          (cons 'toplevel (reverse! next))
+                          (loop next))))))))))
+   (io.close io)))
+
 ;; parse file-in-a-string
 (define (jl-parse-string-stream str filename)
-  (jl-parser-set-stream filename (open-input-string str)))
+  (jl-parse-all (open-input-string str) filename))
 
-(define (jl-parse-file s)
+(define (jl-parse-file filename)
   (trycatch
-   (let ((b (buffer))
-	 (f (open-input-file s)))
-     ;; read whole file first to avoid problems with concurrent modification (issue #10497)
-     (io.copy b f)
-     (io.close f)
-     (io.seek b 0)
-     (begin (jl-parser-set-stream s b)
-	    #t))
+   (jl-parse-all (open-input-file filename) filename)
    (lambda (e) #f)))
 
-(define *filename-stack* '())
-(define *ts-stack* '())
-(define current-token-stream #())
-
-(define (jl-parser-set-stream name stream)
-  (set! *filename-stack* (cons current-filename *filename-stack*))
-  (set! *ts-stack* (cons current-token-stream *ts-stack*))
-  (set! current-filename (symbol name))
-  (set! current-token-stream (make-token-stream stream)))
-
-(define (jl-parser-close-stream)
-  (io.close (ts:port current-token-stream))
-  (set! current-filename (car *filename-stack*))
-  (set! current-token-stream (car *ts-stack*))
-  (set! *filename-stack* (cdr *filename-stack*))
-  (set! *ts-stack* (cdr *ts-stack*)))
-
 (define *depwarn* #t)
 (define (jl-parser-depwarn w)
   (let ((prev *depwarn*))
@@ -201,27 +179,6 @@
     (set! *deperror* (eq? e #t))
     prev))
 
-(define (jl-parser-next)
-  (let* ((err (parser-wrap
-               (lambda ()
-                 (skip-ws-and-comments (ts:port current-token-stream)))))
-         (lineno (input-port-line (ts:port current-token-stream))))
-    (cons lineno
-          (if (pair? err)
-              err
-              (parser-wrap
-               (lambda ()
-                 (let ((e (julia-parse current-token-stream)))
-                   (if (eof-object? e)
-                       e
-                       (if (and (pair? e) (or (eq? (car e) 'error)
-                                              (eq? (car e) 'continue)))
-                           e
-                           (expand-toplevel-expr e))))))))))
-
-(define (jl-parser-current-lineno)
-  (input-port-line (ts:port current-token-stream)))
-
 ; expand a piece of raw surface syntax to an executable thunk
 (define (jl-expand-to-thunk expr)
   (parser-wrap (lambda ()
diff --git a/src/jltypes.c b/src/jltypes.c
index da8cbbfd14f7e..e0bda324ed812 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -35,6 +35,8 @@ jl_datatype_t *jl_vararg_type;
 jl_datatype_t *jl_tvar_type;
 jl_datatype_t *jl_uniontype_type;
 jl_datatype_t *jl_datatype_type;
+jl_datatype_t *jl_function_type;
+jl_datatype_t *jl_builtin_type;
 
 jl_value_t *jl_bottom_type;
 jl_datatype_t *jl_abstractarray_type;
@@ -50,6 +52,7 @@ jl_datatype_t *jl_int32_type;
 jl_datatype_t *jl_uint32_type;
 jl_datatype_t *jl_int64_type;
 jl_datatype_t *jl_uint64_type;
+jl_datatype_t *jl_float16_type;
 jl_datatype_t *jl_float32_type;
 jl_datatype_t *jl_float64_type;
 jl_datatype_t *jl_floatingpoint_type;
@@ -57,10 +60,12 @@ jl_datatype_t *jl_number_type;
 jl_datatype_t *jl_complex_type;
 jl_datatype_t *jl_signed_type;
 
-DLLEXPORT jl_value_t *jl_emptytuple=NULL;
+JL_DLLEXPORT jl_value_t *jl_emptytuple=NULL;
 jl_svec_t *jl_emptysvec;
 jl_value_t *jl_nothing;
 
+jl_datatype_t *jl_carnavalue;
+
 // --- type properties and predicates ---
 
 int jl_is_type(jl_value_t *v)
@@ -122,7 +127,7 @@ static int jl_has_typevars__(jl_value_t *v, int incl_wildcard, jl_value_t **p, s
     return 0;
 }
 
-static int jl_has_typevars_(jl_value_t *v, int incl_wildcard)
+JL_DLLEXPORT int jl_has_typevars_(jl_value_t *v, int incl_wildcard)
 {
     if (jl_is_typevar(v)) return 1;
     return jl_has_typevars__(v, incl_wildcard, NULL, 0);
@@ -140,13 +145,13 @@ static int jl_has_typevars_from_v(jl_value_t *v, jl_value_t **p, size_t np)
     return jl_has_typevars__(v, 0, p, np);
 }
 
-DLLEXPORT int jl_has_typevars(jl_value_t *v)
+JL_DLLEXPORT int jl_has_typevars(jl_value_t *v)
 {
     if (jl_is_typevar(v)) return 1;
     return jl_has_typevars__(v, 0, NULL, 0);
 }
 
-int jl_is_leaf_type(jl_value_t *v)
+JL_DLLEXPORT int jl_is_leaf_type(jl_value_t *v)
 {
     if (jl_is_datatype(v)) {
         if (((jl_datatype_t*)v)->abstract) {
@@ -177,7 +182,7 @@ static int type_eqv_(jl_value_t *a, jl_value_t *b);
 
 // Return true for any type (Integer or Unsigned) that can fit in a
 // size_t and pass back value, else return false
-int jl_get_size(jl_value_t *val, size_t *pnt)
+JL_DLLEXPORT int jl_get_size(jl_value_t *val, size_t *pnt)
 {
     if (jl_is_long(val)) {
         ssize_t slen = jl_unbox_long(val);
@@ -277,12 +282,12 @@ static jl_svec_t *jl_compute_type_union(jl_value_t **types, size_t ntypes)
     // sort Union components by specificity, so "complex" type Unions work as
     // long as there are no ambiguities (see e.g. issue #126).
     // TODO: maybe warn about ambiguities
-    qsort(result->data, j, sizeof(jl_value_t*), union_elt_morespecific);
+    qsort(jl_svec_data(result), j, sizeof(jl_value_t*), union_elt_morespecific);
     JL_GC_POP();
     return result;
 }
 
-jl_value_t *jl_type_union_v(jl_value_t **ts, size_t n)
+static jl_value_t *jl_type_union_v(jl_value_t **ts, size_t n)
 {
     if (n == 0) return (jl_value_t*)jl_bottom_type;
     size_t i;
@@ -303,7 +308,7 @@ jl_value_t *jl_type_union_v(jl_value_t **ts, size_t n)
     return (jl_value_t*)tu;
 }
 
-jl_value_t *jl_type_union(jl_svec_t *types)
+JL_DLLEXPORT jl_value_t *jl_type_union(jl_svec_t *types)
 {
     return jl_type_union_v(jl_svec_data(types), jl_svec_len(types));
 }
@@ -368,9 +373,16 @@ static jl_value_t *intersect_union(jl_uniontype_t *a, jl_value_t *b,
                                    cenv_t *penv, cenv_t *eqc, variance_t var)
 {
     int eq0 = eqc->n, co0 = penv->n;
-    jl_svec_t *t = jl_alloc_svec(jl_svec_len(a->types));
+    size_t i, l = jl_svec_len(a->types);
+    // shortcut an easy case: union contains type b
+    if (!jl_is_typevar(b)) {
+        for(i=0; i < l; i++) {
+            if (jl_svecref(a->types,i) == b)
+                return b;
+        }
+    }
+    jl_svec_t *t = jl_alloc_svec(l);
     JL_GC_PUSH1(&t);
-    size_t i, l=jl_svec_len(t);
     for(i=0; i < l; i++) {
         int eq_l = eqc->n, co_l = penv->n;
         jl_value_t *ti = jl_type_intersect(jl_svecref(a->types,i), b,
@@ -637,34 +649,6 @@ static long meet_tuple_lengths(long bv, long vv, int *bot)
     return vv;
 }
 
-// convert a type to the value it would have if assigned to a static parameter
-// in covariant context.
-// example: {Type{Int},} => {DataType,}
-// calling f{T}(x::T) as f({Int,}) should give T == {DataType,}, but we
-// might temporarily represent this type as {Type{Int},} for more precision.
-static jl_value_t *type_to_static_parameter_value(jl_value_t *t)
-{
-    if (jl_is_type_type(t) && !jl_is_typevar(jl_tparam0(t)))
-        return jl_typeof(jl_tparam0(t));
-    if (jl_is_tuple_type(t)) {
-        jl_svec_t *p = ((jl_datatype_t*)t)->parameters;
-        size_t l = jl_svec_len(p);
-        int changed = 0;
-        jl_svec_t *np = jl_alloc_svec(l);
-        JL_GC_PUSH1(&np);
-        for(size_t i=0; i < l; i++) {
-            jl_value_t *el = type_to_static_parameter_value(jl_svecref(p,i));
-            jl_svecset(np, i, el);
-            if (el != jl_svecref(p,i))
-                changed = 1;
-        }
-        jl_value_t *result = changed ? (jl_value_t*)jl_apply_tuple_type(np) : t;
-        JL_GC_POP();
-        return result;
-    }
-    return t;
-}
-
 static int match_intersection_mode = 0;
 static jl_value_t *meet_tvars(jl_tvar_t *a, jl_tvar_t *b);
 
@@ -674,10 +658,6 @@ static jl_value_t *intersect_typevar(jl_tvar_t *a, jl_value_t *b,
     jl_value_t *both=NULL;
     jl_tvar_t *new_b=NULL;
     JL_GC_PUSH3(&b, &both, &new_b);
-    if (var == covariant) {
-        // matching T to Type{S} in covariant context
-        b = type_to_static_parameter_value(b);
-    }
     if (jl_subtype(b, (jl_value_t*)a, 0)) {
         if (!is_bnd(a,penv)) {
             JL_GC_POP();
@@ -704,6 +684,10 @@ static jl_value_t *intersect_typevar(jl_tvar_t *a, jl_value_t *b,
             }
         }
         else {
+            if (a->ub == jl_bottom_type) {
+                JL_GC_POP();
+                return jl_bottom_type;
+            }
             if (!is_bnd(a,penv)) {
                 JL_GC_POP();
                 return (jl_value_t*)a;
@@ -765,11 +749,6 @@ static jl_value_t *intersect_typevar(jl_tvar_t *a, jl_value_t *b,
                     JL_GC_POP();
                     return (jl_value_t*)a;
                 }
-                jl_value_t *ti = jl_type_intersection(b, penv->data[i+1]);
-                if (ti == (jl_value_t*)jl_bottom_type) {
-                    JL_GC_POP();
-                    return ti;
-                }
                 break;
             }
         }
@@ -870,7 +849,7 @@ static jl_value_t *jl_type_intersect(jl_value_t *a, jl_value_t *b,
     if (b == (jl_value_t*)jl_any_type || b == jl_ANY_flag) return a;
     // tuple
     if (jl_is_tuple_type(a)) {
-        long alen = (long)jl_nparams(a);
+        size_t alen = jl_nparams(a);
         jl_value_t *temp=NULL;
         JL_GC_PUSH2(&b, &temp);
         if (jl_is_ntuple_type(b)) {
@@ -882,7 +861,7 @@ static jl_value_t *jl_type_intersect(jl_value_t *a, jl_value_t *b,
                 if (eqc->data[i] == lenvar) {
                     jl_value_t *v = eqc->data[i+1];
                     // N is already known in NTuple{N,...}
-                    if (jl_get_size(v, (size_t *)&alen)) break;
+                    if (jl_get_size(v, &alen)) break;
                 }
             }
             b = (jl_value_t*)jl_tupletype_fill(alen, elty);
@@ -1119,7 +1098,7 @@ static jl_value_t *jl_type_intersect(jl_value_t *a, jl_value_t *b,
     return result;
 }
 
-jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b)
+JL_DLLEXPORT jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b)
 {
     jl_svec_t *env = jl_emptysvec;
     JL_GC_PUSH1(&env);
@@ -1266,13 +1245,48 @@ static jl_value_t *meet(jl_value_t *X, jl_value_t *Y, variance_t var)
     return (v == (jl_value_t*)jl_bottom_type ?  NULL : v);
 }
 
+// convert a type to the value it would have if assigned to a static parameter
+// in covariant context.
+// example: {Type{Int},} => {DataType,}
+// calling f{T}(x::T) as f({Int,}) should give T == {DataType,}, but we
+// might temporarily represent this type as {Type{Int},} for more precision.
+static jl_value_t *type_to_static_parameter_value(jl_value_t *t, jl_value_t *tv, jl_value_t **tvs, int ntv)
+{
+    int i;
+    for(i=0; i < ntv; i++) {
+        if (tv == tvs[i])
+            break;
+    }
+    if (i >= ntv)
+        return t;  // don't widen vars not in env
+    if (jl_is_type_type(t) && !jl_is_typevar(jl_tparam0(t)))
+        return jl_typeof(jl_tparam0(t));
+    if (jl_is_tuple_type(t)) {
+        jl_svec_t *p = ((jl_datatype_t*)t)->parameters;
+        size_t l = jl_svec_len(p);
+        int changed = 0;
+        jl_svec_t *np = jl_alloc_svec(l);
+        JL_GC_PUSH1(&np);
+        for(size_t i=0; i < l; i++) {
+            jl_value_t *el = type_to_static_parameter_value(jl_svecref(p,i), NULL, NULL, 0);
+            jl_svecset(np, i, el);
+            if (el != jl_svecref(p,i))
+                changed = 1;
+        }
+        jl_value_t *result = changed ? (jl_value_t*)jl_apply_tuple_type(np) : t;
+        JL_GC_POP();
+        return result;
+    }
+    return t;
+}
+
 /*
 void print_env(cenv_t *soln)
 {
     for(int i=0; i < soln->n; i+=2) {
         jl_value_t *T, *S;
         T = soln->data[i]; S = soln->data[i+1];
-        jl_printf(JL_STDOUT, "%s@%x=", ((jl_tvar_t*)T)->name->name, T);
+        jl_printf(JL_STDOUT, "%s@%x=", jl_symbol_name(((jl_tvar_t*)T)->name), T);
         jl_static_show(JL_STDOUT, S);
         jl_printf(JL_STDOUT, " ");
     }
@@ -1280,8 +1294,11 @@ void print_env(cenv_t *soln)
 }
 */
 
-static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
+static int solve_tvar_constraints(cenv_t *env, cenv_t *soln, jl_value_t **tvs, int ntv)
 {
+    jl_value_t *rt1=NULL, *rt2=NULL, *S=NULL;
+    JL_GC_PUSH3(&rt1, &rt2, &S);
+
     while (1) {
         int old_n = soln->n;
 
@@ -1293,7 +1310,7 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
             if (!jl_is_typevar(*pS)) {
                 // detect cycles
                 if (jl_has_typevars_from_v(*pS, &soln->data[i], 1))
-                    return 0;
+                    goto ret_no;
             }
         }
 
@@ -1313,7 +1330,7 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
         for(int i=0; i < env->n; i+=2) {
             jl_value_t *T = env->data[i];
             jl_value_t **pS = &env->data[i+1];
-            jl_value_t *S = *pS;
+            S = *pS;
             if (!jl_is_typevar(S)) {
                 for(int j=i+2; j < env->n; j+=2) {
                     jl_value_t *TT = env->data[j];
@@ -1321,8 +1338,10 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
                     if (TT == T) {
                         // found T=SS in env
                         if (!jl_is_typevar(SS)) {
-                            jl_value_t *m = meet(S, SS, covariant);
-                            if (m == NULL) return 0;
+                            rt1 = type_to_static_parameter_value(S, T, tvs, ntv);
+                            rt2 = type_to_static_parameter_value(SS, TT, tvs, ntv);
+                            jl_value_t *m = meet(rt1, rt2, covariant);
+                            if (m == NULL) goto ret_no;
                             S = m;
                         }
                     }
@@ -1331,7 +1350,7 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
                         jl_value_t **pTT = tvar_lookup(soln, &TT);
                         if (pTT != &TT) {
                             jl_value_t *m = meet(S, *pTT, covariant);
-                            if (m == NULL) return 0;
+                            if (m == NULL) goto ret_no;
                             S = m;
                         }
                     }
@@ -1348,18 +1367,18 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
                         int bot = 0;
                         long mv = meet_tuple_lengths(~lenS, lenT, &bot);
                         if (bot)
-                            return 0;
+                            goto ret_no;
                         // NOTE: this is unused. can we do anything with it?
                         (void)mv;
                         //S = jl_box_long(mv);
                     }
                     else {
                         if (meet(*pT,S,covariant) == NULL)
-                            return 0;
+                            goto ret_no;
                     }
                 }
                 else {
-                    extend(T, S, soln);
+                    extend(T, type_to_static_parameter_value(S, T, tvs, ntv), soln);
                 }
             }
             else {
@@ -1367,7 +1386,7 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
                 if (pT != &T) {
                     if (tvar_lookup(soln, &S) == &S) {
                         jl_value_t *v = meet(S, *pT, covariant);
-                        if (v == NULL) return 0;
+                        if (v == NULL) goto ret_no;
                         extend(S, v, soln);
                         *pT = S;
                     }
@@ -1383,19 +1402,21 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
     for(int i=0; i < env->n; i+=2) {
         jl_value_t *T = env->data[i];
         jl_value_t **pS = &env->data[i+1];
-        jl_value_t *S = *pS;
+        S = *pS;
         if (tvar_lookup(soln, &T) == &T) {
             for(int j=i+2; j < env->n; j+=2) {
                 jl_value_t *TT = env->data[j];
                 jl_value_t *SS = env->data[j+1];
                 if (TT == T) {
-                    jl_value_t *m = meet(S, SS, covariant);
-                    if (m == NULL) return 0;
+                    rt1 = type_to_static_parameter_value(S, T, tvs, ntv);
+                    rt2 = type_to_static_parameter_value(SS, TT, tvs, ntv);
+                    jl_value_t *m = meet(rt1, rt2, covariant);
+                    if (m == NULL) goto ret_no;
                     S = m;
                 }
                 else if (SS == T) {
                     jl_value_t *m = meet(S, *tvar_lookup(soln, &TT), covariant);
-                    if (m == NULL) return 0;
+                    if (m == NULL) goto ret_no;
                     S = m;
                 }
             }
@@ -1404,12 +1425,16 @@ static int solve_tvar_constraints(cenv_t *env, cenv_t *soln)
                     S = (jl_value_t*)jl_new_typevar(underscore_sym,
                                                     (jl_value_t*)jl_bottom_type, S);
                 }
-                extend(T, S, soln);
+                extend(T, type_to_static_parameter_value(S, T, tvs, ntv), soln);
             }
         }
     }
 
+    JL_GC_POP();
     return 1;
+ ret_no:
+    JL_GC_POP();
+    return 0;
 }
 
 jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
@@ -1467,14 +1492,6 @@ jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
         }
     }
 
-    if (!solve_tvar_constraints(&env, &eqc)) {
-        JL_GC_POP();
-        return (jl_value_t*)jl_bottom_type;
-    }
-    //jl_printf(JL_STDOUT, "env: "); print_env(&env);
-    //jl_printf(JL_STDOUT, "sol: "); print_env(&eqc);
-
-    int env0 = eqc.n;
     jl_value_t **tvs;
     int tvarslen;
     if (jl_is_typevar(tvars)) {
@@ -1486,6 +1503,15 @@ jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
         tvs = jl_svec_data(tvars);
         tvarslen = jl_svec_len(tvars);
     }
+
+    if (!solve_tvar_constraints(&env, &eqc, tvs, tvarslen)) {
+        JL_GC_POP();
+        return (jl_value_t*)jl_bottom_type;
+    }
+    //jl_printf(JL_STDOUT, "env: "); print_env(&env);
+    //jl_printf(JL_STDOUT, "sol: "); print_env(&eqc);
+
+    int env0 = eqc.n;
     for(int tk=0; tk < tvarslen; tk++) {
         jl_tvar_t *tv = (jl_tvar_t*)tvs[tk];
         for(e=0; e < env0; e+=2) {
@@ -1560,13 +1586,12 @@ jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
     }
 
     // return environment in same order as tvars
-    *penv = jl_alloc_svec_uninit(tvarslen*2);
+    *penv = jl_alloc_svec_uninit(tvarslen);
     for(int tk=0; tk < tvarslen; tk++) {
         jl_tvar_t *tv = (jl_tvar_t*)tvs[tk];
         for(e=0; e < eqc.n; e+=2) {
             if (eqc.data[e] == (jl_value_t*)tv) {
-                jl_svecset(*penv, tk*2, tv);
-                jl_svecset(*penv, tk*2+1, eqc.data[e+1]);
+                jl_svecset(*penv, tk, eqc.data[e+1]);
             }
         }
     }
@@ -1584,8 +1609,6 @@ static int extensionally_same_type(jl_value_t *a, jl_value_t *b)
     return jl_subtype(a, b, 0) && jl_subtype(b, a, 0);
 }
 
-static int type_eqv_(jl_value_t *a, jl_value_t *b);
-
 static int type_eqv__(jl_value_t *a, jl_value_t *b, int distinguish_tctor)
 {
     if (a == b) return 1;
@@ -1594,7 +1617,7 @@ static int type_eqv__(jl_value_t *a, jl_value_t *b, int distinguish_tctor)
     if (jl_is_typector(b)) b = (jl_value_t*)((jl_typector_t*)b)->body;
     if (jl_is_typevar(a)) {
         if (jl_is_typevar(b)) {
-            return type_eqv_(((jl_tvar_t*)a)->ub, ((jl_tvar_t*)b)->ub) &&
+            return !distinguish_tctor && type_eqv_(((jl_tvar_t*)a)->ub, ((jl_tvar_t*)b)->ub) &&
                 type_eqv_(((jl_tvar_t*)a)->lb, ((jl_tvar_t*)b)->lb);
         }
         else {
@@ -1635,7 +1658,7 @@ static int type_eqv_(jl_value_t *a, jl_value_t *b)
     return type_eqv__(a, b, 0);
 }
 
-int jl_types_equal(jl_value_t *a, jl_value_t *b)
+JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b)
 {
     return type_eqv_(a, b);
 }
@@ -1708,7 +1731,7 @@ jl_value_t *jl_apply_type_(jl_value_t *tc, jl_value_t **params, size_t n)
     else {
         assert(jl_is_datatype(tc));
         tp = ((jl_datatype_t*)tc)->parameters;
-        tname = ((jl_datatype_t*)tc)->name->name->name;
+        tname = jl_symbol_name(((jl_datatype_t*)tc)->name->name);
         stprimary = (jl_datatype_t*)((jl_datatype_t*)tc)->name->primary;
     }
     for(i=0; i < n; i++) {
@@ -1774,7 +1797,7 @@ jl_value_t *jl_apply_type_(jl_value_t *tc, jl_value_t **params, size_t n)
     return (jl_value_t*)result;
 }
 
-jl_value_t *jl_apply_type(jl_value_t *tc, jl_svec_t *params)
+JL_DLLEXPORT jl_value_t *jl_apply_type(jl_value_t *tc, jl_svec_t *params)
 {
     // NOTE: callers are supposed to root these arguments, but there are
     // several uses that don't, so root here just to be safe.
@@ -1784,7 +1807,7 @@ jl_value_t *jl_apply_type(jl_value_t *tc, jl_svec_t *params)
     return t;
 }
 
-DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v)
+JL_DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v)
 {
     // TODO: replace with just using NTuple
     jl_value_t *p = NULL;
@@ -1797,7 +1820,7 @@ DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v)
 
 static int contains_unions(jl_value_t *type)
 {
-    if (jl_is_uniontype(type)) return 1;
+    if (jl_is_uniontype(type)) return type != jl_bottom_type;
     if (jl_is_typector(type)) return contains_unions(((jl_typector_t*)type)->body);
     if (!jl_is_datatype(type)) return 0;
     int i;
@@ -1815,10 +1838,13 @@ static int is_typekey_ordered(jl_value_t **key, size_t n)
     size_t i;
     for(i=0; i < n; i++) {
         jl_value_t *k = key[i];
+        if (jl_is_typevar(k))
+            return 0;
         if (jl_is_type(k) &&
             !(jl_is_datatype(k) && (((jl_datatype_t*)k)->uid ||
                                     k == ((jl_datatype_t*)k)->name->primary ||
-                                    (!jl_has_typevars_(k,1) && !contains_unions(k)))))
+                                    (!jl_has_typevars_(k,1) && !contains_unions(k)))) &&
+            k != jl_bottom_type)
             return 0;
     }
     return 1;
@@ -1839,8 +1865,8 @@ static int typekey_compare(jl_datatype_t *tt, jl_value_t **key, size_t n)
             int dtk = jl_is_datatype(kj);
             if (!dtt && !dtk && jl_egal(tj, kj))
                 continue;
-            uptrint_t tid = (dtt && ((jl_datatype_t*)tj)->uid ? ((jl_datatype_t*)tj)->uid : jl_object_id(tj));
-            uptrint_t kid = (dtk && ((jl_datatype_t*)kj)->uid ? ((jl_datatype_t*)kj)->uid : jl_object_id(kj));
+            uintptr_t tid = (dtt && ((jl_datatype_t*)tj)->uid ? ((jl_datatype_t*)tj)->uid : jl_object_id(tj));
+            uintptr_t kid = (dtk && ((jl_datatype_t*)kj)->uid ? ((jl_datatype_t*)kj)->uid : jl_object_id(kj));
             if (kid != tid)
                 return kid < tid ? -1 : 1;
         }
@@ -1861,6 +1887,8 @@ static int typekey_eq(jl_datatype_t *tt, jl_value_t **key, size_t n)
     return 1;
 }
 
+JL_DEFINE_MUTEX_EXT(typecache);
+
 // look up a type in a cache by binary or linear search.
 // if found, returns the index of the found item. if not found, returns
 // ~n, where n is the index where the type should be inserted.
@@ -1903,11 +1931,14 @@ static ssize_t lookup_type_idx(jl_typename_t *tn, jl_value_t **key, size_t n, in
 static jl_value_t *lookup_type(jl_typename_t *tn, jl_value_t **key, size_t n)
 {
     int ord = is_typekey_ordered(key, n);
+    JL_LOCK(typecache); // Might GC
     ssize_t idx = lookup_type_idx(tn, key, n, ord);
-    return (idx < 0) ? NULL : jl_svecref(ord ? tn->cache : tn->linearcache, idx);
+    jl_value_t *t = (idx < 0) ? NULL : jl_svecref(ord ? tn->cache : tn->linearcache, idx);
+    JL_UNLOCK(typecache);
+    return t;
 }
 
-static int t_uid_ctr = 1;
+static volatile int t_uid_ctr = 1;
 
 int  jl_get_t_uid_ctr(void) { return t_uid_ctr; }
 void jl_set_t_uid_ctr(int i) { t_uid_ctr=i; }
@@ -1915,7 +1946,7 @@ void jl_set_t_uid_ctr(int i) { t_uid_ctr=i; }
 int jl_assign_type_uid(void)
 {
     assert(t_uid_ctr != 0);
-    return t_uid_ctr++;
+    return jl_atomic_fetch_add(&t_uid_ctr, 1);
 }
 
 static int is_cacheable(jl_datatype_t *type)
@@ -1929,12 +1960,12 @@ static int is_cacheable(jl_datatype_t *type)
             return 0;
     }
     else {
-        if (jl_has_typevars_((jl_value_t*)type,0))
+        if (jl_is_leaf_type((jl_value_t*)type))
+            return 1;
+        if (jl_has_typevars_((jl_value_t*)type,1))
             return 0;
         for(int i=0; i < jl_svec_len(t); i++) {
             jl_value_t *pi = jl_svecref(t,i);
-            if (jl_is_typevar(pi))
-                return 0;
             if (type->name == jl_tuple_typename && !jl_is_leaf_type(pi))
                 return 0;
         }
@@ -1983,11 +2014,14 @@ jl_value_t *jl_cache_type_(jl_datatype_t *type)
 {
     if (is_cacheable(type)) {
         int ord = is_typekey_ordered(jl_svec_data(type->parameters), jl_svec_len(type->parameters));
-        ssize_t idx = lookup_type_idx(type->name, type->parameters->data,
+        JL_LOCK(typecache); // Might GC
+        ssize_t idx = lookup_type_idx(type->name, jl_svec_data(type->parameters),
                                       jl_svec_len(type->parameters), ord);
         if (idx >= 0)
-            return jl_svecref(ord ? type->name->cache : type->name->linearcache, idx);
-        cache_insert_type((jl_value_t*)type, ~idx, ord);
+            type = (jl_datatype_t*)jl_svecref(ord ? type->name->cache : type->name->linearcache, idx);
+        else
+            cache_insert_type((jl_value_t*)type, ~idx, ord);
+        JL_UNLOCK(typecache);
     }
     return (jl_value_t*)type;
 }
@@ -2059,7 +2093,7 @@ static jl_value_t *inst_datatype(jl_datatype_t *dt, jl_svec_t *p, jl_value_t **i
     }
 
     // create and initialize new type
-    ndt = jl_new_uninitialized_datatype(istuple ? ntp : dt->nfields);
+    ndt = jl_new_uninitialized_datatype(istuple ? ntp : dt->nfields, 2); // TODO
     // associate these parameters with the new type on
     // the stack, in case one of its field types references it.
     top.tt = (jl_datatype_t*)ndt;
@@ -2155,12 +2189,12 @@ static jl_tupletype_t *jl_apply_tuple_type_v_(jl_value_t **p, size_t np, jl_svec
     return ndt;
 }
 
-DLLEXPORT jl_tupletype_t *jl_apply_tuple_type(jl_svec_t *params)
+JL_DLLEXPORT jl_tupletype_t *jl_apply_tuple_type(jl_svec_t *params)
 {
     return jl_apply_tuple_type_v_(jl_svec_data(params), jl_svec_len(params), params);
 }
 
-DLLEXPORT jl_tupletype_t *jl_apply_tuple_type_v(jl_value_t **p, size_t np)
+JL_DLLEXPORT jl_tupletype_t *jl_apply_tuple_type_v(jl_value_t **p, size_t np)
 {
     return jl_apply_tuple_type_v_(p, np, NULL);
 }
@@ -2217,6 +2251,8 @@ static jl_value_t *inst_tuple_w_(jl_value_t *t, jl_value_t **env, size_t n,
     for(i=0; i < ntp; i++) {
         jl_value_t *elt = jl_svecref(tp, i);
         iparams[i] = (jl_value_t*)inst_type_w_(elt, env, n, stack, 0);
+        if (ip_heap)
+            jl_gc_wb(ip_heap, iparams[i]);
         jl_value_t *pi = iparams[i];
         check_tuple_parameter(pi, i, ntp);
         if (!isabstract && !jl_is_leaf_type(pi)) {
@@ -2242,7 +2278,7 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_value_t **env, size_t n,
                 jl_value_t *val = env[i*2+1];
                 if (check && !jl_is_typevar(val) && !jl_subtype(val, t, 0)) {
                     jl_type_error_rt("type parameter",
-                                     ((jl_tvar_t*)t)->name->name,
+                                     jl_symbol_name(((jl_tvar_t*)t)->name),
                                      t, val);
                 }
                 return val;
@@ -2286,8 +2322,8 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_value_t **env, size_t n,
             iparams[i] = (jl_value_t*)inst_type_w_(elt, env, n, stack, elt != tv);
             if (jl_is_typevar(tv) && !jl_is_typevar(iparams[i])) {
                 if (!jl_subtype(iparams[i], tv, 0)) {
-                    jl_type_error_rt(tt->name->name->name,
-                                     ((jl_tvar_t*)tv)->name->name,
+                    jl_type_error_rt(jl_symbol_name(tt->name->name),
+                                     jl_symbol_name(((jl_tvar_t*)tv)->name),
                                      tv, iparams[i]);
                 }
             }
@@ -2337,6 +2373,9 @@ void jl_reinstantiate_inner_types(jl_datatype_t *t)
     top.tt = t;
     top.prev = NULL;
     size_t n = jl_svec_len(t->parameters);
+    if (n == 0) return;
+    t->name->cache = jl_emptysvec;
+    t->name->linearcache = jl_emptysvec;
     jl_value_t **env = (jl_value_t**)alloca(n*2*sizeof(void*));
     for(int i=0; i < n; i++) {
         env[i*2] = jl_svecref(t->parameters,i);
@@ -2454,6 +2493,8 @@ static int jl_subtype_le(jl_value_t *a, jl_value_t *b, int ta, int invariant)
             if (jl_subtype_le(a, jl_svecref(bp,i), ta, invariant))
                 return 1;
         }
+        if (!ta && jl_is_typevar(a) && ((jl_tvar_t*)a)->ub == jl_bottom_type)
+            return 1;
         return 0;
     }
 
@@ -2556,7 +2597,7 @@ static int jl_subtype_le(jl_value_t *a, jl_value_t *b, int ta, int invariant)
     return jl_egal(a, b);
 }
 
-int jl_subtype(jl_value_t *a, jl_value_t *b, int ta)
+JL_DLLEXPORT int jl_subtype(jl_value_t *a, jl_value_t *b, int ta)
 {
     return jl_subtype_le(a, b, ta, 0);
 }
@@ -2797,7 +2838,7 @@ static int jl_type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
     return 0;
 }
 
-DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b)
+JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b)
 {
     return jl_type_morespecific_(a, b, 0);
 }
@@ -3122,7 +3163,8 @@ jl_value_t *jl_type_match_morespecific(jl_value_t *a, jl_value_t *b)
 
 // initialization -------------------------------------------------------------
 
-DLLEXPORT jl_tvar_t *jl_new_typevar_(jl_sym_t *name, jl_value_t *lb, jl_value_t *ub, jl_value_t *b)
+JL_DLLEXPORT jl_tvar_t *jl_new_typevar_(jl_sym_t *name, jl_value_t *lb,
+                                        jl_value_t *ub, jl_value_t *b)
 {
     jl_tvar_t *tv = (jl_tvar_t*)newobj((jl_value_t*)jl_tvar_type, 4);
     tv->name = name;
@@ -3132,7 +3174,8 @@ DLLEXPORT jl_tvar_t *jl_new_typevar_(jl_sym_t *name, jl_value_t *lb, jl_value_t
     return tv;
 }
 
-jl_tvar_t *jl_new_typevar(jl_sym_t *name, jl_value_t *lb, jl_value_t *ub)
+JL_DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name, jl_value_t *lb,
+                                       jl_value_t *ub)
 {
     return jl_new_typevar_(name, lb, ub, jl_false);
 }
@@ -3148,12 +3191,14 @@ extern void jl_init_int32_int64_cache(void);
 void jl_init_types(void)
 {
     // create base objects
-    jl_datatype_type = jl_new_uninitialized_datatype(10);
+    jl_datatype_type = jl_new_uninitialized_datatype(10, 1);
     jl_set_typeof(jl_datatype_type, jl_datatype_type);
-    jl_typename_type = jl_new_uninitialized_datatype(7);
-    jl_sym_type = jl_new_uninitialized_datatype(0);
+    jl_typename_type = jl_new_uninitialized_datatype(8, 1);
+    jl_sym_type = jl_new_uninitialized_datatype(0, 1);
     jl_symbol_type = jl_sym_type;
-    jl_simplevector_type = jl_new_uninitialized_datatype(1);
+    jl_simplevector_type = jl_new_uninitialized_datatype(1, 1);
+    jl_methtable_type = jl_new_uninitialized_datatype(8, 1);
+    jl_nothing = jl_gc_alloc_0w();
 
     jl_emptysvec = (jl_svec_t*)newobj((jl_value_t*)jl_simplevector_type, 1);
     jl_svec_set_len_unsafe(jl_emptysvec, 0);
@@ -3161,6 +3206,7 @@ void jl_init_types(void)
     jl_any_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Any"), NULL, jl_emptysvec);
     jl_any_type->super = jl_any_type;
     jl_type_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Type"), jl_any_type, jl_emptysvec);
+    jl_type_type->name->mt = jl_new_method_table(jl_type_type->name->name, jl_current_module);
 
     // initialize them. lots of cycles.
     jl_datatype_type->name = jl_new_typename(jl_symbol("DataType"));
@@ -3185,6 +3231,7 @@ void jl_init_types(void)
     jl_datatype_type->instance = NULL;
     jl_datatype_type->uid = jl_assign_type_uid();
     jl_datatype_type->struct_decl = NULL;
+    jl_datatype_type->ditype = NULL;
     jl_datatype_type->abstract = 0;
     jl_datatype_type->pointerfree = 0;
     // NOTE: types should not really be mutable, but the instance and
@@ -3194,25 +3241,48 @@ void jl_init_types(void)
 
     jl_typename_type->name = jl_new_typename(jl_symbol("TypeName"));
     jl_typename_type->name->primary = (jl_value_t*)jl_typename_type;
+    jl_typename_type->name->mt = jl_new_method_table(jl_typename_type->name->name, jl_current_module);
     jl_typename_type->super = jl_any_type;
     jl_typename_type->parameters = jl_emptysvec;
-    jl_typename_type->name->names = jl_svec(7, jl_symbol("name"), jl_symbol("module"),
+    jl_typename_type->name->names = jl_svec(8, jl_symbol("name"), jl_symbol("module"),
                                             jl_symbol("names"), jl_symbol("primary"),
                                             jl_symbol("cache"), jl_symbol("linearcache"),
-                                            jl_symbol("uid"));
-    jl_typename_type->types = jl_svec(7, jl_sym_type, jl_any_type, jl_simplevector_type,
+                                            jl_symbol("uid"), jl_symbol("mt"));
+    jl_typename_type->types = jl_svec(8, jl_sym_type, jl_any_type, jl_simplevector_type,
                                       jl_type_type, jl_simplevector_type, jl_simplevector_type,
-                                      jl_any_type);
+                                      jl_any_type, jl_any_type);
     jl_typename_type->uid = jl_assign_type_uid();
     jl_typename_type->instance = NULL;
     jl_typename_type->struct_decl = NULL;
+    jl_typename_type->ditype = NULL;
     jl_typename_type->abstract = 0;
     jl_typename_type->pointerfree = 0;
     jl_typename_type->mutabl = 1;
     jl_typename_type->ninitialized = 2;
 
+    jl_methtable_type->name = jl_new_typename(jl_symbol("MethodTable"));
+    jl_methtable_type->name->primary = (jl_value_t*)jl_methtable_type;
+    jl_methtable_type->name->mt = jl_new_method_table(jl_methtable_type->name->name, jl_current_module);
+    jl_methtable_type->super = jl_any_type;
+    jl_methtable_type->parameters = jl_emptysvec;
+    jl_methtable_type->name->names = jl_svec(8, jl_symbol("name"), jl_symbol("defs"),
+                                             jl_symbol("cache"), jl_symbol("cache_arg1"),
+                                             jl_symbol("cache_targ"), jl_symbol("max_args"),
+                                             jl_symbol("kwsorter"), jl_symbol("module"));
+    jl_methtable_type->types = jl_svec(8, jl_sym_type, jl_any_type, jl_any_type, jl_any_type,
+                                       jl_any_type, jl_any_type, jl_any_type, jl_any_type);
+    jl_methtable_type->uid = jl_assign_type_uid();
+    jl_methtable_type->instance = NULL;
+    jl_methtable_type->struct_decl = NULL;
+    jl_methtable_type->ditype = NULL;
+    jl_methtable_type->abstract = 0;
+    jl_methtable_type->pointerfree = 0;
+    jl_methtable_type->mutabl = 1;
+    jl_methtable_type->ninitialized = 6;
+
     jl_sym_type->name = jl_new_typename(jl_symbol("Symbol"));
     jl_sym_type->name->primary = (jl_value_t*)jl_sym_type;
+    jl_sym_type->name->mt = jl_new_method_table(jl_sym_type->name->name, jl_current_module);
     jl_sym_type->super = jl_any_type;
     jl_sym_type->parameters = jl_emptysvec;
     jl_sym_type->name->names = jl_emptysvec;
@@ -3220,6 +3290,7 @@ void jl_init_types(void)
     jl_sym_type->instance = NULL;
     jl_sym_type->uid = jl_assign_type_uid();
     jl_sym_type->struct_decl = NULL;
+    jl_sym_type->ditype = NULL;
     jl_sym_type->size = 0;
     jl_sym_type->abstract = 0;
     jl_sym_type->pointerfree = 0;
@@ -3228,6 +3299,7 @@ void jl_init_types(void)
 
     jl_simplevector_type->name = jl_new_typename(jl_symbol("SimpleVector"));
     jl_simplevector_type->name->primary = (jl_value_t*)jl_simplevector_type;
+    jl_simplevector_type->name->mt = jl_new_method_table(jl_simplevector_type->name->name, jl_current_module);
     jl_simplevector_type->super = jl_any_type;
     jl_simplevector_type->parameters = jl_emptysvec;
     jl_simplevector_type->name->names = jl_svec(1, jl_symbol("length"));
@@ -3235,6 +3307,7 @@ void jl_init_types(void)
     jl_simplevector_type->uid = jl_assign_type_uid();
     jl_simplevector_type->instance = NULL;
     jl_simplevector_type->struct_decl = NULL;
+    jl_simplevector_type->ditype = NULL;
     jl_simplevector_type->abstract = 0;
     jl_simplevector_type->pointerfree = 0;
     jl_simplevector_type->mutabl = 1;
@@ -3243,7 +3316,7 @@ void jl_init_types(void)
     // now they can be used to create the remaining base kinds and types
     jl_void_type = jl_new_datatype(jl_symbol("Void"), jl_any_type, jl_emptysvec,
                                    jl_emptysvec, jl_emptysvec, 0, 0, 0);
-    jl_nothing = newstruct(jl_void_type);
+    jl_set_typeof(jl_nothing, jl_void_type);
     jl_void_type->instance = jl_nothing;
 
     jl_uniontype_type = jl_new_datatype(jl_symbol("Union"),
@@ -3261,7 +3334,7 @@ void jl_init_types(void)
                                            jl_symbol("bound")),
                                    jl_svec(4, jl_sym_type, jl_type_type,
                                            jl_type_type, jl_any_type),
-                                   0, 0, 3);
+                                   0, 1, 3);
 
     jl_svec_t *tv;
     tv = jl_svec1(tvar("T"));
@@ -3317,19 +3390,10 @@ void jl_init_types(void)
                         jl_svec(7, jl_type_type, jl_bool_type, jl_bool_type,
                                 jl_any_type, jl_any_type,
                                 jl_any_type, jl_any_type),
-                        0, 1, 7);
-
-    jl_methtable_type =
-        jl_new_datatype(jl_symbol("MethodTable"), jl_any_type, jl_emptysvec,
-                        jl_svec(8, jl_symbol("name"), jl_symbol("defs"),
-                                jl_symbol("cache"), jl_symbol("cache_arg1"),
-                                jl_symbol("cache_targ"), jl_symbol("max_args"),
-                                jl_symbol("kwsorter"), jl_symbol("module")),
-                        jl_svec(8, jl_sym_type, jl_any_type,
-                                jl_any_type, jl_any_type,
-                                jl_any_type, jl_long_type,
-                                jl_any_type, jl_any_type),
-                        0, 1, 6);
+                        0, 1, 4);
+
+    jl_function_type = jl_new_abstracttype((jl_value_t*)jl_symbol("Function"), jl_any_type, jl_emptysvec);
+    jl_builtin_type  = jl_new_abstracttype((jl_value_t*)jl_symbol("Builtin"), jl_function_type, jl_emptysvec);
 
     tv = jl_svec2(tvar("T"), tvar("N"));
     jl_abstractarray_type =
@@ -3416,9 +3480,10 @@ void jl_init_types(void)
     jl_svecset(jl_methtable_type->types, 7, jl_module_type);
 
     jl_lambda_info_type =
-        jl_new_datatype(jl_symbol("LambdaStaticData"),
+        jl_new_datatype(jl_symbol("LambdaInfo"),
                         jl_any_type, jl_emptysvec,
-                        jl_svec(14, jl_symbol("ast"), jl_symbol("sparams"),
+                        jl_svec(16, jl_symbol("ast"), jl_symbol("rettype"),
+                                jl_symbol("sparam_syms"), jl_symbol("sparam_vals"),
                                 jl_symbol("tfunc"), jl_symbol("name"),
                                 jl_symbol("roots"),
                                 /* jl_symbol("specTypes"),
@@ -3426,26 +3491,18 @@ void jl_init_types(void)
                                    jl_symbol("specializations")*/
                                 jl_symbol(""), jl_symbol(""), jl_symbol(""),
                                 jl_symbol("module"), jl_symbol("def"),
-                                jl_symbol("capt"),
                                 jl_symbol("file"), jl_symbol("line"),
-                                jl_symbol("inferred")),
-                        jl_svec(14, jl_any_type, jl_simplevector_type,
+                                jl_symbol("inferred"),
+                                jl_symbol("pure")),
+                        jl_svec(16, jl_any_type, jl_any_type,
+                                jl_simplevector_type, jl_simplevector_type,
                                 jl_any_type, jl_sym_type,
                                 jl_any_type, jl_any_type,
                                 jl_any_type, jl_array_any_type,
                                 jl_module_type, jl_any_type,
-                                jl_any_type,
                                 jl_sym_type, jl_int32_type,
-                                jl_bool_type),
-                        0, 1, 4);
-
-    jl_box_type =
-        jl_new_datatype(jl_symbol("Box"),
-                        jl_any_type, jl_emptysvec,
-                        jl_svec(1, jl_symbol("contents")),
-                        jl_svec(1, jl_any_type), 0, 1, 0);
-    jl_box_typename = jl_box_type->name;
-    jl_box_any_type = (jl_value_t*)jl_box_type;
+                                jl_bool_type, jl_bool_type),
+                        0, 1, 5);
 
     jl_typector_type =
         jl_new_datatype(jl_symbol("TypeConstructor"),
@@ -3455,18 +3512,9 @@ void jl_init_types(void)
                         jl_svec(2, jl_simplevector_type, jl_any_type),
                         0, 0, 2);
 
-    jl_function_type =
-        jl_new_datatype(jl_symbol("Function"), jl_any_type, jl_emptysvec,
-                        jl_svec(3, jl_symbol("fptr"), jl_symbol("env"),
-                                jl_symbol("code")),
-                        jl_svec(3, jl_any_type, jl_any_type,
-                                jl_lambda_info_type),
-                        0, 1, 0);
-
-    jl_svecset(jl_method_type->types, 4, jl_function_type);
-    jl_svecset(jl_lambda_info_type->types, 6, jl_function_type);
-
-    jl_bottom_func = jl_new_closure(jl_f_no_function, (jl_value_t*)jl_emptysvec, NULL);
+    // all kinds of types share a method table
+    jl_typector_type->name->mt = jl_uniontype_type->name->mt = jl_datatype_type->name->mt =
+        jl_type_type->name->mt;
 
     jl_intrinsic_type = jl_new_bitstype((jl_value_t*)jl_symbol("IntrinsicFunction"),
                                         jl_any_type, jl_emptysvec, 32);
@@ -3489,6 +3537,10 @@ void jl_init_types(void)
 
     jl_ANY_flag = (jl_value_t*)tvar("ANY");
 
+    jl_carnavalue =
+        jl_new_abstracttype((jl_value_t*)jl_symbol("Carnavalue"),
+                            jl_any_type, jl_emptysvec);
+
     // complete builtin type metadata
     jl_value_t *pointer_void = jl_apply_type((jl_value_t*)jl_pointer_type,
                                              jl_svec1(jl_void_type));
@@ -3498,10 +3550,10 @@ void jl_init_types(void)
     jl_svecset(jl_datatype_type->types, 7, (jl_value_t*)jl_bool_type);
     jl_svecset(jl_datatype_type->types, 8, (jl_value_t*)jl_bool_type);
     jl_svecset(jl_datatype_type->types, 9, jl_int32_type);
-    jl_svecset(jl_function_type->types, 0, pointer_void);
     jl_svecset(jl_tvar_type->types, 3, (jl_value_t*)jl_bool_type);
     jl_svecset(jl_simplevector_type->types, 0, jl_long_type);
     jl_svecset(jl_typename_type->types, 6, jl_long_type);
+    jl_svecset(jl_methtable_type->types, 5, jl_long_type);
 
     jl_compute_field_offsets(jl_datatype_type);
     jl_compute_field_offsets(jl_typename_type);
@@ -3517,9 +3569,7 @@ void jl_init_types(void)
     jl_compute_field_offsets(jl_topnode_type);
     jl_compute_field_offsets(jl_module_type);
     jl_compute_field_offsets(jl_lambda_info_type);
-    jl_compute_field_offsets(jl_box_type);
     jl_compute_field_offsets(jl_typector_type);
-    jl_compute_field_offsets(jl_function_type);
     jl_compute_field_offsets(jl_simplevector_type);
     jl_simplevector_type->pointerfree = 0;
 
@@ -3535,7 +3585,6 @@ void jl_init_types(void)
     label_sym = jl_symbol("label");
     return_sym = jl_symbol("return");
     lambda_sym = jl_symbol("lambda");
-    macro_sym = jl_symbol("macro");
     module_sym = jl_symbol("module");
     export_sym = jl_symbol("export");
     import_sym = jl_symbol("import");
@@ -3562,17 +3611,19 @@ void jl_init_types(void)
     compositetype_sym = jl_symbol("composite_type");
     type_goto_sym = jl_symbol("type_goto");
     toplevel_sym = jl_symbol("toplevel");
-    tuple_sym = jl_symbol("tuple");
-    kw_sym = jl_symbol("kw");
     dot_sym = jl_symbol(".");
     boundscheck_sym = jl_symbol("boundscheck");
+    inbounds_sym = jl_symbol("inbounds");
     fastmath_sym = jl_symbol("fastmath");
+    stknew_sym = jl_symbol("stknew");
     newvar_sym = jl_symbol("newvar");
     copyast_sym = jl_symbol("copyast");
     simdloop_sym = jl_symbol("simdloop");
+    pure_sym = jl_symbol("pure");
     meta_sym = jl_symbol("meta");
-    arrow_sym = jl_symbol("->");
     dots_sym = jl_symbol("...");
+    list_sym = jl_symbol("list");
+    unused_sym = jl_symbol("#unused#");
 }
 
 #ifdef __cplusplus
diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 9e86e6e7fbdc3..070ad44d2e202 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -6,17 +6,16 @@
 (define prec-assignment
   '(= := += -= *= /= //= .//= .*= ./= |\\=| |.\\=| ^= .^= ÷= .÷= %= .%= |\|=| &= $= => <<= >>= >>>= ~ |.+=| |.-=|))
 (define prec-conditional '(?))
+(define prec-arrow       '(-- --> ← → ↔ ↚ ↛ ↠ ↣ ↦ ↮ ⇎ ⇏ ⇒ ⇔ ⇴ ⇶ ⇷ ⇸ ⇹ ⇺ ⇻ ⇼ ⇽ ⇾ ⇿ ⟵ ⟶ ⟷ ⟷ ⟹ ⟺ ⟻ ⟼ ⟽ ⟾ ⟿ ⤀ ⤁ ⤂ ⤃ ⤄ ⤅ ⤆ ⤇ ⤌ ⤍ ⤎ ⤏ ⤐ ⤑ ⤔ ⤕ ⤖ ⤗ ⤘ ⤝ ⤞ ⤟ ⤠ ⥄ ⥅ ⥆ ⥇ ⥈ ⥊ ⥋ ⥎ ⥐ ⥒ ⥓ ⥖ ⥗ ⥚ ⥛ ⥞ ⥟ ⥢ ⥤ ⥦ ⥧ ⥨ ⥩ ⥪ ⥫ ⥬ ⥭ ⥰ ⧴ ⬱ ⬰ ⬲ ⬳ ⬴ ⬵ ⬶ ⬷ ⬸ ⬹ ⬺ ⬻ ⬼ ⬽ ⬾ ⬿ ⭀ ⭁ ⭂ ⭃ ⭄ ⭇ ⭈ ⭉ ⭊ ⭋ ⭌ ￩ ￫))
 (define prec-lazy-or     '(|\|\||))
 (define prec-lazy-and    '(&&))
-(define prec-arrow       '(-- --> ← → ↔ ↚ ↛ ↠ ↣ ↦ ↮ ⇎ ⇏ ⇒ ⇔ ⇴ ⇶ ⇷ ⇸ ⇹ ⇺ ⇻ ⇼ ⇽ ⇾ ⇿ ⟵ ⟶ ⟷ ⟷ ⟹ ⟺ ⟻ ⟼ ⟽ ⟾ ⟿ ⤀ ⤁ ⤂ ⤃ ⤄ ⤅ ⤆ ⤇ ⤌ ⤍ ⤎ ⤏ ⤐ ⤑ ⤔ ⤕ ⤖ ⤗ ⤘ ⤝ ⤞ ⤟ ⤠ ⥄ ⥅ ⥆ ⥇ ⥈ ⥊ ⥋ ⥎ ⥐ ⥒ ⥓ ⥖ ⥗ ⥚ ⥛ ⥞ ⥟ ⥢ ⥤ ⥦ ⥧ ⥨ ⥩ ⥪ ⥫ ⥬ ⥭ ⥰ ⧴ ⬱ ⬰ ⬲ ⬳ ⬴ ⬵ ⬶ ⬷ ⬸ ⬹ ⬺ ⬻ ⬼ ⬽ ⬾ ⬿ ⭀ ⭁ ⭂ ⭃ ⭄ ⭇ ⭈ ⭉ ⭊ ⭋ ⭌ ￩ ￫))
 (define prec-comparison
-  '(> < >= ≥ <= ≤ == === ≡ != ≠ !== ≢ |.>| |.<| |.>=| |.≥| |.<=| |.≤| |.==| |.!=| |.≠| |.=| |.!| |<:| |>:| ∈ ∉ ∋ ∌ ⊆ ⊈ ⊂ ⊄ ⊊ ∝ ∊ ∍ ∥ ∦ ∷ ∺ ∻ ∽ ∾ ≁ ≃ ≄ ≅ ≆ ≇ ≈ ≉ ≊ ≋ ≌ ≍ ≎ ≐ ≑ ≒ ≓ ≔ ≕ ≖ ≗ ≘ ≙ ≚ ≛ ≜ ≝ ≞ ≟ ≣ ≦ ≧ ≨ ≩ ≪ ≫ ≬ ≭ ≮ ≯ ≰ ≱ ≲ ≳ ≴ ≵ ≶ ≷ ≸ ≹ ≺ ≻ ≼ ≽ ≾ ≿ ⊀ ⊁ ⊃ ⊅ ⊇ ⊉ ⊋ ⊏ ⊐ ⊑ ⊒ ⊜ ⊩ ⊬ ⊮ ⊰ ⊱ ⊲ ⊳ ⊴ ⊵ ⊶ ⊷ ⋍ ⋐ ⋑ ⋕ ⋖ ⋗ ⋘ ⋙ ⋚ ⋛ ⋜ ⋝ ⋞ ⋟ ⋠ ⋡ ⋢ ⋣ ⋤ ⋥ ⋦ ⋧ ⋨ ⋩ ⋪ ⋫ ⋬ ⋭ ⋲ ⋳ ⋴ ⋵ ⋶ ⋷ ⋸ ⋹ ⋺ ⋻ ⋼ ⋽ ⋾ ⋿ ⟈ ⟉ ⟒ ⦷ ⧀ ⧁ ⧡ ⧣ ⧤ ⧥ ⩦ ⩧ ⩪ ⩫ ⩬ ⩭ ⩮ ⩯ ⩰ ⩱ ⩲ ⩳ ⩴ ⩵ ⩶ ⩷ ⩸ ⩹ ⩺ ⩻ ⩼ ⩽ ⩾ ⩿ ⪀ ⪁ ⪂ ⪃ ⪄ ⪅ ⪆ ⪇ ⪈ ⪉ ⪊ ⪋ ⪌ ⪍ ⪎ ⪏ ⪐ ⪑ ⪒ ⪓ ⪔ ⪕ ⪖ ⪗ ⪘ ⪙ ⪚ ⪛ ⪜ ⪝ ⪞ ⪟ ⪠ ⪡ ⪢ ⪣ ⪤ ⪥ ⪦ ⪧ ⪨ ⪩ ⪪ ⪫ ⪬ ⪭ ⪮ ⪯ ⪰ ⪱ ⪲ ⪳ ⪴ ⪵ ⪶ ⪷ ⪸ ⪹ ⪺ ⪻ ⪼ ⪽ ⪾ ⪿ ⫀ ⫁ ⫂ ⫃ ⫄ ⫅ ⫆ ⫇ ⫈ ⫉ ⫊ ⫋ ⫌ ⫍ ⫎ ⫏ ⫐ ⫑ ⫒ ⫓ ⫔ ⫕ ⫖ ⫗ ⫘ ⫙ ⫷ ⫸ ⫹ ⫺ ⊢ ⊣))
-;; infix "in" goes here
+  '(> < >= ≥ <= ≤ == === ≡ != ≠ !== ≢ |.>| |.<| |.>=| |.≥| |.<=| |.≤| |.==| |.!=| |.≠| |.=| |.!| |<:| |>:| ∈ ∉ ∋ ∌ ⊆ ⊈ ⊂ ⊄ ⊊ ∝ ∊ ∍ ∥ ∦ ∷ ∺ ∻ ∽ ∾ ≁ ≃ ≄ ≅ ≆ ≇ ≈ ≉ ≊ ≋ ≌ ≍ ≎ ≐ ≑ ≒ ≓ ≔ ≕ ≖ ≗ ≘ ≙ ≚ ≛ ≜ ≝ ≞ ≟ ≣ ≦ ≧ ≨ ≩ ≪ ≫ ≬ ≭ ≮ ≯ ≰ ≱ ≲ ≳ ≴ ≵ ≶ ≷ ≸ ≹ ≺ ≻ ≼ ≽ ≾ ≿ ⊀ ⊁ ⊃ ⊅ ⊇ ⊉ ⊋ ⊏ ⊐ ⊑ ⊒ ⊜ ⊩ ⊬ ⊮ ⊰ ⊱ ⊲ ⊳ ⊴ ⊵ ⊶ ⊷ ⋍ ⋐ ⋑ ⋕ ⋖ ⋗ ⋘ ⋙ ⋚ ⋛ ⋜ ⋝ ⋞ ⋟ ⋠ ⋡ ⋢ ⋣ ⋤ ⋥ ⋦ ⋧ ⋨ ⋩ ⋪ ⋫ ⋬ ⋭ ⋲ ⋳ ⋴ ⋵ ⋶ ⋷ ⋸ ⋹ ⋺ ⋻ ⋼ ⋽ ⋾ ⋿ ⟈ ⟉ ⟒ ⦷ ⧀ ⧁ ⧡ ⧣ ⧤ ⧥ ⩦ ⩧ ⩪ ⩫ ⩬ ⩭ ⩮ ⩯ ⩰ ⩱ ⩲ ⩳ ⩴ ⩵ ⩶ ⩷ ⩸ ⩹ ⩺ ⩻ ⩼ ⩽ ⩾ ⩿ ⪀ ⪁ ⪂ ⪃ ⪄ ⪅ ⪆ ⪇ ⪈ ⪉ ⪊ ⪋ ⪌ ⪍ ⪎ ⪏ ⪐ ⪑ ⪒ ⪓ ⪔ ⪕ ⪖ ⪗ ⪘ ⪙ ⪚ ⪛ ⪜ ⪝ ⪞ ⪟ ⪠ ⪡ ⪢ ⪣ ⪤ ⪥ ⪦ ⪧ ⪨ ⪩ ⪪ ⪫ ⪬ ⪭ ⪮ ⪯ ⪰ ⪱ ⪲ ⪳ ⪴ ⪵ ⪶ ⪷ ⪸ ⪹ ⪺ ⪻ ⪼ ⪽ ⪾ ⪿ ⫀ ⫁ ⫂ ⫃ ⫄ ⫅ ⫆ ⫇ ⫈ ⫉ ⫊ ⫋ ⫌ ⫍ ⫎ ⫏ ⫐ ⫑ ⫒ ⫓ ⫔ ⫕ ⫖ ⫗ ⫘ ⫙ ⫷ ⫸ ⫹ ⫺ ⊢ ⊣)) ;; plus `in`
 (define prec-pipe        '(|\|>| |<\||))
 (define prec-colon       '(: |..|))
 (define prec-plus        '(+ - ⊕ ⊖ ⊞ ⊟ |.+| |.-| |++| |\|| ∪ ∨ $ ⊔ ± ∓ ∔ ∸ ≂ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣))
 (define prec-bitshift    '(<< >> >>> |.<<| |.>>| |.>>>|))
-(define prec-times       '(* / |./| ÷ |.÷| % ⋅ ∘ × |.%| |.*| |\\| |.\\| & ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍))
+(define prec-times       '(* / |./| ÷ |.÷| % ⋅ ∘ × |.%| |.*| |\\| |.\\| & ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗))
 (define prec-rational    '(// .//))
 (define prec-power       '(^ |.^| ↑ ↓ ⇵ ⟰ ⟱ ⤈ ⤉ ⤊ ⤋ ⤒ ⤓ ⥉ ⥌ ⥍ ⥏ ⥑ ⥔ ⥕ ⥘ ⥙ ⥜ ⥝ ⥠ ⥡ ⥣ ⥥ ⥮ ⥯ ￪ ￬))
 (define prec-decl        '(|::|))
@@ -46,6 +45,11 @@
             (eval `(define ,(symbol (string "is-" name "?")) (Set ,name))))
           prec-names)
 
+(define is-prec-comparison?
+  (let ((compare-ops (Set prec-comparison)))
+    (lambda (t)
+      (or (compare-ops t) (eq? t 'in)))))
+
 ;; hash table of binary operators -> precedence
 (define prec-table (let ((t (table)))
                      (define (pushprec L prec)
@@ -55,6 +59,7 @@
                              (pushprec (cdr L) (+ prec 1)))))
                      (pushprec (map eval prec-names) 1)
                      t))
+(put! prec-table 'in (get prec-table '== 0)) ; add `in` to the prec-table
 (define (operator-precedence op) (get prec-table op 0))
 
 (define unary-ops '(+ - ! ¬ ~ |<:| |>:| √ ∛ ∜))
@@ -100,14 +105,7 @@
                          abstract typealias type bitstype immutable ccall do
                          module baremodule using import export importall))
 
-(define (assignment? e)
-  (and (pair? e) (eq? (car e) '=)))
-
-(define (assignment-like? e)
-  (and (pair? e) (is-prec-assignment? (car e))))
-
-(define (kwarg? e)
-  (and (pair? e) (eq? (car e) 'kw)))
+(define reserved-word? (Set reserved-words))
 
 (define (dict-literal? l)
   (and (length= l 3) (eq? (car l) '=>)))
@@ -160,9 +158,6 @@
 
 ;; --- lexer ---
 
-(define special-char?
-  (let ((chrs (string->list "()[]{},;\"`@")))
-    (lambda (c) (memv c chrs))))
 (define (newline? c) (eqv? c #\newline))
 
 (define (skip-to-eol port)
@@ -394,7 +389,7 @@
        (eq? (car t) 'macrocall)
        (memq (cadr t) '(@int128_str @uint128_str @big_str))))
 
-; skip to end of comment, starting at #:  either #...<eol> or #= .... =#.
+;; skip to end of comment, starting at #:  either #...<eol> or #= .... =#.
 (define (skip-comment port)
   (define (skip-multiline-comment port count)
     (let ((c (read-char port)))
@@ -440,13 +435,15 @@
 (define (next-token port s)
   (aset! s 2 (eq? (skip-ws port whitespace-newline) #t))
   (let ((c (peek-char port)))
-    (cond ((or (eof-object? c) (newline? c))  (read-char port))
+    (cond ((or (eof-object? c) (eqv? c #\newline))  (read-char port))
 
-          ((special-char? c)    (read-char port))
+          ((identifier-start-char? c)     (accum-julia-symbol c port))
 
-          ((char-numeric? c)    (read-number port #f #f))
+          ((string.find "()[]{},;\"`@" c) (read-char port))
 
-          ((eqv? c #\#)         (skip-comment port) (next-token port s))
+          ((string.find "0123456789" c)   (read-number port #f #f))
+
+          ((eqv? c #\#)                   (skip-comment port) (next-token port s))
 
           ;; . is difficult to handle; it could start a number or operator
           ((and (eqv? c #\.)
@@ -465,8 +462,6 @@
 
           ((opchar? c)  (read-operator port (read-char port)))
 
-          ((identifier-start-char? c) (accum-julia-symbol c port))
-
           (else
            (read-char port)
            (if (default-ignorable-char? c)
@@ -513,63 +508,47 @@
 
 (define (syntax-deprecation s what instead)
   (if (or *depwarn* *deperror*)
-    (let ((msg (string
-		 #\newline
-		 (if *deperror* "ERROR:" "WARNING:") " deprecated syntax \"" what "\""
-	      (if (eq? current-filename 'none)
-		  ""
-		  (string " at " current-filename ":" (input-port-line (if (port? s) s (ts:port s)))))
-	      "."
-	      (if (equal? instead "")
-		  ""
-		  (string #\newline "Use \"" instead "\" instead."))
-	      #\newline)))
-	  (if *deperror*
-	    (error msg)
-	    (io.write *stderr* msg)))))
+      (let ((msg (string
+                  #\newline
+                  (if *deperror* "ERROR:" "WARNING:") " deprecated syntax \"" what "\""
+                  (if (or (not s) (eq? current-filename 'none))
+                      ""
+                      (string " at " current-filename ":" (input-port-line (if (port? s) s (ts:port s)))))
+                  "."
+                  (if (equal? instead "")
+                      ""
+                      (string #\newline "Use \"" instead "\" instead."))
+                  #\newline)))
+        (if *deperror*
+            (error msg)
+            (io.write *stderr* msg)))))
 
 ;; --- parser ---
 
-; parse left-to-right binary operator
-; produces structures like (+ (+ (+ 2 3) 4) 5)
+;; parse left-to-right binary operator
+;; produces structures like (+ (+ (+ 2 3) 4) 5)
 (define-macro (parse-LtoR s down ops)
   `(let loop ((ex (,down ,s))
               (t  (peek-token ,s)))
-     (if (not (,ops t))
-         ex
+     (if (,ops t)
          (begin (take-token ,s)
-                (if (or (syntactic-op? t) (eq? t 'in) (eq? t '|::|))
-                    (loop (list t ex (,down ,s)) (peek-token ,s))
-                    (loop (list 'call t ex (,down ,s)) (peek-token ,s)))))))
-
-; parse right-to-left binary operator
-; produces structures like (= a (= b (= c d)))
-(define (parse-RtoL s down ops)
-  (let loop ((ex  (down s))
-             (t   (peek-token s))
-             (spc (ts:space? s)))
-    (if (not (ops t))
-        ex
-        (begin (take-token s)
-               (cond ((and space-sensitive spc (memq t unary-and-binary-ops)
-                           (not (eqv? (peek-char (ts:port s)) #\ )))
-                      (ts:put-back! s t)
-                      ex)
-                     ((syntactic-op? t)
-                      (list t ex (parse-RtoL s down ops)))
-                     ((eq? t '~)
-                      (let ((args (parse-chain s down '~)))
-                        (if (ops (peek-token s))
-                            `(macrocall @~ ,ex ,@(butlast args)
-                                        ,(loop (last args)
-                                               (peek-token s)
-                                               (ts:space? s)))
-                            `(macrocall @~ ,ex ,@args))))
-                     (else
-                      (list 'call t ex (parse-RtoL s down ops))))))))
+                (loop (list 'call t ex (,down ,s)) (peek-token ,s)))
+         ex)))
+
+;; parse right-to-left binary operator
+;; produces structures like (= a (= b (= c d)))
+(define-macro (parse-RtoL s down ops syntactic self)
+  `(let* ((ex (,down ,s))
+          (t  (peek-token ,s)))
+     (if (,ops t)
+         (begin (take-token ,s)
+                (if ,syntactic
+                    (list       t ex (,self ,s))
+                    (list 'call t ex (,self ,s))))
+         ex)))
 
 (define (parse-cond s)
-  (let ((ex (parse-or s)))
+  (let ((ex (parse-arrow s)))
     (cond ((eq? (peek-token s) '?)
            (begin (take-token s)
                   (let ((then (without-range-colon (parse-eq* s))))
@@ -582,7 +561,7 @@
                (if (or (eof-object? next) (closing-token? next)
                        (newline? next))
                    `(call (top string) ,@(reverse args))
-                   (loop (cons (parse-or s) args))))))
+                   (loop (cons (parse-arrow s) args))))))
           (else ex))))
 
 (define (invalid-initial-token? tok)
@@ -601,23 +580,24 @@
       `(= ,(cadr ex) (block (line ,lno ,current-filename) ,(caddr ex)))
       ex))
 
-; parse a@b@c@... as (@ a b c ...) for some operator @
-; op: the operator to look for
-; head: the expression head to yield in the result, e.g. "a;b" => (block a b)
-; closers: a list of tokens that will stop the process
-;          however, this doesn't consume the closing token, just looks at it
-; allow-empty: if true will ignore runs of the operator, like a@@@@b
-; ow, my eyes!!
-(define (parse-Nary s down ops head closers allow-empty)
-  (if (invalid-initial-token? (require-token s))
-      (error (string "unexpected \"" (peek-token s) "\"")))
-  (if (memv (require-token s) closers)
+;; parse a@b@c@... as (@ a b c ...) for some operator @
+;; op: the operator to look for
+;; head: the expression head to yield in the result, e.g. "a;b" => (block a b)
+;; closers: a list of tokens that will stop the process
+;;          however, this doesn't consume the closing token, just looks at it
+;; allow-empty: if true will ignore runs of the operator, like a@@@@b
+;; ow, my eyes!!
+(define (parse-Nary s down ops head closer? allow-empty add-linenums)
+  (let ((t (require-token s)))
+  (if (invalid-initial-token? t)
+      (error (string "unexpected \"" t "\"")))
+  (if (closer? t)
       (list head)  ; empty block
       (let loop ((ex
                   ;; in allow-empty mode skip leading runs of operator
-                  (if (and allow-empty (memv (require-token s) ops))
+                  (if (and allow-empty (memv t ops))
                       '()
-                      (if (memv #\newline ops)
+                      (if add-linenums
                           (let ((loc (line-number-node s)))
                             ;; note: line-number must happen before (down s)
                             (list (down s) loc))
@@ -627,28 +607,28 @@
         (if (not (memv t ops))
             (begin
               (if (not (or (eof-object? t) (eqv? t #\newline) (memv #\, ops)
-                           (memv t closers)))
+                           (closer? t)))
                   (error (string "extra token \"" t "\" after end of expression")))
               (if (or (null? ex) (pair? (cdr ex)) (not first?))
                   ;; () => (head)
                   ;; (ex2 ex1) => (head ex1 ex2)
                   ;; (ex1) if operator appeared => (head ex1) (handles "x;")
-                  (cons head (reverse ex))
+                  (cons head (reverse! ex))
                   ;; (ex1) => ex1
                   (car ex)))
             (begin (take-token s)
                    ;; allow input to end with the operator, as in a;b;
                    (if (or (eof-object? (peek-token s))
-                           (memv (peek-token s) closers)
+                           (closer? (peek-token s))
                            (and allow-empty
                                 (memv (peek-token s) ops))
-                           (and (equal? ops '(#\,))
+                           (and (eqv? (car ops) #\,)
                                 (eq? (peek-token s) '=)))
                        (loop ex #f (peek-token s))
-                       (if (memv #\newline ops)
+                       (if add-linenums
                            (let ((loc (line-number-node s)))
                              (loop (list* (down s) loc ex) #f (peek-token s)))
-                           (loop (cons (down s) ex) #f (peek-token s)))))))))
+                           (loop (cons (down s) ex) #f (peek-token s))))))))))
 
 ; parse ranges and postfix ...
 ; colon is strange; 3 arguments with 2 colons yields one call:
@@ -698,38 +678,54 @@
              (list '... ex))
             (else ex)))))
 
-; the principal non-terminals follow, in increasing precedence order
+;; the principal non-terminals follow, in increasing precedence order
 
 (define (parse-block s (down parse-eq))
   (parse-Nary s down '(#\newline #\;) 'block
-              '(end else elseif catch finally) #t))
+              (lambda (x) (memq x '(end else elseif catch finally))) #t #t))
 
 ;; ";" at the top level produces a sequence of top level expressions
 (define (parse-stmts s)
   (let ((ex (parse-Nary s (lambda (s) (parse-docstring s parse-eq))
-                        '(#\;) 'toplevel '(#\newline) #t)))
+                        '(#\;) 'toplevel (lambda (x) (eqv? x #\newline)) #t #f)))
     ;; check for unparsed junk after an expression
     (let ((t (peek-token s)))
       (if (not (or (eof-object? t) (eqv? t #\newline) (eq? t #f)))
           (error (string "extra token \"" t "\" after end of expression"))))
     ex))
 
+(define (parse-assignment s down)
+  (let loop ((ex (down s))
+             (t  (peek-token s)))
+    (if (not (is-prec-assignment? t))
+        ex
+        (begin (take-token s)
+               (if (eq? t '~)
+                   (if (and space-sensitive (ts:space? s)
+                            (not (eqv? (peek-char (ts:port s)) #\ )))
+                       (begin (ts:put-back! s t)
+                              ex)
+                       (let ((args (parse-chain s down '~)))
+                         `(macrocall @~ ,ex ,@(butlast args)
+                                     ,(loop (last args) (peek-token s)))))
+                   (list t ex (parse-assignment s down)))))))
+
 (define (parse-eq s)
   (let ((lno (input-port-line (ts:port s))))
     (short-form-function-loc
-     (parse-RtoL s parse-comma is-prec-assignment?) lno)))
+     (parse-assignment s parse-comma) lno)))
 
 ; parse-eq* is used where commas are special, for example in an argument list
 (define (parse-eq* s)
   (let ((lno (input-port-line (ts:port s))))
     (short-form-function-loc
-     (parse-RtoL s parse-cond is-prec-assignment?) lno)))
+     (parse-assignment s parse-cond) lno)))
 
 ; parse-comma is needed for commas outside parens, for example a = b,c
-(define (parse-comma s) (parse-Nary s parse-cond  '(#\,) 'tuple '() #f))
-(define (parse-or s)    (parse-LtoR s parse-and   is-prec-lazy-or?))
-(define (parse-and s)   (parse-LtoR s parse-arrow is-prec-lazy-and?))
-(define (parse-arrow s) (parse-RtoL s parse-comparison  is-prec-arrow?))
+(define (parse-comma s) (parse-Nary s parse-cond  '(#\,) 'tuple (lambda (x) #f) #f #f))
+(define (parse-arrow s) (parse-RtoL s parse-or    is-prec-arrow? (eq? t '-->) parse-arrow))
+(define (parse-or s)    (parse-RtoL s parse-and   is-prec-lazy-or? #t parse-or))
+(define (parse-and s)   (parse-RtoL s parse-comparison is-prec-lazy-and? #t parse-and))
 
 ;; parse left to right chains of a certain binary operator
 ;; returns a list of arguments
@@ -780,25 +776,23 @@
 
 (define (parse-pipes s)    (parse-LtoR s parse-range is-prec-pipe?))
 
-(define is-in? (Set '(in)))
-(define (parse-in s)       (parse-LtoR s parse-pipes is-in?))
-
 (define (parse-comparison s)
-  (let loop ((ex (parse-in s))
+  (let loop ((ex (parse-pipes s))
              (first #t))
     (let ((t (peek-token s)))
       (if (not (is-prec-comparison? t))
           ex
           (begin (take-token s)
                  (if first
-                     (loop (list 'comparison ex t (parse-in s)) #f)
-                     (loop (append ex (list t (parse-in s))) #f)))))))
+                     (loop (list 'comparison ex t (parse-pipes s)) #f)
+                     (loop (append ex (list t (parse-pipes s))) #f)))))))
 
-; flag an error for tokens that cannot begin an expression
-(define (closing-token? tok)
-  (or (eof-object? tok)
-      (and (eq? tok 'end) (not end-symbol))
-      (memv tok '(#\, #\) #\] #\} #\; else elseif catch finally))))
+(define closing-token?
+  (let ((closer? (Set '(else elseif catch finally #\, #\) #\] #\} #\;))))
+    (lambda (tok)
+      (or (and (eq? tok 'end) (not end-symbol))
+          (closer? tok)
+          (eof-object? tok)))))
 
 (define (maybe-negate op num)
   (if (eq? op '-)
@@ -816,13 +810,13 @@
 (define (juxtapose? expr t)
   (and (or (number? expr)
            (large-number? expr)
-	   (not (number? t))    ;; disallow "x.3" and "sqrt(2)2"
-	   ;; to allow x'y as a special case
-	   #;(and (pair? expr) (memq (car expr) '(|'| |.'|))
-		(not (memv t '(#\( #\[ #\{))))
-	   )
+           (not (number? t))    ;; disallow "x.3" and "sqrt(2)2"
+           ;; to allow x'y as a special case
+           #;(and (pair? expr) (memq (car expr) '(|'| |.'|))
+                (not (memv t '(#\( #\[ #\{))))
+           )
        (not (operator? t))
-       (not (memq t reserved-words))
+       (not (reserved-word? t))
        (not (closing-token? t))
        (not (newline? t))
        (not (and (pair? expr) (syntactic-unary-op? (car expr))))))
@@ -849,16 +843,15 @@
         (error (string "unexpected " t)))
     ;; TODO: ? should probably not be listed here except for the syntax hack in osutils.jl
     (cond ((and (operator? t) (not (memq t '(: |'| ?))) (not (syntactic-unary-op? t))
-		(not (invalid-identifier-name? t)))
+                (not (invalid-identifier-name? t)))
            (let* ((op  (take-token s))
                   (nch (peek-char (ts:port s))))
              (if (and (or (eq? op '-) (eq? op '+))
                       (or (and (char? nch) (char-numeric? nch))
                           (and (eqv? nch #\.) (read-char (ts:port s)))))
-                 (let ((num
-                        (parse-juxtapose
-                         (read-number (ts:port s) (eqv? nch #\.) (eq? op '-))
-                         s)))
+                 (let ((num (parse-juxtapose
+                             (read-number (ts:port s) (eqv? nch #\.) (eq? op '-))
+                             s)))
                    (if (is-prec-power? (peek-token s))
                        ;; -2^x parsed as (- (^ 2 x))
                        (begin (ts:put-back! s (maybe-negate op num))
@@ -868,12 +861,12 @@
                    (cond ((or (closing-token? next) (newline? next) (eq? next '=))
                           op)  ; return operator by itself, as in (+)
                          ((or (eqv? next #\{)  ;; this case is +{T}(x::T) = ...
-			      (and (not (memq op unary-ops))
-				   (eqv? next #\( )))
+                              (and (not (memq op unary-ops))
+                                   (eqv? next #\( )))
                           (ts:put-back! s op)
                           (parse-factor s))
-			 ((not (memq op unary-ops))
-			  (error (string "\"" op "\" is not a unary operator")))
+                         ((not (memq op unary-ops))
+                          (error (string "\"" op "\" is not a unary operator")))
                          (else
                           (let ((arg (parse-unary s)))
                             (if (and (pair? arg)
@@ -883,7 +876,7 @@
           (else
            (parse-juxtapose (parse-factor s) s)))))
 
-; handle ^ and .^
+;; handle ^ and .^
 (define (parse-factor-h s down ops)
   (let ((ex (down s))
         (t (peek-token s)))
@@ -893,8 +886,8 @@
            (list 'call
                  (take-token s) ex (parse-factor-h s parse-unary ops))))))
 
-; -2^3 is parsed as -(2^3), so call parse-decl for the first argument,
-; and parse-unary from then on (to handle 2^-3)
+;; -2^3 is parsed as -(2^3), so call parse-decl for the first argument,
+;; and parse-unary from then on (to handle 2^-3)
 (define (parse-factor s)
   (parse-factor-h s parse-decl is-prec-power?))
 
@@ -933,7 +926,7 @@
 ;; also handles looking for syntactic reserved words
 (define (parse-call s)
   (let ((ex (parse-unary-prefix s)))
-    (if (memq ex reserved-words)
+    (if (reserved-word? ex)
         (parse-resword s ex)
         (parse-call-chain s ex #f))))
 
@@ -953,32 +946,31 @@
           ex
           (case t
             ((#\( )
-	     (if (ts:space? s)
-             (syntax-deprecation s
-                                 (string (deparse ex) " " (deparse t))
-                                 (string (deparse ex) (deparse t))))
-	     (take-token s)
-             (let ((c
-                    (let ((al (parse-arglist s #\) )))
-                      (receive
-                       (params args) (separate (lambda (x)
-                                                 (and (pair? x)
-                                                      (eq? (car x) 'parameters)))
-                                               al)
-                       (if (eq? (peek-token s) 'do)
-                           (begin
-                             (take-token s)
-                             `(call ,ex ,@params ,(parse-do s) ,@args))
-                           `(call ,ex ,@al))))))
+             (if (ts:space? s)
+                 (syntax-deprecation s
+                                     (string (deparse ex) " " (deparse t))
+                                     (string (deparse ex) (deparse t))))
+             (take-token s)
+             (let ((c (let ((al (parse-arglist s #\) )))
+                        (receive
+                         (params args) (separate (lambda (x)
+                                                   (and (pair? x)
+                                                        (eq? (car x) 'parameters)))
+                                                 al)
+                         (if (eq? (peek-token s) 'do)
+                             (begin
+                               (take-token s)
+                               `(call ,ex ,@params ,(parse-do s) ,@args))
+                             `(call ,ex ,@al))))))
                (if one-call
                    c
                    (loop c))))
             ((#\[ )
-	     (if (ts:space? s)
-             (syntax-deprecation s
-                                 (string (deparse ex) " " (deparse t))
-                                 (string (deparse ex) (deparse t))))
-	     (take-token s)
+             (if (ts:space? s)
+                 (syntax-deprecation s
+                                     (string (deparse ex) " " (deparse t))
+                                     (string (deparse ex) (deparse t))))
+             (take-token s)
              ;; ref is syntax, so we can distinguish
              ;; a[i] = x  from
              ;; ref(a,i) = x
@@ -1010,15 +1002,15 @@
                      (else (error "unknown parse-cat result (internal error)"))))))
             ((|.|)
              (if (ts:space? s)
-               (syntax-deprecation s
-                                           (string (deparse ex) " " (deparse t))
-                                           (string (deparse ex) (deparse t))))
+                 (syntax-deprecation s
+                                     (string (deparse ex) " " (deparse t))
+                                     (string (deparse ex) (deparse t))))
              (take-token s)
              (loop
               (cond ((eqv? (peek-token s) #\()
                      `(|.| ,ex ,(parse-atom s)))
                     ((eq? (peek-token s) '$)
-		     (take-token s)
+                     (take-token s)
                      (let ((dollarex (parse-atom s)))
                        `(|.| ,ex ($ (call (top Expr) (quote quote)
                                           ,dollarex)))))
@@ -1029,15 +1021,15 @@
                                        ,@(cddr name))
                            `(|.| ,ex (quote ,name))))))))
             ((|.'| |'|)
-	     (if (ts:space? s)
-		 (error (string "space not allowed before \"" t "\"")))
-	     (take-token s)
+             (if (ts:space? s)
+                 (error (string "space not allowed before \"" t "\"")))
+             (take-token s)
              (loop (list t ex)))
             ((#\{ )
              (if (ts:space? s)
-               (syntax-deprecation s
-                                   (string (deparse ex) " " (deparse t))
-                                   (string (deparse ex) (deparse t))))
+                 (syntax-deprecation s
+                                     (string (deparse ex) " " (deparse t))
+                                     (string (deparse ex) (deparse t))))
              (take-token s)
              (loop (list* 'curly ex
                           (map subtype-syntax (parse-arglist s #\} )))))
@@ -1061,7 +1053,7 @@
 
 (define expect-end-current-line 0)
 
-(define (expect-end- s word)
+(define (expect-end s word)
   (let ((t (peek-token s)))
     (cond ((eq? t 'end) (take-token s))
           ((eof-object? t)
@@ -1076,239 +1068,239 @@
 (define (parse-subtype-spec s)
   (subtype-syntax (parse-comparison s)))
 
-; parse expressions or blocks introduced by syntactic reserved words
+;; parse expressions or blocks introduced by syntactic reserved words
 (define (parse-resword s word)
-  (define (expect-end s) (expect-end- s word))
-  (with-bindings ((expect-end-current-line (input-port-line (ts:port s))))
-  (with-normal-ops
-  (without-whitespace-newline
-  (case word
-    ((begin quote)
-     (let ((loc  (begin (skip-ws-and-comments (ts:port s))
-                        (line-number-node s)))
-           (blk  (parse-block s)))
-       (expect-end s)
-       (let ((blk  (if (and (length> blk 1)
-                            (pair? (cadr blk)) (eq? (caadr blk) 'line))
-                       (list* 'block loc (cddr blk))
-                       blk)))
-         (if (eq? word 'quote)
-             (list 'quote blk)
-             blk))))
-    ((while)  (begin0 (list 'while (parse-cond s) (parse-block s))
-                      (expect-end s)))
-    ((for)
-     (let* ((ranges (parse-comma-separated-iters s))
-            (body   (parse-block s)))
-       (expect-end s)
-       `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
-             ,body)))
-
-    ((if)
-     (let* ((test (parse-cond s))
-            (then (if (memq (require-token s) '(else elseif))
-                      '(block)
-                      (parse-block s)))
-            (nxt  (require-token s)))
-       (take-token s)
-       (case nxt
-         ((end)     (list 'if test then))
-         ((elseif)
-          (if (newline? (peek-token s))
-              (error (string "missing condition in \"elseif\" at " current-filename
-                             ":" (- (input-port-line (ts:port s)) 1))))
-          `(if ,test ,then
-               ;; line number for elseif condition
-               (block ,(line-number-node s)
-                      ,(parse-resword s 'if))))
-         ((else)
-          (if (eq? (peek-token s) 'if)
-              (error "use \"elseif\" instead of \"else if\""))
-          (begin0 (list 'if test then (parse-block s))
-                  (expect-end s)))
-         (else      (error (string "unexpected \"" nxt "\""))))))
-    ((let)
-     (let ((binds (if (memv (peek-token s) '(#\newline #\;))
-                      '()
-                      (parse-comma-separated-assignments s))))
-       (if (not (or (eof-object? (peek-token s))
-                    (memv (peek-token s) '(#\newline #\; end))))
-           (error "let variables should end in \";\" or newline"))
-       (let ((ex (parse-block s)))
-         (expect-end s)
-         `(let ,ex ,@binds))))
-    ((global local)
-     (let* ((lno (input-port-line (ts:port s)))
-            (const (and (eq? (peek-token s) 'const)
-                        (take-token s)))
-            (expr  (cons word
-                         (map (lambda (x)
-                                (short-form-function-loc x lno))
-                              (parse-comma-separated-assignments s)))))
-       (if const
-           `(const ,expr)
-           expr)))
-    ((stagedfunction function macro)
-     (if (eq? word 'stagedfunction) (syntax-deprecation s "stagedfunction" "@generated function"))
-     (let* ((paren (eqv? (require-token s) #\())
-            (sig   (parse-call s)))
-       (if (and (eq? word 'function) (not paren) (symbol? sig))
-	   (begin (if (not (eq? (require-token s) 'end))
-		      (error (string "expected \"end\" in definition of function \"" sig "\"")))
-		  (take-token s)
-		  `(function ,sig))
-	   (let* ((def   (if (or (symbol? sig)
-				 (and (pair? sig) (eq? (car sig) '|::|)
-				      (symbol? (cadr sig))))
-			     (if paren
-				 ;; in "function (x)" the (x) is a tuple
-				 `(tuple ,sig)
-				 ;; function foo  =>  syntax error
-				 (error (string "expected \"(\" in " word " definition")))
-			     (if (not (and (pair? sig)
-					   (or (eq? (car sig) 'call)
-					       (eq? (car sig) 'tuple))))
-				 (error (string "expected \"(\" in " word " definition"))
-				 sig)))
-		  (loc   (begin (if (not (eq? (peek-token s) 'end))
-				    ;; if ends on same line, don't skip the following newline
-				    (skip-ws-and-comments (ts:port s)))
-                 (line-number-node s)))
-		  (body  (parse-block s)))
-	     (expect-end s)
-	     (add-filename-to-block! body loc)
-	     (list word def body)))))
-    ((abstract)
-     (list 'abstract (parse-subtype-spec s)))
-    ((type immutable)
-     (let ((immu? (eq? word 'immutable)))
-       (if (memq (peek-token s) reserved-words)
-	   (error (string "invalid type name \"" (take-token s) "\"")))
-       (let ((sig (parse-subtype-spec s))
-             (loc (line-number-node s)))
-         (begin0 (list 'type (if (eq? word 'type) #t #f)
-                       sig (add-filename-to-block! (parse-block s) loc))
-                 (expect-end s)))))
-    ((bitstype)
-     (list 'bitstype (with-space-sensitive (parse-cond s))
-           (parse-subtype-spec s)))
-    ((typealias)
-     (let ((lhs (parse-call s)))
-       (if (and (pair? lhs) (eq? (car lhs) 'call))
-           ;; typealias X (...) is tuple type alias, not call
-           (list 'typealias (cadr lhs) (cons 'tuple (cddr lhs)))
-           (list 'typealias lhs (parse-arrow s)))))
-    ((try)
-     (let ((try-block (if (memq (require-token s) '(catch finally))
-                          '(block)
-                          (parse-block s))))
-       (let loop ((nxt    (require-token s))
-                  (catchb #f)
-                  (catchv #f)
-                  (finalb #f))
-         (take-token s)
-         (cond
-          ((eq? nxt 'end)
-           (list* 'try try-block catchv
-                  ;; default to empty catch block in `try ... end`
-                  (or catchb (if finalb #f '(block)))
-                  (if finalb (list finalb) '())))
-          ((and (eq? nxt 'catch)
-                (not catchb))
-           (let ((nl (memv (peek-token s) '(#\newline #\;))))
-             (if (eqv? (peek-token s) #\;)
-                 (take-token s))
-             (if (memq (require-token s) '(end finally))
-                 (loop (require-token s)
-                       '(block)
-                       #f
-                       finalb)
-                 (let* ((var (parse-eq* s))
-                        (var? (and (not nl) (or (symbol? var) (and (length= var 2) (eq? (car var) '$)))))
-                        (catch-block (if (eq? (require-token s) 'finally)
-                                         '(block)
-                                         (parse-block s))))
-                   (loop (require-token s)
-                         (if var?
-                             catch-block
-                             `(block ,var ,@(cdr catch-block)))
-                         (and var? var)
-                         finalb)))))
-          ((and (eq? nxt 'finally)
-                (not finalb))
-           (let ((fb (if (eq? (require-token s) 'catch)
+  (with-bindings
+   ((expect-end-current-line (input-port-line (ts:port s))))
+   (with-normal-ops
+    (without-whitespace-newline
+     (case word
+       ((begin quote)
+        (let ((loc  (begin (skip-ws-and-comments (ts:port s))
+                           (line-number-node s)))
+              (blk  (parse-block s)))
+          (expect-end s word)
+          (let ((blk  (if (and (length> blk 1)
+                               (pair? (cadr blk)) (eq? (caadr blk) 'line))
+                          (list* 'block loc (cddr blk))
+                          blk)))
+            (if (eq? word 'quote)
+                (list 'quote blk)
+                blk))))
+       ((while)  (begin0 (list 'while (parse-cond s) (parse-block s))
+                         (expect-end s word)))
+       ((for)
+        (let* ((ranges (parse-comma-separated-iters s))
+               (body   (parse-block s)))
+          (expect-end s word)
+          `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
+                ,body)))
+
+       ((if)
+        (let* ((test (parse-cond s))
+               (then (if (memq (require-token s) '(else elseif))
                          '(block)
-                         (parse-block s))))
-             (loop (require-token s)
-                   catchb
-                   catchv
-                   fb)))
-          (else    (error (string "unexpected \"" nxt "\"")))))))
-    ((return)          (let ((t (peek-token s)))
-                         (if (or (eqv? t #\newline) (closing-token? t))
-                             (list 'return '(null))
-                             (list 'return (parse-eq s)))))
-    ((break continue)
-     (let ((t (peek-token s)))
-       (if (or (eof-object? t)
-	       (and (eq? t 'end) (not end-symbol))
-	       (memv t '(#\newline #\; #\) :)))
-	 (list word)
-	 (error (string "unexpected \"" t "\" after " word)))))
-
-    ((const)
-     (let ((assgn (parse-eq s)))
-       (if (not (and (pair? assgn)
-                     (or (eq? (car assgn) '=)
-                         (eq? (car assgn) 'global)
-                         (eq? (car assgn) 'local))))
-           (error "expected assignment after \"const\"")
-           `(const ,assgn))))
-    ((module baremodule)
-     (let* ((name (parse-unary-prefix s))
-            (loc  (line-number-node s))
-            (body (parse-block s (lambda (s) (parse-docstring s parse-eq)))))
-       (expect-end s)
-       (list 'module (eq? word 'module) name
-             (if (eq? word 'module)
-                 (list* 'block
-                        ;; add definitions for module-local eval
-                        (let ((x (if (eq? name 'x) 'y 'x)))
-                          `(= (call eval ,x)
-			      (block
-			       ,loc
-			       (call (|.| (top Core) 'eval) ,name ,x))))
-                        `(= (call eval m x)
-			    (block
-			     ,loc
-			     (call (|.| (top Core) 'eval) m x)))
-                        (cdr body))
-                 body))))
-    ((export)
-     (let ((es (map macrocall-to-atsym
-                    (parse-comma-separated s parse-unary-prefix))))
-       (if (not (every symbol-or-interpolate? es))
-           (error "invalid \"export\" statement"))
-       `(export ,@es)))
-    ((import using importall)
-     (let ((imports (parse-imports s word)))
-       (if (length= imports 1)
-           (car imports)
-           (cons 'toplevel imports))))
-    ((ccall)
-     (if (not (eqv? (peek-token s) #\())
-         (error "invalid \"ccall\" syntax")
-         (begin
-           (take-token s)
-           (let ((al (parse-arglist s #\))))
-             (if (and (length> al 1)
-                      (memq (cadr al) '(cdecl stdcall fastcall thiscall)))
-                 ;; place (callingconv) at end of arglist
-                 `(ccall ,(car al) ,@(cddr al) (,(cadr al)))
-                 `(ccall ,.al))))))
-    ((do)
-     (error "invalid \"do\" syntax"))
-    (else (error "unhandled reserved word")))))))
+                         (parse-block s)))
+               (nxt  (require-token s)))
+          (take-token s)
+          (case nxt
+            ((end)     (list 'if test then))
+            ((elseif)
+             (if (newline? (peek-token s))
+                 (error (string "missing condition in \"elseif\" at " current-filename
+                                ":" (- (input-port-line (ts:port s)) 1))))
+             `(if ,test ,then
+                  ;; line number for elseif condition
+                  (block ,(line-number-node s)
+                         ,(parse-resword s 'if))))
+            ((else)
+             (if (eq? (peek-token s) 'if)
+                 (error "use \"elseif\" instead of \"else if\""))
+             (begin0 (list 'if test then (parse-block s))
+                     (expect-end s word)))
+            (else      (error (string "unexpected \"" nxt "\""))))))
+       ((let)
+        (let ((binds (if (memv (peek-token s) '(#\newline #\;))
+                         '()
+                         (parse-comma-separated-assignments s))))
+          (if (not (or (eof-object? (peek-token s))
+                       (memv (peek-token s) '(#\newline #\; end))))
+              (error "let variables should end in \";\" or newline"))
+          (let ((ex (parse-block s)))
+            (expect-end s word)
+            `(let ,ex ,@binds))))
+       ((global local)
+        (let* ((lno (input-port-line (ts:port s)))
+               (const (and (eq? (peek-token s) 'const)
+                           (take-token s)))
+               (expr  (cons word
+                            (map (lambda (x)
+                                   (short-form-function-loc x lno))
+                                 (parse-comma-separated-assignments s)))))
+          (if const
+              `(const ,expr)
+              expr)))
+       ((stagedfunction function macro)
+        (if (eq? word 'stagedfunction) (syntax-deprecation s "stagedfunction" "@generated function"))
+        (let* ((paren (eqv? (require-token s) #\())
+               (sig   (parse-call s)))
+          (if (and (eq? word 'function) (not paren) (symbol-or-interpolate? sig))
+              (begin (if (not (eq? (require-token s) 'end))
+                         (error (string "expected \"end\" in definition of function \"" sig "\"")))
+                     (take-token s)
+                     `(function ,sig))
+              (let* ((def   (if (or (symbol? sig)
+                                    (and (pair? sig) (eq? (car sig) '|::|)
+                                         (symbol? (cadr sig))))
+                                (if paren
+                                    ;; in "function (x)" the (x) is a tuple
+                                    `(tuple ,sig)
+                                    ;; function foo  =>  syntax error
+                                    (error (string "expected \"(\" in " word " definition")))
+                                (if (not (and (pair? sig)
+                                              (or (eq? (car sig) 'call)
+                                                  (eq? (car sig) 'tuple))))
+                                    (error (string "expected \"(\" in " word " definition"))
+                                    sig)))
+                     (loc   (begin (if (not (eq? (peek-token s) 'end))
+                                       ;; if ends on same line, don't skip the following newline
+                                       (skip-ws-and-comments (ts:port s)))
+                                   (line-number-node s)))
+                     (body  (parse-block s)))
+                (expect-end s word)
+                (add-filename-to-block! body loc)
+                (list word def body)))))
+       ((abstract)
+        (list 'abstract (parse-subtype-spec s)))
+       ((type immutable)
+        (let ((immu? (eq? word 'immutable)))
+          (if (reserved-word? (peek-token s))
+              (error (string "invalid type name \"" (take-token s) "\"")))
+          (let ((sig (parse-subtype-spec s))
+                (loc (line-number-node s)))
+            (begin0 (list 'type (if (eq? word 'type) #t #f)
+                          sig (add-filename-to-block! (parse-block s) loc))
+                    (expect-end s word)))))
+       ((bitstype)
+        (list 'bitstype (with-space-sensitive (parse-cond s))
+              (parse-subtype-spec s)))
+       ((typealias)
+        (let ((lhs (parse-call s)))
+          (if (and (pair? lhs) (eq? (car lhs) 'call))
+              ;; typealias X (...) is tuple type alias, not call
+              (list 'typealias (cadr lhs) (cons 'tuple (cddr lhs)))
+              (list 'typealias lhs (parse-arrow s)))))
+       ((try)
+        (let ((try-block (if (memq (require-token s) '(catch finally))
+                             '(block)
+                             (parse-block s))))
+          (let loop ((nxt    (require-token s))
+                     (catchb #f)
+                     (catchv #f)
+                     (finalb #f))
+            (take-token s)
+            (cond
+             ((eq? nxt 'end)
+              (list* 'try try-block catchv
+                     ;; default to empty catch block in `try ... end`
+                     (or catchb (if finalb #f '(block)))
+                     (if finalb (list finalb) '())))
+             ((and (eq? nxt 'catch)
+                   (not catchb))
+              (let ((nl (memv (peek-token s) '(#\newline #\;))))
+                (if (eqv? (peek-token s) #\;)
+                    (take-token s))
+                (if (memq (require-token s) '(end finally))
+                    (loop (require-token s)
+                          '(block)
+                          #f
+                          finalb)
+                    (let* ((var (if nl (parse-eq s) (parse-eq* s)))
+                           (var? (and (not nl) (or (symbol? var) (and (length= var 2) (eq? (car var) '$)))))
+                           (catch-block (if (eq? (require-token s) 'finally)
+                                            '(block)
+                                            (parse-block s))))
+                      (loop (require-token s)
+                            (if var?
+                                catch-block
+                                `(block ,var ,@(cdr catch-block)))
+                            (and var? var)
+                            finalb)))))
+             ((and (eq? nxt 'finally)
+                   (not finalb))
+              (let ((fb (if (eq? (require-token s) 'catch)
+                            '(block)
+                            (parse-block s))))
+                (loop (require-token s)
+                      catchb
+                      catchv
+                      fb)))
+             (else    (error (string "unexpected \"" nxt "\"")))))))
+       ((return)          (let ((t (peek-token s)))
+                            (if (or (eqv? t #\newline) (closing-token? t))
+                                (list 'return '(null))
+                                (list 'return (parse-eq s)))))
+       ((break continue)
+        (let ((t (peek-token s)))
+          (if (or (eof-object? t)
+                  (and (eq? t 'end) (not end-symbol))
+                  (memv t '(#\newline #\; #\) :)))
+              (list word)
+              (error (string "unexpected \"" t "\" after " word)))))
+
+       ((const)
+        (let ((assgn (parse-eq s)))
+          (if (not (and (pair? assgn)
+                        (or (eq? (car assgn) '=)
+                            (eq? (car assgn) 'global)
+                            (eq? (car assgn) 'local))))
+              (error "expected assignment after \"const\"")
+              `(const ,assgn))))
+       ((module baremodule)
+        (let* ((name (parse-unary-prefix s))
+               (loc  (line-number-node s))
+               (body (parse-block s (lambda (s) (parse-docstring s parse-eq)))))
+          (expect-end s word)
+          (list 'module (eq? word 'module) name
+                (if (eq? word 'module)
+                    (list* 'block
+                           ;; add definitions for module-local eval
+                           (let ((x (if (eq? name 'x) 'y 'x)))
+                             `(= (call eval ,x)
+                                 (block
+                                  ,loc
+                                  (call (|.| (top Core) 'eval) ,name ,x))))
+                           `(= (call eval m x)
+                               (block
+                                ,loc
+                                (call (|.| (top Core) 'eval) m x)))
+                           (cdr body))
+                    body))))
+       ((export)
+        (let ((es (map macrocall-to-atsym
+                       (parse-comma-separated s parse-unary-prefix))))
+          (if (not (every symbol-or-interpolate? es))
+              (error "invalid \"export\" statement"))
+          `(export ,@es)))
+       ((import using importall)
+        (let ((imports (parse-imports s word)))
+          (if (length= imports 1)
+              (car imports)
+              (cons 'toplevel imports))))
+       ((ccall)
+        (if (not (eqv? (peek-token s) #\())
+            (error "invalid \"ccall\" syntax")
+            (begin
+              (take-token s)
+              (let ((al (parse-arglist s #\))))
+                (if (and (length> al 1)
+                         (memq (cadr al) '(cdecl stdcall fastcall thiscall)))
+                    ;; place (callingconv) at end of arglist
+                    `(ccall ,(car al) ,@(cddr al) (,(cadr al)))
+                    `(ccall ,.al))))))
+       ((do)
+        (error "invalid \"do\" syntax"))
+       (else (error "unhandled reserved word")))))))
 
 (define (add-filename-to-block! body loc)
   (if (and (length> body 1)
@@ -1318,15 +1310,16 @@
   body)
 
 (define (parse-do s)
-  (with-bindings ((expect-end-current-line (input-port-line (ts:port s))))
-  (without-whitespace-newline
-   (let* ((doargs (if (eqv? (peek-token s) #\newline)
-                      '()
-                      (parse-comma-separated s parse-range)))
-          (loc (line-number-node s)))
-     `(-> (tuple ,@doargs)
-          ,(begin0 (add-filename-to-block! (parse-block s) loc)
-                   (expect-end- s 'do)))))))
+  (with-bindings
+   ((expect-end-current-line (input-port-line (ts:port s))))
+   (without-whitespace-newline
+    (let* ((doargs (if (eqv? (peek-token s) #\newline)
+                       '()
+                       (parse-comma-separated s parse-range)))
+           (loc (line-number-node s)))
+      `(-> (tuple ,@doargs)
+           ,(begin0 (add-filename-to-block! (parse-block s) loc)
+                    (expect-end s 'do)))))))
 
 (define (macrocall-to-atsym e)
   (if (and (pair? e) (eq? (car e) 'macrocall))
@@ -1378,9 +1371,9 @@
       (cond
        ((eq? nxt '|.|)
         (if (ts:space? s)
-          (syntax-deprecation s
-                              (string (deparse word) " " (deparse nxt))
-                              (string (deparse word) (deparse nxt))))
+            (syntax-deprecation s
+                                (string (deparse word) " " (deparse nxt))
+                                (string (deparse word) (deparse nxt))))
         (take-token s)
         (loop (cons (macrocall-to-atsym (parse-unary-prefix s)) path)))
        ((or (memv nxt '(#\newline #\; #\, :))
@@ -1393,7 +1386,7 @@
        (else
         `(,word ,@(reverse path)))))))
 
-; parse comma-separated assignments, like "i=1:n,j=1:m,..."
+;; parse comma-separated assignments, like "i=1:n,j=1:m,..."
 (define (parse-comma-separated s what)
   (let loop ((exprs '()))
     (let ((r (what s)))
@@ -1404,21 +1397,23 @@
 (define (parse-comma-separated-assignments s)
   (parse-comma-separated s parse-eq*))
 
-; as above, but allows both "i=r" and "i in r"
+;; as above, but allows both "i=r" and "i in r"
+(define (parse-iteration-spec s)
+  (let ((r (parse-eq* s)))
+    (cond ((and (pair? r) (eq? (car r) '=))  r)
+          ((eq? r ':)  r)
+          ((and (length= r 4) (eq? (car r) 'comparison)
+                (or (eq? (caddr r) 'in) (eq? (caddr r) '∈)))
+           `(= ,(cadr r) ,(cadddr r)))
+          (else
+           (error "invalid iteration specification")))))
+
 (define (parse-comma-separated-iters s)
   (let loop ((ranges '()))
-    (let ((r (parse-eq* s)))
-      (let ((r (cond ((and (pair? r) (eq? (car r) '=))
-                      r)
-                     ((eq? r ':)
-                      r)
-                     ((and (pair? r) (eq? (car r) 'in))
-                      `(= ,(cadr r) ,(caddr r)))
-                     (else
-                      (error "invalid iteration specification")))))
-        (case (peek-token s)
-          ((#\,)  (take-token s) (loop (cons r ranges)))
-          (else   (reverse! (cons r ranges))))))))
+    (let ((r (parse-iteration-spec s)))
+      (case (peek-token s)
+        ((#\,)  (take-token s) (loop (cons r ranges)))
+        (else   (reverse! (cons r ranges)))))))
 
 (define (parse-space-separated-exprs s)
   (with-space-sensitive
@@ -1441,26 +1436,24 @@
                        x))
        lst))
 
-; handle function call argument list, or any comma-delimited list.
-; . an extra comma at the end is allowed
-; . expressions after a ; are enclosed in (parameters ...)
-; . an expression followed by ... becomes (... x)
+;; handle function call argument list, or any comma-delimited list.
+;; . an extra comma at the end is allowed
+;; . expressions after a ; are enclosed in (parameters ...)
+;; . an expression followed by ... becomes (... x)
 (define (parse-arglist s closer)
-  (with-normal-ops
-   (with-whitespace-newline
-    (parse-arglist- s closer))))
-(define (parse-arglist- s closer)
+(with-normal-ops
+ (with-whitespace-newline
   (let loop ((lst '()))
     (let ((t (require-token s)))
-      (if (equal? t closer)
+      (if (eqv? t closer)
           (begin (take-token s)
                  (if (eqv? closer #\) )
                      ;; (= x y) inside function call is keyword argument
-                     (to-kws (reverse lst))
-                     (reverse lst)))
-          (if (equal? t #\;)
+                     (to-kws (reverse! lst))
+                     (reverse! lst)))
+          (if (eqv? t #\;)
               (begin (take-token s)
-                     (if (equal? (peek-token s) closer)
+                     (if (eqv? (peek-token s) closer)
                          ;; allow f(a, b; )
                          (loop lst)
                          (let ((params (loop '()))
@@ -1472,17 +1465,21 @@
               (let* ((nxt (parse-eq* s))
                      (c (require-token s)))
                 (cond ((eqv? c #\,)
-                       (begin (take-token s) (loop (cons nxt lst))))
-                      ((eqv? c #\;)          (loop (cons nxt lst)))
-                      ((equal? c closer)     (loop (cons nxt lst)))
+                       (take-token s)
+                       (loop (cons nxt lst)))
+                      ((eqv? c #\;)     (loop (cons nxt lst)))
+                      ((eqv? c closer)  (loop (cons nxt lst)))
+                      ((eq? c 'for)
+                       (take-token s)
+                       (loop (cons (parse-generator s nxt) lst)))
                       ;; newline character isn't detectable here
                       #;((eqv? c #\newline)
-                       (error "unexpected line break in argument list"))
-                      ((memv c '(#\] #\}))
+                      (error "unexpected line break in argument list"))
+                      ((or (eqv? c #\]) (eqv? c #\}))
                        (error (string "unexpected \"" c "\" in argument list")))
                       (else
                        (error (string "missing comma or " closer
-                                      " in argument list"))))))))))
+                                      " in argument list"))))))))))))
 
 (define (parse-vect s first closer)
   (let loop ((lst '())
@@ -1519,7 +1516,7 @@
 (define (parse-comprehension s first closer)
   (let ((r (parse-comma-separated-iters s)))
     (if (not (eqv? (require-token s) closer))
-        (error (string "expected " closer))
+        (error (string "expected \"" closer "\""))
         (take-token s))
     `(comprehension ,first ,@r)))
 
@@ -1529,6 +1526,9 @@
         `(dict_comprehension ,@(cdr c))
         (error "invalid dict comprehension"))))
 
+(define (parse-generator s first)
+  `(generator ,first ,@(parse-comma-separated-iters s)))
+
 (define (parse-matrix s first closer gotnewline)
   (define (fix head v) (cons head (reverse v)))
   (define (update-outer v outer)
@@ -1605,32 +1605,44 @@
                       (else
                        (parse-matrix s first closer #f))))))))))
 
-; for sequenced evaluation inside expressions: e.g. (a;b, c;d)
-(define (parse-stmts-within-expr s)
-  (parse-Nary s parse-eq* '(#\;) 'block '(#\, #\) ) #t))
-
-(define (parse-tuple s first)
-  (let loop ((lst '())
-             (nxt first))
-    (case (require-token s)
-      ((#\))
-       (take-token s)
-       (cons 'tuple (reverse (cons nxt lst))))
-      ((#\,)
-       (take-token s)
-       (if (eqv? (require-token s) #\))
-           ;; allow ending with ,
-           (begin (take-token s)
-                  (cons 'tuple (reverse (cons nxt lst))))
-           (loop (cons nxt lst) (parse-eq* s))))
-      ((#\;)
-       (error "unexpected semicolon in tuple"))
-      #;((#\newline)
-      (error "unexpected line break in tuple"))
-      ((#\] #\})
-       (error (string "unexpected \"" (peek-token s) "\" in tuple")))
-      (else
-       (error "missing separator in tuple")))))
+(define (kw-to-= e) (if (kwarg? e) (cons '= (cdr e)) e))
+(define (=-to-kw e) (if (assignment? e) (cons 'kw (cdr e)) e))
+
+;; translate nested (parameters ...) expressions to a statement block if possible
+;; this allows us to first parse tuples using parse-arglist
+(define (parameters-to-block e)
+  (if (and (pair? e) (eq? (car e) 'parameters))
+      (cond ((length= e 1) '())
+            ((length= e 2) (parameters-to-block (cadr e)))
+            ((length= e 3)
+             (let ((fst (cadr e))
+                   (snd (caddr e)))
+               (if (and (pair? fst) (eq? (car fst) 'parameters))
+                   (let ((rec (parameters-to-block fst))
+                         (snd (parameters-to-block snd)))
+                     (and rec snd
+                          (cons (car snd) rec)))
+                   #f)))
+            (else #f))
+      (list (kw-to-= e))))
+
+;; convert an arglist to a tuple or block expr
+;; leading-semi? means we saw (; ...)
+;; comma? means there was a comma after the first expression
+(define (arglist-to-tuple leading-semi? comma? args . first)
+  (if (and (pair? first) (null? args) (not leading-semi?) (not comma?))
+      `(block ,@first)  ;; this case is (x;)
+      (or (and (not comma?) (length= args 1) (pair? (car args)) (eq? (caar args) 'parameters)
+               (let ((blk (parameters-to-block (car args))))
+                 (and blk (or (and (not leading-semi?)
+                                   `(block ,@first ,@blk))
+                              (and (null? first) (null? blk)
+                                   `(block))))))  ;; all semicolons inside ()
+          (and (null? first) (null? args) (not comma?)
+               `(block))  ;; this case is (;)
+          (if (and (pair? args) (pair? (car args)) (eq? (caar args) 'parameters))
+              `(tuple ,(car args) ,@first ,@(map kw-to-= (cdr args)))
+              `(tuple ,@first ,@(map kw-to-= args))))))
 
 (define (not-eof-2 c)
   (if (eof-object? c)
@@ -1662,19 +1674,19 @@
 (define (take-char p)
   (begin (read-char p) p))
 
-; map the first element of lst
+;; map the first element of lst
 (define (map-first f lst)
   (if (null? lst) ()
     (cons (f (car lst)) (cdr lst))))
 
-; map the elements of lst where (pred index) is true
-; e.g., (map-at odd? (lambda (x) 0) '(a b c d)) -> '(a 0 c 0)
+;; map the elements of lst where (pred index) is true
+;; e.g., (map-at odd? (lambda (x) 0) '(a b c d)) -> '(a 0 c 0)
 (define (map-at pred f lst)
   (define (map-at- pred f lst i r)
     (if (null? lst) (reverse r)
-      (let* ((x (car lst))
-             (y (if (pred i) (f x) x)))
-        (map-at- pred f (cdr lst) (+ i 1) (cons y r)))))
+        (let* ((x (car lst))
+               (y (if (pred i) (f x) x)))
+          (map-at- pred f (cdr lst) (+ i 1) (cons y r)))))
   (map-at- pred f lst 0 ()))
 
 (define (parse-string-literal s custom)
@@ -1682,20 +1694,20 @@
     (if (eqv? (peek-char p) #\")
         (if (eqv? (peek-char (take-char p)) #\")
             (map-first strip-leading-newline
-              (dedent-triplequoted-string
-                (parse-string-literal- 2 (take-char p) s custom)))
+                       (dedent-triplequoted-string
+                        (parse-string-literal- 2 (take-char p) s custom)))
             (list ""))
         (parse-string-literal- 0 p s custom))))
 
 (define (strip-leading-newline s)
   (let ((n (sizeof s)))
     (cond
-      ((and (> n 0) (eqv? (string.char s 0) #\newline))
-       (string.tail s 1))
-      ((and (> n 1) (eqv? (string.char s 0) #\return)
-                    (eqv? (string.char s 1) #\newline))
-       (string.tail s 2))
-      (else s))))
+     ((and (> n 0) (eqv? (string.char s 0) #\newline))
+      (string.tail s 1))
+     ((and (> n 1) (eqv? (string.char s 0) #\return)
+           (eqv? (string.char s 1) #\newline))
+      (string.tail s 2))
+     (else s))))
 
 (define (dedent-triplequoted-string lst)
   (let ((prefix (triplequoted-string-indentation lst)))
@@ -1710,10 +1722,10 @@
 
 (define (triplequoted-string-indentation lst)
   (longest-common-prefix
-    (apply append (map (lambda (s) (if (string? s)
-                                       (triplequoted-string-indentation- s)
-                                       ()))
-                       lst))))
+   (apply append (map (lambda (s) (if (string? s)
+                                      (triplequoted-string-indentation- s)
+                                      ()))
+                      lst))))
 
 (define (triplequoted-string-indentation- s)
   (let ((p (open-input-string s)))
@@ -1722,28 +1734,28 @@
                (prefix ())
                (prefixes ()))
       (cond
-        ((eqv? c #\newline)
-         (loop (read-char p) 1 () prefixes))
-        ((eqv? state 0)
-         (if (eof-object? c) prefixes
-             (loop (read-char p) 0 () prefixes)))
-        ((memv c '(#\space #\tab))
-         (loop (read-char p) 2 (cons c prefix) prefixes))
-        (else
-         (loop (read-char p) 0 () (cons (reverse prefix) prefixes)))))))
+       ((eqv? c #\newline)
+        (loop (read-char p) 1 () prefixes))
+       ((eqv? state 0)
+        (if (eof-object? c) prefixes
+            (loop (read-char p) 0 () prefixes)))
+       ((memv c '(#\space #\tab))
+        (loop (read-char p) 2 (cons c prefix) prefixes))
+       (else
+        (loop (read-char p) 0 () (cons (reverse prefix) prefixes)))))))
 
-; return the longest common prefix of the elements of l
-; e.g., (longest-common-prefix ((1 2) (1 4))) -> (1)
+;; return the longest common prefix of the elements of l
+;; e.g., (longest-common-prefix ((1 2) (1 4))) -> (1)
 (define (longest-common-prefix l)
   (let ((len (length l)))
-  (cond
-    ((= len 0) ())
-    ((= len 1) (car l))
-    (else (longest-common-prefix
+    (cond
+     ((= len 0) ())
+     ((= len 1) (car l))
+     (else (longest-common-prefix
             (cons (longest-common-prefix2 (car l) (cadr l))
                   (cddr l)))))))
 
-; return the longest common prefix of lists a & b
+;; return the longest common prefix of lists a & b
 (define (longest-common-prefix2 a b)
   (longest-common-prefix2- a b ()))
 
@@ -1763,7 +1775,7 @@
         (string-split- s sep (+ i (sizeof sep)) (cons (string.sub s start i) splits))
         (reverse (cons (string.sub s start (sizeof s)) splits)))))
 
-; replace all occurrences of a in s with b
+;; replace all occurrences of a in s with b
 (define (string-replace s a b)
   (string.join (string-split s a) b))
 
@@ -1831,6 +1843,14 @@
                (list* ex (tostr custom b) e)
                0)))
 
+      ; convert literal \r and \r\n in strings to \n (issue #11988)
+      ((eqv? c #\return) ; \r
+       (begin
+         (if (eqv? (peek-char p) #\linefeed) ; \r\n
+             (read-char p))
+         (write-char #\newline b)
+         (loop (read-char p) b e 0)))
+
       (else
        (write-char (not-eof-3 c) b)
        (loop (read-char p) b e 0)))))
@@ -1847,46 +1867,43 @@
      ;; process escape sequences using lisp read
      (read (open-input-string (string #\" s #\"))))))
 
-; parse numbers, identifiers, parenthesized expressions, lists, vectors, etc.
-(define (parse-atom s)
-  (let ((ex (parse-atom- s)))
-    (if (invalid-identifier-name? ex)
-        (error (string "invalid identifier name \"" ex "\"")))
-    ex))
+(define (check-identifier ex)
+  (if (invalid-identifier-name? ex)
+      (error (string "invalid identifier name \"" ex "\""))))
 
-(define (parse-atom- s)
+;; parse numbers, identifiers, parenthesized expressions, lists, vectors, etc.
+(define (parse-atom s (checked #t))
   (let ((t (require-token s)))
-    (cond ((or (string? t) (number? t) (large-number? t)) (take-token s))
-
-          ;; char literal
+    (cond ;; char literal
           ((eq? t '|'|)
            (take-token s)
            (let ((firstch (read-char (ts:port s))))
-             (if (eqv? firstch #\')
-              (error "invalid character literal")
-              (if (and (not (eqv? firstch #\\))
-                       (not (eof-object? firstch))
-                       (eqv? (peek-char (ts:port s)) #\'))
-               ;; easy case: 1 character, no \
-               (begin (read-char (ts:port s)) firstch)
-               (let ((b (open-output-string)))
-                 (let loop ((c firstch))
-                   (if (eqv? c #\')
-                       #t
-                       (begin (write-char (not-eof-1 c) b)
-                              (if (eqv? c #\\)
-                                  (write-char
-                                   (not-eof-1 (read-char (ts:port s))) b))
-                              (loop (read-char (ts:port s))))))
-                 (let ((str (unescape-string (io.tostring! b))))
-                   (if (= (length str) 1)
-                       ;; one byte, e.g. '\xff'. maybe not valid UTF-8, but we
-                       ;; want to use the raw value as a codepoint in this case.
-                       (wchar (aref str 0))
-                       (if (or (not (= (string-length str) 1))
-                               (not (string.isutf8 str)))
-                           (error "invalid character literal")
-                           (string.char str 0)))))))))
+               (if (and (not (eqv? firstch #\\))
+                        (not (eof-object? firstch))
+                        (eqv? (peek-char (ts:port s)) #\'))
+                   ;; easy case: 1 character, no \
+                   (begin (read-char (ts:port s)) firstch)
+                   (let ((b (open-output-string)))
+                     (let loop ((c firstch))
+                       (if (eqv? c #\')
+                           #t
+                           (begin (if (eqv? c #\")
+                                      (error "invalid character literal") ;; issue 14683
+                                      #t)
+                                  (write-char (not-eof-1 c) b)
+                                  (if (eqv? c #\\)
+                                      (write-char
+                                       (not-eof-1 (read-char (ts:port s))) b))
+                                      (loop (read-char (ts:port s))))))
+                     (let ((str (unescape-string (io.tostring! b))))
+                       (if (= (length str) 1)
+                           ;; one byte, e.g. '\xff'. maybe not valid UTF-8, but we
+                           ;; want to use the raw value as a codepoint in this case.
+                           (wchar (aref str 0))
+                           (if (or (not (= (string-length str) 1))
+                                   (not (string.isutf8 str)))
+                               (error "invalid character literal")
+                               (string.char str 0))))))))
 
           ;; symbol/expression quote
           ((eq? t ':)
@@ -1896,68 +1913,68 @@
                       (or (not (symbol? nxt))
                           (ts:space? s)))
                  ':
-		 (if (ts:space? s)
-		     (error "space not allowed after \":\" used for quoting")
-		     (list 'quote (parse-atom- s))))))
+                 (if (ts:space? s)
+                     (error "space not allowed after \":\" used for quoting")
+                     (list 'quote (parse-atom s #f))))))
 
           ;; misplaced =
           ((eq? t '=) (error "unexpected \"=\""))
 
           ;; identifier
-          ((symbol? t) (take-token s))
+          ((symbol? t)
+           (if checked (check-identifier t))
+           (take-token s))
 
           ;; parens or tuple
           ((eqv? t #\( )
            (take-token s)
            (with-normal-ops
-           (with-whitespace-newline
-           (cond
-            ((eqv? (require-token s) #\) )
-             ;; empty tuple ()
-             (begin (take-token s) '(tuple)))
-            ((syntactic-op? (peek-token s))
-             ;; allow (=) etc.
-             (let ((tok (take-token s)))
-               (if (not (eqv? (require-token s) #\) ))
-                   (error (string "invalid identifier name \"" tok "\""))
-                   (take-token s))
-               tok))
-            (else
-             ;; here we parse the first subexpression separately, so
-             ;; we can look for a comma to see if it's a tuple.
-             ;; this lets us distinguish (x) from (x,)
-             (let* ((ex (parse-eq* s))
-                    (t  (require-token s)))
-               (cond ((eqv? t #\) )
-                      (take-token s)
-                      (if (and (pair? ex) (eq? (car ex) '...))
-                          ;; (ex...)
-                          `(tuple ,ex)
-                          ;; value in parentheses (x)
-                          ex))
-                     ((eqv? t #\, )
-                      ;; tuple (x,) (x,y) (x...) etc.
-                      (parse-tuple s ex))
-                     ((eqv? t #\;)
-                      ;; parenthesized block (a;b;c)
-                      (take-token s)
-                      (if (eqv? (require-token s) #\))
-                          ;; (ex;)
-                          (begin (take-token s) `(block ,ex))
-                          (let* ((blk (parse-stmts-within-expr s))
-                                 (tok (require-token s)))
-                            (if (eqv? tok #\,)
-                                (error "unexpected comma in statement block"))
-                            (if (not (eqv? tok #\)))
-                                (error "missing separator in statement block"))
-                            (take-token s)
-                            `(block ,ex ,blk))))
-                     #;((eqv? t #\newline)
-                        (error "unexpected line break in tuple"))
-                     ((memv t '(#\] #\}))
-                      (error (string "unexpected \"" t "\" in tuple")))
-                     (else
-                      (error "missing separator in tuple")))))))))
+            (with-whitespace-newline
+             (cond
+              ((eqv? (require-token s) #\) )
+               ;; empty tuple ()
+               (begin (take-token s) '(tuple)))
+              ((syntactic-op? (peek-token s))
+               ;; allow (=) etc.
+               (let ((tok (take-token s)))
+                 (if (not (eqv? (require-token s) #\) ))
+                     (error (string "invalid identifier name \"" tok "\""))
+                     (take-token s))
+                 (if checked (check-identifier tok))
+                 tok))
+              ((eqv? (peek-token s) #\;)
+               (arglist-to-tuple #t #f (parse-arglist s #\) )))
+              (else
+               ;; here we parse the first subexpression separately, so
+               ;; we can look for a comma to see if it's a tuple.
+               ;; this lets us distinguish (x) from (x,)
+               (let* ((ex (parse-eq* s))
+                      (t  (require-token s)))
+                 (cond ((eqv? t #\) )
+                        (take-token s)
+                        (if (and (pair? ex) (eq? (car ex) '...))
+                            ;; (ex...)
+                            `(tuple ,ex)
+                            ;; value in parentheses (x)
+                            ex))
+                       ((eq? t 'for)
+                        (take-token s)
+                        (let ((gen (parse-generator s ex)))
+                          (if (eqv? (require-token s) #\) )
+                              (take-token s)
+                              (error "expected \")\""))
+                          gen))
+                       (else
+                        ;; tuple (x,) (x,y) (x...) etc.
+                        (if (eqv? t #\, )
+                            (take-token s))
+                        (arglist-to-tuple #f (eqv? t #\,) (parse-arglist s #\) ) ex)))))))))
+
+          ;; cat expression
+          ((eqv? t #\[ )
+           (take-token s)
+           (let ((vex (parse-cat s #\])))
+             (if (null? vex) '(vect) vex)))
 
           ;; cell expression
           ((eqv? t #\{ )
@@ -2013,12 +2030,6 @@
                                   (syntax-deprecation s "{a,b, ...}" "Any[a,b, ...]")
                                   `(cell1d ,@(cdr vex)))))))))))
 
-          ;; cat expression
-          ((eqv? t #\[ )
-           (take-token s)
-           (let ((vex (parse-cat s #\])))
-             (if (null? vex) '(vect) vex)))
-
           ;; string literal
           ((eqv? t #\")
            (take-token s)
@@ -2037,22 +2048,24 @@
             (let* ((head (parse-unary-prefix s))
                    (t    (peek-token s)))
               (cond
-                 ((eqv? head '__LINE__) (input-port-line (ts:port s)))
-                 ((ts:space? s)
-                  `(macrocall ,(macroify-name head)
-                              ,@(parse-space-separated-exprs s)))
-                 (else
-                   (let ((call (parse-call-chain s head #t)))
-                      (if (and (pair? call) (eq? (car call) 'call))
-                        `(macrocall ,(macroify-name (cadr call)) ,@(cddr call))
-                        `(macrocall ,(macroify-name call)
-                                    ,@(parse-space-separated-exprs s)))))))))
+               ((eqv? head '__LINE__) (input-port-line (ts:port s)))
+               ((ts:space? s)
+                `(macrocall ,(macroify-name head)
+                            ,@(parse-space-separated-exprs s)))
+               (else
+                (let ((call (parse-call-chain s head #t)))
+                  (if (and (pair? call) (eq? (car call) 'call))
+                      `(macrocall ,(macroify-name (cadr call)) ,@(cddr call))
+                      `(macrocall ,(macroify-name call)
+                                  ,@(parse-space-separated-exprs s)))))))))
 
           ;; command syntax
           ((eqv? t #\`)
            (take-token s)
            (parse-backquote s))
 
+          ((or (string? t) (number? t) (large-number? t)) (take-token s))
+
           (else (error (string "invalid syntax: \"" (take-token s) "\""))))))
 
 (define (valid-modref? e)
@@ -2080,14 +2093,13 @@
   (let* ((ex (production s)))
     (if (and (doc-string-literal? ex)
              (let loop ((t (peek-token s)))
-               (cond
-                ((closing-token? t) #f)
-                ((newline? t) (take-token s) (loop (peek-token s)))
-                (else #t))))
+               (cond ((closing-token? t) #f)
+                     ((newline? t) (take-token s) (loop (peek-token s)))
+                     (else #t))))
         `(macrocall @doc ,ex ,(production s))
         ex)))
 
-; --- main entry point ---
+;; --- main entry point ---
 
 ;; can optionally specify which grammar production to parse.
 ;; default is parse-stmts.
@@ -2109,4 +2121,4 @@
          (if (eof-object? (peek-token s))
              (eof-object)
              ((if (null? production) parse-stmts (car production))
-	            s)))))
+              s)))))
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 8f79636fc2cdf..3121c0f8766a7 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1,253 +1,30 @@
-(define (quoted? e) (memq (car e) '(quote top line break inert)))
+;; ignored variable name. TODO replace with _?
+(define UNUSED '|#unused#|)
 
-(define (lam:args x) (cadr x))
-(define (lam:vars x) (llist-vars (lam:args x)))
-(define (lam:vinfo x) (caddr x))
-(define (lam:body x) (cadddr x))
+;; pass 1: syntax desugaring
 
 ;; allow (:: T) => (:: #gensym T) in formal argument lists
-(define (fill-missing-argname a)
+(define (fill-missing-argname a unused)
   (if (and (pair? a) (eq? (car a) '|::|) (null? (cddr a)))
-      `(|::| ,(gensy) ,(cadr a))
+      `(|::| ,(if unused UNUSED (gensy)) ,(cadr a))
       a))
-(define (fix-arglist l)
+(define (fix-arglist l (unused #t))
   (if (any vararg? (butlast l))
       (error "invalid ... on non-final argument"))
   (map (lambda (a)
          (cond ((and (pair? a) (eq? (car a) 'kw))
-                `(kw ,(fill-missing-argname (cadr a)) ,(caddr a)))
+                `(kw ,(fill-missing-argname (cadr a) unused) ,(caddr a)))
                ((and (pair? a) (eq? (car a) '...))
-                `(... ,(fill-missing-argname (cadr a))))
+                `(... ,(fill-missing-argname (cadr a) unused)))
                (else
-                (fill-missing-argname a))))
+                (fill-missing-argname a unused))))
        l))
 
-(define (deparse-arglist l (sep ",")) (string.join (map deparse l) sep))
-
-(define (deparse e)
-  (cond ((or (symbol? e) (number? e)) (string e))
-        ((eq? e #t) "true")
-        ((eq? e #f) "false")
-        ((eq? (typeof e) 'julia_value)
-         (let ((s (string e)))
-           (if (string.find s "#<julia: ")
-               ;; successfully printed as a julia value
-               (string.sub s 9 (string.dec s (length s)))
-               s)))
-        ((atom? e) (string e))
-        ((eq? (car e) '|.|)
-         (string (deparse (cadr e)) '|.|
-                 (if (and (pair? (caddr e)) (memq (caaddr e) '(quote inert)))
-                     (deparse (cadr (caddr e)))
-                     (string #\( (deparse (caddr e)) #\)))))
-        ((memq (car e) '(... |'| |.'|))
-         (string (deparse (cadr e)) (car e)))
-        ((syntactic-op? (car e))
-         (string (deparse (cadr e)) (car e) (deparse (caddr e))))
-        ((memq (car e) '($ &))
-         (string (car e) (deparse (cadr e))))
-        ((eq? (car e) '|::|)
-         (if (length> e 2)
-             (string (deparse (cadr e)) (car e) (deparse (caddr e)))
-             (string (car e) (deparse (cadr e)))))
-        (else (case (car e)
-                ((tuple)
-                 (string #\( (deparse-arglist (cdr e))
-                         (if (length= e 2) #\, "")
-                         #\)))
-                ((cell1d) (string #\{ (deparse-arglist (cdr e)) #\}))
-                ((call)   (string (deparse (cadr e)) #\( (deparse-arglist (cddr e)) #\)))
-                ((ref)    (string (deparse (cadr e)) #\[ (deparse-arglist (cddr e)) #\]))
-                ((curly)  (string (deparse (cadr e)) #\{ (deparse-arglist (cddr e)) #\}))
-                ((quote inert)
-		 (if (symbol? (cadr e))
-		     (string ":" (deparse (cadr e)))
-		     (string ":(" (deparse (cadr e)) ")")))
-                ((vcat)   (string #\[ (deparse-arglist (cdr e)) #\]))
-                ((hcat)   (string #\[ (deparse-arglist (cdr e) " ") #\]))
-                ((global local const)
-                 (string (car e) " " (deparse (cadr e))))
-                ((:)
-                 (string (deparse (cadr e)) ': (deparse (caddr e))
-                         (if (length> e 3)
-                             (string ': (deparse (cadddr e)))
-                             "")))
-                ((comparison) (apply string (map deparse (cdr e))))
-                ((in) (string (deparse (cadr e)) " in " (deparse (caddr e))))
-                ((jlgensym) (string "GenSym(" (cdr e) ")"))
-		((line) (if (length= e 2)
-			    (string "# line " (cadr e))
-			    (string "# " (caddr e) ", line " (cadr e))))
-		((block)
-		 (string "begin\n"
-			 (string.join (map (lambda (ex) (string "    " (deparse ex)))
-					   (cdr e))
-				      "\n")
-			 "\nend"))
-                (else
-                 (string e))))))
-
-(define (bad-formal-argument v)
-  (error (string #\" (deparse v) #\" " is not a valid function argument name")))
-
-(define (arg-name v)
-  (cond ((and (symbol? v) (not (eq? v 'true)) (not (eq? v 'false)))
-         v)
-        ((not (pair? v))
-         (bad-formal-argument v))
-        (else
-         (case (car v)
-           ((... kw)      (decl-var (cadr v)))
-           ((|::|)
-            (if (not (symbol? (cadr v)))
-                (bad-formal-argument (cadr v)))
-            (decl-var v))
-           (else (bad-formal-argument v))))))
-
-; convert a lambda list into a list of just symbols
-(define (llist-vars lst)
-  (map arg-name (filter (lambda (a)
-                          (not (and (pair? a)
-                                    (eq? (car a) 'parameters))))
-                        lst)))
-
-(define (llist-keywords lst)
-  (apply append
-         (map (lambda (a)
-                (if (and (pair? a) (eq? (car a) 'parameters))
-                    (map arg-name (cdr a))
-                    '()))
-              lst)))
-
-(define (arg-type v)
-  (cond ((symbol? v)  'Any)
-        ((not (pair? v))
-         (bad-formal-argument v))
-        (else
-         (case (car v)
-           ((...) (if (eq? (length v) 3)
-                      `(... ,(decl-type (cadr v)) ,(caddr v))
-                      `(... ,(decl-type (cadr v)))))
-           ((|::|)
-            (if (not (symbol? (cadr v)))
-                (bad-formal-argument (cadr v)))
-            (decl-type v))
-           (else (bad-formal-argument v))))))
-
-; get just argument types
-(define (llist-types lst)
-  (map arg-type lst))
-
-(define (decl? e)
-  (and (pair? e) (eq? (car e) '|::|)))
-
-(define (jlgensym? e)
-  (and (pair? e) (eq? (car e) 'jlgensym)))
-
-(define (symbol-like? e)
-  (or (symbol? e) (jlgensym? e)))
-
-; get the variable name part of a declaration, x::int => x
-(define (decl-var v)
-  (if (decl? v) (cadr v) v))
-
-(define (decl-type v)
-  (if (decl? v) (caddr v) 'Any))
-
-(define (sym-dot? e)
-  (and (length= e 3) (eq? (car e) '|.|)
-       (symbol-like? (cadr e))))
-
+;; identify some expressions that are safe to repeat
 (define (effect-free? e)
   (or (not (pair? e)) (jlgensym? e) (sym-dot? e) (quoted? e) (equal? e '(null))))
 
-(define (undot-name e)
-  (if (symbol? e)
-      e
-      (cadr (caddr e))))
-
-(define make-jlgensym
-  (let ((jlgensym-counter 0))
-    (lambda ()
-      (begin0 `(jlgensym ,jlgensym-counter)
-              (set! jlgensym-counter (+ 1 jlgensym-counter))))))
-
-; make an expression safe for multiple evaluation
-; for example a[f(x)] => (temp=f(x); a[temp])
-; retuns a pair (expr . assignments)
-; where 'assignments' is a list of needed assignment statements
-(define (remove-argument-side-effects e)
-  (let ((a '()))
-    (cond
-     ((and (decl? e) (symbol? (cadr e)))
-      (cons (cadr e) (list e)))
-     ((not (pair? e))
-      (cons e '()))
-     (else
-      (cons (map (lambda (x)
-                   (cond
-                    ((and (decl? x) (symbol? (cadr x)))
-                     (set! a (cons x a))
-                     (cadr x))
-                    ((not (effect-free? x))
-                     (let ((g (make-jlgensym)))
-                       (if (or (eq? (car x) '...) (eq? (car x) '&))
-                           (if (and (pair? (cadr x))
-                                    (not (quoted? (cadr x))))
-                               (begin (set! a (cons `(= ,g ,(cadr x)) a))
-                                      `(,(car x) ,g))
-                               x)
-                           (begin (set! a (cons `(= ,g ,x) a))
-                                  g))))
-                    (else
-                     x)))
-                 e)
-            (reverse a))))))
-
-(define (expand-update-operator- op lhs rhs declT)
-  (let ((e (remove-argument-side-effects lhs)))
-    `(block ,@(cdr e)
-            ,(if (null? declT)
-                 `(= ,(car e) (call ,op ,(car e) ,rhs))
-                 `(= ,(car e) (call ,op (:: ,(car e) ,(car declT)) ,rhs))))))
-
-(define (expand-update-operator op lhs rhs . declT)
-  (cond ((and (pair? lhs) (eq? (car lhs) 'ref))
-         ;; expand indexing inside op= first, to remove "end" and ":"
-         (let* ((ex (partially-expand-ref lhs))
-                (stmts (butlast (cdr ex)))
-                (refex (last    (cdr ex)))
-                (nuref `(ref ,(caddr refex) ,@(cdddr refex))))
-           `(block ,@stmts
-                   ,(expand-update-operator- op nuref rhs declT))))
-        ((and (pair? lhs) (eq? (car lhs) '|::|))
-         ;; (+= (:: x T) rhs)
-         (let ((e (remove-argument-side-effects (cadr lhs)))
-               (T (caddr lhs)))
-           `(block ,@(cdr e)
-                   ,(expand-update-operator op (car e) rhs T))))
-        (else
-         (expand-update-operator- op lhs rhs declT))))
-
-(define (dotop? o) (and (symbol? o) (eqv? (string.char (string o) 0) #\.)))
-
-(define (partially-expand-ref e)
-  (let ((a    (cadr e))
-        (idxs (cddr e)))
-    (let* ((reuse (and (pair? a)
-                       (contains (lambda (x)
-                                   (or (eq? x 'end)
-                                       (eq? x ':)
-                                       (and (pair? x)
-                                            (eq? (car x) ':))))
-                                 idxs)))
-           (arr   (if reuse (make-jlgensym) a))
-           (stmts (if reuse `((= ,arr ,a)) '())))
-      (receive
-       (new-idxs stuff) (process-indexes arr idxs)
-       `(block
-         ,@(append stmts stuff)
-         (call getindex ,arr ,@new-idxs))))))
+;; expanding comparison chains: (comparison a op b op c ...)
 
 ;; accumulate a series of comparisons, with the given "and" constructor,
 ;; exit criteria, and "take" function that consumes part of a list,
@@ -266,8 +43,8 @@
   (if (eq? arg arg2) expr
       `(block (= ,arg2 ,arg) ,expr)))
 
-;; generate a comparison from e.g. (a < b ...)
-;; returning (expr . rest)
+;; generate first comparison call, converting e.g. (a < b < c)
+;; to ((call < a b) b < c)
 (define (compare-one e)
   (let* ((arg   (caddr e))
          (arg2  (if (and (pair? arg)
@@ -332,7 +109,7 @@
             `(call (top trailingsize) ,a ,dimno)
             `(call (top size) ,a ,dimno)))))
 
-; replace `end` for the closest ref expression, so doesn't go inside nested refs
+;; replace `end` for the closest ref expression, so doesn't go inside nested refs
 (define (replace-end ex a n tuples last)
   (cond ((eq? ex 'end)                (end-val a n tuples last))
         ((or (atom? ex) (quoted? ex)) ex)
@@ -376,17 +153,6 @@
                     stmts tuples
                     (cons (replace-end idx a n tuples last) ret)))))))
 
-(define (make-decl n t) `(|::| ,n ,t))
-
-(define (function-expr argl body)
-  (let ((t (llist-types argl))
-        (n (llist-vars argl)))
-    (if (has-dups n)
-        (error "function argument names not unique"))
-    (let ((argl (map make-decl n t)))
-      `(lambda ,argl
-         (scope-block ,body)))))
-
 ;; GF method does not need to keep decl expressions on lambda args
 ;; except for rest arg
 (define (method-lambda-expr argl body)
@@ -397,26 +163,29 @@
                              (if (pair? (caddr x))
                                  x
                                  `(|::| ,(arg-name x) (curly Vararg Any)))
-                         (arg-name x))))
+                             (arg-name x))))
                    argl)))
-    `(lambda ,argl
-       (scope-block ,body))))
+    `(lambda ,argl ()
+             (scope-block ,body))))
 
+;; convert list of names (sl) and list of upper bounds to expressions that
+;; construct TypeVars
 (define (symbols->typevars sl upperbounds bnd)
   (let ((bnd (if bnd '(true) '())))
     (if (null? upperbounds)
         (map (lambda (x)    `(call (top TypeVar) ',x ,@bnd)) sl)
         (map (lambda (x ub) `(call (top TypeVar) ',x ,ub ,@bnd)) sl upperbounds))))
 
+;; extract type variable name from A<:B expressions
 (define (sparam-name sp)
-  (cond ((symbol? sp)
-         sp)
+  (cond ((symbol? sp) sp)
         ((and (length= sp 3)
               (eq? (car sp) '|<:|)
               (symbol? (cadr sp)))
          (cadr sp))
         (else (error "malformed type parameter list"))))
 
+;; return (values names bounds) for a series of type var expressions (A<:B)
 (define (sparam-name-bounds sparams names bounds)
   (cond ((null? sparams)
          (values (reverse names) (reverse bounds)))
@@ -431,17 +200,21 @@
         (else
          (error "malformed type parameter list"))))
 
-(define (method-expr-name m)
-  (let ((lhs (cadr m)))
-    (cond ((symbol? lhs)       lhs)
-          ((eq? (car lhs) 'kw) (cadr lhs))
-          (else                lhs))))
+(define (method-expr-name m) (cadr m))
 
+;; extract static parameter names from a (method ...) expression
 (define (method-expr-static-parameters m)
-  (if (eq? (car (cadr (caddr m))) 'lambda)
-      (cadr (cadr (caddr m)))
+  (if (eq? (car (caddr m)) 'block)
+      (let ((lst '()))
+        (pattern-replace
+         (pattern-set
+          (pattern-lambda (= v (call (top (-/ TypeVar)) (quote T) y z))
+                          (begin (set! lst (cons T lst)) __)))
+         (butlast (cdr (caddr m))))
+        (reverse! lst))
       '()))
 
+;; expressions of the form a.b.c... where everything is a symbol
 (define (sym-ref? e)
   (or (symbol? e)
       (and (length= e 3) (eq? (car e) '|.|)
@@ -453,52 +226,82 @@
 (define (dots->vararg a)
   (if (null? a) a
       (let ((head (butlast a))
-	    (las  (last a)))
-	(if (vararg? las)
-	    `(,@head (curly Vararg ,(cadr las)))
-	    `(,@head ,las)))))
+            (las  (last a)))
+        (if (vararg? las)
+            `(,@head (curly Vararg ,(cadr las)))
+            `(,@head ,las)))))
+
+(define (hidden-name? s)
+  (and (symbol? s)
+       (eqv? (string.char (string s) 0) #\#)))
+
+(define (is-call-name? name)
+  (or (eq? name 'call) (and (pair? name) (sym-ref? name)
+                            (equal? (caddr name) '(inert call)))))
+
+(define (replace-vars e renames)
+  (cond ((symbol? e)      (lookup e renames e))
+        ((or (not (pair? e)) (quoted? e))  e)
+        ((memq (car e) '(-> function scope-block)) e)
+        (else
+         (cons (car e)
+               (map (lambda (x) (replace-vars x renames))
+                    (cdr e))))))
 
+;; construct the (method ...) expression for one primitive method definition,
+;; assuming optional and keyword args are already handled
 (define (method-def-expr- name sparams argl body isstaged)
   (receive
    (names bounds) (sparam-name-bounds sparams '() '())
    (begin
      (let ((anames (llist-vars argl)))
-       (if (has-dups anames)
+       (if (has-dups (filter (lambda (x) (not (eq? x UNUSED))) anames))
            (error "function argument names not unique"))
        (if (has-dups names)
            (error "function static parameter names not unique"))
-       (if (any (lambda (x) (memq x names)) anames)
+       (if (any (lambda (x) (and (not (eq? x UNUSED)) (memq x names))) anames)
            (error "function argument and static parameter names must be distinct")))
-     (if (not (or (sym-ref? name)
-                  (and (pair? name) (eq? (car name) 'kw)
-                       (sym-ref? (cadr name)))))
+     (if (and name (not (sym-ref? name)))
          (error (string "invalid method name \"" (deparse name) "\"")))
-     (let* ((types (llist-types argl))
-            (body  (method-lambda-expr argl body)))
-       (if (null? sparams)
-           `(method ,name (call (top svec) (curly Tuple ,@(dots->vararg types)) (call (top svec)))
-		    ,body ,isstaged)
-           `(method ,name
-                    (call (lambda ,names
-                            (call (top svec) (curly Tuple ,@(dots->vararg types)) (call (top svec) ,@names)))
-                          ,@(symbols->typevars names bounds #t))
-                    ,body ,isstaged))))))
-
-(define (vararg? x) (and (pair? x) (eq? (car x) '...)))
-(define (varargexpr? x) (and
-                         (pair? x)
-                         (eq? (car x) '::)
-                         (or
-                          (eq? (caddr x) 'Vararg)
-                          (and
-                           (pair? (caddr x))
-                           (length> (caddr x) 1)
-                           (eq? (cadr (caddr x)) 'Vararg)))))
-(define (trans?  x) (and (pair? x) (eq? (car x) '|.'|)))
-(define (ctrans? x) (and (pair? x) (eq? (car x) '|'|)))
-
+     (let* ((iscall (is-call-name? name))
+            (name  (if iscall #f name))
+            (types (llist-types argl))
+            (body  (method-lambda-expr argl body))
+            ;; HACK: the typevars need to be bound to jlgensyms, since this code
+            ;; might be moved to a different scope by closure-convert.
+            (temps (map (lambda (x) (make-jlgensym)) names))
+            (renames (map cons names temps))
+            (mdef
+             (if (null? sparams)
+                 `(method ,name (call (top svec) (curly Tuple ,@(dots->vararg types)) (call (top svec)))
+                          ,body ,isstaged)
+                 `(method ,name
+                          (block
+                           ,@(map make-assignment temps (symbols->typevars names bounds #t))
+                           (call (top svec) (curly Tuple
+                                                   ,@(dots->vararg
+                                                      (map (lambda (ty)
+                                                             (replace-vars ty renames))
+                                                           types)))
+                                 (call (top svec) ,@temps)))
+                          ,body ,isstaged))))
+       (if (and iscall (not (null? argl)))
+           (let* ((n (arg-name (car argl)))
+                  (n (if (hidden-name? n) "" n))
+                  (t (deparse (arg-type (car argl)))))
+             (syntax-deprecation #f
+                                 (string "call(" n "::" t ", ...)")
+                                 (string "(" n "::" t ")(...)"))))
+       (if (symbol? name)
+           `(block (method ,name) ,mdef ,name)  ;; return the function
+           mdef)))))
+
+;; keyword default values that can be assigned right away. however, this creates
+;; a quasi-bug (part of issue #9535) where it can be hard to predict when a
+;; keyword argument will throw an UndefVarError.
 (define (const-default? x)
-  (or (number? x) (string? x) (char? x) (and (pair? x) (memq (car x) '(quote inert)))))
+  (or (number? x) (string? x) (char? x) (and (pair? x) (memq (car x) '(quote inert)))
+      (eq? x 'true) (eq? x 'false)))
 
 (define (keywords-method-def-expr name sparams argl body isstaged)
   (let* ((kargl (cdar argl))  ;; keyword expressions (= k v)
@@ -506,6 +309,7 @@
          (body  (if (and (pair? body) (eq? (car body) 'block))
                     body
                     `(block ,body)))
+         (ftype (decl-type (car pargl)))
          ;; 1-element list of vararg argument, or empty if none
          (vararg (let ((l (if (null? pargl) '() (last pargl))))
                    (if (vararg? l)
@@ -550,22 +354,10 @@
          (keyword-sparam-names
           (map (lambda (s) (if (symbol? s) s (cadr s))) keyword-sparams)))
     (let ((kw (gensy)) (i (gensy)) (ii (gensy)) (elt (gensy)) (rkw (gensy))
-          (mangled (symbol (string "__"
-                                   (undot-name name)
-                                   "#"
-                                   (string.sub (string (gensym)) 1)
-                                   "__")))
+          (mangled (symbol (string "#" (if name (undot-name name) 'call) "#"
+                                   (string (current-julia-module-counter)))))
           (flags (map (lambda (x) (gensy)) vals)))
       `(block
-        ;; call with keyword args pre-sorted - original method code goes here
-        ,(method-def-expr-
-          mangled sparams
-          `(,@vars ,@restkw ,@pargl ,@vararg)
-          `(block
-            ,@(if (null? lno) '()
-                  (list (append (car lno) (list (undot-name name)))))
-            ,@stmts) isstaged)
-
         ;; call with no keyword args
         ,(method-def-expr-
           name positional-sparams (append pargl vararg)
@@ -585,16 +377,34 @@
                                 (list `(... ,(arg-name (car vararg))))))))
           #f)
 
+        ;; call with keyword args pre-sorted - original method code goes here
+        ,(method-def-expr-
+          mangled sparams
+          `((|::| ,mangled (call (top typeof) ,mangled)) ,@vars ,@restkw
+            ;; strip type off function self argument if not needed for a static param.
+            ;; then it is ok for cl-convert to move this definition above the original def.
+            ,(if (decl? (car pargl))
+                 (if (any (lambda (sp)
+                            (expr-contains-eq (sparam-name sp) (caddr (car pargl))))
+                          positional-sparams)
+                     (car pargl)
+                     (decl-var (car pargl)))
+                 (car pargl))
+            ,@(cdr pargl) ,@vararg)
+          `(block
+            ,@(if (null? lno) '()
+                  ;; TODO jb/functions get a better `name` for functions specified by type
+                  (list (append (car lno) (list (undot-name name)))))
+            ,@stmts) isstaged)
+
         ;; call with unsorted keyword args. this sorts and re-dispatches.
         ,(method-def-expr-
-          (list 'kw name) (filter
-                           ;; remove sparams that don't occur, to avoid printing
-                           ;; the warning twice
-                           (lambda (s)
-                             (let ((name (if (symbol? s) s (cadr s))))
-                               (expr-contains-eq name (cons 'list argl))))
-                           positional-sparams)
-          `((:: ,kw (top Array)) ,@pargl ,@vararg)
+          name
+          (filter ;; remove sparams that don't occur, to avoid printing the warning twice
+           (lambda (s) (let ((name (if (symbol? s) s (cadr s))))
+                         (expr-contains-eq name (cons 'list argl))))
+           positional-sparams)
+          `((|::| ,UNUSED (call (|.| Core 'kwftype) ,ftype)) (:: ,kw (top Array)) ,@pargl ,@vararg)
           `(block
             (line 0 || ||)
             ;; initialize keyword args to their defaults, or set a flag telling
@@ -663,105 +473,111 @@
                                 (list `(... ,(arg-name (car vararg))))))))
           #f)
         ;; return primary function
-        ,name))))
-
-(define (take-while f xs)
-  (cond ((null? xs) '())
-        ((f (car xs)) (cons (car xs) (take-while f (cdr xs))))
-        (else '())))
+        ,(if (or (not (symbol? name)) (is-call-name? name))
+             '(null) name)))))
 
 (define (optional-positional-defs name sparams req opt dfl body isstaged overall-argl . kw)
   ;; prologue includes line number node and eventual meta nodes
   (let ((prologue (if (pair? body)
-                       (take-while (lambda (e)
-                                     (and (pair? e) (or (eq? (car e) 'line) (eq? (car e) 'meta))))
-                                   (cdr body))
-                       '())))
-  `(block
-    ,@(map (lambda (n)
-             (let* ((passed (append req (list-head opt n)))
-                    ;; only keep static parameters used by these arguments
-                    (sp     (filter (lambda (sp)
-                                      (contains (lambda (e) (eq? e (sparam-name sp)))
-                                                passed))
-                                    sparams))
-                    (vals   (list-tail dfl n))
-                    (absent (list-tail opt n)) ;; absent arguments
-                    (body
-                     (if (any (lambda (defaultv)
-                                ;; does any default val expression...
-                                (contains (lambda (e)
-                                            ;; contain "e" such that...
-                                            (any (lambda (a)
-                                                   ;; "e" is in an absent arg
-                                                   (contains (lambda (u)
-                                                               (eq? u e))
-                                                             a))
-                                                 absent))
-                                          defaultv))
-                              vals)
-                         ;; then add only one next argument
-                         `(block
-                           ,@prologue
-                           (call ,name ,@kw ,@(map arg-name passed) ,(car vals)))
-                         ;; otherwise add all
-                         `(block
-                           ,@prologue
-                           (call ,name ,@kw ,@(map arg-name passed) ,@vals)))))
-               (method-def-expr name sp (append kw passed) body #f)))
-           (iota (length opt)))
-    ,(method-def-expr name sparams overall-argl body isstaged))))
+                      (take-while (lambda (e)
+                                    (and (pair? e) (or (eq? (car e) 'line) (eq? (car e) 'meta))))
+                                  (cdr body))
+                      '())))
+    `(block
+      ,@(map (lambda (n)
+               (let* ((passed (append req (list-head opt n)))
+                      ;; only keep static parameters used by these arguments
+                      (sp     (filter (lambda (sp)
+                                        (contains (lambda (e) (eq? e (sparam-name sp)))
+                                                  passed))
+                                      sparams))
+                      (vals   (list-tail dfl n))
+                      (absent (list-tail opt n)) ;; absent arguments
+                      (body
+                       (if (any (lambda (defaultv)
+                                  ;; does any default val expression...
+                                  (contains (lambda (e)
+                                              ;; contain "e" such that...
+                                              (any (lambda (a)
+                                                     ;; "e" is in an absent arg
+                                                     (contains (lambda (u)
+                                                                 (eq? u e))
+                                                               a))
+                                                   absent))
+                                            defaultv))
+                                vals)
+                           ;; then add only one next argument
+                           `(block
+                             ,@prologue
+                             (call ,(arg-name (car req)) ,@kw ,@(map arg-name (cdr passed)) ,(car vals)))
+                           ;; otherwise add all
+                           `(block
+                             ,@prologue
+                             (call ,(arg-name (car req)) ,@kw ,@(map arg-name (cdr passed)) ,@vals)))))
+                 (method-def-expr name sp (append kw passed) body #f)))
+             (iota (length opt)))
+      ,(method-def-expr name sparams overall-argl body isstaged))))
+
+;; strip empty (parameters ...), normalizing `f(x;)` to `f(x)`.
+(define (remove-empty-parameters argl)
+  (if (and (has-parameters? argl) (null? (cdar argl)))
+      (cdr argl)
+      argl))
+
+(define (check-kw-args kw)
+  (let ((invalid (filter (lambda (x) (not (or (kwarg? x)
+                                              (vararg? x))))
+                         kw)))
+    (if (pair? invalid)
+        (if (and (pair? (car invalid)) (eq? 'parameters (caar invalid)))
+            (error "more than one semicolon in argument list")
+            (cond ((symbol? (car invalid))
+                   (error (string "keyword argument \"" (car invalid) "\" needs a default value")))
+                  (else
+                   (error (string "invalid keyword argument syntax \""
+                                  (deparse (car invalid))
+                                  "\" (expected assignment)"))))))))
 
 (define (method-def-expr name sparams argl body isstaged)
-  (if (any kwarg? argl)
-      ;; has optional positional args
-      (begin
-        (let check ((l     argl)
-                    (seen? #f))
-          (if (pair? l)
-              (if (kwarg? (car l))
-                  (check (cdr l) #t)
-                  (if (and seen? (not (vararg? (car l))))
-                      (error "optional positional arguments must occur at end")
-                      (check (cdr l) #f)))))
-        (receive
-         (kws argl) (separate kwarg? argl)
-         (let ((opt  (map cadr  kws))
-               (dfl  (map caddr kws)))
-           (if (has-parameters? argl)
-               ;; both!
-               ;; separate into keyword version with all positional args,
-               ;; and a series of optional-positional-defs that delegate keywords
-               (let ((kw   (car argl))
-                     (argl (cdr argl)))
-                 (check-kw-args (cdr kw))
+  (let ((argl (remove-empty-parameters argl)))
+    (if (any kwarg? argl)
+        ;; has optional positional args
+        (begin
+          (let check ((l     argl)
+                      (seen? #f))
+            (if (pair? l)
+                (if (kwarg? (car l))
+                    (check (cdr l) #t)
+                    (if (and seen? (not (vararg? (car l))))
+                        (error "optional positional arguments must occur at end")
+                        (check (cdr l) #f)))))
+          (receive
+           (kws argl) (separate kwarg? argl)
+           (let ((opt  (map cadr  kws))
+                 (dfl  (map caddr kws)))
+             (if (has-parameters? argl)
+                 ;; both!
+                 ;; separate into keyword version with all positional args,
+                 ;; and a series of optional-positional-defs that delegate keywords
+                 (let ((kw   (car argl))
+                       (argl (cdr argl)))
+                   (check-kw-args (cdr kw))
+                   (receive
+                    (vararg req) (separate vararg? argl)
+                    (optional-positional-defs name sparams req opt dfl body isstaged
+                                              (cons kw (append req opt vararg))
+                                              `(parameters (... ,(gensy))))))
+                 ;; optional positional only
                  (receive
                   (vararg req) (separate vararg? argl)
                   (optional-positional-defs name sparams req opt dfl body isstaged
-                                            (cons kw (append req opt vararg))
-                                            `(parameters (... ,(gensy))))))
-               ;; optional positional only
-               (receive
-                (vararg req) (separate vararg? argl)
-                (optional-positional-defs name sparams req opt dfl body isstaged
-                                          (append req opt vararg)))))))
-      (if (has-parameters? argl)
-          ;; keywords only
-          (begin (check-kw-args (cdar argl))
-                 (keywords-method-def-expr name sparams argl body isstaged))
-          ;; neither
-          (method-def-expr- name sparams argl body isstaged))))
-
-;; remove nested blocks
-(define (flatten-blocks e)
-  (if (atom? e)
-      e
-      (apply append!
-             (map (lambda (x)
-                    (cond ((atom? x) (list x))
-                          ((eq? (car x) 'block) (cdr (flatten-blocks x)))
-                          (else (list x))))
-                  e))))
+                                            (append req opt vararg)))))))
+        (if (has-parameters? argl)
+            ;; keywords only
+            (begin (check-kw-args (cdar argl))
+                   (keywords-method-def-expr name sparams argl body isstaged))
+            ;; neither
+            (method-def-expr- name sparams argl body isstaged)))))
 
 (define (struct-def-expr name params super fields mut)
   (receive
@@ -781,7 +597,7 @@
           ;; definition with Any for all arguments
           `(function (call ,name ,@field-names)
                      (block
-		      ,@locs
+                      ,@locs
                       (call new ,@field-names)))))
     (if (and gen-specific? (any (lambda (t) (not (eq? t 'Any))) field-types))
         (list
@@ -789,7 +605,7 @@
          `(function (call ,name
                           ,@(map make-decl field-names field-types))
                     (block
-		     ,@locs
+                     ,@locs
                      (call new ,@field-names)))
          any-ctor)
         (list any-ctor))))
@@ -801,7 +617,7 @@
                                    params bounds))
                      ,@(map make-decl field-names field-types))
                (block
-		,@locs
+                ,@locs
                 (call (curly ,name ,@params) ,@field-names)))))
 
 (define (new-call Tname type-params params args field-names field-types mutabl)
@@ -822,13 +638,14 @@
                `(new ,Texpr ,@(map (lambda (fty val)
                                      `(call (top convert) ,fty ,val))
                                    (list-head field-types (length args)) args))
-               (let ((tn (gensy)))
-                 `(let (new ,tn ,@(map (lambda (fld val)
-                                         `(call (top convert)
-                                                (call (top fieldtype) ,tn (quote ,fld))
-                                                ,val))
-                                       (list-head field-names (length args)) args))
-                    (= ,tn ,Texpr))))))))
+               (let ((tn (make-jlgensym)))
+                 `(block
+                   (= ,tn ,Texpr)
+                   (new ,tn ,@(map (lambda (fld val)
+                                     `(call (top convert)
+                                            (call (top fieldtype) ,tn (quote ,fld))
+                                            ,val))
+                                   (list-head field-names (length args)) args)))))))))
 
 ;; insert a statement after line number node
 (define (prepend-stmt stmt body)
@@ -850,23 +667,24 @@
 (define (ctor-signature name params bounds method-params sig)
   (if (null? params)
       (if (null? method-params)
-          (cons `(call call ,@(arglist-unshift sig `(|::| ,(gensy) (curly Type ,name))))
+          (cons `(call (|::| (curly Type ,name)) ,@sig)
                 params)
-          (cons `(call (curly call ,@method-params)
-                       ,@(arglist-unshift sig `(|::| ,(gensy) (curly Type ,name))))
+          (cons `(call (curly (|::| (curly Type ,name)) ,@method-params) ,@sig)
                 params))
       (if (null? method-params)
-          (cons `(call (curly call ,@(map (lambda (p b) `(<: ,p ,b)) params bounds))
-                       ,@(arglist-unshift sig `(|::| ,(gensy) (curly Type (curly ,name ,@params)))))
+          (cons `(call (curly (|::| (curly Type (curly ,name ,@params)))
+                              ,@(map (lambda (p b) `(<: ,p ,b)) params bounds))
+                       ,@sig)
                 params)
           ;; rename parameters that conflict with user-written method parameters
           (let ((new-params (map (lambda (p) (if (memq p method-params)
                                                  (gensy)
                                                  p))
                                  params)))
-            (cons `(call (curly call ,@(map (lambda (p b) `(<: ,p ,b)) new-params bounds)
+            (cons `(call (curly (|::| (curly Type (curly ,name ,@new-params)))
+                                ,@(map (lambda (p b) `(<: ,p ,b)) new-params bounds)
                                 ,@method-params)
-                         ,@(arglist-unshift sig `(|::| ,(gensy) (curly Type (curly ,name ,@new-params)))))
+                         ,@sig)
                   new-params)))))
 
 (define (ctor-def keyword name Tname params bounds method-params sig ctor-body body)
@@ -880,17 +698,21 @@
                  ;; new{...} inside a non-ctor inner definition.
                  ,(ctor-body body '()))))
 
+;; rewrite calls to `new( ... )` to `new` expressions on the appropriate
+;; type, determined by the containing constructor definition.
 (define (rewrite-ctor ctor Tname params bounds field-names field-types mutabl)
   (define (ctor-body body type-params)
     (pattern-replace (pattern-set
                       (pattern-lambda
                        (call (-/ new) . args)
                        (new-call Tname type-params params
-                                 args field-names field-types mutabl))
+                                 (map (lambda (a) (ctor-body a type-params)) args)
+                                 field-names field-types mutabl))
                       (pattern-lambda
                        (call (curly (-/ new) . p) . args)
                        (new-call Tname p params
-                                 args field-names field-types mutabl)))
+                                 (map (lambda (a) (ctor-body a type-params)) args)
+                                 field-names field-types mutabl)))
                      body))
   (pattern-replace
    (pattern-set
@@ -911,24 +733,24 @@
 ;; check if there are any calls to new with fewer than n arguments
 (define (ctors-min-initialized expr)
   (and (pair? expr)
-   (min
-    ((pattern-lambda
-      (call (-/ new) . args)
-      (length args)) (car expr))
-    ((pattern-lambda
-      (call (curly (-/ new) . p) . args)
-      (length args)) (car expr))
-    (ctors-min-initialized (car expr))
-    (ctors-min-initialized (cdr expr)))))
+       (min
+        ((pattern-lambda
+          (call (-/ new) . args)
+          (length args)) (car expr))
+        ((pattern-lambda
+          (call (curly (-/ new) . p) . args)
+          (length args)) (car expr))
+        (ctors-min-initialized (car expr))
+        (ctors-min-initialized (cdr expr)))))
 
 (define (struct-def-expr- name params bounds super fields0 mut)
   (receive
    (fields defs) (separate (lambda (x) (or (symbol? x) (decl? x)))
                            fields0)
    (let* ((defs        (filter (lambda (x) (not (effect-free? x))) defs))
-	  (locs        (if (and (pair? fields0) (pair? (car fields0)) (eq? (caar fields0) 'line))
-			   (list (car fields0))
-			   '()))
+          (locs        (if (and (pair? fields0) (pair? (car fields0)) (eq? (caar fields0) 'line))
+                           (list (car fields0))
+                           '()))
           (field-names (map decl-var fields))
           (field-types (map decl-type fields))
           (defs2 (if (null? defs)
@@ -936,65 +758,47 @@
                      defs))
           (min-initialized (min (ctors-min-initialized defs) (length fields))))
      (let ((dups (has-dups field-names)))
-        (if dups (error (string "duplicate field name: \"" (car dups) "\" is not unique"))))
+       (if dups (error (string "duplicate field name: \"" (car dups) "\" is not unique"))))
      (for-each (lambda (v)
                  (if (not (symbol? v))
                      (error (string "field name \"" (deparse v) "\" is not a symbol"))))
                field-names)
-     (if (null? params)
-         `(block
-           (global ,name) (const ,name)
-           (composite_type ,name (call (top svec) ,@params)
-                           (call (top svec) ,@(map (lambda (x) `',x) field-names))
-                           ,super (call (top svec) ,@field-types) ,mut ,min-initialized)
-           (call
-            (lambda ()
-              (scope-block
-               (block
-                (global ,name) (global call)
-                ,@(map (lambda (c)
-                         (rewrite-ctor c name '() '() field-names field-types mut))
-                       defs2)))))
-           (null))
-         ;; parametric case
-         `(block
-           (scope-block
-            (block
-             (global ,name) (const ,name)
-             ,@(map (lambda (v) `(local ,v)) params)
-             ,@(map make-assignment params (symbols->typevars params bounds #t))
-             (composite_type ,name (call (top svec) ,@params)
-                             (call (top svec) ,@(map (lambda (x) `',x) field-names))
-                             ,super (call (top svec) ,@field-types) ,mut ,min-initialized)))
-           ;; "inner" constructors
-           (call
-            (lambda ()
-              (scope-block
-               (block
-                (global ,name) (global call)
-                ,@(map (lambda (c)
-                         (rewrite-ctor c name params bounds field-names field-types mut))
-                       defs2)))))
-           ;; "outer" constructors
-           ,@(if (and (null? defs)
-                      ;; don't generate an outer constructor if the type has
-                      ;; parameters not mentioned in the field types. such a
-                      ;; constructor would not be callable anyway.
-                      (every (lambda (sp)
-                               (expr-contains-eq sp (cons 'list field-types)))
-                             params))
-                 `((scope-block
-                    (block
-                     (global ,name)
-                     ,(default-outer-ctor name field-names field-types
-                        params bounds locs))))
-                 '())
-           (null))))))
+     `(block
+       (scope-block
+        (block
+         (global ,name) (const ,name)
+         ,@(map (lambda (v) `(local ,v)) params)
+         ,@(map make-assignment params (symbols->typevars params bounds #t))
+         (composite_type ,name (call (top svec) ,@params)
+                         (call (top svec) ,@(map (lambda (x) `',x) field-names))
+                         ,super (call (top svec) ,@field-types) ,mut ,min-initialized)))
+       ;; "inner" constructors
+       (scope-block
+        (block
+         (global ,name)
+         ,@(map (lambda (c)
+                  (rewrite-ctor c name params bounds field-names field-types mut))
+                defs2)))
+       ;; "outer" constructors
+       ,@(if (and (null? defs)
+                  (not (null? params))
+                  ;; don't generate an outer constructor if the type has
+                  ;; parameters not mentioned in the field types. such a
+                  ;; constructor would not be callable anyway.
+                  (every (lambda (sp)
+                           (expr-contains-eq sp (cons 'list field-types)))
+                         params))
+             `((scope-block
+                (block
+                 (global ,name)
+                 ,(default-outer-ctor name field-names field-types
+                    params bounds locs))))
+             '())
+       (null)))))
 
 (define (abstract-type-def-expr name params super)
   (receive
-   (params bounds)
-   (sparam-name-bounds params '() '())
+   (params bounds) (sparam-name-bounds params '() '())
    `(block
      (const ,name)
      (scope-block
@@ -1005,8 +809,7 @@
 
 (define (bits-def-expr n name params super)
   (receive
-   (params bounds)
-   (sparam-name-bounds params '() '())
+   (params bounds) (sparam-name-bounds params '() '())
    `(block
      (const ,name)
      (scope-block
@@ -1015,7 +818,7 @@
        ,@(map make-assignment params (symbols->typevars params bounds #f))
        (bits_type ,name (call (top svec) ,@params) ,n ,super))))))
 
-; take apart a type signature, e.g. T{X} <: S{Y}
+;; take apart a type signature, e.g. T{X} <: S{Y}
 (define (analyze-type-sig ex)
   (or ((pattern-lambda (-- name (-s))
                        (values name '() 'Any)) ex)
@@ -1038,20 +841,210 @@
         `(block
           ,.(reverse! stmts)
           (call (top ccall) ,name ,RT (call (top svec) ,@(dots->vararg atypes))
-		,.(reverse! C)
+                ,.(reverse! C)
                 ,@A))
         (let* ((a     (car A))
                (isseq (and (pair? (car F)) (eq? (caar F) '...)))
                (ty    (if isseq (cadar F) (car F))))
           (if (eq? ty 'Any)
-            (loop (if isseq F (cdr F)) (cdr A) stmts (list* 0 a C))
-            (let* ((g (make-jlgensym))
-                   (isamp (and (pair? a) (eq? (car a) '&)))
-                   (a (if isamp (cadr a) a))
-                   (stmts (cons `(= ,g (call (top ,(if isamp 'ptr_arg_cconvert 'cconvert)) ,ty ,a)) stmts))
-                   (ca `(call (top ,(if isamp 'ptr_arg_unsafe_convert 'unsafe_convert)) ,ty ,g)))
-              (loop (if isseq F (cdr F)) (cdr A) stmts
-                    (list* g (if isamp `(& ,ca) ca) C))))))))
+              (loop (if isseq F (cdr F)) (cdr A) stmts (list* 0 a C))
+              (let* ((g (make-jlgensym))
+                     (isamp (and (pair? a) (eq? (car a) '&)))
+                     (a (if isamp (cadr a) a))
+                     (stmts (cons `(= ,g (call (top ,(if isamp 'ptr_arg_cconvert 'cconvert)) ,ty ,a)) stmts))
+                     (ca `(call (top ,(if isamp 'ptr_arg_unsafe_convert 'unsafe_convert)) ,ty ,g)))
+                (loop (if isseq F (cdr F)) (cdr A) stmts
+                      (list* g (if isamp `(& ,ca) ca) C))))))))
+
+(define (expand-function-def e)   ;; handle function or stagedfunction
+  (let ((name (cadr e)))
+    (cond ((and (length= e 2) (symbol? name))  `(method ,name))
+          ((not (pair? name))                  e)
+          ((eq? (car name) 'tuple)
+           (expand-forms `(-> ,name ,(caddr e))))
+          ((eq? (car name) 'call)
+           (let* ((head    (cadr name))
+                  (argl    (cddr name))
+                  (has-sp  (and (pair? head) (eq? (car head) 'curly)))
+                  (name    (if has-sp (cadr head) head))
+                  (sparams (if has-sp (cddr head) '()))
+                  (isstaged (eq? (car e) 'stagedfunction))
+                  (adj-decl (lambda (n) (if (and (decl? n) (length= n 2))
+                                            `(|::| |#self#| ,(cadr n))
+                                            n)))
+                  ;; fill in first (closure) argument
+                  (farg    (if (decl? name)
+                               (adj-decl name)
+                               `(|::| |#self#| (call (|.| Core 'Typeof) ,name))))
+                  (argl    (fix-arglist
+                            (if (and (not (decl? name)) (eq? (undot-name name) 'call))
+                                (cons (adj-decl (car argl)) (cdr argl))
+                                (arglist-unshift argl farg))
+                            (and (not (any kwarg? argl)) (not (and (pair? argl)
+                                                                   (pair? (car argl))
+                                                                   (eq? (caar argl) 'parameters))))))
+                  (name    (if (decl? name) #f name)))
+             (expand-forms
+              (method-def-expr name sparams argl (caddr e) isstaged))))
+          (else e))))
+
+;; handle ( )->( ) function expressions. blocks `(a;b=1)` on the left need to be
+;; converted to argument lists with kwargs.
+(define (expand-arrow e)
+  (let ((a    (cadr e))
+        (body (caddr e)))
+    (let ((argl (if (pair? a)
+                    (if (eq? (car a) 'tuple)
+                        (map =-to-kw (cdr a))
+                        (if (eq? (car a) 'block)
+                            (cond ((length= a 1) '())
+                                  ((length= a 2) (list (cadr a)))
+                                  ((length= a 3)
+                                   (if (assignment? (caddr a))
+                                       `((parameters (kw ,@(cdr (caddr a)))) ,(cadr a))
+                                       `((parameters ,(caddr a)) ,(cadr a))))
+                                  (else
+                                   (error "more than one semicolon in argument list")))
+                            (list (=-to-kw a))))
+                    (list a)))
+          ;; TODO: always use a specific special name like #anon# or _, then ignore
+          ;; this as a local variable name.
+          (name (symbol (string "#" (current-julia-module-counter)))))
+      (expand-forms
+       `(block (local ,name)
+               (function (call ,name ,@argl) ,body))))))
+
+(define (expand-let e)
+  (let ((ex (cadr e))
+        (binds (cddr e)))
+    (expand-forms
+     (if
+      (null? binds)
+      `(scope-block (block ,ex))
+      (let loop ((binds (reverse binds))
+                 (blk   ex))
+        (if (null? binds)
+            blk
+            (cond
+             ((or (symbol? (car binds)) (decl? (car binds)))
+              ;; just symbol -> add local
+              (loop (cdr binds)
+                    `(scope-block
+                      (block
+                       (local ,(car binds))
+                       (newvar ,(decl-var (car binds)))
+                       ,blk))))
+             ((and (length= (car binds) 3)
+                   (eq? (caar binds) '=))
+              ;; some kind of assignment
+              (cond
+               ((or (symbol? (cadar binds))
+                    (decl?   (cadar binds)))
+                (let ((vname (decl-var (cadar binds))))
+                  (loop (cdr binds)
+                        (if (contains (lambda (x) (eq? x vname))
+                                      (caddar binds))
+                            (let ((tmp (make-jlgensym)))
+                              `(scope-block
+                                (block (= ,tmp ,(caddar binds))
+                                       (scope-block
+                                        (block
+                                         (local ,(cadar binds))
+                                         (newvar ,vname)
+                                         (= ,vname ,tmp)
+                                         ,blk)))))
+                            `(scope-block
+                              (block
+                               (local ,(cadar binds))
+                               (newvar ,vname)
+                               (= ,vname ,(caddar binds))
+                               ,blk))))))
+               ((and (pair? (cadar binds))
+                     (eq? (caadar binds) 'call))
+                ;; f()=c
+                (let* ((asgn (butlast (expand-forms (car binds))))
+                       (name (cadr (cadar binds)))
+                       (name (cond ((symbol? name) name)
+                                   ((and (pair? name) (eq? (car name) 'curly))
+                                    (cadr name))
+                                   (else (error "invalid let syntax")))))
+                  (loop (cdr binds)
+                        `(scope-block
+                          (block
+                           (local ,name)
+                           (newvar ,name)
+                           ,asgn
+                           ,blk)))))
+               ;; (a, b, c, ...) = rhs
+               ((and (pair? (cadar binds))
+                     (eq? (caadar binds) 'tuple))
+                (let ((vars (lhs-vars (cadar binds))))
+                  (loop (cdr binds)
+                        `(scope-block
+                          (block
+                           ,@(map (lambda (v) `(local ,v)) vars)
+                           ,@(map (lambda (v) `(newvar ,(decl-var v))) vars)
+                           ,(car binds)
+                           ,blk)))))
+               (else (error "invalid let syntax"))))
+             (else (error "invalid let syntax")))))))))
+
+(define (expand-macro-def e)
+  (cond ((and (pair? (cadr e))
+              (eq? (car (cadr e)) 'call)
+              (symbol? (cadr (cadr e))))
+         (let ((anames (cddr (cadr e))))
+           (expand-forms
+            `(function (call ,(symbol (string #\@ (cadr (cadr e))))
+                             ,@(map (lambda (v)
+                                      (if (symbol? v)
+                                          `(|::| ,v (top ANY))
+                                          v))
+                                    anames))
+                       ,@(cddr e)))))
+        (else
+         (error "invalid macro definition"))))
+
+(define (expand-type-def e)
+  (let ((mut (cadr e))
+        (sig (caddr e))
+        (fields (cdr (cadddr e))))
+    (let loop ((f fields))
+      (if (null? f)
+          '()
+          (let ((x (car f)))
+            (cond ((or (symbol? x) (decl? x) (and (pair? x) (eq? (car x) 'line)))
+                   (loop (cdr f)))
+                  ((and (assignment? x) (or (symbol? (cadr x)) (decl? (cadr x))))
+                   (error (string "\"" (deparse x) "\" inside type definition is reserved")))
+                  (else '())))))
+    (expand-forms
+     (receive (name params super) (analyze-type-sig sig)
+              (struct-def-expr name params super fields mut)))))
+
+;; the following are for expanding `try` blocks
+
+(define (find-symbolic-label-defs e tbl)
+  (if (or (not (pair? e)) (quoted? e))
+      '()
+      (if (eq? (car e) 'symboliclabel)
+          (put! tbl (cadr e) #t)
+          (for-each (lambda (x) (find-symbolic-label-defs x tbl)) e))))
+
+(define (find-symbolic-label-refs e tbl)
+  (if (or (not (pair? e)) (quoted? e))
+      '()
+      (if (eq? (car e) 'symbolicgoto)
+          (put! tbl (cadr e) #t)
+          (for-each (lambda (x) (find-symbolic-label-refs x tbl)) e))))
+
+(define (has-unmatched-symbolic-goto? e)
+  (let ((label-refs (table))
+        (label-defs (table)))
+    (find-symbolic-label-refs e label-refs)
+    (find-symbolic-label-defs e label-defs)
+    (any not (map (lambda (k) (get label-defs k #f))
+                  (table.keys label-refs)))))
 
 (define (block-returns? e)
   (if (assignment? e)
@@ -1063,7 +1056,7 @@
   (cond ((or (atom? e) (quoted? e)) e)
         ((or (eq? (car e) 'lambda)
              (eq? (car e) 'function)
-         (eq? (car e) 'stagedfunction)
+             (eq? (car e) 'stagedfunction)
              (eq? (car e) '->)) e)
         ((eq? (car e) 'return)
          `(block ,@(if ret `((= ,ret true)) '())
@@ -1071,367 +1064,139 @@
                  (break ,bb)))
         (else (map (lambda (x) (replace-return x bb ret retval)) e))))
 
-(define (expand-binding-forms e)
-  (cond
-   ((atom? e) e)
-   ((quoted? e) e)
-   (else
-    (case (car e)
-      ((function stagedfunction)
-       (let ((name (cadr e)))
-         (if (pair? name)
-             (if (eq? (car name) 'call)
-                 (expand-binding-forms
-                  (if (and (pair? (cadr name))
-                           (eq? (car (cadr name)) 'curly))
-                      (method-def-expr (cadr (cadr name))
-                                       (cddr (cadr name))
-                                       (fix-arglist (cddr name))
-                                       (caddr e) (eq? (car e) 'stagedfunction))
-                      (method-def-expr (cadr name)
-                                       '()
-                                       (fix-arglist (cddr name))
-                                       (caddr e) (eq? (car e) 'stagedfunction))))
-                 (if (eq? (car name) 'tuple)
-                     (expand-binding-forms
-                      `(-> ,name ,(caddr e)))
-                     e))
-	     (if (and (length= e 2) (symbol? name))
-		 `(method ,name)
-		 e))))
-
-      ((->)
-       (let ((a (cadr e))
-             (b (caddr e)))
-         (let ((a (if (and (pair? a)
-                           (eq? (car a) 'tuple))
-                      (cdr a)
-                      (list a))))
-           (expand-binding-forms
-            (function-expr (fix-arglist a)
-                           `(block
-                             ,.(map (lambda (d)
-                                      `(= ,(cadr d)
-                                          (typeassert ,@(cdr d))))
-                                    (filter decl? a))
-                             ,b))))))
-
-      ((let)
-       (let ((ex (cadr e))
-             (binds (cddr e)))
-         (expand-binding-forms
-          (if
-           (null? binds)
-           `(scope-block (block ,ex))
-           (let loop ((binds (reverse binds))
-                      (blk   ex))
-             (if (null? binds)
-                 blk
-                 (cond
-                  ((or (symbol? (car binds)) (decl? (car binds)))
-                   ;; just symbol -> add local
-                   (loop (cdr binds)
-                         `(scope-block
-                           (block
-                            (local ,(car binds))
-                            (newvar ,(decl-var (car binds)))
-                            ,blk))))
-                  ((and (length= (car binds) 3)
-                        (eq? (caar binds) '=))
-                   ;; some kind of assignment
-                   (cond
-                    ((or (symbol? (cadar binds))
-                         (decl?   (cadar binds)))
-                     (let ((vname (decl-var (cadar binds))))
-                       (loop (cdr binds)
-                             (if (contains (lambda (x) (eq? x vname))
-                                           (caddar binds))
-                                 (let ((tmp (make-jlgensym)))
-                                   `(scope-block
-                                     (block (= ,tmp ,(caddar binds))
-                                      (scope-block
-                                       (block
-                                        (local ,(cadar binds))
-                                        (newvar ,vname)
-                                        (= ,vname ,tmp)
-                                        ,blk)))))
-                                 `(scope-block
-                                   (block
-                                    (local ,(cadar binds))
-                                    (newvar ,vname)
-                                    (= ,vname ,(caddar binds))
-                                    ,blk))))))
-                    ((and (pair? (cadar binds))
-                          (eq? (caadar binds) 'call))
-                     ;; f()=c
-                     (let ((asgn (cadr (julia-expand0 (car binds)))))
-                       (loop (cdr binds)
-                             `(scope-block
-                               (block
-                                (local ,(cadr asgn))
-                                (newvar ,(cadr asgn))
-                                ,asgn
-                                ,blk)))))
-                    (else (error "invalid let syntax"))))
-                  (else (error "invalid let syntax")))))))))
-
-      ((macro)
-       (cond ((and (pair? (cadr e))
-                   (eq? (car (cadr e)) 'call)
-                   (symbol? (cadr (cadr e))))
-              `(macro ,(symbol (string #\@ (cadr (cadr e))))
-                 ,(expand-binding-forms
-                   `(-> (tuple ,@(cddr (cadr e)))
-                        ,(caddr e)))))
-             ((symbol? (cadr e))  ;; already expanded
-              e)
-             (else
-              (error "invalid macro definition"))))
-
-      ((type)
-       (let ((mut (cadr e))
-             (sig (caddr e))
-             (fields (cdr (cadddr e))))
-	 (let loop ((f fields))
-	   (if (null? f)
-	       '()
-	       (let ((x (car f)))
-		 (cond ((or (symbol? x) (decl? x) (and (pair? x) (eq? (car x) 'line)))
-			(loop (cdr f)))
-		       ((and (assignment? x) (or (symbol? (cadr x)) (decl? (cadr x))))
-			(error (string "\"" (deparse x) "\" inside type definition is reserved")))
-		       (else '())))))
-         (expand-binding-forms
-          (receive (name params super) (analyze-type-sig sig)
-                   (struct-def-expr name params super fields mut)))))
-
-      ((try)
-       (if (length= e 5)
-           (let (;; expand inner try blocks first, so their return statements
-                 ;; will have been moved for `finally`, causing correct
-                 ;; chaining behavior when the current (outer) try block is
-                 ;; expanded.
-                 (tryb (expand-binding-forms (cadr e)))
-                 (var  (caddr e))
-                 (catchb (cadddr e))
-                 (finalb (cadddr (cdr e))))
-             (if (has-unmatched-symbolic-goto? tryb)
-                 (error "goto from a try/finally block is not permitted"))
-             (let ((hasret (or (contains return? tryb)
-                               (contains return? catchb))))
-               (let ((err (gensy))
-                     (ret (and hasret
-                               (or (not (block-returns? tryb))
-                                   (and catchb
-                                        (not (block-returns? catchb))))
-                               (gensy)))
-                     (retval (if hasret (gensy) #f))
-                     (bb  (gensy))
-		     (finally-exception (gensy))
-                     (val (gensy))) ;; this is jlgensym, but llvm has trouble determining that it dominates all uses
-                 (let ((tryb   (replace-return tryb bb ret retval))
-                       (catchb (replace-return catchb bb ret retval)))
-                   (expand-binding-forms
-                    `(scope-block
-                      (block
-                       ,@(if hasret `((local ,retval)) '())
-                       (local ,val)
-		       (local ,finally-exception)
-                       (= ,err false)
-                       ,@(if ret `((= ,ret false)) '())
-                       (break-block
-                        ,bb
-                        (try (= ,val
-                                ,(if catchb
-                                     `(try ,tryb ,var ,catchb)
-                                     tryb))
-                             #f
-                             (= ,err true)))
-		       (= ,finally-exception (the_exception))
-                       ,finalb
-                       (if ,err (ccall 'jl_rethrow_other Void (tuple Any) ,finally-exception))
-                       ,(if hasret
-                            (if ret
-                                `(if ,ret (return ,retval) ,val)
-                                `(return ,retval))
-                            val))))))))
-           (if (length= e 4)
-               (let ((tryb (cadr e))
-                     (var  (caddr e))
-                     (catchb (cadddr e)))
-                 (expand-binding-forms
-                  (if (symbol-like? var)
-                      `(trycatch (scope-block ,tryb)
-                                 (scope-block
-                                  (block (= ,var (the_exception))
-                                         ,catchb)))
-                      `(trycatch (scope-block ,tryb)
-                                 (scope-block ,catchb)))))
-               (map expand-binding-forms e))))
-
-      ((=)
-       (if (and (pair? (cadr e))
-                (eq? (car (cadr e)) 'call))
-           (expand-binding-forms (cons 'function (cdr e)))
-           (map expand-binding-forms e)))
-
-      ((const)
-       (if (atom? (cadr e))
-           e
-           (case (car (cadr e))
-             ((global local)
-              (expand-binding-forms
-               (qualified-const-expr (cdr (cadr e)) e)))
-             ((=)
-              (let ((lhs (cadr (cadr e)))
-                    (rhs (caddr (cadr e))))
-                (let ((vars (if (and (pair? lhs) (eq? (car lhs) 'tuple))
-                                (cdr lhs)
-                                (list lhs))))
-                  `(block
-                    ,.(map (lambda (v)
-                             `(const ,(const-check-symbol (decl-var v))))
-                           vars)
-                    ,(expand-binding-forms `(= ,lhs ,rhs))))))
-             (else
-              e))))
-
-      ((local global)
-       (if (and (symbol? (cadr e)) (length= e 2))
-           e
-           (expand-binding-forms (expand-decls (car e) (cdr e)))))
-
-      ((typealias)
-       (if (and (pair? (cadr e))
-                (eq? (car (cadr e)) 'curly))
-           (let ((name (cadr (cadr e)))
-                 (params (cddr (cadr e)))
-                 (type-ex (caddr e)))
-             (receive
-              (params bounds)
-              (sparam-name-bounds params '() '())
-              `(call (lambda ,params
-                       (block
-                        (const ,name)
-                        (= ,name (call (top TypeConstructor)
-                                       (call (top svec) ,@params)
-                                       ,(expand-binding-forms type-ex)))))
-                     ,@(symbols->typevars params bounds #t))))
-           (expand-binding-forms
-            `(const (= ,(cadr e) ,(caddr e))))))
-
-      ((module) e)
+(define (expand-try e)
+  (if (length= e 5)
+      (let (;; expand inner try blocks first, so their return statements
+            ;; will have been moved for `finally`, causing correct
+            ;; chaining behavior when the current (outer) try block is
+            ;; expanded.
+            (tryb (expand-forms (cadr e)))
+            (var  (caddr e))
+            (catchb (cadddr e))
+            (finalb (cadddr (cdr e))))
+        (if (has-unmatched-symbolic-goto? tryb)
+            (error "goto from a try/finally block is not permitted"))
+        (let ((hasret (or (contains return? tryb)
+                          (contains return? catchb))))
+          (let ((err (gensy))
+                (ret (and hasret
+                          (or (not (block-returns? tryb))
+                              (and catchb
+                                   (not (block-returns? catchb))))
+                          (gensy)))
+                (retval (if hasret (gensy) #f))
+                (bb  (gensy))
+                (finally-exception (gensy))
+                (val (gensy))) ;; this is jlgensym, but llvm has trouble determining that it dominates all uses
+            (let ((tryb   (replace-return tryb bb ret retval))
+                  (catchb (replace-return catchb bb ret retval)))
+              (expand-forms
+               `(scope-block
+                 (block
+                  ,@(if hasret `((local ,retval)) '())
+                  (local ,val)
+                  (local ,finally-exception)
+                  (= ,err false)
+                  ,@(if ret `((= ,ret false)) '())
+                  (break-block
+                   ,bb
+                   (try (= ,val
+                           ,(if catchb
+                                `(try ,tryb ,var ,catchb)
+                                tryb))
+                        #f
+                        (= ,err true)))
+                  (= ,finally-exception (the_exception))
+                  ,finalb
+                  (if ,err (ccall 'jl_rethrow_other Void (tuple Any) ,finally-exception))
+                  ,(if hasret
+                       (if ret
+                           `(if ,ret (return ,retval) ,val)
+                           `(return ,retval))
+                       val))))))))
+      (if (length= e 4)
+          (let ((tryb (cadr e))
+                (var  (caddr e))
+                (catchb (cadddr e)))
+            (expand-forms
+             (if (symbol-like? var)
+                 `(trycatch (scope-block ,tryb)
+                            (scope-block
+                             (block (= ,var (the_exception))
+                                    ,catchb)))
+                 `(trycatch (scope-block ,tryb)
+                            (scope-block ,catchb)))))
+          (map expand-forms e))))
+
+(define (expand-typealias e)
+  (if (and (pair? (cadr e))
+           (eq? (car (cadr e)) 'curly))
+      (let ((name (cadr (cadr e)))
+            (params (cddr (cadr e)))
+            (type-ex (caddr e)))
+        (receive
+         (params bounds) (sparam-name-bounds params '() '())
+         `(block
+           (const ,name)
+           (= ,name
+              (scope-block
+               (block
+                ,@(map (lambda (v) `(local ,v)) params)
+                ,@(map (lambda (l r) (make-assignment l (expand-forms r)))
+                       params
+                       (symbols->typevars params bounds #t))
+                (call (top TypeConstructor)
+                      (call (top svec) ,@params)
+                      ,(expand-forms type-ex))))))))
+      (expand-forms
+       `(const (= ,(cadr e) ,(caddr e))))))
+
+;; take apart e.g. `const a::Int = 0` into `const a; a::Int = 0`
+(define (expand-const-decl e)
+  (if (atom? (cadr e))
+      e
+      (case (car (cadr e))
+        ((global local)
+         (expand-forms
+          (qualified-const-expr (cdr (cadr e)) e)))
+        ((=)
+         (let ((lhs (cadr (cadr e)))
+               (rhs (caddr (cadr e))))
+           (let ((vars (if (and (pair? lhs) (eq? (car lhs) 'tuple))
+                           (cdr lhs)
+                           (list lhs))))
+             `(block
+               ,.(map (lambda (v)
+                        `(const ,(const-check-symbol (decl-var v))))
+                      vars)
+               ,(expand-forms `(= ,lhs ,rhs))))))
+        (else e))))
 
-      (else
-       (map expand-binding-forms e))))))
-
-;; a copy of the above patterns, but returning the names of vars
-;; introduced by the forms, instead of their transformations.
-(define vars-introduced-by-patterns
-  (pattern-set
-   ;; function with static parameters
-   (pattern-lambda
-    (function (call (curly name . sparams) . argl) body)
-    (cons 'varlist (append (llist-vars (fix-arglist argl))
-                           (apply nconc
-                                  (map (lambda (v) (trycatch
-                                                    (list (sparam-name v))
-                                                    (lambda (e) '())))
-                                       sparams)))))
-
-   ;; function definition
-   (pattern-lambda (function (call name . argl) body)
-                   (cons 'varlist (llist-vars (fix-arglist argl))))
-
-   (pattern-lambda (function (tuple . args) body)
-                   `(-> (tuple ,@args) ,body))
-
-   ;; expression form function definition
-   (pattern-lambda (= (call (curly name . sparams) . argl) body)
-                   `(function (call (curly ,name . ,sparams) . ,argl) ,body))
-   (pattern-lambda (= (call name . argl) body)
-                   `(function (call ,name ,@argl) ,body))
-
-   ;; anonymous function
-   (pattern-lambda (-> a b)
-                   (let ((a (if (and (pair? a)
-                                     (eq? (car a) 'tuple))
-                                (cdr a)
-                                (list a))))
-                     (cons 'varlist (llist-vars (fix-arglist a)))))
-
-   ;; let
-   (pattern-lambda (let ex . binds)
-                   (let loop ((binds binds)
-                              (vars  '()))
-                     (if (null? binds)
-                         (cons 'varlist vars)
-                         (cond
-                          ((or (symbol? (car binds)) (decl? (car binds)))
-                           ;; just symbol -> add local
-                           (loop (cdr binds)
-                                 (cons (decl-var (car binds)) vars)))
-                          ((and (length= (car binds) 3)
-                                (eq? (caar binds) '=))
-                           ;; some kind of assignment
-                           (cond
-                            ((or (symbol? (cadar binds))
-                                 (decl?   (cadar binds)))
-                             ;; a=b -> add argument
-                             (loop (cdr binds)
-                                   (cons (decl-var (cadar binds)) vars)))
-                            ((and (pair? (cadar binds))
-                                  (eq? (caadar binds) 'call))
-                             ;; f()=c
-                             (let ((asgn (cadr (julia-expand0 (car binds)))))
-                               (loop (cdr binds)
-                                     (cons (cadr asgn) vars))))
-                            (else '())))
-                          (else '())))))
-
-   ;; macro definition
-   (pattern-lambda (macro (call name . argl) body)
-                   `(-> (tuple ,@argl) ,body))
-
-   (pattern-lambda (try tryb var catchb finalb)
-                   (if var (list 'varlist var) '()))
-   (pattern-lambda (try tryb var catchb)
-                   (if var (list 'varlist var) '()))
-
-   ;; type definition
-   (pattern-lambda (type mut (<: (curly tn . tvars) super) body)
-                   (list* 'varlist (cons (unescape tn) (unescape tn)) '(new . new)
-                          (map typevar-expr-name tvars)))
-   (pattern-lambda (type mut (curly tn . tvars) body)
-                   (list* 'varlist (cons (unescape tn) (unescape tn)) '(new . new)
-                          (map typevar-expr-name tvars)))
-   (pattern-lambda (type mut (<: tn super) body)
-                   (list 'varlist (cons (unescape tn) (unescape tn)) '(new . new)))
-   (pattern-lambda (type mut tn body)
-                   (list 'varlist (cons (unescape tn) (unescape tn)) '(new . new)))
-
-   )) ; vars-introduced-by-patterns
-
-(define keywords-introduced-by-patterns
-  (pattern-set
-   (pattern-lambda (function (call (curly name . sparams) . argl) body)
-                   (cons 'varlist (llist-keywords (fix-arglist argl))))
-
-   (pattern-lambda (function (call name . argl) body)
-                   (cons 'varlist (llist-keywords (fix-arglist argl))))
-
-   (pattern-lambda (= (call (curly name . sparams) . argl) body)
-                   `(function (call (curly ,name . ,sparams) . ,argl) ,body))
-   (pattern-lambda (= (call name . argl) body)
-                   `(function (call ,name ,@argl) ,body))
-   ))
+(define (const-check-symbol s)
+  (if (not (symbol? s))
+      (error "expected identifier after \"const\"")
+      s))
+
+(define (qualified-const-expr binds __)
+  (let ((vs (map (lambda (b)
+                   (if (assignment? b)
+                       (const-check-symbol (decl-var (cadr b)))
+                       (error "expected assignment after \"const\"")))
+                 binds)))
+    `(block ,@(map (lambda (v) `(const ,v)) vs)
+            ,(cadr __))))
+
+(define (expand-local-or-global-decl e)
+  (if (and (symbol? (cadr e)) (length= e 2))
+      e
+      (expand-forms (expand-decls (car e) (cdr e)))))
 
 (define (assigned-name e)
   (if (and (pair? e) (memq (car e) '(call curly)))
       (assigned-name (cadr e))
       e))
 
-; local x, y=2, z => local x;local y;local z;y = 2
+;; local x, y=2, z => local x;local y;local z;y = 2
 (define (expand-decls what binds)
   (if (not (list? binds))
       (error (string "invalid \"" what "\" declaration")))
@@ -1454,38 +1219,12 @@
                 ((and (pair? x) (eq? (car x) '|::|))
                  (loop (cdr b)
                        (cons (decl-var x) vars)
-                       (cons x assigns)))
+                       (cons `(decl ,@(cdr x)) assigns)))
                 ((symbol? x)
                  (loop (cdr b) (cons x vars) assigns))
                 (else
                  (error (string "invalid syntax in \"" what "\" declaration"))))))))
 
-(define (make-assignment l r) `(= ,l ,r))
-(define (assignment? e) (and (pair? e) (eq? (car e) '=)))
-(define (return? e) (and (pair? e) (eq? (car e) 'return)))
-
-(define (const-check-symbol s)
-  (if (not (symbol? s))
-      (error "expected identifier after \"const\"")
-      s))
-
-(define (qualified-const-expr binds __)
-  (let ((vs (map (lambda (b)
-                   (if (assignment? b)
-                       (const-check-symbol (decl-var (cadr b)))
-                       (error "expected assignment after \"const\"")))
-                 binds)))
-    `(block ,@(map (lambda (v) `(const ,v)) vs)
-            ,(cadr __))))
-
-(define (eq-sym? a b)
-  (or (eq? a b) (and (jlgensym? a) (jlgensym? b) (eqv? (cdr a) (cdr b)))))
-
-(define (mem-jlgensym item lst)
-  (cond ((atom? lst) #f)
-        ((and (jlgensym? (car lst)) (eq? (car lst) item)) #t)
-        (#t (mem-jlgensym item (cdr lst)))))
-
 ;; convert (lhss...) = (tuple ...) to assignments, eliminating the tuple
 (define (tuple-to-assignments lhss0 x)
   (let loop ((lhss lhss0)
@@ -1497,7 +1236,7 @@
     (if (null? lhss)
         `(block ,@(reverse stmts)
                 ,@(reverse after)
-                (unnecessary-tuple (tuple ,@(reverse elts))))
+                (tuple ,@(reverse elts)))
         (let ((L (car lhss))
               (R (car rhss)))
           (if (and (symbol-like? L)
@@ -1533,20 +1272,39 @@
                           (+ i 1)))))
       ,t)))
 
-(define (check-kw-args kw)
-  (let ((invalid (filter (lambda (x) (not (or (kwarg? x)
-                                              (vararg? x))))
-                         kw)))
-    (if (pair? invalid)
-        (if (and (pair? (car invalid)) (eq? 'parameters (caar invalid)))
-            (error "more than one semicolon in argument list")
-            (cond ((symbol? (car invalid))
-                   (error (string "keyword argument \"" (car invalid) "\" needs a default value")))
-                  (else
-                   (error (string "invalid keyword argument syntax \""
-                                  (deparse (car invalid))
-                                  "\" (expected assignment)"))))))))
+;; make an expression safe for multiple evaluation
+;; for example a[f(x)] => (temp=f(x); a[temp])
+;; retuns a pair (expr . assignments)
+;; where 'assignments' is a list of needed assignment statements
+(define (remove-argument-side-effects e)
+  (let ((a '()))
+    (cond
+     ((and (decl? e) (symbol? (cadr e)))
+      (cons (cadr e) (list e)))
+     ((not (pair? e))
+      (cons e '()))
+     (else
+      (cons (map (lambda (x)
+                   (cond
+                    ((and (decl? x) (symbol? (cadr x)))
+                     (set! a (cons x a))
+                     (cadr x))
+                    ((not (effect-free? x))
+                     (let ((g (make-jlgensym)))
+                       (if (or (eq? (car x) '...) (eq? (car x) '&))
+                           (if (and (pair? (cadr x))
+                                    (not (quoted? (cadr x))))
+                               (begin (set! a (cons `(= ,g ,(cadr x)) a))
+                                      `(,(car x) ,g))
+                               x)
+                           (begin (set! a (cons `(= ,g ,x) a))
+                                  g))))
+                    (else
+                     x)))
+                 e)
+            (reverse a))))))
 
+;; lower function call containing keyword arguments
 (define (lower-kw-call f kw pa)
   (if (any (lambda (x) (and (pair? x) (eq? (car x) 'parameters)))
            kw)
@@ -1563,34 +1321,36 @@
                                 `((quote ,(cadr a)) ,(caddr a)))
                               keys))))
      (if (null? restkeys)
-         `(call (top kwcall) (|.| ,(current-julia-module) 'call) ,(length keys) ,@keyargs
-                ,f (call (top Array) (top Any) ,(* 2 (length keys)))
-                ,@pa)
+         `(call (call (top kwfunc) ,f) (cell1d ,@keyargs) ,f ,@pa)
          (let ((container (make-jlgensym)))
            `(block
-             (= ,container (call (top Array) (top Any) ,(* 2 (length keys))))
+             (= ,container (cell1d ,@keyargs))
              ,@(map (lambda (rk)
-                    (let* ((k (make-jlgensym))
-                           (v (make-jlgensym))
-                           (push-expr `(ccall 'jl_cell_1d_push2 Void
-                                             (tuple Any Any Any)
-                                             ,container
-                                             (|::| ,k (top Symbol))
-                                             ,v)))
-                      (if (vararg? rk)
-                          `(for (= (tuple ,k ,v) ,(cadr rk))
-                                ,push-expr)
-                          `(block (= (tuple ,k ,v) ,rk)
-                                  ,push-expr))))
-                  restkeys)
-             ,(let ((kw-call `(call (top kwcall) (|.| ,(current-julia-module) 'call) ,(length keys) ,@keyargs
-                                    ,f ,container ,@pa)))
-                (if (not (null? keys))
-                    kw-call
-                    `(if (call (top isempty) ,container)
-                         (call ,f ,@pa)
-                         ,kw-call)))))))))
+                      (let* ((k (make-jlgensym))
+                             (v (make-jlgensym))
+                             (push-expr `(ccall 'jl_cell_1d_push2 Void
+                                                (tuple Any Any Any)
+                                                ,container
+                                                (|::| ,k (top Symbol))
+                                                ,v)))
+                        (if (vararg? rk)
+                            `(for (= (tuple ,k ,v) ,(cadr rk))
+                                  ,push-expr)
+                            `(block (= (tuple ,k ,v) ,rk)
+                                    ,push-expr))))
+                    restkeys)
+             ,(if (not (null? keys))
+                  `(call (call (top kwfunc) ,f) ,container ,f ,@pa)
+                  (let* ((expr_stmts (remove-argument-side-effects `(call ,f ,@pa)))
+                         (pa         (cddr (car expr_stmts)))
+                         (stmts      (cdr expr_stmts)))
+                    `(block
+                      ,@stmts
+                      (if (call (top isempty) ,container)
+                          (call ,f ,@pa)
+                          (call (call (top kwfunc) ,f) ,container ,f ,@pa)))))))))))
 
+;; convert e.g. A'*B to Ac_mul_B(A,B)
 (define (expand-transposed-op e ops)
   (let ((a (caddr e))
         (b (cadddr e)))
@@ -1615,6 +1375,50 @@
           (else
            `(call ,(cadr e) ,(expand-forms a) ,(expand-forms b))))))
 
+;; convert `a+=b` to `a=a+b`
+(define (expand-update-operator- op lhs rhs declT)
+  (let ((e (remove-argument-side-effects lhs)))
+    `(block ,@(cdr e)
+            ,(if (null? declT)
+                 `(= ,(car e) (call ,op ,(car e) ,rhs))
+                 `(= ,(car e) (call ,op (:: ,(car e) ,(car declT)) ,rhs))))))
+
+(define (partially-expand-ref e)
+  (let ((a    (cadr e))
+        (idxs (cddr e)))
+    (let* ((reuse (and (pair? a)
+                       (contains (lambda (x)
+                                   (or (eq? x 'end)
+                                       (eq? x ':)
+                                       (and (pair? x)
+                                            (eq? (car x) ':))))
+                                 idxs)))
+           (arr   (if reuse (make-jlgensym) a))
+           (stmts (if reuse `((= ,arr ,a)) '())))
+      (receive
+       (new-idxs stuff) (process-indexes arr idxs)
+       `(block
+         ,@(append stmts stuff)
+         (call getindex ,arr ,@new-idxs))))))
+
+(define (expand-update-operator op lhs rhs . declT)
+  (cond ((and (pair? lhs) (eq? (car lhs) 'ref))
+         ;; expand indexing inside op= first, to remove "end" and ":"
+         (let* ((ex (partially-expand-ref lhs))
+                (stmts (butlast (cdr ex)))
+                (refex (last    (cdr ex)))
+                (nuref `(ref ,(caddr refex) ,@(cdddr refex))))
+           `(block ,@stmts
+                   ,(expand-update-operator- op nuref rhs declT))))
+        ((and (pair? lhs) (eq? (car lhs) '|::|))
+         ;; (+= (:: x T) rhs)
+         (let ((e (remove-argument-side-effects (cadr lhs)))
+               (T (caddr lhs)))
+           `(block ,@(cdr e)
+                   ,(expand-update-operator op (car e) rhs T))))
+        (else
+         (expand-update-operator- op lhs rhs declT))))
+
 (define (lower-update-op e)
   (expand-forms
    (expand-update-operator
@@ -1623,6 +1427,41 @@
     (cadr e)
     (caddr e))))
 
+(define (expand-and e)
+  (let ((e (cdr (flatten-ex '&& e))))
+    (let loop ((tail e))
+      (if (null? tail)
+          'true
+          (if (null? (cdr tail))
+              (car tail)
+              `(if ,(car tail)
+                   ,(loop (cdr tail))
+                   false))))))
+
+(define (expand-or e)
+  (let ((e (cdr (flatten-ex '|\|\|| e))))
+    (let loop ((tail e))
+      (if (null? tail)
+          'false
+          (if (null? (cdr tail))
+              (car tail)
+              (if (symbol-like? (car tail))
+                  `(if ,(car tail) ,(car tail)
+                       ,(loop (cdr tail)))
+                  (let ((g (make-jlgensym)))
+                    `(block (= ,g ,(car tail))
+                            (if ,g ,g
+                                ,(loop (cdr tail)))))))))))
+
+(define (expand-forms e)
+  (if (or (atom? e) (memq (car e) '(quote inert top line module toplevel jlgensym null meta)))
+      e
+      (let ((ex (get expand-table (car e) #f)))
+        (if ex
+            (ex e)
+            (cons (car e)
+                  (map expand-forms (cdr e)))))))
+
 (define (expand-for while lhs X body)
   ;; (for (= lhs X) body)
   (let ((coll  (make-jlgensym))
@@ -1641,29 +1480,37 @@
                                             `(call (top next) ,coll ,state))
                    ,body))))))))
 
-(define (map-expand-forms e) (map expand-forms e))
-
-(define (expand-forms e)
-  (if (atom? e)
-      e
-      ((get expand-table (car e) map-expand-forms) e)))
-
+;; table mapping expression head to a function expanding that form
 (define expand-table
   (table
-   'quote identity
-   'inert identity
-   'top   identity
-   'line  identity
-   'module identity
+   'function       expand-function-def
+   'stagedfunction expand-function-def
+   '->             expand-arrow
+   'let            expand-let
+   'macro          expand-macro-def
+   'type           expand-type-def
+   'try            expand-try
+   'typealias      expand-typealias
 
    'lambda
-   (lambda (e) (list* 'lambda (map expand-forms (cadr e)) (map expand-forms (cddr e))))
+   (lambda (e)
+     `(lambda ,(map expand-forms (cadr e))
+        ,@(if (length= e 3) '(()) '())
+        ,@(map expand-forms (cddr e))))
 
    'block
    (lambda (e)
-     (if (null? (cdr e))
-         '(block (null))
-         (map expand-forms e)))
+     (let ((e (flatten-blocks e)))
+       (cond ((null? (cdr e)) '(null))
+             ((null? (cddr e)) (expand-forms (cadr e)))
+             (else
+              `(block
+                ,.(map (lambda (x)
+                         (if (decl? x)
+                             `(decl ,@(map expand-forms (cdr x)))
+                             (expand-forms x)))
+                       (butlast (cdr e)))
+                ,(expand-forms (last e)))))))
 
    '|.|
    (lambda (e)
@@ -1673,101 +1520,122 @@
    (lambda (e)
      `(call in ,(expand-forms (cadr e)) ,(expand-forms (caddr e))))
 
+   'const  expand-const-decl
+   'local  expand-local-or-global-decl
+   'global expand-local-or-global-decl
+
    '=
    (lambda (e)
-     (if (or (atom? (cadr e)) (jlgensym? (cadr e)))
-         `(= ,(cadr e) ,(expand-forms (caddr e)))
-         (case (car (cadr e))
-           ((|.|)
-            ;; a.b =
-            (let ((a (cadr (cadr e)))
-                  (b (caddr (cadr e)))
-                  (rhs (caddr e)))
-              (let ((aa (if (atom? a) a (make-jlgensym)))
-                    (bb (if (or (atom? b) (quoted? b)) b (make-jlgensym))))
-                `(block
-                  ,.(if (eq? aa a) '() `((= ,aa ,(expand-forms a))))
-                  ,.(if (eq? bb b) '() `((= ,bb ,(expand-forms b))))
-                  (call (top setfield!) ,aa ,bb
-                        (call (top convert)
-                              (call (top fieldtype) (call (top typeof) ,aa) ,bb)
-                              ,(expand-forms rhs)))))))
-
-           ((tuple)
-            ;; multiple assignment
-            (let ((lhss (cdr (cadr e)))
-                  (x    (caddr e)))
-              (if (and (pair? x) (pair? lhss) (eq? (car x) 'tuple)
-                       (length= lhss (length (cdr x))))
-                  ;; (a, b, ...) = (x, y, ...)
-                  (expand-forms
-                   (tuple-to-assignments lhss x))
-                  ;; (a, b, ...) = other
-                  (let* ((xx  (if (and (symbol? x) (not (memq x lhss)))
-                                  x (make-jlgensym)))
-                         (ini (if (eq? x xx) '() `((= ,xx ,(expand-forms x)))))
-                         (st  (gensy)))
-                    `(block
-                      ,@ini
-                      (= ,st (call (top start) ,xx))
-                      ,.(map (lambda (i lhs)
-                               (expand-forms
-                                (lower-tuple-assignment
-                                 (list lhs st)
-                                 `(call (top indexed_next)
-                                        ,xx ,(+ i 1) ,st))))
-                             (iota (length lhss))
-                             lhss)
-                      ,xx)))))
-
-           ((typed_hcat)
-            (error "invalid spacing in left side of indexed assignment"))
-           ((typed_vcat)
-            (error "unexpected \";\" in left side of indexed assignment"))
-
-           ((ref)
-            ;; (= (ref a . idxs) rhs)
-            (let ((a    (cadr (cadr e)))
-                  (idxs (cddr (cadr e)))
+     (cond
+      ((and (pair? (cadr e))
+            (eq? (car (cadr e)) 'call))
+       (expand-forms (cons 'function (cdr e))))
+      ((assignment? (caddr e))
+       ;; chain of assignments - convert a=b=c to `b=c; a=c`
+       (let loop ((lhss (list (cadr e)))
                   (rhs  (caddr e)))
-              (let* ((reuse (and (pair? a)
-                                 (contains (lambda (x)
-                                             (or (eq? x 'end)
-                                                 (and (pair? x)
-                                                      (eq? (car x) ':))))
-                                           idxs)))
-                     (arr   (if reuse (make-jlgensym) a))
-                     (stmts (if reuse `((= ,arr ,(expand-forms a))) '())))
-                (let* ((rrhs (and (pair? rhs) (not (jlgensym? rhs)) (not (quoted? rhs))))
-                       (r    (if rrhs (make-jlgensym) rhs))
-                       (rini (if rrhs `((= ,r ,(expand-forms rhs))) '())))
-                  (receive
-                   (new-idxs stuff) (process-indexes arr idxs)
-                   `(block
-                     ,@stmts
-                     ,.(map expand-forms stuff)
-                     ,@rini
-                     ,(expand-forms
-                       `(call setindex! ,arr ,r ,@new-idxs))
-                     ,r))))))
-
-           ((|::|)
-            ;; (= (|::| x T) rhs)
-            (let ((x (cadr (cadr e)))
-                  (T (caddr (cadr e)))
-                  (rhs (caddr e)))
-              (let ((e (remove-argument-side-effects x)))
+         (if (assignment? rhs)
+             (loop (cons (cadr rhs) lhss) (caddr rhs))
+             (let ((rr (if (symbol-like? rhs) rhs (make-jlgensym))))
+               (expand-forms
+                `(block ,.(if (eq? rr rhs) '() `((= ,rr ,rhs)))
+                        ,@(map (lambda (l) `(= ,l ,rr))
+                               lhss)
+                        ,rr))))))
+      ((symbol-like? (cadr e))
+       `(= ,(cadr e) ,(expand-forms (caddr e))))
+      ((atom? (cadr e))
+       (error (string "invalid assignment location \"" (deparse (cadr e)) "\"")))
+      (else
+       (case (car (cadr e))
+         ((|.|)
+          ;; a.b =
+          (let ((a   (cadr (cadr e)))
+                (b   (caddr (cadr e)))
+                (rhs (caddr e)))
+            (let ((aa (if (symbol-like? a) a (make-jlgensym)))
+                  (bb (if (or (atom? b) (symbol-like? b) (and (pair? b) (quoted? b)))
+                          b (make-jlgensym)))
+                  (rr (if (or (symbol-like? rhs) (atom? rhs)) rhs (make-jlgensym))))
+              `(block
+                ,.(if (eq? aa a)   '() `((= ,aa ,(expand-forms a))))
+                ,.(if (eq? bb b)   '() `((= ,bb ,(expand-forms b))))
+                ,.(if (eq? rr rhs) '() `((= ,rr ,(expand-forms rhs))))
+                (call (top setfield!) ,aa ,bb
+                      (call (top convert)
+                            (call (top fieldtype) (call (top typeof) ,aa) ,bb)
+                            ,rr))
+                ,rr))))
+         ((tuple)
+          ;; multiple assignment
+          (let ((lhss (cdr (cadr e)))
+                (x    (caddr e)))
+            (if (and (pair? x) (pair? lhss) (eq? (car x) 'tuple)
+                     (length= lhss (length (cdr x))))
+                ;; (a, b, ...) = (x, y, ...)
                 (expand-forms
-                 `(block ,@(cdr e)
-                         (|::| ,(car e) ,T)
-                         (= ,(car e) ,rhs))))))
-
-           ((vcat)
-            ;; (= (vcat . args) rhs)
-            (error "use \"(a, b) = ...\" to assign multiple values"))
-
-           (else
-            (error "invalid assignment location")))))
+                 (tuple-to-assignments lhss x))
+                ;; (a, b, ...) = other
+                (let* ((xx  (if (and (symbol? x) (not (memq x lhss)))
+                                x (make-jlgensym)))
+                       (ini (if (eq? x xx) '() `((= ,xx ,(expand-forms x)))))
+                       (st  (gensy)))
+                  `(block
+                    ,@ini
+                    (= ,st (call (top start) ,xx))
+                    ,.(map (lambda (i lhs)
+                             (expand-forms
+                              (lower-tuple-assignment
+                               (list lhs st)
+                               `(call (top indexed_next)
+                                      ,xx ,(+ i 1) ,st))))
+                           (iota (length lhss))
+                           lhss)
+                    ,xx)))))
+         ((typed_hcat)
+          (error "invalid spacing in left side of indexed assignment"))
+         ((typed_vcat)
+          (error "unexpected \";\" in left side of indexed assignment"))
+         ((ref)
+          ;; (= (ref a . idxs) rhs)
+          (let ((a    (cadr (cadr e)))
+                (idxs (cddr (cadr e)))
+                (rhs  (caddr e)))
+            (let* ((reuse (and (pair? a)
+                               (contains (lambda (x)
+                                           (or (eq? x 'end)
+                                               (and (pair? x)
+                                                    (eq? (car x) ':))))
+                                         idxs)))
+                   (arr   (if reuse (make-jlgensym) a))
+                   (stmts (if reuse `((= ,arr ,(expand-forms a))) '()))
+                   (rrhs (and (pair? rhs) (not (jlgensym? rhs)) (not (quoted? rhs))))
+                   (r    (if rrhs (make-jlgensym) rhs))
+                   (rini (if rrhs `((= ,r ,(expand-forms rhs))) '())))
+              (receive
+               (new-idxs stuff) (process-indexes arr idxs)
+               `(block
+                 ,@stmts
+                 ,.(map expand-forms stuff)
+                 ,@rini
+                 ,(expand-forms
+                   `(call setindex! ,arr ,r ,@new-idxs))
+                 ,r)))))
+         ((|::|)
+          ;; (= (|::| x T) rhs)
+          (let ((x (cadr (cadr e)))
+                (T (caddr (cadr e)))
+                (rhs (caddr e)))
+            (let ((e (remove-argument-side-effects x)))
+              (expand-forms
+               `(block ,@(cdr e)
+                       (decl ,(car e) ,T)
+                       (= ,(car e) ,rhs))))))
+         ((vcat)
+          ;; (= (vcat . args) rhs)
+          (error "use \"(a, b) = ...\" to assign multiple values"))
+         (else
+          (error (string "invalid assignment location \"" (deparse (cadr e)) "\"")))))))
 
    'abstract
    (lambda (e)
@@ -1785,19 +1653,17 @@
                  (bits-def-expr n name params super)))))
 
    'comparison
-   (lambda (e)
-     (expand-forms (expand-compare-chain (cdr e))))
+   (lambda (e) (expand-forms (expand-compare-chain (cdr e))))
 
    'ref
    (lambda (e)
      (let ((args (cddr e)))
        (if (has-parameters? args)
-         (error "unexpected semicolon in array expression")
-         (expand-forms (partially-expand-ref e)))))
+           (error "unexpected semicolon in array expression")
+           (expand-forms (partially-expand-ref e)))))
 
    'curly
-   (lambda (e)
-     (expand-forms `(call (top apply_type) ,@(cdr e))))
+   (lambda (e) (expand-forms `(call (top apply_type) ,@(cdr e))))
 
    'call
    (lambda (e)
@@ -1807,9 +1673,9 @@
                        (eq? (car (caddr e)) 'parameters))
                   ;; (call f (parameters . kwargs) ...)
                   (expand-forms
-                    (receive
-                      (kws args) (separate kwarg? (cdddr e))
-                      (lower-kw-call f (append kws (cdr (caddr e))) args))))
+                   (receive
+                    (kws args) (separate kwarg? (cdddr e))
+                    (lower-kw-call f (append kws (cdr (caddr e))) args))))
                  ((any kwarg? (cddr e))
                   ;; (call f ... (kw a b) ...)
                   (expand-forms
@@ -1835,7 +1701,7 @@
                                            (tuple-wrap (cdr a) '())))
                                 (tuple-wrap (cdr a) (cons x run))))))
                     (expand-forms
-                     `(call (top _apply) (|.| ,(current-julia-module) 'call) ,f ,@(tuple-wrap argl '())))))
+                     `(call (top _apply) ,f ,@(tuple-wrap argl '())))))
 
                  ((and (eq? (cadr e) '*) (length= e 4))
                   (expand-transposed-op
@@ -1855,11 +1721,10 @@
 
    'tuple
    (lambda (e)
-     (for-each (lambda (x)
-		 ;; assignment inside tuple looks like a keyword argument
-		 (if (assignment? x)
-		     (error "assignment not allowed inside tuple")))
-	       (cdr e))
+     (if (and (length> e 1) (pair? (cadr e)) (eq? (caadr e) 'parameters))
+         (error "unexpected semicolon in tuple"))
+     (if (any assignment? (cdr e))
+         (error "assignment not allowed inside tuple"))
      (expand-forms `(call (top tuple) ,@(cdr e))))
 
    'dict
@@ -1944,9 +1809,9 @@
    'inner-while
    (lambda (e)
      `(scope-block
-        (_while ,(expand-forms (cadr e))
-                (break-block loop-cont
-                             ,(expand-forms (caddr e))))))
+       (_while ,(expand-forms (cadr e))
+               (break-block loop-cont
+                            ,(expand-forms (caddr e))))))
 
    'break
    (lambda (e)
@@ -1969,6 +1834,9 @@
                        (caddr e)  ;; body
                        (nest (cdr ranges) #f)))))
 
+   '&&     (lambda (e) (expand-forms (expand-and e)))
+   '|\|\|| (lambda (e) (expand-forms (expand-or  e)))
+
    '+=     lower-update-op
    '-=     lower-update-op
    '*=     lower-update-op
@@ -2014,21 +1882,21 @@
    (lambda (e)
      (let ((a (cdr e)))
        (if (has-parameters? a)
-         (error "unexpected semicolon in array expression")
-         (expand-forms
-           (if (any (lambda (x)
-                      (and (pair? x) (eq? (car x) 'row)))
-                    a)
-             ;; convert nested hcat inside vcat to hvcat
-             (let ((rows (map (lambda (x)
-                               (if (and (pair? x) (eq? (car x) 'row))
-                                   (cdr x)
-                                   (list x)))
-                             a)))
-               `(call hvcat
-                   (tuple ,.(map length rows))
-                     ,.(apply append rows)))
-             `(call vcat ,@a))))))
+           (error "unexpected semicolon in array expression")
+           (expand-forms
+            (if (any (lambda (x)
+                       (and (pair? x) (eq? (car x) 'row)))
+                     a)
+                ;; convert nested hcat inside vcat to hvcat
+                (let ((rows (map (lambda (x)
+                                   (if (and (pair? x) (eq? (car x) 'row))
+                                       (cdr x)
+                                       (list x)))
+                                 a)))
+                  `(call hvcat
+                         (tuple ,.(map length rows))
+                         ,.(apply append rows)))
+                `(call vcat ,@a))))))
 
    'typed_hcat
    (lambda (e) `(call (top typed_hcat) ,(expand-forms (cadr e)) ,.(map expand-forms (cddr e))))
@@ -2039,8 +1907,8 @@
            (a (cddr e)))
        (expand-forms
         (if (any (lambda (x)
-             (and (pair? x) (eq? (car x) 'row)))
-           a)
+                   (and (pair? x) (eq? (car x) 'row)))
+                 a)
             ;; convert nested hcat inside vcat to hvcat
             (let ((rows (map (lambda (x)
                                (if (and (pair? x) (eq? (car x) 'row))
@@ -2065,14 +1933,31 @@
            (begin
              (if (not (and (pair? argtypes)
                            (eq? (car argtypes) 'tuple)))
-	       (if (and (pair? RT)
-			(eq? (car RT) 'tuple))
-                 (error "ccall argument types must be a tuple; try \"(T,)\" and check if you specified a correct return type")
-                 (error "ccall argument types must be a tuple; try \"(T,)\"")))
+                 (if (and (pair? RT)
+                          (eq? (car RT) 'tuple))
+                     (error "ccall argument types must be a tuple; try \"(T,)\" and check if you specified a correct return type")
+                     (error "ccall argument types must be a tuple; try \"(T,)\"")))
              (expand-forms
               (lower-ccall name RT (cdr argtypes) args))))
          e))
 
+   'generator
+   (lambda (e)
+     (let ((expr   (cadr e))
+           (vars   (map cadr  (cddr e)))
+           (ranges (map caddr (cddr e))))
+       (let* ((argname (if (and (length= vars 1) (symbol? (car vars)))
+                           (car vars)
+                           (gensy)))
+              (splat (if (eq? argname (car vars))
+                         '()
+                         `((= (tuple ,@vars) ,argname)))))
+         (expand-forms
+          `(call (top Generator) (-> ,argname (block ,@splat ,expr))
+                 ,(if (length= ranges 1)
+                      (car ranges)
+                      `(call (top IteratorND) (call (top product) ,@ranges))))))))
+
    'comprehension
    (lambda (e)
      (expand-forms (lower-comprehension #f       (cadr e) (cddr e))))
@@ -2157,9 +2042,9 @@
       (if (null? ranges)
           `(block (= ,oneresult ,expr)
                   ,@(if atype '() `((type_goto ,initlabl ,oneresult)))
-                  (boundscheck false)
+                  (inbounds true)
                   (call (top setindex!) ,result ,oneresult ,ri)
-                  (boundscheck pop)
+                  (inbounds pop)
                   (= ,ri (call (top +) ,ri 1)))
           `(block
             (= ,(car states) (call (top start) ,(car rv)))
@@ -2258,364 +2143,12 @@
 
 (define (lhs-vars e)
   (cond ((symbol? e) (list e))
+        ((decl? e)   (list (decl-var e)))
         ((and (pair? e) (eq? (car e) 'tuple))
          (apply append (map lhs-vars (cdr e))))
         (else '())))
 
-; (op (op a b) c) => (a b c) etc.
-(define (flatten-op op e)
-  (if (not (pair? e)) e
-      (apply append
-             (map (lambda (x)
-                    (if (and (pair? x) (eq? (car x) op))
-                        (flatten-op op x)
-                        (list x)))
-                  (cdr e)))))
-
-(define (expand-and e)
-  (let ((e (flatten-op '&& e)))
-    (let loop ((tail e))
-      (if (null? tail)
-          'true
-          (if (null? (cdr tail))
-              (car tail)
-              `(if ,(car tail)
-                   ,(loop (cdr tail))
-                   false))))))
-
-(define (expand-or e)
-  (let ((e (flatten-op '|\|\|| e)))
-    (let loop ((tail e))
-      (if (null? tail)
-          'false
-          (if (null? (cdr tail))
-              (car tail)
-              (if (symbol-like? (car tail))
-                  `(if ,(car tail) ,(car tail)
-                       ,(loop (cdr tail)))
-                  (let ((g (gensy)))
-                    `(block (= ,g ,(car tail))
-                            (if ,g ,g
-                                ,(loop (cdr tail)))))))))))
-
-;; in "return x()" inside a try block, "x()" is not really in tail position
-;; since we need to pop the exception handler first. convert these cases
-;; to "tmp = x(); return tmp"
-(define (fix-try-block-returns e)
-  (cond ((or (atom? e) (jlgensym? e) (quoted? e))  e)
-        ((and (eq? (car e) 'return) (or (symbol-like? (cadr e)) (pair? (cadr e))))
-         (let ((sym (make-jlgensym)))
-           `(block (= ,sym ,(cadr e))
-                   (return ,sym))))
-        ((eq? (car e) 'lambda) e)
-        (else
-         (cons (car e)
-               (map fix-try-block-returns (cdr e))))))
-
-; conversion to "linear flow form"
-;
-; This pass removes control flow constructs from value position.
-; A "control flow construct" is anything that would require a branch.
-;  (block ... (value-expr ... control-expr ...) ...) =>
-;  (block ... (= var control-expr) (value-expr ... var ...) ...)
-; except the assignment is incorporated into control-expr, so that
-; control exprs only occur in statement position.
-;
-; The conversion works by passing around the intended destination of
-; the value being computed: #f for statement position, #t for value position,
-; or a symbol if the value needs to be assigned to a particular variable.
-; This is the "dest" argument to to-lff.
-;
-; This also keeps track of tail position, and converts the code so that
-; everything in tail position is returned explicitly.
-;
-; The result is that every expression whose value is needed is either
-; a function argument, an assignment RHS, or returned explicitly.
-; In this form, expressions can be analyzed freely without fear of
-; intervening branches. Similarly, control flow can be analyzed without
-; worrying about implicit value locations (the "evaluation stack").
-(define *lff-line* 0)
-(define (to-LFF e)
-  (set! *lff-line* 0)
-  (with-exception-catcher
-   (lambda (e)
-     (if (and (> *lff-line* 0) (pair? e) (eq? (car e) 'error))
-         (let ((msg (cadr e)))
-           (raise `(error ,(string msg " at line " *lff-line*))))
-         (raise e)))
-   (lambda () (to-blk (to-lff e #t #t)))))
-
-(define (to-blk r)
-  (if (length= r 1) (car r) (cons 'block (reverse r))))
-
-(define (blk-tail r) (reverse r))
-
-;; apply to-lff to each subexpr and combine results
-(define (map-to-lff e dest tail)
-  (let ((r (map (lambda (arg) (to-lff arg #t #f))
-                (cdr e))))
-    (cond ((symbol-like? dest)
-           (cons `(= ,dest ,(cons (car e) (map car r)))
-                 (apply append (map cdr (reverse r)))))
-          (else
-           (let ((ex (cons (car e) (map car r))))
-             (cons (if tail `(return ,ex) ex)
-                   (apply append (map cdr (reverse r)))))))))
-
-;; to-lff returns (new-ex . stmts) where stmts is a list of statements that
-;; must run before new-ex is valid.
-;;
-;; If the input expression needed to be removed from its original context,
-;; like the 'if' in "1+if(a,b,c)", then new-ex is a symbol holding the
-;; result of the expression.
-;;
-;; If dest is a symbol or #f, new-ex can be a statement.
-;;
-;; We essentially maintain a stack of control-flow constructs that need to be
-;; run in statement position as we walk around an expression. If we hit
-;; statement context, we can dump the control-flow stuff there.
-;; This expression walk is entirely within the "else" clause of the giant
-;; case expression. Everything else deals with special forms.
-(define (to-lff e dest tail)
-  (if (effect-free? e)
-      (cond ((symbol-like? dest)
-             (if (and (pair? e) (eq? (car e) 'break))
-                 ;; odd corner case: sometimes try/finally generates
-                 ;; a (break ) as an assignment RHS
-                 (to-lff e #f #f)
-                 (cons `(= ,dest ,e) '())))
-            (dest (cons (if tail `(return ,e) e)
-                        '()))
-            (else (cons e '())))
-
-      (case (car e)
-        ((call)  ;; ensure left-to-right evaluation of arguments
-         (let ((assigned
-                ;; vars assigned in each arg
-                ;; start with cddr since each arg only considers subsequent ones
-                (map (lambda (x) (expr-find-all assignment-like? x cadr))
-                     (cddr e))))
-           (if (every null? assigned)
-               ;; no assignments
-               (map-to-lff e dest tail)
-               ;; has assignments
-               (let each-arg ((ass  assigned)
-                              (args (cdr e))
-                              (tmp  '())
-                              (newa '()))
-                 ;; if an argument contains vars assigned in later arguments,
-                 ;; lift out a temporary assignment for it.
-                 (if (null? ass)
-                     (if (null? tmp)
-                         (map-to-lff e dest tail)
-                         (to-lff `(block
-                                   ,.(reverse tmp)
-                                   (call ,.(reverse newa) ,(car args)))
-                                 dest tail))
-                     (if (expr-contains-p (lambda (v) (if (jlgensym? v)
-                                            (any (lambda (vlist) (mem-jlgensym v vlist)) ass)
-                                            (any (lambda (vlist) (memq v vlist)) ass)))
-                                          (car args))
-                         (let ((g (make-jlgensym)))
-                           (each-arg (cdr ass) (cdr args)
-                                     (cons `(= ,g ,(car args)) tmp)
-                                     (cons g newa)))
-                         (each-arg (cdr ass) (cdr args)
-                                   tmp
-                                   (cons (car args) newa))))))))
-
-        ((=)
-         (if (or (not (symbol-like? (cadr e)))
-                 (eq? (cadr e) 'true)
-                 (eq? (cadr e) 'false))
-             (error (string "invalid assignment location \"" (deparse (cadr e)) "\"")))
-         (let ((LHS (cadr e))
-               (RHS (caddr e)))
-           (cond ((not dest)
-                  (to-lff RHS LHS #f))
-                 #;((assignment? RHS)
-                 (let ((r (to-lff RHS dest #f)))
-                 (list* (if tail `(return ,(car r)) (car r))
-                 `(= ,LHS ,(car r))
-                 (cdr r))))
-                 ((and (effect-free? RHS)
-                       ;; need temp var for `x::Int = x` (issue #6896)
-                       (not (eq? RHS (decl-var LHS))))
-                  (cond ((symbol-like? dest)
-                            (list `(= ,LHS ,RHS)
-                                  `(= ,dest ,RHS)))
-                        (dest  (list (if tail `(return ,RHS) RHS)
-                                     `(= ,LHS ,RHS)))
-                        (else  (list e))))
-                 (else
-                  (to-lff (let ((val (make-jlgensym)))
-                            `(block (= ,val ,RHS)
-                                    (= ,LHS ,val)
-                                    ,val))
-                          dest tail)))))
-
-        ((if)
-         (cond ((or (and tail (not (jlgensym? dest))) (eq? dest #f) (symbol? dest))
-                (let ((r (to-lff (cadr e) #t #f)))
-                  (cons `(if
-                          ,(car r)
-                          ,(to-blk (to-lff (caddr e) dest tail))
-                          ,(if (length= e 4)
-                               (to-blk (to-lff (cadddr e) dest tail))
-                               (to-blk (to-lff '(null)  dest tail))))
-                        (cdr r))))
-               (else (let* ((g (gensy))
-                            (stmts (cons g
-                                         (cons `(local! ,g) (to-lff e g tail)))))
-                       (if (jlgensym? dest) (cons `(= ,dest ,g) stmts) stmts)))))
-
-        ((line)
-         (set! *lff-line* (cadr e))
-         (cons e '()))
-
-        ((trycatch)
-         (cond ((and (eq? dest #t) (not tail))
-                (let ((g (gensy)))
-                  (list* g
-                         `(local! ,g)
-                         (to-lff e g #f))))
-               (else (let* ((g (if (jlgensym? dest) (gensy) dest))
-                            (stmts (cons `(trycatch ,(fix-try-block-returns
-                                                      (to-blk (to-lff (cadr e) g tail)))
-                                                     ,(to-blk (to-lff (caddr e) g tail)))
-                                          ())))
-                       (if (jlgensym? dest) (cons `(= ,dest ,g) stmts) stmts)))))
-
-        ((&&)
-         (to-lff (expand-and e) dest tail))
-        ((|\|\||)
-         (to-lff (expand-or e) dest tail))
-
-        ((block)
-         (if (length= e 2)
-             (to-lff (cadr e) dest tail)
-             (let* ((g (make-jlgensym))
-                    (stmts
-                     (let loop ((tl (cdr e)))
-                       (if (null? tl) '()
-                           (if (null? (cdr tl))
-                               (cond ((or tail (eq? dest #f) (symbol-like? dest))
-                                      (blk-tail (to-lff (car tl) dest tail)))
-                                     (else
-                                      (blk-tail (to-lff (car tl) g tail))))
-                               (cons (to-blk (to-lff (car tl) #f #f))
-                                     (loop (cdr tl))))))))
-               (if (and (eq? dest #t) (not tail))
-                   (cons g (reverse stmts))
-                   (if (and tail (null? stmts))
-                       (cons '(return (null))
-                             '())
-                       (cons (cons 'block stmts)
-                             '()))))))
-
-        ((return)
-         (if (and dest (not tail))
-             (error "misplaced return statement")
-             (to-lff (cadr e) #t #t)))
-
-        ((_while) (cond ((eq? dest #t)
-                         (cons (if tail '(return (null)) '(null))
-                               (to-lff e #f #f)))
-                        (else
-                         (let* ((r (to-lff (cadr e) #t #f))
-                                (w (cons `(_while ,(to-blk (cdr r))
-                                                  ,(car r)
-                                                  ,(to-blk
-                                                    (to-lff (caddr e) #f #f)))
-                                         '())))
-                           (if (symbol-like? dest)
-                               (cons `(= ,dest (null)) w)
-                               w)))))
-
-        ((break-block)
-         (let ((r (to-lff (caddr e) dest tail)))
-           (if dest
-               (cons (car r)
-                     (list `(break-block ,(cadr e) ,(to-blk (cdr r)))))
-               (cons `(break-block ,(cadr e) ,(car r))
-                     (cdr r)))))
-
-        ((scope-block)
-         (if (and dest (not tail) (not (jlgensym? dest)))
-             (let* ((g (make-jlgensym))
-                    (r (to-lff (cadr e) g tail)))
-               (cons (car (to-lff g dest tail))
-                   (cons `(scope-block ,(to-blk r))
-                         '())))
-             (let ((r (to-lff (cadr e) dest tail)))
-               (cons `(scope-block ,(to-blk r))
-                     '()))))
-
-        ;; move the break to the list of preceding statements. value is
-        ;; null but this will never be observed.
-        ((break) (cons '(null) (list e)))
-
-        ((lambda)
-         (let ((l `(lambda ,(cadr e)
-                     ,(to-blk (to-lff (caddr e) #t #t)))))
-           (if (symbol-like? dest)
-               (cons `(= ,dest ,l) '())
-               (cons (if tail `(return ,l) l) '()))))
-
-        ((local global)
-         (if dest
-             (error (string "misplaced \"" (car e) "\" declaration")))
-         (cons (to-blk (to-lff '(null) dest tail))
-               (list e)))
-
-        ((|::|)
-         (if dest
-             ;; convert to typeassert or decl based on whether it's in
-             ;; value or statement position.
-             (to-lff `(typeassert ,@(cdr e)) dest tail)
-             (to-lff `(decl ,@(cdr e)) dest tail)))
-
-        ((unnecessary-tuple)
-         (if dest
-             (to-lff (cadr e) dest tail)
-             ;; remove if not in value position
-             (to-lff '(null) dest tail)))
-
-        ((method)
-         (if (and dest (not tail))
-             (let ((ex (to-lff (method-expr-name e) dest tail))
-                   (fu (to-lff e #f #f)))
-               (cons (car ex)
-                     (append fu (cdr ex))))
-             (map-to-lff e dest tail)))
-
-        ((module)
-	 (cons e '()))
-
-        ((symbolicgoto symboliclabel)
-         (cons (if tail '(return (null)) '(null))
-               (map-to-lff e #f #f)))
-
-        (else
-         (map-to-lff e dest tail)))))
-
-#|
-future issue:
-right now scope blocks need to be inside functions:
-
-> (julia-expand '(block (call + 1 (scope-block (block (= a b) c)))))
-(block (scope-block (local a) (local #:g13) (block (= a b) (= #:g13 c)))
-       (return (call + 1 #:g13)))
-
-> (julia-expand '(scope-block (call + 1 (scope-block (block (= a b) c)))))
-(scope-block
- (local #:g15)
- (block (scope-block (local a) (block (= a b) (= #:g15 c)))
-        (return (call + 1 #:g15))))
-
-The first one gave something broken, but the second case works.
-So far only the second case can actually occur.
-|#
+;; pass 2: identify and rename local vars
 
 (define (check-dups locals)
   (if (and (pair? locals) (pair? (cdr locals)))
@@ -2628,17 +2161,20 @@ So far only the second case can actually occur.
   (if (or (not (pair? e)) (quoted? e))
       '()
       (case (car e)
-        ((lambda scope-block module)  '())
+        ((lambda scope-block module toplevel)  '())
         ((method)
          (let ((v (decl-var (method-expr-name e))))
-           (if (or (not (symbol? v)) (memq v env))
-               '()
-               (list v))))
+           (append!
+            (if (length= e 2) '() (find-assigned-vars (caddr e) env))
+            (if (or (not (symbol? v)) (memq v env))
+                '()
+                (list v)))))
         ((=)
-         (let ((v (decl-var (cadr e))))
+         (let ((v (decl-var (cadr e)))
+               (rest (find-assigned-vars (caddr e) env)))
            (if (or (jlgensym? v) (memq v env))
-               '()
-               (list v))))
+               rest
+               (cons v rest))))
         (else
          (apply append! (map (lambda (x) (find-assigned-vars x env))
                              e))))))
@@ -2646,7 +2182,7 @@ So far only the second case can actually occur.
 (define (find-decls kind e)
   (if (or (not (pair? e)) (quoted? e))
       '()
-      (cond ((memq (car e) '(lambda scope-block module))
+      (cond ((memq (car e) '(lambda scope-block module toplevel))
              '())
             ((eq? (car e) kind)
              (list (decl-var (cadr e))))
@@ -2655,7 +2191,6 @@ So far only the second case can actually occur.
                                  e))))))
 
 (define (find-local-decls  e) (find-decls 'local  e))
-(define (find-local!-decls e) (find-decls 'local! e))
 (define (find-global-decls e) (find-decls 'global e))
 
 (define (find-locals e env glob)
@@ -2663,306 +2198,174 @@ So far only the second case can actually occur.
    (append! (check-dups (find-local-decls e))
             ;; const decls on non-globals also introduce locals
             (diff (find-decls 'const e) glob)
-            (find-local!-decls e)
             (find-assigned-vars e env))))
 
-(define (remove-local-decls e)
-  (cond ((or (not (pair? e)) (quoted? e)) e)
-        ((or (eq? (car e) 'scope-block) (eq? (car e) 'lambda)) e)
-        ((eq? (car e) 'block)
-         (map remove-local-decls
-              (filter (lambda (x) (not (and (pair? x) (eq? (car x) 'local))))
-                      e)))
-        (else
-         (map remove-local-decls e))))
+(define (occurs-outside? sym e excl)
+  (cond ((eq? e sym) #t)
+        ((not (pair? e)) #f)
+        ((eq? e excl) #f)
+        ((memq (car e) '(lambda module toplevel quote top line inert)) #f)
+        (else (any (lambda (x) (occurs-outside? sym x excl))
+                   (cdr e)))))
 
-;; local variable identification
-;; convert (scope-block x) to `(scope-block ,@locals ,x)
-;; where locals is a list of (local x) expressions, derived from two sources:
+;; local variable identification and renaming, derived from:
 ;; 1. (local x) expressions inside this scope-block and lambda
 ;; 2. (const x) expressions in a scope-block where x is not declared global
 ;; 3. variables assigned inside this scope-block that don't exist in outer
 ;;    scopes
-(define (add-local-decls e env implicitglobals)
-  (if (or (not (pair? e)) (quoted? e)) e
-      (cond ((eq? (car e) 'lambda)
-             (let* ((env (append (lam:vars e) env))
-                    (body (add-local-decls (caddr e) env
-					   ;; don't propagate implicit globals
-					   ;; issue #7234
-					   '())))
-               (list 'lambda (cadr e) body)))
-
-            ((eq? (car e) 'scope-block)
-             (let* ((iglo (find-decls 'implicit-global (cadr e)))
-		    (glob (diff (find-global-decls (cadr e)) iglo))
-                    (vars (find-locals
-                           ;; being declared global prevents a variable
-                           ;; assignment from introducing a local
-                           (cadr e)
-			   (append env glob implicitglobals iglo)
-			   (append glob iglo)))
-                    (body (add-local-decls (cadr e)
-					   (append vars glob env)
-					   (append iglo implicitglobals)))
-		    (lineno (if (and (length> body 1)
-				     (pair? (cadr body))
-                                     (eq? 'line (car (cadr body))))
-                                (list (cadr body))
-                                '()))
-                    (body (if (null? lineno)
-                              body
-                              `(,(car body) ,@(cddr body)))))
-               (for-each (lambda (v)
-                           (if (memq v vars)
-                               (error (string "variable \"" v "\" declared both local and global"))))
-                         glob)
-               `(scope-block ,@lineno
-                             ;; place local decls after initial line node
-                             ,.(map (lambda (v) `(local ,v))
-                                    vars)
-                             ,(remove-local-decls body))))
-
-	    ((eq? (car e) 'module)
-	     (error "module expression not at top level"))
-
-            (else
-             ;; form (local! x) adds a local to a normal (non-scope) block
-             (let ((newenv (append (declared-local!-vars e) env)))
-               (map (lambda (x)
-                      (add-local-decls x newenv implicitglobals))
-                    e))))))
-
-(define (identify-locals e) (add-local-decls e '() '()))
-
-(define (declared-local-vars e)
-  (map (lambda (x) (decl-var (cadr x)))
-       (filter (lambda (x)
-                 (and (pair? x)
-                      (or (eq? (car x) 'local)
-                          (eq? (car x) 'local!))))
-               (cdr e))))
-(define (declared-local!-vars e)
-  (map cadr
-       (filter (lambda (x)
-                 (and (pair? x)
-                      (eq? (car x) 'local!)))
-               (cdr e))))
-
-(define (without alst remove)
-  (cond ((null? alst)               '())
-        ((null? remove)             alst)
-        ((memq (caar alst) remove)  (without (cdr alst) remove))
-        (else                       (cons (car alst)
-                                          (without (cdr alst) remove)))))
-
-; e - expression
-; renames - assoc list of (oldname . newname)
-; this works on any tree format after identify-locals
-(define (rename-vars e renames)
-  (cond ((null? renames)  e)
-        ((symbol? e)      (lookup e renames e))
-        ((not (pair? e))  e)
-        ((quoted? e)      e)
-        (else
-         (let (; remove vars bound by current expr from rename list
-               (new-renames
-                (without renames
-                         (case (car e)
-                           ((lambda)
-                            (append (lambda-all-vars e)
-                                    (find-global-decls (cadddr e))))
-                           ((scope-block)
-                            (append (declared-local-vars e)
-                                    (find-global-decls (cadr e))))
-                           (else '())))))
-           (cons (car e)
-                 (map (lambda (x)
-                        (rename-vars x new-renames))
-                      (cdr e)))))))
-
-;; all vars used in e outside x
-(define (vars-used-outside e x)
-  (table.keys (free-vars- e (table) x)))
-
-(define (flatten-lambda-scopes e)
-  (cond ((or (atom? e) (quoted? e)) e)
-        ((eq? (car e) 'lambda) (flatten-scopes e))
-        (else (map flatten-lambda-scopes e))))
-
-;; remove (scope-block) and (local), convert lambdas to the form
-;; (lambda (argname...) (locals var...) body)
-(define (flatten-scopes e)
-  (define scope-block-vars '())
-  (define (remove-scope-blocks e context usedv)
-    (cond ((or (atom? e) (quoted? e)) e)
-          ((eq? (car e) 'lambda) e)
-          ((eq? (car e) 'scope-block)
-           (let ((vars (declared-local-vars e))
-                 (body (cons 'block (cdr e))));(car (last-pair e))))
-             (let* ((outer    (append usedv (vars-used-outside context e)))
-                    ;; only rename conflicted vars
-                    (to-ren   (filter (lambda (v) (memq v outer)) vars))
-                    (newnames (map named-gensy to-ren))
-                    (bod      (rename-vars (remove-scope-blocks body e outer)
-                                           (map cons to-ren newnames))))
-               (set! scope-block-vars (nconc newnames scope-block-vars))
-               (set! scope-block-vars (nconc (diff vars to-ren)
-                                             scope-block-vars))
-               bod)))
-          (else (map (lambda (e) (remove-scope-blocks e context usedv))
-                     e))))
-
-  (cond ((not (pair? e))   e)
-        ((quoted? e)       e)
-        ((eq? (car e)      'lambda)
-         (let* ((argnames  (lam:vars e))
-                (body      (caddr e))
-                (body2     (flatten-lambda-scopes body))
-                (r-s-b     (remove-scope-blocks body2 body2 argnames)))
+;; returns lambdas in the form (lambda (args...) (locals...) body)
+(define (resolve-scopes- e env implicitglobals lam renames newlam)
+  (cond ((symbol? e) (let ((r (assq e renames)))
+                       (if r (cdr r) e)))
+        ((or (not (pair? e)) (quoted? e) (eq? (car e) 'toplevel)) e)
+        ((eq? (car e) 'local) '(null)) ;; remove local decls
+        ((eq? (car e) 'lambda)
+         (let* ((lv (lam:vars e))
+                (env (append lv env))
+                (body (resolve-scopes- (lam:body e) env
+                                       ;; don't propagate implicit globals
+                                       ;; issue #7234
+                                       '()
+                                       e
+                                       (filter (lambda (ren) (not (memq (car ren) lv)))
+                                               renames)
+                                       #t)))
+           `(lambda ,(cadr e) ,(caddr e) ,body)))
+        ((eq? (car e) 'scope-block)
+         (let* ((blok (cadr e))
+                (other-locals (if lam (caddr lam) '()))
+                (iglo (find-decls 'implicit-global blok))
+                (glob (diff (find-global-decls blok) iglo))
+                (vars (find-locals
+                       blok
+                       ;; being declared global prevents a variable
+                       ;; assignment from introducing a local
+                       (append env glob implicitglobals iglo)
+                       (append glob iglo)))
+                (need-rename
+                 (if (or newlam (not lam)) '()
+                     (receive
+                      (conflicted unknown)
+                      (separate (lambda (v) (or (memq v env) (memq v other-locals)))
+                                vars)
+                      (append
+                       conflicted
+                       (let ((lbod (lam:body lam)))
+                         (filter (lambda (v) (occurs-outside? v lbod e))
+                                 unknown))))))
+                (renamed (map named-gensy need-rename))
+                (new-ren (append (map cons need-rename renamed)
+                                 (filter (lambda (ren)
+                                           (not (memq (car ren) vars)))
+                                         renames)))
+                (new-env (append vars glob env))
+                (new-iglo (append iglo implicitglobals))
+                (body (resolve-scopes- blok new-env new-iglo lam new-ren #f))
+                (lineno (if (and (length> body 1)
+                                 (pair? (cadr body))
+                                 (eq? 'line (car (cadr body))))
+                            (list (cadr body))
+                            '()))
+                (real-new-vars (append (diff vars need-rename) renamed)))
            (for-each (lambda (v)
-                       (if (memq v argnames)
-                           (error (string "local \"" v "\" conflicts with argument"))))
-                     (declared-local-vars body))
-           `(lambda ,(cadr e)
-              (locals ,@scope-block-vars)
-              ,r-s-b)))
-        (else (map (lambda (x) (if (not (pair? x)) x
-                                   (flatten-scopes x)))
-                   e))))
-
-(define (has-unmatched-symbolic-goto? e)
-  (let ((label-refs (table))
-        (label-defs (table)))
-    (find-symbolic-label-refs e label-refs)
-    (find-symbolic-label-defs e label-defs)
-    (any not (map (lambda (k) (get label-defs k #f))
-                  (table.keys label-refs)))))
-
-(define (symbolic-label-handler-levels e levels handler-level)
-  (if (or (not (pair? e)) (quoted? e))
-      '()
-      (case (car e)
-        ((trycatch)
-         (symbolic-label-handler-levels (cadr e) levels (+ handler-level 1)))
-        ((symboliclabel)
-         (put! levels (cadr e) handler-level))
+                       (if (memq v vars)
+                           (error (string "variable \"" v "\" declared both local and global"))))
+                     glob)
+           (if lam
+               (set-car! (cddr lam)
+                         (append real-new-vars (caddr lam))))
+           `(block
+             ,@lineno
+             ,@(map (lambda (v) `(local ,v))
+                    real-new-vars)
+             ,@(if (and (pair? body) (eq? (car body) 'block))
+                   (if (null? lineno)
+                       (cdr body)
+                       (cddr body))
+                   (list body)))))
+        ((eq? (car e) 'module)
+         (error "module expression not at top level"))
         (else
-         (map (lambda (x) (symbolic-label-handler-levels x levels handler-level)) e)))))
-
-(define (find-symbolic-label-defs e tbl)
-  (if (or (not (pair? e)) (quoted? e))
-      '()
-      (if (eq? (car e) 'symboliclabel)
-          (put! tbl (cadr e) #t)
-          (map (lambda (x) (find-symbolic-label-defs x tbl)) e))))
-
-(define (find-symbolic-label-refs e tbl)
-  (if (or (not (pair? e)) (quoted? e))
-      '()
-      (if (eq? (car e) 'symbolicgoto)
-          (put! tbl (cadr e) #t)
-          (map (lambda (x) (find-symbolic-label-refs x tbl)) e))))
-
-(define (find-symbolic-labels e)
-  (let ((defs (table))
-        (refs (table)))
-    (find-symbolic-label-defs e defs)
-    (find-symbolic-label-refs e refs)
-    (table.foldl
-     (lambda (label v labels)
-       (if (has? refs label)
-           (cons label labels)
-           labels))
-     '() defs)))
-
-(define (rename-symbolic-labels- e relabel)
-  (cond
-   ((or (not (pair? e)) (quoted? e)) e)
-   ((eq? (car e) 'symbolicgoto)
-    (let ((newlabel (assq (cadr e) relabel)))
-      (if newlabel `(symbolicgoto ,(cdr newlabel)) e)))
-   ((eq? (car e) 'symboliclabel)
-    (let ((newlabel (assq (cadr e) relabel)))
-      (if newlabel `(symboliclabel ,(cdr newlabel)) e)))
-   (else (map (lambda (x) (rename-symbolic-labels- x relabel)) e))))
-
-(define (rename-symbolic-labels e)
-  (let* ((labels (find-symbolic-labels e))
-         (relabel (pair-with-gensyms labels)))
-    (rename-symbolic-labels- e relabel)))
-
-(define (max-jlgensym e)
-  (if (or (not (pair? e)) (quoted? e))
-      -1
-      (if (jlgensym? e) (cadr e)
-          (foldl (lambda (x l) (max (max-jlgensym x) l)) -1 e))))
+         (cons (car e)
+               (map (lambda (x)
+                      (resolve-scopes- x env implicitglobals lam renames #f))
+                    (cdr e))))))
 
-(define (renumber-jlgensym- e tbl next-jlgensym)
-  (cond
-   ((or (not (pair? e)) (quoted? e)) e)
-   ((jlgensym? e)
-      (let ((n (get tbl (cadr e) #f)))
-        (if n n
-          (let ((n (next-jlgensym))) (put! tbl (cadr e) n) n))))
-   (else (map (lambda (x) (renumber-jlgensym- x tbl next-jlgensym)) e))))
+(define (resolve-scopes e) (resolve-scopes- e '() '() #f '() #f))
 
-(define (renumber-jlgensym e)
-  (let ((jlgensym-counter 0))
-    (define (next-jlgensym)
-      (begin0 `(jlgensym ,jlgensym-counter)
-              (set! jlgensym-counter (+ 1 jlgensym-counter))))
-    (renumber-jlgensym- e (table) next-jlgensym)))
-
-(define (make-var-info name) (list name 'Any 0))
-(define vinfo:name car)
-(define vinfo:type cadr)
-(define (vinfo:set-type! v t) (set-car! (cdr v) t))
-
-(define (vinfo:capt v) (< 0 (logand (caddr v) 1)))
-(define (vinfo:asgn v) (< 0 (logand (caddr v) 2)))
-(define (vinfo:const v) (< 0 (logand (caddr v) 8)))
-(define (set-bit x b val) (if val (logior x b) (logand x (lognot b))))
-;; record whether var is captured
-(define (vinfo:set-capt! v c)  (set-car! (cddr v) (set-bit (caddr v) 1 c)))
-;; whether var is assigned
-(define (vinfo:set-asgn! v a)  (set-car! (cddr v) (set-bit (caddr v) 2 a)))
-;; whether var is assigned by an inner function
-(define (vinfo:set-iasg! v a)  (set-car! (cddr v) (set-bit (caddr v) 4 a)))
-;; whether var is const
-(define (vinfo:set-const! v a) (set-car! (cddr v) (set-bit (caddr v) 8 a)))
-;; whether var is assigned once
-(define (vinfo:set-sa! v a)    (set-car! (cddr v) (set-bit (caddr v) 16 a)))
-;; occurs undef: mask 32
-
-(define var-info-for assq)
+;; pass 3: analyze variables
 
+;; names of arguments and local vars
 (define (lambda-all-vars e)
-  (append (lam:vars e)
-          (cdr (caddr e))))
+  (append (lam:vars e) (caddr e)))
 
-(define (free-vars- e tab excl)
-  (cond ((symbol? e) (put! tab e #t))
+;; compute set of variables referenced in a lambda but not bound by it
+(define (free-vars- e tab)
+  (cond ((or (eq? e 'true) (eq? e 'false) (eq? e UNUSED)) tab)
+        ((symbol? e) (put! tab e #t))
         ((or (atom? e) (quoted? e)) tab)
-        ((eq? e excl) tab)
         ((eq? (car e) 'lambda)
          (let ((bound (lambda-all-vars e)))
            (for-each (lambda (v) (if (not (memq v bound)) (put! tab v #t)))
                      (free-vars (lam:body e))))
          tab)
         (else
-         (for-each (lambda (x) (free-vars- x tab excl))
+         (for-each (lambda (x) (free-vars- x tab))
                    (cdr e))
          tab)))
 
-(define *free-vars-secret-value* (list 0))
 (define (free-vars e)
-  (table.keys (free-vars- e (table) *free-vars-secret-value*)))
-
-(define (caddddr x) (car (cdr (cdr (cdr (cdr x))))))
-; convert each lambda's (locals ...) to
-;   ((localvars...) var-info-lst captured-var-infos)
-; where var-info-lst is a list of var-info records
+  (table.keys (free-vars- e (table))))
+
+(define (analyze-vars-lambda e env captvars sp new-sp)
+  (let* ((args (filter (lambda (v) (not (eq? (arg-name v) UNUSED)))
+                       (lam:args e)))
+         (locl (caddr e))
+         (allv (nconc (map arg-name args) locl))
+         (fv   (let* ((fv (diff (free-vars (lam:body e)) allv))
+                      ;; add variables referenced in declared types for free vars
+                      (dv (apply nconc (map (lambda (v)
+                                              (let ((vi (var-info-for v env)))
+                                                (if vi (free-vars (vinfo:type vi)) '())))
+                                            fv))))
+                 (append (diff dv fv) fv)))
+         (glo  (find-global-decls (lam:body e)))
+         ;; make var-info records for vars introduced by this lambda
+         (vi   (nconc
+                (map (lambda (decl) (make-var-info (decl-var decl)))
+                     args)
+                (map make-var-info locl)))
+         (capt-sp (filter (lambda (v) (and (memq v fv) (not (memq v glo))))
+                          sp))
+         ;; captured vars: vars from the environment that occur
+         ;; in our set of free variables (fv).
+         (cv    (append (filter (lambda (v) (and (memq (vinfo:name v) fv)
+                                                 (not (memq (vinfo:name v) new-sp))
+                                                 (not (memq (vinfo:name v) glo))))
+                                env)
+                        (map make-var-info capt-sp))))
+    (analyze-vars (lam:body e)
+                  (append vi
+                          ;; new environment: add our vars
+                          (filter (lambda (v)
+                                    (and (not (memq (vinfo:name v) allv))
+                                         (not (memq (vinfo:name v) glo))))
+                                  env))
+                  cv (delete-duplicates (append new-sp sp)))
+    ;; mark all the vars we capture as captured
+    (for-each (lambda (v) (vinfo:set-capt! v #t))
+              cv)
+    (set-car! (cddr e)
+              `(,vi ,cv 0 ,(delete-duplicates (append new-sp capt-sp))))
+    e))
+
+;; this pass records information about variables used by closure conversion.
+;; finds which variables are assigned or captured, and records variable
+;; type declarations.
+;; this info is recorded by setting the second argument of `lambda` expressions
+;; in-place to
+;;   (var-info-lst captured-var-infos gensyms static_params)
+;; where var-info-lst is a list of var-info records
 (define (analyze-vars e env captvars sp)
   (if (or (atom? e) (quoted? e))
       e
@@ -2974,21 +2377,17 @@ So far only the second case can actually occur.
                  (if (vinfo:asgn vi)
                      (vinfo:set-sa! vi #f)
                      (vinfo:set-sa! vi #t))
-                 (vinfo:set-asgn! vi #t)
-                 (if (assq (car vi) captvars)
-                     (vinfo:set-iasg! vi #t)))))
-         `(= ,(cadr e) ,(analyze-vars (caddr e) env captvars sp)))
-        #;((or (eq? (car e) 'local) (eq? (car e) 'local!))
-         '(null))
-        ((typeassert)
-         ;(let ((vi (var-info-for (cadr e) env)))
-         ;  (if vi
-         ;      (begin (vinfo:set-type! vi (caddr e))
-         ;           (cadr e))
-         `(call (top typeassert) ,(cadr e) ,(caddr e)))
-        ((decl |::|)
-         ; handle var::T declaration by storing the type in the var-info
-         ; record. for non-symbols or globals, emit a type assertion.
+                 (vinfo:set-asgn! vi #t))))
+         (analyze-vars (caddr e) env captvars sp))
+        ((call)
+         (let ((vi (var-info-for (cadr e) env)))
+           (if vi
+               (vinfo:set-called! vi #t))
+           (for-each (lambda (x) (analyze-vars x env captvars sp))
+                     (cdr e))))
+        ((decl)
+         ;; handle var::T declaration by storing the type in the var-info
+         ;; record. for non-symbols or globals, emit a type assertion.
          (let ((vi (var-info-for (cadr e) env)))
            (if vi
                (begin (if (not (eq? (vinfo:type vi) 'Any))
@@ -2997,120 +2396,486 @@ So far only the second case can actually occur.
                       (if (assq (cadr e) captvars)
                           (error (string "type of \"" (cadr e)
                                          "\" declared in inner scope")))
-                      (vinfo:set-type! vi (caddr e))
-                      '(null))
-               `(call (top typeassert) ,(cadr e) ,(caddr e)))))
+                      (vinfo:set-type! vi (caddr e))))))
         ((lambda)
-         (let* ((args (lam:args e))
-                (locl (cdr (caddr e)))
-                (allv (nconc (map arg-name args) locl))
-                (fv   (let* ((fv (diff (free-vars (lam:body e)) allv))
-                             ;; add variables referenced in declared types for free vars
-                             (dv (apply nconc (map (lambda (v)
-                                                     (let ((vi (var-info-for v env)))
-                                                       (if vi (free-vars (vinfo:type vi)) '())))
-                                                   fv))))
-                        (append (diff dv fv) fv)))
-                (glo  (find-global-decls (lam:body e)))
-                ;; make var-info records for vars introduced by this lambda
-                (vi   (nconc
-                       (map (lambda (decl) (make-var-info (decl-var decl)))
-                            args)
-                       (map make-var-info locl)))
-                ;; captured vars: vars from the environment that occur
-                ;; in our set of free variables (fv).
-                (cv    (filter (lambda (v) (and (memq (vinfo:name v) fv)
-                                                (not (memq
-                                                      (vinfo:name v) glo))))
-                               env))
-                ;; count of GenSym references in this function (or an array of their types)
-                (gensym_types (+ (max-jlgensym (lam:body e)) 1))
-                (bod   (analyze-vars
-                        (lam:body e)
-                        (append vi
-                                ;; new environment: add our vars
-                                (filter (lambda (v)
-                                          (and
-                                           (not (memq (vinfo:name v) allv))
-                                           (not (memq (vinfo:name v) glo))))
-                                        env))
-                        cv sp)))
-           ;; mark all the vars we capture as captured
-           (for-each (lambda (v) (vinfo:set-capt! v #t))
-                     cv)
-           `(lambda ,args
-              (,vi ,cv ,gensym_types ,sp)
-              ,bod)))
-        ((localize)
-         ;; special feature for @spawn that wraps a piece of code in a "let"
-         ;; binding each free variable.
-         (let ((env-vars (map vinfo:name env))
-               (localize-vars (cddr e)))
-           (let ((vs (filter
-                      (lambda (v) (or (memq v localize-vars)
-                                      (memq v env-vars)))
-                      (free-vars (cadr e)))))
-             (analyze-vars
-              `(call (lambda ,vs ,(caddr (cadr e)) ,(cadddr (cadr e)))
-                     ,@vs)
-              env captvars sp))))
-	((with-static-parameters)
-	 ;; (with-static-parameters func_expr sp_1 sp_2 ...)
-	 (analyze-vars (cadr e) env captvars
-		       (delete-duplicates (append sp (cddr e)))))
+         (analyze-vars-lambda e env captvars sp '()))
+        ((with-static-parameters)
+         ;; (with-static-parameters func_expr sp_1 sp_2 ...)
+         (assert (eq? (car (cadr e)) 'lambda))
+         (analyze-vars-lambda (cadr e) env captvars sp
+                              (cddr e)))
         ((method)
          (let ((vi (var-info-for (method-expr-name e) env)))
            (if vi
-               (begin
-                 (vinfo:set-asgn! vi #t)
-                 ;; note: method defs require a memory loc. (issue #7658)
-                 (vinfo:set-sa! vi #f)
-                 (if (assq (car vi) captvars)
-                     (vinfo:set-iasg! vi #t)))))
-	 (if (length= e 2)
-	     `(method ,(cadr e))
-	     `(method ,(cadr e)
-		      ,(analyze-vars (caddr  e) env captvars sp)
-		      ,(analyze-vars (cadddr e) env captvars
-				     (delete-duplicates
-				      (append sp (method-expr-static-parameters e))))
-		      ,(caddddr e))))
-	((module) e)
-        (else (cons (car e)
-                    (map (lambda (x) (analyze-vars x env captvars sp))
-                         (cdr e)))))))
-
-(define (analyze-variables e) (analyze-vars e '() '() '()))
-
-(define (not-bool e)
-  (cond ((memq e '(true #t))  'false)
-        ((memq e '(false #f)) 'true)
-        (else                 `(call (top !) ,e))))
-
-;; remove if, _while, block, break-block, and break
-;; replaced with goto and gotoifnot
-;; TODO: remove type-assignment-affecting expressions from conditional branch.
-;;       needed because there's no program location after the condition
-;;       is evaluated but before the branch's successors.
-;;       pulling a complex condition out to a temporary variable creates
-;;       such a location (the assignment to the variable).
-(define (goto-form e)
+               (begin (vinfo:set-asgn! vi #t)
+                      ;; note: method defs require a memory loc. (issue #7658)
+                      (vinfo:set-sa! vi #f))))
+         (if (length= e 2)
+             e
+             (begin (analyze-vars (caddr e) env captvars sp)
+                    (assert (eq? (car (cadddr e)) 'lambda))
+                    (analyze-vars-lambda (cadddr e) env captvars sp
+                                         (method-expr-static-parameters e)))))
+        ((module toplevel) e)
+        (else (for-each (lambda (x) (analyze-vars x env captvars sp))
+                        (cdr e))))))
+
+(define (analyze-variables! e) (analyze-vars e '() '() '()) e)
+
+;; pass 4: closure conversion
+
+;; this pass lifts all inner functions to the top level by generating
+;; a type for them. for example `f(x) = y->(y+x)` is converted to
+#|
+immutable yt{T}
+    x::T
+end
+
+(self::yt)(y) = y + self.x
+
+f(x) = yt(x)
+|#
+
+;; template for generating a closure type with parameters
+(define (type-for-closure-parameterized name P fields types super)
+  (let ((n (length P)))
+    `(thunk
+      (lambda ()
+        ((,@(map (lambda (p) `(,p Any 18)) P))
+         () 0 ())
+        (body (global ,name) (const ,name)
+              ,@(map (lambda (p) `(= ,p (call (top TypeVar) ',p (top Any) true))) P)
+              (composite_type ,name (call (top svec) ,@P)
+                              (call (top svec) ,@(map (lambda (v) `',v) fields))
+                              ,super
+                              (call (top svec) ,@types) #f ,(length fields))
+              (return (null)))))))
+
+;; ... and without parameters
+(define (type-for-closure name fields super)
+  `(thunk (lambda ()
+            (() () 0 ())
+            (body (global ,name) (const ,name)
+                  (composite_type ,name (call (top svec))
+                                  (call (top svec) ,@(map (lambda (v) `',v) fields))
+                                  ,super
+                                  (call (top svec) ,@(map (lambda (v) 'Any) fields))
+                                  #f ,(length fields))
+                  (return (null))))))
+
+(define (vinfo:not-capt vi)
+  (list (car vi) (cadr vi) (logand (caddr vi) (lognot 5))))
+
+(define (clear-capture-bits vinfos)
+  (map vinfo:not-capt vinfos))
+
+(define (convert-lambda lam fname interp capt-sp)
+  `(lambda ,(lam:args lam)
+     (,(clear-capture-bits (car (lam:vinfo lam)))
+      ()
+      ,(caddr (lam:vinfo lam))
+      ,(delete-duplicates (append (lam:sp lam) capt-sp)))
+     ,(add-box-inits-to-body
+       lam
+       (cl-convert (cadddr lam) fname lam (table) #f interp))))
+
+(define (convert-for-type-decl rhs t)
+  (if (eq? t 'Any)
+      rhs
+      `(call (top typeassert)
+             (call (top convert) ,t ,rhs)
+             ,t)))
+
+;; convert assignment to a closed variable to a setfield! call.
+;; while we're at it, generate `convert` calls for variables with
+;; declared types.
+;; when doing this, the original value needs to be preserved, to
+;; ensure the expression `a=b` always returns exactly `b`.
+(define (convert-assignment var rhs0 fname lam interp)
+  (let* ((vi (assq var (car  (lam:vinfo lam))))
+         (cv (assq var (cadr (lam:vinfo lam))))
+         (vt  (or (and vi (vinfo:type vi))
+                  (and cv (vinfo:type cv))
+                  'Any))
+         (closed (and cv (vinfo:asgn cv) (vinfo:capt cv)))
+         (capt   (and vi (vinfo:asgn vi) (vinfo:capt vi))))
+    (if (and (not closed) (not capt) (eq? vt 'Any))
+        `(= ,var ,rhs0)
+        (let* ((rhs1 (if (or (jlgensym? rhs0) (simple-atom? rhs0)
+                             (equal? rhs0 '(the_exception)))
+                         rhs0
+                         (make-jlgensym)))
+               (rhs  (if (eq? vt 'Any)
+                         rhs1
+                         (convert-for-type-decl rhs1 (cl-convert vt fname lam #f #f interp))))
+               (ex (cond (closed `(call (top setfield!)
+                                        ,(if interp
+                                             `($ ,var)
+                                             `(call (top getfield) ,fname (inert ,var)))
+                                        (inert contents)
+                                        ,rhs))
+                         (capt `(call (top setfield!) ,var (inert contents) ,rhs))
+                         (else `(= ,var ,rhs)))))
+          (if (eq? rhs1 rhs0)
+              `(block ,ex ,rhs0)
+              `(block (= ,rhs1 ,rhs0)
+                      ,ex
+                      ,rhs1))))))
+
+;; replace leading (function) argument type with `typ`
+(define (fix-function-arg-type te typ iskw namemap type-sp)
+  (let* ((typapp (caddr te))
+         (types  (pattern-replace
+                  (pattern-set
+                   (pattern-lambda (call (call (top (-/ getfield)) (-/ Core) (quote (-/ Typeof))) name)
+                                   (get namemap name __)))
+                  (cdddr typapp)))
+         (closure-type (if (null? type-sp)
+                           typ
+                           `(call (top apply_type) ,typ ,@type-sp)))
+         (newtypes
+          (if iskw
+              `(,(car types) ,(cadr types) ,closure-type ,@(cdddr types))
+              `(,closure-type ,@(cdr types)))))
+    `(call (top svec) (call (top apply_type) Tuple ,@newtypes)
+           (call (top svec) ,@(append (cddr (cadddr te)) type-sp)))))
+
+;; collect all toplevel-butlast expressions inside `e`, and return
+;; (ex . stmts), where `ex` is the expression to evaluated and
+;; `stmts` is a list of statements to move to the top level.
+;; TODO: this implementation seems quite inefficient.
+(define (lift-toplevel e)
+  (if (atom? e) (cons e '())
+      (let* ((rec (map lift-toplevel e))
+             (e2  (map car rec))
+             (tl  (apply append (map cdr rec))))
+        (if (eq? (car e) 'toplevel-butlast)
+            (cons (last e2) (append tl (butlast (cdr e2))))
+            (cons e2 tl)))))
+
+(define (add-box-inits-to-body lam body)
+  (let ((args (map arg-name (lam:args lam)))
+        (vis  (car (lam:vinfo lam)))
+        (lnos (take-while (lambda (x) (and (pair? x) (eq? (car x) 'line)))
+                          (cdr body))))
+    ;; insert Box allocations for captured/assigned arguments
+    `(,(car body)
+      ,@lnos
+      ,@(apply append
+               (map (lambda (arg)
+                      (let ((vi (assq arg vis)))
+                        (if (and vi (vinfo:asgn vi) (vinfo:capt vi))
+                            `((= ,arg (call (top Box) ,arg)))
+                            '())))
+                    args))
+      ,@(list-tail body (+ 1 (length lnos))))))
+
+;; clear capture bit for vars assigned once at the top, to avoid allocating
+;; some unnecessary Boxes.
+(define (lambda-optimize-vars! lam)
+  (define (expr-uses-var ex v)
+    (cond ((assignment? ex) (expr-contains-eq v (caddr ex)))
+          ((eq? (car ex) 'method)
+           (and (length> ex 2)
+                (assq v (cadr (lam:vinfo (cadddr ex))))))
+          (else #f)))
+  (assert (eq? (car lam) 'lambda))
+  (let ((vi (car (lam:vinfo lam))))
+    (if (and (any vinfo:capt vi)
+             (any vinfo:sa vi))
+        (let* ((leading
+                (filter (lambda (x) (and (pair? x) (or (eq? (car x) 'method)
+                                                       (eq? (car x) '=))))
+                        (take-while (lambda (e)
+                                      (or (atom? e)
+                                          (memq (car e) '(quote top line inert local
+                                                                implicit-global global
+                                                                const newvar = null method))))
+                                    (lam:body lam))))
+               (unused (map cadr leading))
+               (def (table)))
+          ;; TODO: reorder leading statements to put assignments where the RHS is
+          ;; `simple-atom?` at the top.
+          (for-each (lambda (e)
+                      (set! unused (filter (lambda (v) (not (expr-uses-var e v)))
+                                           unused))
+                      (if (memq (cadr e) unused)
+                          (put! def (cadr e) #t)))
+                    leading)
+          (for-each (lambda (v)
+                      (if (and (vinfo:sa v) (has? def (car v)))
+                          (set-car! (cddr v) (logand (caddr v) (lognot 5)))))
+                    vi)))
+    lam))
+
+(define (is-var-boxed? v lam)
+  (or (let ((vi (assq v (car (lam:vinfo lam)))))
+        (and vi (vinfo:asgn vi) (vinfo:capt vi)))
+      (let ((cv (assq v (cadr (lam:vinfo lam)))))
+        (and cv (vinfo:asgn cv) (vinfo:capt cv)))))
+
+(define (toplevel-preserving? e)
+  (and (pair? e) (memq (car e) '(if block body trycatch))))
+
+(define (map-cl-convert exprs fname lam namemap toplevel interp)
+  (if toplevel
+      (map (lambda (x)
+             (let ((tl (lift-toplevel (cl-convert x fname lam namemap
+                                                  (and toplevel (toplevel-preserving? x))
+                                                  interp))))
+               (if (null? (cdr tl))
+                   (car tl)
+                   `(block ,@(cdr tl) ,(car tl)))))
+           exprs)
+      (map (lambda (x) (cl-convert x fname lam namemap #f interp)) exprs)))
+
+(define (cl-convert e fname lam namemap toplevel interp)
+  (if (and (not lam)
+           (not (and (pair? e) (memq (car e) '(lambda method macro)))))
+      (if (atom? e) e
+          (cons (car e) (map-cl-convert (cdr e) fname lam namemap toplevel interp)))
+      (cond
+       ((symbol? e)
+        (let ((vi (assq e (car  (lam:vinfo lam))))
+              (cv (assq e (cadr (lam:vinfo lam)))))
+          (cond ((eq? e fname) e)
+                ((memq e (lam:sp lam)) e)
+                (cv
+                 (let ((access (if interp
+                                   `($ (call (top QuoteNode) ,e))
+                                   `(call (top getfield) ,fname (inert ,e)))))
+                   (if (and (vinfo:asgn cv) (vinfo:capt cv))
+                       `(call (top getfield) ,access (inert contents))
+                       access)))
+                (vi
+                 (if (and (vinfo:asgn vi) (vinfo:capt vi))
+                     `(call (top getfield) ,e (inert contents))
+                     e))
+                (else e))))
+       ((atom? e) e)
+       (else
+        (case (car e)
+          ((quote top line break inert module toplevel null meta) e)
+          ((=)
+           (let ((var (cadr e))
+                 (rhs (cl-convert (caddr e) fname lam namemap toplevel interp)))
+             (if (jlgensym? var)
+                 `(= ,var ,rhs)
+                 (convert-assignment var rhs fname lam interp))))
+          ((newvar)
+           (let ((vi (assq (cadr e) (car (lam:vinfo lam)))))
+             (if (and vi (vinfo:asgn vi) (vinfo:capt vi))
+                 `(= ,(cadr e) (call (top Box)))
+                 e)))
+          ((local)
+           (let ((vi (assq (cadr e) (car (lam:vinfo lam)))))
+             (if (and vi (vinfo:asgn vi) (vinfo:capt vi)
+                      ;; avoid redundant box for vars with newvar nodes
+                      (not (any (lambda (x) (and (length= x 2)
+                                                 (eq? (car x) 'newvar) (eq? (cadr x) (cadr e))))
+                                (lam:body lam))))
+                 `(= ,(cadr e) (call (top Box)))
+                 `(newvar ,(cadr e)))))
+          ((const)
+           (if (or (assq (cadr e) (car  (lam:vinfo lam)))
+                   (assq (cadr e) (cadr (lam:vinfo lam))))
+               '(null)
+               e))
+          ((method)
+           (let* ((name  (method-expr-name e))
+                  (short (length= e 2))  ;; function f end
+                  (lam2  (if short #f (cadddr e)))
+                  (vis   (if short '(() () ()) (lam:vinfo lam2)))
+                  (cvs   (map car (cadr vis)))
+                  (local? (and lam (symbol? name)
+                               (or (assq name (car  (lam:vinfo lam)))
+                                   (assq name (cadr (lam:vinfo lam))))))
+                  (sig      (and (not short) (caddr e)))
+                  (sp-inits (if (or short (not (eq? (car sig) 'block)))
+                                '()
+                                (map-cl-convert (butlast (cdr sig))
+                                                fname lam namemap toplevel interp)))
+                  (sig      (and sig (if (eq? (car sig) 'block)
+                                         (last sig)
+                                         sig))))
+             (if local?
+                 (begin (if (memq name (lam:args lam))
+                            (error (string "cannot add method to function argument " name)))
+                        (if (eqv? (string.char (string name) 0) #\@)
+                            (error "macro definition not allowed inside a local scope"))))
+             (if (not local?) ;; not a local function; will not be closure converted to a new type
+                 (cond (short e)
+                       ((null? cvs)
+                        `(toplevel-butlast
+                          ,@sp-inits
+                          (method ,name ,(cl-convert sig fname lam namemap toplevel interp)
+                                  (lambda ,(cadr lam2)
+                                    (,(clear-capture-bits (car vis))
+                                     ,@(cdr vis))
+                                    ,(add-box-inits-to-body
+                                      lam2
+                                      (cl-convert (cadddr lam2) 'anon lam2 (table) #f interp)))
+                                  ,(last e))))
+                       (else
+                        (let* ((exprs     (lift-toplevel (convert-lambda lam2 '|#anon| #t '())))
+                               (top-stmts (cdr exprs))
+                               (newlam    (renumber-jlgensym (linearize (car exprs))))
+                               (vi        (lam:vinfo newlam))
+                               ;; insert `list` expression heads to make the lambda vinfo
+                               ;; lists quotable
+                               (newlam `(lambda (list ,@(cadr newlam))
+                                          (list (list ,@(map (lambda (l) (cons 'list l))
+                                                             (car vi)))
+                                                (list ,@(cadr vi)) ,(caddr vi) (list ,@(cadddr vi)))
+                                          ,@(cdddr newlam))))
+                          `(toplevel-butlast
+                            ,@top-stmts
+                            ,@sp-inits
+                            (method ,name ,(cl-convert sig fname lam namemap toplevel interp)
+                                    ,(julia-expand-macros `(quote ,newlam))
+                                    ,(last e))))))
+                 ;; local case - lift to a new type at top level
+                 (let* ((exists (get namemap name #f))
+                        (tname  (or exists
+                                    (and name
+                                         (symbol (string "#" name "#" (current-julia-module-counter))))))
+                        (alldefs (expr-find-all
+                                  (lambda (ex) (and (eq? (car ex) 'method)
+                                                    (not (eq? ex e))
+                                                    (length> ex 2)
+                                                    (eq? (method-expr-name ex) name)))
+                                  (lam:body lam)
+                                  identity
+                                  (lambda (x) (and (pair? x) (not (eq? (car x) 'lambda))))))
+                        (cvs   (delete-duplicates
+                                (apply append  ;; merge captured vars from all definitions
+                                       cvs
+                                       (map (lambda (methdef)
+                                              (map car (cadr (lam:vinfo (cadddr methdef)))))
+                                            alldefs))))
+                        (sps   (delete-duplicates  ;; static params from all definitions
+                                (apply append
+                                       (if lam2 (lam:sp lam2) '())
+                                       (map (lambda (methdef) (lam:sp (cadddr methdef)))
+                                            alldefs))))
+                        (capt-sp (intersect cvs sps))
+                        (capt-vars (diff cvs capt-sp))
+                        (method-sp (map (lambda (s) (make-jlgensym)) capt-sp))
+                        (typedef  ;; expression to define the type
+                         (let* ((fieldtypes (map (lambda (v)
+                                                   (if (is-var-boxed? v lam)
+                                                       'Any ;; TODO
+                                                       (gensy)))
+                                                 capt-vars))
+                                (para (append capt-sp
+                                              (filter (lambda (v) (not (eq? v 'Any))) fieldtypes))))
+                           (if (null? para)
+                               (type-for-closure tname capt-vars '(top Function))
+                               (type-for-closure-parameterized tname para capt-vars fieldtypes '(top Function)))))
+                        (mk-closure  ;; expression to make the closure
+                         (let* ((var-exprs (map (lambda (v)
+                                                  (let ((cv (assq v (cadr (lam:vinfo lam)))))
+                                                    (if cv
+                                                        (if interp
+                                                            `($ (call (top QuoteNode) ,v))
+                                                            `(call (top getfield) ,fname (inert ,v)))
+                                                        v)))
+                                                capt-vars))
+                                (P (append
+                                    capt-sp
+                                    (filter identity (map (lambda (v ve)
+                                                            (if (is-var-boxed? v lam)
+                                                                #f
+                                                                `(call (top typeof) ,ve)))
+                                                          capt-vars var-exprs)))))
+                           `(new ,(if (null? P)
+                                      tname
+                                      `(call (top apply_type) ,tname ,@P))
+                                 ,@var-exprs)))
+                        (iskw ;; TODO jb/functions need more robust version of this
+                         (contains (lambda (x) (eq? x 'kwftype)) sig)))
+                   `(toplevel-butlast
+                     ,@(if exists
+                           '()
+                           (list
+                            (begin (and name (put! namemap name tname))
+                                   typedef)))
+                     ,@sp-inits
+                     ,@(if short '()
+                           (map (lambda (gs tvar)
+                                  (make-assignment gs `(call (top TypeVar) ',tvar (top Any) true)))
+                                method-sp capt-sp))
+                     ,@(if short '()
+                           `((method #f
+                                     ,(cl-convert
+                                       (fix-function-arg-type sig tname iskw namemap method-sp)
+                                       fname lam namemap toplevel interp)
+                                     ,(convert-lambda lam2
+                                                      (if iskw
+                                                          (caddr (lam:args lam2))
+                                                          (car (lam:args lam2)))
+                                                      #f capt-sp)
+                                     ,(last e))))
+                     ,(if exists
+                          '(null)
+                          (convert-assignment name mk-closure fname lam interp)))))))
+          ((lambda)  ;; should only happen inside (thunk ...)
+           ;; flattening blocks helps lambda-optimize-vars! work
+           (set-car! (cdddr e) (flatten-blocks (lam:body e)))
+           `(lambda ,(cadr e)
+              (,(clear-capture-bits (car (lam:vinfo e)))
+               () ,@(cddr (lam:vinfo e)))
+              (block
+               ,@(map-cl-convert (cdr (lam:body e)) 'anon
+                                 (lambda-optimize-vars! e)
+                                 (table)
+                                 (null? (cadr e)) ;; only toplevel thunks have 0 args
+                                 interp))))
+          ;; remaining `::` expressions are type assertions
+          ((|::|)
+           (cl-convert `(call (top typeassert) ,@(cdr e)) fname lam namemap toplevel interp))
+          ;; remaining `decl` expressions are only type assertions if the
+          ;; argument is global or a non-symbol.
+          ((decl)
+           (if (or (assq (cadr e) (car  (lam:vinfo lam)))
+                   (assq (cadr e) (cadr (lam:vinfo lam))))
+               '(null)
+               (cl-convert `(call (top typeassert) ,@(cdr e)) fname lam namemap toplevel interp)))
+          ;; `with-static-parameters` expressions can be removed now; used only by analyze-vars
+          ((with-static-parameters)
+           (cl-convert (cadr e) fname lam namemap toplevel interp))
+          (else (cons (car e)
+                      (map-cl-convert (cdr e) fname lam namemap toplevel interp))))))))
+
+(define (closure-convert e) (cl-convert e #f #f #f #f #f))
+
+;; pass 5: convert to linear IR
+
+;; with this enabled, all nested calls are assigned to numbered locations
+(define *very-linear-mode* #f)
+
+(define (linearize e)
   (cond ((or (not (pair? e)) (quoted? e)) e)
         ((eq? (car e) 'lambda)
-         `(lambda ,(cadr e) ,(caddr e)
-                  ,(compile-body (cadddr e) (append (car (caddr e))
-                                                    (cadr (caddr e))))))
-        (else (cons (car e)
-                    (map goto-form (cdr e))))))
-
-(define (compile-body e vi)
+         (set-car! (cdddr e) (compile-body (cadddr e) (append (car (caddr e))
+                                                              (cadr (caddr e)))
+                                           e)))
+        (else (for-each linearize (cdr e))))
+  e)
+
+;; this pass behaves like an interpreter on the given code.
+;; to perform stateful operations, it calls `emit` to record that something
+;; needs to be done. in value position, it returns an expression computing
+;; the needed value. in the future, all intermediate values will have
+;; numbered slots (or be simple immediate values), and then those will be the
+;; only possible returned values.
+(define (compile-body e vi lam)
   (let ((code '())
-        (label-counter 0)
-        (label-map (table))
-        (label-decl (table))
-        (label-level (table))
-        (handler-level 0))
-    (symbolic-label-handler-levels e label-level 0)
+        (label-counter 0)     ;; counter for generating label addresses
+        (label-map (table))   ;; maps label names to generated addresses
+        (label-level (table)) ;; exception handler level of each label
+        (handler-goto-fixups '())  ;; `goto`s that might need `leave` exprs added
+        (handler-level 0))  ;; exception handler nesting depth
     (define (emit c)
       (set! code (cons c code)))
     (define (make-label)
@@ -3124,165 +2889,271 @@ So far only the second case can actually occur.
           (let ((l (make-label)))
             (mark-label l)
             l)))
-    (define (compile e break-labels)
-      (if (or (not (pair? e)) (equal? e '(null)))
-          ;; atom has no effect, but keep symbols for undefined-var checking
-          #f #;(if (symbol? e) (emit e) #f)
+    (define (emit-return x)
+      (if (> handler-level 0)
+          (let ((tmp (if (or (simple-atom? x) (jlgensym? x) (equal? x '(null)))
+                         #f (make-jlgensym))))
+            (if tmp (emit `(= ,tmp ,x)))
+            (emit `(leave ,handler-level))
+            (emit `(return ,(or tmp x))))
+          (emit `(return ,x))))
+    (define (new-mutable-var)
+      (let ((g (gensy)))
+        (set-car! (lam:vinfo lam) (append (car (lam:vinfo lam)) `((,g Any 2))))
+        g))
+    ;; evaluate the arguments of a call, creating temporary locations as needed
+    (define (compile-args lst break-labels)
+      (if (null? lst) '()
+          (let ((temps? (or *very-linear-mode*
+                            (expr-contains-p (lambda (x) (and (assignment? x)
+                                                              (symbol? (cadr x))))
+                                             (cons 'block (cdr lst))))))
+            (let loop ((lst  lst)
+                       (vals '()))
+              (if (null? lst)
+                  (reverse! vals)
+                  (let* ((arg (car lst))
+                         (aval (compile arg break-labels #t #f)))
+                    (loop (cdr lst)
+                          (cons (if (and temps?
+                                         (not (simple-atom? arg))  (not (jlgensym? arg))
+                                         (not (simple-atom? aval)) (not (jlgensym? aval))
+                                         (not (and (pair? arg)
+                                                   (memq (car arg) '(& quote inert top copyast))))
+                                         (not (and (symbol? arg)
+                                                   (or (null? (cdr lst))
+                                                       (null? vals)))))
+                                    (let ((tmp (make-jlgensym)))
+                                      (emit `(= ,tmp ,aval))
+                                      tmp)
+                                    aval)
+                                vals))))))))
+    (define (compile-cond ex break-labels)
+      (let ((cnd (compile ex break-labels #t #f)))
+        (if (and *very-linear-mode*
+                 (not (or (simple-atom? cnd) (jlgensym? cnd) (symbol? cnd))))
+            (let ((tmp (make-jlgensym)))
+              (emit `(= ,tmp ,cnd))
+              tmp)
+            cnd)))
+    ;; the interpreter loop. `break-labels` keeps track of the labels to jump to
+    ;; for all currently closing break-blocks.
+    ;; `value` means we are in a context where a value is required; a meaningful
+    ;; value must be returned.
+    ;; `tail` means we are in tail position, where a value needs to be `return`ed
+    ;; from the current function.
+    (define (compile e break-labels value tail)
+      (if (or (not (pair? e)) (memq (car e) '(null jlgensym quote inert top copyast the_exception $
+                                                   cdecl stdcall fastcall thiscall)))
+          (cond (tail  (emit-return e))
+                (value e)
+                ((symbol? e) (emit e) #f)  ;; keep symbols for undefined-var checking
+                (else #f))
           (case (car e)
-            ((call)  (emit (goto-form e)))
-            ((=)     (let ((vt (vinfo:type
-                                (or (var-info-for (cadr e) vi) '(#f Any)))))
-                       (if (not (eq? vt 'Any))
-                           (emit `(= ,(cadr e)
-                                     (call (top typeassert)
-                                           (call (top convert) ,vt
-                                                 ,(goto-form (caddr e)))
-                                           ,vt)))
-                           (emit `(= ,(cadr e) ,(goto-form (caddr e)))))))
-            ((if) (let ((test     `(gotoifnot ,(goto-form (cadr e)) _))
-                        (end-jump `(goto _))
-                        (tail     (and (pair? (caddr e))
-                                       (eq? (car (caddr e)) 'return))))
-                    (emit test)
-                    (compile (caddr e) break-labels)
-                    (if (and (not tail)
-                             (not (equal? (cadddr e) '(null))))
-                        (emit end-jump))
-                    (set-car! (cddr test) (make&mark-label))
-                    (compile (cadddr e) break-labels)
-                    (if (not tail)
-                        (set-car! (cdr end-jump) (make&mark-label)))))
-            ((block) (for-each (lambda (x) (compile x break-labels))
-                               (cdr e)))
+            ((call new)
+             (let* ((ccall? (and (eq? (car e) 'call) (equal? (cadr e) '(top ccall))))
+                    (args (if ccall?
+                              ;; NOTE: first 3 arguments of ccall must be left in place
+                              (append (list-head (cdr e) 4)
+                                      (compile-args (list-tail e 5) break-labels))
+                              (compile-args (cdr e) break-labels)))
+                    (callex (cons (car e) args)))
+               (cond (tail (emit-return callex))
+                     (value callex)
+                     ((eq? (car e) 'new) #f)
+                     (else (emit callex)))))
+            ((=)
+             (let ((rhs (compile (caddr e) break-labels #t #f)))
+               (if value
+                   (let ((rr (if (or (atom? rhs) (jlgensym? rhs) (eq? (car rhs) 'null))
+                                 rhs (make-jlgensym))))
+                     (if (not (eq? rr rhs))
+                         (emit `(= ,rr ,rhs)))
+                     (emit `(= ,(cadr e) ,rr))
+                     (if tail (emit-return rr))
+                     rr)
+                   (emit `(= ,(cadr e) ,rhs)))))
+            ((block body)
+             (let loop ((xs (cdr e)))
+               (if (null? (cdr xs))
+                   (compile (car xs) break-labels value tail)
+                   (begin (compile (car xs) break-labels #f #f)
+                          (loop (cdr xs))))))
+            ((return)
+             (compile (cadr e) break-labels #t #t)
+             '(null))
+            ((if)
+             (let ((test `(gotoifnot ,(compile-cond (cadr e) break-labels) _))
+                   (end-jump `(goto _))
+                   (val (if (and value (not tail)) (new-mutable-var) #f)))
+               (emit test)
+               (let ((v1 (compile (caddr e) break-labels value tail)))
+                 (if val (emit `(= ,val ,v1)))
+                 (if (and (not tail) (or (length> e 3) val))
+                     (emit end-jump))
+                 (set-car! (cddr test) (make&mark-label))
+                 (let ((v2 (if (length> e 3)
+                               (compile (cadddr e) break-labels value tail)
+                               '(null))))
+                   (if val (emit `(= ,val ,v2)))
+                   (if (not tail)
+                       (set-car! (cdr end-jump) (make&mark-label))
+                       (if (length= e 3)
+                           (emit-return v2)))
+                   val))))
             ((_while)
-             (let ((test-blk (cadr e))
-                   (endl (make-label)))
-               (if (or (atom? test-blk) (equal? test-blk '(block)))
-                   ;; if condition is simple, compile it twice in order
-                   ;; to generate a single branch per iteration.
-                   (let ((topl (make-label)))
-                     (compile test-blk break-labels)
-                     (emit `(gotoifnot ,(goto-form (caddr e)) ,endl))
-                     (mark-label topl)
-                     (compile (cadddr e) break-labels)
-                     (compile test-blk break-labels)
-                     (emit `(gotoifnot ,(not-bool (goto-form (caddr e))) ,topl))
-                     (mark-label endl))
-
-                   (let ((topl (make&mark-label)))
-                     (compile test-blk break-labels)
-                     (emit `(gotoifnot ,(goto-form (caddr e)) ,endl))
-                     (compile (cadddr e) break-labels)
-                     (emit `(goto ,topl))
-                     (mark-label endl)))))
-
-            ((break-block) (let ((endl (make-label)))
-                             (compile (caddr e)
-                                      (cons (list (cadr e) endl handler-level)
-                                            break-labels))
-                             (mark-label endl)))
-            ((break) (let ((labl (assq (cadr e) break-labels)))
-                       (if (not labl)
-                           (error "break or continue outside loop")
-                           (begin
-                             (if (> handler-level (caddr labl))
-                                 (emit `(leave
-                                         ,(- handler-level (caddr labl)))))
-                             (emit `(goto ,(cadr labl)))))))
-            ((return) (begin
-                        (if (> handler-level 0)
-                            (emit `(leave ,handler-level)))
-                        (emit (goto-form e))))
-            ((label) (let ((m (get label-map (cadr e) #f)))
-                       (if m
-                           (emit `(label ,m))
-                           (let ((l (make&mark-label)))
-                             (put! label-map (cadr e) l)))
-                       (put! label-decl (cadr e) #t)))
-            ((symboliclabel) (let ((m (get label-map (cadr e) #f)))
-                               (if m
-                                   (if (get label-decl (cadr e) #f)
-                                       (error (string "label \"" (cadr e) "\" defined multiple times"))
-                                       (emit `(label ,m)))
-                                   (let ((l (make&mark-label)))
-                                     (put! label-map (cadr e) l)))
-                               (put! label-decl (cadr e) #t)))
-            ((symbolicgoto) (let ((m (get label-map (cadr e) #f))
-                                  (target-level (get label-level (cadr e) #f)))
-                              (cond
-                               ((not target-level)
-                                (error (string "label \"" (cadr e) "\" referenced but not defined")))
-                               ((> target-level handler-level)
-                                (error (string "cannot goto label \"" (cadr e) "\" inside try/catch block")))
-                               ((< target-level handler-level)
-                                (emit `(leave ,(- handler-level target-level)))))
-                              (if m
-                                  (emit `(goto ,m))
-                                  (let ((l (make-label)))
-                                    (put! label-map (cadr e) l)
-                                    (emit `(goto ,l))))))
-            ((type_goto) (let((m (get label-map (cadr e) #f)))
-                           (if m
-                               (emit `(type_goto ,m ,@(cddr e)))
-                               (let ((l (make-label)))
-                                 (put! label-map (cadr e) l)
-                                 (emit `(type_goto ,l ,@(cddr e)))))))
+             (let* ((endl (make-label))
+                    (topl (make&mark-label))
+                    (test (compile-cond (cadr e) break-labels)))
+               (emit `(gotoifnot ,test ,endl))
+               (compile (caddr e) break-labels #f #f)
+               (emit `(goto ,topl))
+               (mark-label endl)))
+            ((break-block)
+             (let ((endl (make-label)))
+               (begin0 (compile (caddr e)
+                                (cons (list (cadr e) endl handler-level)
+                                      break-labels)
+                                value #f)
+                       (mark-label endl)))
+             (if value (compile '(null) break-labels value tail)))
+            ((break)
+             (let ((labl (assq (cadr e) break-labels)))
+               (if (not labl)
+                   (error "break or continue outside loop")
+                   (begin
+                     (if (> handler-level (caddr labl))
+                         (emit `(leave ,(- handler-level (caddr labl)))))
+                     (emit `(goto ,(cadr labl)))))))
+            ((label symboliclabel)
+             (if (eq? (car e) 'symboliclabel)
+                 (if (has? label-level (cadr e))
+                     (error (string "label \"" (cadr e) "\" defined multiple times"))
+                     (put! label-level (cadr e) handler-level)))
+             (let ((m (get label-map (cadr e) #f)))
+               (if m
+                   (emit `(label ,m))
+                   (put! label-map (cadr e) (make&mark-label)))
+               (if tail (emit-return '(null)))))
+            ((symbolicgoto)
+             (let* ((m (get label-map (cadr e) #f))
+                    (m (or m (let ((l (make-label)))
+                               (put! label-map (cadr e) l)
+                               l))))
+               (emit `(goto ,m))
+               (set! handler-goto-fixups
+                     (cons (list code handler-level (cadr e)) handler-goto-fixups))))
+
+            ((type_goto)
+             (let ((m (get label-map (cadr e) #f)))
+               (if m
+                   (emit `(type_goto ,m ,@(cddr e)))
+                   (let ((l (make-label)))
+                     (put! label-map (cadr e) l)
+                     (emit `(type_goto ,l ,@(cddr e)))))))
+            ((static_typeof)
+             (assert (and value (not tail)))
+             e)
+
             ;; exception handlers are lowered using
             ;; (enter L) - push handler with catch block at label L
             ;; (leave n) - pop N exception handlers
-            ;; (the_exception) - get the thrown object
             ((trycatch)
              (let ((catch (make-label))
                    (endl  (make-label)))
                (emit `(enter ,catch))
                (set! handler-level (+ handler-level 1))
-               (compile (cadr e) break-labels)
-               (set! handler-level (- handler-level 1))
-               (if (not (and (pair? (car code)) (eq? (caar code) 'return)))
-                   ;; try ends in return, no need to handle flow off end of it
-                   (begin (emit `(leave 1))
-                          (emit `(goto ,endl)))
-                   (set! endl #f))
-               (mark-label catch)
-               (emit `(leave 1))
-               (compile (caddr e) break-labels)
-               (if endl
-                   (mark-label endl))
-               ))
+               (let* ((v1  (compile (cadr e)
+                                    break-labels value #f))
+                      (val (if (and value (not tail))
+                               (new-mutable-var) #f)))
+                 (if val (emit `(= ,val ,v1)))
+                 (if tail
+                     (begin (emit-return v1)
+                            (set! endl #f))
+                     (begin (emit '(leave 1))
+                            (emit `(goto ,endl))))
+                 (set! handler-level (- handler-level 1))
+                 (mark-label catch)
+                 (emit `(leave 1))
+                 (let ((v2 (compile (caddr e) break-labels value tail)))
+                   (if val (emit `(= ,val ,v2)))
+                   (if endl (mark-label endl))
+                   val))))
+
+            ((method)
+             (if (length> e 2)
+                 (begin (emit `(method ,(cadr e)
+                                       ,(compile (caddr e) break-labels #t #f)
+                                       ,(linearize (cadddr e))
+                                       ,@(cddddr e)))
+                        (if value (compile '(null) break-labels value tail)))
+                 (cond (tail  (emit-return e))
+                       (value e)
+                       (else  (emit e)))))
+            ((lambda)
+             (let ((temp (linearize e)))
+               (if tail
+                   (emit-return temp)
+                   (emit temp))))
+
+            ((&)
+             (assert (and value (not tail)))
+             `(& ,(compile (cadr e) break-labels value tail)))
 
+            ((newvar)
+             ;; avoid duplicate newvar nodes
+             (if (not (and (pair? code) (equal? (car code) e)))
+                 (emit e)
+                 #f))
             ((global) ; remove global declarations
              (let ((vname (cadr e)))
                (if (var-info-for vname vi)
-                   ; issue #7264
+                   ;; issue #7264
                    (error (string "`global " vname "`: " vname " is local variable in the enclosing scope"))
                    #f)))
+            ((local) #f)
             ((implicit-global) #f)
-            ((local!) #f)
-            ((jlgensym) #f)
-            ((local)
-             ;; emit (newvar x) where captured locals are introduced.
-             (let* ((vname (cadr e))
-                    (vinf  (var-info-for vname vi)))
-               (if (and vinf
-                        (not (and (pair? code)
-                                  (equal? (car code) `(newvar ,vname)))))
-                   (emit `(newvar ,vname))
-                   #f)))
-            ((newvar)
-             ;; avoid duplicate newvar nodes
-             (if (not (and (pair? code) (equal? (car code) e)))
-                 (emit e)
-                 #f))
-            (else  (emit (goto-form e))))))
-    (compile e '())
+            ((const) (emit e))
+
+            ;; metadata
+            ((line meta boundscheck simdloop) (emit e))
+            ((inbounds)
+             ;; TODO: this should not be here but sometimes ends up in tail position, e.g.
+             ;; `f(x) = @inbounds return x`
+             (cond (tail  (emit-return e))
+                   (value e)
+                   (else  (emit e))))
+            ;; top level expressions returning values
+            ((abstract_type bits_type composite_type thunk toplevel module)
+             (if tail (emit-return e) (emit e)))
+            ;; other top level expressions
+            ((import importall using export)
+             (emit e)
+             (if tail (emit-return '(null)) '(null)))
+            (else
+             (error (string "unhandled expr " e))))))
+    (compile e '() #t #t)
+    (for-each (lambda (x)
+                (let ((point (car x))
+                      (hl    (cadr x))
+                      (lab   (caddr x)))
+                  (let ((target-level (get label-level lab #f)))
+                    (cond ((not target-level)
+                           (error (string "label \"" lab "\" referenced but not defined")))
+                          ((> target-level hl)
+                           (error (string "cannot goto label \"" lab "\" inside try/catch block")))
+                          ((= target-level hl)
+                           (set-cdr! point (cddr point))) ;; remove empty slot
+                          (else
+                           (set-car! (cdr point) `(leave ,(- hl target-level))))))))
+              handler-goto-fixups)
     (let* ((stmts (reverse! code))
-	   (di    (definitely-initialized-vars stmts vi)))
+           (di    (definitely-initialized-vars stmts vi)))
       (cons 'body (filter (lambda (e)
-			    (not (and (pair? e) (eq? (car e) 'newvar)
-				      (has? di (cadr e)))))
-			  stmts)))))
-
-(define to-goto-form goto-form)
+                            (not (and (pair? e) (eq? (car e) 'newvar)
+                                      (has? di (cadr e)))))
+                          stmts)))))
 
 ;; find newvar nodes that are unnecessary because (1) the variable is not
 ;; captured, and (2) the variable is assigned before any branches.
@@ -3292,305 +3163,64 @@ So far only the second case can actually occur.
 ;; are *always* used undefined, and therefore don't need to be *re*-initialized.
 (define (definitely-initialized-vars stmts vi)
   (let ((vars (table))
-	(di   (table)))
+        (di   (table)))
     (let loop ((stmts stmts))
       (if (null? stmts)
-	  di
-	  (begin
-	    (let ((e (car stmts)))
-	      (cond ((and (pair? e) (eq? (car e) 'newvar))
-		     (let ((vinf (var-info-for (cadr e) vi)))
-		       (if (and vinf (not (vinfo:capt vinf)))
-			   (put! vars (cadr e) #t))))
-		    ((and (pair? e) (eq? (car e) '=))
-		     (if (has? vars (cadr e))
-			 (begin (del! vars (cadr e))
-				(put! di (cadr e) #t))))
-		    ((and (pair? e) (memq (car e) '(goto gotoifnot)))
-		     (set! vars (table)))))
-	    (loop (cdr stmts)))))))
-
-;; macro expander
-
-(define (splice-expr? e)
-  ;; ($ (tuple (... x)))
-  (and (length= e 2)          (eq? (car e)   '$)
-       (length= (cadr e) 2)   (eq? (caadr e) 'tuple)
-       (vararg? (cadadr e))))
-
-(define (wrap-with-splice x)
-  `(call (top _expr) (inert $)
-	 (call (top _expr) (inert tuple)
-	       (call (top _expr) (inert |...|) ,x))))
-
-(define (julia-bq-bracket x d)
-  (if (splice-expr? x)
-      (if (= d 0)
-	  (cadr (cadr (cadr x)))
-	  (list 'cell1d
-		(wrap-with-splice (julia-bq-expand (cadr (cadr (cadr x))) (- d 1)))))
-      (list 'cell1d (julia-bq-expand x d))))
-
-(define (julia-bq-expand x d)
-  (cond ((or (eq? x 'true) (eq? x 'false))  x)
-	((or (symbol? x) (jlgensym? x))     (list 'inert x))
-        ((atom? x)  x)
-        ((eq? (car x) 'quote)
-	 `(call (top _expr) (inert quote) ,(julia-bq-expand (cadr x) (+ d 1))))
-        ((eq? (car x) '$)
-	 (if (and (= d 0) (length= x 2))
-	     (cadr x)
-	     (if (splice-expr? (cadr x))
-		 `(call (top splicedexpr) (inert $)
-			(call (top append_any) ,(julia-bq-bracket (cadr x) (- d 1))))
-		 `(call (top _expr) (inert $) ,(julia-bq-expand (cadr x) (- d 1))))))
-        ((not (contains (lambda (e) (and (pair? e) (eq? (car e) '$))) x))
-         `(copyast (inert ,x)))
-	((not (any splice-expr? x))
-	 `(call (top _expr) ,.(map (lambda (ex) (julia-bq-expand ex d)) x)))
-	(else
-	 (let loop ((p (cdr x)) (q '()))
-	   (if (null? p)
-	       (let ((forms (reverse q)))
-		 `(call (top splicedexpr) ,(julia-bq-expand (car x) d)
-			(call (top append_any) ,@forms)))
-	       (loop (cdr p) (cons (julia-bq-bracket (car p) d) q)))))))
-
-(define (julia-expand-macros e)
-  (cond ((not (pair? e))     e)
-        ((eq? (car e) 'quote)
-         ;; backquote is essentially a built-in macro at the moment
-         (julia-expand-macros (julia-bq-expand (cadr e) 0)))
-        ((eq? (car e) 'inert) e)
-        ((eq? (car e) 'macrocall)
-         ;; expand macro
-         (let ((form (apply invoke-julia-macro (cadr e) (cddr e))))
-           (if (not form)
-               (error (string "macro \"" (cadr e) "\" not defined")))
-           (if (and (pair? form) (eq? (car form) 'error))
-               (error (cadr form)))
-           (let ((form (car form))
-                 (m    (cdr form)))
-             ;; m is the macro's def module, or #f if def env === use env
-             (rename-symbolic-labels
-              (julia-expand-macros
-               (resolve-expansion-vars form m))))))
-	((eq? (car e) 'module) e)
-        (else
-         (map julia-expand-macros e))))
-
-(define (pair-with-gensyms v)
-  (map (lambda (s)
-         (if (pair? s)
-             s
-             (cons s (named-gensy s))))
-       v))
-
-(define (unescape e)
-  (if (and (pair? e) (eq? (car e) 'escape))
-      (cadr e)
-      e))
-
-(define (typevar-expr-name e)
-  (if (symbol? e) e
-      (cadr e)))
+          di
+          (begin
+            (let ((e (car stmts)))
+              (cond ((and (pair? e) (eq? (car e) 'newvar))
+                     (let ((vinf (var-info-for (cadr e) vi)))
+                       (if (and vinf (not (vinfo:capt vinf)))
+                           (put! vars (cadr e) #t))))
+                    ((and (pair? e) (eq? (car e) '=))
+                     (if (has? vars (cadr e))
+                         (begin (del! vars (cadr e))
+                                (put! di (cadr e) #t))))
+                    ((and (pair? e) (memq (car e) '(goto gotoifnot)))
+                     (set! vars (table)))))
+            (loop (cdr stmts)))))))
+
+;; pass 6: renumber jlgensyms to start at 0 in each function
+
+(define (make-gensym-generator)
+  (let ((jlgensym-counter 0))
+    (lambda ()
+      (begin0 `(jlgensym ,jlgensym-counter)
+              (set! jlgensym-counter (+ 1 jlgensym-counter))))))
 
-(define (new-expansion-env-for x env)
-  (append!
-   (filter (lambda (v)
-             (not (assq (car v) env)))
-           (append!
-            (pair-with-gensyms (vars-introduced-by x))
-            (map (lambda (v) (cons v v))
-                 (keywords-introduced-by x))))
-   env))
-
-(define (resolve-expansion-vars-with-new-env x env m inarg)
-  (resolve-expansion-vars-
-   x
-   (if (and (pair? x) (eq? (car x) 'let))
-       ;; let is strange in that it needs both old and new envs within
-       ;; the same expression
-       env
-       (new-expansion-env-for x env))
-   m inarg))
-
-(define (resolve-expansion-vars- e env m inarg)
-  (cond ((or (eq? e 'true) (eq? e 'false) (eq? e 'end))
-         e)
-    ((symbol? e)
-     (let ((a (assq e env)))
-       (if a (cdr a)
-           (if m `(|.| ,m (quote ,e))
-           e))))
-        ((or (not (pair? e)) (quoted? e))
-         e)
-        (else
-         (case (car e)
-           ((jlgensym) e)
-           ((escape) (cadr e))
-           ((using import importall export meta) (map unescape e))
-           ((macrocall)
-        (if (or (eq? (cadr e) '@label) (eq? (cadr e) '@goto)) e
-            `(macrocall ,.(map (lambda (x)
-                                 (resolve-expansion-vars- x env m inarg))
-                               (cdr e)))))
-           ((symboliclabel) e)
-           ((symbolicgoto) e)
-           ((type)
-            `(type ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m inarg)
-                   ;; type has special behavior: identifiers inside are
-                   ;; field names, not expressions.
-                   ,(map (lambda (x)
-                           (cond ((atom? x) x)
-                                 ((and (pair? x) (eq? (car x) '|::|))
-                                  `(|::| ,(cadr x)
-                                    ,(resolve-expansion-vars- (caddr x) env m inarg)))
-                                 (else
-                                  (resolve-expansion-vars-with-new-env x env m inarg))))
-                         (cadddr e))))
-
-           ((parameters)
-            (cons 'parameters
-                  (map (lambda (x)
-                         (resolve-expansion-vars- x env m #f))
-                       (cdr e))))
-
-           ((= function)
-            (if (and (pair? (cadr e)) (eq? (caadr e) 'call))
-                ;; in (kw x 1) inside an arglist, the x isn't actually a kwarg
-                `(,(car e) (call ,(resolve-expansion-vars-with-new-env (cadadr e) env m inarg)
-                                 ,@(map (lambda (x)
-                                          (resolve-expansion-vars-with-new-env x env m #t))
-                                        (cddr (cadr e))))
-                  ,(resolve-expansion-vars-with-new-env (caddr e) env m inarg))
-                `(,(car e) ,@(map (lambda (x)
-                                    (resolve-expansion-vars-with-new-env x env m inarg))
-                                  (cdr e)))))
-
-           ((kw)
-            (if (and (pair? (cadr e))
-                     (eq? (caadr e) '|::|))
-                `(kw (|::|
-                      ,(if inarg
-                           (resolve-expansion-vars- (cadr (cadr e)) env m inarg)
-                           ;; in keyword arg A=B, don't transform "A"
-                           (cadr (cadr e)))
-                      ,(resolve-expansion-vars- (caddr (cadr e)) env m inarg))
-                     ,(resolve-expansion-vars- (caddr e) env m inarg))
-                `(kw ,(if inarg
-                          (resolve-expansion-vars- (cadr e) env m inarg)
-                          (cadr e))
-                     ,(resolve-expansion-vars- (caddr e) env m inarg))))
-
-           ((let)
-            (let* ((newenv (new-expansion-env-for e env))
-                   (body   (resolve-expansion-vars- (cadr e) newenv m inarg)))
-              `(let ,body
-                 ,@(map
-                    (lambda (bind)
-                      (if (assignment? bind)
-                          (make-assignment
-                           ;; expand binds in old env with dummy RHS
-                           (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
-                                                          newenv m inarg))
-                           ;; expand initial values in old env
-                           (resolve-expansion-vars- (caddr bind) env m inarg))
-                          bind))
-                    (cddr e)))))
-
-           ;; todo: trycatch
-           (else
-            (cons (car e)
-                  (map (lambda (x)
-                         (resolve-expansion-vars-with-new-env x env m inarg))
-                       (cdr e))))))))
-
-;; decl-var that also identifies f in f()=...
-(define (decl-var* e)
-  (cond ((not (pair? e))       e)
-        ((eq? (car e) 'escape) '())
-        ((eq? (car e) 'call)   (decl-var* (cadr e)))
-        ((eq? (car e) '=)      (decl-var* (cadr e)))
-        ((eq? (car e) 'curly)  (decl-var* (cadr e)))
-        (else                  (decl-var e))))
-
-(define (find-declared-vars-in-expansion e decl)
-  (if (or (not (pair? e)) (quoted? e))
-      '()
-      (cond ((eq? (car e) 'escape)  '())
-            ((eq? (car e) decl)     (map decl-var* (cdr e)))
-            (else
-             (apply append! (map (lambda (x)
-                                   (find-declared-vars-in-expansion x decl))
-                                 e))))))
+(define (renumber-jlgensym- e tbl next-jlgensym)
+  (cond
+   ((or (not (pair? e)) (quoted? e)) e)
+   ((eq? (car e) 'lambda)
+    (let* ((next  (make-gensym-generator))
+           (body  (renumber-jlgensym- (lam:body e) (table) next))
+           (count (cadr (next)))
+           (vi    (caddr e)))
+      `(lambda ,(cadr e)
+         (,(car vi) ,(cadr vi) ,count ,(last vi))
+         ,body)))
+   ((jlgensym? e)
+    (let ((n (get tbl (cadr e) #f)))
+      (if n n
+          (let ((n (next-jlgensym))) (put! tbl (cadr e) n) n))))
+   (else (map (lambda (x) (renumber-jlgensym- x tbl next-jlgensym)) e))))
 
-(define (find-assigned-vars-in-expansion e)
-  (if (or (not (pair? e)) (quoted? e))
-      '()
-      (case (car e)
-        ((escape)  '())
-        ((= function)
-         (append! (filter
-                   symbol?
-                   (if (and (pair? (cadr e)) (eq? (car (cadr e)) 'tuple))
-                       (map decl-var* (cdr (cadr e)))
-                       (list (decl-var* (cadr e)))))
-                  (find-assigned-vars-in-expansion (caddr e))))
-        (else
-         (apply append! (map find-assigned-vars-in-expansion e))))))
-
-(define (vars-introduced-by e)
-  (let ((v (pattern-expand1 vars-introduced-by-patterns e)))
-    (if (and (pair? v) (eq? (car v) 'varlist))
-        (cdr v)
-        '())))
-
-(define (keywords-introduced-by e)
-  (let ((v (pattern-expand1 keywords-introduced-by-patterns e)))
-    (if (and (pair? v) (eq? (car v) 'varlist))
-        (cdr v)
-        '())))
-
-(define (env-for-expansion e)
-  (let ((globals (find-declared-vars-in-expansion e 'global)))
-    (let ((v (diff (delete-duplicates
-                    (append! (find-declared-vars-in-expansion e 'local)
-                             (find-assigned-vars-in-expansion e)
-                             (map (lambda (x)
-                                    (if (pair? x) (car x) x))
-                                  (vars-introduced-by e))))
-                   globals)))
-      (append!
-       (pair-with-gensyms v)
-       (map (lambda (s) (cons s s))
-            (diff (keywords-introduced-by e) globals))))))
-
-(define (resolve-expansion-vars e m)
-  ;; expand binding form patterns
-  ;; keep track of environment, rename locals to gensyms
-  ;; and wrap globals in (getfield module var) for macro's home module
-  (resolve-expansion-vars- e (env-for-expansion e) m #f))
+(define (renumber-jlgensym e)
+  (renumber-jlgensym- e #f error))
 
 ;; expander entry point
 
 (define (julia-expand1 ex)
-  (to-goto-form
-    (analyze-variables
-     (renumber-jlgensym
-      (flatten-scopes
-       (identify-locals ex))))))
-
-(define (julia-expand01 ex)
-  (to-LFF
-   (expand-forms
-    (expand-binding-forms ex))))
-
-(define (julia-expand0 ex)
-  (let ((e (julia-expand-macros ex)))
-    (if (and (pair? e) (eq? (car e) 'toplevel))
-        `(toplevel ,.(map julia-expand01 (cdr e)))
-        (julia-expand01 e))))
+  (renumber-jlgensym
+   (linearize
+    (closure-convert
+     (analyze-variables!
+      (resolve-scopes ex))))))
+
+(define julia-expand0 expand-forms)
 
 (define (julia-expand ex)
-  (julia-expand1 (julia-expand0 ex)))
+  (julia-expand1
+   (julia-expand0
+    (julia-expand-macros ex))))
diff --git a/src/julia.expmap b/src/julia.expmap
index 2da919929999e..86fa949097aed 100644
--- a/src/julia.expmap
+++ b/src/julia.expmap
@@ -4,7 +4,6 @@
     __stack_chk_guard;
     asprintf;
     bitvector_*;
-    clock_now;
     ev_break;
     get_exename;
     getlocalip;
@@ -15,6 +14,7 @@
     iswprint;
     jl_*;
     rec_backtrace;
+    rec_backtrace_ctx;
     julia_*;
     libsupport_init;
     localtime_r;
diff --git a/src/julia.h b/src/julia.h
index 22e19de7a6b84..1918cd6f5f685 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -3,11 +3,11 @@
 #ifndef JULIA_H
 #define JULIA_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "options.h"
+//** Configuration options that affect the Julia ABI **//
+// if this is not defined, only individual dimension sizes are
+// stored and not total length, to save space.
+#define STORE_ARRAY_LEN
+//** End Configuration options **//
 
 #include "libsupport.h"
 #include <stdint.h>
@@ -21,6 +21,9 @@ extern "C" {
 #  define jl_jmp_buf sigjmp_buf
 #  if defined(_CPU_ARM_)
 #    define MAX_ALIGN 8
+#  elif defined(_CPU_AARCH64_)
+// int128 is 16 bytes aligned on aarch64
+#    define MAX_ALIGN 16
 #  else
 #    define MAX_ALIGN sizeof(void*)
 #  endif
@@ -36,72 +39,53 @@ extern "C" {
 #define NWORDS(sz) (((sz)+3)>>2)
 #endif
 
-#if __GNUC__
-#define NORETURN __attribute__ ((noreturn))
+#if defined(__GNUC__)
+#  define JL_NORETURN __attribute__ ((noreturn))
+#  define JL_CONST_FUNC __attribute__((const))
+#elif defined(_COMPILER_MICROSOFT_)
+#  define JL_NORETURN __declspec(noreturn)
+// This is the closest I can find for __attribute__((const))
+#  define JL_CONST_FUNC __declspec(noalias)
 #else
-#define NORETURN
+#  define JL_NORETURN
+#  define JL_CONST_FUNC
 #endif
 
 #define container_of(ptr, type, member) \
     ((type *) ((char *)(ptr) - offsetof(type, member)))
 
-#ifdef _MSC_VER
-#if _WIN64
-#define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) __declspec(align(8)) x
-#else
-#define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) __declspec(align(4)) x
-#endif
-#elif __GNUC__
-#define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) x __attribute__ ((aligned (sizeof(void*))))
-#else
-#define JL_ATTRIBUTE_ALIGN_PTRSIZE(x)
-#endif
+#include <julia_threads.h>
 
-// threading ------------------------------------------------------------------
-
-// WARNING: Threading support is incomplete.  Changing the 1 to a 0 will break Julia.
-// Nonetheless, we define JL_THREAD and use it to give advanced notice to maintainers
-// of what eventual threading support will change.
-#if 1
-// Definition for compiling non-thread-safe Julia.
-#  define JL_THREAD
-#elif !defined(_OS_WINDOWS_)
-// Definition for compiling Julia on platforms with GCC __thread.
-#  define JL_THREAD __thread
-#else
-// Definition for compiling Julia on Windows
-#  define JL_THREAD __declspec(thread)
+#ifdef __cplusplus
+extern "C" {
 #endif
 
 // core data types ------------------------------------------------------------
 
-#ifndef _COMPILER_MICROSOFT_
-#define JL_DATA_TYPE \
-    struct _jl_value_t *fieldptr0[0];
-#else
 #define JL_DATA_TYPE
-#endif
 
-typedef struct _jl_value_t {
-    JL_DATA_TYPE
-    struct _jl_value_t *fieldptr[];
-} jl_value_t;
+typedef struct _jl_value_t jl_value_t;
+
+// typedef struct _jl_value_t {
+//     JL_DATA_TYPE
+//     struct _jl_value_t *fieldptr[];
+// } jl_value_t;
 
 typedef struct {
     union {
         jl_value_t *type; // 16-bytes aligned
         uintptr_t type_bits;
-        struct {
-            uintptr_t gc_bits:2;
-        };
+        uintptr_t gc_bits:2;
     };
-    jl_value_t value;
+    // jl_value_t value;
 } jl_taggedvalue_t;
 
-#define jl_astaggedvalue__MACRO(v) container_of((v),jl_taggedvalue_t,value)
-#define jl_typeof__MACRO(v) ((jl_value_t*)(jl_astaggedvalue__MACRO(v)->type_bits&~(uintptr_t)15))
-#define jl_astaggedvalue jl_astaggedvalue__MACRO
-#define jl_typeof jl_typeof__MACRO
+#define jl_astaggedvalue(v)                                             \
+    ((jl_taggedvalue_t*)((char*)(v) - sizeof(jl_taggedvalue_t)))
+#define jl_valueof(v)                                           \
+    ((jl_value_t*)((char*)(v) + sizeof(jl_taggedvalue_t)))
+#define jl_typeof(v)                                                    \
+    ((jl_value_t*)(jl_astaggedvalue(v)->type_bits & ~(uintptr_t)15))
 static inline void jl_set_typeof(void *v, void *t)
 {
     jl_taggedvalue_t *tag = jl_astaggedvalue(v);
@@ -113,8 +97,8 @@ typedef struct _jl_sym_t {
     JL_DATA_TYPE
     struct _jl_sym_t *left;
     struct _jl_sym_t *right;
-    uptrint_t hash;    // precomputed hash value
-    JL_ATTRIBUTE_ALIGN_PTRSIZE(char name[]);
+    uintptr_t hash;    // precomputed hash value
+    // JL_ATTRIBUTE_ALIGN_PTRSIZE(char name[]);
 } jl_sym_t;
 
 typedef struct _jl_gensym_t {
@@ -125,33 +109,33 @@ typedef struct _jl_gensym_t {
 typedef struct {
     JL_DATA_TYPE
     size_t length;
-    jl_value_t *data[];
+    // pointer size aligned
+    // jl_value_t *data[];
 } jl_svec_t;
 
+typedef struct {
+    /*
+      how - allocation style
+      0 = data is inlined, or a foreign pointer we don't manage
+      1 = julia-allocated buffer that needs to be marked
+      2 = malloc-allocated pointer this array object manages
+      3 = has a pointer to the Array that owns the data
+    */
+    uint16_t how:2;
+    uint16_t ndims:10;
+    uint16_t pooled:1;
+    uint16_t ptrarray:1;  // representation is pointer array
+    uint16_t isshared:1;  // data is shared by multiple Arrays
+    uint16_t isaligned:1; // data allocated with memalign
+} jl_array_flags_t;
+
 typedef struct {
     JL_DATA_TYPE
     void *data;
 #ifdef STORE_ARRAY_LEN
     size_t length;
 #endif
-    union {
-        struct {
-            /*
-              how - allocation style
-              0 = data is inlined, or a foreign pointer we don't manage
-              1 = julia-allocated buffer that needs to be marked
-              2 = malloc-allocated pointer this array object manages
-              3 = has a pointer to the Array that owns the data
-            */
-            unsigned short how:2;
-            unsigned short ndims:10;
-            unsigned short pooled:1;
-            unsigned short ptrarray:1;  // representation is pointer array
-            unsigned short isshared:1;  // data is shared by multiple Arrays
-            unsigned short isaligned:1; // data allocated with memalign
-        };
-        unsigned short flags;
-    };
+    jl_array_flags_t flags;
     uint16_t elsize;
     uint32_t offset;  // for 1-d only. does not need to get big.
     size_t nrows;
@@ -172,9 +156,18 @@ STATIC_INLINE int jl_array_ndimwords(uint32_t ndims)
 }
 
 typedef jl_value_t *(*jl_fptr_t)(jl_value_t*, jl_value_t**, uint32_t);
+typedef jl_value_t *(*jl_fptr_sparam_t)(jl_svec_t*, jl_value_t*, jl_value_t**, uint32_t);
 
 typedef struct _jl_datatype_t jl_tupletype_t;
 
+typedef struct _jl_llvm_functions_t {
+    void *functionObject;       // jlcall llvm Function
+    void *cFunctionList;        // c callable llvm Functions
+
+    // specialized llvm Function (common core for the other two)
+    void *specFunctionObject;
+} jl_llvm_functions_t;
+
 typedef struct _jl_lambda_info_t {
     JL_DATA_TYPE
     // this holds the static data for a function:
@@ -183,44 +176,47 @@ typedef struct _jl_lambda_info_t {
     // this is the stuff that's shared among different instantiations
     // (different environments) of a closure.
     jl_value_t *ast;
-    // sparams is a vector (symbol, value, symbol, value, ...)
-    jl_svec_t *sparams;
+    jl_value_t *rettype;
+    // sparams is a vector of values indexed by symbols
+    jl_svec_t *sparam_syms;
+    jl_svec_t *sparam_vals;
     jl_value_t *tfunc;
     jl_sym_t *name;  // for error reporting
     jl_array_t *roots;  // pointers in generated code
-    jl_tupletype_t *specTypes;  // argument types this is specialized for
+    jl_tupletype_t *specTypes;  // argument types this will be compiled for
     // a slower-but-works version of this function as a fallback
-    struct _jl_function_t *unspecialized;
+    struct _jl_lambda_info_t *unspecialized;
     // array of all lambda infos with code generated from this one
     jl_array_t *specializations;
     struct _jl_module_t *module;
     struct _jl_lambda_info_t *def;  // original this is specialized from
-    jl_value_t *capt;  // captured var info
     jl_sym_t *file;
     int32_t line;
     int8_t inferred;
+    int8_t pure;
+    uint8_t called;  // bit flags: whether each of the first 8 arguments is called
 
     // hidden fields:
-    // flag telling if inference is running on this function
-    // used to avoid infinite recursion
-    int8_t inInference : 1;
-    int8_t inCompile : 1;
+    uint8_t jlcall_api : 1;     // the c-abi for fptr; 0 = jl_fptr_t, 1 = jl_fptr_sparam_t
+    uint8_t inInference : 1;    // flags to tell if inference is running on this function
+                                // used to avoid infinite recursion
+    uint8_t inCompile : 1;
+    uint8_t needs_sparam_vals_ducttape : 1; // if there are intrinsic calls,
+                                            // probably require the sparams to compile successfully
+                                            // (and so unspecialized will be created for each linfo instead of linfo->def)
     jl_fptr_t fptr;             // jlcall entry point
-    void *functionObject;       // jlcall llvm Function
-    void *cFunctionList;        // c callable llvm Functions
 
-    // specialized llvm Function (common core for the other two)
-    void *specFunctionObject;
+    // On the old JIT, handles to all Functions generated for this linfo
+    // For the new JITs, handles to declarations in the shadow module
+    // with the same name as the generated functions for this linfo, suitable
+    // for referencing in LLVM IR
+    jl_llvm_functions_t functionObjects;
+
     int32_t functionID; // index that this function will have in the codegen table
     int32_t specFunctionID; // index that this specFunction will have in the codegen table
 } jl_lambda_info_t;
 
-typedef struct _jl_function_t {
-    JL_DATA_TYPE
-    jl_fptr_t fptr;
-    jl_value_t *env;
-    jl_lambda_info_t *linfo;
-} jl_function_t;
+typedef jl_value_t jl_function_t;
 
 typedef struct {
     JL_DATA_TYPE
@@ -240,7 +236,8 @@ typedef struct {
     jl_value_t *primary;
     jl_svec_t *cache;        // sorted array
     jl_svec_t *linearcache;  // unsorted array
-    ptrint_t uid;
+    intptr_t uid;
+    struct _jl_methtable_t *mt;
 } jl_typename_t;
 
 typedef struct {
@@ -248,14 +245,23 @@ typedef struct {
     jl_svec_t *types;
 } jl_uniontype_t;
 
+typedef struct {
+    uint8_t offset;   // offset relative to data start, excluding type tag
+    uint8_t size:7;
+    uint8_t isptr:1;
+} jl_fielddesc8_t;
+
 typedef struct {
     uint16_t offset;   // offset relative to data start, excluding type tag
     uint16_t size:15;
     uint16_t isptr:1;
-} jl_fielddesc_t;
+} jl_fielddesc16_t;
 
-#define JL_FIELD_MAX_OFFSET ((1ul << 16) - 1ul)
-#define JL_FIELD_MAX_SIZE ((1ul << 15) - 1ul)
+typedef struct {
+    uint32_t offset;   // offset relative to data start, excluding type tag
+    uint32_t size:31;
+    uint32_t isptr:1;
+} jl_fielddesc32_t;
 
 typedef struct _jl_datatype_t {
     JL_DATA_TYPE
@@ -271,12 +277,18 @@ typedef struct _jl_datatype_t {
     int32_t ninitialized;
     // hidden fields:
     uint32_t nfields;
-    uint32_t alignment : 31;  // strictest alignment over all fields
+    uint32_t alignment : 29;  // strictest alignment over all fields
     uint32_t haspadding : 1;  // has internal undefined bytes
+    uint32_t fielddesc_type : 2; // 0 -> 8, 1 -> 16, 2 -> 32
     uint32_t uid;
-    void *struct_decl;  //llvm::Value*
+    void *struct_decl;  //llvm::Type*
     void *ditype; // llvm::MDNode* to be used as llvm::DIType(ditype)
-    jl_fielddesc_t fields[];
+    // Last field needs to be pointer size aligned
+    // union {
+    //     jl_fielddesc8_t field8[];
+    //     jl_fielddesc16_t field16[];
+    //     jl_fielddesc32_t field32[];
+    // };
 } jl_datatype_t;
 
 typedef struct {
@@ -301,6 +313,7 @@ typedef struct {
     unsigned constp:1;
     unsigned exportp:1;
     unsigned imported:1;
+    unsigned deprecated:1;
 } jl_binding_t;
 
 typedef struct _jl_module_t {
@@ -309,11 +322,10 @@ typedef struct _jl_module_t {
     struct _jl_module_t *parent;
     htable_t bindings;
     arraylist_t usings;  // modules with all bindings potentially imported
-    jl_array_t *constant_table;
-    jl_function_t *call_func;  // cached lookup of `call` within this module
     uint8_t istopmod;
     uint8_t std_imports;  // only for temporarily deprecating `importall Base.Operators`
     uint64_t uuid;
+    uint32_t counter;
 } jl_module_t;
 
 typedef struct _jl_methlist_t {
@@ -322,7 +334,7 @@ typedef struct _jl_methlist_t {
     int8_t va;
     int8_t isstaged;
     jl_svec_t *tvars;
-    jl_function_t *func;
+    jl_lambda_info_t *func;
     // cache of specializations of this method for invoke(), i.e.
     // cases where this method was called even though it was not necessarily
     // the most specific for the argument types.
@@ -339,8 +351,8 @@ typedef struct _jl_methtable_t {
     jl_methlist_t *cache;
     jl_array_t *cache_arg1;
     jl_array_t *cache_targ;
-    ptrint_t max_args;  // max # of non-vararg arguments in a signature
-    jl_function_t *kwsorter;  // keyword argument sorter function
+    intptr_t max_args;  // max # of non-vararg arguments in a signature
+    jl_value_t *kwsorter;  // keyword argument sorter function
     jl_module_t *module; // used for incremental serialization to locate original binding
 #ifdef JL_GF_PROFILE
     int ncalls;
@@ -356,101 +368,105 @@ typedef struct {
 
 // constants and type objects -------------------------------------------------
 
-extern DLLEXPORT jl_datatype_t *jl_any_type;
-extern DLLEXPORT jl_datatype_t *jl_type_type;
-extern DLLEXPORT jl_tvar_t     *jl_typetype_tvar;
-extern DLLEXPORT jl_datatype_t *jl_typetype_type;
-extern DLLEXPORT jl_value_t    *jl_ANY_flag;
-extern DLLEXPORT jl_datatype_t *jl_typename_type;
-extern DLLEXPORT jl_datatype_t *jl_typector_type;
-extern DLLEXPORT jl_datatype_t *jl_sym_type;
-extern DLLEXPORT jl_datatype_t *jl_symbol_type;
-extern DLLEXPORT jl_datatype_t *jl_gensym_type;
-extern DLLEXPORT jl_datatype_t *jl_simplevector_type;
-extern DLLEXPORT jl_typename_t *jl_tuple_typename;
-extern DLLEXPORT jl_datatype_t *jl_anytuple_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_any_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_type_type;
+extern JL_DLLEXPORT jl_tvar_t     *jl_typetype_tvar;
+extern JL_DLLEXPORT jl_datatype_t *jl_typetype_type;
+extern JL_DLLEXPORT jl_value_t    *jl_ANY_flag;
+extern JL_DLLEXPORT jl_datatype_t *jl_typename_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_typector_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_sym_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_symbol_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_gensym_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_simplevector_type;
+extern JL_DLLEXPORT jl_typename_t *jl_tuple_typename;
+extern JL_DLLEXPORT jl_datatype_t *jl_anytuple_type;
 #define jl_tuple_type jl_anytuple_type
-extern DLLEXPORT jl_datatype_t *jl_ntuple_type;
-extern DLLEXPORT jl_typename_t *jl_ntuple_typename;
-extern DLLEXPORT jl_datatype_t *jl_vararg_type;
-extern DLLEXPORT jl_datatype_t *jl_tvar_type;
-extern DLLEXPORT jl_datatype_t *jl_task_type;
-
-extern DLLEXPORT jl_datatype_t *jl_uniontype_type;
-extern DLLEXPORT jl_datatype_t *jl_datatype_type;
-
-extern DLLEXPORT jl_value_t *jl_bottom_type;
-extern DLLEXPORT jl_datatype_t *jl_lambda_info_type;
-extern DLLEXPORT jl_datatype_t *jl_module_type;
-extern DLLEXPORT jl_datatype_t *jl_function_type;
-extern DLLEXPORT jl_datatype_t *jl_abstractarray_type;
-extern DLLEXPORT jl_datatype_t *jl_densearray_type;
-extern DLLEXPORT jl_datatype_t *jl_array_type;
-extern DLLEXPORT jl_typename_t *jl_array_typename;
-extern DLLEXPORT jl_datatype_t *jl_weakref_type;
-extern DLLEXPORT jl_datatype_t *jl_ascii_string_type;
-extern DLLEXPORT jl_datatype_t *jl_utf8_string_type;
-extern DLLEXPORT jl_datatype_t *jl_errorexception_type;
-extern DLLEXPORT jl_datatype_t *jl_argumenterror_type;
-extern DLLEXPORT jl_datatype_t *jl_loaderror_type;
-extern DLLEXPORT jl_datatype_t *jl_initerror_type;
-extern DLLEXPORT jl_datatype_t *jl_typeerror_type;
-extern DLLEXPORT jl_datatype_t *jl_methoderror_type;
-extern DLLEXPORT jl_datatype_t *jl_undefvarerror_type;
-extern DLLEXPORT jl_value_t *jl_stackovf_exception;
-extern DLLEXPORT jl_value_t *jl_memory_exception;
-extern DLLEXPORT jl_value_t *jl_readonlymemory_exception;
-extern DLLEXPORT jl_value_t *jl_diverror_exception;
-extern DLLEXPORT jl_value_t *jl_domain_exception;
-extern DLLEXPORT jl_value_t *jl_overflow_exception;
-extern DLLEXPORT jl_value_t *jl_inexact_exception;
-extern DLLEXPORT jl_value_t *jl_undefref_exception;
-extern DLLEXPORT jl_value_t *jl_interrupt_exception;
-extern DLLEXPORT jl_datatype_t *jl_boundserror_type;
-extern DLLEXPORT jl_value_t *jl_an_empty_cell;
-
-extern DLLEXPORT jl_datatype_t *jl_bool_type;
-extern DLLEXPORT jl_datatype_t *jl_char_type;
-extern DLLEXPORT jl_datatype_t *jl_int8_type;
-extern DLLEXPORT jl_datatype_t *jl_uint8_type;
-extern DLLEXPORT jl_datatype_t *jl_int16_type;
-extern DLLEXPORT jl_datatype_t *jl_uint16_type;
-extern DLLEXPORT jl_datatype_t *jl_int32_type;
-extern DLLEXPORT jl_datatype_t *jl_uint32_type;
-extern DLLEXPORT jl_datatype_t *jl_int64_type;
-extern DLLEXPORT jl_datatype_t *jl_uint64_type;
-extern DLLEXPORT jl_datatype_t *jl_float32_type;
-extern DLLEXPORT jl_datatype_t *jl_float64_type;
-extern DLLEXPORT jl_datatype_t *jl_floatingpoint_type;
-extern DLLEXPORT jl_datatype_t *jl_number_type;
-extern DLLEXPORT jl_datatype_t *jl_void_type;
-extern DLLEXPORT jl_datatype_t *jl_complex_type;
-extern DLLEXPORT jl_datatype_t *jl_signed_type;
-extern DLLEXPORT jl_datatype_t *jl_voidpointer_type;
-extern DLLEXPORT jl_datatype_t *jl_pointer_type;
-extern DLLEXPORT jl_datatype_t *jl_ref_type;
-
-extern DLLEXPORT jl_value_t *jl_array_uint8_type;
-extern DLLEXPORT jl_value_t *jl_array_any_type;
-extern DLLEXPORT jl_value_t *jl_array_symbol_type;
-extern DLLEXPORT jl_datatype_t *jl_expr_type;
-extern DLLEXPORT jl_datatype_t *jl_symbolnode_type;
-extern DLLEXPORT jl_datatype_t *jl_globalref_type;
-extern DLLEXPORT jl_datatype_t *jl_linenumbernode_type;
-extern DLLEXPORT jl_datatype_t *jl_labelnode_type;
-extern DLLEXPORT jl_datatype_t *jl_gotonode_type;
-extern DLLEXPORT jl_datatype_t *jl_quotenode_type;
-extern DLLEXPORT jl_datatype_t *jl_newvarnode_type;
-extern DLLEXPORT jl_datatype_t *jl_topnode_type;
-extern DLLEXPORT jl_datatype_t *jl_intrinsic_type;
-extern DLLEXPORT jl_datatype_t *jl_methtable_type;
-extern DLLEXPORT jl_datatype_t *jl_method_type;
-
-extern DLLEXPORT jl_svec_t *jl_emptysvec;
-extern DLLEXPORT jl_value_t *jl_emptytuple;
-extern DLLEXPORT jl_value_t *jl_true;
-extern DLLEXPORT jl_value_t *jl_false;
-extern DLLEXPORT jl_value_t *jl_nothing;
+extern JL_DLLEXPORT jl_datatype_t *jl_ntuple_type;
+extern JL_DLLEXPORT jl_typename_t *jl_ntuple_typename;
+extern JL_DLLEXPORT jl_datatype_t *jl_vararg_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_tvar_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_task_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_function_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_builtin_type;
+
+extern JL_DLLEXPORT jl_datatype_t *jl_uniontype_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_datatype_type;
+
+extern JL_DLLEXPORT jl_value_t *jl_bottom_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_lambda_info_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_module_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_abstractarray_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_densearray_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_array_type;
+extern JL_DLLEXPORT jl_typename_t *jl_array_typename;
+extern JL_DLLEXPORT jl_datatype_t *jl_weakref_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_ascii_string_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_utf8_string_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_errorexception_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_argumenterror_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_loaderror_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_initerror_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_typeerror_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_methoderror_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_undefvarerror_type;
+extern JL_DLLEXPORT jl_value_t *jl_stackovf_exception;
+extern JL_DLLEXPORT jl_value_t *jl_memory_exception;
+extern JL_DLLEXPORT jl_value_t *jl_readonlymemory_exception;
+extern JL_DLLEXPORT jl_value_t *jl_diverror_exception;
+extern JL_DLLEXPORT jl_value_t *jl_domain_exception;
+extern JL_DLLEXPORT jl_value_t *jl_overflow_exception;
+extern JL_DLLEXPORT jl_value_t *jl_inexact_exception;
+extern JL_DLLEXPORT jl_value_t *jl_undefref_exception;
+extern JL_DLLEXPORT jl_value_t *jl_interrupt_exception;
+extern JL_DLLEXPORT jl_datatype_t *jl_boundserror_type;
+extern JL_DLLEXPORT jl_value_t *jl_an_empty_cell;
+
+extern JL_DLLEXPORT jl_datatype_t *jl_bool_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_char_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_int8_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_uint8_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_int16_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_uint16_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_int32_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_uint32_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_int64_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_uint64_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_float16_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_float32_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_float64_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_floatingpoint_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_number_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_void_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_complex_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_signed_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_voidpointer_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_pointer_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_ref_type;
+
+extern JL_DLLEXPORT jl_value_t *jl_array_uint8_type;
+extern JL_DLLEXPORT jl_value_t *jl_array_any_type;
+extern JL_DLLEXPORT jl_value_t *jl_array_symbol_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_expr_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_symbolnode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_globalref_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_linenumbernode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_labelnode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_gotonode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_quotenode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_newvarnode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_topnode_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_intrinsic_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_methtable_type;
+extern JL_DLLEXPORT jl_datatype_t *jl_method_type;
+
+extern JL_DLLEXPORT jl_svec_t *jl_emptysvec;
+extern JL_DLLEXPORT jl_value_t *jl_emptytuple;
+extern JL_DLLEXPORT jl_value_t *jl_true;
+extern JL_DLLEXPORT jl_value_t *jl_false;
+extern JL_DLLEXPORT jl_value_t *jl_nothing;
+
+extern JL_DLLEXPORT jl_datatype_t *jl_carnavalue;
 
 // some important symbols
 extern jl_sym_t *call_sym;
@@ -458,7 +474,7 @@ extern jl_sym_t *dots_sym;    extern jl_sym_t *vararg_sym;
 extern jl_sym_t *quote_sym;   extern jl_sym_t *newvar_sym;
 extern jl_sym_t *top_sym;     extern jl_sym_t *dot_sym;
 extern jl_sym_t *line_sym;    extern jl_sym_t *toplevel_sym;
-extern DLLEXPORT jl_sym_t *jl_incomplete_sym;
+extern JL_DLLEXPORT jl_sym_t *jl_incomplete_sym;
 extern jl_sym_t *error_sym;   extern jl_sym_t *amp_sym;
 extern jl_sym_t *module_sym;  extern jl_sym_t *colons_sym;
 extern jl_sym_t *export_sym;  extern jl_sym_t *import_sym;
@@ -467,19 +483,20 @@ extern jl_sym_t *goto_sym;    extern jl_sym_t *goto_ifnot_sym;
 extern jl_sym_t *label_sym;   extern jl_sym_t *return_sym;
 extern jl_sym_t *lambda_sym;  extern jl_sym_t *assign_sym;
 extern jl_sym_t *null_sym;    extern jl_sym_t *body_sym;
-extern jl_sym_t *macro_sym;   extern jl_sym_t *method_sym;
+extern jl_sym_t *method_sym;
 extern jl_sym_t *enter_sym;   extern jl_sym_t *leave_sym;
 extern jl_sym_t *exc_sym;     extern jl_sym_t *new_sym;
-extern jl_sym_t *static_typeof_sym; extern jl_sym_t *kw_sym;
+extern jl_sym_t *static_typeof_sym;
 extern jl_sym_t *const_sym;   extern jl_sym_t *thunk_sym;
 extern jl_sym_t *anonymous_sym;  extern jl_sym_t *underscore_sym;
 extern jl_sym_t *abstracttype_sym; extern jl_sym_t *bitstype_sym;
 extern jl_sym_t *compositetype_sym; extern jl_sym_t *type_goto_sym;
-extern jl_sym_t *global_sym;  extern jl_sym_t *tuple_sym;
-extern jl_sym_t *boundscheck_sym; extern jl_sym_t *copyast_sym;
-extern jl_sym_t *fastmath_sym;
-extern jl_sym_t *simdloop_sym; extern jl_sym_t *meta_sym;
-extern jl_sym_t *arrow_sym; extern jl_sym_t *inert_sym;
+extern jl_sym_t *global_sym; extern jl_sym_t *unused_sym;
+extern jl_sym_t *boundscheck_sym; extern jl_sym_t *inbounds_sym;
+extern jl_sym_t *copyast_sym; extern jl_sym_t *fastmath_sym;
+extern jl_sym_t *pure_sym; extern jl_sym_t *simdloop_sym;
+extern jl_sym_t *meta_sym; extern jl_sym_t *list_sym;
+extern jl_sym_t *inert_sym; extern jl_sym_t *stknew_sym;
 
 // gc -------------------------------------------------------------------------
 
@@ -490,17 +507,15 @@ typedef struct _jl_gcframe_t {
 } jl_gcframe_t;
 
 // NOTE: it is the caller's responsibility to make sure arguments are
-// rooted. foo(f(), g()) will not work, and foo can't do anything about it,
-// so the caller must do
-// jl_value_t *x=NULL, *y=NULL; JL_GC_PUSH(&x, &y);
+// rooted such that the gc can see them on the stack.
+// `foo(f(), g())` is not safe,
+// since the result of `f()` is not rooted during the call to `g()`,
+// and the arguments to foo are not gc-protected during the call to foo.
+// foo can't do anything about it, so the caller must do:
+// jl_value_t *x=NULL, *y=NULL; JL_GC_PUSH2(&x, &y);
 // x = f(); y = g(); foo(x, y)
 
-extern DLLEXPORT JL_THREAD jl_gcframe_t *jl_pgcstack;
-
-#define JL_GC_PUSH(...)                                                   \
-  void *__gc_stkf[] = {(void*)((VA_NARG(__VA_ARGS__)<<1)|1), jl_pgcstack, \
-                       __VA_ARGS__};                                      \
-  jl_pgcstack = (jl_gcframe_t*)__gc_stkf;
+#define jl_pgcstack (jl_get_ptls_states()->pgcstack)
 
 #define JL_GC_PUSH1(arg1)                                                 \
   void *__gc_stkf[] = {(void*)3, jl_pgcstack, arg1};                      \
@@ -524,83 +539,54 @@ extern DLLEXPORT JL_THREAD jl_gcframe_t *jl_pgcstack;
 
 #define JL_GC_PUSHARGS(rts_var,n)                               \
   rts_var = ((jl_value_t**)alloca(((n)+2)*sizeof(jl_value_t*)))+2;    \
-  ((void**)rts_var)[-2] = (void*)(((size_t)n)<<1);              \
+  ((void**)rts_var)[-2] = (void*)(((size_t)(n))<<1);                  \
   ((void**)rts_var)[-1] = jl_pgcstack;                          \
   memset((void*)rts_var, 0, (n)*sizeof(jl_value_t*));           \
   jl_pgcstack = (jl_gcframe_t*)&(((void**)rts_var)[-2])
 
 #define JL_GC_POP() (jl_pgcstack = jl_pgcstack->prev)
 
-void jl_gc_init(void);
-void jl_gc_setmark(jl_value_t *v);
-DLLEXPORT int jl_gc_enable(int on);
-DLLEXPORT int jl_gc_is_enabled(void);
-DLLEXPORT int64_t jl_gc_total_bytes(void);
-DLLEXPORT uint64_t jl_gc_total_hrtime(void);
-DLLEXPORT int64_t jl_gc_diff_total_bytes(void);
-void jl_gc_sync_total_bytes(void);
-
-DLLEXPORT void jl_gc_collect(int);
-DLLEXPORT void jl_gc_preserve(jl_value_t *v);
-DLLEXPORT void jl_gc_unpreserve(void);
-DLLEXPORT int jl_gc_n_preserved_values(void);
-
-DLLEXPORT void jl_gc_add_finalizer(jl_value_t *v, jl_function_t *f);
-DLLEXPORT void jl_finalize(jl_value_t *o);
-DLLEXPORT jl_weakref_t *jl_gc_new_weakref(jl_value_t *value);
-void jl_gc_free_array(jl_array_t *a);
-void jl_gc_track_malloced_array(jl_array_t *a);
-void jl_gc_count_allocd(size_t sz);
-void jl_gc_run_all_finalizers(void);
-DLLEXPORT jl_value_t *jl_gc_alloc_0w(void);
-DLLEXPORT jl_value_t *jl_gc_alloc_1w(void);
-DLLEXPORT jl_value_t *jl_gc_alloc_2w(void);
-DLLEXPORT jl_value_t *jl_gc_alloc_3w(void);
-void *allocb(size_t sz);
-void *reallocb(void*, size_t);
-DLLEXPORT jl_value_t *jl_gc_allocobj(size_t sz);
-
-DLLEXPORT void jl_clear_malloc_data(void);
-DLLEXPORT int64_t jl_gc_num_pause(void);
-DLLEXPORT int64_t jl_gc_num_full_sweep(void);
+JL_DLLEXPORT int jl_gc_enable(int on);
+JL_DLLEXPORT int jl_gc_is_enabled(void);
+JL_DLLEXPORT int64_t jl_gc_total_bytes(void);
+JL_DLLEXPORT uint64_t jl_gc_total_hrtime(void);
+JL_DLLEXPORT int64_t jl_gc_diff_total_bytes(void);
 
-// GC write barriers
-DLLEXPORT void jl_gc_queue_root(jl_value_t *root); // root isa jl_value_t*
-void gc_queue_binding(jl_binding_t *bnd);
-void gc_setmark_buf(void *buf, int);
+JL_DLLEXPORT void jl_gc_collect(int);
 
-static inline void jl_gc_wb_binding(jl_binding_t *bnd, void *val) // val isa jl_value_t*
-{
-    if (__unlikely((jl_astaggedvalue(bnd)->gc_bits & 1) == 1 &&
-                   (jl_astaggedvalue(val)->gc_bits & 1) == 0))
-        gc_queue_binding(bnd);
-}
+JL_DLLEXPORT void jl_gc_add_finalizer(jl_value_t *v, jl_function_t *f);
+JL_DLLEXPORT void jl_finalize(jl_value_t *o);
+JL_DLLEXPORT jl_weakref_t *jl_gc_new_weakref(jl_value_t *value);
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_0w(void);
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_1w(void);
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_2w(void);
+JL_DLLEXPORT jl_value_t *jl_gc_alloc_3w(void);
+JL_DLLEXPORT jl_value_t *jl_gc_allocobj(size_t sz);
+
+JL_DLLEXPORT void jl_clear_malloc_data(void);
 
-static inline void jl_gc_wb(void *parent, void *ptr) // parent and ptr isa jl_value_t*
+// GC write barriers
+JL_DLLEXPORT void jl_gc_queue_root(jl_value_t *root); // root isa jl_value_t*
+
+STATIC_INLINE void jl_gc_wb(void *parent, void *ptr)
 {
-    if (__unlikely((jl_astaggedvalue(parent)->gc_bits & 1) == 1 &&
+    // parent and ptr isa jl_value_t*
+    if (__unlikely((jl_astaggedvalue(parent)->gc_bits & 3) == 1 &&
                    (jl_astaggedvalue(ptr)->gc_bits & 1) == 0))
         jl_gc_queue_root((jl_value_t*)parent);
 }
 
-static inline void jl_gc_wb_buf(void *parent, void *bufptr) // parent isa jl_value_t*
-{
-    // if parent is marked and buf is not
-    if (__unlikely((jl_astaggedvalue(parent)->gc_bits & 1) == 1))
-        //            (jl_astaggedvalue(bufptr)->gc_bits) != 1))
-        gc_setmark_buf(bufptr, jl_astaggedvalue(parent)->gc_bits);
-}
-
-static inline void jl_gc_wb_back(void *ptr) // ptr isa jl_value_t*
+STATIC_INLINE void jl_gc_wb_back(void *ptr) // ptr isa jl_value_t*
 {
     // if ptr is marked
-    if (__unlikely((jl_astaggedvalue(ptr)->gc_bits & 1) == 1)) {
+    if (__unlikely((jl_astaggedvalue(ptr)->gc_bits & 3) == 1)) {
         jl_gc_queue_root((jl_value_t*)ptr);
     }
 }
 
-DLLEXPORT void *jl_gc_managed_malloc(size_t sz);
-DLLEXPORT void *jl_gc_managed_realloc(void *d, size_t sz, size_t oldsz, int isaligned, jl_value_t* owner);
+JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz);
+JL_DLLEXPORT void *jl_gc_managed_realloc(void *d, size_t sz, size_t oldsz,
+                                         int isaligned, jl_value_t *owner);
 
 // object accessors -----------------------------------------------------------
 
@@ -608,7 +594,7 @@ DLLEXPORT void *jl_gc_managed_realloc(void *d, size_t sz, size_t oldsz, int isal
 
 #define jl_svec_len(t)              (((jl_svec_t*)(t))->length)
 #define jl_svec_set_len_unsafe(t,n) (((jl_svec_t*)(t))->length=(n))
-#define jl_svec_data(t)             (((jl_svec_t*)(t))->data)
+#define jl_svec_data(t) ((jl_value_t**)((char*)(t) + sizeof(jl_svec_t)))
 
 STATIC_INLINE jl_value_t *jl_svecref(void *t, size_t i)
 {
@@ -628,14 +614,14 @@ STATIC_INLINE jl_value_t *jl_svecset(void *t, size_t i, void *x)
 #ifdef STORE_ARRAY_LEN
 #define jl_array_len(a)   (((jl_array_t*)(a))->length)
 #else
-DLLEXPORT size_t jl_array_len_(jl_array_t *a);
+JL_DLLEXPORT size_t jl_array_len_(jl_array_t *a);
 #define jl_array_len(a)   jl_array_len_((jl_array_t*)(a))
 #endif
 #define jl_array_data(a)  ((void*)((jl_array_t*)(a))->data)
 #define jl_array_dim(a,i) ((&((jl_array_t*)(a))->nrows)[i])
 #define jl_array_dim0(a)  (((jl_array_t*)(a))->nrows)
 #define jl_array_nrows(a) (((jl_array_t*)(a))->nrows)
-#define jl_array_ndims(a) ((int32_t)(((jl_array_t*)a)->ndims))
+#define jl_array_ndims(a) ((int32_t)(((jl_array_t*)a)->flags.ndims))
 #define jl_array_data_owner_offset(ndims) (offsetof(jl_array_t,ncols) + sizeof(size_t)*(1+jl_array_ndimwords(ndims))) // in bytes
 #define jl_array_data_owner(a) (*((jl_value_t**)((char*)a + jl_array_data_owner_offset(jl_array_ndims(a)))))
 
@@ -649,7 +635,7 @@ STATIC_INLINE jl_value_t *jl_cellset(void *a, size_t i, void *x)
     assert(i < jl_array_len(a));
     ((jl_value_t**)(jl_array_data(a)))[i] = (jl_value_t*)x;
     if (x) {
-        if (((jl_array_t*)a)->how == 3) {
+        if (((jl_array_t*)a)->flags.how == 3) {
             a = jl_array_data_owner(a);
         }
         jl_gc_wb(a, x);
@@ -664,40 +650,95 @@ STATIC_INLINE jl_value_t *jl_cellset(void *a, size_t i, void *x)
 #define jl_fieldref(s,i) jl_get_nth_field(((jl_value_t*)s),i)
 #define jl_nfields(v)    jl_datatype_nfields(jl_typeof(v))
 
-#define jl_symbolnode_sym(s) ((jl_sym_t*)jl_fieldref(s,0))
-#define jl_symbolnode_type(s) (jl_fieldref(s,1))
-#define jl_linenode_file(x) ((jl_sym_t*)jl_fieldref(x,0))
-#define jl_linenode_line(x) (((ptrint_t*)jl_fieldref(x,1))[0])
-#define jl_labelnode_label(x) (((ptrint_t*)x)[0])
-#define jl_gotonode_label(x) (((ptrint_t*)x)[0])
-#define jl_globalref_mod(s) ((jl_module_t*)jl_fieldref(s,0))
-#define jl_globalref_name(s) ((jl_sym_t*)jl_fieldref(s,1))
+// Not using jl_fieldref to avoid allocations
+#define jl_symbolnode_sym(s) (*(jl_sym_t**)s)
+#define jl_symbolnode_type(s) (((jl_value_t**)s)[1])
+#define jl_linenode_file(x) (*(jl_sym_t**)x)
+#define jl_linenode_line(x) (((intptr_t*)x)[1])
+#define jl_labelnode_label(x) (((intptr_t*)x)[0])
+#define jl_gotonode_label(x) (((intptr_t*)x)[0])
+#define jl_globalref_mod(s) (*(jl_module_t**)s)
+#define jl_globalref_name(s) (((jl_sym_t**)s)[1])
 
 #define jl_nparams(t)  jl_svec_len(((jl_datatype_t*)(t))->parameters)
 #define jl_tparam0(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 0)
 #define jl_tparam1(t)  jl_svecref(((jl_datatype_t*)(t))->parameters, 1)
 #define jl_tparam(t,i) jl_svecref(((jl_datatype_t*)(t))->parameters, i)
 
+// get a pointer to the data in a datatype
+#define jl_data_ptr(v)  ((jl_value_t**)v)
+
 #define jl_cell_data(a)   ((jl_value_t**)((jl_array_t*)a)->data)
-#define jl_string_data(s) ((char*)((jl_array_t*)(s)->fieldptr[0])->data)
-#define jl_string_len(s)  (jl_array_len(((jl_array_t*)(s)->fieldptr[0])))
-#define jl_iostr_data(s)  ((char*)((jl_array_t*)(s)->fieldptr[0])->data)
+#define jl_string_data(s) ((char*)((jl_array_t*)jl_data_ptr(s)[0])->data)
+#define jl_string_len(s)  (jl_array_len((jl_array_t*)(jl_data_ptr(s)[0])))
+#define jl_iostr_data(s)  ((char*)((jl_array_t*)jl_data_ptr(s)[0])->data)
 
-#define jl_gf_mtable(f) ((jl_methtable_t*)((jl_function_t*)(f))->env)
+#define jl_gf_mtable(f) (((jl_datatype_t*)jl_typeof(f))->name->mt)
 #define jl_gf_name(f)   (jl_gf_mtable(f)->name)
 
-// get a pointer to the data in a datatype
-#define jl_data_ptr(v)  (((jl_value_t*)v)->fieldptr)
-
 // struct type info
-#define jl_field_offset(st,i)  (((jl_datatype_t*)st)->fields[i].offset)
-#define jl_field_size(st,i)    (((jl_datatype_t*)st)->fields[i].size)
-#define jl_field_isptr(st,i)   (((jl_datatype_t*)st)->fields[i].isptr)
 #define jl_field_name(st,i)    (jl_sym_t*)jl_svecref(((jl_datatype_t*)st)->name->names, (i))
 #define jl_field_type(st,i)    jl_svecref(((jl_datatype_t*)st)->types, (i))
 #define jl_datatype_size(t)    (((jl_datatype_t*)t)->size)
 #define jl_datatype_nfields(t) (((jl_datatype_t*)(t))->nfields)
 
+// inline version with strong type check to detect typos in a `->name` chain
+STATIC_INLINE char *jl_symbol_name_(jl_sym_t *s)
+{
+    return (char*)s + LLT_ALIGN(sizeof(jl_sym_t), sizeof(void*));
+}
+#define jl_symbol_name(s) jl_symbol_name_(s)
+
+#define jl_datatype_fields(d) ((char*)(d) + sizeof(jl_datatype_t))
+
+#define DEFINE_FIELD_ACCESSORS(f)                                       \
+    static inline uint32_t jl_field_##f(jl_datatype_t *st, int i)       \
+    {                                                                   \
+        assert(i >= 0 && (size_t)i < jl_datatype_nfields(st));          \
+        if (st->fielddesc_type == 0) {                                  \
+            return ((jl_fielddesc8_t*)jl_datatype_fields(st))[i].f;     \
+        }                                                               \
+        else if (st->fielddesc_type == 1) {                             \
+            return ((jl_fielddesc16_t*)jl_datatype_fields(st))[i].f;    \
+        }                                                               \
+        else {                                                          \
+            return ((jl_fielddesc32_t*)jl_datatype_fields(st))[i].f;    \
+        }                                                               \
+    }                                                                   \
+    static inline void jl_field_set##f(jl_datatype_t *st, int i,        \
+                                       uint32_t val)                    \
+    {                                                                   \
+        assert(i >= 0 && (size_t)i < jl_datatype_nfields(st));          \
+        if (st->fielddesc_type == 0) {                                  \
+            ((jl_fielddesc8_t*)jl_datatype_fields(st))[i].f = val;      \
+        }                                                               \
+        else if (st->fielddesc_type == 1) {                             \
+            ((jl_fielddesc16_t*)jl_datatype_fields(st))[i].f = val;     \
+        }                                                               \
+        else {                                                          \
+            ((jl_fielddesc32_t*)jl_datatype_fields(st))[i].f = val;     \
+        }                                                               \
+    }
+
+DEFINE_FIELD_ACCESSORS(offset)
+DEFINE_FIELD_ACCESSORS(size)
+DEFINE_FIELD_ACCESSORS(isptr)
+
+static inline uint32_t jl_fielddesc_size(int8_t fielddesc_type)
+{
+    if (fielddesc_type == 0) {
+        return sizeof(jl_fielddesc8_t);
+    }
+    else if (fielddesc_type == 1) {
+        return sizeof(jl_fielddesc16_t);
+    }
+    else {
+        return sizeof(jl_fielddesc32_t);
+    }
+}
+
+#undef DEFINE_FIELD_ACCESSORS
+
 // basic predicates -----------------------------------------------------------
 #define jl_is_nothing(v)     (((jl_value_t*)(v)) == ((jl_value_t*)jl_nothing))
 #define jl_is_tuple(v)       (((jl_datatype_t*)jl_typeof(v))->name == jl_tuple_typename)
@@ -742,14 +783,11 @@ STATIC_INLINE jl_value_t *jl_cellset(void *a, size_t i, void *x)
 #define jl_is_module(v)      jl_typeis(v,jl_module_type)
 #define jl_is_mtable(v)      jl_typeis(v,jl_methtable_type)
 #define jl_is_task(v)        jl_typeis(v,jl_task_type)
-#define jl_is_func(v)        jl_typeis(v,jl_function_type)
-#define jl_is_function(v)    jl_is_func(v)
 #define jl_is_ascii_string(v) jl_typeis(v,jl_ascii_string_type)
 #define jl_is_utf8_string(v) jl_typeis(v,jl_utf8_string_type)
 #define jl_is_byte_string(v) (jl_is_ascii_string(v) || jl_is_utf8_string(v))
 #define jl_is_cpointer(v)    jl_is_cpointer_type(jl_typeof(v))
 #define jl_is_pointer(v)     jl_is_cpointer_type(jl_typeof(v))
-#define jl_is_gf(f)          (((jl_function_t*)(f))->fptr==jl_apply_generic)
 
 STATIC_INLINE int jl_is_bitstype(void *v)
 {
@@ -852,112 +890,104 @@ STATIC_INLINE int jl_is_type_type(jl_value_t *v)
 }
 
 // object identity
-DLLEXPORT int jl_egal(jl_value_t *a, jl_value_t *b);
-DLLEXPORT uptrint_t jl_object_id(jl_value_t *v);
+JL_DLLEXPORT int jl_egal(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT uintptr_t jl_object_id(jl_value_t *v);
 
 // type predicates and basic operations
-int jl_is_type(jl_value_t *v);
-DLLEXPORT int jl_is_leaf_type(jl_value_t *v);
-DLLEXPORT int jl_has_typevars(jl_value_t *v);
-DLLEXPORT int jl_subtype(jl_value_t *a, jl_value_t *b, int ta);
-DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b);
-DLLEXPORT jl_value_t *jl_type_union(jl_svec_t *types);
-jl_value_t *jl_type_union_v(jl_value_t **ts, size_t n);
-jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
-                                          jl_svec_t **penv, jl_svec_t *tvars);
-DLLEXPORT jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b);
-DLLEXPORT int jl_args_morespecific(jl_value_t *a, jl_value_t *b);
-DLLEXPORT const char *jl_typename_str(jl_value_t *v);
-DLLEXPORT const char *jl_typeof_str(jl_value_t *v);
-DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT int jl_is_leaf_type(jl_value_t *v);
+JL_DLLEXPORT int jl_has_typevars(jl_value_t *v);
+JL_DLLEXPORT int jl_subtype(jl_value_t *a, jl_value_t *b, int ta);
+JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_type_union(jl_svec_t *types);
+JL_DLLEXPORT jl_value_t *jl_type_intersection(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT int jl_args_morespecific(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT const char *jl_typename_str(jl_value_t *v);
+JL_DLLEXPORT const char *jl_typeof_str(jl_value_t *v);
+JL_DLLEXPORT int jl_type_morespecific(jl_value_t *a, jl_value_t *b);
 
 // type constructors
-DLLEXPORT jl_typename_t *jl_new_typename(jl_sym_t *name);
-DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name,jl_value_t *lb,jl_value_t *ub);
-jl_typector_t *jl_new_type_ctor(jl_svec_t *params, jl_value_t *body);
-DLLEXPORT jl_value_t *jl_apply_type(jl_value_t *tc, jl_svec_t *params);
-DLLEXPORT jl_tupletype_t *jl_apply_tuple_type(jl_svec_t *params);
-DLLEXPORT jl_tupletype_t *jl_apply_tuple_type_v(jl_value_t **p, size_t np);
-jl_value_t *jl_apply_type_(jl_value_t *tc, jl_value_t **params, size_t n);
-jl_value_t *jl_instantiate_type_with(jl_value_t *t, jl_value_t **env, size_t n);
-jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_datatype_t *super,
-                                   jl_svec_t *parameters);
-DLLEXPORT jl_datatype_t *jl_new_uninitialized_datatype(size_t nfields);
-DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
-                                         jl_svec_t *parameters,
-                                         jl_svec_t *fnames, jl_svec_t *ftypes,
-                                         int abstract, int mutabl, int ninitialized);
-DLLEXPORT jl_datatype_t *jl_new_bitstype(jl_value_t *name, jl_datatype_t *super,
-                                         jl_svec_t *parameters, size_t nbits);
-jl_datatype_t *jl_wrap_Type(jl_value_t *t);  // x -> Type{x}
-jl_datatype_t *jl_wrap_vararg(jl_value_t *t);
+JL_DLLEXPORT jl_typename_t *jl_new_typename(jl_sym_t *name);
+JL_DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name,jl_value_t *lb,jl_value_t *ub);
+JL_DLLEXPORT jl_value_t *jl_apply_type(jl_value_t *tc, jl_svec_t *params);
+JL_DLLEXPORT jl_tupletype_t *jl_apply_tuple_type(jl_svec_t *params);
+JL_DLLEXPORT jl_tupletype_t *jl_apply_tuple_type_v(jl_value_t **p, size_t np);
+JL_DLLEXPORT jl_datatype_t *jl_new_uninitialized_datatype(size_t nfields,
+                                                          int8_t fielddesc_type);
+JL_DLLEXPORT jl_datatype_t *jl_new_datatype(jl_sym_t *name, jl_datatype_t *super,
+                                            jl_svec_t *parameters,
+                                            jl_svec_t *fnames, jl_svec_t *ftypes,
+                                            int abstract, int mutabl,
+                                            int ninitialized);
+JL_DLLEXPORT jl_datatype_t *jl_new_bitstype(jl_value_t *name,
+                                            jl_datatype_t *super,
+                                            jl_svec_t *parameters, size_t nbits);
 
 // constructors
-DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *bt, void *data);
-void jl_assign_bits(void *dest, jl_value_t *bits);
-DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...);
-DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uint32_t na);
-DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type);
-DLLEXPORT jl_function_t *jl_new_closure(jl_fptr_t proc, jl_value_t *env,
-                                        jl_lambda_info_t *li);
-DLLEXPORT jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast, jl_svec_t *sparams, jl_module_t *ctx);
-DLLEXPORT jl_svec_t *jl_svec(size_t n, ...);
-DLLEXPORT jl_svec_t *jl_svec1(void *a);
-DLLEXPORT jl_svec_t *jl_svec2(void *a, void *b);
-DLLEXPORT jl_svec_t *jl_alloc_svec(size_t n);
-DLLEXPORT jl_svec_t *jl_alloc_svec_uninit(size_t n);
-DLLEXPORT jl_svec_t *jl_svec_append(jl_svec_t *a, jl_svec_t *b);
-jl_svec_t *jl_svec_copy(jl_svec_t *a);
-DLLEXPORT jl_svec_t *jl_svec_fill(size_t n, jl_value_t *x);
-DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v);
-DLLEXPORT jl_sym_t *jl_symbol(const char *str);
-DLLEXPORT jl_sym_t *jl_symbol_lookup(const char *str);
-DLLEXPORT jl_sym_t *jl_symbol_n(const char *str, int32_t len);
-DLLEXPORT jl_sym_t *jl_gensym(void);
-DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len);
-DLLEXPORT jl_sym_t *jl_get_root_symbol(void);
-jl_expr_t *jl_exprn(jl_sym_t *head, size_t n);
-jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module);
-void jl_add_method(jl_function_t *gf, jl_tupletype_t *types, jl_function_t *meth,
-                   jl_svec_t *tvars, int8_t isstaged);
-DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp, jl_value_t *bp_owner,
-                                              jl_binding_t *bnd);
-DLLEXPORT jl_value_t *jl_method_def(jl_sym_t *name, jl_value_t **bp, jl_value_t *bp_owner, jl_binding_t *bnd,
-                                    jl_svec_t *argtypes, jl_function_t *f, jl_value_t *isstaged,
-                                    jl_value_t *call_func, int iskw);
-DLLEXPORT jl_value_t *jl_box_bool(int8_t x);
-DLLEXPORT jl_value_t *jl_box_int8(int8_t x);
-DLLEXPORT jl_value_t *jl_box_uint8(uint8_t x);
-DLLEXPORT jl_value_t *jl_box_int16(int16_t x);
-DLLEXPORT jl_value_t *jl_box_uint16(uint16_t x);
-DLLEXPORT jl_value_t *jl_box_int32(int32_t x);
-DLLEXPORT jl_value_t *jl_box_uint32(uint32_t x);
-DLLEXPORT jl_value_t *jl_box_char(uint32_t x);
-DLLEXPORT jl_value_t *jl_box_int64(int64_t x);
-DLLEXPORT jl_value_t *jl_box_uint64(uint64_t x);
-DLLEXPORT jl_value_t *jl_box_float32(float x);
-DLLEXPORT jl_value_t *jl_box_float64(double x);
-DLLEXPORT jl_value_t *jl_box_voidpointer(void *x);
-DLLEXPORT jl_value_t *jl_box_gensym(size_t x);
-DLLEXPORT jl_value_t *jl_box8 (jl_datatype_t *t, int8_t  x);
-DLLEXPORT jl_value_t *jl_box16(jl_datatype_t *t, int16_t x);
-DLLEXPORT jl_value_t *jl_box32(jl_datatype_t *t, int32_t x);
-DLLEXPORT jl_value_t *jl_box64(jl_datatype_t *t, int64_t x);
-DLLEXPORT int8_t jl_unbox_bool(jl_value_t *v);
-DLLEXPORT int8_t jl_unbox_int8(jl_value_t *v);
-DLLEXPORT uint8_t jl_unbox_uint8(jl_value_t *v);
-DLLEXPORT int16_t jl_unbox_int16(jl_value_t *v);
-DLLEXPORT uint16_t jl_unbox_uint16(jl_value_t *v);
-DLLEXPORT int32_t jl_unbox_int32(jl_value_t *v);
-DLLEXPORT uint32_t jl_unbox_uint32(jl_value_t *v);
-DLLEXPORT int64_t jl_unbox_int64(jl_value_t *v);
-DLLEXPORT uint64_t jl_unbox_uint64(jl_value_t *v);
-DLLEXPORT float jl_unbox_float32(jl_value_t *v);
-DLLEXPORT double jl_unbox_float64(jl_value_t *v);
-DLLEXPORT void *jl_unbox_voidpointer(jl_value_t *v);
-DLLEXPORT ssize_t jl_unbox_gensym(jl_value_t *v);
-
-DLLEXPORT int jl_get_size(jl_value_t *val, size_t *pnt);
+JL_DLLEXPORT jl_value_t *jl_new_bits(jl_value_t *bt, void *data);
+JL_DLLEXPORT jl_value_t *jl_new_struct(jl_datatype_t *type, ...);
+JL_DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args,
+                                        uint32_t na);
+JL_DLLEXPORT jl_value_t *jl_new_struct_uninit(jl_datatype_t *type);
+JL_DLLEXPORT jl_function_t *jl_new_closure(jl_fptr_t proc, jl_value_t *env,
+                                           jl_lambda_info_t *li);
+JL_DLLEXPORT jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast,
+                                                  jl_svec_t *tvars,
+                                                  jl_svec_t *sparams,
+                                                  jl_module_t *ctx);
+JL_DLLEXPORT jl_svec_t *jl_svec(size_t n, ...);
+JL_DLLEXPORT jl_svec_t *jl_svec1(void *a);
+JL_DLLEXPORT jl_svec_t *jl_svec2(void *a, void *b);
+JL_DLLEXPORT jl_svec_t *jl_alloc_svec(size_t n);
+JL_DLLEXPORT jl_svec_t *jl_alloc_svec_uninit(size_t n);
+JL_DLLEXPORT jl_svec_t *jl_svec_copy(jl_svec_t *a);
+JL_DLLEXPORT jl_svec_t *jl_svec_fill(size_t n, jl_value_t *x);
+JL_DLLEXPORT jl_value_t *jl_tupletype_fill(size_t n, jl_value_t *v);
+JL_DLLEXPORT jl_sym_t *jl_symbol(const char *str);
+JL_DLLEXPORT jl_sym_t *jl_symbol_lookup(const char *str);
+JL_DLLEXPORT jl_sym_t *jl_symbol_n(const char *str, int32_t len);
+JL_DLLEXPORT jl_sym_t *jl_gensym(void);
+JL_DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len);
+JL_DLLEXPORT jl_sym_t *jl_get_root_symbol(void);
+JL_DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp,
+                                                 jl_value_t *bp_owner,
+                                                 jl_binding_t *bnd);
+JL_DLLEXPORT jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module);
+JL_DLLEXPORT jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_t *module, jl_datatype_t *st, int iskw);
+JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata, jl_lambda_info_t *f, jl_value_t *isstaged);
+JL_DLLEXPORT jl_function_t *jl_get_kwsorter(jl_typename_t *tn);
+JL_DLLEXPORT jl_value_t *jl_box_bool(int8_t x);
+JL_DLLEXPORT jl_value_t *jl_box_int8(int8_t x);
+JL_DLLEXPORT jl_value_t *jl_box_uint8(uint8_t x);
+JL_DLLEXPORT jl_value_t *jl_box_int16(int16_t x);
+JL_DLLEXPORT jl_value_t *jl_box_uint16(uint16_t x);
+JL_DLLEXPORT jl_value_t *jl_box_int32(int32_t x);
+JL_DLLEXPORT jl_value_t *jl_box_uint32(uint32_t x);
+JL_DLLEXPORT jl_value_t *jl_box_char(uint32_t x);
+JL_DLLEXPORT jl_value_t *jl_box_int64(int64_t x);
+JL_DLLEXPORT jl_value_t *jl_box_uint64(uint64_t x);
+JL_DLLEXPORT jl_value_t *jl_box_float32(float x);
+JL_DLLEXPORT jl_value_t *jl_box_float64(double x);
+JL_DLLEXPORT jl_value_t *jl_box_voidpointer(void *x);
+JL_DLLEXPORT jl_value_t *jl_box_gensym(size_t x);
+JL_DLLEXPORT jl_value_t *jl_box8 (jl_datatype_t *t, int8_t  x);
+JL_DLLEXPORT jl_value_t *jl_box16(jl_datatype_t *t, int16_t x);
+JL_DLLEXPORT jl_value_t *jl_box32(jl_datatype_t *t, int32_t x);
+JL_DLLEXPORT jl_value_t *jl_box64(jl_datatype_t *t, int64_t x);
+JL_DLLEXPORT int8_t jl_unbox_bool(jl_value_t *v);
+JL_DLLEXPORT int8_t jl_unbox_int8(jl_value_t *v);
+JL_DLLEXPORT uint8_t jl_unbox_uint8(jl_value_t *v);
+JL_DLLEXPORT int16_t jl_unbox_int16(jl_value_t *v);
+JL_DLLEXPORT uint16_t jl_unbox_uint16(jl_value_t *v);
+JL_DLLEXPORT int32_t jl_unbox_int32(jl_value_t *v);
+JL_DLLEXPORT uint32_t jl_unbox_uint32(jl_value_t *v);
+JL_DLLEXPORT int64_t jl_unbox_int64(jl_value_t *v);
+JL_DLLEXPORT uint64_t jl_unbox_uint64(jl_value_t *v);
+JL_DLLEXPORT float jl_unbox_float32(jl_value_t *v);
+JL_DLLEXPORT double jl_unbox_float64(jl_value_t *v);
+JL_DLLEXPORT void *jl_unbox_voidpointer(jl_value_t *v);
+JL_DLLEXPORT ssize_t jl_unbox_gensym(jl_value_t *v);
+
+JL_DLLEXPORT int jl_get_size(jl_value_t *val, size_t *pnt);
 
 #ifdef _P64
 #define jl_box_long(x)   jl_box_int64(x)
@@ -974,133 +1004,139 @@ DLLEXPORT int jl_get_size(jl_value_t *val, size_t *pnt);
 #endif
 
 // structs
-DLLEXPORT int         jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err);
-DLLEXPORT jl_value_t *jl_get_nth_field(jl_value_t *v, size_t i);
-DLLEXPORT jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i);
-DLLEXPORT void        jl_set_nth_field(jl_value_t *v, size_t i, jl_value_t *rhs);
-DLLEXPORT int         jl_field_isdefined(jl_value_t *v, size_t i);
-DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld);
-DLLEXPORT jl_value_t *jl_value_ptr(jl_value_t *a);
+JL_DLLEXPORT int         jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err);
+JL_DLLEXPORT jl_value_t *jl_get_nth_field(jl_value_t *v, size_t i);
+JL_DLLEXPORT jl_value_t *jl_get_nth_field_checked(jl_value_t *v, size_t i);
+JL_DLLEXPORT void        jl_set_nth_field(jl_value_t *v, size_t i,
+                                          jl_value_t *rhs);
+JL_DLLEXPORT int         jl_field_isdefined(jl_value_t *v, size_t i);
+JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld);
+JL_DLLEXPORT jl_value_t *jl_value_ptr(jl_value_t *a);
 
 // arrays
 
-DLLEXPORT jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *dims);
-DLLEXPORT jl_array_t *jl_new_arrayv(jl_value_t *atype, ...);
-DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
-                                       jl_value_t *dims);
-DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
-                                         size_t nel, int own_buffer);
-DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
-                                      jl_value_t *dims, int own_buffer);
-int jl_array_store_unboxed(jl_value_t *el_type);
-
-DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr);
-DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr, size_t nc);
-DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr, size_t nc,
-                                        size_t z);
-DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len);
-DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len);
-DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str);
-DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a);
-DLLEXPORT jl_array_t *jl_alloc_cell_1d(size_t n);
-DLLEXPORT jl_value_t *jl_arrayref(jl_array_t *a, size_t i);  // 0-indexed
-DLLEXPORT void jl_arrayset(jl_array_t *a, jl_value_t *v, size_t i);  // 0-indexed
-DLLEXPORT void jl_arrayunset(jl_array_t *a, size_t i);  // 0-indexed
-int jl_array_isdefined(jl_value_t **args, int nargs);
-DLLEXPORT void jl_array_grow_end(jl_array_t *a, size_t inc);
-DLLEXPORT void jl_array_del_end(jl_array_t *a, size_t dec);
-DLLEXPORT void jl_array_grow_beg(jl_array_t *a, size_t inc);
-DLLEXPORT void jl_array_del_beg(jl_array_t *a, size_t dec);
-DLLEXPORT void jl_array_sizehint(jl_array_t *a, size_t sz);
-DLLEXPORT void jl_cell_1d_push(jl_array_t *a, jl_value_t *item);
-DLLEXPORT jl_value_t *jl_apply_array_type(jl_datatype_t *type, size_t dim);
+JL_DLLEXPORT jl_array_t *jl_new_array(jl_value_t *atype, jl_value_t *dims);
+JL_DLLEXPORT jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data,
+                                          jl_value_t *dims);
+JL_DLLEXPORT jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data,
+                                            size_t nel, int own_buffer);
+JL_DLLEXPORT jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data,
+                                         jl_value_t *dims, int own_buffer);
+
+JL_DLLEXPORT jl_array_t *jl_alloc_array_1d(jl_value_t *atype, size_t nr);
+JL_DLLEXPORT jl_array_t *jl_alloc_array_2d(jl_value_t *atype, size_t nr,
+                                           size_t nc);
+JL_DLLEXPORT jl_array_t *jl_alloc_array_3d(jl_value_t *atype, size_t nr,
+                                           size_t nc, size_t z);
+JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len);
+JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len);
+JL_DLLEXPORT jl_value_t *jl_cstr_to_string(const char *str);
+JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a);
+JL_DLLEXPORT jl_array_t *jl_alloc_cell_1d(size_t n);
+JL_DLLEXPORT jl_value_t *jl_arrayref(jl_array_t *a, size_t i);  // 0-indexed
+JL_DLLEXPORT void jl_arrayset(jl_array_t *a, jl_value_t *v, size_t i);  // 0-indexed
+JL_DLLEXPORT void jl_arrayunset(jl_array_t *a, size_t i);  // 0-indexed
+JL_DLLEXPORT void jl_array_grow_end(jl_array_t *a, size_t inc);
+JL_DLLEXPORT void jl_array_del_end(jl_array_t *a, size_t dec);
+JL_DLLEXPORT void jl_array_grow_beg(jl_array_t *a, size_t inc);
+JL_DLLEXPORT void jl_array_del_beg(jl_array_t *a, size_t dec);
+JL_DLLEXPORT void jl_array_sizehint(jl_array_t *a, size_t sz);
+JL_DLLEXPORT void jl_cell_1d_push(jl_array_t *a, jl_value_t *item);
+JL_DLLEXPORT jl_value_t *jl_apply_array_type(jl_datatype_t *type, size_t dim);
 // property access
-DLLEXPORT void *jl_array_ptr(jl_array_t *a);
-DLLEXPORT void *jl_array_eltype(jl_value_t *a);
-DLLEXPORT int jl_array_rank(jl_value_t *a);
-DLLEXPORT size_t jl_array_size(jl_value_t *a, int d);
+JL_DLLEXPORT void *jl_array_ptr(jl_array_t *a);
+JL_DLLEXPORT void *jl_array_eltype(jl_value_t *a);
+JL_DLLEXPORT int jl_array_rank(jl_value_t *a);
+JL_DLLEXPORT size_t jl_array_size(jl_value_t *a, int d);
 
 // strings
-DLLEXPORT const char *jl_bytestring_ptr(jl_value_t *s);
+JL_DLLEXPORT const char *jl_bytestring_ptr(jl_value_t *s);
 
 // modules and global variables
-extern DLLEXPORT jl_module_t *jl_main_module;
-extern DLLEXPORT jl_module_t *jl_internal_main_module;
-extern DLLEXPORT jl_module_t *jl_core_module;
-extern DLLEXPORT jl_module_t *jl_base_module;
-extern DLLEXPORT jl_module_t *jl_top_module;
-extern DLLEXPORT jl_module_t *jl_current_module;
-DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name);
+extern JL_DLLEXPORT jl_module_t *jl_main_module;
+extern JL_DLLEXPORT jl_module_t *jl_internal_main_module;
+extern JL_DLLEXPORT jl_module_t *jl_core_module;
+extern JL_DLLEXPORT jl_module_t *jl_base_module;
+extern JL_DLLEXPORT jl_module_t *jl_top_module;
+#define jl_current_module (jl_get_ptls_states()->current_module)
+JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name);
 // get binding for reading
-DLLEXPORT jl_binding_t *jl_get_binding(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT jl_binding_t *jl_get_binding_or_error(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT jl_value_t *jl_module_globalref(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT jl_binding_t *jl_get_binding(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT jl_binding_t *jl_get_binding_or_error(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT jl_value_t *jl_module_globalref(jl_module_t *m, jl_sym_t *var);
 // get binding for assignment
-DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT int jl_binding_resolved_p(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m, jl_sym_t *var);
-DLLEXPORT void jl_set_global(jl_module_t *m, jl_sym_t *var, jl_value_t *val);
-DLLEXPORT void jl_set_const(jl_module_t *m, jl_sym_t *var, jl_value_t *val);
-DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_value_t *rhs);
-DLLEXPORT void jl_declare_constant(jl_binding_t *b);
-DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from);
-DLLEXPORT void jl_module_use(jl_module_t *to, jl_module_t *from, jl_sym_t *s);
-DLLEXPORT void jl_module_import(jl_module_t *to, jl_module_t *from, jl_sym_t *s);
-DLLEXPORT void jl_module_importall(jl_module_t *to, jl_module_t *from);
-DLLEXPORT void jl_module_export(jl_module_t *from, jl_sym_t *s);
-DLLEXPORT int jl_is_imported(jl_module_t *m, jl_sym_t *s);
-DLLEXPORT jl_module_t *jl_new_main_module(void);
-DLLEXPORT void jl_add_standard_imports(jl_module_t *m);
+JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m,
+                                                         jl_sym_t *var);
+JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT int jl_binding_resolved_p(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m, jl_sym_t *var);
+JL_DLLEXPORT void jl_set_global(jl_module_t *m, jl_sym_t *var, jl_value_t *val);
+JL_DLLEXPORT void jl_set_const(jl_module_t *m, jl_sym_t *var, jl_value_t *val);
+JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_value_t *rhs);
+JL_DLLEXPORT void jl_declare_constant(jl_binding_t *b);
+JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from);
+JL_DLLEXPORT void jl_module_use(jl_module_t *to, jl_module_t *from, jl_sym_t *s);
+JL_DLLEXPORT void jl_module_import(jl_module_t *to, jl_module_t *from,
+                                   jl_sym_t *s);
+JL_DLLEXPORT void jl_module_importall(jl_module_t *to, jl_module_t *from);
+JL_DLLEXPORT void jl_module_export(jl_module_t *from, jl_sym_t *s);
+JL_DLLEXPORT int jl_is_imported(jl_module_t *m, jl_sym_t *s);
+JL_DLLEXPORT jl_module_t *jl_new_main_module(void);
+JL_DLLEXPORT void jl_add_standard_imports(jl_module_t *m);
 STATIC_INLINE jl_function_t *jl_get_function(jl_module_t *m, const char *name)
 {
-    return  (jl_function_t*) jl_get_global(m, jl_symbol(name));
+    return (jl_function_t*)jl_get_global(m, jl_symbol(name));
 }
-DLLEXPORT void jl_module_run_initializer(jl_module_t *m);
-jl_function_t *jl_module_call_func(jl_module_t *m);
+JL_DLLEXPORT void jl_module_run_initializer(jl_module_t *m);
 int jl_is_submodule(jl_module_t *child, jl_module_t *parent);
 
 // eq hash tables
-DLLEXPORT jl_array_t *jl_eqtable_put(jl_array_t *h, void *key, void *val);
-DLLEXPORT jl_value_t *jl_eqtable_get(jl_array_t *h, void *key, jl_value_t *deflt);
+JL_DLLEXPORT jl_array_t *jl_eqtable_put(jl_array_t *h, void *key, void *val);
+JL_DLLEXPORT jl_value_t *jl_eqtable_get(jl_array_t *h, void *key,
+                                        jl_value_t *deflt);
 
 // system information
-DLLEXPORT int jl_errno(void);
-DLLEXPORT void jl_set_errno(int e);
-DLLEXPORT int32_t jl_stat(const char *path, char *statbuf);
-DLLEXPORT int jl_cpu_cores(void);
-DLLEXPORT long jl_getpagesize(void);
-DLLEXPORT long jl_getallocationgranularity(void);
-DLLEXPORT int jl_is_debugbuild(void);
-DLLEXPORT jl_sym_t* jl_get_OS_NAME();
-DLLEXPORT jl_sym_t* jl_get_ARCH();
+JL_DLLEXPORT int jl_errno(void);
+JL_DLLEXPORT void jl_set_errno(int e);
+JL_DLLEXPORT int32_t jl_stat(const char *path, char *statbuf);
+JL_DLLEXPORT int jl_cpu_cores(void);
+JL_DLLEXPORT long jl_getpagesize(void);
+JL_DLLEXPORT long jl_getallocationgranularity(void);
+JL_DLLEXPORT int jl_is_debugbuild(void);
+JL_DLLEXPORT jl_sym_t *jl_get_OS_NAME(void);
+JL_DLLEXPORT jl_sym_t *jl_get_ARCH(void);
 
 // environment entries
-DLLEXPORT jl_value_t *jl_environ(int i);
+JL_DLLEXPORT jl_value_t *jl_environ(int i);
 
 // throwing common exceptions
-DLLEXPORT void NORETURN jl_error(const char *str);
-DLLEXPORT void NORETURN jl_errorf(const char *fmt, ...);
-DLLEXPORT void NORETURN jl_exceptionf(jl_datatype_t *ty, const char *fmt, ...);
-DLLEXPORT void NORETURN jl_too_few_args(const char *fname, int min);
-DLLEXPORT void NORETURN jl_too_many_args(const char *fname, int max);
-DLLEXPORT void NORETURN jl_type_error(const char *fname, jl_value_t *expected, jl_value_t *got);
-DLLEXPORT void NORETURN jl_type_error_rt(const char *fname, const char *context,
-                                jl_value_t *ty, jl_value_t *got);
-DLLEXPORT void NORETURN jl_type_error_rt_line(const char *fname, const char *context,
-                                     jl_value_t *ty, jl_value_t *got, int line);
-DLLEXPORT void NORETURN jl_undefined_var_error(jl_sym_t *var);
-DLLEXPORT void NORETURN jl_bounds_error(jl_value_t *v, jl_value_t *t);
-DLLEXPORT void NORETURN jl_bounds_error_v(jl_value_t *v, jl_value_t **idxs, size_t nidxs);
-DLLEXPORT void NORETURN jl_bounds_error_int(jl_value_t *v, size_t i);
-DLLEXPORT void NORETURN jl_bounds_error_tuple_int(jl_value_t **v, size_t nv, size_t i);
-DLLEXPORT void NORETURN jl_bounds_error_unboxed_int(void *v, jl_value_t *vt, size_t i);
-DLLEXPORT void NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs, size_t nidxs);
-DLLEXPORT jl_value_t *jl_exception_occurred(void);
-DLLEXPORT void jl_exception_clear(void);
+JL_DLLEXPORT void JL_NORETURN jl_error(const char *str);
+JL_DLLEXPORT void JL_NORETURN jl_errorf(const char *fmt, ...);
+JL_DLLEXPORT void JL_NORETURN jl_exceptionf(jl_datatype_t *ty,
+                                            const char *fmt, ...);
+JL_DLLEXPORT void JL_NORETURN jl_too_few_args(const char *fname, int min);
+JL_DLLEXPORT void JL_NORETURN jl_too_many_args(const char *fname, int max);
+JL_DLLEXPORT void JL_NORETURN jl_type_error(const char *fname,
+                                            jl_value_t *expected,
+                                            jl_value_t *got);
+JL_DLLEXPORT void JL_NORETURN jl_type_error_rt(const char *fname,
+                                               const char *context,
+                                               jl_value_t *ty, jl_value_t *got);
+JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var);
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error(jl_value_t *v, jl_value_t *t);
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_v(jl_value_t *v,
+                                                jl_value_t **idxs, size_t nidxs);
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_int(jl_value_t *v, size_t i);
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_tuple_int(jl_value_t **v,
+                                                        size_t nv, size_t i);
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_unboxed_int(void *v, jl_value_t *vt, size_t i);
+JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs, size_t nidxs);
+JL_DLLEXPORT void JL_NORETURN jl_eof_error(void);
+JL_DLLEXPORT jl_value_t *jl_exception_occurred(void);
+JL_DLLEXPORT void jl_exception_clear(void);
 
 #define JL_NARGS(fname, min, max)                               \
     if (nargs < min) jl_too_few_args(#fname, min);              \
@@ -1124,39 +1160,33 @@ typedef enum {
     JL_IMAGE_JULIA_HOME = 1,
     //JL_IMAGE_LIBJULIA = 2,
 } JL_IMAGE_SEARCH;
-DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel);
-DLLEXPORT void jl_init(const char *julia_home_dir);
-DLLEXPORT void jl_init_with_image(const char *julia_home_dir, const char *image_relative_path);
-DLLEXPORT int jl_is_initialized(void);
-DLLEXPORT int julia_trampoline(int argc, const char *argv[], int (*pmain)(int ac,char *av[]));
-DLLEXPORT void jl_atexit_hook(int status);
-DLLEXPORT void NORETURN jl_exit(int status);
-
-DLLEXPORT int jl_deserialize_verify_header(ios_t *s);
-DLLEXPORT void jl_preload_sysimg_so(const char *fname);
-DLLEXPORT ios_t *jl_create_system_image(void);
-DLLEXPORT void jl_save_system_image(const char *fname);
-DLLEXPORT void jl_restore_system_image(const char *fname);
-DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len);
-DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t* worklist);
-DLLEXPORT jl_value_t *jl_restore_incremental(const char *fname);
-DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(const char *buf, size_t sz);
-void jl_init_restored_modules(jl_array_t *init_order);
+JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel);
+JL_DLLEXPORT void jl_init(const char *julia_home_dir);
+JL_DLLEXPORT void jl_init_with_image(const char *julia_home_dir,
+                                     const char *image_relative_path);
+JL_DLLEXPORT int jl_is_initialized(void);
+JL_DLLEXPORT void jl_atexit_hook(int status);
+JL_DLLEXPORT void JL_NORETURN jl_exit(int status);
+
+JL_DLLEXPORT int jl_deserialize_verify_header(ios_t *s);
+JL_DLLEXPORT void jl_preload_sysimg_so(const char *fname);
+JL_DLLEXPORT ios_t *jl_create_system_image(void);
+JL_DLLEXPORT void jl_save_system_image(const char *fname);
+JL_DLLEXPORT void jl_restore_system_image(const char *fname);
+JL_DLLEXPORT void jl_restore_system_image_data(const char *buf, size_t len);
+JL_DLLEXPORT int jl_save_incremental(const char *fname, jl_array_t *worklist);
+JL_DLLEXPORT jl_value_t *jl_restore_incremental(const char *fname);
+JL_DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(const char *buf, size_t sz);
 
 // front end interface
-DLLEXPORT jl_value_t *jl_parse_input_line(const char *str, size_t len);
-DLLEXPORT jl_value_t *jl_parse_string(const char *str, size_t len,
-                                      int pos0, int greedy);
-DLLEXPORT int jl_parse_depwarn(int warn);
-int jl_start_parsing_file(const char *fname);
-void jl_stop_parsing(void);
-jl_value_t *jl_parse_next(void);
-DLLEXPORT jl_value_t *jl_load_file_string(const char *text, size_t len,
-                                          char *filename, size_t namelen);
-DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr);
-DLLEXPORT jl_value_t *jl_expand_in(jl_module_t *module, jl_value_t *expr);
-jl_lambda_info_t *jl_wrap_expr(jl_value_t *expr);
-DLLEXPORT void *jl_eval_string(const char *str);
+JL_DLLEXPORT jl_value_t *jl_parse_input_line(const char *str, size_t len);
+JL_DLLEXPORT jl_value_t *jl_parse_string(const char *str, size_t len,
+                                         int pos0, int greedy);
+JL_DLLEXPORT int jl_parse_depwarn(int warn);
+JL_DLLEXPORT jl_value_t *jl_load_file_string(const char *text, size_t len,
+                                             char *filename, size_t namelen);
+JL_DLLEXPORT jl_value_t *jl_expand(jl_value_t *expr);
+JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str);
 
 // external libraries
 enum JL_RTLD_CONSTANT {
@@ -1174,83 +1204,47 @@ enum JL_RTLD_CONSTANT {
 };
 #define JL_RTLD_DEFAULT (JL_RTLD_LAZY | JL_RTLD_DEEPBIND)
 
-typedef void *jl_uv_libhandle; // uv_lib_t* (avoid uv.h dependency)
-DLLEXPORT jl_uv_libhandle jl_load_dynamic_library(const char *fname, unsigned flags);
-DLLEXPORT jl_uv_libhandle jl_load_dynamic_library_e(const char *fname, unsigned flags);
-DLLEXPORT void *jl_dlsym_e(jl_uv_libhandle handle, const char *symbol);
-DLLEXPORT void *jl_dlsym(jl_uv_libhandle handle, const char *symbol);
-DLLEXPORT int jl_uv_dlopen(const char *filename, jl_uv_libhandle lib, unsigned flags);
-char *jl_dlfind_win32(const char *name);
-DLLEXPORT int add_library_mapping(char *lib, void *hnd);
+typedef void *jl_uv_libhandle; // compatible with dlopen (void*) / LoadLibrary (HMODULE)
+JL_DLLEXPORT jl_uv_libhandle jl_load_dynamic_library(const char *fname, unsigned flags);
+JL_DLLEXPORT jl_uv_libhandle jl_load_dynamic_library_e(const char *fname, unsigned flags);
+JL_DLLEXPORT jl_uv_libhandle jl_dlopen(const char *filename, unsigned flags);
+JL_DLLEXPORT int jl_dlclose(jl_uv_libhandle handle);
+JL_DLLEXPORT void *jl_dlsym_e(jl_uv_libhandle handle, const char *symbol);
+JL_DLLEXPORT void *jl_dlsym(jl_uv_libhandle handle, const char *symbol);
 
 #if defined(__linux__) || defined(__FreeBSD__)
-DLLEXPORT const char *jl_lookup_soname(const char *pfx, size_t n);
+JL_DLLEXPORT const char *jl_lookup_soname(const char *pfx, size_t n);
 #endif
 
 // compiler
-void jl_compile(jl_function_t *f);
-DLLEXPORT jl_value_t *jl_toplevel_eval(jl_value_t *v);
-DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex, int delay_warn);
-jl_value_t *jl_eval_global_var(jl_module_t *m, jl_sym_t *e);
-DLLEXPORT jl_value_t *jl_load(const char *fname, size_t len);
-jl_value_t *jl_parse_eval_all(const char *fname, size_t len);
-jl_value_t *jl_interpret_toplevel_thunk(jl_lambda_info_t *lam);
-jl_value_t *jl_interpret_toplevel_thunk_with(jl_lambda_info_t *lam,
-                                             jl_value_t **loc, size_t nl);
-jl_value_t *jl_interpret_toplevel_expr(jl_value_t *e);
-DLLEXPORT jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m, jl_value_t *e,
-                                                    jl_value_t **locals, size_t nl);
-jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
-                           jl_value_t *sp, jl_expr_t *ast, int sparams, int allow_alloc);
-int jl_is_toplevel_only_expr(jl_value_t *e);
-DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m);
-void jl_type_infer(jl_lambda_info_t *li, jl_tupletype_t *argtypes, jl_lambda_info_t *def);
-
-jl_function_t *jl_method_lookup_by_type(jl_methtable_t *mt, jl_tupletype_t *types,
-                                        int cache, int inexact);
-jl_function_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t nargs, int cache);
-jl_value_t *jl_gf_invoke(jl_function_t *gf, jl_tupletype_t *types,
-                         jl_value_t **args, size_t nargs);
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_value_t *v);
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex);
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in_warn(jl_module_t *m, jl_value_t *ex,
+                                                  int delay_warn);
+JL_DLLEXPORT jl_value_t *jl_load(const char *fname, size_t len);
+JL_DLLEXPORT jl_value_t *jl_interpret_toplevel_expr_in(jl_module_t *m,
+                                                       jl_value_t *e,
+                                                       jl_svec_t *local_syms,
+                                                       jl_svec_t *local_vals);
+JL_DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m);
 
 // AST access
-jl_array_t *jl_lam_args(jl_expr_t *l);
-jl_array_t *jl_lam_vinfo(jl_expr_t *l);
-jl_array_t *jl_lam_capt(jl_expr_t *l);
-jl_value_t *jl_lam_gensyms(jl_expr_t *l);
-jl_array_t *jl_lam_staticparams(jl_expr_t *l);
-jl_sym_t *jl_lam_argname(jl_lambda_info_t *li, int i);
-int jl_lam_vars_captured(jl_expr_t *ast);
-jl_expr_t *jl_lam_body(jl_expr_t *l);
-int jl_in_vinfo_array(jl_array_t *a, jl_sym_t *v);
-int jl_local_in_ast(jl_expr_t *ast, jl_sym_t *sym);
-DLLEXPORT jl_value_t *jl_ast_rettype(jl_lambda_info_t *li, jl_value_t *ast);
-jl_sym_t *jl_decl_var(jl_value_t *ex);
-DLLEXPORT int jl_is_rest_arg(jl_value_t *ex);
-
-DLLEXPORT jl_value_t *jl_prepare_ast(jl_lambda_info_t *li, jl_svec_t *sparams);
-DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr);
-
-DLLEXPORT jl_value_t *jl_compress_ast(jl_lambda_info_t *li, jl_value_t *ast);
-DLLEXPORT jl_value_t *jl_uncompress_ast(jl_lambda_info_t *li, jl_value_t *data);
-
-DLLEXPORT int jl_is_operator(char *sym);
-DLLEXPORT int jl_operator_precedence(char *sym);
-
-STATIC_INLINE int jl_vinfo_capt(jl_array_t *vi)
-{
-    return (jl_unbox_long(jl_cellref(vi,2))&1)!=0;
-}
+JL_DLLEXPORT int jl_is_rest_arg(jl_value_t *ex);
+
+JL_DLLEXPORT jl_value_t *jl_prepare_ast(jl_lambda_info_t *li);
+JL_DLLEXPORT jl_value_t *jl_copy_ast(jl_value_t *expr);
+
+JL_DLLEXPORT jl_value_t *jl_compress_ast(jl_lambda_info_t *li, jl_value_t *ast);
+JL_DLLEXPORT jl_value_t *jl_uncompress_ast(jl_lambda_info_t *li, jl_value_t *data);
+
+JL_DLLEXPORT int jl_is_operator(char *sym);
+JL_DLLEXPORT int jl_operator_precedence(char *sym);
 
 STATIC_INLINE int jl_vinfo_assigned(jl_array_t *vi)
 {
     return (jl_unbox_long(jl_cellref(vi,2))&2)!=0;
 }
 
-STATIC_INLINE int jl_vinfo_assigned_inner(jl_array_t *vi)
-{
-    return (jl_unbox_long(jl_cellref(vi,2))&4)!=0;
-}
-
 STATIC_INLINE int jl_vinfo_sa(jl_array_t *vi)
 {
     return (jl_unbox_long(jl_cellref(vi,2))&16)!=0;
@@ -1263,43 +1257,45 @@ STATIC_INLINE int jl_vinfo_usedundef(jl_array_t *vi)
 
 // calling into julia ---------------------------------------------------------
 
+JL_DLLEXPORT jl_value_t *jl_apply_generic(jl_value_t **args, uint32_t nargs);
+
 STATIC_INLINE
-jl_value_t *jl_apply(jl_function_t *f, jl_value_t **args, uint32_t nargs)
+jl_value_t *jl_apply(jl_value_t **args, uint32_t nargs)
 {
-    return f->fptr((jl_value_t*)f, args, nargs);
+    return jl_apply_generic(args, nargs);
 }
 
-DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs);
-DLLEXPORT jl_value_t *jl_call0(jl_function_t *f);
-DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a);
-DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b);
-DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a, jl_value_t *b, jl_value_t *c);
+JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs);
+JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f);
+JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
+                                  jl_value_t *b, jl_value_t *c);
 
 // interfacing with Task runtime
-DLLEXPORT void jl_yield(void);
+JL_DLLEXPORT void jl_yield(void);
 
 // async signal handling ------------------------------------------------------
 
 #include <signal.h>
 
-DLLEXPORT extern volatile sig_atomic_t jl_signal_pending;
-DLLEXPORT extern volatile sig_atomic_t jl_defer_signal;
+JL_DLLEXPORT extern volatile sig_atomic_t jl_signal_pending;
+JL_DLLEXPORT extern volatile sig_atomic_t jl_defer_signal;
 
-#define JL_SIGATOMIC_BEGIN() (jl_defer_signal++)
+#define JL_SIGATOMIC_BEGIN() jl_atomic_fetch_add(&jl_defer_signal, 1)
 #define JL_SIGATOMIC_END()                                      \
     do {                                                        \
-        jl_defer_signal--;                                      \
-        if (jl_defer_signal == 0 && jl_signal_pending != 0) {   \
+        if (jl_atomic_fetch_add(&jl_defer_signal, -1) == 1      \
+            && jl_signal_pending != 0) {                        \
             jl_signal_pending = 0;                              \
             jl_sigint_action();                                 \
         }                                                       \
     } while(0)
 
-DLLEXPORT void jl_sigint_action(void);
-DLLEXPORT void restore_signals(void);
-DLLEXPORT void jl_install_sigint_handler(void);
-DLLEXPORT void jl_sigatomic_begin(void);
-DLLEXPORT void jl_sigatomic_end(void);
+JL_DLLEXPORT void jl_sigint_action(void);
+JL_DLLEXPORT void jl_install_sigint_handler(void);
+JL_DLLEXPORT void jl_sigatomic_begin(void);
+JL_DLLEXPORT void jl_sigatomic_end(void);
 
 // tasks and exceptions -------------------------------------------------------
 
@@ -1308,12 +1304,15 @@ typedef struct _jl_handler_t {
     jl_jmp_buf eh_ctx;
     jl_gcframe_t *gcstack;
     struct _jl_handler_t *prev;
+    int8_t gc_state;
+#ifdef JULIA_ENABLE_THREADING
+    size_t locks_len;
+#endif
 } jl_handler_t;
 
 typedef struct _jl_task_t {
     JL_DATA_TYPE
     struct _jl_task_t *parent;
-    struct _jl_task_t *last;
     jl_value_t *tls;
     jl_sym_t *state;
     jl_value_t *consumers;
@@ -1323,12 +1322,10 @@ typedef struct _jl_task_t {
     jl_value_t *backtrace;
     jl_function_t *start;
     jl_jmp_buf ctx;
-#ifndef COPY_STACKS
-    void *stack;
-#endif
     size_t bufsz;
     void *stkbuf;
-    size_t ssize;
+    size_t ssize:31;
+    size_t started:1;
 
     // current exception handler
     jl_handler_t *eh;
@@ -1336,29 +1333,70 @@ typedef struct _jl_task_t {
     jl_gcframe_t *gcstack;
     // current module, or NULL if this task has not set one
     jl_module_t *current_module;
-} jl_task_t;
 
-extern DLLEXPORT JL_THREAD jl_task_t * volatile jl_current_task;
-extern DLLEXPORT JL_THREAD jl_task_t *jl_root_task;
-extern DLLEXPORT JL_THREAD jl_value_t *jl_exception_in_transit;
+    // id of owning thread
+    // does not need to be defined until the task runs
+    int16_t tid;
+#ifdef JULIA_ENABLE_THREADING
+    // This is statically initialized when the task is not holding any locks
+    arraylist_t locks;
+#endif
+} jl_task_t;
 
-DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize);
-DLLEXPORT jl_value_t *jl_switchto(jl_task_t *t, jl_value_t *arg);
-DLLEXPORT void NORETURN jl_throw(jl_value_t *e);
-DLLEXPORT void NORETURN jl_throw_with_superfluous_argument(jl_value_t *e, int);
-DLLEXPORT void NORETURN jl_rethrow(void);
-DLLEXPORT void NORETURN jl_rethrow_other(jl_value_t *e);
+typedef struct {
+    jl_tls_states_t *ptls;
+    uv_thread_t system_id;
+    void *signal_stack;
+} jl_thread_task_state_t;
+
+#define jl_current_task (jl_get_ptls_states()->current_task)
+#define jl_root_task (jl_get_ptls_states()->root_task)
+#define jl_exception_in_transit (jl_get_ptls_states()->exception_in_transit)
+#define jl_task_arg_in_transit (jl_get_ptls_states()->task_arg_in_transit)
+
+JL_DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize);
+JL_DLLEXPORT jl_value_t *jl_switchto(jl_task_t *t, jl_value_t *arg);
+JL_DLLEXPORT void JL_NORETURN jl_throw(jl_value_t *e);
+JL_DLLEXPORT void JL_NORETURN jl_rethrow(void);
+JL_DLLEXPORT void JL_NORETURN jl_rethrow_other(jl_value_t *e);
+
+#ifdef JULIA_ENABLE_THREADING
+STATIC_INLINE void jl_lock_frame_push(void (*unlock_func)(void))
+{
+    // For early bootstrap
+    if (__unlikely(!jl_current_task))
+        return;
+    arraylist_t *locks = &jl_current_task->locks;
+    size_t len = locks->len;
+    if (__unlikely(len >= locks->max)) {
+        arraylist_grow(locks, 1);
+    }
+    else {
+        locks->len = len + 1;
+    }
+    locks->items[len] = (void*)unlock_func;
+}
+#endif // ifndef JULIA_ENABLE_THREADING
 
 STATIC_INLINE void jl_eh_restore_state(jl_handler_t *eh)
 {
     JL_SIGATOMIC_BEGIN();
     jl_current_task->eh = eh->prev;
     jl_pgcstack = eh->gcstack;
+    jl_gc_state_save_and_set(eh->gc_state);
+#ifdef JULIA_ENABLE_THREADING
+    arraylist_t *locks = &jl_current_task->locks;
+    if (locks->len > eh->locks_len) {
+        for (size_t i = locks->len;i > eh->locks_len;i--)
+            ((void(*)(void))locks->items[i - 1])();
+        locks->len = eh->locks_len;
+    }
+#endif
     JL_SIGATOMIC_END();
 }
 
-DLLEXPORT void jl_enter_handler(jl_handler_t *eh);
-DLLEXPORT void jl_pop_handler(int n);
+JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh);
+JL_DLLEXPORT void jl_pop_handler(int n);
 
 #if defined(_OS_WINDOWS_)
 #if defined(_COMPILER_MINGW_)
@@ -1411,41 +1449,23 @@ void jl_longjmp(jmp_buf _Buf,int _Value);
 #define JL_STDERR jl_uv_stderr
 #define JL_STDIN  jl_uv_stdin
 
-DLLEXPORT void jl_run_event_loop(uv_loop_t *loop);
-DLLEXPORT int jl_run_once(uv_loop_t *loop);
-DLLEXPORT int jl_process_events(uv_loop_t *loop);
-
-DLLEXPORT uv_loop_t *jl_global_event_loop(void);
+JL_DLLEXPORT void jl_run_event_loop(uv_loop_t *loop);
+JL_DLLEXPORT int jl_run_once(uv_loop_t *loop);
+JL_DLLEXPORT int jl_process_events(uv_loop_t *loop);
 
-DLLEXPORT uv_pipe_t *jl_make_pipe(int writable, int julia_only, jl_value_t *julia_struct);
-DLLEXPORT void jl_close_uv(uv_handle_t *handle);
+JL_DLLEXPORT uv_loop_t *jl_global_event_loop(void);
 
-DLLEXPORT int32_t jl_start_reading(uv_stream_t *handle);
+JL_DLLEXPORT void jl_close_uv(uv_handle_t *handle);
 
-DLLEXPORT void jl_callback(void *callback);
+JL_DLLEXPORT int jl_tcp_bind(uv_tcp_t *handle, uint16_t port, uint32_t host,
+                             unsigned int flags);
 
-DLLEXPORT uv_async_t *jl_make_async(uv_loop_t *loop, jl_value_t *julia_struct);
-DLLEXPORT void jl_async_send(uv_async_t *handle);
-DLLEXPORT uv_idle_t * jl_make_idle(uv_loop_t *loop, jl_value_t *julia_struct);
-DLLEXPORT int jl_idle_start(uv_idle_t *idle);
-DLLEXPORT int jl_idle_stop(uv_idle_t *idle);
+JL_DLLEXPORT int jl_sizeof_ios_t(void);
 
-DLLEXPORT uv_timer_t *jl_make_timer(uv_loop_t *loop, jl_value_t *julia_struct);
-DLLEXPORT int jl_timer_stop(uv_timer_t *timer);
-
-DLLEXPORT uv_tcp_t *jl_tcp_init(uv_loop_t *loop);
-DLLEXPORT int jl_tcp_bind(uv_tcp_t *handle, uint16_t port, uint32_t host, unsigned int flags);
-
-DLLEXPORT int jl_sizeof_ios_t(void);
-
-#ifdef _OS_WINDOWS_
-DLLEXPORT struct tm* localtime_r(const time_t *t, struct tm *tm);
-#endif
-
-DLLEXPORT jl_array_t *jl_takebuf_array(ios_t *s);
-DLLEXPORT jl_value_t *jl_takebuf_string(ios_t *s);
-DLLEXPORT void *jl_takebuf_raw(ios_t *s);
-DLLEXPORT jl_value_t *jl_readuntil(ios_t *s, uint8_t delim);
+JL_DLLEXPORT jl_array_t *jl_takebuf_array(ios_t *s);
+JL_DLLEXPORT jl_value_t *jl_takebuf_string(ios_t *s);
+JL_DLLEXPORT void *jl_takebuf_raw(ios_t *s);
+JL_DLLEXPORT jl_value_t *jl_readuntil(ios_t *s, uint8_t delim);
 
 typedef struct {
     void *data;
@@ -1461,32 +1481,29 @@ typedef struct {
 #define _JL_FORMAT_ATTR(type, str, arg)
 #endif
 
-DLLEXPORT int jl_printf(uv_stream_t *s, const char *format, ...)
+JL_DLLEXPORT int jl_printf(uv_stream_t *s, const char *format, ...)
     _JL_FORMAT_ATTR(printf, 2, 3);
-DLLEXPORT int jl_vprintf(uv_stream_t *s, const char *format, va_list args)
+JL_DLLEXPORT int jl_vprintf(uv_stream_t *s, const char *format, va_list args)
     _JL_FORMAT_ATTR(printf, 2, 0);
-DLLEXPORT void jl_safe_printf(const char *str, ...)
+JL_DLLEXPORT void jl_safe_printf(const char *str, ...)
     _JL_FORMAT_ATTR(printf, 1, 2);
 
-extern DLLEXPORT JL_STREAM *JL_STDIN;
-extern DLLEXPORT JL_STREAM *JL_STDOUT;
-extern DLLEXPORT JL_STREAM *JL_STDERR;
+extern JL_DLLEXPORT JL_STREAM *JL_STDIN;
+extern JL_DLLEXPORT JL_STREAM *JL_STDOUT;
+extern JL_DLLEXPORT JL_STREAM *JL_STDERR;
 
-DLLEXPORT JL_STREAM *jl_stdout_stream(void);
-DLLEXPORT JL_STREAM *jl_stdin_stream(void);
-DLLEXPORT JL_STREAM *jl_stderr_stream(void);
+JL_DLLEXPORT JL_STREAM *jl_stdout_stream(void);
+JL_DLLEXPORT JL_STREAM *jl_stdin_stream(void);
+JL_DLLEXPORT JL_STREAM *jl_stderr_stream(void);
 
 // showing and std streams
-DLLEXPORT void jl_show(jl_value_t *stream, jl_value_t *v);
-DLLEXPORT void jl_flush_cstdio(void);
-DLLEXPORT jl_value_t *jl_stdout_obj(void);
-DLLEXPORT jl_value_t *jl_stderr_obj(void);
-DLLEXPORT size_t jl_static_show(JL_STREAM *out, jl_value_t *v);
-DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type);
-DLLEXPORT void jlbacktrace(void);
-
-// debugging
-void show_execution_point(char *filename, int lno);
+JL_DLLEXPORT void jl_show(jl_value_t *stream, jl_value_t *v);
+JL_DLLEXPORT void jl_flush_cstdio(void);
+JL_DLLEXPORT jl_value_t *jl_stdout_obj(void);
+JL_DLLEXPORT jl_value_t *jl_stderr_obj(void);
+JL_DLLEXPORT size_t jl_static_show(JL_STREAM *out, jl_value_t *v);
+JL_DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type);
+JL_DLLEXPORT void jlbacktrace(void);
 
 // julia options -----------------------------------------------------------
 // NOTE: This struct needs to be kept in sync with JLOptions type in base/options.jl
@@ -1517,6 +1534,7 @@ typedef struct {
     int8_t worker;
     int8_t handle_signals;
     int8_t use_precompiled;
+    int8_t use_compilecache;
     const char *bindto;
     const char *outputbc;
     const char *outputo;
@@ -1524,9 +1542,9 @@ typedef struct {
     int8_t incremental;
 } jl_options_t;
 
-extern DLLEXPORT jl_options_t jl_options;
+extern JL_DLLEXPORT jl_options_t jl_options;
 
-DLLEXPORT int jl_generating_output(void);
+JL_DLLEXPORT int jl_generating_output(void);
 
 // Settings for code_coverage and malloc_log
 // NOTE: if these numbers change, test/cmdlineargs.jl will have to be updated
@@ -1542,6 +1560,7 @@ DLLEXPORT int jl_generating_output(void);
 #define JL_OPTIONS_COMPILE_OFF 0
 #define JL_OPTIONS_COMPILE_ON  1
 #define JL_OPTIONS_COMPILE_ALL 2
+#define JL_OPTIONS_COMPILE_MIN 3
 
 #define JL_OPTIONS_COLOR_ON 1
 #define JL_OPTIONS_COLOR_OFF 2
@@ -1566,16 +1585,19 @@ DLLEXPORT int jl_generating_output(void);
 #define JL_OPTIONS_USE_PRECOMPILED_YES 1
 #define JL_OPTIONS_USE_PRECOMPILED_NO 0
 
+#define JL_OPTIONS_USE_COMPILECACHE_YES 1
+#define JL_OPTIONS_USE_COMPILECACHE_NO 0
+
 // Version information
-#include "julia_version.h"
-
-DLLEXPORT extern int jl_ver_major(void);
-DLLEXPORT extern int jl_ver_minor(void);
-DLLEXPORT extern int jl_ver_patch(void);
-DLLEXPORT extern int jl_ver_is_release(void);
-DLLEXPORT extern const char* jl_ver_string(void);
-DLLEXPORT const char *jl_git_branch();
-DLLEXPORT const char *jl_git_commit();
+#include <julia_version.h>
+
+JL_DLLEXPORT extern int jl_ver_major(void);
+JL_DLLEXPORT extern int jl_ver_minor(void);
+JL_DLLEXPORT extern int jl_ver_patch(void);
+JL_DLLEXPORT extern int jl_ver_is_release(void);
+JL_DLLEXPORT extern const char *jl_ver_string(void);
+JL_DLLEXPORT const char *jl_git_branch(void);
+JL_DLLEXPORT const char *jl_git_commit(void);
 
 // nullable struct representations
 typedef struct {
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 230bcd9f6de5a..b38c3e2baef8f 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -3,17 +3,31 @@
 #ifndef JULIA_INTERNAL_H
 #define JULIA_INTERNAL_H
 
-#include "options.h"
-#include "uv.h"
+#include <options.h>
+#include <uv.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#include <sched.h>
+#else
+#define sleep(x) Sleep(1000*x)
+#endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 extern size_t jl_page_size;
-extern char *jl_stack_lo;
-extern char *jl_stack_hi;
+#define jl_stack_lo (jl_get_ptls_states()->stack_lo)
+#define jl_stack_hi (jl_get_ptls_states()->stack_hi)
 extern jl_function_t *jl_typeinf_func;
+#if defined(JL_USE_INTEL_JITEVENTS)
+extern unsigned sig_stack_size;
+#endif
+#define jl_safe_restore jl_get_ptls_states()->safe_restore
+
+JL_DLLEXPORT extern int jl_lineno;
+JL_DLLEXPORT extern const char *jl_filename;
+#define jl_in_finalizer (jl_get_ptls_states()->in_finalizer)
 
 STATIC_INLINE jl_value_t *newobj(jl_value_t *type, size_t nfields)
 {
@@ -41,17 +55,56 @@ STATIC_INLINE jl_value_t *newstruct(jl_datatype_t *type)
     return jv;
 }
 
+void jl_generate_fptr(jl_lambda_info_t *li);
+void jl_compile_linfo(jl_lambda_info_t *li, void *cyclectx);
+
+// invoke (compiling if necessary) the jlcall function pointer for a method
+STATIC_INLINE jl_value_t *jl_call_method_internal(jl_lambda_info_t *meth, jl_value_t **args, uint32_t nargs)
+{
+    if (__unlikely(meth->fptr == NULL)) {
+        jl_compile_linfo(meth, NULL);
+        jl_generate_fptr(meth);
+    }
+    if (meth->jlcall_api == 0)
+        return meth->fptr(args[0], &args[1], nargs-1);
+    else
+        return ((jl_fptr_sparam_t)meth->fptr)(meth->sparam_vals, args[0], &args[1], nargs-1);
+}
+
+jl_tupletype_t *jl_argtype_with_function(jl_function_t *f, jl_tupletype_t *types);
+
 #define GC_MAX_SZCLASS (2032-sizeof(void*))
 // MSVC miscalculates sizeof(jl_taggedvalue_t) because
 // empty structs are a GNU extension
 #define sizeof_jl_taggedvalue_t (sizeof(void*))
 void jl_gc_inhibit_finalizers(int state);
+void jl_gc_setmark(jl_value_t *v);
+void jl_gc_sync_total_bytes(void);
+void jl_gc_track_malloced_array(jl_array_t *a);
+void jl_gc_count_allocd(size_t sz);
+void jl_gc_run_all_finalizers(void);
+void *allocb(size_t sz);
 
-#ifdef GC_DEBUG_ENV
-void gc_debug_print_status();
-#else
-#define gc_debug_print_status()
-#endif
+void gc_queue_binding(jl_binding_t *bnd);
+void gc_setmark_buf(void *buf, int);
+
+static inline void jl_gc_wb_binding(jl_binding_t *bnd, void *val) // val isa jl_value_t*
+{
+    if (__unlikely((jl_astaggedvalue(bnd)->gc_bits & 3) == 1 &&
+                   (jl_astaggedvalue(val)->gc_bits & 1) == 0))
+        gc_queue_binding(bnd);
+}
+
+static inline void jl_gc_wb_buf(void *parent, void *bufptr) // parent isa jl_value_t*
+{
+    // if parent is marked and buf is not
+    if (__unlikely((jl_astaggedvalue(parent)->gc_bits & 3) == 1))
+        //            (jl_astaggedvalue(bufptr)->gc_bits) != 1))
+        gc_setmark_buf(bufptr, jl_astaggedvalue(parent)->gc_bits);
+}
+
+void gc_debug_print_status(void);
+void gc_debug_critical_error(void);
 #if defined(GC_FINAL_STATS)
 void jl_print_gc_stats(JL_STREAM *s);
 #else
@@ -64,39 +117,30 @@ void jl_set_t_uid_ctr(int i);
 uint32_t jl_get_gs_ctr(void);
 void jl_set_gs_ctr(uint32_t ctr);
 
-void NORETURN jl_no_method_error_bare(jl_function_t *f, jl_value_t *args);
-void NORETURN jl_no_method_error(jl_function_t *f, jl_value_t **args, size_t na);
+void JL_NORETURN jl_no_method_error_bare(jl_function_t *f, jl_value_t *args);
+void JL_NORETURN jl_no_method_error(jl_function_t *f, jl_value_t **args, size_t na);
+JL_DLLEXPORT void jl_typeassert(jl_value_t *x, jl_value_t *t);
 
-#define JL_CALLABLE(name) \
-    DLLEXPORT jl_value_t *name(jl_value_t *F, jl_value_t **args, uint32_t nargs)
+#define JL_CALLABLE(name)                                               \
+    JL_DLLEXPORT jl_value_t *name(jl_value_t *F, jl_value_t **args, uint32_t nargs)
 
-JL_CALLABLE(jl_trampoline);
-JL_CALLABLE(jl_apply_generic);
 JL_CALLABLE(jl_unprotect_stack);
-JL_CALLABLE(jl_f_no_function);
 JL_CALLABLE(jl_f_tuple);
+JL_CALLABLE(jl_f_intrinsic_call);
 extern jl_function_t *jl_unprotect_stack_func;
-extern jl_function_t *jl_bottom_func;
 void jl_install_default_signal_handlers(void);
+void restore_signals(void);
+void *jl_install_thread_signal_handler(void);
 
-extern jl_datatype_t *jl_box_type;
-extern jl_value_t *jl_box_any_type;
-extern jl_typename_t *jl_box_typename;
-
-STATIC_INLINE int jl_is_box(void *v)
-{
-    jl_value_t *t = jl_typeof(v);
-    return (jl_is_datatype(t) &&
-            ((jl_datatype_t*)(t))->name == jl_box_typename);
-}
+jl_fptr_t jl_get_builtin_fptr(jl_value_t *b);
 
 ssize_t jl_max_jlgensym_in(jl_value_t *v);
 
 extern uv_loop_t *jl_io_loop;
 
-DLLEXPORT void jl_uv_associate_julia_struct(uv_handle_t *handle, jl_value_t *data);
-DLLEXPORT int jl_uv_fs_result(uv_fs_t *f);
-
+JL_DLLEXPORT void jl_uv_associate_julia_struct(uv_handle_t *handle,
+                                               jl_value_t *data);
+JL_DLLEXPORT int jl_uv_fs_result(uv_fs_t *f);
 
 int jl_tuple_subtype(jl_value_t **child, size_t cl, jl_datatype_t *pdt, int ta);
 
@@ -107,19 +151,79 @@ jl_value_t *jl_type_match_morespecific(jl_value_t *a, jl_value_t *b);
 int jl_types_equal_generic(jl_value_t *a, jl_value_t *b, int useenv);
 jl_datatype_t *jl_inst_concrete_tupletype_v(jl_value_t **p, size_t np);
 jl_datatype_t *jl_inst_concrete_tupletype(jl_svec_t *p);
-
-void jl_set_datatype_super(jl_datatype_t *tt, jl_value_t *super);
-void jl_add_constructors(jl_datatype_t *t);
+jl_lambda_info_t *jl_method_cache_insert(jl_methtable_t *mt, jl_tupletype_t *type,
+                                         jl_lambda_info_t *method);
+jl_methlist_t *jl_method_table_insert(jl_methtable_t *mt, jl_tupletype_t *type,
+                                      jl_lambda_info_t *method, jl_svec_t *tvars,
+                                      int8_t isstaged);
+int jl_is_type(jl_value_t *v);
+jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
+                                          jl_svec_t **penv, jl_svec_t *tvars);
+jl_typector_t *jl_new_type_ctor(jl_svec_t *params, jl_value_t *body);
+jl_value_t *jl_apply_type_(jl_value_t *tc, jl_value_t **params, size_t n);
+jl_value_t *jl_instantiate_type_with(jl_value_t *t, jl_value_t **env, size_t n);
+jl_datatype_t *jl_new_abstracttype(jl_value_t *name, jl_datatype_t *super,
+                                   jl_svec_t *parameters);
+jl_datatype_t *jl_wrap_Type(jl_value_t *t);  // x -> Type{x}
+jl_datatype_t *jl_wrap_vararg(jl_value_t *t);
+void jl_assign_bits(void *dest, jl_value_t *bits);
+jl_expr_t *jl_exprn(jl_sym_t *head, size_t n);
+jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module);
+void jl_add_method(jl_function_t *gf, jl_tupletype_t *types, jl_lambda_info_t *meth,
+                   jl_svec_t *tvars, int8_t isstaged);
+void jl_add_method_to_table(jl_methtable_t *mt, jl_tupletype_t *types, jl_lambda_info_t *meth,
+                            jl_svec_t *tvars, int8_t isstaged);
+jl_function_t *jl_module_call_func(jl_module_t *m);
+int jl_is_submodule(jl_module_t *child, jl_module_t *parent);
+
+jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast);
+
+jl_lambda_info_t *jl_wrap_expr(jl_value_t *expr);
+jl_value_t *jl_eval_global_var(jl_module_t *m, jl_sym_t *e);
+jl_value_t *jl_parse_eval_all(const char *fname, size_t len,
+                              const char *content, size_t contentlen);
+jl_value_t *jl_interpret_toplevel_thunk(jl_lambda_info_t *lam);
+jl_value_t *jl_interpret_toplevel_thunk_with(jl_lambda_info_t *lam,
+                                             jl_value_t **loc, size_t nl);
+jl_value_t *jl_interpret_toplevel_expr(jl_value_t *e);
+jl_value_t *jl_static_eval(jl_value_t *ex, void *ctx_, jl_module_t *mod,
+                           jl_lambda_info_t *li, int sparams, int allow_alloc);
+int jl_is_toplevel_only_expr(jl_value_t *e);
+void jl_type_infer(jl_lambda_info_t *li, jl_lambda_info_t *def);
+
+jl_lambda_info_t *jl_get_unspecialized(jl_lambda_info_t *method);
+jl_lambda_info_t *jl_method_lookup_by_type(jl_methtable_t *mt, jl_tupletype_t *types,
+                                           int cache, int inexact);
+jl_lambda_info_t *jl_method_lookup(jl_methtable_t *mt, jl_value_t **args, size_t nargs, int cache);
+jl_value_t *jl_gf_invoke(jl_tupletype_t *types, jl_value_t **args, size_t nargs);
+jl_sym_t *jl_decl_var(jl_value_t *ex);
+
+jl_array_t *jl_lam_args(jl_expr_t *l);
+jl_array_t *jl_lam_vinfo(jl_expr_t *l);
+jl_array_t *jl_lam_capt(jl_expr_t *l);
+jl_value_t *jl_lam_gensyms(jl_expr_t *l);
+jl_array_t *jl_lam_staticparams(jl_expr_t *l);
+jl_sym_t *jl_lam_argname(jl_lambda_info_t *li, int i);
+int jl_lam_vars_captured(jl_expr_t *ast);
+jl_expr_t *jl_lam_body(jl_expr_t *l);
+int jl_local_in_linfo(jl_lambda_info_t *linfo, jl_sym_t *sym);
+jl_value_t *jl_first_argument_datatype(jl_value_t *argtypes);
+jl_value_t *jl_preresolve_globals(jl_value_t *expr, jl_lambda_info_t *lam);
+int jl_has_intrinsics(jl_lambda_info_t *li, jl_expr_t *e, jl_module_t *m);
 
 jl_value_t *jl_nth_slot_type(jl_tupletype_t *sig, size_t i);
 void jl_compute_field_offsets(jl_datatype_t *st);
 jl_array_t *jl_new_array_for_deserialization(jl_value_t *atype, uint32_t ndims, size_t *dims,
                                              int isunboxed, int elsz);
+jl_lambda_info_t *jl_copy_lambda_info(jl_lambda_info_t *linfo);
 extern jl_array_t *jl_module_init_order;
 
 #ifdef JL_USE_INTEL_JITEVENTS
 extern char jl_using_intel_jitevents;
 #endif
+#ifdef JL_USE_OPROFILE_JITEVENTS
+extern char jl_using_oprofile_jitevents;
+#endif
 extern size_t jl_arr_xtralloc_limit;
 
 void jl_init_types(void);
@@ -129,11 +233,26 @@ void jl_init_primitives(void);
 void jl_init_codegen(void);
 void jl_init_intrinsic_functions(void);
 void jl_init_tasks(void);
+void jl_init_stack_limits(int ismaster);
 void jl_init_root_task(void *stack, size_t ssize);
 void jl_init_serializer(void);
+void jl_gc_init(void);
+void jl_init_restored_modules(jl_array_t *init_order);
+
 void _julia_init(JL_IMAGE_SEARCH rel);
 #ifdef COPY_STACKS
-extern JL_THREAD void *jl_stackbase;
+#define jl_stackbase (jl_get_ptls_states()->stackbase)
+#endif
+
+void jl_set_base_ctx(char *__stk);
+
+void jl_init_threading(void);
+void jl_start_threads(void);
+void jl_shutdown_threading(void);
+#ifdef JULIA_ENABLE_THREADING
+jl_get_ptls_states_func jl_get_ptls_states_getter(void);
+void jl_gc_signal_init(void);
+void jl_gc_signal_wait(void);
 #endif
 
 void jl_dump_bitcode(char *fname, const char *sysimg_data, size_t sysimg_len);
@@ -141,45 +260,48 @@ void jl_dump_objfile(char *fname, int jit_model, const char *sysimg_data, size_t
 int32_t jl_get_llvm_gv(jl_value_t *p);
 void jl_idtable_rehash(jl_array_t **pa, size_t newsz);
 
-#ifdef _OS_LINUX_
-DLLEXPORT void jl_read_sonames(void);
-#endif
-
-jl_lambda_info_t *jl_add_static_parameters(jl_lambda_info_t *l, jl_svec_t *sp);
-jl_function_t *jl_get_specialization(jl_function_t *f, jl_tupletype_t *types);
+JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *module);
+jl_lambda_info_t *jl_get_specialization1(jl_tupletype_t *types, void *cyclectx);
 jl_function_t *jl_module_get_initializer(jl_module_t *m);
-void jl_generate_fptr(jl_function_t *f);
-void jl_fptr_to_llvm(void *fptr, jl_lambda_info_t *lam, int specsig);
+uint32_t jl_module_next_counter(jl_module_t *m);
+void jl_fptr_to_llvm(jl_fptr_t fptr, jl_lambda_info_t *lam, int specsig);
+jl_tupletype_t *arg_type_tuple(jl_value_t **args, size_t nargs);
 
-jl_value_t* skip_meta(jl_array_t *body);
+jl_value_t *skip_meta(jl_array_t *body);
+int has_meta(jl_array_t *body, jl_sym_t *sym);
 
 // backtraces
+uint64_t jl_getUnwindInfo(uint64_t dwBase);
 #ifdef _OS_WINDOWS_
-extern volatile HANDLE hMainThread;
+extern HANDLE hMainThread;
 typedef CONTEXT *bt_context_t;
-DWORD64 jl_getUnwindInfo(ULONG64 dwBase);
 extern volatile int jl_in_stackwalk;
 #else
-#define UNW_LOCAL_ONLY
-#include <libunwind.h>
+// This gives unwind only local unwinding options ==> faster code
+#  define UNW_LOCAL_ONLY
+#  include <libunwind.h>
 typedef unw_context_t *bt_context_t;
+#  if (!defined(SYSTEM_LIBUNWIND) || UNW_VERSION_MAJOR > 1 ||   \
+       (UNW_VERSION_MAJOR == 1 && UNW_VERSION_MINOR > 1))
+// Enable our memory manager only for libunwind with our patch or
+// on a newer release
+#    define JL_UNW_HAS_FORMAT_IP 1
+#  endif
 #endif
-#define MAX_BT_SIZE 80000
-extern ptrint_t bt_data[MAX_BT_SIZE+1];
-extern size_t bt_size;
-DLLEXPORT size_t rec_backtrace(ptrint_t *data, size_t maxsize);
-DLLEXPORT size_t rec_backtrace_ctx(ptrint_t *data, size_t maxsize, bt_context_t ctx);
+#define jl_bt_data (jl_get_ptls_states()->bt_data)
+#define jl_bt_size (jl_get_ptls_states()->bt_size)
+JL_DLLEXPORT size_t rec_backtrace(intptr_t *data, size_t maxsize);
+JL_DLLEXPORT size_t rec_backtrace_ctx(intptr_t *data, size_t maxsize, bt_context_t ctx);
 #ifdef LIBOSXUNWIND
-size_t rec_backtrace_ctx_dwarf(ptrint_t *data, size_t maxsize, bt_context_t ctx);
-#endif
-DLLEXPORT void jl_raise_debugger(void);
-#ifdef _OS_DARWIN_
-DLLEXPORT void attach_exception_port(void);
+size_t rec_backtrace_ctx_dwarf(intptr_t *data, size_t maxsize, bt_context_t ctx);
 #endif
+void jl_critical_error(int sig, bt_context_t context, intptr_t *bt_data, size_t *bt_size);
+JL_DLLEXPORT void jl_raise_debugger(void);
 // Set *name and *filename to either NULL or malloc'd string
 void jl_getFunctionInfo(char **name, char **filename, size_t *line,
-                        char **inlinedat_file, size_t *inlinedat_line,
+                        char **inlinedat_file, size_t *inlinedat_line, jl_lambda_info_t **outer_linfo,
                         uintptr_t pointer, int *fromC, int skipC, int skipInline);
+JL_DLLEXPORT void jl_gdblookup(intptr_t ip);
 
 // *to is NULL or malloc'd pointer, from is allowed to be NULL
 static inline char *jl_copy_str(char **to, const char *from)
@@ -197,28 +319,184 @@ static inline char *jl_copy_str(char **to, const char *from)
 
 // timers
 // Returns time in nanosec
-DLLEXPORT uint64_t jl_hrtime(void);
+JL_DLLEXPORT uint64_t jl_hrtime(void);
 
 // libuv stuff:
-DLLEXPORT extern uv_lib_t *jl_dl_handle;
-DLLEXPORT extern uv_lib_t *jl_RTLD_DEFAULT_handle;
+JL_DLLEXPORT extern void *jl_dl_handle;
+JL_DLLEXPORT extern void *jl_RTLD_DEFAULT_handle;
 #if defined(_OS_WINDOWS_)
-DLLEXPORT extern uv_lib_t *jl_exe_handle;
-extern uv_lib_t *jl_ntdll_handle;
-extern uv_lib_t *jl_kernel32_handle;
-extern uv_lib_t *jl_crtdll_handle;
-extern uv_lib_t *jl_winsock_handle;
+JL_DLLEXPORT extern void *jl_exe_handle;
+extern void *jl_ntdll_handle;
+extern void *jl_kernel32_handle;
+extern void *jl_crtdll_handle;
+extern void *jl_winsock_handle;
 #endif
 
+void *jl_get_library(const char *f_lib);
+JL_DLLEXPORT void *jl_load_and_lookup(const char *f_lib, const char *f_name,
+                                      void **hnd);
+const char *jl_dlfind_win32(const char *name);
+
 // libuv wrappers:
-DLLEXPORT int jl_fs_rename(const char *src_path, const char *dst_path);
+JL_DLLEXPORT int jl_fs_rename(const char *src_path, const char *dst_path);
 
 #if defined(_CPU_X86_) || defined(_CPU_X86_64_)
 #define HAVE_CPUID
 #endif
 
 #ifdef SEGV_EXCEPTION
-extern DLLEXPORT jl_value_t *jl_segv_exception;
+extern JL_DLLEXPORT jl_value_t *jl_segv_exception;
+#endif
+
+// Runtime intrinsics //
+const char *jl_intrinsic_name(int f);
+
+JL_DLLEXPORT jl_value_t *jl_reinterpret(jl_value_t *ty, jl_value_t *v);
+JL_DLLEXPORT jl_value_t *jl_pointerref(jl_value_t *p, jl_value_t *i);
+JL_DLLEXPORT jl_value_t *jl_pointerset(jl_value_t *p, jl_value_t *x, jl_value_t *i);
+
+JL_DLLEXPORT jl_value_t *jl_neg_int(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_add_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_sub_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_mul_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_sdiv_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_udiv_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_srem_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_urem_int(jl_value_t *a, jl_value_t *b);
+
+JL_DLLEXPORT jl_value_t *jl_neg_float(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_add_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_sub_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_mul_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_div_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_rem_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_fma_float(jl_value_t *a, jl_value_t *b, jl_value_t *c);
+JL_DLLEXPORT jl_value_t *jl_muladd_float(jl_value_t *a, jl_value_t *b, jl_value_t *c);
+
+JL_DLLEXPORT jl_value_t *jl_eq_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_ne_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_slt_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_ult_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_sle_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_ule_int(jl_value_t *a, jl_value_t *b);
+
+JL_DLLEXPORT jl_value_t *jl_eq_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_ne_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_lt_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_le_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_fpiseq(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_fpislt(jl_value_t *a, jl_value_t *b);
+
+JL_DLLEXPORT jl_value_t *jl_not_int(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_and_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_or_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_xor_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_shl_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_lshr_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_ashr_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_bswap_int(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_ctpop_int(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_ctlz_int(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_cttz_int(jl_value_t *a);
+
+JL_DLLEXPORT jl_value_t *jl_sext_int(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_zext_int(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_trunc_int(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_sitofp(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_uitofp(jl_value_t *ty, jl_value_t *a);
+
+JL_DLLEXPORT jl_value_t *jl_fptoui(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_fptosi(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_fptrunc(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_fpext(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_fptoui_auto(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_fptosi_auto(jl_value_t *a);
+
+JL_DLLEXPORT jl_value_t *jl_checked_fptoui(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_checked_fptosi(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_checked_trunc_sint(jl_value_t *ty, jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_checked_trunc_uint(jl_value_t *ty, jl_value_t *a);
+
+JL_DLLEXPORT jl_value_t *jl_check_top_bit(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_checked_sadd_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_uadd_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_ssub_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_usub_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_smul_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_umul_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_sdiv_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_udiv_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_srem_int(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_checked_urem_int(jl_value_t *a, jl_value_t *b);
+
+JL_DLLEXPORT jl_value_t *jl_nan_dom_err(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_ceil_llvm(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_floor_llvm(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_trunc_llvm(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_rint_llvm(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_sqrt_llvm(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_powi_llvm(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_abs_float(jl_value_t *a);
+JL_DLLEXPORT jl_value_t *jl_copysign_float(jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_flipsign_int(jl_value_t *a, jl_value_t *b);
+
+JL_DLLEXPORT jl_value_t *jl_select_value(jl_value_t *isfalse, jl_value_t *a, jl_value_t *b);
+JL_DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a);
+int jl_array_store_unboxed(jl_value_t *el_type);
+int jl_array_isdefined(jl_value_t **args, int nargs);
+
+JL_DEFINE_MUTEX_EXT(codegen)
+
+#if defined(__APPLE__) && defined(JULIA_ENABLE_THREADING)
+void jl_mach_gc_begin(void);
+void jl_mach_gc_end(void);
+#endif
+
+#if defined(_OS_WINDOWS_)
+STATIC_INLINE void *jl_malloc_aligned(size_t sz, size_t align)
+{
+    return _aligned_malloc(sz ? sz : 1, align);
+}
+STATIC_INLINE void *jl_realloc_aligned(void *p, size_t sz, size_t oldsz,
+                                       size_t align)
+{
+    (void)oldsz;
+    return _aligned_realloc(p, sz ? sz : 1, align);
+}
+STATIC_INLINE void jl_free_aligned(void *p)
+{
+    _aligned_free(p);
+}
+#else
+STATIC_INLINE void *jl_malloc_aligned(size_t sz, size_t align)
+{
+#if defined(_P64) || defined(__APPLE__)
+    if (align <= 16)
+        return malloc(sz);
+#endif
+    void *ptr;
+    if (posix_memalign(&ptr, align, sz))
+        return NULL;
+    return ptr;
+}
+STATIC_INLINE void *jl_realloc_aligned(void *d, size_t sz, size_t oldsz,
+                                       size_t align)
+{
+#if defined(_P64) || defined(__APPLE__)
+    if (align <= 16)
+        return realloc(d, sz);
+#endif
+    void *b = jl_malloc_aligned(sz, align);
+    if (b != NULL) {
+        memcpy(b, d, oldsz > sz ? sz : oldsz);
+        free(d);
+    }
+    return b;
+}
+STATIC_INLINE void jl_free_aligned(void *p)
+{
+    free(p);
+}
 #endif
 
 #ifdef __cplusplus
diff --git a/src/julia_threads.h b/src/julia_threads.h
new file mode 100644
index 0000000000000..22ae989c480a8
--- /dev/null
+++ b/src/julia_threads.h
@@ -0,0 +1,361 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+// Meant to be included in <julia.h>
+#ifndef JULIA_THREADS_H
+#define JULIA_THREADS_H
+
+// threading ------------------------------------------------------------------
+
+// WARNING: Threading support is incomplete and experimental
+// Nonetheless, we define JL_THREAD and use it to give advanced notice to
+// maintainers of what eventual threading support will change.
+
+// JULIA_ENABLE_THREADING is switched on in Make.inc if JULIA_THREADS is
+// set (in Make.user)
+
+#if defined(__i386__) && defined(__GNUC__) && !defined(__SSE2__)
+#  error Julia can only be built for architectures above Pentium 4. Pass -march=pentium4, or set MARCH=pentium4 and ensure that -march is not passed separately with an older architecture.
+#endif
+#ifdef _COMPILER_MICROSOFT_
+#  include <intrin.h>
+#  include <type_traits>
+#endif
+#if defined(_CPU_X86_64_) || defined(_CPU_X86_)
+#  include <immintrin.h>
+#endif
+
+// This includes all the thread local states we care about for a thread.
+#define JL_MAX_BT_SIZE 80000
+typedef struct _jl_tls_states_t {
+    struct _jl_gcframe_t *pgcstack;
+    struct _jl_value_t *exception_in_transit;
+    // Whether it is safe to execute GC at the same time.
+#define JL_GC_STATE_WAITING 1
+    // gc_state = 1 means the thread is doing GC or is waiting for the GC to
+    //              finish.
+#define JL_GC_STATE_SAFE 2
+    // gc_state = 2 means the thread is running unmanaged code that can be
+    //              execute at the same time with the GC.
+    volatile int8_t gc_state;
+    volatile int8_t in_finalizer;
+    int8_t disable_gc;
+    struct _jl_thread_heap_t *heap;
+    struct _jl_module_t *current_module;
+    struct _jl_task_t *volatile current_task;
+    struct _jl_task_t *root_task;
+    struct _jl_value_t *volatile task_arg_in_transit;
+    void *stackbase;
+    char *stack_lo;
+    char *stack_hi;
+    jl_jmp_buf *volatile jmp_target;
+    jl_jmp_buf base_ctx; // base context of stack
+    jl_jmp_buf *safe_restore;
+    int16_t tid;
+    size_t bt_size;
+    intptr_t bt_data[JL_MAX_BT_SIZE + 1];
+} jl_tls_states_t;
+
+#ifdef __MIC__
+#  define jl_cpu_pause() _mm_delay_64(100)
+#  define jl_cpu_wake() ((void)0)
+#  define JL_CPU_WAKE_NOOP 1
+#elif defined(_CPU_X86_64_) || defined(_CPU_X86_)  /* !__MIC__ */
+#  define jl_cpu_pause() _mm_pause()
+#  define jl_cpu_wake() ((void)0)
+#  define JL_CPU_WAKE_NOOP 1
+#elif defined(_CPU_AARCH64_) || (defined(_CPU_ARM_) && __ARM_ARCH >= 7)
+#  define jl_cpu_pause() __asm__ volatile ("wfe" ::: "memory")
+#  define jl_cpu_wake() __asm__ volatile ("sev" ::: "memory")
+#  define JL_CPU_WAKE_NOOP 0
+#else
+#  define jl_cpu_pause() ((void)0)
+#  define jl_cpu_wake() ((void)0)
+#  define JL_CPU_WAKE_NOOP 1
+#endif
+
+/**
+ * Thread synchronization primitives:
+ *
+ * These roughly follows the c11/c++11 memory model and the act as memory
+ * barriers at both the compiler level and the hardware level.
+ * The only exception is the GC safepoint and GC state transitions for which
+ * we use only a compiler (signal) barrier and use the signal handler to do the
+ * synchronization in order to lower the mutator overhead as much as possible.
+ *
+ * We use the compiler instrinsics to implement a similar API to the c11/c++11
+ * one instead of using it directly because,
+ *
+ *     1. We support GCC 4.7 and GCC add support for c11 atomics in 4.9.
+ *        Luckily, the __atomic intrinsics were added in GCC 4.7.
+ *     2. (most importantly) we need interoperability between code written
+ *        in different languages.
+ *        The current c++ standard (c++14) does not allow using c11 atomic
+ *        functions or types and there's currently no grantee that the two
+ *        types are compatible (although most of them probably are).
+ *        We also need to access these atomic variables from the LLVM JIT code
+ *        which is very hard unless the layout of the object is fully
+ *        specified.
+ */
+#if defined(__GNUC__)
+#  define jl_signal_fence() __atomic_signal_fence(__ATOMIC_SEQ_CST)
+#  define jl_atomic_fetch_add(obj, arg)                 \
+    __atomic_fetch_add(obj, arg, __ATOMIC_SEQ_CST)
+// Returns the original value of `obj`
+// Use the legacy __sync builtins for now, this can also be written using
+// the __atomic builtins or c11 atomics with GNU extension or c11 _Generic
+#  define jl_atomic_compare_exchange(obj, expected, desired)    \
+    __sync_val_compare_and_swap(obj, expected, desired)
+// TODO: Maybe add jl_atomic_compare_exchange_weak for spin lock
+#  define jl_atomic_store(obj, val)                     \
+    __atomic_store_n(obj, val, __ATOMIC_SEQ_CST)
+#  if defined(__clang__) || defined(__ICC) || defined(__INTEL_COMPILER) || \
+    !(defined(_CPU_X86_) || defined(_CPU_X86_64_))
+// ICC and Clang doesn't have this bug...
+#    define jl_atomic_store_release(obj, val)           \
+    __atomic_store_n(obj, val, __ATOMIC_RELEASE)
+#  else
+// Workaround a GCC bug when using store with release order by using the
+// stronger version instead.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67458
+#    define jl_atomic_store_release(obj, val) jl_atomic_store(obj, val)
+#  endif
+#  define jl_atomic_load(obj)                   \
+    __atomic_load_n(obj, __ATOMIC_SEQ_CST)
+#  define jl_atomic_load_acquire(obj)           \
+    __atomic_load_n(obj, __ATOMIC_ACQUIRE)
+#elif defined(_COMPILER_MICROSOFT_)
+#  define jl_signal_fence() _ReadWriteBarrier()
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd8((volatile char*)obj, (char)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd16((volatile short*)obj, (short)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd((volatile LONG*)obj, (LONG)arg);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_fetch_add(T *obj, T2 arg)
+{
+    return (T)_InterlockedExchangeAdd64((volatile __int64*)obj, (__int64)arg);
+}
+// Returns the original value of `obj`
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 1, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange8((volatile char*)obj,
+                                           (char)desired, (char)expected);
+}
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 2, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange16((volatile short*)obj,
+                                            (short)desired, (short)expected);
+}
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 4, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange((volatile LONG*)obj,
+                                          (LONG)desired, (LONG)expected);
+}
+template<typename T, typename T2, typename T3>
+static inline typename std::enable_if<sizeof(T) == 8, T>::type
+jl_atomic_compare_exchange(volatile T *obj, T2 expected, T3 desired)
+{
+    return (T)_InterlockedCompareExchange64((volatile __int64*)obj,
+                                            (__int64)desired, (__int64)expected);
+}
+// atomic stores
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 1>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange8((volatile char*)obj, (char)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 2>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange16((volatile short*)obj, (short)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 4>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange((volatile LONG*)obj, (LONG)val);
+}
+template<typename T, typename T2>
+static inline typename std::enable_if<sizeof(T) == 8>::type
+jl_atomic_store(volatile T *obj, T2 val)
+{
+    _InterlockedExchange64((volatile __int64*)obj, (__int64)val);
+}
+template<typename T, typename T2>
+static inline void jl_atomic_store_release(volatile T *obj, T2 val)
+{
+    jl_signal_fence();
+    *obj = (T)val;
+}
+// atomic loads
+template<typename T>
+static inline T jl_atomic_load(volatile T *obj)
+{
+    // Trick to generate cheaper instructions compare to `_InterlockedOr`
+    // Note that we don't care whether the exchange succeeded or not...
+    return jl_atomic_compare_exchange(obj, T(0), T(0));
+}
+template<typename T>
+static inline T jl_atomic_load_acquire(volatile T *obj)
+{
+    T val = *obj;
+    jl_signal_fence();
+    return val;
+}
+#else
+#  error "No atomic operations supported."
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+JL_DLLEXPORT int16_t jl_threadid(void);
+JL_DLLEXPORT void *jl_threadgroup(void);
+JL_DLLEXPORT void jl_threading_profile(void);
+JL_DLLEXPORT void (jl_cpu_pause)(void);
+JL_DLLEXPORT void (jl_cpu_wake)(void);
+
+// Accessing the tls variables, gc safepoint and gc states
+JL_DLLEXPORT JL_CONST_FUNC jl_tls_states_t *(jl_get_ptls_states)(void);
+#ifndef JULIA_ENABLE_THREADING
+extern JL_DLLEXPORT jl_tls_states_t jl_tls_states;
+#define jl_get_ptls_states() (&jl_tls_states)
+#define jl_gc_state() ((int8_t)0)
+#define jl_gc_safepoint()
+STATIC_INLINE int8_t jl_gc_state_set(int8_t state, int8_t old_state)
+{
+    (void)state;
+    return old_state;
+}
+#else // ifndef JULIA_ENABLE_THREADING
+typedef jl_tls_states_t *(*jl_get_ptls_states_func)(void);
+JL_DLLEXPORT void jl_set_ptls_states_getter(jl_get_ptls_states_func f);
+// Make sure jl_gc_state() is always a rvalue
+#define jl_gc_state() ((int8_t)(jl_get_ptls_states()->gc_state))
+JL_DLLEXPORT extern volatile size_t *jl_gc_signal_page;
+STATIC_INLINE void jl_gc_safepoint(void)
+{
+    // This triggers a SegFault when we are in GC
+    // Assign it to a variable to make sure the compiler emit the load
+    // and to avoid Clang warning for -Wunused-volatile-lvalue
+    jl_signal_fence();
+    size_t v = *jl_gc_signal_page;
+    jl_signal_fence();
+    (void)v;
+}
+STATIC_INLINE int8_t jl_gc_state_set(int8_t state, int8_t old_state)
+{
+    jl_get_ptls_states()->gc_state = state;
+    // A safe point is required if we transition from GC-safe region to
+    // non GC-safe region.
+    if (old_state && !state)
+        jl_gc_safepoint();
+    return old_state;
+}
+#endif // ifndef JULIA_ENABLE_THREADING
+STATIC_INLINE int8_t jl_gc_state_save_and_set(int8_t state)
+{
+    return jl_gc_state_set(state, jl_gc_state());
+}
+#define jl_gc_unsafe_enter() jl_gc_state_save_and_set(0)
+#define jl_gc_unsafe_leave(state) ((void)jl_gc_state_set((state), 0))
+#define jl_gc_safe_enter() jl_gc_state_save_and_set(JL_GC_STATE_SAFE)
+#define jl_gc_safe_leave(state) ((void)jl_gc_state_set((state), JL_GC_STATE_SAFE))
+
+// Locks
+#ifdef JULIA_ENABLE_THREADING
+#define JL_DEFINE_MUTEX(m)                                                \
+    uint64_t volatile m ## _mutex = 0;                                    \
+    int32_t m ## _lock_count = 0;                                         \
+    void jl_unlock_## m ## _func(void)                                    \
+    {                                                                     \
+        JL_UNLOCK_RAW(m);                                                 \
+    }
+
+#define JL_DEFINE_MUTEX_EXT(m)                                            \
+    extern uint64_t volatile m ## _mutex;                                 \
+    extern int32_t m ## _lock_count;                                      \
+    void jl_unlock_## m ## _func(void);
+
+#define JL_LOCK_WAIT(m, wait_ex) do {                                   \
+        if (m ## _mutex == uv_thread_self()) {                          \
+            ++m ## _lock_count;                                         \
+        }                                                               \
+        else {                                                          \
+            for (;;) {                                                  \
+                if (m ## _mutex == 0 &&                                 \
+                    jl_atomic_compare_exchange(&m ## _mutex, 0,         \
+                                               uv_thread_self()) == 0) { \
+                    m ## _lock_count = 1;                               \
+                    break;                                              \
+                }                                                       \
+                wait_ex;                                                \
+                jl_cpu_pause();                                         \
+            }                                                           \
+        }                                                               \
+    } while (0)
+
+#define JL_UNLOCK_RAW(m) do {                                           \
+        if (m ## _mutex == uv_thread_self()) {                          \
+            --m ## _lock_count;                                         \
+            if (m ## _lock_count == 0) {                                \
+                jl_atomic_compare_exchange(&m ## _mutex, uv_thread_self(), 0); \
+                jl_cpu_wake();                                          \
+            }                                                           \
+        }                                                               \
+        else {                                                          \
+            assert(0 && "Unlocking a lock in a different thread.");     \
+        }                                                               \
+    } while (0)
+
+// JL_LOCK is a GC safe point while JL_LOCK_NOGC is not
+// Always use JL_LOCK unless no one holding the lock can trigger a GC or GC
+// safepoint. JL_LOCK_NOGC should only be needed for GC internal locks.
+#define JL_LOCK(m) do {                                 \
+        JL_LOCK_WAIT(m, jl_gc_safepoint());             \
+        jl_lock_frame_push(jl_unlock_## m ## _func);    \
+    } while (0)
+#define JL_UNLOCK(m) do {                       \
+        JL_UNLOCK_RAW(m);                       \
+        if (__likely(jl_current_task))          \
+            jl_current_task->locks.len--;       \
+    } while (0)
+#define JL_LOCK_NOGC(m) JL_LOCK_WAIT(m, )
+#define JL_UNLOCK_NOGC(m) JL_UNLOCK_RAW(m)
+#else // JULIA_ENABLE_THREADING
+#define JL_DEFINE_MUTEX(m)
+#define JL_DEFINE_MUTEX_EXT(m)
+#define JL_LOCK(m) do {} while (0)
+#define JL_UNLOCK(m) do {} while (0)
+#define JL_LOCK_NOGC(m) do {} while (0)
+#define JL_UNLOCK_NOGC(m) do {} while (0)
+#endif // JULIA_ENABLE_THREADING
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/llvm-gcroot.cpp b/src/llvm-gcroot.cpp
new file mode 100644
index 0000000000000..a99c2f3afbd5c
--- /dev/null
+++ b/src/llvm-gcroot.cpp
@@ -0,0 +1,757 @@
+#include <llvm/ADT/SmallBitVector.h>
+#include <llvm/IR/Value.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Transforms/Utils/BasicBlockUtils.h>
+
+#include <vector>
+#include <queue>
+
+#include "llvm-version.h"
+#include "julia.h"
+
+#ifdef LLVM37
+#define LLVM37_param(x) (x),
+#else
+#define LLVM37_param(x)
+#endif
+
+using namespace llvm;
+
+#ifndef NDEBUG
+static struct {
+    unsigned count;
+    unsigned locals;
+    unsigned temp;
+} jl_gc_frame_stats = {0};
+#endif
+
+class JuliaGCAllocator {
+public:
+    JuliaGCAllocator(CallInst *ptlsStates, Type *T_pjlvalue) :
+        F(*ptlsStates->getParent()->getParent()),
+        M(*F.getParent()),
+        T_int32(Type::getInt32Ty(F.getContext())),
+        T_int64(Type::getInt64Ty(F.getContext())),
+        V_null(Constant::getNullValue(T_pjlvalue)),
+        ptlsStates(ptlsStates),
+        gcframe(new AllocaInst(T_pjlvalue, ConstantInt::get(T_int32, 0))),
+        gcroot_func(M.getFunction("julia.gc_root_decl")),
+        gckill_func(M.getFunction("julia.gc_root_kill")),
+        gc_store_func(M.getFunction("julia.gc_store")),
+        jlcall_frame_func(M.getFunction("julia.jlcall_frame_decl"))
+    {
+/* Algorithm sketch:
+ *  Compute liveness for each basic block
+ *    liveness computed at the basic-block level for <inst, arg-offset> pairs
+ *  Propagate liveness from each basic block to its predecessors
+ *  Allocate argument slot for each jlcall frame
+ */
+#ifdef JL_DEBUG_BUILD
+        gcframe->setName("gcrootframe");
+#endif
+        gcframe->insertAfter(ptlsStates);
+        assert(gcroot_func && gckill_func && jlcall_frame_func && gc_store_func);
+    }
+
+private:
+Function &F;
+Module &M;
+Type *const T_int32;
+Type *const T_int64;
+Value *const V_null;
+CallInst *const ptlsStates;
+AllocaInst *const gcframe;
+Function *const gcroot_func;
+Function *const gckill_func;
+Function *const gc_store_func;
+Function *const jlcall_frame_func;
+
+typedef std::pair<CallInst*, unsigned> frame_register;
+class liveness {
+public:
+    typedef unsigned id;
+    enum {
+        assign = 1<<0, // an assignment to a gcroot exists in the basic-block (potentially no live-in from the predecessor basic-blocks)
+        kill   = 1<<1, // a use of a gcroot exists in the basic-block (potentially a "kill" and no live-out to the successor basic-blocks)
+        live   = 1<<2  // the gcroot is live over the entire basic-block (the assign/kill are not dominating of entry/exit)
+            // live | kill | assign == a usage and assignment exist, but it is also live on exit, the entry liveness depends on whether a store or use is encountered first
+            // live | kill == a usage exists, but the value must be live for the entire basic-block since it is not the terminal usage in the domination tree
+            // kill | assign == a usage and definition exist in domination order, so the actual lifetime is only a subset of the basic-block
+            // live | assign == impossible (this would be strange)
+    };
+};
+
+#ifndef NDEBUG // llvm assertions build
+// gdb debugging code for inspecting the bb_uses map
+void jl_dump_bb_uses(std::map<BasicBlock*, std::map<frame_register, liveness::id> > &bb_uses)
+{
+    for (std::map<BasicBlock*, std::map<frame_register, liveness::id> >::iterator
+            live_reg = bb_uses.begin(), e = bb_uses.end(); live_reg != e; ++live_reg) {
+        BasicBlock *bb = live_reg->first;
+        errs() << '\n' << bb << '\n';
+        for (std::map<frame_register, liveness::id>::iterator
+                regs = live_reg->second.begin(), regse = live_reg->second.end(); regs != regse; ++regs) {
+            errs() << regs->second << " #" << regs->first.second << ' ' << regs->first.first << '\n';
+        }
+    }
+}
+#endif
+
+Instruction *get_pgcstack(Instruction *ptlsStates)
+{
+    Constant *offset = ConstantInt::getSigned(T_int32, offsetof(jl_tls_states_t, pgcstack) / sizeof(void*));
+    return GetElementPtrInst::Create(
+            LLVM37_param(NULL)
+            ptlsStates,
+            ArrayRef<Value*>(offset),
+            "jl_pgcstack");
+}
+
+frame_register get_gcroot(Value *ptr)
+{
+    frame_register frame;
+    frame.first = dyn_cast<CallInst>(ptr);
+    frame.second = 0;
+    if (frame.first == NULL) {
+        // also try to look through GEP for jlcall_frame_func
+        if (GetElementPtrInst *gepInst = dyn_cast<GetElementPtrInst>(ptr)) {
+            if (gepInst->getNumIndices() == 1) {
+                frame.first = dyn_cast<CallInst>(gepInst->getPointerOperand());
+                if (frame.first && frame.first->getCalledFunction() == jlcall_frame_func)
+                    frame.second = cast<ConstantInt>(gepInst->idx_begin()->get())->getZExtValue();
+                else
+                    frame.first = NULL;
+            }
+        }
+    }
+    return frame;
+}
+
+void collapseRedundantRoots()
+{
+    for (BasicBlock::iterator I = gcframe->getParent()->begin(), E(gcframe); I != E; ) {
+        CallInst* callInst = dyn_cast<CallInst>(&*I);
+        ++I;
+        if (callInst && callInst->getCalledFunction() == gcroot_func) {
+            // see if a root is only used briefly for `store -> load -> store other` pattern or `store, store other`
+            // such that the first store can be trivially replaced with just "other" and delete the chain
+            // or if is used for store, but the value is never needed
+            StoreInst *theStore = NULL;
+            unsigned n_stores = 0;
+            bool variable_slot = true; // whether this gc-root is only used as a variable-slot; e.g. whether theLoad is theValue
+            LoadInst *theLoad = NULL;
+            for (User::use_iterator use = callInst->use_begin(), usee = callInst->use_end(); use != usee; ) {
+#ifdef LLVM35
+                User *user = use->getUser();
+#else
+                User *user = use.getUse().getUser();
+#endif
+                ++use;
+                if (StoreInst *storeInst = dyn_cast<StoreInst>(user)) {
+                    if (n_stores == 0)
+                        theStore = storeInst;
+                    else
+                        theStore = NULL;
+                    Value *theValue = storeInst->getValueOperand();
+                    if (!theValue->hasOneUse()) { // not just the store
+                        variable_slot = false; // this gc-root is used as more than just a variable-slot (aka phi node)
+                    }
+                    n_stores++;
+                }
+                else if (LoadInst *loadInst = dyn_cast<LoadInst>(user)) {
+                    if (loadInst->use_empty()) {
+                        // dead load?
+                        loadInst->eraseFromParent();
+                    }
+                    else {
+                        if (theLoad) {
+                            // multiple live loads, this is hard to optimize, so skip it
+                            n_stores = 0;
+                            break;
+                        }
+                        theLoad = loadInst;
+                    }
+                }
+                else {
+                    // what is this? oh, well. skip trying to optimize this gc-root
+                    n_stores = 0;
+                    break;
+                }
+            }
+
+            if (n_stores == 0)
+                continue;
+
+            if (theLoad == NULL) {
+                // this gc-root is never loaded from, so we don't need it as a variable location
+                // delete any stores to this gc-root that would be keeping an otherwise-unused value alive
+                for (User::use_iterator use = callInst->use_begin(), usee = callInst->use_end(); use != usee; ) {
+#ifdef LLVM35
+                    User *user = use->getUser();
+#else
+                    User *user = use.getUse().getUser();
+#endif
+                    StoreInst *theStore = cast<StoreInst>(user);
+                    ++use;
+                    Value *theValue = theStore->getValueOperand();
+                    if (theValue->hasOneUse()) { // just the store
+                        if (&*I == theStore) ++I;
+                        theStore->eraseFromParent();
+                    }
+                }
+                if (callInst->use_empty()) {
+                    callInst->eraseFromParent();
+                    continue;
+                }
+                else if (callInst->hasOneUse()) {
+                    User::use_iterator use = callInst->use_begin();
+#ifdef LLVM35
+                    theStore = cast<StoreInst>(use->getUser());
+#else
+                    theStore = cast<StoreInst>(use.getUse().getUser());
+#endif
+                }
+            }
+
+            if ((theLoad != NULL && variable_slot) ||
+                (theLoad == NULL && theStore != NULL)) {
+                Value *theValue = theLoad ? theLoad : theStore->getValueOperand();
+                if (theValue->hasNUses(theLoad ? 1 : 2)) { // only uses are theStore and theLoad and theOther
+                    // check if this value is only used for a store to another gcroot
+                    User::use_iterator value_use = theValue->use_begin();
+                    if (theLoad && *value_use == theStore)
+                        ++value_use;
+#ifdef LLVM35
+                    StoreInst *theOther = dyn_cast<StoreInst>(value_use->getUser());
+                    unsigned OperandNo = value_use->getOperandNo();
+#else
+                    StoreInst *theOther = dyn_cast<StoreInst>(value_use.getUse().getUser());
+                    unsigned OperandNo = value_use.getOperandNo();
+#endif
+                    if (theOther && OperandNo != StoreInst::getPointerOperandIndex()) {
+                        // test whether this store is valid as a gc-root
+                        bool patternMatchSuccess = false;
+                        frame_register gcroot_other_gep = get_gcroot(theOther->getPointerOperand());
+                        CallInst *gcroot_other = gcroot_other_gep.first;
+                        // it could be a gcroot...
+                        if (gcroot_other && gcroot_other->getCalledFunction() == gcroot_func && theStore != NULL) {
+                            // need to make sure there aren't any other uses of gcroot_other (including gckill)
+                            // between the initial store and the replacement store
+                            // TODO: do this better once we have liveness information for locals?
+                            BasicBlock *current = theStore->getParent();
+                            BasicBlock::iterator bbi(theStore);
+                            BasicBlock::iterator bbi_end = current->end();
+                            patternMatchSuccess = true;
+                            ++bbi;
+                            while (patternMatchSuccess) {
+                                Instruction *inst = &*bbi;
+                                if (inst == theOther) {
+                                    break; // success
+                                }
+                                for (Instruction::op_iterator op = inst->op_begin(), op_e = inst->op_end(); op != op_e; ++op) {
+                                    if (op->get() == gcroot_other) {
+                                        patternMatchSuccess = false;
+                                        break; // fail: gcroot_other had another reference, can't make this replacement
+                                    }
+                                }
+                                if (++bbi == bbi_end) {
+                                    // iterate the basicblock forward, if it's a simple branch
+#ifdef LLVM35
+                                    BasicBlock *next = current->getUniqueSuccessor();
+#else
+                                    succ_iterator SI = succ_begin(current), E = succ_end(current);
+                                    BasicBlock *next = NULL;
+                                    if (SI != E) {
+                                        next = *SI;
+                                        for (++SI; SI != E; ++SI) {
+                                            if (*SI != next) {
+                                                next = NULL;
+                                                break;
+                                            }
+                                        }
+                                    }
+#endif
+                                    if (next) {
+                                        bbi = next->begin();
+                                        bbi_end = next->end();
+                                        current = next;
+                                    }
+                                    else {
+                                        patternMatchSuccess = false;
+                                    }
+                                }
+                            }
+                        }
+                        // ...or it could be a jlcall frame
+                        else if (gcroot_other && gcroot_other->getCalledFunction() == jlcall_frame_func) {
+                            // jlcall_frame_func slots are effectively SSA,
+                            // so it's always safe to merge an earlier store into it
+                            // but do need to update liveness information for this slot
+                            // TODO: do this better once we have liveness information for locals?
+                            if (theStore != NULL && theOther->getParent() == theStore->getParent()) {
+                                //unsigned arg_offset = gcroot_other_gep->second;
+                                //frame_register def(gcroot_other, arg_offset);
+                                //std::map<frame_register, liveness::id> &inuse_list = bb_uses[theOther->getParent()];
+                                //std::map<frame_register, liveness::id>::iterator inuse_reg = inuse_list.find(def);
+                                patternMatchSuccess = true;
+                            }
+                        }
+                        if (patternMatchSuccess) {
+                            // do the gcroot merge -- replace gcroot with gcroot_other in all the store operations for this gcroot
+                            // so that theOther, theLoad, and this gcroot are no longer needed
+                            Value *gcroot_other = theOther->getPointerOperand();
+                            if (&*I == theOther) ++I;
+                            theOther->eraseFromParent();
+                            if (theLoad) {
+                                if (&*I == theLoad) ++I;
+                                theLoad->eraseFromParent();
+                            }
+                            if (theStore) {
+                                theStore->setOperand(StoreInst::getPointerOperandIndex(), gcroot_other);
+                            }
+                            else {
+                                for (User::use_iterator use = callInst->use_begin(), usee = callInst->use_end(); use != usee; ) {
+#ifdef LLVM35
+                                    User *user = use->getUser();
+#else
+                                    User *user = use.getUse().getUser();
+#endif
+                                    ++use;
+                                    StoreInst *theStore = cast<StoreInst>(user);
+                                    theStore->setOperand(StoreInst::getPointerOperandIndex(), gcroot_other);
+                                }
+                            }
+                            callInst->eraseFromParent();
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+bool record_usage(CallInst *callInst,
+        std::map<BasicBlock*, std::map<frame_register, liveness::id> > &bb_uses,
+        std::map<BasicBlock*, SmallBitVector> &regs_used,
+        unsigned &offset, bool commit=true)
+{
+/* record-usage(inst, bb-uses, regs-used, offset, commit=true)
+ *     for (arg-offset, operand) in enumerate(arguments(inst))
+ *         reg = <inst, arg-offset>
+ *         for (bb, liveness) in bb-uses
+ *             if not reg in liveness
+ *                 continue
+ *             # TODO: optimize better if liveness[reg] doesn't contain live
+ *             conflict = regs-used[bb][offset + arg-offset]
+ *             if commit
+ *                 assert !conflict
+ *                 regs-used[bb][offset + arg-offset] = true
+ *             else if conflict
+ *                 return false
+ *     return true
+ */
+    unsigned arg_n = cast<ConstantInt>(callInst->getArgOperand(0))->getZExtValue();
+#if 0 // suboptimal allocator that ignores computed liveness data
+    {
+        SmallBitVector &regs = regs_used[&callInst->getParent()->getParent()->getEntryBlock()];
+        if (offset + arg_n > regs.size())
+            regs.resize(offset + arg_n);
+        for (unsigned arg_offset = 0; arg_offset < arg_n; ++arg_offset) {
+            frame_register def(callInst, arg_offset);
+#else // }} better allocator that uses per-basicblock liveness
+    for (std::map<BasicBlock*, std::map<frame_register, liveness::id> >::iterator
+            live_reg = bb_uses.begin(), e = bb_uses.end(); live_reg != e; ++live_reg) {
+        BasicBlock *bb = live_reg->first;
+        SmallBitVector &regs = regs_used[bb];
+        if (offset + arg_n > regs.size())
+            regs.resize(offset + arg_n);
+        for (unsigned arg_offset = 0; arg_offset < arg_n; ++arg_offset) {
+            frame_register def(callInst, arg_offset);
+            std::map<frame_register, liveness::id>::iterator inuse_reg = live_reg->second.find(def);
+            if (inuse_reg == live_reg->second.end())
+                continue;
+            // TODO: optimize here better when not live in inuse_reg->second, by ascertaining liveness at the instruction level for this bb
+#endif
+            unsigned index = offset + arg_offset;
+            bool conflict = regs.test(index);
+            if (commit) {
+                assert(!conflict);
+                regs.set(index);
+            }
+            else if (conflict) {
+                // update the offset argument to point to the next open register beyond index
+                // to help avoid unnecessary work and accelerate the search
+                ++offset;
+                while (offset + arg_offset < regs.size() && regs.test(offset + arg_offset))
+                    ++offset;
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+unsigned find_space_for(CallInst *callInst,
+        std::map<BasicBlock*, std::map<frame_register, liveness::id> > &bb_uses,
+        std::map<BasicBlock*, SmallBitVector> &regs_used)
+{
+/* find-space-for(inst, bb-uses, regs-used)
+ *     n = 0
+ *     while !record-usage(inst, bb-uses, regs-used, n, false)
+ *         n++
+ *     return n
+ *
+ */
+    unsigned n = 0;
+    while (!record_usage(callInst, bb_uses, regs_used, n, false)) { }
+    return n;
+}
+
+public:
+void allocate_frame()
+{
+    Instruction *last_gcframe_inst = gcframe;
+    collapseRedundantRoots();
+
+/* # initialize the kill BasicBlock of all jlcall-frames
+ * bb-uses : map<BB, map< pair<inst, arg-offset>, assign|live|kill > >
+ * for inst in gc-frame(f)
+ *     if inst match "a call to make-jlcall-frame"
+ *         kill-use = get-unique-use<isa-CallInst>(inst)
+ *         bb-uses[bb][<def, 1:nargs>] = kill
+ */
+    std::map<BasicBlock*, std::map<frame_register, liveness::id> > bb_uses;
+    std::priority_queue< std::pair<unsigned, CallInst*> > frames;
+    for (BasicBlock::iterator I = gcframe->getParent()->begin(), E(gcframe); I != E; ) {
+        CallInst* callInst = dyn_cast<CallInst>(&*I);
+        ++I;
+        if (callInst && callInst->getCalledFunction() == jlcall_frame_func) {
+            BasicBlock *bb = NULL;
+            unsigned arg_n = cast<ConstantInt>(callInst->getArgOperand(0))->getZExtValue();
+            frames.push(std::make_pair(arg_n, callInst));
+            // the jlcall frame should have been passed to exactly one call (the jlcall) -- find its basic-block
+            for (User::use_iterator use = callInst->use_begin(), usee = callInst->use_end(); use != usee; ++use) {
+#ifdef LLVM35
+                User *user = use->getUser();
+#else
+                User *user = use.getUse().getUser();
+#endif
+                if (CallInst *callInst = dyn_cast<CallInst>(user)) {
+                    assert(bb == NULL);
+                    bb = callInst->getParent();
+#ifdef NDEBUG
+                    break;
+#endif
+                }
+            }
+            assert(bb != NULL);
+            std::map<frame_register, liveness::id> &inuse_list = bb_uses[bb];
+            for (unsigned arg_offset = 0; arg_offset < arg_n; ++arg_offset) {
+                inuse_list[frame_register(callInst, arg_offset)] = liveness::kill;
+            }
+        }
+    }
+
+/* # initialize the dataflow queue for tracking liveness
+ * bb-queue : queue<BB>
+ * for bb in iterator(f)
+ *     inuse-list = &bb-uses[bb]
+ *     for inst in reverse-iterator(f)
+ *         if inst matches store-inst # todo: or inst matches "gc-store-inst" (for stores to non-stack-slots)
+ *             if inst->operand(0) matches "a call to make-jlcall-frame" (or gep thereof)
+ *                 def = <inst, arg-offset>
+ *                 if inuse-list[def] is kill
+ *                     inuse-list[def] = assign|kill
+ *      if not has-live-out(bb)
+ *          continue
+ *      for pred in predecessors(bb)
+ *          if not pred in bb-queue
+ *              push-back(bb-queue, pred)
+ */
+    std::vector<BasicBlock*> bb_queue;
+    for (std::map<BasicBlock*, std::map<frame_register, liveness::id> >::iterator
+            live_reg = bb_uses.begin(), e = bb_uses.end(); live_reg != e; ++live_reg) {
+        BasicBlock *bb = live_reg->first;
+        std::map<frame_register, liveness::id> &inuse_list = live_reg->second;
+        unsigned live_out = inuse_list.size();
+
+        for (BasicBlock::iterator ri = bb->end(); ri != bb->begin(); ) {
+            Instruction *i = &*--ri;
+            if (StoreInst *storeInst = dyn_cast<StoreInst>(i)) {
+                frame_register def = get_gcroot(storeInst->getPointerOperand());
+                if (CallInst *callInst = def.first) {
+                    if (callInst->getCalledFunction() == jlcall_frame_func) {
+                        std::map<frame_register, liveness::id>::iterator inuse_reg = inuse_list.find(def);
+                        if (inuse_reg != inuse_list.end() && inuse_reg->second == liveness::kill) {
+                            inuse_reg->second |= liveness::assign;
+                            --live_out;
+                        }
+                    }
+                }
+            }
+        }
+        if (live_out == 0)
+            continue;
+        assert(&*bb != &F.getEntryBlock()); // only undef variables should live-out from the entry bb
+        for (pred_iterator PI = pred_begin(bb), PE = pred_end(bb); PI != PE; ++PI) {
+            if (std::find(bb_queue.begin(), bb_queue.end(), *PI) == bb_queue.end())
+                bb_queue.push_back(*PI);
+        }
+    }
+
+
+/* # follow liveness information flow until termination
+ * while not empty(bb-queue)
+ *     bb = pop(bb-queue)
+ *     inuse-list = &bb-uses[bb]
+ *     changes = 0
+ *     for succ in successors(bb)
+ *         for <def, op> in bb-uses[succ]
+ *             if (not assign in op) and not (inuse-list[def] contains live or assign)
+ *                 # need to add live value from successor to current block, unless it was already marked
+ *                 inuse-list[def] |= live
+ *                 changes += 1
+ *     for inst in iterator(bb)
+ *         if inst matches store-inst # todo: or inst matches "gc-store-inst" (for stores to non-stack-slots)
+ *             if inst->operand(0) matches "a call to make-jlcall-frame" (or gep thereof)
+ *                 def = <inst, arg-offset>
+ *                 if live in inuse-list[def]
+ *                     inuse-list[def] |= assign
+ *                     if not kill in inuse-list[def]
+ *                          # found the assignment, def is no longer live
+ *                          inuse-list[def] &= ~live
+ *                     else
+ *                          # not a true kill due to recursion -- the kill happened before this assign in this BB, so it is still live
+ *                     changes -= 1
+ *     # if the live list changed, make sure all predecessors are in the queue to be reanalyzed
+ *     if changes == 0
+ *         continue
+ *     for pred in predecessors(bb)
+ *         if not pred in bb-queue
+ *             push-back(bb-queue, pred)
+ */
+
+    while (!bb_queue.empty()) {
+        BasicBlock *bb = bb_queue.back();
+        bb_queue.pop_back();
+        std::map<frame_register, liveness::id> &inuse_list = bb_uses[bb];
+        unsigned changes = 0;
+        for (succ_iterator SI = succ_begin(bb), SE = succ_end(bb); SI != SE; ++SI) {
+            std::map<frame_register, liveness::id> &succ_uses = bb_uses[*SI];
+            for (std::map<frame_register, liveness::id>::iterator reg = succ_uses.begin(), rege = succ_uses.end(); reg != rege; ++reg) {
+                if (!(reg->second & liveness::assign)) {
+                    liveness::id &live = inuse_list[reg->first];
+                    if (!(live & (liveness::live | liveness::assign))) {
+                        live |= liveness::live;
+                        ++changes;
+                    }
+                }
+            }
+        }
+        if (!changes) // short-circuit
+            continue;
+        for (BasicBlock::iterator i = bb->begin(), ie = bb->end(); i != ie; ++i) {
+            if (StoreInst *storeInst = dyn_cast<StoreInst>(&*i)) {
+                frame_register def = get_gcroot(storeInst->getPointerOperand());
+                if (CallInst *callInst = def.first) {
+                    if (callInst->getCalledFunction() == jlcall_frame_func) {
+                        std::map<frame_register, liveness::id>::iterator inuse_reg = inuse_list.find(def);
+                        if (inuse_reg != inuse_list.end() && (inuse_reg->second & liveness::live)) {
+                            inuse_reg->second |= liveness::assign;
+                            if (!(inuse_reg->second & liveness::kill))
+                                inuse_reg->second &= ~liveness::live;
+                            --changes;
+                        }
+                    }
+                }
+            }
+        }
+        if (!changes)
+            continue;
+        assert(bb != &F.getEntryBlock()); // only undef variables should live-out from the entry bb
+        for (pred_iterator PI = pred_begin(bb), PE = pred_end(bb); PI != PE; ++PI) {
+            if (std::find(bb_queue.begin(), bb_queue.end(), *PI) == bb_queue.end())
+                bb_queue.push_back(*PI);
+        }
+    }
+
+/* # allocate space in locals for the variables
+ * TBD
+ */
+
+/* # allocate space in temp-args for each jlcall frame
+ * regs-used = zip(get-basic-blocks(), falses)
+ * for <frame-size, inst> in frames
+ *     frame-offset = find-space-for(inst, bb-uses, regs-used)
+ *     record-usage(inst, bb-uses, regs-used, frame-offset)
+ * # frame iterator allocates space in reverse size order
+ * # so that the large frames get allocated first
+ * # and the smaller frames just fill in the gaps
+ * # I believe this is likely to give good results (compact gc-frames)
+ */
+    std::map<BasicBlock*, SmallBitVector> regs_used;
+    std::map<CallInst*, unsigned> frame_offsets;
+    unsigned maxDepth = 0;
+    for (; !frames.empty(); frames.pop()) {
+        std::pair<unsigned, CallInst*> frame = frames.top();
+        unsigned arg_n = frame.first;
+        if (arg_n == 0) continue;
+        CallInst *callInst = frame.second;
+        unsigned frame_offset = find_space_for(callInst, bb_uses, regs_used);
+        record_usage(callInst, bb_uses, regs_used, frame_offset);
+        frame_offsets[callInst] = frame_offset;
+        if (frame_offset + arg_n > maxDepth)
+            maxDepth = frame_offset + arg_n;
+    }
+
+/* # cleanup and finalize the IR */
+    for (Function::iterator bb = F.begin(), be = F.end(); bb != be; ++bb) {
+        for (BasicBlock::iterator i = bb->begin(), ie = bb->end(); i != ie; ) {
+            Instruction *inst = &*i;
+            ++i;
+            // delete the now unused gckill information
+            if (CallInst* callInst = dyn_cast<CallInst>(inst)) {
+                if (callInst->getCalledFunction() == gckill_func) {
+                    callInst->eraseFromParent();
+                }
+            }
+            // delete any StoreInst to a gcframe slot that isn't live
+            else if (StoreInst *storeInst = dyn_cast<StoreInst>(inst)) {
+                frame_register def = get_gcroot(storeInst->getPointerOperand());
+                if (CallInst *gcroot = def.first) {
+                    if (gcroot->getCalledFunction() == jlcall_frame_func) {
+                        std::map<frame_register, liveness::id> &inuse_list = bb_uses[storeInst->getParent()];
+                        std::map<frame_register, liveness::id>::iterator inuse_reg = inuse_list.find(def);
+                        if (inuse_reg == inuse_list.end())
+                            storeInst->eraseFromParent();
+                    }
+                }
+            }
+        }
+    }
+
+    Instruction *tempSlot;
+    if (frame_offsets.empty()) {
+        tempSlot = NULL;
+    }
+    else {
+        tempSlot = GetElementPtrInst::Create(LLVM37_param(NULL) gcframe, ArrayRef<Value*>(ConstantInt::get(T_int32, 2)));
+#ifdef JL_DEBUG_BUILD
+        tempSlot->setName("temproots");
+#endif
+        tempSlot->insertAfter(gcframe);
+        if (last_gcframe_inst == gcframe)
+            last_gcframe_inst = tempSlot;
+
+        // finalize all of the jlcall frames by replacing all of the frames with the appropriate gep(tempslot)
+        for (std::map<CallInst*, unsigned>::iterator frame = frame_offsets.begin(), framee = frame_offsets.end(); frame != framee; ++frame) {
+            CallInst *gcroot = frame->first;
+            Value* offset[1] = {ConstantInt::get(T_int32, frame->second)};
+            GetElementPtrInst *gep = GetElementPtrInst::Create(LLVM37_param(NULL) tempSlot, makeArrayRef(offset));
+            gep->insertAfter(last_gcframe_inst);
+            gcroot->replaceAllUsesWith(gep);
+            gcroot->eraseFromParent();
+            last_gcframe_inst = gep;
+        }
+    }
+
+/* # replace all intermediate roots defs with the appropriate gep(gcroot)
+ * for inst in entry-basic-block(function)
+ *     if inst matches "gc-root"
+ *         slot = get-argument(inst)
+ *         newslot = CreateGEP(gc-frame) -> at InsertPoint(gc-frame)
+ *         Replace(slot, newslot) -> at InsertPoint(gc-frame)
+ *         CreateStore(NULL, newslot) -> at InsertPoint(gc-frame)
+ */
+    unsigned argSpaceSize = 0;
+    Instruction *argSlot = NULL;
+    for(BasicBlock::iterator I = gcframe->getParent()->begin(), E(gcframe); I != E; ) {
+        CallInst* callInst = dyn_cast<CallInst>(&*I);
+        ++I;
+        if (callInst && callInst->getCalledFunction() == gcroot_func) {
+            if (!argSlot) {
+                argSlot = GetElementPtrInst::Create(LLVM37_param(NULL) gcframe, ArrayRef<Value*>(ConstantInt::get(T_int32, 2)));
+#ifdef JL_DEBUG_BUILD
+                argSlot->setName("locals");
+#endif
+                argSlot->insertAfter(gcframe);
+                if (last_gcframe_inst == gcframe)
+                    last_gcframe_inst = argSlot;
+            }
+            Instruction *argTempi = GetElementPtrInst::Create(LLVM37_param(NULL) argSlot, ArrayRef<Value*>(ConstantInt::get(T_int32, argSpaceSize++)));
+            argTempi->insertAfter(last_gcframe_inst);
+            callInst->replaceAllUsesWith(argTempi);
+            callInst->eraseFromParent();
+            // Initialize the slots for function variables to NULL
+            StoreInst *store = new StoreInst(V_null, argTempi);
+            store->insertAfter(argTempi);
+            last_gcframe_inst = store;
+        }
+    }
+
+    if (argSpaceSize + maxDepth == 0) {
+        // 0 roots; remove gc frame entirely
+        gcframe->eraseFromParent();
+    }
+    else {
+        // Initialize the slots for temporary variables to NULL
+        for (unsigned i = 0; i < maxDepth; i++) {
+            Instruction *argTempi = GetElementPtrInst::Create(LLVM37_param(NULL) tempSlot, ArrayRef<Value*>(ConstantInt::get(T_int32, i)));
+            argTempi->insertAfter(last_gcframe_inst);
+            StoreInst *store = new StoreInst(V_null, argTempi);
+            store->insertAfter(argTempi);
+            last_gcframe_inst = store;
+        }
+
+        gcframe->setOperand(0, ConstantInt::get(T_int32, 2 + argSpaceSize + maxDepth)); // fix up the size of the gc frame
+        if (tempSlot)
+            tempSlot->setOperand(1, ConstantInt::get(T_int32, 2 + argSpaceSize)); // fix up the offset to the temp slot space
+
+        IRBuilder<> builder(F.getContext());
+        Type *T_ppjlvalue = V_null->getType()->getPointerTo();
+#ifdef _P64
+        Type *T_size = T_int64;
+#else
+        Type *T_size = T_int32;
+#endif
+        builder.SetInsertPoint(&*(++BasicBlock::iterator(last_gcframe_inst))); // set insert *before* point, e.g. after the gcframe
+        DebugLoc noDbg;
+        builder.SetCurrentDebugLocation(noDbg);
+
+        builder.CreateStore(ConstantInt::get(T_size, (argSpaceSize + maxDepth) << 1),
+                            builder.CreateBitCast(builder.CreateConstGEP1_32(gcframe, 0), T_size->getPointerTo()));
+        builder.CreateStore(builder.CreateLoad(builder.Insert(get_pgcstack(ptlsStates))),
+                            builder.CreatePointerCast(builder.CreateConstGEP1_32(gcframe, 1), PointerType::get(T_ppjlvalue,0)));
+        builder.CreateStore(gcframe, builder.Insert(get_pgcstack(ptlsStates)));
+
+        // Finish by emitting the gc pops before any return
+        for(Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
+            if (isa<ReturnInst>(I->getTerminator())) {
+                builder.SetInsertPoint(I->getTerminator()); // set insert *before* Ret
+                Instruction *gcpop =
+                    (Instruction*)builder.CreateConstGEP1_32(gcframe, 1);
+                builder.CreateStore(builder.CreatePointerCast(builder.CreateLoad(gcpop),
+                                                          T_ppjlvalue),
+                                    builder.Insert(get_pgcstack(ptlsStates)));
+            }
+        }
+    }
+
+#ifndef NDEBUG
+    jl_gc_frame_stats.count++;
+    jl_gc_frame_stats.locals += argSpaceSize;
+    jl_gc_frame_stats.temp += maxDepth;
+#endif
+}
+
+};
+
+void jl_codegen_finalize_temp_arg(CallInst *ptlsStates, Type *T_pjlvalue)
+{
+    JuliaGCAllocator allocator(ptlsStates, T_pjlvalue);
+    allocator.allocate_frame();
+}
diff --git a/src/llvm-simdloop.cpp b/src/llvm-simdloop.cpp
index 3ec3cb5ea8a18..f149157b5b428 100644
--- a/src/llvm-simdloop.cpp
+++ b/src/llvm-simdloop.cpp
@@ -20,11 +20,11 @@ namespace llvm {
 
 // simd loop
 static unsigned simd_loop_mdkind = 0;
-static MDNode* simd_loop_md = NULL;
+static MDNode *simd_loop_md = NULL;
 
 /// Mark loop as a SIMD loop.  Return false if loop cannot be marked.
 /// incr should be the basic block that increments the loop counter.
-bool annotateSimdLoop(BasicBlock* incr)
+bool annotateSimdLoop(BasicBlock *incr)
 {
     DEBUG(dbgs() << "LSL: annotating simd_loop\n");
     // Lazy initialization
@@ -72,20 +72,20 @@ struct LowerSIMDLoop: public LoopPass {
     bool hasSIMDLoopMetadata( Loop *L) const;
 
     /// If Phi is part of a reduction cycle of FAdd or FMul, mark the ops as permitting reassociation/commuting.
-    void enableUnsafeAlgebraIfReduction(PHINode* Phi, Loop* L) const;
+    void enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const;
 };
 
 bool LowerSIMDLoop::hasSIMDLoopMetadata(Loop *L) const
 {
     // Note: If a loop has 0 or multiple latch blocks, it's probably not a simd_loop anyway.
-    if (BasicBlock* latch = L->getLoopLatch())
+    if (BasicBlock *latch = L->getLoopLatch())
         for (BasicBlock::iterator II = latch->begin(), EE = latch->end(); II!=EE; ++II)
             if (II->getMetadata(simd_loop_mdkind))
                 return true;
     return false;
 }
 
-void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode* Phi, Loop* L) const
+void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode *Phi, Loop *L) const
 {
     typedef SmallVector<Instruction*, 8> chainVector;
     chainVector chain;
@@ -94,7 +94,7 @@ void LowerSIMDLoop::enableUnsafeAlgebraIfReduction(PHINode* Phi, Loop* L) const
     for (Instruction *I = Phi; ; I=J) {
         J = NULL;
         // Find the user of instruction I that is within loop L.
-#if defined(LLVM_VERSION_MAJOR) && LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 5
+#ifdef LLVM35
         for (User *UI : I->users()) { /*}*/
             Instruction *U = cast<Instruction>(UI);
 #else
@@ -149,8 +149,8 @@ bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
         return false;
 
     DEBUG(dbgs() << "LSL: simd_loop found\n");
-#if defined(LLVM_VERSION_MAJOR) && LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 4
-    MDNode* n = L->getLoopID();
+#ifdef LLVM34
+    MDNode *n = L->getLoopID();
     if (!n) {
         // Loop does not have a LoopID yet, so give it one.
 #ifdef LLVM36
@@ -162,13 +162,13 @@ bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
         L->setLoopID(n);
     }
 #else
-    MDNode* n = MDNode::get(getGlobalContext(), ArrayRef<Value*>());
+    MDNode *n = MDNode::get(getGlobalContext(), ArrayRef<Value*>());
     L->getLoopLatch()->getTerminator()->setMetadata("llvm.loop.parallel", n);
 #endif
 #ifdef LLVM36
-    MDNode* m = MDNode::get(getGlobalContext(), ArrayRef<Metadata*>(n));
+    MDNode *m = MDNode::get(getGlobalContext(), ArrayRef<Metadata*>(n));
 #else
-    MDNode* m = MDNode::get(getGlobalContext(), ArrayRef<Value*>(n));
+    MDNode *m = MDNode::get(getGlobalContext(), ArrayRef<Value*>(n));
 #endif
 
     // Mark memory references so that Loop::isAnnotatedParallel will return true for this loop.
@@ -179,7 +179,7 @@ bool LowerSIMDLoop::runOnLoop(Loop *L, LPPassManager &LPM)
     assert(L->isAnnotatedParallel());
 
     // Mark floating-point reductions as okay to reassociate/commute.
-    BasicBlock* Lh = L->getHeader();
+    BasicBlock *Lh = L->getHeader();
     DEBUG(dbgs() << "LSL: loop header: " << *Lh << "\n");
     for (BasicBlock::iterator I = Lh->begin(), E = Lh->end(); I!=E; ++I)
         if (PHINode *Phi = dyn_cast<PHINode>(I))
@@ -194,7 +194,8 @@ static RegisterPass<LowerSIMDLoop> X("LowerSIMDLoop", "LowerSIMDLoop Pass",
                                      false /* Only looks at CFG */,
                                      false /* Analysis Pass */);
 
-DLLEXPORT Pass* createLowerSimdLoopPass() {
+JL_DLLEXPORT Pass *createLowerSimdLoopPass()
+{
     return new LowerSIMDLoop();
 }
 
diff --git a/src/llvm-version.h b/src/llvm-version.h
index 7d11b2013dba8..c006c926c474c 100644
--- a/src/llvm-version.h
+++ b/src/llvm-version.h
@@ -2,14 +2,23 @@
 
 #include <llvm/Config/llvm-config.h>
 
+#if defined(LLVM_VERSION_MAJOR) && LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 9
+#define LLVM39 1
+#endif
+
 #if defined(LLVM_VERSION_MAJOR) && LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 8
 #define LLVM38 1
+#define USE_ORCJIT
 #endif
 
 #if defined(LLVM_VERSION_MAJOR) && LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 7
 #define LLVM37 1
-// Experimental:
-//#define USE_ORCJIT
+
+// We enable ORCJIT only if we have our custom patches
+#ifndef SYSTEM_LLVM
+#define USE_ORCJIT
+#endif
+
 #endif
 
 #if defined(LLVM_VERSION_MAJOR) && LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR >= 6
@@ -34,3 +43,6 @@
 #ifdef USE_ORCJIT //temporary, since in some places USE_MCJIT may be used instead of the correct LLVM version test
 #define USE_MCJIT
 #endif
+#ifdef USE_ORCMCJIT //temporary, since in some places USE_MCJIT may be used instead of the correct LLVM version test
+#define USE_MCJIT
+#endif
diff --git a/src/macroexpand.scm b/src/macroexpand.scm
new file mode 100644
index 0000000000000..d21b317c8ce02
--- /dev/null
+++ b/src/macroexpand.scm
@@ -0,0 +1,430 @@
+;; macro expander
+
+;; backquote expansion
+
+(define (splice-expr? e)
+  ;; ($ (tuple (... x)))
+  (and (length= e 2)          (eq? (car e)   '$)
+       (length= (cadr e) 2)   (eq? (caadr e) 'tuple)
+       (vararg? (cadadr e))))
+
+(define (wrap-with-splice x)
+  `(call (top _expr) (inert $)
+         (call (top _expr) (inert tuple)
+               (call (top _expr) (inert |...|) ,x))))
+
+(define (julia-bq-bracket x d)
+  (if (splice-expr? x)
+      (if (= d 0)
+          (cadr (cadr (cadr x)))
+          (list 'cell1d
+                (wrap-with-splice (julia-bq-expand (cadr (cadr (cadr x))) (- d 1)))))
+      (list 'cell1d (julia-bq-expand x d))))
+
+(define (julia-bq-expand x d)
+  (cond ((or (eq? x 'true) (eq? x 'false))  x)
+        ((or (symbol? x) (jlgensym? x))     (list 'inert x))
+        ((atom? x)  x)
+        ((eq? (car x) 'quote)
+         `(call (top _expr) (inert quote) ,(julia-bq-expand (cadr x) (+ d 1))))
+        ((eq? (car x) '$)
+         (if (and (= d 0) (length= x 2))
+             (cadr x)
+             (if (splice-expr? (cadr x))
+                 `(call (top splicedexpr) (inert $)
+                        (call (top append_any) ,(julia-bq-bracket (cadr x) (- d 1))))
+                 `(call (top _expr) (inert $) ,(julia-bq-expand (cadr x) (- d 1))))))
+        ((not (contains (lambda (e) (and (pair? e) (eq? (car e) '$))) x))
+         `(copyast (inert ,x)))
+        ((not (any splice-expr? x))
+         `(call (top _expr) ,.(map (lambda (ex) (julia-bq-expand ex d)) x)))
+        (else
+         (let loop ((p (cdr x)) (q '()))
+           (if (null? p)
+               (let ((forms (reverse q)))
+                 `(call (top splicedexpr) ,(julia-bq-expand (car x) d)
+                        (call (top append_any) ,@forms)))
+               (loop (cdr p) (cons (julia-bq-bracket (car p) d) q)))))))
+
+;; hygiene
+
+;; return the names of vars introduced by forms, instead of their transformations.
+(define vars-introduced-by-patterns
+  (pattern-set
+   ;; function with static parameters
+   (pattern-lambda
+    (function (call (curly name . sparams) . argl) body)
+    (cons 'varlist (append (llist-vars (fix-arglist argl))
+                           (apply nconc
+                                  (map (lambda (v) (trycatch
+                                                    (list (sparam-name v))
+                                                    (lambda (e) '())))
+                                       sparams)))))
+
+   ;; function definition
+   (pattern-lambda (function (call name . argl) body)
+                   (cons 'varlist (llist-vars (fix-arglist argl))))
+
+   (pattern-lambda (function (tuple . args) body)
+                   `(-> (tuple ,@args) ,body))
+
+   ;; expression form function definition
+   (pattern-lambda (= (call (curly name . sparams) . argl) body)
+                   `(function (call (curly ,name . ,sparams) . ,argl) ,body))
+   (pattern-lambda (= (call name . argl) body)
+                   `(function (call ,name ,@argl) ,body))
+
+   ;; anonymous function
+   (pattern-lambda (-> a b)
+                   (let ((a (if (and (pair? a)
+                                     (eq? (car a) 'tuple))
+                                (cdr a)
+                                (list a))))
+                     (cons 'varlist (llist-vars (fix-arglist a)))))
+
+   ;; let
+   (pattern-lambda (let ex . binds)
+                   (let loop ((binds binds)
+                              (vars  '()))
+                     (if (null? binds)
+                         (cons 'varlist vars)
+                         (cond
+                          ((or (symbol? (car binds)) (decl? (car binds)))
+                           ;; just symbol -> add local
+                           (loop (cdr binds)
+                                 (cons (decl-var (car binds)) vars)))
+                          ((and (length= (car binds) 3)
+                                (eq? (caar binds) '=))
+                           ;; some kind of assignment
+                           (cond
+                            ((or (symbol? (cadar binds))
+                                 (decl?   (cadar binds)))
+                             ;; a=b -> add argument
+                             (loop (cdr binds)
+                                   (cons (decl-var (cadar binds)) vars)))
+                            ((and (pair? (cadar binds))
+                                  (eq? (caadar binds) 'call))
+                             ;; f()=c
+                             (let ((asgn (cadr (julia-expand0 (car binds)))))
+                               (loop (cdr binds)
+                                     (cons (cadr asgn) vars))))
+                            ((and (pair? (cadar binds))
+                                  (eq? (caadar binds) 'tuple))
+                             (loop (cdr binds)
+                                   (append (map decl-var (lhs-vars (cadar binds))) vars)))
+                            (else '())))
+                          (else '())))))
+
+   ;; macro definition
+   (pattern-lambda (macro (call name . argl) body)
+                   `(-> (tuple ,@argl) ,body))
+
+   (pattern-lambda (try tryb var catchb finalb)
+                   (if var (list 'varlist var) '()))
+   (pattern-lambda (try tryb var catchb)
+                   (if var (list 'varlist var) '()))
+
+   ;; type definition
+   (pattern-lambda (type mut (<: (curly tn . tvars) super) body)
+                   (list* 'varlist (cons (unescape tn) (unescape tn)) '(new . new)
+                          (map typevar-expr-name tvars)))
+   (pattern-lambda (type mut (curly tn . tvars) body)
+                   (list* 'varlist (cons (unescape tn) (unescape tn)) '(new . new)
+                          (map typevar-expr-name tvars)))
+   (pattern-lambda (type mut (<: tn super) body)
+                   (list 'varlist (cons (unescape tn) (unescape tn)) '(new . new)))
+   (pattern-lambda (type mut tn body)
+                   (list 'varlist (cons (unescape tn) (unescape tn)) '(new . new)))
+
+   )) ; vars-introduced-by-patterns
+
+(define keywords-introduced-by-patterns
+  (pattern-set
+   (pattern-lambda (function (call (curly name . sparams) . argl) body)
+                   (cons 'varlist (llist-keywords (fix-arglist argl))))
+
+   (pattern-lambda (function (call name . argl) body)
+                   (cons 'varlist (llist-keywords (fix-arglist argl))))
+
+   (pattern-lambda (= (call (curly name . sparams) . argl) body)
+                   `(function (call (curly ,name . ,sparams) . ,argl) ,body))
+   (pattern-lambda (= (call name . argl) body)
+                   `(function (call ,name ,@argl) ,body))
+   ))
+
+(define (pair-with-gensyms v)
+  (map (lambda (s)
+         (if (pair? s)
+             s
+             (cons s (named-gensy s))))
+       v))
+
+(define (unescape e)
+  (if (and (pair? e) (eq? (car e) 'escape))
+      (cadr e)
+      e))
+
+(define (typevar-expr-name e)
+  (if (symbol? e) e
+      (cadr e)))
+
+(define (new-expansion-env-for x env)
+  (let ((globals (find-declared-vars-in-expansion x 'global)))
+    (receive
+     (pairs vnames) (separate pair? (vars-introduced-by x))
+     (let ((v (diff (delete-duplicates
+                     (append! (find-declared-vars-in-expansion x 'local)
+                              (find-assigned-vars-in-expansion x)
+                              vnames))
+                    globals)))
+       (append!
+        pairs
+        (filter (lambda (v) (not (assq (car v) env)))
+                (append!
+                 (pair-with-gensyms v)
+                 (map (lambda (v) (cons v v))
+                      (diff (keywords-introduced-by x) globals))))
+        env)))))
+
+(define (resolve-expansion-vars-with-new-env x env m inarg)
+  (resolve-expansion-vars-
+   x
+   (if (and (pair? x) (eq? (car x) 'let))
+       ;; let is strange in that it needs both old and new envs within
+       ;; the same expression
+       env
+       (new-expansion-env-for x env))
+   m inarg))
+
+(define (resolve-expansion-vars- e env m inarg)
+  (cond ((or (eq? e 'true) (eq? e 'false) (eq? e 'end))
+         e)
+        ((symbol? e)
+         (let ((a (assq e env)))
+           (if a (cdr a)
+               (if m `(|.| ,m (quote ,e))
+                   e))))
+        ((or (not (pair? e)) (quoted? e))
+         e)
+        (else
+         (case (car e)
+           ((jlgensym) e)
+           ((escape) (cadr e))
+           ((global) (let ((arg (cadr e)))
+                       (cond ((symbol? arg) e)
+                             ((assignment? arg)
+                              `(global
+                                (= ,(unescape (cadr arg))
+                                   ,(resolve-expansion-vars-with-new-env (caddr arg) env m inarg))))
+                             (else
+                              `(global ,(resolve-expansion-vars-with-new-env arg env m inarg))))))
+           ((using import importall export meta) (map unescape e))
+           ((macrocall)
+            (if (or (eq? (cadr e) '@label) (eq? (cadr e) '@goto)) e
+                `(macrocall ,.(map (lambda (x)
+                                     (resolve-expansion-vars- x env m inarg))
+                                   (cdr e)))))
+           ((symboliclabel) e)
+           ((symbolicgoto) e)
+           ((type)
+            `(type ,(cadr e) ,(resolve-expansion-vars- (caddr e) env m inarg)
+                   ;; type has special behavior: identifiers inside are
+                   ;; field names, not expressions.
+                   ,(map (lambda (x)
+                           (cond ((atom? x) x)
+                                 ((and (pair? x) (eq? (car x) '|::|))
+                                  `(|::| ,(cadr x)
+                                    ,(resolve-expansion-vars- (caddr x) env m inarg)))
+                                 (else
+                                  (resolve-expansion-vars-with-new-env x env m inarg))))
+                         (cadddr e))))
+
+           ((parameters)
+            (cons 'parameters
+                  (map (lambda (x)
+                         (resolve-expansion-vars- x env m #f))
+                       (cdr e))))
+
+           ((= function)
+            (if (and (pair? (cadr e)) (eq? (caadr e) 'call))
+                ;; in (kw x 1) inside an arglist, the x isn't actually a kwarg
+                `(,(car e) (call ,(resolve-expansion-vars-with-new-env (cadadr e) env m inarg)
+                                 ,@(map (lambda (x)
+                                          (resolve-expansion-vars-with-new-env x env m #t))
+                                        (cddr (cadr e))))
+                  ,(resolve-expansion-vars-with-new-env (caddr e) env m inarg))
+                `(,(car e) ,@(map (lambda (x)
+                                    (resolve-expansion-vars-with-new-env x env m inarg))
+                                  (cdr e)))))
+
+           ((kw)
+            (if (and (pair? (cadr e))
+                     (eq? (caadr e) '|::|))
+                `(kw (|::|
+                      ,(if inarg
+                           (resolve-expansion-vars- (cadr (cadr e)) env m inarg)
+                           ;; in keyword arg A=B, don't transform "A"
+                           (cadr (cadr e)))
+                      ,(resolve-expansion-vars- (caddr (cadr e)) env m inarg))
+                     ,(resolve-expansion-vars- (caddr e) env m inarg))
+                `(kw ,(if inarg
+                          (resolve-expansion-vars- (cadr e) env m inarg)
+                          (cadr e))
+                     ,(resolve-expansion-vars- (caddr e) env m inarg))))
+
+           ((localize)
+            (let ((expr (cadr e))
+                  (lvars (map unescape (cddr e))))
+              (let ((vs (delete-duplicates
+                         (expr-find-all (lambda (v)
+                                          (and (symbol? v) (or (memq v lvars)
+                                                               (assq v env))))
+                                        expr identity)))
+                    (e2 (resolve-expansion-vars-with-new-env expr env m inarg)))
+                `(call (-> (tuple ,@vs) ,e2) ,@vs))))
+
+           ((let)
+            (let* ((newenv (new-expansion-env-for e env))
+                   (body   (resolve-expansion-vars- (cadr e) newenv m inarg)))
+              `(let ,body
+                 ,@(map
+                    (lambda (bind)
+                      (if (assignment? bind)
+                          (make-assignment
+                           ;; expand binds in old env with dummy RHS
+                           (cadr (resolve-expansion-vars- (make-assignment (cadr bind) 0)
+                                                          newenv m inarg))
+                           ;; expand initial values in old env
+                           (resolve-expansion-vars- (caddr bind) env m inarg))
+                          bind))
+                    (cddr e)))))
+
+           ;; todo: trycatch
+           (else
+            (cons (car e)
+                  (map (lambda (x)
+                         (resolve-expansion-vars-with-new-env x env m inarg))
+                       (cdr e))))))))
+
+;; decl-var that also identifies f in f()=...
+(define (decl-var* e)
+  (cond ((not (pair? e))       e)
+        ((eq? (car e) 'escape) '())
+        ((eq? (car e) 'call)   (decl-var* (cadr e)))
+        ((eq? (car e) '=)      (decl-var* (cadr e)))
+        ((eq? (car e) 'curly)  (decl-var* (cadr e)))
+        (else                  (decl-var e))))
+
+(define (function-def? e)
+  (and (pair? e) (or (eq? (car e) 'function) (eq? (car e) '->)
+                     (and (eq? (car e) '=) (length= e 3)
+                          (pair? (cadr e)) (eq? (caadr e) 'call)))))
+
+(define (find-declared-vars-in-expansion e decl (outer #t))
+  (cond ((or (not (pair? e)) (quoted? e)) '())
+        ((eq? (car e) 'escape)  '())
+        ((eq? (car e) 'localize) '())
+        ((eq? (car e) decl)     (map decl-var* (cdr e)))
+        ((and (not outer) (function-def? e)) '())
+        (else
+         (apply append! (map (lambda (x)
+                               (find-declared-vars-in-expansion x decl #f))
+                             e)))))
+
+(define (find-assigned-vars-in-expansion e (outer #t))
+  (cond ((or (not (pair? e)) (quoted? e))  '())
+        ((eq? (car e) 'escape)  '())
+        ((eq? (car e) 'localize) '())
+        ((and (not outer) (function-def? e))
+         ;; pick up only function name
+         (let ((fname (cond ((eq? (car e) '=) (cadr (cadr e)))
+                            ((eq? (car e) 'function)
+                             (if (eq? (car (cadr e)) 'tuple)
+                                 #f
+                                 (cadr (cadr e))))
+                            (else #f))))
+           (if (symbol? fname)
+               (list fname)
+               '())))
+        ((and (eq? (car e) '=) (not (function-def? e)))
+         (append! (filter
+                   symbol?
+                   (if (and (pair? (cadr e)) (eq? (car (cadr e)) 'tuple))
+                       (map decl-var* (cdr (cadr e)))
+                       (list (decl-var* (cadr e)))))
+                  (find-assigned-vars-in-expansion (caddr e) #f)))
+        (else
+         (apply append! (map (lambda (x)
+                               (find-assigned-vars-in-expansion x #f))
+                             e)))))
+
+(define (vars-introduced-by e)
+  (let ((v (pattern-expand1 vars-introduced-by-patterns e)))
+    (if (and (pair? v) (eq? (car v) 'varlist))
+        (cdr v)
+        '())))
+
+(define (keywords-introduced-by e)
+  (let ((v (pattern-expand1 keywords-introduced-by-patterns e)))
+    (if (and (pair? v) (eq? (car v) 'varlist))
+        (cdr v)
+        '())))
+
+(define (resolve-expansion-vars e m)
+  ;; expand binding form patterns
+  ;; keep track of environment, rename locals to gensyms
+  ;; and wrap globals in (getfield module var) for macro's home module
+  (resolve-expansion-vars-with-new-env e '() m #f))
+
+(define (find-symbolic-labels e)
+  (let ((defs (table))
+        (refs (table)))
+    (find-symbolic-label-defs e defs)
+    (find-symbolic-label-refs e refs)
+    (table.foldl
+     (lambda (label v labels)
+       (if (has? refs label)
+           (cons label labels)
+           labels))
+     '() defs)))
+
+(define (rename-symbolic-labels- e relabel)
+  (cond
+   ((or (not (pair? e)) (quoted? e)) e)
+   ((eq? (car e) 'symbolicgoto)
+    (let ((newlabel (assq (cadr e) relabel)))
+      (if newlabel `(symbolicgoto ,(cdr newlabel)) e)))
+   ((eq? (car e) 'symboliclabel)
+    (let ((newlabel (assq (cadr e) relabel)))
+      (if newlabel `(symboliclabel ,(cdr newlabel)) e)))
+   (else (map (lambda (x) (rename-symbolic-labels- x relabel)) e))))
+
+(define (rename-symbolic-labels e)
+  (let* ((labels (find-symbolic-labels e))
+         (relabel (pair-with-gensyms labels)))
+    (rename-symbolic-labels- e relabel)))
+
+;; macro expander entry point
+
+(define (julia-expand-macros e)
+  (cond ((not (pair? e))     e)
+        ((eq? (car e) 'quote)
+         ;; backquote is essentially a built-in macro at the moment
+         (julia-expand-macros (julia-bq-expand (cadr e) 0)))
+        ((eq? (car e) 'inert) e)
+        ((eq? (car e) 'macrocall)
+         ;; expand macro
+         (let ((form (apply invoke-julia-macro (cadr e) (cddr e))))
+           (if (not form)
+               (error (string "macro \"" (cadr e) "\" not defined")))
+           (if (and (pair? form) (eq? (car form) 'error))
+               (error (cadr form)))
+           (let ((form (car form))
+                 (m    (cdr form)))
+             ;; m is the macro's def module, or #f if def env === use env
+             (rename-symbolic-labels
+              (julia-expand-macros
+               (resolve-expansion-vars form m))))))
+        ((eq? (car e) 'module) e)
+        (else
+         (map julia-expand-macros e))))
diff --git a/src/mk_julia_flisp_boot.scm b/src/mk_julia_flisp_boot.scm
index 295474188e2c2..59985106d9517 100644
--- a/src/mk_julia_flisp_boot.scm
+++ b/src/mk_julia_flisp_boot.scm
@@ -1,2 +1,5 @@
-(load "jlfrontend.scm")
-(make-system-image (os.getenv "julia_flisp_boot"))
+(set! lastpwd (path.cwd))
+(path.cwd (cadr *argv*))
+(load (caddr *argv*))
+(path.cwd lastpwd)
+(make-system-image (cadddr *argv*))
diff --git a/src/module.c b/src/module.c
index 4162113cbc126..cf4d34c55d647 100644
--- a/src/module.c
+++ b/src/module.c
@@ -15,9 +15,8 @@ jl_module_t *jl_main_module=NULL;
 jl_module_t *jl_core_module=NULL;
 jl_module_t *jl_base_module=NULL;
 jl_module_t *jl_top_module=NULL;
-jl_module_t *jl_current_module=NULL;
 
-jl_module_t *jl_new_module(jl_sym_t *name)
+JL_DLLEXPORT jl_module_t *jl_new_module(jl_sym_t *name)
 {
     jl_module_t *m = (jl_module_t*)jl_gc_allocobj(sizeof(jl_module_t));
     jl_set_typeof(m, jl_module_type);
@@ -25,11 +24,10 @@ jl_module_t *jl_new_module(jl_sym_t *name)
     assert(jl_is_symbol(name));
     m->name = name;
     m->parent = NULL;
-    m->constant_table = NULL;
-    m->call_func = NULL;
     m->istopmod = 0;
     m->std_imports = 0;
     m->uuid = uv_now(uv_default_loop());
+    m->counter = 0;
     htable_new(&m->bindings, 0);
     arraylist_new(&m->usings, 0);
     if (jl_core_module) {
@@ -42,7 +40,12 @@ jl_module_t *jl_new_module(jl_sym_t *name)
     return m;
 }
 
-DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports)
+uint32_t jl_module_next_counter(jl_module_t *m)
+{
+    return ++(m->counter);
+}
+
+JL_DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports)
 {
     jl_module_t *m = jl_new_module(name);
     JL_GC_PUSH1(&m);
@@ -53,14 +56,14 @@ DLLEXPORT jl_value_t *jl_f_new_module(jl_sym_t *name, uint8_t std_imports)
     return (jl_value_t*)m;
 }
 
-DLLEXPORT void jl_set_istopmod(uint8_t isprimary)
+JL_DLLEXPORT void jl_set_istopmod(uint8_t isprimary)
 {
     jl_current_module->istopmod = 1;
     if (isprimary)
         jl_top_module = jl_current_module;
 }
 
-DLLEXPORT uint8_t jl_istopmod(jl_module_t *mod)
+JL_DLLEXPORT uint8_t jl_istopmod(jl_module_t *mod)
 {
     return mod->istopmod;
 }
@@ -76,11 +79,12 @@ static jl_binding_t *new_binding(jl_sym_t *name)
     b->constp = 0;
     b->exportp = 0;
     b->imported = 0;
+    b->deprecated = 0;
     return b;
 }
 
 // get binding for assignment
-DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
     jl_binding_t *b;
@@ -93,7 +97,7 @@ DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var)
         else if ((*bp)->owner != m) {
             // TODO: change this to an error soon
             jl_printf(JL_STDERR,
-                       "WARNING: imported binding for %s overwritten in module %s\n", var->name, m->name->name);
+                      "WARNING: imported binding for %s overwritten in module %s\n", jl_symbol_name(var), jl_symbol_name(m->name));
         }
         else {
             return *bp;
@@ -108,7 +112,7 @@ DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m, jl_sym_t *var)
 }
 
 // return module of binding
-DLLEXPORT jl_module_t *jl_get_module_of_binding(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_module_t *jl_get_module_of_binding(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_binding(m, var);
     if (b == NULL)
@@ -119,14 +123,15 @@ DLLEXPORT jl_module_t *jl_get_module_of_binding(jl_module_t *m, jl_sym_t *var)
 // get binding for adding a method
 // like jl_get_binding_wr, but uses existing imports instead of warning
 // and overwriting.
-DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var)
 {
     if (jl_base_module && m->std_imports && !jl_binding_resolved_p(m,var)) {
         jl_module_t *opmod = (jl_module_t*)jl_get_global(jl_base_module, jl_symbol("Operators"));
         if (opmod != NULL && jl_defines_or_exports_p(opmod, var)) {
             jl_printf(JL_STDERR,
                       "WARNING: module %s should explicitly import %s from %s\n",
-                      m->name->name, var->name, jl_base_module->name->name);
+                      jl_symbol_name(m->name), jl_symbol_name(var),
+                      jl_symbol_name(jl_base_module->name));
             jl_module_import(m, opmod, var);
         }
     }
@@ -138,23 +143,22 @@ DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *
         if (b->owner != m && b->owner != NULL) {
             jl_binding_t *b2 = jl_get_binding(b->owner, var);
             if (b2 == NULL)
-                jl_errorf("invalid method definition: imported function %s.%s does not exist", b->owner->name->name, var->name);
-            if (!b->imported && (b2->value==NULL || jl_is_function(b2->value))) {
-                if (b2->value && !jl_is_gf(b2->value)) {
-                    jl_errorf("error in method definition: %s.%s cannot be extended", b->owner->name->name, var->name);
-                }
-                else {
-                    if (jl_base_module && m->std_imports && b->owner == jl_base_module) {
-                        jl_module_t *opmod = (jl_module_t*)jl_get_global(jl_base_module, jl_symbol("Operators"));
-                        if (opmod != NULL && jl_defines_or_exports_p(opmod, var)) {
-                            jl_printf(JL_STDERR,
-                                      "WARNING: module %s should explicitly import %s from %s\n",
-                                      m->name->name, var->name, b->owner->name->name);
-                            return b2;
-                        }
+                jl_errorf("invalid method definition: imported function %s.%s does not exist", jl_symbol_name(b->owner->name), jl_symbol_name(var));
+            // TODO: we might want to require explicitly importing types to add constructors
+            if (!b->imported && (b2->value == NULL || !jl_is_type(b2->value))) {
+                if (jl_base_module && m->std_imports && b->owner == jl_base_module) {
+                    jl_module_t *opmod = (jl_module_t*)jl_get_global(jl_base_module, jl_symbol("Operators"));
+                    if (opmod != NULL && jl_defines_or_exports_p(opmod, var)) {
+                        jl_printf(JL_STDERR,
+                                  "WARNING: module %s should explicitly import %s from %s\n",
+                                  jl_symbol_name(m->name),
+                                  jl_symbol_name(var),
+                                  jl_symbol_name(b->owner->name));
+                        return b2;
                     }
-                    jl_errorf("error in method definition: function %s.%s must be explicitly imported to be extended", b->owner->name->name, var->name);
                 }
+                jl_errorf("error in method definition: function %s.%s must be explicitly imported to be extended", jl_symbol_name(b->owner->name),
+                          jl_symbol_name(var));
             }
             return b2;
         }
@@ -204,7 +208,9 @@ static jl_binding_t *jl_get_binding_(jl_module_t *m, jl_sym_t *var, modstack_t *
                     !(tempb->constp && tempb->value && b->constp && b->value == tempb->value)) {
                     jl_printf(JL_STDERR,
                               "WARNING: both %s and %s export \"%s\"; uses of it in module %s must be qualified\n",
-                              owner->name->name, imp->name->name, var->name, m->name->name);
+                              jl_symbol_name(owner->name),
+                              jl_symbol_name(imp->name), jl_symbol_name(var),
+                              jl_symbol_name(m->name));
                     // mark this binding resolved, to avoid repeating the warning
                     (void)jl_get_binding_wr(m, var);
                     return NULL;
@@ -227,20 +233,24 @@ static jl_binding_t *jl_get_binding_(jl_module_t *m, jl_sym_t *var, modstack_t *
     return b;
 }
 
-DLLEXPORT jl_binding_t *jl_get_binding(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_binding_t *jl_get_binding(jl_module_t *m, jl_sym_t *var)
 {
     return jl_get_binding_(m, var, NULL);
 }
 
-DLLEXPORT jl_binding_t *jl_get_binding_or_error(jl_module_t *m, jl_sym_t *var)
+void jl_binding_deprecation_warning(jl_binding_t *b);
+
+JL_DLLEXPORT jl_binding_t *jl_get_binding_or_error(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_binding_(m, var, NULL);
     if (b == NULL)
         jl_undefined_var_error(var);
+    if (b->deprecated)
+        jl_binding_deprecation_warning(b);
     return b;
 }
 
-DLLEXPORT jl_value_t *jl_module_globalref(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_value_t *jl_module_globalref(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = (jl_binding_t*)ptrhash_get(&m->bindings, var);
     if (b == HT_NOTFOUND) {
@@ -262,7 +272,7 @@ static int eq_bindings(jl_binding_t *a, jl_binding_t *b)
 }
 
 // does module m explicitly import s?
-int jl_is_imported(jl_module_t *m, jl_sym_t *s)
+JL_DLLEXPORT int jl_is_imported(jl_module_t *m, jl_sym_t *s)
 {
     jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, s);
     jl_binding_t *bto = *bp;
@@ -279,7 +289,8 @@ static void module_import_(jl_module_t *to, jl_module_t *from, jl_sym_t *s,
     if (b == NULL) {
         jl_printf(JL_STDERR,
                   "WARNING: could not import %s.%s into %s\n",
-                  from->name->name, s->name, to->name->name);
+                  jl_symbol_name(from->name), jl_symbol_name(s),
+                  jl_symbol_name(to->name));
     }
     else {
         jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&to->bindings, s);
@@ -302,7 +313,8 @@ static void module_import_(jl_module_t *to, jl_module_t *from, jl_sym_t *s,
                 }
                 jl_printf(JL_STDERR,
                           "WARNING: ignoring conflicting import of %s.%s into %s\n",
-                          from->name->name, s->name, to->name->name);
+                          jl_symbol_name(from->name), jl_symbol_name(s),
+                          jl_symbol_name(to->name));
             }
             else if (bto->constp || bto->value) {
                 // conflict with name owned by destination module
@@ -313,7 +325,8 @@ static void module_import_(jl_module_t *to, jl_module_t *from, jl_sym_t *s,
                 }
                 jl_printf(JL_STDERR,
                           "WARNING: import of %s.%s into %s conflicts with an existing identifier; ignored.\n",
-                          from->name->name, s->name, to->name->name);
+                          jl_symbol_name(from->name), jl_symbol_name(s),
+                          jl_symbol_name(to->name));
             }
             else {
                 bto->owner = b->owner;
@@ -324,23 +337,25 @@ static void module_import_(jl_module_t *to, jl_module_t *from, jl_sym_t *s,
             jl_binding_t *nb = new_binding(s);
             nb->owner = b->owner;
             nb->imported = (explici!=0);
+            nb->deprecated = b->deprecated;
             *bp = nb;
             jl_gc_wb_buf(to, nb);
         }
     }
 }
 
-void jl_module_import(jl_module_t *to, jl_module_t *from, jl_sym_t *s)
+JL_DLLEXPORT void jl_module_import(jl_module_t *to, jl_module_t *from,
+                                   jl_sym_t *s)
 {
     module_import_(to, from, s, 1);
 }
 
-void jl_module_use(jl_module_t *to, jl_module_t *from, jl_sym_t *s)
+JL_DLLEXPORT void jl_module_use(jl_module_t *to, jl_module_t *from, jl_sym_t *s)
 {
     module_import_(to, from, s, 0);
 }
 
-void jl_module_importall(jl_module_t *to, jl_module_t *from)
+JL_DLLEXPORT void jl_module_importall(jl_module_t *to, jl_module_t *from)
 {
     void **table = from->bindings.table;
     for(size_t i=1; i < from->bindings.size; i+=2) {
@@ -352,7 +367,7 @@ void jl_module_importall(jl_module_t *to, jl_module_t *from)
     }
 }
 
-void jl_module_using(jl_module_t *to, jl_module_t *from)
+JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from)
 {
     if (to == from)
         return;
@@ -377,7 +392,8 @@ void jl_module_using(jl_module_t *to, jl_module_t *from)
                     !eq_bindings(jl_get_binding(to,var), b)) {
                     jl_printf(JL_STDERR,
                               "WARNING: using %s.%s in module %s conflicts with an existing identifier.\n",
-                              from->name->name, var->name, to->name->name);
+                              jl_symbol_name(from->name), jl_symbol_name(var),
+                              jl_symbol_name(to->name));
                 }
             }
         }
@@ -386,7 +402,7 @@ void jl_module_using(jl_module_t *to, jl_module_t *from)
     arraylist_push(&to->usings, from);
 }
 
-void jl_module_export(jl_module_t *from, jl_sym_t *s)
+JL_DLLEXPORT void jl_module_export(jl_module_t *from, jl_sym_t *s)
 {
     jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&from->bindings, s);
     if (*bp == HT_NOTFOUND) {
@@ -400,41 +416,42 @@ void jl_module_export(jl_module_t *from, jl_sym_t *s)
     (*bp)->exportp = 1;
 }
 
-int jl_boundp(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_binding(m, var);
     return b && (b->value != NULL);
 }
 
-int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
     if (*bp == HT_NOTFOUND) return 0;
     return (*bp)->exportp || (*bp)->owner==m;
 }
 
-DLLEXPORT int jl_module_exports_p(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT int jl_module_exports_p(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
     if (*bp == HT_NOTFOUND) return 0;
     return (*bp)->exportp;
 }
 
-int jl_binding_resolved_p(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT int jl_binding_resolved_p(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t **bp = (jl_binding_t**)ptrhash_bp(&m->bindings, var);
     if (*bp == HT_NOTFOUND) return 0;
     return (*bp)->owner != NULL;
 }
 
-jl_value_t *jl_get_global(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_binding(m, var);
     if (b == NULL) return NULL;
+    if (b->deprecated) jl_binding_deprecation_warning(b);
     return b->value;
 }
 
-void jl_set_global(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
+JL_DLLEXPORT void jl_set_global(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
 {
     jl_binding_t *bp = jl_get_binding_wr(m, var);
     if (!bp->constp) {
@@ -443,7 +460,7 @@ void jl_set_global(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
     }
 }
 
-void jl_set_const(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
+JL_DLLEXPORT void jl_set_const(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
 {
     jl_binding_t *bp = jl_get_binding_wr(m, var);
     if (!bp->constp) {
@@ -453,49 +470,106 @@ void jl_set_const(jl_module_t *m, jl_sym_t *var, jl_value_t *val)
     }
 }
 
-DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var)
+JL_DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var)
 {
     if (m == NULL) m = jl_current_module;
     jl_binding_t *b = jl_get_binding(m, var);
     return b && b->constp;
 }
 
-DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_value_t *rhs)
+JL_DLLEXPORT void jl_deprecate_binding(jl_module_t *m, jl_sym_t *var)
+{
+    jl_binding_t *b = jl_get_binding(m, var);
+    if (b) b->deprecated = 1;
+}
+
+JL_DLLEXPORT int jl_is_binding_deprecated(jl_module_t *m, jl_sym_t *var)
+{
+    jl_binding_t *b = jl_get_binding(m, var);
+    return b && b->deprecated;
+}
+
+extern const char *jl_filename;
+extern int jl_lineno;
+
+void jl_binding_deprecation_warning(jl_binding_t *b)
+{
+    if (b->deprecated && jl_options.depwarn) {
+        if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR)
+            jl_printf(JL_STDERR, "WARNING: ");
+        if (b->owner)
+            jl_printf(JL_STDERR, "%s.%s is deprecated",
+                      jl_symbol_name(b->owner->name), jl_symbol_name(b->name));
+        else
+            jl_printf(JL_STDERR, "%s is deprecated", jl_symbol_name(b->name));
+        jl_value_t *v = b->value;
+        if (v && (jl_is_type(v)/* || (jl_is_function(v) && jl_is_gf(v))*/)) {
+            jl_printf(JL_STDERR, ", use ");
+            if (b->owner && strcmp(jl_symbol_name(b->owner->name), "Base") == 0 &&
+                strcmp(jl_symbol_name(b->name), "Uint") == 0) {
+                // TODO: Suggesting type b->value is wrong for typealiases.
+                // Uncommon in Base, hardcoded here for now, see #13221
+                jl_printf(JL_STDERR, "UInt");
+            }
+            else {
+                jl_static_show(JL_STDERR, v);
+            }
+            jl_printf(JL_STDERR, " instead");
+        }
+        jl_printf(JL_STDERR, ".\n");
+
+        if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR)
+            jl_printf(JL_STDERR, "  likely near %s:%d\n", jl_filename, jl_lineno);
+
+        if (jl_options.depwarn == JL_OPTIONS_DEPWARN_ERROR) {
+            if (b->owner)
+                jl_errorf("deprecated binding: %s.%s",
+                          jl_symbol_name(b->owner->name),
+                          jl_symbol_name(b->name));
+            else
+                jl_errorf("deprecated binding: %s", jl_symbol_name(b->name));
+        }
+    }
+}
+
+JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_value_t *rhs)
 {
     if (b->constp && b->value != NULL) {
         if (!jl_egal(rhs, b->value)) {
             if (jl_typeof(rhs) != jl_typeof(b->value) ||
-                jl_is_type(rhs) || jl_is_function(rhs) || jl_is_module(rhs)) {
-                jl_errorf("invalid redefinition of constant %s", b->name->name);
+                jl_is_type(rhs) /*|| jl_is_function(rhs)*/ || jl_is_module(rhs)) {
+                jl_errorf("invalid redefinition of constant %s",
+                          jl_symbol_name(b->name));
             }
-            jl_printf(JL_STDERR,"WARNING: redefining constant %s\n",b->name->name);
+            jl_printf(JL_STDERR, "WARNING: redefining constant %s\n",
+                      jl_symbol_name(b->name));
         }
     }
     b->value = rhs;
     jl_gc_wb_binding(b, rhs);
 }
 
-DLLEXPORT void jl_declare_constant(jl_binding_t *b)
+JL_DLLEXPORT void jl_declare_constant(jl_binding_t *b)
 {
     if (b->value != NULL && !b->constp) {
         jl_errorf("cannot declare %s constant; it already has a value",
-                  b->name->name);
+                  jl_symbol_name(b->name));
     }
     b->constp = 1;
 }
 
-DLLEXPORT jl_value_t *jl_get_current_module()
+JL_DLLEXPORT jl_value_t *jl_get_current_module(void)
 {
     return (jl_value_t*)jl_current_module;
 }
 
-DLLEXPORT void jl_set_current_module(jl_value_t *m)
+JL_DLLEXPORT void jl_set_current_module(jl_value_t *m)
 {
     assert(jl_typeis(m, jl_module_type));
     jl_current_module = (jl_module_t*)m;
 }
 
-DLLEXPORT jl_value_t *jl_module_usings(jl_module_t *m)
+JL_DLLEXPORT jl_value_t *jl_module_usings(jl_module_t *m)
 {
     jl_array_t *a = jl_alloc_array_1d(jl_array_any_type, 0);
     JL_GC_PUSH1(&a);
@@ -508,7 +582,7 @@ DLLEXPORT jl_value_t *jl_module_usings(jl_module_t *m)
     return (jl_value_t*)a;
 }
 
-DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported)
+JL_DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported)
 {
     jl_array_t *a = jl_alloc_array_1d(jl_array_symbol_type, 0);
     JL_GC_PUSH1(&a);
@@ -517,7 +591,9 @@ DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported)
     for(i=1; i < m->bindings.size; i+=2) {
         if (table[i] != HT_NOTFOUND) {
             jl_binding_t *b = (jl_binding_t*)table[i];
-            if (b->exportp || ((imported || b->owner == m) && (all || m == jl_main_module))) {
+            int hidden = jl_symbol_name(b->name)[0]=='#';
+            if ((b->exportp || ((imported || b->owner == m) && (all || m == jl_main_module))) &&
+                !b->deprecated && !hidden) {
                 jl_array_grow_end(a, 1);
                 //XXX: change to jl_arrayset if array storage allocation for Array{Symbols,1} changes:
                 jl_cellset(a, jl_array_dim0(a)-1, (jl_value_t*)b->name);
@@ -528,25 +604,25 @@ DLLEXPORT jl_value_t *jl_module_names(jl_module_t *m, int all, int imported)
     return (jl_value_t*)a;
 }
 
-DLLEXPORT jl_sym_t *jl_module_name(jl_module_t *m) { return m->name; }
-DLLEXPORT jl_module_t *jl_module_parent(jl_module_t *m) { return m->parent; }
-DLLEXPORT uint64_t jl_module_uuid(jl_module_t *m) { return m->uuid; }
+JL_DLLEXPORT jl_sym_t *jl_module_name(jl_module_t *m) { return m->name; }
+JL_DLLEXPORT jl_module_t *jl_module_parent(jl_module_t *m) { return m->parent; }
+JL_DLLEXPORT uint64_t jl_module_uuid(jl_module_t *m) { return m->uuid; }
 
 jl_function_t *jl_module_get_initializer(jl_module_t *m)
 {
     jl_value_t *f = jl_get_global(m, jl_symbol("__init__"));
-    if (f == NULL || !jl_is_function(f))
+    if (f == NULL /*|| !jl_is_function(f)*/)
         return NULL;
     return (jl_function_t*)f;
 }
 
-void jl_module_run_initializer(jl_module_t *m)
+JL_DLLEXPORT void jl_module_run_initializer(jl_module_t *m)
 {
     jl_function_t *f = jl_module_get_initializer(m);
     if (f == NULL)
         return;
     JL_TRY {
-        jl_apply(f, NULL, 0);
+        jl_apply(&f, 1);
     }
     JL_CATCH {
         if (jl_initerror_type == NULL) {
@@ -559,17 +635,6 @@ void jl_module_run_initializer(jl_module_t *m)
     }
 }
 
-jl_function_t *jl_module_call_func(jl_module_t *m)
-{
-    if (m->call_func == NULL) {
-        jl_function_t *cf = (jl_function_t*)jl_get_global(m, call_sym);
-        if (cf == NULL || !jl_is_function(cf) || !jl_is_gf(cf))
-            cf = jl_bottom_func;
-        m->call_func = cf;
-    }
-    return m->call_func;
-}
-
 int jl_is_submodule(jl_module_t *child, jl_module_t *parent)
 {
     while (1) {
diff --git a/src/options.h b/src/options.h
index c17495befef20..948f00e857fed 100644
--- a/src/options.h
+++ b/src/options.h
@@ -3,26 +3,21 @@
 #ifndef JL_OPTIONS_H
 #define JL_OPTIONS_H
 
+// Options in here are NOT allowed to affect the jlapi, since that would require this header to be installed
+
 // Build-time options for debugging, tweaking, and selecting alternative
 // implementations of core features.
 
 // object layout options ------------------------------------------------------
 
-// if this is not defined, only individual dimension sizes are
-// stored and not total length, to save space.
-#define STORE_ARRAY_LEN
-
 // how much space we're willing to waste if an array outgrows its
 // original object
 #define ARRAY_INLINE_NBYTES (2048*sizeof(void*))
 
 // codegen options ------------------------------------------------------------
 
-// (Experimental) codegen support for thread-local storage
-// #define CODEGEN_TLS
-
 // (Experimental) Use MCJIT ELF, even where it's not the native format
-// #define FORCE_ELF
+//#define FORCE_ELF
 
 // with KEEP_BODIES, we keep LLVM function bodies around for later debugging
 // #define KEEP_BODIES
@@ -65,7 +60,7 @@
 //#define GC_TIME
 
 // OBJPROFILE counts objects by type
-//#define OBJPROFILE
+// #define OBJPROFILE
 
 
 // method dispatch profiling --------------------------------------------------
@@ -94,6 +89,20 @@
 #define COPY_STACKS
 #endif
 
+// threading options ----------------------------------------------------------
+
+// controls for when threads sleep
+#define THREAD_SLEEP_THRESHOLD_NAME     "JULIA_THREAD_SLEEP_THRESHOLD"
+#define DEFAULT_THREAD_SLEEP_THRESHOLD  1e9    // cycles (1e9==1sec@1GHz)
+
+// defaults for # threads
+#define NUM_THREADS_NAME                "JULIA_NUM_THREADS"
+#define DEFAULT_NUM_THREADS             4
+
+// affinitization behavior
+#define MACHINE_EXCLUSIVE_NAME          "JULIA_EXCLUSIVE"
+#define DEFAULT_MACHINE_EXCLUSIVE       0
+
 // sanitizer defaults ---------------------------------------------------------
 
 // Automatically enable MEMDEBUG and KEEP_BODIES for the sanitizers
@@ -108,5 +117,4 @@
 #  endif
 #endif
 
-
 #endif
diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
new file mode 100644
index 0000000000000..ac085fdab641a
--- /dev/null
+++ b/src/runtime_ccall.cpp
@@ -0,0 +1,140 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#include <map>
+#include <string>
+#include <cstdio>
+#include <llvm/Support/Host.h>
+#include "julia.h"
+#include "julia_internal.h"
+using namespace llvm;
+
+// --- library symbol lookup ---
+
+// map from "libX" to full soname "libX.so.ver"
+#if defined(__linux__) || defined(__FreeBSD__)
+static std::map<std::string, std::string> sonameMap;
+static bool got_sonames = false;
+
+static void jl_read_sonames(void)
+{
+    char *line=NULL;
+    size_t sz=0;
+#if defined(__linux__)
+    FILE *ldc = popen("/sbin/ldconfig -p", "r");
+#else
+    FILE *ldc = popen("/sbin/ldconfig -r", "r");
+#endif
+    if (ldc == NULL) return; // ignore errors in running ldconfig (other than whatever might have been printed to stderr)
+
+    while (!feof(ldc)) {
+        ssize_t n = getline(&line, &sz, ldc);
+        if (n == -1)
+            break;
+        if (n > 2 && isspace((unsigned char)line[0])) {
+#ifdef __linux__
+            int i = 0;
+            while (isspace((unsigned char)line[++i])) ;
+            char *name = &line[i];
+            char *dot = strstr(name, ".so");
+            i = 0;
+#else
+            char *name = strstr(line, ":-l");
+            if (name == NULL) continue;
+            strncpy(name, "lib", 3);
+            char *dot = strchr(name, '.');
+#endif
+
+            if (NULL == dot)
+                continue;
+
+#ifdef __linux__
+            // Detect if this entry is for the current architecture
+            while (!isspace((unsigned char)dot[++i])) ;
+            while (isspace((unsigned char)dot[++i])) ;
+            int j = i;
+            while (!isspace((unsigned char)dot[++j])) ;
+            char *arch = strstr(dot+i,"x86-64");
+            if (arch != NULL && arch < dot + j) {
+#ifdef _P32
+                continue;
+#endif
+            }
+            else {
+#ifdef _P64
+                continue;
+#endif
+            }
+#endif // __linux__
+
+            char *abslibpath = strrchr(line, ' ');
+            if (dot != NULL && abslibpath != NULL) {
+                std::string pfx(name, dot - name);
+                // Do not include ' ' in front and '\n' at the end
+                std::string soname(abslibpath+1, line+n-(abslibpath+1)-1);
+                sonameMap[pfx] = soname;
+            }
+        }
+    }
+
+    free(line);
+    pclose(ldc);
+}
+
+extern "C" JL_DLLEXPORT const char *jl_lookup_soname(const char *pfx, size_t n)
+{
+    if (!got_sonames) {
+        jl_read_sonames();
+        got_sonames = true;
+    }
+    std::string str(pfx, n);
+    if (sonameMap.find(str) != sonameMap.end()) {
+        return sonameMap[str].c_str();
+    }
+    return NULL;
+}
+#endif
+
+// map from user-specified lib names to handles
+static std::map<std::string, void*> libMap;
+
+extern "C"
+void *jl_get_library(const char *f_lib)
+{
+    void *hnd;
+#ifdef _OS_WINDOWS_
+    if ((intptr_t)f_lib == 1)
+        return jl_exe_handle;
+    if ((intptr_t)f_lib == 2)
+        return jl_dl_handle;
+#endif
+    if (f_lib == NULL)
+        return jl_RTLD_DEFAULT_handle;
+    hnd = libMap[f_lib];
+    if (hnd != NULL)
+        return hnd;
+    hnd = jl_load_dynamic_library(f_lib, JL_RTLD_DEFAULT);
+    if (hnd != NULL)
+        libMap[f_lib] = hnd;
+    return hnd;
+}
+
+extern "C" JL_DLLEXPORT
+void *jl_load_and_lookup(const char *f_lib, const char *f_name, void **hnd)
+{
+    void *handle = *hnd;
+    if (!handle)
+        *hnd = handle = jl_get_library(f_lib);
+    return jl_dlsym(handle, f_name);
+}
+
+// miscellany
+extern "C" JL_DLLEXPORT
+jl_value_t *jl_get_cpu_name(void)
+{
+#ifdef LLVM35
+    StringRef HostCPUName = llvm::sys::getHostCPUName();
+#else
+    const std::string& HostCPUName = llvm::sys::getHostCPUName();
+#endif
+    return jl_pchar_to_string(HostCPUName.data(), HostCPUName.size());
+}
diff --git a/src/runtime_intrinsics.c b/src/runtime_intrinsics.c
new file mode 100644
index 0000000000000..e6d76782dde8e
--- /dev/null
+++ b/src/runtime_intrinsics.c
@@ -0,0 +1,948 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+// This is in implementation of the Julia intrinsic functions against boxed types
+// excluding the c interface (ccall, cglobal, llvmcall)
+//
+// this file assumes a little-endian processor, although that isn't too hard to fix
+// it also assumes two's complement negative numbers, which might be a bit harder to fix
+//
+// TODO: add half-float support
+
+#include "julia.h"
+#include "julia_internal.h"
+#include "APInt-C.h"
+const unsigned int host_char_bit = 8;
+
+// run time version of box/unbox intrinsic
+JL_DLLEXPORT jl_value_t *jl_reinterpret(jl_value_t *ty, jl_value_t *v)
+{
+    JL_TYPECHK(reinterpret, datatype, ty);
+    if (!jl_is_leaf_type(ty) || !jl_is_bitstype(ty))
+        jl_error("reinterpret: target type not a leaf bitstype");
+    if (!jl_is_bitstype(jl_typeof(v)))
+        jl_error("reinterpret: value not a bitstype");
+    if (jl_datatype_size(jl_typeof(v)) != jl_datatype_size(ty))
+        jl_error("reinterpret: argument size does not match size of target type");
+    if (ty == jl_typeof(v))
+        return v;
+    if (ty == (jl_value_t*)jl_bool_type)
+        return *(uint8_t*)jl_data_ptr(v) & 1 ? jl_true : jl_false;
+    return jl_new_bits(ty, jl_data_ptr(v));
+}
+
+// run time version of pointerref intrinsic (warning: i is not rooted)
+JL_DLLEXPORT jl_value_t *jl_pointerref(jl_value_t *p, jl_value_t *i)
+{
+    JL_TYPECHK(pointerref, pointer, p);
+    JL_TYPECHK(pointerref, long, i);
+    jl_value_t *ety = jl_tparam0(jl_typeof(p));
+    if (ety == (jl_value_t*)jl_any_type) {
+        jl_value_t **pp = (jl_value_t**)(jl_unbox_long(p) + (jl_unbox_long(i)-1)*sizeof(void*));
+        return *pp;
+    }
+    else {
+        if (!jl_is_datatype(ety))
+            jl_error("pointerref: invalid pointer");
+        size_t nb = LLT_ALIGN(jl_datatype_size(ety), ((jl_datatype_t*)ety)->alignment);
+        char *pp = (char*)jl_unbox_long(p) + (jl_unbox_long(i)-1)*nb;
+        return jl_new_bits(ety, pp);
+    }
+}
+
+// run time version of pointerset intrinsic (warning: x is not gc-rooted)
+JL_DLLEXPORT jl_value_t *jl_pointerset(jl_value_t *p, jl_value_t *x, jl_value_t *i)
+{
+    JL_TYPECHK(pointerset, pointer, p);
+    JL_TYPECHK(pointerset, long, i);
+    jl_value_t *ety = jl_tparam0(jl_typeof(p));
+    if (ety == (jl_value_t*)jl_any_type) {
+        jl_value_t **pp = (jl_value_t**)(jl_unbox_long(p) + (jl_unbox_long(i)-1)*sizeof(void*));
+        *pp = x;
+    }
+    else {
+        if (!jl_is_datatype(ety))
+            jl_error("pointerset: invalid pointer");
+        size_t nb = LLT_ALIGN(jl_datatype_size(ety), ((jl_datatype_t*)ety)->alignment);
+        char *pp = (char*)jl_unbox_long(p) + (jl_unbox_long(i)-1)*nb;
+        if (jl_typeof(x) != ety)
+            jl_error("pointerset: type mismatch in assign");
+        jl_assign_bits(pp, x);
+    }
+    return p;
+}
+
+static inline unsigned int next_power_of_two(unsigned int val)
+{
+  /* this function taken from libuv src/unix/core.c */
+  val -= 1;
+  val |= val >> 1;
+  val |= val >> 2;
+  val |= val >> 4;
+  val |= val >> 8;
+  val |= val >> 16;
+  val += 1;
+  return val;
+}
+
+static inline char signbitbyte(void *a, unsigned bytes)
+{
+    // sign bit of an signed number of n bytes, as a byte
+    return (((signed char*)a)[bytes - 1] < 0) ? ~0 : 0;
+}
+
+static inline char usignbitbyte(void *a, unsigned bytes)
+{
+    // sign bit of an unsigned number
+    return 0;
+}
+
+static inline unsigned select_by_size(unsigned sz)
+{
+    /* choose the right sized function specialization */
+    switch (sz) {
+    default: return 0;
+    case  1: return 1;
+    case  2: return 2;
+    case  4: return 3;
+    case  8: return 4;
+    case 16: return 5;
+    }
+}
+
+#define SELECTOR_FUNC(intrinsic) \
+    typedef intrinsic##_t select_##intrinsic##_t[6]; \
+    static inline intrinsic##_t select_##intrinsic(unsigned sz, select_##intrinsic##_t list) \
+    { \
+        intrinsic##_t thunk = list[select_by_size(sz)]; \
+        if (!thunk) thunk = list[0]; \
+        return thunk; \
+    }
+
+#define fp_select(a, func) \
+    sizeof(a) == sizeof(float) ? func##f((float)a) : func(a)
+#define fp_select2(a, b, func) \
+    sizeof(a) == sizeof(float) ? func##f(a, b) : func(a, b)
+
+// fast-function generators //
+
+// integer input
+// OP::Function macro(input)
+// name::unique string
+// nbits::number of bits
+// c_type::c_type corresponding to nbits
+#define un_iintrinsic_ctype(OP, name, nbits, c_type) \
+static inline void jl_##name##nbits(unsigned runtime_nbits, void *pa, void *pr) \
+{ \
+    c_type a = *(c_type*)pa; \
+    *(c_type*)pr = OP(a); \
+}
+
+// integer input, unsigned output
+// OP::Function macro(input)
+// name::unique string
+// nbits::number of bits
+// c_type::c_type corresponding to nbits
+#define uu_iintrinsic_ctype(OP, name, nbits, c_type) \
+static inline unsigned jl_##name##nbits(unsigned runtime_nbits, void *pa) \
+{ \
+    c_type a = *(c_type*)pa; \
+    return OP(a); \
+}
+
+// floating point
+// OP::Function macro(output pointer, input)
+// name::unique string
+// nbits::number of bits in the *input*
+// c_type::c_type corresponding to nbits
+#define un_fintrinsic_ctype(OP, name, c_type) \
+static inline void name(unsigned osize, void *pa, void *pr) \
+{ \
+    c_type a = *(c_type*)pa; \
+    OP((c_type*)pr, a); \
+}
+
+// float or integer inputs
+// OP::Function macro(inputa, inputb)
+// name::unique string
+// nbits::number of bits
+// c_type::c_type corresponding to nbits
+#define bi_intrinsic_ctype(OP, name, nbits, c_type) \
+static void jl_##name##nbits(unsigned runtime_nbits, void *pa, void *pb, void *pr) \
+{ \
+    c_type a = *(c_type*)pa; \
+    c_type b = *(c_type*)pb; \
+    *(c_type*)pr = (c_type)OP(a, b); \
+}
+
+// float or integer inputs, bool output
+// OP::Function macro(inputa, inputb)
+// name::unique string
+// nbits::number of bits
+// c_type::c_type corresponding to nbits
+#define bool_intrinsic_ctype(OP, name, nbits, c_type) \
+static int jl_##name##nbits(unsigned runtime_nbits, void *pa, void *pb) \
+{ \
+    c_type a = *(c_type*)pa; \
+    c_type b = *(c_type*)pb; \
+    return OP(a, b); \
+}
+
+// integer inputs, with precondition test
+// OP::Function macro(inputa, inputb)
+// name::unique string
+// nbits::number of bits
+// c_type::c_type corresponding to nbits
+#define checked_intrinsic_ctype(CHECK_OP, OP, name, nbits, c_type) \
+static int jl_##name##nbits(unsigned runtime_nbits, void *pa, void *pb, void *pr) \
+{ \
+    c_type a = *(c_type*)pa; \
+    c_type b = *(c_type*)pb; \
+    if (CHECK_OP(a, b)) \
+        return 1; \
+    *(c_type*)pr = (c_type)OP(a, b); \
+    return 0; \
+}
+
+// float inputs
+// OP::Function macro(inputa, inputb, inputc)
+// name::unique string
+// nbits::number of bits
+// c_type::c_type corresponding to nbits
+#define ter_intrinsic_ctype(OP, name, nbits, c_type) \
+static void jl_##name##nbits(unsigned runtime_nbits, void *pa, void *pb, void *pc, void *pr) \
+{ \
+    c_type a = *(c_type*)pa; \
+    c_type b = *(c_type*)pb; \
+    c_type c = *(c_type*)pc; \
+    *(c_type*)pr = (c_type)OP(a, b, c); \
+}
+
+
+// unary operator generator //
+
+typedef void (*intrinsic_1_t)(unsigned, void*, void*);
+SELECTOR_FUNC(intrinsic_1)
+#define un_iintrinsic(name, u) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a) \
+{ \
+    return jl_iintrinsic_1(jl_typeof(a), a, #name, u##signbitbyte, jl_intrinsiclambda_ty1, name##_list); \
+}
+#define un_iintrinsic_fast(LLVMOP, OP, name, u) \
+un_iintrinsic_ctype(OP, name, 8, u##int##8_t) \
+un_iintrinsic_ctype(OP, name, 16, u##int##16_t) \
+un_iintrinsic_ctype(OP, name, 32, u##int##32_t) \
+un_iintrinsic_ctype(OP, name, 64, u##int##64_t) \
+static select_intrinsic_1_t name##_list = { \
+    LLVMOP, \
+    jl_##name##8, \
+    jl_##name##16, \
+    jl_##name##32, \
+    jl_##name##64, \
+}; \
+un_iintrinsic(name, u)
+#define un_iintrinsic_slow(LLVMOP, name, u) \
+static select_intrinsic_1_t name##_list = { \
+    LLVMOP \
+}; \
+un_iintrinsic(name, u)
+
+typedef unsigned (*intrinsic_u1_t)(unsigned, void*);
+SELECTOR_FUNC(intrinsic_u1)
+#define uu_iintrinsic(name, u) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a) \
+{ \
+    return jl_iintrinsic_1(jl_typeof(a), a, #name, u##signbitbyte, jl_intrinsiclambda_u1, name##_list); \
+}
+#define uu_iintrinsic_fast(LLVMOP, OP, name, u) \
+uu_iintrinsic_ctype(OP, name, 8, u##int##8_t) \
+uu_iintrinsic_ctype(OP, name, 16, u##int##16_t) \
+uu_iintrinsic_ctype(OP, name, 32, u##int##32_t) \
+uu_iintrinsic_ctype(OP, name, 64, u##int##64_t) \
+static select_intrinsic_u1_t name##_list = { \
+    LLVMOP, \
+    jl_##name##8, \
+    jl_##name##16, \
+    jl_##name##32, \
+    jl_##name##64, \
+}; \
+uu_iintrinsic(name, u)
+#define uu_iintrinsic_slow(LLVMOP, name, u) \
+static select_intrinsic_u1_t name##_list = { \
+    LLVMOP \
+}; \
+uu_iintrinsic(name, u)
+
+static inline
+jl_value_t *jl_iintrinsic_1(jl_value_t *ty, jl_value_t *a, const char *name,
+                            char (*getsign)(void*, unsigned),
+                            jl_value_t *(*lambda1)(jl_value_t*, void*, unsigned, unsigned, void*), void *list)
+{
+    if (!jl_is_bitstype(jl_typeof(a)))
+        jl_errorf("%s: value is not a bitstype", name);
+    if (!jl_is_bitstype(ty))
+        jl_errorf("%s: type is not a bitstype", name);
+    void *pa = jl_data_ptr(a);
+    unsigned isize = jl_datatype_size(jl_typeof(a));
+    unsigned isize2 = next_power_of_two(isize);
+    unsigned osize = jl_datatype_size(ty);
+    unsigned osize2 = next_power_of_two(osize);
+    if (isize2 > osize2)
+        osize2 = isize2;
+    if (osize2 > isize || isize2 > isize) {
+        /* if needed, round type up to a real c-type and set/clear the unused bits */
+        void *pa2;
+        pa2 = alloca(osize2);
+        /* TODO: this memcpy assumes little-endian,
+         * for big-endian, need to align the copy to the other end */ \
+        memcpy(pa2, pa, isize);
+        memset((char*)pa2 + isize, getsign(pa, isize), osize2 - isize);
+        pa = pa2;
+    }
+    jl_value_t *newv = lambda1(ty, pa, osize, osize2, list);
+    if (ty == (jl_value_t*)jl_bool_type)
+        return *(uint8_t*)jl_data_ptr(newv) & 1 ? jl_true : jl_false;
+    return newv;
+}
+
+static inline jl_value_t *jl_intrinsiclambda_ty1(jl_value_t *ty, void *pa, unsigned osize, unsigned osize2, void *voidlist)
+{
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    intrinsic_1_t op = select_intrinsic_1(osize2, (intrinsic_1_t*)voidlist);
+    op(osize * host_char_bit, pa, jl_data_ptr(newv));
+    return newv;
+}
+
+static inline jl_value_t *jl_intrinsiclambda_u1(jl_value_t *ty, void *pa, unsigned osize, unsigned osize2, void *voidlist)
+{
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    intrinsic_u1_t op = select_intrinsic_u1(osize2, (intrinsic_u1_t*)voidlist);
+    unsigned cnt = op(osize * host_char_bit, pa);
+    // TODO: the following memset/memcpy assumes little-endian
+    // for big-endian, need to copy from the other end of cnt
+    if (osize > sizeof(unsigned)) {
+        // perform zext, if needed
+        memset((char*)jl_data_ptr(newv) + sizeof(unsigned), 0, osize - sizeof(unsigned));
+        osize = sizeof(unsigned);
+    }
+    memcpy(jl_data_ptr(newv), &cnt, osize);
+    return newv;
+}
+
+// conversion operator
+
+typedef void (*intrinsic_cvt_t)(unsigned, void*, unsigned, void*);
+typedef unsigned (*intrinsic_cvt_check_t)(unsigned, unsigned, void*);
+#define cvt_iintrinsic_checked(LLVMOP, check_op, name) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *ty, jl_value_t *a) \
+{ \
+    return jl_intrinsic_cvt(ty, a, #name, LLVMOP, check_op); \
+}
+#define cvt_iintrinsic(LLVMOP, name) \
+    cvt_iintrinsic_checked(LLVMOP, NULL, name) \
+
+static inline jl_value_t *jl_intrinsic_cvt(jl_value_t *ty, jl_value_t *a, const char *name, intrinsic_cvt_t op, intrinsic_cvt_check_t check_op)
+{
+    jl_value_t *aty = jl_typeof(a);
+    if (!jl_is_bitstype(aty))
+        jl_errorf("%s: value is not a bitstype", name);
+    if (!jl_is_bitstype(ty))
+        jl_errorf("%s: type is not a bitstype", name);
+    void *pa = jl_data_ptr(a);
+    unsigned isize = jl_datatype_size(aty);
+    unsigned osize = jl_datatype_size(ty);
+    if (check_op && check_op(isize, osize, pa))
+        jl_throw(jl_inexact_exception);
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    op(aty == (jl_value_t*)jl_bool_type ? 1 : isize * host_char_bit, pa,
+            osize * host_char_bit, jl_data_ptr(newv));
+    if (ty == (jl_value_t*)jl_bool_type)
+        return *(uint8_t*)jl_data_ptr(newv) & 1 ? jl_true : jl_false;
+    return newv;
+}
+
+// floating point
+
+#define un_fintrinsic_withtype(OP, name) \
+un_fintrinsic_ctype(OP, jl_##name##32, float) \
+un_fintrinsic_ctype(OP, jl_##name##64, double) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *ty, jl_value_t *a) \
+{ \
+    return jl_fintrinsic_1(ty, a, #name, jl_##name##32, jl_##name##64); \
+}
+
+#define un_fintrinsic(OP, name) \
+un_fintrinsic_withtype(OP, name##_withtype) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a) \
+{ \
+    return jl_##name##_withtype(jl_typeof(a), a); \
+}
+
+typedef void (fintrinsic_op1)(unsigned, void*, void*);
+
+static inline jl_value_t *jl_fintrinsic_1(jl_value_t *ty, jl_value_t *a, const char *name, fintrinsic_op1 *floatop, fintrinsic_op1 *doubleop)
+{
+    if (!jl_is_bitstype(jl_typeof(a)))
+        jl_errorf("%s: value is not a bitstype", name);
+    if (!jl_is_bitstype(ty))
+        jl_errorf("%s: type is not a bitstype", name);
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    void *pa = jl_data_ptr(a), *pr = jl_data_ptr(newv);
+    unsigned sz = jl_datatype_size(jl_typeof(a));
+    unsigned sz2 = jl_datatype_size(ty);
+    switch (sz) {
+    /* choose the right size c-type operation based on the input */
+    case 4:
+        floatop(sz2 * host_char_bit, pa, pr);
+        break;
+    case 8:
+        doubleop(sz2 * host_char_bit, pa, pr);
+        break;
+    default:
+        jl_errorf("%s: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64", name);
+    }
+    return newv;
+}
+
+// binary operator generator //
+
+// integer
+
+typedef void (*intrinsic_2_t)(unsigned, void*, void*, void*);
+SELECTOR_FUNC(intrinsic_2)
+#define bi_iintrinsic(name, u, cvtb) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
+{ \
+    return jl_iintrinsic_2(a, b, #name, u##signbitbyte, jl_intrinsiclambda_2, name##_list, cvtb); \
+}
+#define bi_iintrinsic_cnvtb_fast(LLVMOP, OP, name, u, cvtb) \
+bi_intrinsic_ctype(OP, name, 8, u##int##8_t) \
+bi_intrinsic_ctype(OP, name, 16, u##int##16_t) \
+bi_intrinsic_ctype(OP, name, 32, u##int##32_t) \
+bi_intrinsic_ctype(OP, name, 64, u##int##64_t) \
+static select_intrinsic_2_t name##_list = { \
+    LLVMOP, \
+    jl_##name##8, \
+    jl_##name##16, \
+    jl_##name##32, \
+    jl_##name##64, \
+}; \
+bi_iintrinsic(name, u, cvtb)
+#define bi_iintrinsic_fast(LLVMOP, OP, name, u) \
+    bi_iintrinsic_cnvtb_fast(LLVMOP, OP, name, u, 0)
+
+typedef int (*intrinsic_cmp_t)(unsigned, void*, void*);
+SELECTOR_FUNC(intrinsic_cmp)
+#define cmp_iintrinsic(name, u) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
+{ \
+    return jl_iintrinsic_2(a, b, #name, u##signbitbyte, jl_intrinsiclambda_cmp, name##_list, 0); \
+}
+#define bool_iintrinsic_fast(LLVMOP, OP, name, u) \
+bool_intrinsic_ctype(OP, name, 8, u##int##8_t) \
+bool_intrinsic_ctype(OP, name, 16, u##int##16_t) \
+bool_intrinsic_ctype(OP, name, 32, u##int##32_t) \
+bool_intrinsic_ctype(OP, name, 64, u##int##64_t) \
+static select_intrinsic_cmp_t name##_list = { \
+    LLVMOP, \
+    jl_##name##8, \
+    jl_##name##16, \
+    jl_##name##32, \
+    jl_##name##64, \
+}; \
+cmp_iintrinsic(name, u)
+
+typedef int (*intrinsic_checked_t)(unsigned, void*, void*, void*);
+SELECTOR_FUNC(intrinsic_checked)
+#define checked_iintrinsic(name, u) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
+{ \
+    return jl_iintrinsic_2(a, b, #name, u##signbitbyte, jl_intrinsiclambda_checked, name##_list, 0); \
+}
+#define checked_iintrinsic_fast(LLVMOP, CHECK_OP, OP, name, u) \
+checked_intrinsic_ctype(CHECK_OP, OP, name, 8, u##int##8_t) \
+checked_intrinsic_ctype(CHECK_OP, OP, name, 16, u##int##16_t) \
+checked_intrinsic_ctype(CHECK_OP, OP, name, 32, u##int##32_t) \
+checked_intrinsic_ctype(CHECK_OP, OP, name, 64, u##int##64_t) \
+static select_intrinsic_checked_t name##_list = { \
+    LLVMOP, \
+    jl_##name##8, \
+    jl_##name##16, \
+    jl_##name##32, \
+    jl_##name##64, \
+}; \
+checked_iintrinsic(name, u)
+#define checked_iintrinsic_slow(LLVMOP, name, u) \
+static select_intrinsic_checked_t name##_list = { \
+    LLVMOP \
+}; \
+checked_iintrinsic(name, u)
+
+static inline
+jl_value_t *jl_iintrinsic_2(jl_value_t *a, jl_value_t *b, const char *name,
+                            char (*getsign)(void*, unsigned),
+                            jl_value_t *(*lambda2)(jl_value_t*, void*, void*, unsigned, unsigned, void*),
+                            void *list, int cvtb)
+{
+    jl_value_t *ty = jl_typeof(a);
+    jl_value_t *tyb = jl_typeof(b);
+    if (tyb != ty) {
+        if (!cvtb)
+            jl_errorf("%s: types of a and b must match", name);
+        if (!jl_is_bitstype(tyb))
+            jl_errorf("%s: b is not a bitstypes", name);
+    }
+    if (!jl_is_bitstype(ty))
+        jl_errorf("%s: a is not a bitstypes", name);
+    void *pa = jl_data_ptr(a), *pb = jl_data_ptr(b);
+    unsigned sz = jl_datatype_size(ty);
+    unsigned sz2 = next_power_of_two(sz);
+    unsigned szb = jl_datatype_size(tyb);
+    if (sz2 > sz) {
+        /* round type up to the appropriate c-type and set/clear the unused bits */
+        void *pa2 = alloca(sz2);
+        memcpy(pa2, pa, sz);
+        memset((char*)pa2 + sz, getsign(pa, sz), sz2 - sz);
+        pa = pa2;
+    }
+    if (sz2 > szb) {
+        /* round type up to the appropriate c-type and set/clear/truncate the unused bits */
+        void *pb2 = alloca(sz2);
+        memcpy(pb2, pb, szb);
+        memset((char*)pb2 + szb, getsign(pb, sz), sz2 - szb);
+        pb = pb2;
+    }
+    jl_value_t *newv = lambda2(ty, pa, pb, sz, sz2, list);
+    return newv;
+}
+
+static inline jl_value_t *jl_intrinsiclambda_2(jl_value_t *ty, void *pa, void *pb, unsigned sz, unsigned sz2, void *voidlist)
+{
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    intrinsic_2_t op = select_intrinsic_2(sz2, (intrinsic_2_t*)voidlist);
+    op(sz * host_char_bit, pa, pb, jl_data_ptr(newv));
+    if (ty == (jl_value_t*)jl_bool_type)
+        return *(uint8_t*)jl_data_ptr(newv) & 1 ? jl_true : jl_false;
+    return newv;
+}
+
+static inline jl_value_t *jl_intrinsiclambda_cmp(jl_value_t *ty, void *pa, void *pb, unsigned sz, unsigned sz2, void *voidlist)
+{
+    intrinsic_cmp_t op = select_intrinsic_cmp(sz2, (intrinsic_cmp_t*)voidlist);
+    int cmp = op(sz * host_char_bit, pa, pb);
+    return cmp ? jl_true : jl_false;
+}
+
+static inline jl_value_t *jl_intrinsiclambda_checked(jl_value_t *ty, void *pa, void *pb, unsigned sz, unsigned sz2, void *voidlist)
+{
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    intrinsic_checked_t op = select_intrinsic_checked(sz2, (intrinsic_checked_t*)voidlist);
+    int ovflw = op(sz * host_char_bit, pa, pb, jl_data_ptr(newv));
+    if (ovflw)
+        jl_throw(jl_overflow_exception);
+    if (ty == (jl_value_t*)jl_bool_type)
+        return *(uint8_t*)jl_data_ptr(newv) & 1 ? jl_true : jl_false;
+    return newv;
+}
+
+// floating point
+
+#define bi_fintrinsic(OP, name) \
+    bi_intrinsic_ctype(OP, name, 32, float) \
+    bi_intrinsic_ctype(OP, name, 64, double) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
+{ \
+    jl_value_t *ty = jl_typeof(a); \
+    if (jl_typeof(b) != ty) \
+        jl_error(#name ": types of a and b must match"); \
+    if (!jl_is_bitstype(ty)) \
+        jl_error(#name ": values are not bitstypes"); \
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty); \
+    void *pa = jl_data_ptr(a), *pb = jl_data_ptr(b), *pr = jl_data_ptr(newv); \
+    int sz = jl_datatype_size(ty); \
+    switch (sz) { \
+    /* choose the right size c-type operation */ \
+    case 4: \
+        jl_##name##32(32, pa, pb, pr); \
+        break; \
+    case 8: \
+        jl_##name##64(64, pa, pb, pr); \
+        break; \
+    default: \
+        jl_error(#name ": runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64"); \
+    } \
+    return newv; \
+}
+
+#define bool_fintrinsic(OP, name) \
+    bool_intrinsic_ctype(OP, name, 32, float) \
+    bool_intrinsic_ctype(OP, name, 64, double) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b) \
+{ \
+    jl_value_t *ty = jl_typeof(a); \
+    if (jl_typeof(b) != ty) \
+        jl_error(#name ": types of a and b must match"); \
+    if (!jl_is_bitstype(ty)) \
+        jl_error(#name ": values are not bitstypes"); \
+    void *pa = jl_data_ptr(a), *pb = jl_data_ptr(b); \
+    int sz = jl_datatype_size(ty); \
+    int cmp; \
+    switch (sz) { \
+    /* choose the right size c-type operation */ \
+    case 4: \
+        cmp = jl_##name##32(32, pa, pb); \
+        break; \
+    case 8: \
+        cmp = jl_##name##64(64, pa, pb); \
+        break; \
+    default: \
+        jl_error(#name ": runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64"); \
+    } \
+    return cmp ? jl_true : jl_false; \
+}
+
+#define ter_fintrinsic(OP, name) \
+    ter_intrinsic_ctype(OP, name, 32, float) \
+    ter_intrinsic_ctype(OP, name, 64, double) \
+JL_DLLEXPORT jl_value_t *jl_##name(jl_value_t *a, jl_value_t *b, jl_value_t *c) \
+{ \
+    jl_value_t *ty = jl_typeof(a); \
+    if (jl_typeof(b) != ty || jl_typeof(c) != ty) \
+        jl_error(#name ": types of a, b, and c must match"); \
+    if (!jl_is_bitstype(ty)) \
+        jl_error(#name ": values are not bitstypes"); \
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty); \
+    void *pa = jl_data_ptr(a), *pb = jl_data_ptr(b), *pc = jl_data_ptr(c), *pr = jl_data_ptr(newv); \
+    int sz = jl_datatype_size(ty); \
+    switch (sz) { \
+    /* choose the right size c-type operation */ \
+    case 4: \
+        jl_##name##32(32, pa, pb, pc, pr); \
+        break; \
+    case 8: \
+        jl_##name##64(64, pa, pb, pc, pr); \
+        break; \
+    default: \
+        jl_error(#name ": runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64"); \
+    } \
+    return newv; \
+}
+
+// arithmetic
+#define neg(a) -a
+#define neg_float(pr, a) *pr = -a
+un_iintrinsic_fast(LLVMNeg, neg, neg_int, u)
+#define add(a,b) a + b
+bi_iintrinsic_fast(LLVMAdd, add, add_int, u)
+#define sub(a,b) a - b
+bi_iintrinsic_fast(LLVMSub, sub, sub_int, u)
+#define mul(a,b) a * b
+bi_iintrinsic_fast(LLVMMul, mul, mul_int, u)
+#define div(a,b) a / b
+bi_iintrinsic_fast(LLVMSDiv, div, sdiv_int,  )
+bi_iintrinsic_fast(LLVMUDiv, div, udiv_int, u)
+#define rem(a,b) a % b
+bi_iintrinsic_fast(LLVMSRem, rem, srem_int,  )
+bi_iintrinsic_fast(LLVMURem, rem, urem_int, u)
+#define smod(a,b) ((a < 0) == (b < 0)) ? a % b : (b + (a % b)) % b
+bi_iintrinsic_fast(jl_LLVMSMod, smod, smod_int,  )
+#define frem(a, b) \
+    fp_select2(a, b, fmod)
+
+un_fintrinsic(neg_float,neg_float)
+bi_fintrinsic(add,add_float)
+bi_fintrinsic(sub,sub_float)
+bi_fintrinsic(mul,mul_float)
+bi_fintrinsic(div,div_float)
+bi_fintrinsic(frem,rem_float)
+
+// ternary operators //
+#define fma(a, b, c) \
+    sizeof(a) == sizeof(float) ? fmaf(a, b, c) : fma(a, b, c)
+#define muladd(a, b, c) a * b + c
+ter_fintrinsic(fma,fma_float)
+ter_fintrinsic(muladd,muladd_float)
+
+// same-type comparisons
+#define eq(a,b) a == b
+bool_iintrinsic_fast(LLVMICmpEQ, eq, eq_int, u)
+#define ne(a,b) a != b
+bool_iintrinsic_fast(LLVMICmpNE, ne, ne_int, u)
+#define lt(a,b) a < b
+bool_iintrinsic_fast(LLVMICmpSLT, lt, slt_int,  )
+bool_iintrinsic_fast(LLVMICmpULT, lt, ult_int, u)
+#define le(a,b) a <= b
+bool_iintrinsic_fast(LLVMICmpSLE, le, sle_int,  )
+bool_iintrinsic_fast(LLVMICmpULE, le, ule_int, u)
+
+typedef union {
+    float f;
+    int32_t d;
+    uint32_t ud;
+} bits32;
+typedef union {
+    double f;
+    int64_t d;
+    uint64_t ud;
+} bits64;
+
+#define fpiseq_n(c_type, nbits) \
+static inline int fpiseq##nbits(c_type a, c_type b) { \
+    bits##nbits ua, ub; \
+    ua.f = a; \
+    ub.f = b; \
+    return (isnan(a) && isnan(b)) || ua.d == ub.d; \
+}
+fpiseq_n(float, 32)
+fpiseq_n(double, 64)
+#define fpiseq(a,b) \
+    sizeof(a) == sizeof(float) ? fpiseq32(a, b) : fpiseq64(a, b)
+
+#define fpislt_n(c_type, nbits) \
+static inline int fpislt##nbits(c_type a, c_type b) { \
+    bits##nbits ua, ub; \
+    ua.f = a; \
+    ub.f = b; \
+    if (!isnan(a) && isnan(b)) \
+        return 1; \
+    if (isnan(a) || isnan(b)) \
+        return 0; \
+    if (ua.d >= 0 && ua.d < ub.d) \
+        return 1; \
+    if (ua.d < 0 && ua.ud > ub.ud) \
+        return 1; \
+    return 0; \
+}
+fpislt_n(float, 32)
+fpislt_n(double, 64)
+#define fpislt(a, b) \
+    sizeof(a) == sizeof(float) ? fpislt32(a, b) : fpislt64(a, b)
+
+bool_fintrinsic(eq,eq_float)
+bool_fintrinsic(ne,ne_float)
+bool_fintrinsic(lt,lt_float)
+bool_fintrinsic(le,le_float)
+bool_fintrinsic(fpiseq,fpiseq)
+bool_fintrinsic(fpislt,fpislt)
+
+// bitwise operators
+#define and_op(a,b) a & b
+bi_iintrinsic_fast(LLVMAnd, and_op, and_int, u)
+#define or_op(a,b) a | b
+bi_iintrinsic_fast(LLVMOr, or_op, or_int, u)
+#define xor_op(a,b) a ^ b
+bi_iintrinsic_fast(LLVMXor, xor_op, xor_int, u)
+#define shl_op(a,b) b >= 8 * sizeof(a) ? 0 : a << b
+bi_iintrinsic_cnvtb_fast(LLVMShl, shl_op, shl_int, u, 1)
+#define lshr_op(a,b) (b >= 8 * sizeof(a)) ? 0 : a >> b
+bi_iintrinsic_cnvtb_fast(LLVMLShr, lshr_op, lshr_int, u, 1)
+#define ashr_op(a,b) \
+        /* if ((signed)a > 0) [in two's complement] ? ... : ...) */ \
+        (a >> (host_char_bit * sizeof(a) - 1)) ? ~(b >= 8 * sizeof(a) ? 0 : (~a) >> b) : (b >= 8 * sizeof(a) ? 0 : a >> b)
+bi_iintrinsic_cnvtb_fast(LLVMAShr, ashr_op, ashr_int, u, 1)
+//#define bswap_op(a) __builtin_bswap(a)
+//un_iintrinsic_fast(LLVMByteSwap, bswap_op, bswap_int, u)
+un_iintrinsic_slow(LLVMByteSwap, bswap_int, u)
+//#define ctpop_op(a) __builtin_ctpop(a)
+//uu_iintrinsic_fast(LLVMCountPopulation, ctpop_op, ctpop_int, u)
+uu_iintrinsic_slow(LLVMCountPopulation, ctpop_int, u)
+//#define ctlz_op(a) __builtin_ctlz(a)
+//uu_iintrinsic_fast(LLVMCountLeadingZeros, ctlz_op, ctlz_int, u)
+uu_iintrinsic_slow(LLVMCountLeadingZeros, ctlz_int, u)
+//#define cttz_op(a) __builtin_cttz(a)
+//uu_iintrinsic_fast(LLVMCountTrailingZeros, cttz_op, cttz_int, u)
+uu_iintrinsic_slow(LLVMCountTrailingZeros, cttz_int, u)
+#define not_op(a) ~a
+un_iintrinsic_fast(LLVMFlipAllBits, not_op, not_int, u)
+
+// conversions
+cvt_iintrinsic(LLVMTrunc, trunc_int)
+cvt_iintrinsic(LLVMSExt, sext_int)
+cvt_iintrinsic(LLVMZExt, zext_int)
+cvt_iintrinsic(LLVMSItoFP, sitofp)
+cvt_iintrinsic(LLVMUItoFP, uitofp)
+cvt_iintrinsic(LLVMFPtoSI, fptosi)
+cvt_iintrinsic(LLVMFPtoUI, fptoui)
+
+#define fpcvt(pr, a) \
+        if (osize == 32) \
+            *(float*)pr = a; \
+        else if (osize == 64) \
+            *(double*)pr = a; \
+        else \
+            jl_error("fptrunc/fpext: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+un_fintrinsic_withtype(fpcvt,fptrunc)
+un_fintrinsic_withtype(fpcvt,fpext)
+
+JL_DLLEXPORT jl_value_t *jl_fptoui_auto(jl_value_t *a)
+{
+    jl_datatype_t *ty;
+    switch (jl_datatype_size(jl_typeof(a))) {
+        case 4:
+            ty = jl_uint32_type;
+            break;
+        case 8:
+            ty = jl_uint64_type;
+            break;
+        default:
+            jl_error("fptoui: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+    }
+    return jl_fptoui((jl_value_t*)ty, a);
+}
+JL_DLLEXPORT jl_value_t *jl_fptosi_auto(jl_value_t *a)
+{
+    jl_datatype_t *ty;
+    switch (jl_datatype_size(jl_typeof(a))) {
+        case 4:
+            ty = jl_int32_type;
+            break;
+        case 8:
+            ty = jl_int64_type;
+            break;
+        default:
+            jl_error("fptoui: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+    }
+    return jl_fptosi((jl_value_t*)ty, a);
+}
+
+// checked conversion
+static inline int all_eq(char *p, char n, char v)
+{
+    // computes p[0:n] == v
+    while (n--)
+        if (*p++ != v)
+            return 0;
+    return 1;
+}
+static unsigned check_trunc_sint(unsigned isize, unsigned osize, void *pa)
+{
+    return !all_eq((char*)pa + osize, isize - osize, signbitbyte(pa, isize)); // TODO: assumes little-endian
+}
+cvt_iintrinsic_checked(LLVMTrunc, check_trunc_sint, checked_trunc_sint)
+static unsigned check_trunc_uint(unsigned isize, unsigned osize, void *pa)
+{
+    return !all_eq((char*)pa + osize, isize - osize, 0); // TODO: assumes little-endian
+}
+cvt_iintrinsic_checked(LLVMTrunc, check_trunc_uint, checked_trunc_uint)
+
+#define checked_fptosi(pr, a) \
+        if (!LLVMFPtoSI_exact(sizeof(a) * host_char_bit, pa, osize, pr)) \
+            jl_throw(jl_inexact_exception);
+un_fintrinsic_withtype(checked_fptosi, checked_fptosi)
+#define checked_fptoui(pr, a) \
+        if (!LLVMFPtoUI_exact(sizeof(a) * host_char_bit, pa, osize, pr)) \
+            jl_throw(jl_inexact_exception);
+un_fintrinsic_withtype(checked_fptoui, checked_fptoui)
+
+JL_DLLEXPORT jl_value_t *jl_check_top_bit(jl_value_t *a)
+{
+    jl_value_t *ty = jl_typeof(a);
+    if (!jl_is_bitstype(ty))
+        jl_error("check_top_bit: value is not a bitstype");
+    if (signbitbyte(jl_data_ptr(a), jl_datatype_size(ty)))
+        jl_throw(jl_inexact_exception);
+    return a;
+}
+
+// checked arithmetic
+#define check_sadd_int(a,b) \
+        /* this test is a reduction of (b > 0) ? (a + b > typemax(a)) : (a + b < typemin(a)) ==> overflow \
+         * where (a - a) == (typeof(a))0 */ \
+        (b > 0) ? (a > ~((a - a + 1) << (8 * sizeof(a) - 1)) - b) : (a < ((a - a + 1) << (8 * sizeof(a) - 1)) - b)
+checked_iintrinsic_fast(LLVMAdd_sov, check_sadd_int, add, checked_sadd_int,  )
+#define check_uadd_int(a,b) \
+        /* this test checks for (a + b) > typemax(a) ==> overflow */ \
+        a >= -b
+checked_iintrinsic_fast(LLVMAdd_uov, check_uadd_int, add, checked_uadd_int, u)
+#define check_ssub_int(a,b) check_sadd_int(a,-b)
+checked_iintrinsic_fast(LLVMSub_sov, check_ssub_int, sub, checked_ssub_int,  )
+#define check_usub_int(a,b) \
+        /* this test checks for (a - b) < 0 ==> overflow */ \
+        a < b
+checked_iintrinsic_fast(LLVMSub_uov, check_usub_int, sub, checked_usub_int, u)
+checked_iintrinsic_slow(LLVMMul_sov, checked_smul_int,  )
+checked_iintrinsic_slow(LLVMMul_uov, checked_umul_int, u)
+checked_iintrinsic_slow(LLVMDiv_sov, checked_sdiv_int,  )
+checked_iintrinsic_slow(LLVMDiv_uov, checked_udiv_int, u)
+checked_iintrinsic_slow(LLVMRem_sov, checked_srem_int,  )
+checked_iintrinsic_slow(LLVMRem_uov, checked_urem_int, u)
+
+JL_DLLEXPORT jl_value_t *jl_nan_dom_err(jl_value_t *a, jl_value_t *b)
+{
+    jl_value_t *ty = jl_typeof(a);
+    if (jl_typeof(b) != ty)
+        jl_error("nan_dom_err: types of a and b must match");
+    if (!jl_is_bitstype(ty))
+        jl_error("nan_dom_err: values are not bitstypes");
+    switch (jl_datatype_size(ty)) {
+        case 4:
+            if (isnan(*(float*)a) && !isnan(*(float*)b))
+                jl_throw(jl_domain_exception);
+            break;
+        case 8:
+            if (isnan(*(double*)a) && !isnan(*(double*)b))
+                jl_throw(jl_domain_exception);
+            break;
+        default:
+            jl_error("nan_dom_err: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+    }
+    return a;
+}
+
+// functions
+#define flipsign(a, b) \
+        (b >= 0) ? a : -a
+bi_iintrinsic_fast(jl_LLVMFlipSign, flipsign, flipsign_int,  )
+#define abs_float(pr, a) *pr = fp_select(a, fabs)
+#define ceil_float(pr, a) *pr = fp_select(a, ceil)
+#define floor_float(pr, a) *pr = fp_select(a, floor)
+#define trunc_float(pr, a) *pr = fp_select(a, trunc)
+#define rint_float(pr, a) *pr = fp_select(a, rint)
+#define sqrt_float(pr, a) \
+        if (a < 0) \
+            jl_throw(jl_domain_exception); \
+        *pr = fp_select(a, sqrt)
+#define copysign_float(a, b) \
+        fp_select2(a, b, copysign)
+
+un_fintrinsic(abs_float,abs_float)
+bi_fintrinsic(copysign_float,copysign_float)
+un_fintrinsic(ceil_float,ceil_llvm)
+un_fintrinsic(floor_float,floor_llvm)
+un_fintrinsic(trunc_float,trunc_llvm)
+un_fintrinsic(rint_float,rint_llvm)
+un_fintrinsic(sqrt_float,sqrt_llvm)
+
+JL_DLLEXPORT jl_value_t *jl_powi_llvm(jl_value_t *a, jl_value_t *b)
+{
+    jl_value_t *ty = jl_typeof(a);
+    if (!jl_is_bitstype(ty))
+        jl_error("powi_llvm: a is not a bitstype");
+    if (!jl_is_bitstype(jl_typeof(b)) || jl_datatype_size(jl_typeof(b)) != 4)
+        jl_error("powi_llvm: b is not a 32-bit bitstype");
+    jl_value_t *newv = newstruct((jl_datatype_t*)ty);
+    void *pa = jl_data_ptr(a), *pr = jl_data_ptr(newv);
+    int sz = jl_datatype_size(ty);
+    switch (sz) {
+    /* choose the right size c-type operation */
+    case 4:
+        *(float*)pr = powf(*(float*)pa, (float)jl_unbox_int32(b));
+        break;
+    case 8:
+        *(double*)pr = pow(*(double*)pa, (double)jl_unbox_int32(b));
+        break;
+    default:
+        jl_error("powi_llvm: runtime floating point intrinsics are not implemented for bit sizes other than 32 and 64");
+    }
+    return newv;
+}
+
+JL_DLLEXPORT jl_value_t *jl_select_value(jl_value_t *isfalse, jl_value_t *a, jl_value_t *b)
+{
+    JL_TYPECHK(isfalse, bool, isfalse);
+    return (isfalse == jl_false ? b : a);
+}
+
+JL_DLLEXPORT jl_value_t *jl_arraylen(jl_value_t *a)
+{
+    return jl_box_long(jl_array_len((jl_array_t*)a));
+}
diff --git a/src/signal-handling.c b/src/signal-handling.c
index 1319d047733a0..715ae7cfbbadc 100644
--- a/src/signal-handling.c
+++ b/src/signal-handling.c
@@ -10,100 +10,98 @@
 extern "C" {
 #endif
 
+#include <threading.h>
+
 // Profiler control variables //
-static volatile ptrint_t *bt_data_prof = NULL;
+static volatile intptr_t *bt_data_prof = NULL;
 static volatile size_t bt_size_max = 0;
 static volatile size_t bt_size_cur = 0;
-static volatile u_int64_t nsecprof = 0;
+static volatile uint64_t nsecprof = 0;
 static volatile int running = 0;
-static const    u_int64_t GIGA = 1000000000ULL;
+static const    uint64_t GIGA = 1000000000ULL;
 // Timers to take samples at intervals
-DLLEXPORT void jl_profile_stop_timer(void);
-DLLEXPORT int jl_profile_start_timer(void);
-
+JL_DLLEXPORT void jl_profile_stop_timer(void);
+JL_DLLEXPORT int jl_profile_start_timer(void);
 
 volatile sig_atomic_t jl_signal_pending = 0;
 volatile sig_atomic_t jl_defer_signal = 0;
 
-
 int exit_on_sigint = 0;
-DLLEXPORT void jl_exit_on_sigint(int on) {exit_on_sigint = on;}
+JL_DLLEXPORT void jl_exit_on_sigint(int on) {exit_on_sigint = on;}
 
 // what to do on SIGINT
-DLLEXPORT void jl_sigint_action(void)
+JL_DLLEXPORT void jl_sigint_action(void)
 {
     if (exit_on_sigint) jl_exit(130); // 128+SIGINT
     jl_throw(jl_interrupt_exception);
 }
 
 #if defined(_WIN32)
-#define sig_stack_size 131072 // 128k reserved for SEGV handling
-#include <signals-win.c>
-#else
-#include <signal.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <pthread.h>
-#if defined(JL_USE_INTEL_JITEVENTS)
-unsigned sig_stack_size = SIGSTKSZ;
-#else
-#define sig_stack_size SIGSTKSZ
-#endif
-static void *signal_stack;
-static int is_addr_on_stack(void *addr);
-#ifdef __APPLE__
-#include "signals-apple.c"
-#elif defined(__FreeBSD__)
-#include "signals-bsd.c"
+#include "signals-win.c"
 #else
-#include "signals-linux.c"
-#endif
 #include "signals-unix.c"
 #endif
 
+// what to do on a critical error
+void jl_critical_error(int sig, bt_context_t context, intptr_t *bt_data, size_t *bt_size)
+{
+    // This function is not allowed to reference any TLS variables.
+    // We need to explicitly pass in the TLS buffer pointer when
+    // we make `jl_filename` and `jl_lineno` thread local.
+    size_t n = *bt_size;
+    if (sig)
+        jl_safe_printf("\nsignal (%d): %s\n", sig, strsignal(sig));
+    jl_safe_printf("while loading %s, in expression starting on line %d\n", jl_filename, jl_lineno);
+    if (context)
+        *bt_size = n = rec_backtrace_ctx(bt_data, JL_MAX_BT_SIZE, context);
+    for(size_t i=0; i < n; i++)
+        jl_gdblookup(bt_data[i]);
+    gc_debug_print_status();
+    gc_debug_critical_error();
+}
+
 ///////////////////////
 // Utility functions //
 ///////////////////////
-DLLEXPORT int jl_profile_init(size_t maxsize, u_int64_t delay_nsec)
+JL_DLLEXPORT int jl_profile_init(size_t maxsize, uint64_t delay_nsec)
 {
     bt_size_max = maxsize;
     nsecprof = delay_nsec;
     if (bt_data_prof != NULL)
         free((void*)bt_data_prof);
-    bt_data_prof = (ptrint_t*) calloc(maxsize, sizeof(ptrint_t));
+    bt_data_prof = (intptr_t*) calloc(maxsize, sizeof(intptr_t));
     if (bt_data_prof == NULL && maxsize > 0)
         return -1;
     bt_size_cur = 0;
     return 0;
 }
 
-DLLEXPORT u_int8_t *jl_profile_get_data(void)
+JL_DLLEXPORT uint8_t *jl_profile_get_data(void)
 {
-    return (u_int8_t*) bt_data_prof;
+    return (uint8_t*) bt_data_prof;
 }
 
-DLLEXPORT size_t jl_profile_len_data(void)
+JL_DLLEXPORT size_t jl_profile_len_data(void)
 {
     return bt_size_cur;
 }
 
-DLLEXPORT size_t jl_profile_maxlen_data(void)
+JL_DLLEXPORT size_t jl_profile_maxlen_data(void)
 {
     return bt_size_max;
 }
 
-DLLEXPORT u_int64_t jl_profile_delay_nsec(void)
+JL_DLLEXPORT uint64_t jl_profile_delay_nsec(void)
 {
     return nsecprof;
 }
 
-DLLEXPORT void jl_profile_clear_data(void)
+JL_DLLEXPORT void jl_profile_clear_data(void)
 {
     bt_size_cur = 0;
 }
 
-DLLEXPORT int jl_profile_is_running(void)
+JL_DLLEXPORT int jl_profile_is_running(void)
 {
     return running;
 }
diff --git a/src/signals-apple.c b/src/signals-apple.c
deleted file mode 100644
index ab3709bb86101..0000000000000
--- a/src/signals-apple.c
+++ /dev/null
@@ -1,347 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-#include <mach/mach_traps.h>
-#include <mach/task.h>
-#include <mach/mig_errors.h>
-#include <AvailabilityMacros.h>
-
-#ifdef MAC_OS_X_VERSION_10_9
-#include <sys/_types/_ucontext64.h>
-#else
-#define __need_ucontext64_t
-#include <machine/_structs.h>
-#endif
-
-static mach_port_t segv_port = 0;
-
-extern boolean_t exc_server(mach_msg_header_t *, mach_msg_header_t *);
-
-void *mach_segv_listener(void *arg)
-{
-    (void)arg;
-    while (1) {
-        int ret = mach_msg_server(exc_server,2048,segv_port,MACH_MSG_TIMEOUT_NONE);
-        jl_safe_printf("mach_msg_server: %s\n", mach_error_string(ret));
-        jl_exit(128+SIGSEGV);
-    }
-}
-
-#ifdef SEGV_EXCEPTION
-void darwin_segv_handler(unw_context_t *uc)
-{
-    bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, uc);
-    jl_exception_in_transit = jl_segv_exception;
-    jl_rethrow();
-}
-#endif
-
-void darwin_stack_overflow_handler(unw_context_t *uc)
-{
-    bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, uc);
-    jl_exception_in_transit = jl_stackovf_exception;
-    jl_rethrow();
-}
-
-void darwin_accerr_handler(unw_context_t *uc)
-{
-    bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, uc);
-    jl_exception_in_transit = jl_readonlymemory_exception;
-    jl_rethrow();
-}
-
-#define HANDLE_MACH_ERROR(msg, retval) \
-    if (retval!=KERN_SUCCESS) { mach_error(msg ":", (retval)); jl_exit(1); }
-
-#ifdef LIBOSXUNWIND
-volatile mach_port_t mach_profiler_thread = 0;
-static kern_return_t profiler_segv_handler
-                (mach_port_t                          exception_port,
-                 mach_port_t                                  thread,
-                 mach_port_t                                    task,
-                 exception_type_t                          exception,
-                 exception_data_t                               code,
-                 mach_msg_type_number_t                   code_count);
-#endif
-
-enum x86_trap_flags {
-    USER_MODE = 0x4,
-    WRITE_FAULT = 0x2,
-    PAGE_PRESENT = 0x1
-};
-
-//exc_server uses dlsym to find symbol
-DLLEXPORT
-kern_return_t catch_exception_raise(mach_port_t            exception_port,
-                                    mach_port_t            thread,
-                                    mach_port_t            task,
-                                    exception_type_t       exception,
-                                    exception_data_t       code,
-                                    mach_msg_type_number_t code_count)
-{
-    unsigned int count = MACHINE_THREAD_STATE_COUNT;
-    unsigned int exc_count = X86_EXCEPTION_STATE64_COUNT;
-    x86_thread_state64_t state, old_state;
-    x86_exception_state64_t exc_state;
-    kern_return_t ret;
-    //memset(&state,0,sizeof(x86_thread_state64_t));
-    //memset(&exc_state,0,sizeof(x86_exception_state64_t));
-#ifdef LIBOSXUNWIND
-    if (thread == mach_profiler_thread) {
-        return profiler_segv_handler(exception_port,thread,task,exception,code,code_count);
-    }
-#endif
-    ret = thread_get_state(thread,x86_EXCEPTION_STATE64,(thread_state_t)&exc_state,&exc_count);
-    HANDLE_MACH_ERROR("thread_get_state(1)",ret);
-    uint64_t fault_addr = exc_state.__faultvaddr;
-#ifdef SEGV_EXCEPTION
-    if (1) {
-#else
-    if (msync((void*)(fault_addr & ~(jl_page_size - 1)), 1, MS_ASYNC) == 0) { // check if this was a valid address
-#endif
-        ret = thread_get_state(thread,x86_THREAD_STATE64,(thread_state_t)&state,&count);
-        HANDLE_MACH_ERROR("thread_get_state(2)",ret);
-        old_state = state;
-        // memset(&state,0,sizeof(x86_thread_state64_t));
-        // Setup libunwind information
-        state.__rsp = (uint64_t)signal_stack + sig_stack_size;
-        state.__rsp -= sizeof(unw_context_t);
-        state.__rsp &= -16;
-        unw_context_t *uc = (unw_context_t*)state.__rsp;
-        state.__rsp -= 512;
-        // This is for alignment. In particular note that the sizeof(void*) is necessary
-        // since it would usually specify the return address (i.e., we are aligning the call
-        // frame to a 16 byte boundary as required by the abi, but the stack pointer
-        // to point to the byte beyond that. Not doing this leads to funny behavior on
-        // the first access to an external function will fail due to stack misalignment
-        state.__rsp &= -16;
-        state.__rsp -= sizeof(void*);
-        memset(uc,0,sizeof(unw_context_t));
-        memcpy(uc,&old_state,sizeof(x86_thread_state64_t));
-        state.__rdi = (uint64_t)uc;
-        if (is_addr_on_stack((void*)fault_addr)) {
-            state.__rip = (uint64_t)darwin_stack_overflow_handler;
-        }
-#ifdef SEGV_EXCEPTION
-        else if (msync((void*)(fault_addr & ~(jl_page_size - 1)), 1, MS_ASYNC) != 0) {
-            // no page mapped at this address
-            state.__rip = (uint64_t)darwin_segv_handler;
-        }
-#endif
-        else {
-            if (!(exc_state.__err & WRITE_FAULT))
-                return KERN_INVALID_ARGUMENT; // rethrow the SEGV since it wasn't an error with writing to read-only memory
-            state.__rip = (uint64_t)darwin_accerr_handler;
-        }
-
-        state.__rbp = state.__rsp;
-        ret = thread_set_state(thread,x86_THREAD_STATE64,(thread_state_t)&state,count);
-        HANDLE_MACH_ERROR("thread_set_state",ret);
-        return KERN_SUCCESS;
-    }
-    else {
-        ret = thread_get_state(thread,x86_THREAD_STATE64,(thread_state_t)&state,&count);
-        HANDLE_MACH_ERROR("thread_get_state(3)",ret);
-        jl_safe_printf("\nsignal (%d): %s\n", SIGSEGV, strsignal(SIGSEGV));
-        bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, (unw_context_t*)&state);
-        jlbacktrace();
-        return KERN_INVALID_ARGUMENT;
-    }
-}
-
-void attach_exception_port()
-{
-    kern_return_t ret;
-    // http://www.opensource.apple.com/source/xnu/xnu-2782.1.97/osfmk/man/thread_set_exception_ports.html
-    ret = thread_set_exception_ports(mach_thread_self(),EXC_MASK_BAD_ACCESS,segv_port,EXCEPTION_DEFAULT,MACHINE_THREAD_STATE);
-    HANDLE_MACH_ERROR("thread_set_exception_ports",ret);
-}
-
-#ifdef LIBOSXUNWIND
-//
-// OS X
-//
-#include <mach/mach_traps.h>
-#include <mach/task.h>
-#include <mach/mig_errors.h>
-#include <mach/clock.h>
-#include <mach/clock_types.h>
-#include <mach/clock_reply.h>
-#include <assert.h>
-
-#define HANDLE_MACH_ERROR(msg, retval) \
-    if (retval!=KERN_SUCCESS) { mach_error(msg ":", (retval)); jl_exit(1); }
-
-static pthread_t profiler_thread;
-static mach_port_t main_thread;
-clock_serv_t clk;
-static int profile_started = 0;
-static mach_port_t profile_port = 0;
-volatile static int forceDwarf = -2;
-static unw_context_t profiler_uc;
-mach_timespec_t timerprof;
-
-static kern_return_t profiler_segv_handler
-                (mach_port_t                          exception_port,
-                 mach_port_t                                  thread,
-                 mach_port_t                                    task,
-                 exception_type_t                          exception,
-                 exception_data_t                               code,
-                 mach_msg_type_number_t                   code_count)
-{
-    assert(thread == mach_profiler_thread);
-    x86_thread_state64_t state;
-
-    // Not currently unwinding. Raise regular segfault
-    if (forceDwarf == -2)
-        return KERN_INVALID_ARGUMENT;
-
-    if (forceDwarf == 0)
-        forceDwarf = 1;
-    else
-        forceDwarf = -1;
-
-    unsigned int count = MACHINE_THREAD_STATE_COUNT;
-
-    thread_get_state(thread,x86_THREAD_STATE64,(thread_state_t)&state,&count);
-
-    // don't change cs fs gs rflags
-    uint64_t cs = state.__cs;
-    uint64_t fs = state.__fs;
-    uint64_t gs = state.__gs;
-    uint64_t rflags = state.__rflags;
-
-    memcpy(&state,&profiler_uc,sizeof(x86_thread_state64_t));
-
-    state.__cs = cs;
-    state.__fs = fs;
-    state.__gs = gs;
-    state.__rflags = rflags;
-
-    kern_return_t ret = thread_set_state(thread,x86_THREAD_STATE64,(thread_state_t)&state,count);
-    HANDLE_MACH_ERROR("thread_set_state",ret);
-
-    return KERN_SUCCESS;
-}
-
-void *mach_profile_listener(void *arg)
-{
-    (void)arg;
-    int max_size = 512;
-    attach_exception_port();
-    mach_profiler_thread = mach_thread_self();
-    mig_reply_error_t *bufRequest = (mig_reply_error_t *) malloc(max_size);
-    while (1) {
-        kern_return_t ret = mach_msg(&bufRequest->Head, MACH_RCV_MSG,
-                                     0, max_size, profile_port,
-                                     MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
-        HANDLE_MACH_ERROR("mach_msg",ret);
-        if (bt_size_cur < bt_size_max) {
-            kern_return_t ret;
-            // Suspend the thread so we may safely sample it
-            ret = thread_suspend(main_thread);
-            HANDLE_MACH_ERROR("thread_suspend",ret);
-
-            // Do the actual sampling
-            unsigned int count = MACHINE_THREAD_STATE_COUNT;
-            x86_thread_state64_t state;
-
-            // Get the state of the suspended thread
-            ret = thread_get_state(main_thread,x86_THREAD_STATE64,(thread_state_t)&state,&count);
-            HANDLE_MACH_ERROR("thread_get_state",ret);
-
-            // Initialize the unwind context with the suspend thread's state
-            unw_context_t uc;
-            memset(&uc,0,sizeof(unw_context_t));
-            memcpy(&uc,&state,sizeof(x86_thread_state64_t));
-
-            /*
-             *  Unfortunately compact unwind info is incorrectly generated for quite a number of
-             *  libraries by quite a large number of compilers. We can fall back to DWARF unwind info
-             *  in some cases, but in quite a number of cases (especially libraries not compiled in debug
-             *  mode, only the compact unwind info may be available). Even more unfortunately, there is no
-             *  way to detect such bogus compact unwind info (other than noticing the resulting segfault).
-             *  What we do here is ugly, but necessary until the compact unwind info situation improves.
-             *  We try to use the compact unwind info and if that results in a segfault, we retry with DWARF info.
-             *  Note that in a small number of cases this may result in bogus stack traces, but at least the topmost
-             *  entry will always be correct, and the number of cases in which this is an issue is rather small.
-             *  Other than that, this implementation is not incorrect as the other thread is paused while we are profiling
-             *  and during stack unwinding we only ever read memory, but never write it.
-             */
-
-            forceDwarf = 0;
-            unw_getcontext(&profiler_uc);
-
-            if (forceDwarf == 0) {
-                // Save the backtrace
-                bt_size_cur += rec_backtrace_ctx((ptrint_t*)bt_data_prof+bt_size_cur, bt_size_max-bt_size_cur-1, &uc);
-            }
-            else if (forceDwarf == 1) {
-                bt_size_cur += rec_backtrace_ctx_dwarf((ptrint_t*)bt_data_prof+bt_size_cur, bt_size_max-bt_size_cur-1, &uc);
-            }
-            else if (forceDwarf == -1) {
-                jl_safe_printf("WARNING: profiler attempt to access an invalid memory location\n");
-            }
-
-            forceDwarf = -2;
-
-            // Mark the end of this block with 0
-            bt_data_prof[bt_size_cur] = 0;
-            bt_size_cur++;
-
-            // We're done! Resume the thread.
-            ret = thread_resume(main_thread);
-            HANDLE_MACH_ERROR("thread_resume",ret)
-
-            if (running) {
-                // Reset the alarm
-                ret = clock_alarm(clk, TIME_RELATIVE, timerprof, profile_port);
-                HANDLE_MACH_ERROR("clock_alarm",ret)
-            }
-        }
-    }
-}
-
-DLLEXPORT int jl_profile_start_timer(void)
-{
-    kern_return_t ret;
-    if (!profile_started) {
-        mach_port_t self = mach_task_self();
-        main_thread = mach_thread_self();
-
-        ret = host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, (clock_serv_t *)&clk);
-        HANDLE_MACH_ERROR("host_get_clock_service", ret);
-
-        ret = mach_port_allocate(self,MACH_PORT_RIGHT_RECEIVE,&profile_port);
-        HANDLE_MACH_ERROR("mach_port_allocate",ret);
-
-        // Alright, create a thread to serve as the listener for exceptions
-        pthread_attr_t attr;
-        if (pthread_attr_init(&attr) != 0) {
-            jl_error("pthread_attr_init failed");
-        }
-        pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
-        if (pthread_create(&profiler_thread,&attr,mach_profile_listener,NULL) != 0) {
-            jl_error("pthread_create failed");
-        }
-        pthread_attr_destroy(&attr);
-
-        profile_started = 1;
-    }
-
-    timerprof.tv_sec = nsecprof/GIGA;
-    timerprof.tv_nsec = nsecprof%GIGA;
-
-    running = 1;
-    ret = clock_alarm(clk, TIME_RELATIVE, timerprof, profile_port);
-    HANDLE_MACH_ERROR("clock_alarm",ret);
-
-    return 0;
-}
-
-DLLEXPORT void jl_profile_stop_timer(void)
-{
-    running = 0;
-}
-#else
-#include "signals-bsd.c"
-#endif
diff --git a/src/signals-bsd.c b/src/signals-bsd.c
deleted file mode 100644
index d9247490b0a03..0000000000000
--- a/src/signals-bsd.c
+++ /dev/null
@@ -1,63 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-// BSD / Apple-System
-//
-#include <string.h>
-#include <sys/time.h>
-struct itimerval timerprof;
-
-// The handler function, called whenever the profiling timer elapses
-static void profile_bt(int sig)
-{
-    if (running && bt_size_cur < bt_size_max) {
-        // Get backtrace data
-        bt_size_cur += rec_backtrace((ptrint_t*)bt_data_prof+bt_size_cur, bt_size_max-bt_size_cur-1);
-        // Mark the end of this block with 0
-        bt_data_prof[bt_size_cur] = 0;
-        bt_size_cur++;
-    }
-    if (bt_size_cur >= bt_size_max) {
-        // Buffer full: Delete the  timer
-        jl_profile_stop_timer();
-    }
-}
-
-DLLEXPORT int jl_profile_start_timer(void)
-{
-    struct sigaction sa;
-    sigset_t ss;
-
-    // Make sure SIGPROF is unblocked
-    sigemptyset(&ss);
-    sigaddset(&ss, SIGPROF);
-    if (sigprocmask(SIG_UNBLOCK, &ss, NULL) == -1)
-        return -4;
-
-    // Establish the signal handler
-    memset(&sa, 0, sizeof(struct sigaction));
-    sa.sa_handler = profile_bt;
-    sigemptyset(&sa.sa_mask);
-    if (sigaction(SIGPROF, &sa, NULL) == -1)
-        return -1;
-
-    timerprof.it_interval.tv_sec = nsecprof/GIGA;
-    timerprof.it_interval.tv_usec = (nsecprof%GIGA)/1000;
-    timerprof.it_value.tv_sec = nsecprof/GIGA;
-    timerprof.it_value.tv_usec = (nsecprof%GIGA)/1000;
-    if (setitimer(ITIMER_PROF, &timerprof, 0) == -1)
-        return -3;
-
-    running = 1;
-
-    return 0;
-}
-
-DLLEXPORT void jl_profile_stop_timer(void)
-{
-    if (running) {
-        memset(&timerprof, 0, sizeof(timerprof));
-        setitimer(ITIMER_PROF, &timerprof, 0);
-    }
-    running = 0;
-}
-
diff --git a/src/signals-linux.c b/src/signals-linux.c
deleted file mode 100644
index b89c2b335d683..0000000000000
--- a/src/signals-linux.c
+++ /dev/null
@@ -1,74 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-// Linux
-//
-// Linux can use the BSD timers, but this is the more careful approach.
-#include <time.h>
-#include <string.h>  // for memset
-
-static timer_t timerprof;
-static struct itimerspec itsprof;
-
-// The handler function, called whenever the profiling timer elapses
-static void profile_bt(int signal, siginfo_t *si, void *uc)
-{
-    if (running && si->si_value.sival_ptr == &timerprof && bt_size_cur < bt_size_max) {
-        // Get backtrace data
-        bt_size_cur += rec_backtrace((ptrint_t*)bt_data_prof+bt_size_cur, bt_size_max-bt_size_cur-1);
-        // Mark the end of this block with 0
-        bt_data_prof[bt_size_cur] = 0;
-        bt_size_cur++;
-    }
-    if (bt_size_cur >= bt_size_max) {
-        // Buffer full: Delete the  timer
-        jl_profile_stop_timer();
-    }
-}
-
-DLLEXPORT int jl_profile_start_timer(void)
-{
-    struct sigevent sigprof;
-    struct sigaction sa;
-    sigset_t ss;
-
-    // Make sure SIGUSR2 is unblocked
-    sigemptyset(&ss);
-    sigaddset(&ss, SIGUSR2);
-    if (sigprocmask(SIG_UNBLOCK, &ss, NULL) == -1)
-        return -4;
-
-    // Establish the signal handler
-    memset(&sa, 0, sizeof(struct sigaction));
-    sa.sa_flags = SA_SIGINFO;
-    sa.sa_sigaction = profile_bt;
-    sigemptyset(&sa.sa_mask);
-    if (sigaction(SIGUSR2, &sa, NULL) == -1)
-        return -1;
-
-    // Establish the signal event
-    memset(&sigprof, 0, sizeof(struct sigevent));
-    sigprof.sigev_notify = SIGEV_SIGNAL;
-    sigprof.sigev_signo = SIGUSR2;
-    sigprof.sigev_value.sival_ptr = &timerprof;
-    if (timer_create(CLOCK_REALTIME, &sigprof, &timerprof) == -1)
-        return -2;
-
-    // Start the timer
-    itsprof.it_interval.tv_sec = nsecprof/GIGA;
-    itsprof.it_interval.tv_nsec = nsecprof%GIGA;
-    itsprof.it_value.tv_sec = nsecprof/GIGA;
-    itsprof.it_value.tv_nsec = nsecprof%GIGA;
-    if (timer_settime(timerprof, 0, &itsprof, NULL) == -1)
-        return -3;
-
-    running = 1;
-    return 0;
-}
-
-DLLEXPORT void jl_profile_stop_timer(void)
-{
-    if (running)
-        timer_delete(timerprof);
-    running = 0;
-}
-
diff --git a/src/signals-mach.c b/src/signals-mach.c
new file mode 100644
index 0000000000000..a5d96156ad017
--- /dev/null
+++ b/src/signals-mach.c
@@ -0,0 +1,443 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#include <mach/clock.h>
+#include <mach/clock_types.h>
+#include <mach/clock_reply.h>
+#include <mach/mach_traps.h>
+#include <mach/task.h>
+#include <mach/mig_errors.h>
+#include <AvailabilityMacros.h>
+
+#ifdef MAC_OS_X_VERSION_10_9
+#include <sys/_types/_ucontext64.h>
+#else
+#define __need_ucontext64_t
+#include <sys/_structs.h>
+#endif
+
+static void attach_exception_port(thread_port_t thread);
+
+#ifdef JULIA_ENABLE_THREADING
+JL_DEFINE_MUTEX(gc_suspend)
+// This is a copy of `jl_gc_safepoint_activated` to make it easier
+// to synchronic the GC and the signal handler
+static int jl_gc_safepoint_activated = 0;
+// low 16 bits are the thread id, the next 8 bits are the original gc_state
+static arraylist_t suspended_threads;
+void jl_mach_gc_begin(void)
+{
+    JL_LOCK_NOGC(gc_suspend);
+    jl_gc_safepoint_activated = 1;
+    JL_UNLOCK_NOGC(gc_suspend);
+}
+void jl_mach_gc_end(void)
+{
+    JL_LOCK_NOGC(gc_suspend);
+    jl_gc_safepoint_activated = 0;
+    for (size_t i = 0;i < suspended_threads.len;i++) {
+        uintptr_t item = (uintptr_t)suspended_threads.items[i];
+        int16_t tid = (int16_t)item;
+        int8_t gc_state = (int8_t)(item >> 8);
+        jl_all_task_states[tid].ptls->gc_state = gc_state;
+        thread_resume(pthread_mach_thread_np(jl_all_task_states[tid].system_id));
+    }
+    suspended_threads.len = 0;
+    JL_UNLOCK_NOGC(gc_suspend);
+}
+#endif
+
+static mach_port_t segv_port = 0;
+
+extern boolean_t exc_server(mach_msg_header_t *, mach_msg_header_t *);
+
+#define STR(x) #x
+#define XSTR(x) STR(x)
+#define HANDLE_MACH_ERROR(msg, retval) \
+    if (retval != KERN_SUCCESS) { mach_error(msg XSTR(: __FILE__:__LINE__:), (retval)); jl_exit(1); }
+
+void *mach_segv_listener(void *arg)
+{
+    (void)arg;
+    while (1) {
+        int ret = mach_msg_server(exc_server, 2048, segv_port, MACH_MSG_TIMEOUT_NONE);
+        jl_safe_printf("mach_msg_server: %s\n", mach_error_string(ret));
+        jl_exit(128 + SIGSEGV);
+    }
+}
+
+static void allocate_segv_handler()
+{
+#ifdef JULIA_ENABLE_THREADING
+    arraylist_new(&suspended_threads, jl_n_threads);
+#endif
+    pthread_t thread;
+    pthread_attr_t attr;
+    kern_return_t ret;
+    mach_port_t self = mach_task_self();
+    ret = mach_port_allocate(self, MACH_PORT_RIGHT_RECEIVE, &segv_port);
+    HANDLE_MACH_ERROR("mach_port_allocate",ret);
+    ret = mach_port_insert_right(self, segv_port, segv_port, MACH_MSG_TYPE_MAKE_SEND);
+    HANDLE_MACH_ERROR("mach_port_insert_right",ret);
+    // Alright, create a thread to serve as the listener for exceptions
+    if (pthread_attr_init(&attr) != 0) {
+        jl_error("pthread_attr_init failed");
+    }
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    if (pthread_create(&thread, &attr, mach_segv_listener, NULL) != 0) {
+        jl_error("pthread_create failed");
+    }
+    pthread_attr_destroy(&attr);
+    for (int16_t tid = 0;tid < jl_n_threads;tid++) {
+        attach_exception_port(pthread_mach_thread_np(jl_all_task_states[tid].system_id));
+    }
+}
+
+#ifdef LIBOSXUNWIND
+volatile mach_port_t mach_profiler_thread = 0;
+static kern_return_t profiler_segv_handler
+                (mach_port_t                          exception_port,
+                 mach_port_t                                  thread,
+                 mach_port_t                                    task,
+                 exception_type_t                          exception,
+                 exception_data_t                               code,
+                 mach_msg_type_number_t                   code_count);
+#endif
+
+enum x86_trap_flags {
+    USER_MODE = 0x4,
+    WRITE_FAULT = 0x2,
+    PAGE_PRESENT = 0x1
+};
+
+void jl_throw_in_thread(int tid, mach_port_t thread, jl_value_t *exception)
+{
+    unsigned int count = MACHINE_THREAD_STATE_COUNT;
+    x86_thread_state64_t state;
+    kern_return_t ret = thread_get_state(thread, x86_THREAD_STATE64, (thread_state_t)&state, &count);
+    HANDLE_MACH_ERROR("thread_get_state", ret);
+
+    jl_all_task_states[tid].ptls->bt_size =
+        rec_backtrace_ctx(jl_all_task_states[tid].ptls->bt_data,
+                          JL_MAX_BT_SIZE, (bt_context_t)&state);
+    jl_all_task_states[tid].ptls->exception_in_transit = exception;
+
+    uint64_t rsp = (uint64_t)jl_all_task_states[tid].signal_stack + sig_stack_size;
+    rsp &= -16; // ensure 16-byte alignment
+
+    // push (null) $RIP onto the stack
+    rsp -= sizeof(void*);
+    *(void**)rsp = NULL;
+
+    state.__rsp = rsp; // set stack pointer
+    state.__rip = (uint64_t)&jl_rethrow; // "call" the function
+
+    ret = thread_set_state(thread, x86_THREAD_STATE64, (thread_state_t)&state, count);
+    HANDLE_MACH_ERROR("thread_set_state",ret);
+}
+
+//exc_server uses dlsym to find symbol
+JL_DLLEXPORT
+kern_return_t catch_exception_raise(mach_port_t            exception_port,
+                                    mach_port_t            thread,
+                                    mach_port_t            task,
+                                    exception_type_t       exception,
+                                    exception_data_t       code,
+                                    mach_msg_type_number_t code_count)
+{
+    unsigned int count = MACHINE_THREAD_STATE_COUNT;
+    unsigned int exc_count = X86_EXCEPTION_STATE64_COUNT;
+    x86_exception_state64_t exc_state;
+    x86_thread_state64_t state;
+#ifdef LIBOSXUNWIND
+    if (thread == mach_profiler_thread) {
+        return profiler_segv_handler(exception_port, thread, task, exception, code, code_count);
+    }
+#endif
+    int16_t tid;
+#ifdef JULIA_ENABLE_THREADING
+    jl_tls_states_t *ptls = NULL;
+    for (tid = 0;tid < jl_n_threads;tid++) {
+        if (pthread_mach_thread_np(jl_all_task_states[tid].system_id) == thread) {
+            ptls = jl_all_task_states[tid].ptls;
+            break;
+        }
+    }
+    if (!ptls) {
+        // We don't know about this thread, let the kernel try another handler
+        // instead. This shouldn't actually happen since we only register the
+        // handler for the threads we know about.
+        jl_safe_printf("ERROR: Exception handler triggered on unmanaged thread.\n");
+        return KERN_INVALID_ARGUMENT;
+    }
+#else
+    jl_tls_states_t *ptls = &jl_tls_states;
+    tid = 0;
+#endif
+    kern_return_t ret = thread_get_state(thread, x86_EXCEPTION_STATE64, (thread_state_t)&exc_state, &exc_count);
+    HANDLE_MACH_ERROR("thread_get_state", ret);
+    uint64_t fault_addr = exc_state.__faultvaddr;
+#ifdef JULIA_ENABLE_THREADING
+    if (fault_addr == (uintptr_t)jl_gc_signal_page) {
+        JL_LOCK_NOGC(gc_suspend);
+        if (!jl_gc_safepoint_activated) {
+            // GC is done before we get the message, do nothing and return
+            JL_UNLOCK_NOGC(gc_suspend);
+            return KERN_SUCCESS;
+        }
+        // Otherwise, set the gc state of the thread, suspend and record it
+        int8_t gc_state = ptls->gc_state;
+        ptls->gc_state = JL_GC_STATE_WAITING;
+        uintptr_t item = tid | (((uintptr_t)gc_state) << 16);
+        arraylist_push(&suspended_threads, (void*)item);
+        thread_suspend(thread);
+        JL_UNLOCK_NOGC(gc_suspend);
+        return KERN_SUCCESS;
+    }
+#endif
+#ifdef SEGV_EXCEPTION
+    if (1) {
+#else
+    if (msync((void*)(fault_addr & ~(jl_page_size - 1)), 1, MS_ASYNC) == 0) { // check if this was a valid address
+#endif
+        jl_value_t *excpt;
+        if (is_addr_on_stack(ptls, (void*)fault_addr)) {
+            excpt = jl_stackovf_exception;
+        }
+#ifdef SEGV_EXCEPTION
+        else if (msync((void*)(fault_addr & ~(jl_page_size - 1)), 1, MS_ASYNC) != 0) {
+            // no page mapped at this address
+            excpt = jl_segv_exception;
+        }
+#endif
+        else {
+            if (!(exc_state.__err & WRITE_FAULT))
+                return KERN_INVALID_ARGUMENT; // rethrow the SEGV since it wasn't an error with writing to read-only memory
+            excpt = jl_readonlymemory_exception;
+        }
+        jl_throw_in_thread(tid, thread, excpt);
+
+        return KERN_SUCCESS;
+    }
+    else {
+        kern_return_t ret = thread_get_state(thread, x86_THREAD_STATE64, (thread_state_t)&state, &count);
+        HANDLE_MACH_ERROR("thread_get_state", ret);
+        jl_critical_error(SIGSEGV, (unw_context_t*)&state,
+                          ptls->bt_data, &ptls->bt_size);
+        return KERN_INVALID_ARGUMENT;
+    }
+}
+
+static void attach_exception_port(thread_port_t thread)
+{
+    kern_return_t ret;
+    // http://www.opensource.apple.com/source/xnu/xnu-2782.1.97/osfmk/man/thread_set_exception_ports.html
+    ret = thread_set_exception_ports(thread, EXC_MASK_BAD_ACCESS, segv_port, EXCEPTION_DEFAULT, MACHINE_THREAD_STATE);
+    HANDLE_MACH_ERROR("thread_set_exception_ports", ret);
+}
+
+static void jl_thread_suspend_and_get_state(int tid, unw_context_t **ctx, int sig)
+{
+    (void)sig;
+    mach_port_t tid_port = pthread_mach_thread_np(jl_all_task_states[tid].system_id);
+
+    kern_return_t ret = thread_suspend(tid_port);
+    HANDLE_MACH_ERROR("thread_suspend", ret);
+
+    // Do the actual sampling
+    unsigned int count = MACHINE_THREAD_STATE_COUNT;
+    static unw_context_t state;
+    memset(&state, 0, sizeof(unw_context_t));
+
+    // Get the state of the suspended thread
+    ret = thread_get_state(tid_port, x86_THREAD_STATE64, (thread_state_t)&state, &count);
+
+    // Initialize the unwind context with the suspend thread's state
+    *ctx = &state;
+}
+
+static void jl_thread_resume(int tid, int sig)
+{
+    mach_port_t thread = pthread_mach_thread_np(jl_all_task_states[tid].system_id);
+
+    if (tid == 0 && sig == SIGINT) {
+        if (jl_defer_signal) {
+            jl_signal_pending = sig;
+        }
+        else {
+            jl_signal_pending = 0;
+            jl_throw_in_thread(tid, thread, jl_interrupt_exception);
+        }
+    }
+
+    kern_return_t ret = thread_resume(thread);
+    HANDLE_MACH_ERROR("thread_resume", ret)
+}
+
+static int profile_started = 0;
+mach_timespec_t timerprof;
+static pthread_t profiler_thread;
+clock_serv_t clk;
+static mach_port_t profile_port = 0;
+
+#ifdef LIBOSXUNWIND
+volatile static int forceDwarf = -2;
+static unw_context_t profiler_uc;
+
+static kern_return_t profiler_segv_handler
+                (mach_port_t                          exception_port,
+                 mach_port_t                                  thread,
+                 mach_port_t                                    task,
+                 exception_type_t                          exception,
+                 exception_data_t                               code,
+                 mach_msg_type_number_t                   code_count)
+{
+    assert(thread == mach_profiler_thread);
+    x86_thread_state64_t state;
+
+    // Not currently unwinding. Raise regular segfault
+    if (forceDwarf == -2)
+        return KERN_INVALID_ARGUMENT;
+
+    if (forceDwarf == 0)
+        forceDwarf = 1;
+    else
+        forceDwarf = -1;
+
+    unsigned int count = MACHINE_THREAD_STATE_COUNT;
+
+    thread_get_state(thread, x86_THREAD_STATE64, (thread_state_t)&state, &count);
+
+    // don't change cs fs gs rflags
+    uint64_t cs = state.__cs;
+    uint64_t fs = state.__fs;
+    uint64_t gs = state.__gs;
+    uint64_t rflags = state.__rflags;
+
+    memcpy(&state, &profiler_uc, sizeof(x86_thread_state64_t));
+
+    state.__cs = cs;
+    state.__fs = fs;
+    state.__gs = gs;
+    state.__rflags = rflags;
+
+    kern_return_t ret = thread_set_state(thread, x86_THREAD_STATE64, (thread_state_t)&state, count);
+    HANDLE_MACH_ERROR("thread_set_state", ret);
+
+    return KERN_SUCCESS;
+}
+#endif
+
+void *mach_profile_listener(void *arg)
+{
+    (void)arg;
+    int i;
+    const int max_size = 512;
+    attach_exception_port(mach_thread_self());
+#ifdef LIBOSXUNWIND
+    mach_profiler_thread = mach_thread_self();
+#endif
+    mig_reply_error_t *bufRequest = (mig_reply_error_t *) malloc(max_size);
+    while (1) {
+        kern_return_t ret = mach_msg(&bufRequest->Head, MACH_RCV_MSG,
+                                     0, max_size, profile_port,
+                                     MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+        HANDLE_MACH_ERROR("mach_msg", ret);
+        // sample each thread, round-robin style in reverse order
+        // (so that thread zero gets notified last)
+        for (i = jl_n_threads; i-- > 0; ) {
+            // if there is no space left, break early
+            if (bt_size_cur >= bt_size_max - 1)
+                break;
+
+            unw_context_t *uc;
+            jl_thread_suspend_and_get_state(i, &uc, -1);
+
+#ifdef LIBOSXUNWIND
+            /*
+             *  Unfortunately compact unwind info is incorrectly generated for quite a number of
+             *  libraries by quite a large number of compilers. We can fall back to DWARF unwind info
+             *  in some cases, but in quite a number of cases (especially libraries not compiled in debug
+             *  mode, only the compact unwind info may be available). Even more unfortunately, there is no
+             *  way to detect such bogus compact unwind info (other than noticing the resulting segfault).
+             *  What we do here is ugly, but necessary until the compact unwind info situation improves.
+             *  We try to use the compact unwind info and if that results in a segfault, we retry with DWARF info.
+             *  Note that in a small number of cases this may result in bogus stack traces, but at least the topmost
+             *  entry will always be correct, and the number of cases in which this is an issue is rather small.
+             *  Other than that, this implementation is not incorrect as the other thread is paused while we are profiling
+             *  and during stack unwinding we only ever read memory, but never write it.
+             */
+
+            forceDwarf = 0;
+            unw_getcontext(&profiler_uc); // will resume from this point if the next lines segfault at any point
+
+            if (forceDwarf == 0) {
+                // Save the backtrace
+                bt_size_cur += rec_backtrace_ctx((intptr_t*)bt_data_prof + bt_size_cur, bt_size_max - bt_size_cur - 1, uc);
+            }
+            else if (forceDwarf == 1) {
+                bt_size_cur += rec_backtrace_ctx_dwarf((intptr_t*)bt_data_prof + bt_size_cur, bt_size_max - bt_size_cur - 1, uc);
+            }
+            else if (forceDwarf == -1) {
+                jl_safe_printf("WARNING: profiler attempt to access an invalid memory location\n");
+            }
+
+            forceDwarf = -2;
+#else
+            bt_size_cur += rec_backtrace_ctx((intptr_t*)bt_data_prof + bt_size_cur, bt_size_max - bt_size_cur - 1, uc);
+#endif
+
+            // Mark the end of this block with 0
+            bt_data_prof[bt_size_cur++] = 0;
+
+            // We're done! Resume the thread.
+            jl_thread_resume(i, 0);
+
+            if (running) {
+                // Reset the alarm
+                kern_return_t ret = clock_alarm(clk, TIME_RELATIVE, timerprof, profile_port);
+                HANDLE_MACH_ERROR("clock_alarm", ret)
+            }
+        }
+    }
+}
+
+JL_DLLEXPORT int jl_profile_start_timer(void)
+{
+    kern_return_t ret;
+    if (!profile_started) {
+        mach_port_t self = mach_task_self();
+
+        ret = host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, (clock_serv_t *)&clk);
+        HANDLE_MACH_ERROR("host_get_clock_service", ret);
+
+        ret = mach_port_allocate(self, MACH_PORT_RIGHT_RECEIVE, &profile_port);
+        HANDLE_MACH_ERROR("mach_port_allocate", ret);
+
+        // Alright, create a thread to serve as the listener for exceptions
+        pthread_attr_t attr;
+        if (pthread_attr_init(&attr) != 0) {
+            jl_error("pthread_attr_init failed");
+        }
+        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+        if (pthread_create(&profiler_thread, &attr, mach_profile_listener, NULL) != 0) {
+            jl_error("pthread_create failed");
+        }
+        pthread_attr_destroy(&attr);
+
+        profile_started = 1;
+    }
+
+    timerprof.tv_sec = nsecprof/GIGA;
+    timerprof.tv_nsec = nsecprof%GIGA;
+
+    running = 1;
+    ret = clock_alarm(clk, TIME_RELATIVE, timerprof, profile_port);
+    HANDLE_MACH_ERROR("clock_alarm", ret);
+
+    return 0;
+}
+
+JL_DLLEXPORT void jl_profile_stop_timer(void)
+{
+    running = 0;
+}
diff --git a/src/signals-unix.c b/src/signals-unix.c
index 9a858acfd2357..fd2ec5dc7da55 100644
--- a/src/signals-unix.c
+++ b/src/signals-unix.c
@@ -1,131 +1,444 @@
 // This file is a part of Julia. License is MIT: http://julialang.org/license
 
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <pthread.h>
+#if defined(_OS_DARWIN_) && !defined(MAP_ANONYMOUS)
+#define MAP_ANONYMOUS MAP_ANON
+#endif
 
-void fpe_handler(int arg)
-{
-    (void)arg;
-    sigset_t sset;
-    sigemptyset(&sset);
-    sigaddset(&sset, SIGFPE);
-    sigprocmask(SIG_UNBLOCK, &sset, NULL);
+#ifdef __APPLE__
+#include <AvailabilityMacros.h>
+#ifdef MAC_OS_X_VERSION_10_9
+#include <sys/_types/_ucontext64.h>
+#else
+#define __need_ucontext64_t
+#include <machine/_structs.h>
+#endif
+#endif
 
-    jl_throw(jl_diverror_exception);
-}
+// Figure out the best signals/timers to use for this platform
+#ifdef __APPLE__ // Darwin's mach ports allow signal-free thread management
+#define HAVE_MACH
+#elif defined(__FreeBSD__) // generic bsd
+#define HAVE_ITIMER
+#else // generic linux
+#define HAVE_TIMER
+#endif
+
+#if defined(JL_USE_INTEL_JITEVENTS)
+unsigned sig_stack_size = SIGSTKSZ;
+#elif defined(_CPU_AARCH64_)
+// The default SIGSTKSZ causes stack overflow in libunwind.
+#define sig_stack_size (1 << 16)
+#else
+#define sig_stack_size SIGSTKSZ
+#endif
 
-static int is_addr_on_stack(void *addr)
+static pthread_t signals_thread;
+static volatile int remote_sig;
+
+static int is_addr_on_stack(jl_tls_states_t *ptls, void *addr)
 {
 #ifdef COPY_STACKS
-    return ((char*)addr > (char*)jl_stack_lo-3000000 &&
-            (char*)addr < (char*)jl_stack_hi);
+    return ((char*)addr > (char*)ptls->stack_lo-3000000 &&
+            (char*)addr < (char*)ptls->stack_hi);
 #else
-    return ((char*)addr > (char*)jl_current_task->stack-8192 &&
-            (char*)addr < (char*)jl_current_task->stack+jl_current_task->ssize);
+    return ((char*)addr > (char*)ptls->current_task->stkbuf &&
+            (char*)addr < (char*)ptls->current_task->stkbuf + ptls->current_task->ssize);
 #endif
 }
 
-#ifndef SIGINFO
-#define SIGINFO SIGUSR1
-#endif
 void sigdie_handler(int sig, siginfo_t *info, void *context)
 {
-    if (sig != SIGINFO) {
-        sigset_t sset;
-        uv_tty_reset_mode();
-        sigfillset(&sset);
-        sigprocmask(SIG_UNBLOCK, &sset, NULL);
-        signal(sig, SIG_DFL);
-    }
-    jl_safe_printf("\nsignal (%d): %s\n", sig, strsignal(sig));
+    sigset_t sset;
+    uv_tty_reset_mode();
+    sigfillset(&sset);
+    sigprocmask(SIG_UNBLOCK, &sset, NULL);
+    signal(sig, SIG_DFL);
 #ifdef __APPLE__
-    bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, (bt_context_t)&((ucontext64_t*)context)->uc_mcontext64->__ss);
+    jl_critical_error(sig, (bt_context_t)&((ucontext64_t*)context)->uc_mcontext64->__ss, jl_bt_data, &jl_bt_size);
 #else
-    bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, (ucontext_t*)context);
+    jl_critical_error(sig, (bt_context_t)context, jl_bt_data, &jl_bt_size);
 #endif
-    jlbacktrace();
-    gc_debug_print_status();
     if (sig != SIGSEGV &&
         sig != SIGBUS &&
-        sig != SIGILL &&
-        sig != SIGINFO) {
+        sig != SIGILL) {
         raise(sig);
     }
+    // fall-through return to re-execute faulting statement (but without the error handler)
 }
 
-#ifndef __APPLE__ // Apple handles this from a separate thread (catch_exception_raise)
-extern int in_jl_;
-void segv_handler(int sig, siginfo_t *info, void *context)
+static void jl_unblock_signal(int sig)
 {
+    // Put in a separate function to save some stack space since
+    // sigset_t can be pretty big.
     sigset_t sset;
-    assert(sig == SIGSEGV);
+    sigemptyset(&sset);
+    sigaddset(&sset, sig);
+    sigprocmask(SIG_UNBLOCK, &sset, NULL);
+}
 
-    if (in_jl_ || is_addr_on_stack(info->si_addr)) { // stack overflow, or restarting jl_
-        sigemptyset(&sset);
-        sigaddset(&sset, SIGSEGV);
-        sigprocmask(SIG_UNBLOCK, &sset, NULL);
+#if defined(HAVE_MACH)
+#include <signals-mach.c>
+#else
+
+static void segv_handler(int sig, siginfo_t *info, void *context)
+{
+    assert(sig == SIGSEGV || sig == SIGBUS);
+
+#ifdef JULIA_ENABLE_THREADING
+    if (info->si_addr == jl_gc_signal_page) {
+        jl_unblock_signal(sig);
+        jl_gc_signal_wait();
+        return;
+    }
+#endif
+    if (jl_safe_restore || is_addr_on_stack(jl_get_ptls_states(), info->si_addr)) { // stack overflow, or restarting jl_
+        jl_unblock_signal(sig);
         jl_throw(jl_stackovf_exception);
     }
-    else if (info->si_code == SEGV_ACCERR) {  // writing to read-only memory (e.g., mmap)
-        sigemptyset(&sset);
-        sigaddset(&sset, SIGSEGV);
-        sigprocmask(SIG_UNBLOCK, &sset, NULL);
+    else if (sig == SIGSEGV && info->si_code == SEGV_ACCERR) {  // writing to read-only memory (e.g., mmap)
+        jl_unblock_signal(sig);
         jl_throw(jl_readonlymemory_exception);
     }
     else {
 #ifdef SEGV_EXCEPTION
-        sigemptyset(&sset);
-        sigaddset(&sset, SIGSEGV);
-        sigprocmask(SIG_UNBLOCK, &sset, NULL);
+        jl_unblock_signal(sig);
         jl_throw(jl_segv_exception);
 #else
         sigdie_handler(sig, info, context);
 #endif
     }
 }
-#endif
 
-void restore_signals(void)
+static void allocate_segv_handler(void)
 {
-    sigset_t sset;
-    sigemptyset(&sset);
-    sigprocmask(SIG_SETMASK, &sset, 0);
+    struct sigaction act;
+    memset(&act, 0, sizeof(struct sigaction));
+    sigemptyset(&act.sa_mask);
+    act.sa_sigaction = segv_handler;
+    act.sa_flags = SA_ONSTACK | SA_SIGINFO;
+    if (sigaction(SIGSEGV, &act, NULL) < 0) {
+        jl_errorf("fatal error: sigaction: %s", strerror(errno));
+    }
+    // On AArch64, stack overflow triggers a SIGBUS
+    if (sigaction(SIGBUS, &act, NULL) < 0) {
+        jl_errorf("fatal error: sigaction: %s", strerror(errno));
+    }
 }
 
-void sigint_handler(int sig, siginfo_t *info, void *context)
+static unw_context_t *volatile signal_context;
+static volatile int waiting_for;
+static pthread_mutex_t in_signal_lock;
+static pthread_cond_t exit_signal_cond;
+static pthread_cond_t signal_caught_cond;
+
+static void jl_thread_suspend_and_get_state(int tid, unw_context_t **ctx, int sig)
+{
+    pthread_mutex_lock(&in_signal_lock);
+    remote_sig = sig;
+    waiting_for = tid;
+    pthread_kill(jl_all_task_states[tid].system_id, SIGUSR2);
+    pthread_cond_wait(&signal_caught_cond, &in_signal_lock);  // wait for thread to acknowledge
+    assert(waiting_for == 0);
+    *ctx = signal_context;
+}
+
+static void jl_thread_resume(int tid, int sig)
+{
+    (void)sig;
+    remote_sig = 0;
+    waiting_for = tid;
+    pthread_cond_broadcast(&exit_signal_cond);
+    pthread_cond_wait(&signal_caught_cond, &in_signal_lock); // wait for thread to acknowledge
+    assert(waiting_for == 0);
+    pthread_mutex_unlock(&in_signal_lock);
+}
+
+
+static inline void wait_barrier(void)
 {
-    if (jl_defer_signal) {
-        jl_signal_pending = sig;
+    if (waiting_for < 0) {
+        if (jl_atomic_fetch_add(&waiting_for, 1) == -1) {
+            pthread_cond_broadcast(&signal_caught_cond);
+        }
     }
     else {
-        jl_signal_pending = 0;
-        sigset_t sset;
-        sigemptyset(&sset);
-        sigaddset(&sset, SIGINT);
-        sigprocmask(SIG_UNBLOCK, &sset, NULL);
-        jl_sigint_action();
+        pthread_cond_broadcast(&signal_caught_cond);
+        waiting_for = 0;
     }
 }
+void usr2_handler(int sig, siginfo_t *info, void *ctx)
+{
+    ucontext_t *context = (ucontext_t*)ctx;
+    if ((remote_sig > 0 && waiting_for < 0) || waiting_for == ti_tid) {
+        int realsig = remote_sig;
+#ifdef __APPLE__
+        signal_context = (unw_context_t*)&context->uc_mcontext->__ss;
+#else
+        signal_context = (unw_context_t*)context;
+#endif
+
+        pthread_mutex_lock(&in_signal_lock);
+        wait_barrier();
+        pthread_cond_wait(&exit_signal_cond, &in_signal_lock);
+        wait_barrier();
+        pthread_mutex_unlock(&in_signal_lock);
 
-DLLEXPORT void jl_install_sigint_handler(void)
+        if (ti_tid == 0 && realsig == SIGINT) {
+            if (jl_defer_signal) {
+                jl_signal_pending = realsig;
+            }
+            else {
+                jl_signal_pending = 0;
+                jl_unblock_signal(sig);
+                jl_throw(jl_interrupt_exception);
+            }
+        }
+    }
+}
+
+#if defined(HAVE_TIMER)
+// Linux-style
+#include <time.h>
+#include <string.h>  // for memset
+
+static timer_t timerprof;
+static struct itimerspec itsprof;
+
+JL_DLLEXPORT int jl_profile_start_timer(void)
 {
+    struct sigevent sigprof;
+
+    // Establish the signal event
+    memset(&sigprof, 0, sizeof(struct sigevent));
+    sigprof.sigev_notify = SIGEV_SIGNAL;
+    sigprof.sigev_signo = SIGUSR1;
+    sigprof.sigev_value.sival_ptr = &timerprof;
+    if (timer_create(CLOCK_REALTIME, &sigprof, &timerprof) == -1)
+        return -2;
+
+    // Start the timer
+    itsprof.it_interval.tv_sec = nsecprof/GIGA;
+    itsprof.it_interval.tv_nsec = nsecprof%GIGA;
+    itsprof.it_value.tv_sec = nsecprof/GIGA;
+    itsprof.it_value.tv_nsec = nsecprof%GIGA;
+    if (timer_settime(timerprof, 0, &itsprof, NULL) == -1)
+        return -3;
+
+    running = 1;
+    return 0;
+}
+
+JL_DLLEXPORT void jl_profile_stop_timer(void)
+{
+    if (running)
+        timer_delete(timerprof);
+    running = 0;
+}
+
+#elif defined(HAVE_ITIMER)
+// BSD-style timers
+#include <string.h>
+#include <sys/time.h>
+struct itimerval timerprof;
+
+JL_DLLEXPORT int jl_profile_start_timer(void)
+{
+    timerprof.it_interval.tv_sec = nsecprof/GIGA;
+    timerprof.it_interval.tv_usec = (nsecprof%GIGA)/1000;
+    timerprof.it_value.tv_sec = nsecprof/GIGA;
+    timerprof.it_value.tv_usec = (nsecprof%GIGA)/1000;
+    if (setitimer(ITIMER_PROF, &timerprof, 0) == -1)
+        return -3;
+
+    running = 1;
+
+    return 0;
+}
+
+JL_DLLEXPORT void jl_profile_stop_timer(void)
+{
+    if (running) {
+        memset(&timerprof, 0, sizeof(timerprof));
+        setitimer(ITIMER_PROF, &timerprof, 0);
+    }
+    running = 0;
+}
+
+#else
+
+#error no profile tools available
+
+#endif
+#endif // HAVE_MACH
+
+static void *alloc_sigstack(size_t size)
+{
+    size_t pagesz = jl_getpagesize();
+    // Add one guard page to catch stack overflow in the signal handler
+    size = LLT_ALIGN(size, pagesz) + pagesz;
+    void *stackbuff = mmap(0, size, PROT_READ | PROT_WRITE,
+                           MAP_NORESERVE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (stackbuff == MAP_FAILED)
+        jl_errorf("fatal error allocating signal stack: mmap: %s",
+                  strerror(errno));
+    mprotect(stackbuff, pagesz, PROT_NONE);
+    return (void*)((char*)stackbuff + pagesz);
+}
+
+void *jl_install_thread_signal_handler(void)
+{
+    void *signal_stack = alloc_sigstack(sig_stack_size);
+    stack_t ss;
+    ss.ss_flags = 0;
+    ss.ss_size = sig_stack_size;
+    ss.ss_sp = signal_stack;
+    if (sigaltstack(&ss, NULL) < 0) {
+        jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
+    }
+
+#if !defined(HAVE_MACH)
     struct sigaction act;
     memset(&act, 0, sizeof(struct sigaction));
     sigemptyset(&act.sa_mask);
-    act.sa_sigaction = sigint_handler;
-    act.sa_flags = SA_SIGINFO;
-    if (sigaction(SIGINT, &act, NULL) < 0) {
+    act.sa_sigaction = usr2_handler;
+    act.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESTART;
+    if (sigaction(SIGUSR2, &act, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
+#endif
+
+    return signal_stack;
 }
 
-void jl_install_default_signal_handlers(void)
+void jl_sigsetset(sigset_t *sset)
+{
+    sigemptyset(sset);
+    sigaddset(sset, SIGINT);
+    sigaddset(sset, SIGTERM);
+    sigaddset(sset, SIGABRT);
+    sigaddset(sset, SIGQUIT);
+#ifdef SIGINFO
+    sigaddset(sset, SIGINFO);
+#else
+    sigaddset(sset, SIGUSR1);
+#endif
+#ifdef HAVE_ITIMER
+    sigaddset(sset, SIGPROF);
+#endif
+}
+
+static void *signal_listener(void *arg)
 {
-#if defined(__linux__) && defined(JL_USE_INTEL_JITEVENTS)
-    if (jl_using_intel_jitevents)
-        // Intel VTune Amplifier needs at least 64k for alternate stack.
-        if (SIGSTKSZ < 1<<16)
-            sig_stack_size = 1<<16;
+    static intptr_t bt_data[JL_MAX_BT_SIZE + 1];
+    static size_t bt_size = 0;
+    sigset_t sset;
+    unw_context_t *signal_context;
+    int sig, critical, profile;
+    int i;
+    jl_sigsetset(&sset);
+    while (1) {
+        profile = 0;
+        sigwait(&sset, &sig);
+#ifndef HAVE_MACH
+#  ifdef HAVE_ITIMER
+        profile = (sig == SIGPROF);
+#  else
+        profile = (sig == SIGUSR1);
+#  endif
+#endif
+
+        critical = (sig == SIGINT && exit_on_sigint);
+        critical |= (sig == SIGTERM);
+        critical |= (sig == SIGABRT);
+        critical |= (sig == SIGQUIT);
+#ifdef SIGINFO
+        critical |= (sig == SIGINFO);
+#else
+        critical |= (sig == SIGUSR1 && !profile);
+#endif
+
+        bt_size = 0;
+        // sample each thread, round-robin style in reverse order
+        // (so that thread zero gets notified last)
+        for (i = jl_n_threads; i-- > 0; ) {
+            // notify thread to stop
+            jl_thread_suspend_and_get_state(i, &signal_context, sig);
+
+            // do backtrace on thread contexts for critical signals
+            // this part must be signal-handler safe
+            if (critical) {
+                bt_size += rec_backtrace_ctx(bt_data + bt_size,
+                        JL_MAX_BT_SIZE / jl_n_threads - 1,
+                        signal_context);
+                bt_data[bt_size++] = 0;
+            }
+
+            // do backtrace for profiler
+            if (profile && running) {
+                if (bt_size_cur < bt_size_max - 1) {
+                    // Get backtrace data
+                    bt_size_cur += rec_backtrace_ctx((intptr_t*)bt_data_prof + bt_size_cur,
+                            bt_size_max - bt_size_cur - 1, signal_context);
+                    // Mark the end of this block with 0
+                    bt_data_prof[bt_size_cur++] = 0;
+                }
+                if (bt_size_cur >= bt_size_max - 1) {
+                    // Buffer full: Delete the timer
+                    jl_profile_stop_timer();
+                }
+            }
+
+            // notify thread to resume
+            jl_thread_resume(i, sig);
+        }
+
+        // this part is async with the running of the rest of the program
+        // and must be thread-safe, but not necessarily signal-handler safe
+        if (critical) {
+            jl_critical_error(sig, NULL, bt_data, &bt_size);
+#ifdef SIGINFO
+            if (sig != SIGINFO)
+#else
+            if (sig != SIGUSR1)
+#endif
+                jl_exit(128 + sig);
+        }
+    }
+}
+
+void restore_signals(void)
+{
+    sigset_t sset;
+    jl_sigsetset(&sset);
+    sigprocmask(SIG_SETMASK, &sset, 0);
+
+#if !defined(HAVE_MACH)
+    if (pthread_mutex_init(&in_signal_lock, NULL) != 0 ||
+        pthread_cond_init(&exit_signal_cond, NULL) != 0 ||
+        pthread_cond_init(&signal_caught_cond, NULL) != 0) {
+        jl_error("SIGUSR pthread init failed");
+    }
 #endif
-    signal_stack = malloc(sig_stack_size);
+
+    if (pthread_create(&signals_thread, NULL, signal_listener, NULL) != 0) {
+        jl_error("pthread_create(signal_listener) failed");
+    }
+}
+
+void fpe_handler(int arg)
+{
+    (void)arg;
+    jl_unblock_signal(SIGFPE);
+    jl_throw(jl_diverror_exception);
+}
+
+void jl_install_default_signal_handlers(void)
+{
     struct sigaction actf;
     memset(&actf, 0, sizeof(struct sigaction));
     sigemptyset(&actf.sa_mask);
@@ -134,73 +447,45 @@ void jl_install_default_signal_handlers(void)
     if (sigaction(SIGFPE, &actf, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
-    if (signal(SIGPIPE,SIG_IGN) == SIG_ERR) {
+    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
         jl_error("fatal error: Couldn't set SIGPIPE");
     }
-#if defined (_OS_DARWIN_)
-    kern_return_t ret;
-    mach_port_t self = mach_task_self();
-    ret = mach_port_allocate(self,MACH_PORT_RIGHT_RECEIVE,&segv_port);
-    HANDLE_MACH_ERROR("mach_port_allocate",ret);
-    ret = mach_port_insert_right(self,segv_port,segv_port,MACH_MSG_TYPE_MAKE_SEND);
-    HANDLE_MACH_ERROR("mach_port_insert_right",ret);
-
-    // Alright, create a thread to serve as the listener for exceptions
-    pthread_t thread;
-    pthread_attr_t attr;
-    if (pthread_attr_init(&attr) != 0) {
-        jl_error("pthread_attr_init failed");
-    }
-    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
-    if (pthread_create(&thread,&attr,mach_segv_listener,NULL) != 0) {
-        jl_error("pthread_create failed");
+    if (signal(SIGTRAP, SIG_IGN) == SIG_ERR) {
+        jl_error("fatal error: Couldn't set SIGTRAP");
     }
-    pthread_attr_destroy(&attr);
 
-    attach_exception_port();
-#else // defined(_OS_DARWIN_)
-    stack_t ss;
-    ss.ss_flags = 0;
-    ss.ss_size = sig_stack_size;
-    ss.ss_sp = signal_stack;
-    if (sigaltstack(&ss, NULL) < 0) {
-        jl_errorf("fatal error: sigaltstack: %s", strerror(errno));
-    }
+    allocate_segv_handler();
 
-    struct sigaction act;
-    memset(&act, 0, sizeof(struct sigaction));
-    sigemptyset(&act.sa_mask);
-    act.sa_sigaction = segv_handler;
-    act.sa_flags = SA_ONSTACK | SA_SIGINFO;
-    if (sigaction(SIGSEGV, &act, NULL) < 0) {
-        jl_errorf("fatal error: sigaction: %s", strerror(errno));
-    }
-#endif // defined(_OS_DARWIN_)
     struct sigaction act_die;
     memset(&act_die, 0, sizeof(struct sigaction));
     sigemptyset(&act_die.sa_mask);
     act_die.sa_sigaction = sigdie_handler;
     act_die.sa_flags = SA_SIGINFO;
-    if (sigaction(SIGINFO, &act_die, NULL) < 0) {
-        jl_errorf("fatal error: sigaction: %s", strerror(errno));
-    }
-    if (sigaction(SIGBUS, &act_die, NULL) < 0) {
-        jl_errorf("fatal error: sigaction: %s", strerror(errno));
-    }
     if (sigaction(SIGILL, &act_die, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
-    if (sigaction(SIGTERM, &act_die, NULL) < 0) {
+    if (sigaction(SIGSYS, &act_die, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
-    if (sigaction(SIGABRT, &act_die, NULL) < 0) {
+    // need to ensure the following signals are not SIG_IGN, even though they will be blocked
+    act_die.sa_flags = SA_SIGINFO | SA_RESTART;
+#if defined(HAVE_ITIMER)
+    if (sigaction(SIGPROF, &act_die, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
-    if (sigaction(SIGQUIT, &act_die, NULL) < 0) {
+#endif
+#ifdef SIGINFO
+    if (sigaction(SIGINFO, &act_die, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
-    if (sigaction(SIGSYS, &act_die, NULL) < 0) {
+#else
+    if (sigaction(SIGUSR1, &act_die, NULL) < 0) {
         jl_errorf("fatal error: sigaction: %s", strerror(errno));
     }
+#endif
 }
 
+JL_DLLEXPORT void jl_install_sigint_handler(void)
+{
+    // TODO: ?
+}
diff --git a/src/signals-win.c b/src/signals-win.c
index f2e2e12f7af98..6ef10e8697933 100644
--- a/src/signals-win.c
+++ b/src/signals-win.c
@@ -1,9 +1,10 @@
 // This file is a part of Julia. License is MIT: http://julialang.org/license
 
 // Windows
-//
-DLLEXPORT void gdblookup(ptrint_t ip);
-#define WIN32_LEAN_AND_MEAN
+
+#define sig_stack_size 131072 // 128k reserved for SEGV handling
+static BOOL (*pSetThreadStackGuarantee)(PULONG);
+
 // Copied from MINGW_FLOAT_H which may not be found due to a collision with the builtin gcc float.h
 // eventually we can probably integrate this into OpenLibm.
 #if defined(_COMPILER_MINGW_)
@@ -42,6 +43,7 @@ static char *strsignal(int sig)
 
 void __cdecl crt_sig_handler(int sig, int num)
 {
+    CONTEXT Context;
     switch (sig) {
     case SIGFPE:
         fpreset();
@@ -69,18 +71,19 @@ void __cdecl crt_sig_handler(int sig, int num)
         }
         break;
     default: // SIGSEGV, (SSIGTERM, IGILL)
-        ios_printf(ios_stderr,"\nsignal (%d): %s\n", sig, strsignal(sig));
-        bt_size = rec_backtrace(bt_data, MAX_BT_SIZE);
-        jlbacktrace();
-        gc_debug_print_status();
+        memset(&Context, 0, sizeof(Context));
+        RtlCaptureContext(&Context);
+        jl_critical_error(sig, &Context, jl_bt_data, &jl_bt_size);
         raise(sig);
     }
 }
 
-BOOL (*pSetThreadStackGuarantee)(PULONG);
 void restore_signals(void)
 {
-    SetConsoleCtrlHandler(NULL, 0); //turn on ctrl-c handler
+    // turn on ctrl-c handler
+    SetConsoleCtrlHandler(NULL, 0);
+    // see if SetThreadStackGuarantee exists
+    pSetThreadStackGuarantee = (BOOL (*)(PULONG)) jl_dlsym_e(jl_kernel32_handle, "SetThreadStackGuarantee");
 }
 
 void jl_throw_in_ctx(jl_value_t *excpt, CONTEXT *ctxThread, int bt)
@@ -93,7 +96,7 @@ void jl_throw_in_ctx(jl_value_t *excpt, CONTEXT *ctxThread, int bt)
 #else
 #error WIN16 not supported :P
 #endif
-    bt_size = bt ? rec_backtrace_ctx(bt_data, MAX_BT_SIZE, ctxThread) : 0;
+    jl_bt_size = bt ? rec_backtrace_ctx(jl_bt_data, JL_MAX_BT_SIZE, ctxThread) : 0;
     jl_exception_in_transit = excpt;
 #if defined(_CPU_X86_64_)
     *(DWORD64*)Rsp = 0;
@@ -106,7 +109,7 @@ void jl_throw_in_ctx(jl_value_t *excpt, CONTEXT *ctxThread, int bt)
 #endif
 }
 
-volatile HANDLE hMainThread = NULL;
+HANDLE hMainThread = INVALID_HANDLE_VALUE;
 
 static BOOL WINAPI sigint_handler(DWORD wsig) //This needs winapi types to guarantee __stdcall
 {
@@ -165,6 +168,13 @@ static LONG WINAPI _exception_handler(struct _EXCEPTION_POINTERS *ExceptionInfo,
                 jl_throw_in_ctx(jl_stackovf_exception, ExceptionInfo->ContextRecord,in_ctx&&pSetThreadStackGuarantee);
                 return EXCEPTION_CONTINUE_EXECUTION;
             case EXCEPTION_ACCESS_VIOLATION:
+#ifdef JULIA_ENABLE_THREADING
+                if (ExceptionInfo->ExceptionRecord->ExceptionInformation[1] ==
+                    (intptr_t)jl_gc_signal_page) {
+                    jl_gc_signal_wait();
+                    return EXCEPTION_CONTINUE_EXECUTION;
+                }
+#endif
                 if (ExceptionInfo->ExceptionRecord->ExceptionInformation[0] == 1) { // writing to read-only memory (e.g. mmap)
                     jl_throw_in_ctx(jl_readonlymemory_exception, ExceptionInfo->ContextRecord,in_ctx);
                     return EXCEPTION_CONTINUE_EXECUTION;
@@ -216,9 +226,9 @@ static LONG WINAPI _exception_handler(struct _EXCEPTION_POINTERS *ExceptionInfo,
                 jl_safe_printf("UNKNOWN"); break;
         }
         jl_safe_printf(" at 0x%Ix -- ", (size_t)ExceptionInfo->ExceptionRecord->ExceptionAddress);
-        gdblookup((ptrint_t)ExceptionInfo->ExceptionRecord->ExceptionAddress);
-        bt_size = rec_backtrace_ctx(bt_data, MAX_BT_SIZE, ExceptionInfo->ContextRecord);
-        jlbacktrace();
+        jl_gdblookup((intptr_t)ExceptionInfo->ExceptionRecord->ExceptionAddress);
+
+        jl_critical_error(0, ExceptionInfo->ContextRecord, jl_bt_data, &jl_bt_size);
         static int recursion = 0;
         if (recursion++)
             exit(1);
@@ -256,7 +266,7 @@ EXCEPTION_DISPOSITION _seh_exception_handler(PEXCEPTION_RECORD ExceptionRecord,
 }
 #endif
 
-DLLEXPORT void jl_install_sigint_handler(void)
+JL_DLLEXPORT void jl_install_sigint_handler(void)
 {
     SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigint_handler,1);
 }
@@ -290,12 +300,13 @@ static DWORD WINAPI profile_bt( LPVOID lparam )
                 break;
             }
             // Get backtrace data
-            bt_size_cur += rec_backtrace_ctx((ptrint_t*)bt_data_prof+bt_size_cur, bt_size_max-bt_size_cur-1, &ctxThread);
+            bt_size_cur += rec_backtrace_ctx((intptr_t*)bt_data_prof+bt_size_cur, bt_size_max-bt_size_cur-1, &ctxThread);
             // Mark the end of this block with 0
             bt_data_prof[bt_size_cur] = 0;
             bt_size_cur++;
             if ((DWORD)-1 == ResumeThread(hMainThread)) {
                 fputs("failed to resume main thread! aborting.",stderr);
+                gc_debug_critical_error();
                 abort();
             }
         }
@@ -306,7 +317,7 @@ static DWORD WINAPI profile_bt( LPVOID lparam )
     hBtThread = 0;
     return 0;
 }
-DLLEXPORT int jl_profile_start_timer(void)
+JL_DLLEXPORT int jl_profile_start_timer(void)
 {
     running = 1;
     if (hBtThread == 0) {
@@ -327,16 +338,13 @@ DLLEXPORT int jl_profile_start_timer(void)
     }
     return (hBtThread != NULL ? 0 : -1);
 }
-DLLEXPORT void jl_profile_stop_timer(void)
+JL_DLLEXPORT void jl_profile_stop_timer(void)
 {
     running = 0;
 }
 
 void jl_install_default_signal_handlers(void)
 {
-    ULONG StackSizeInBytes = sig_stack_size;
-    if (uv_dlsym(jl_kernel32_handle, "SetThreadStackGuarantee", (void**)&pSetThreadStackGuarantee) || !pSetThreadStackGuarantee(&StackSizeInBytes))
-        pSetThreadStackGuarantee = NULL;
     if (signal(SIGFPE, (void (__cdecl *)(int))crt_sig_handler) == SIG_ERR) {
         jl_error("fatal error: Couldn't set SIGFPE");
     }
@@ -354,3 +362,15 @@ void jl_install_default_signal_handlers(void)
     }
     SetUnhandledExceptionFilter(exception_handler);
 }
+
+void *jl_install_thread_signal_handler(void)
+{
+    // Ensure the stack overflow handler has enough space to collect the backtrace
+    ULONG StackSizeInBytes = sig_stack_size;
+    if (pSetThreadStackGuarantee) {
+        if (!pSetThreadStackGuarantee(&StackSizeInBytes)) {
+            pSetThreadStackGuarantee = NULL;
+        }
+    }
+    return NULL;
+}
diff --git a/src/simplevector.c b/src/simplevector.c
index 3bad3726d42d8..16006831a2af5 100644
--- a/src/simplevector.c
+++ b/src/simplevector.c
@@ -7,20 +7,19 @@
 #include "julia.h"
 #include "julia_internal.h"
 
-DLLEXPORT jl_svec_t *jl_svec(size_t n, ...)
+JL_DLLEXPORT jl_svec_t *jl_svec(size_t n, ...)
 {
     va_list args;
     if (n == 0) return jl_emptysvec;
     va_start(args, n);
     jl_svec_t *jv = jl_alloc_svec_uninit(n);
-    for(size_t i=0; i < n; i++) {
+    for(size_t i=0; i < n; i++)
         jl_svecset(jv, i, va_arg(args, jl_value_t*));
-    }
     va_end(args);
     return jv;
 }
 
-jl_svec_t *jl_svec1(void *a)
+JL_DLLEXPORT jl_svec_t *jl_svec1(void *a)
 {
     jl_svec_t *v = (jl_svec_t*)jl_gc_alloc_2w();
     jl_set_typeof(v, jl_simplevector_type);
@@ -29,7 +28,7 @@ jl_svec_t *jl_svec1(void *a)
     return v;
 }
 
-jl_svec_t *jl_svec2(void *a, void *b)
+JL_DLLEXPORT jl_svec_t *jl_svec2(void *a, void *b)
 {
     jl_svec_t *v = (jl_svec_t*)jl_gc_alloc_3w();
     jl_set_typeof(v, jl_simplevector_type);
@@ -39,7 +38,7 @@ jl_svec_t *jl_svec2(void *a, void *b)
     return v;
 }
 
-jl_svec_t *jl_alloc_svec_uninit(size_t n)
+JL_DLLEXPORT jl_svec_t *jl_alloc_svec_uninit(size_t n)
 {
     if (n == 0) return jl_emptysvec;
     jl_svec_t *jv = (jl_svec_t*)newobj((jl_value_t*)jl_simplevector_type, n+1);
@@ -47,42 +46,29 @@ jl_svec_t *jl_alloc_svec_uninit(size_t n)
     return jv;
 }
 
-jl_svec_t *jl_alloc_svec(size_t n)
+JL_DLLEXPORT jl_svec_t *jl_alloc_svec(size_t n)
 {
     if (n == 0) return jl_emptysvec;
     jl_svec_t *jv = jl_alloc_svec_uninit(n);
-    for(size_t i=0; i < n; i++) {
+    for(size_t i=0; i < n; i++)
         jl_svecset(jv, i, NULL);
-    }
     return jv;
 }
 
-jl_svec_t *jl_svec_append(jl_svec_t *a, jl_svec_t *b)
+JL_DLLEXPORT jl_svec_t *jl_svec_copy(jl_svec_t *a)
 {
-    jl_svec_t *c = jl_alloc_svec_uninit(jl_svec_len(a) + jl_svec_len(b));
-    size_t i=0, j;
-    for(j=0; j < jl_svec_len(a); j++) {
-        jl_svecset(c, i, jl_svecref(a,j));
-        i++;
-    }
-    for(j=0; j < jl_svec_len(b); j++) {
-        jl_svecset(c, i, jl_svecref(b,j));
-        i++;
-    }
+    size_t i, n=jl_svec_len(a);
+    jl_svec_t *c = jl_alloc_svec_uninit(n);
+    for(i=0; i < n; i++)
+        jl_svecset(c, i, jl_svecref(a,i));
     return c;
 }
 
-jl_svec_t *jl_svec_copy(jl_svec_t *a)
-{
-    return jl_svec_append(a, jl_emptysvec);
-}
-
-jl_svec_t *jl_svec_fill(size_t n, jl_value_t *x)
+JL_DLLEXPORT jl_svec_t *jl_svec_fill(size_t n, jl_value_t *x)
 {
     if (n==0) return jl_emptysvec;
     jl_svec_t *v = jl_alloc_svec_uninit(n);
-    for(size_t i=0; i < n; i++) {
+    for(size_t i=0; i < n; i++)
         jl_svecset(v, i, x);
-    }
     return v;
 }
diff --git a/src/support/END.h b/src/support/END.h
index 84e0dc6ceb9ad..3f551aca5716d 100644
--- a/src/support/END.h
+++ b/src/support/END.h
@@ -29,7 +29,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	from: @(#)DEFS.h	5.1 (Berkeley) 4/23/90
+ *      from: @(#)DEFS.h        5.1 (Berkeley) 4/23/90
  * $FreeBSD: src/sys/i386/include/asm.h,v 1.14 2007/08/22 04:26:07 jkoshy Exp $
  */
 
diff --git a/src/support/ENTRY.amd64.h b/src/support/ENTRY.amd64.h
index a3419e8e8c286..4ad13fc421da4 100644
--- a/src/support/ENTRY.amd64.h
+++ b/src/support/ENTRY.amd64.h
@@ -29,7 +29,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	from: @(#)DEFS.h	5.1 (Berkeley) 4/23/90
+ *      from: @(#)DEFS.h        5.1 (Berkeley) 4/23/90
  * $FreeBSD: src/sys/amd64/include/asm.h,v 1.18 2007/08/22 04:26:07 jkoshy Exp $
  */
 
@@ -59,7 +59,8 @@ EXT(CNAME):
 _START_ENTRY
 .globl EXT(CNAME)
 .section .drectve
-.ascii " -export:" XSTR(CNAME)
+.ascii " -export:"
+.ascii XSTR(CNAME)
 .section .text
 .def EXT(CNAME)
 .scl 2
diff --git a/src/support/ENTRY.i387.h b/src/support/ENTRY.i387.h
index 6a808f728a1c1..109ea745034d5 100644
--- a/src/support/ENTRY.i387.h
+++ b/src/support/ENTRY.i387.h
@@ -29,7 +29,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	from: @(#)DEFS.h	5.1 (Berkeley) 4/23/90
+ *      from: @(#)DEFS.h        5.1 (Berkeley) 4/23/90
  * $FreeBSD: src/sys/i386/include/asm.h,v 1.14 2007/08/22 04:26:07 jkoshy Exp $
  */
 
diff --git a/src/support/Makefile b/src/support/Makefile
index 382377e62aa5e..b20c27540dfd0 100644
--- a/src/support/Makefile
+++ b/src/support/Makefile
@@ -1,17 +1,15 @@
-JULIAHOME = $(abspath ../..)
+JULIAHOME := $(abspath ../..)
+BUILDDIR := .
 include $(JULIAHOME)/Make.inc
 
 override CFLAGS += $(JCFLAGS)
 override CXXFLAGS += $(JCXXFLAGS)
 override CPPFLAGS += $(JCPPFLAGS)
 
-BUILDDIR ?= .
-
-SRCS = hashing timefuncs ptrhash operators \
-	utf8 ios htable bitvector \
+SRCS := hashing timefuncs ptrhash operators utf8 ios htable bitvector \
 	int2str libsupportinit arraylist strtod
 ifeq ($(OS),WINNT)
-SRCS += asprintf wsasocketpair
+SRCS += asprintf wsasocketpair strptime
 ifeq ($(ARCH),i686)
 SRCS += _setjmp.win32 _longjmp.win32
 else ifeq ($(ARCH),i386)
@@ -20,15 +18,19 @@ else ifeq ($(ARCH),x86_64)
 SRCS += _setjmp.win64 _longjmp.win64
 endif
 endif
+ifeq ($(USEMSVC), 1)
+SRCS += dirname
+endif
 
-HEADERS = $(wildcard *.h) $(LIBUV_INC)/uv.h
+HEADERS := $(wildcard *.h) $(LIBUV_INC)/uv.h
 
-OBJS = $(SRCS:%=$(BUILDDIR)/%.o)
-DOBJS = $(SRCS:%=$(BUILDDIR)/%.dbg.obj)
+OBJS := $(SRCS:%=$(BUILDDIR)/%.o)
+DOBJS := $(SRCS:%=$(BUILDDIR)/%.dbg.obj)
 
-FLAGS = $(CFLAGS) $(HFILEDIRS:%=-I%) -I$(LIBUV_INC) -I$(UTF8PROC_INC) -DLIBRARY_EXPORTS -DUTF8PROC_EXPORTS
+FLAGS := $(HFILEDIRS:%=-I%) -I$(LIBUV_INC) -I$(UTF8PROC_INC) -DLIBRARY_EXPORTS -DUTF8PROC_EXPORTS
 ifneq ($(USEMSVC), 1)
-FLAGS += -Wall -Wno-strict-aliasing -fvisibility=hidden
+FLAGS += -Wall -Wno-strict-aliasing -fvisibility=hidden -Wpointer-arith -Wundef
+override CFLAGS += -Wold-style-definition -Wstrict-prototypes -Wc++-compat
 endif
 
 DEBUGFLAGS += $(FLAGS)
@@ -37,12 +39,12 @@ SHIPFLAGS += $(FLAGS)
 default: release
 
 $(BUILDDIR):
-	mkdir $(BUILDDIR)
+	mkdir -p $(BUILDDIR)
 
 $(BUILDDIR)/%.o: %.c $(HEADERS) | $(BUILDDIR)
-	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(SHIPFLAGS) $(DISABLE_ASSERTIONS) -c $< -o $@)
+	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(SHIPFLAGS) $(DISABLE_ASSERTIONS) -c $< -o $@)
 $(BUILDDIR)/%.dbg.obj: %.c $(HEADERS) | $(BUILDDIR)
-	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(DEBUGFLAGS) -c $< -o $@)
+	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(DEBUGFLAGS) -c $< -o $@)
 ifneq ($(USEMSVC), 1)
 $(BUILDDIR)/%.o: %.S | $(BUILDDIR)
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(SHIPFLAGS) -c $< -o $@)
diff --git a/src/support/Windows.mk b/src/support/Windows.mk
index 7fc2dd42c50f0..5bfaf9f48f483 100644
--- a/src/support/Windows.mk
+++ b/src/support/Windows.mk
@@ -34,7 +34,8 @@ OBJECTS = \
 	int2str.obj \
 	libsupportinit.obj \
 	arraylist.obj \
-	asprintf.obj
+	asprintf.obj \
+	dirname.obj
 
 INCLUDE = $(INCLUDE);$(MAKEDIR)\..\..\deps\libuv\include
 CFLAGS = $(CFLAGS) -D_CRT_SECURE_NO_WARNINGS -DLIBRARY_EXPORTS
diff --git a/src/support/bitvector.c b/src/support/bitvector.c
index 009c2d931802d..046216b5aca00 100644
--- a/src/support/bitvector.c
+++ b/src/support/bitvector.c
@@ -19,12 +19,12 @@
 extern "C" {
 #endif
 
-u_int32_t *bitvector_resize(u_int32_t *b, uint64_t oldsz, uint64_t newsz,
+uint32_t *bitvector_resize(uint32_t *b, uint64_t oldsz, uint64_t newsz,
                             int initzero)
 {
-    u_int32_t *p;
+    uint32_t *p;
     size_t sz = ((newsz+31)>>5) * sizeof(uint32_t);
-    p = (u_int32_t*)LLT_REALLOC(b, sz);
+    p = (uint32_t*)LLT_REALLOC(b, sz);
     if (p == NULL) return NULL;
     if (initzero && newsz>oldsz) {
         size_t osz = ((oldsz+31)>>5) * sizeof(uint32_t);
@@ -33,17 +33,17 @@ u_int32_t *bitvector_resize(u_int32_t *b, uint64_t oldsz, uint64_t newsz,
     return p;
 }
 
-u_int32_t *bitvector_new(u_int64_t n, int initzero)
+uint32_t *bitvector_new(uint64_t n, int initzero)
 {
     return bitvector_resize(NULL, 0, n, initzero);
 }
 
-size_t bitvector_nwords(u_int64_t nbits)
+size_t bitvector_nwords(uint64_t nbits)
 {
     return ((nbits+31)>>5);
 }
 
-void bitvector_set(u_int32_t *b, u_int64_t n, u_int32_t c)
+void bitvector_set(uint32_t *b, uint64_t n, uint32_t c)
 {
     if (c)
         b[n>>5] |= (1<<(n&31));
@@ -51,19 +51,19 @@ void bitvector_set(u_int32_t *b, u_int64_t n, u_int32_t c)
         b[n>>5] &= ~(1<<(n&31));
 }
 
-u_int32_t bitvector_get(u_int32_t *b, u_int64_t n)
+uint32_t bitvector_get(uint32_t *b, uint64_t n)
 {
     return b[n>>5] & (1<<(n&31));
 }
 
 // a mask with n set lo or hi bits
-#define lomask(n) (u_int32_t)((((u_int32_t)1)<<(n))-1)
-#define ONES32 ((u_int32_t)0xffffffff)
+#define lomask(n) (uint32_t)((((uint32_t)1)<<(n))-1)
+#define ONES32 ((uint32_t)0xffffffff)
 
 #if defined(__INTEL_COMPILER) && !defined(__clang__)
 #define count_bits(b) _popcnt32(b)
 #else
-STATIC_INLINE u_int32_t count_bits(u_int32_t b)
+STATIC_INLINE uint32_t count_bits(uint32_t b)
 {
     b = b - ((b>>1)&0x55555555);
     b = ((b>>2)&0x33333333) + (b&0x33333333);
@@ -134,11 +134,11 @@ uint64_t bitvector_next(uint32_t *b, uint64_t n0, uint64_t n)
     return i + (n-nb);
 }
 
-u_int64_t bitvector_count(u_int32_t *b, u_int64_t offs, u_int64_t nbits)
+uint64_t bitvector_count(uint32_t *b, uint64_t offs, uint64_t nbits)
 {
     size_t i, nw;
-    u_int32_t ntail;
-    u_int64_t ans;
+    uint32_t ntail;
+    uint64_t ans;
 
     if (nbits == 0) return 0;
     nw = (offs+nbits+31)>>5;
@@ -161,11 +161,11 @@ u_int64_t bitvector_count(u_int32_t *b, u_int64_t offs, u_int64_t nbits)
     return ans;
 }
 
-u_int32_t bitvector_any1(u_int32_t *b, u_int64_t offs, u_int64_t nbits)
+uint32_t bitvector_any1(uint32_t *b, uint64_t offs, uint64_t nbits)
 {
-    index_t i;
-    u_int32_t nw, tail;
-    u_int32_t mask;
+    size_t i;
+    uint32_t nw, tail;
+    uint32_t mask;
 
     if (nbits == 0) return 0;
     nw = (offs+nbits+31)>>5;
diff --git a/src/support/bitvector.h b/src/support/bitvector.h
index f670460d0e47a..36dda22277493 100644
--- a/src/support/bitvector.h
+++ b/src/support/bitvector.h
@@ -7,20 +7,20 @@
 extern "C" {
 #endif
 
-DLLEXPORT u_int32_t *bitvector_new(u_int64_t n, int initzero);
-DLLEXPORT
-u_int32_t *bitvector_resize(u_int32_t *b, uint64_t oldsz, uint64_t newsz,
-                            int initzero);
-size_t bitvector_nwords(u_int64_t nbits);
-DLLEXPORT void bitvector_set(u_int32_t *b, u_int64_t n, u_int32_t c);
-DLLEXPORT u_int32_t bitvector_get(u_int32_t *b, u_int64_t n);
+JL_DLLEXPORT uint32_t *bitvector_new(uint64_t n, int initzero);
+JL_DLLEXPORT
+uint32_t *bitvector_resize(uint32_t *b, uint64_t oldsz, uint64_t newsz,
+                           int initzero);
+size_t bitvector_nwords(uint64_t nbits);
+JL_DLLEXPORT void bitvector_set(uint32_t *b, uint64_t n, uint32_t c);
+JL_DLLEXPORT uint32_t bitvector_get(uint32_t *b, uint64_t n);
 
-DLLEXPORT uint64_t bitvector_next(uint32_t *b, uint64_t n0, uint64_t n);
+JL_DLLEXPORT uint64_t bitvector_next(uint32_t *b, uint64_t n0, uint64_t n);
 
-DLLEXPORT
-u_int64_t bitvector_count(u_int32_t *b, u_int64_t offs, u_int64_t nbits);
-DLLEXPORT
-u_int32_t bitvector_any1(u_int32_t *b, u_int64_t offs, u_int64_t nbits);
+JL_DLLEXPORT
+uint64_t bitvector_count(uint32_t *b, uint64_t offs, uint64_t nbits);
+JL_DLLEXPORT
+uint32_t bitvector_any1(uint32_t *b, uint64_t offs, uint64_t nbits);
 
 #ifdef __cplusplus
 }
diff --git a/src/flisp/dirname.c b/src/support/dirname.c
similarity index 97%
rename from src/flisp/dirname.c
rename to src/support/dirname.c
index c6bd70ca54d14..520055df28bcb 100644
--- a/src/flisp/dirname.c
+++ b/src/support/dirname.c
@@ -39,10 +39,14 @@
 extern "C" {
 #endif
 
-DLLEXPORT char *dirname( char *path )
+JL_DLLEXPORT char *dirname( char *path )
 {
     size_t len;
-    static char *retfail = NULL;
+#  if !defined(_COMPILER_MICROSOFT_)
+    static __thread char *retfail = NULL;
+#  else
+    static __declspec(thread) char *retfail = NULL;
+#  endif
 
     /* to handle path names for files in multibyte character locales,
      * we need to set up LC_CTYPE to match the host file system locale.
diff --git a/src/support/dirpath.h b/src/support/dirpath.h
index f02634591bfca..782bf8adf9a1b 100644
--- a/src/support/dirpath.h
+++ b/src/support/dirpath.h
@@ -6,7 +6,7 @@
 #ifdef _OS_WINDOWS_
 #define PATHSEPSTRING "\\"
 #define PATHLISTSEPSTRING ";"
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(_COMPILER_CLANG_)
 #define PATH_MAX MAX_PATH
 #endif
 #else
diff --git a/src/support/dtypes.h b/src/support/dtypes.h
index 4568315557038..9cb3a4b5150d7 100644
--- a/src/support/dtypes.h
+++ b/src/support/dtypes.h
@@ -60,13 +60,13 @@
 #ifdef _OS_WINDOWS_
 #define STDCALL __stdcall
 # ifdef LIBRARY_EXPORTS
-#  define DLLEXPORT __declspec(dllexport)
+#  define JL_DLLEXPORT __declspec(dllexport)
 # else
-#  define DLLEXPORT __declspec(dllimport)
+#  define JL_DLLEXPORT __declspec(dllimport)
 # endif
 #else
 #define STDCALL
-#define DLLEXPORT __attribute__ ((visibility("default")))
+#define JL_DLLEXPORT __attribute__ ((visibility("default")))
 #endif
 
 #ifdef _OS_LINUX_
@@ -97,23 +97,6 @@
 #define BYTE_ORDER         __BYTE_ORDER
 #endif
 
-#if (__STDC_VERSION__ >= 199901L) || defined(__GNUG__)
-// argument counting macros for C99
-#define VA_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9,_10,  \
-                 _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
-                 _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
-                 _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
-                 _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
-                 _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
-                 _61,_62,_63,N,...) N
-#define VA_RSEQ_N() 63,62,61,60,59,58,57,56,55,54,53,52,51,50, \
-                    49,48,47,46,45,44,43,42,41,40,39,38,37,36, \
-                    35,34,33,32,31,30,29,28,27,26,25,24,23,22, \
-                    21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
-#define VA_NARG_(...) VA_ARG_N(__VA_ARGS__)
-#define VA_NARG(...) VA_NARG_(__VA_ARGS__,VA_RSEQ_N())
-#endif
-
 #define LLT_ALLOC(n) malloc(n)
 #define LLT_REALLOC(p,n) realloc((p),(n))
 #define LLT_FREE(x) free(x)
@@ -137,6 +120,18 @@
 #  define NOINLINE_DECL(f) f __attribute__((noinline))
 #endif
 
+#ifdef _COMPILER_MICROSOFT_
+# ifdef _P64
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) __declspec(align(8)) x
+# else
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) __declspec(align(4)) x
+# endif
+#elif defined(__GNUC__)
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x) x __attribute__ ((aligned (sizeof(void*))))
+#else
+#  define JL_ATTRIBUTE_ALIGN_PTRSIZE(x)
+#endif
+
 typedef int bool_t;
 typedef unsigned char  byte_t;   /* 1 byte */
 
@@ -151,16 +146,6 @@ typedef int64_t int_t;
 typedef uint32_t uint_t;
 typedef int32_t int_t;
 #endif
-typedef ptrdiff_t ptrint_t; // pointer-size int
-typedef size_t uptrint_t;
-typedef ptrdiff_t offset_t;
-typedef size_t index_t;
-
-typedef uint8_t  u_int8_t;
-typedef uint16_t u_int16_t;
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
-typedef uptrint_t u_ptrint_t;
 
 #define LLT_ALIGN(x, sz) (((x) + (sz-1)) & (-sz))
 
diff --git a/src/support/hashing.c b/src/support/hashing.c
index 6535dfa4d055b..7a48b710c3ad8 100644
--- a/src/support/hashing.c
+++ b/src/support/hashing.c
@@ -27,7 +27,7 @@ uint_t nextipow2(uint_t i)
     return i<<1;
 }
 
-u_int32_t int32hash(u_int32_t a)
+uint32_t int32hash(uint32_t a)
 {
     a = (a+0x7ed55d16) + (a<<12);
     a = (a^0xc761c23c) ^ (a>>19);
@@ -38,7 +38,7 @@ u_int32_t int32hash(u_int32_t a)
     return a;
 }
 
-u_int64_t int64hash(u_int64_t key)
+uint64_t int64hash(uint64_t key)
 {
     key = (~key) + (key << 21);            // key = (key << 21) - key - 1;
     key =   key  ^ (key >> 24);
@@ -50,7 +50,7 @@ u_int64_t int64hash(u_int64_t key)
     return key;
 }
 
-u_int32_t int64to32hash(u_int64_t key)
+uint32_t int64to32hash(uint64_t key)
 {
     key = (~key) + (key << 18); // key = (key << 18) - key - 1;
     key =   key  ^ (key >> 31);
@@ -58,7 +58,7 @@ u_int32_t int64to32hash(u_int64_t key)
     key = key ^ (key >> 11);
     key = key + (key << 6);
     key = key ^ (key >> 22);
-    return (u_int32_t)key;
+    return (uint32_t)key;
 }
 
 #include "MurmurHash3.c"
diff --git a/src/support/hashing.h b/src/support/hashing.h
index 539c8dcb29796..99ff397b91c18 100644
--- a/src/support/hashing.h
+++ b/src/support/hashing.h
@@ -8,18 +8,18 @@ extern "C" {
 #endif
 
 uint_t nextipow2(uint_t i);
-DLLEXPORT u_int32_t int32hash(u_int32_t a);
-DLLEXPORT u_int64_t int64hash(u_int64_t key);
-DLLEXPORT u_int32_t int64to32hash(u_int64_t key);
+JL_DLLEXPORT uint32_t int32hash(uint32_t a);
+JL_DLLEXPORT uint64_t int64hash(uint64_t key);
+JL_DLLEXPORT uint32_t int64to32hash(uint64_t key);
 #ifdef _P64
 #define inthash int64hash
 #else
 #define inthash int32hash
 #endif
-DLLEXPORT u_int64_t memhash(const char *buf, size_t n);
-DLLEXPORT u_int64_t memhash_seed(const char *buf, size_t n, u_int32_t seed);
-DLLEXPORT u_int32_t memhash32(const char *buf, size_t n);
-DLLEXPORT u_int32_t memhash32_seed(const char *buf, size_t n, u_int32_t seed);
+JL_DLLEXPORT uint64_t memhash(const char *buf, size_t n);
+JL_DLLEXPORT uint64_t memhash_seed(const char *buf, size_t n, uint32_t seed);
+JL_DLLEXPORT uint32_t memhash32(const char *buf, size_t n);
+JL_DLLEXPORT uint32_t memhash32_seed(const char *buf, size_t n, uint32_t seed);
 
 #ifdef __cplusplus
 }
diff --git a/src/support/htable.h b/src/support/htable.h
index 5d0095ef9d3cf..eb5bfd259a684 100644
--- a/src/support/htable.h
+++ b/src/support/htable.h
@@ -33,6 +33,14 @@ int HTNAME##_has(htable_t *h, void *key);                       \
 int HTNAME##_remove(htable_t *h, void *key);                    \
 void **HTNAME##_bp(htable_t *h, void *key);
 
+#define HTPROT_R(HTNAME)                                                \
+void *HTNAME##_get_r(htable_t *h, void *key, void *ctx);                \
+void HTNAME##_put_r(htable_t *h, void *key, void *val, void *ctx);      \
+void HTNAME##_adjoin_r(htable_t *h, void *key, void *val, void *ctx);   \
+int HTNAME##_has_r(htable_t *h, void *key, void *ctx);                  \
+int HTNAME##_remove_r(htable_t *h, void *key, void *ctx);               \
+void **HTNAME##_bp_r(htable_t *h, void *key, void *ctx);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/support/htable.inc b/src/support/htable.inc
index dfac596597275..3e504672162df 100644
--- a/src/support/htable.inc
+++ b/src/support/htable.inc
@@ -9,8 +9,8 @@
 // compute empirical max-probe for a given size
 #define max_probe(size) ((size)<=(HT_N_INLINE*2) ? (HT_N_INLINE/2) : (size)>>3)
 
-#define HTIMPL(HTNAME, HFUNC, EQFUNC)                                   \
-static void **HTNAME##_lookup_bp(htable_t *h, void *key)                \
+#define _HTIMPL_EX(HTNAME, HFUNC, EQFUNC, _STATIC)                      \
+static void **HTNAME##_lookup_bp_r(htable_t *h, void *key, void *ctx)   \
 {                                                                       \
     uint_t hv;                                                          \
     size_t i, orig, index, iter;                                        \
@@ -19,10 +19,10 @@ static void **HTNAME##_lookup_bp(htable_t *h, void *key)                \
     void **tab = h->table;                                              \
     void **ol;                                                          \
                                                                         \
-    hv = HFUNC((uptrint_t)key);                                         \
+    hv = HFUNC((uintptr_t)key, ctx);                                    \
  retry_bp:                                                              \
     iter = 0;                                                           \
-    index = (index_t)(hv & (sz-1)) * 2;                                 \
+    index = (size_t)(hv & (sz-1)) * 2;                                  \
     sz *= 2;                                                            \
     orig = index;                                                       \
                                                                         \
@@ -32,7 +32,7 @@ static void **HTNAME##_lookup_bp(htable_t *h, void *key)                \
             return &tab[index+1];                                       \
         }                                                               \
                                                                         \
-        if (EQFUNC(key, tab[index]))                                    \
+        if (EQFUNC(key, tab[index], ctx))                               \
             return &tab[index+1];                                       \
                                                                         \
         index = (index+2) & (sz-1);                                     \
@@ -63,7 +63,7 @@ static void **HTNAME##_lookup_bp(htable_t *h, void *key)                \
     h->size = newsz;                                                    \
     for(i=0; i < sz; i+=2) {                                            \
         if (ol[i+1] != HT_NOTFOUND) {                                   \
-            (*HTNAME##_lookup_bp(h, ol[i])) = ol[i+1];                  \
+            (*HTNAME##_lookup_bp_r(h, ol[i], ctx)) = ol[i+1];           \
         }                                                               \
     }                                                                   \
     if (ol != &h->_space[0])                                            \
@@ -78,26 +78,26 @@ static void **HTNAME##_lookup_bp(htable_t *h, void *key)                \
     return NULL;                                                        \
 }                                                                       \
                                                                         \
-void HTNAME##_put(htable_t *h, void *key, void *val)                    \
+_STATIC void HTNAME##_put_r(htable_t *h, void *key, void *val, void *ctx) \
 {                                                                       \
-    void **bp = HTNAME##_lookup_bp(h, key);                             \
+    void **bp = HTNAME##_lookup_bp_r(h, key, ctx);                      \
                                                                         \
     *bp = val;                                                          \
 }                                                                       \
                                                                         \
-void **HTNAME##_bp(htable_t *h, void *key)                              \
+_STATIC void **HTNAME##_bp_r(htable_t *h, void *key, void *ctx)         \
 {                                                                       \
-    return HTNAME##_lookup_bp(h, key);                                  \
+    return HTNAME##_lookup_bp_r(h, key, ctx);                           \
 }                                                                       \
                                                                         \
 /* returns bp if key is in hash, otherwise NULL */                      \
 /* if return is non-NULL and *bp == HT_NOTFOUND then key was deleted */ \
-static void **HTNAME##_peek_bp(htable_t *h, void *key)                  \
+static void **HTNAME##_peek_bp_r(htable_t *h, void *key, void *ctx)     \
 {                                                                       \
     size_t sz = hash_size(h);                                           \
     size_t maxprobe = max_probe(sz);                                    \
     void **tab = h->table;                                              \
-    size_t index = (index_t)(HFUNC((uptrint_t)key) & (sz-1)) * 2;       \
+    size_t index = (size_t)(HFUNC((uintptr_t)key, ctx) & (sz-1)) * 2;   \
     sz *= 2;                                                            \
     size_t orig = index;                                                \
     size_t iter = 0;                                                    \
@@ -105,7 +105,7 @@ static void **HTNAME##_peek_bp(htable_t *h, void *key)                  \
     do {                                                                \
         if (tab[index] == HT_NOTFOUND)                                  \
             return NULL;                                                \
-        if (EQFUNC(key, tab[index]))                                    \
+        if (EQFUNC(key, tab[index], ctx))                               \
             return &tab[index+1];                                       \
                                                                         \
         index = (index+2) & (sz-1);                                     \
@@ -117,22 +117,22 @@ static void **HTNAME##_peek_bp(htable_t *h, void *key)                  \
     return NULL;                                                        \
 }                                                                       \
                                                                         \
-void *HTNAME##_get(htable_t *h, void *key)                              \
+_STATIC void *HTNAME##_get_r(htable_t *h, void *key, void *ctx)         \
 {                                                                       \
-    void **bp = HTNAME##_peek_bp(h, key);                               \
+    void **bp = HTNAME##_peek_bp_r(h, key, ctx);                        \
     if (bp == NULL)                                                     \
         return HT_NOTFOUND;                                             \
     return *bp;                                                         \
 }                                                                       \
                                                                         \
-int HTNAME##_has(htable_t *h, void *key)                                \
+_STATIC int HTNAME##_has_r(htable_t *h, void *key, void *ctx)           \
 {                                                                       \
-    return (HTNAME##_get(h,key) != HT_NOTFOUND);                        \
+    return (HTNAME##_get_r(h, key, ctx) != HT_NOTFOUND);                \
 }                                                                       \
                                                                         \
-int HTNAME##_remove(htable_t *h, void *key)                             \
+_STATIC int HTNAME##_remove_r(htable_t *h, void *key, void *ctx)        \
 {                                                                       \
-    void **bp = HTNAME##_peek_bp(h, key);                               \
+    void **bp = HTNAME##_peek_bp_r(h, key, ctx);                        \
     if (bp != NULL) {                                                   \
         *bp = HT_NOTFOUND;                                              \
         return 1;                                                       \
@@ -140,9 +140,56 @@ int HTNAME##_remove(htable_t *h, void *key)                             \
     return 0;                                                           \
 }                                                                       \
                                                                         \
-void HTNAME##_adjoin(htable_t *h, void *key, void *val)                 \
+_STATIC void HTNAME##_adjoin_r(htable_t *h, void *key, void *val, void *ctx) \
 {                                                                       \
-    void **bp = HTNAME##_lookup_bp(h, key);                             \
+    void **bp = HTNAME##_lookup_bp_r(h, key, ctx);                      \
     if (*bp == HT_NOTFOUND)                                             \
         *bp = val;                                                      \
 }
+
+#define HTIMPL(HTNAME, HFUNC, EQFUNC)                                   \
+static uint_t HTNAME##_hfunc_wrapper(uintptr_t key, void *ctx)          \
+{                                                                       \
+    (void)ctx;                                                          \
+    return HFUNC(key);                                                  \
+}                                                                       \
+                                                                        \
+static uint_t HTNAME##_eqfunc_wrapper(void *key1, void *key2, void *ctx) \
+{                                                                       \
+    (void)ctx;                                                          \
+    return EQFUNC(key1, key2);                                          \
+}                                                                       \
+                                                                        \
+_HTIMPL_EX(HTNAME, HTNAME##_hfunc_wrapper, HTNAME##_eqfunc_wrapper, static) \
+                                                                        \
+void HTNAME##_put(htable_t *h, void *key, void *val)                    \
+{                                                                       \
+    HTNAME##_put_r(h, key, val, NULL);                                  \
+}                                                                       \
+                                                                        \
+void **HTNAME##_bp(htable_t *h, void *key)                              \
+{                                                                       \
+    return HTNAME##_bp_r(h, key, NULL);                                 \
+}                                                                       \
+                                                                        \
+void *HTNAME##_get(htable_t *h, void *key)                              \
+{                                                                       \
+    return HTNAME##_get_r(h, key, NULL);                                \
+}                                                                       \
+                                                                        \
+int HTNAME##_has(htable_t *h, void *key)                                \
+{                                                                       \
+    return HTNAME##_has_r(h, key, NULL);                                \
+}                                                                       \
+                                                                        \
+int HTNAME##_remove(htable_t *h, void *key)                             \
+{                                                                       \
+    return HTNAME##_remove_r(h, key, NULL);                             \
+}                                                                       \
+                                                                        \
+void HTNAME##_adjoin(htable_t *h, void *key, void *val)                 \
+{                                                                       \
+    return HTNAME##_adjoin_r(h, key, val, NULL);                        \
+}
+
+#define HTIMPL_R(HTNAME, HFUNC, EQFUNC) _HTIMPL_EX(HTNAME, HFUNC, EQFUNC, )
diff --git a/src/support/ios.c b/src/support/ios.c
index 889e8f661d1c2..e2ed4abc8a08a 100644
--- a/src/support/ios.c
+++ b/src/support/ios.c
@@ -39,7 +39,7 @@ extern "C" {
 /* OS-level primitive wrappers */
 
 #if defined(__APPLE__) || defined(_OS_WINDOWS_)
-DLLEXPORT void *memrchr(const void *s, int c, size_t n)
+JL_DLLEXPORT void *memrchr(const void *s, int c, size_t n)
 {
     const unsigned char *src = (unsigned char*)s + n;
     unsigned char uc = c;
@@ -191,7 +191,7 @@ static char *_buf_realloc(ios_t *s, size_t sz)
             return NULL;
         s->ownbuf = 1;
         if (s->size > 0)
-            memcpy(temp, s->buf, s->size);
+            memcpy(temp, s->buf, (size_t)s->size);
     }
 
     s->buf = temp;
@@ -213,12 +213,12 @@ static size_t _write_grow(ios_t *s, const char *data, size_t n)
         if (s->bpos + n > s->maxsize) {
             /* TODO: here you might want to add a mechanism for limiting
                the growth of the stream. */
-            newsize = s->maxsize ? s->maxsize * 2 : 8;
+            newsize = (size_t)(s->maxsize ? s->maxsize * 2 : 8);
             while (s->bpos + n > newsize)
                 newsize *= 2;
             if (_buf_realloc(s, newsize) == NULL) {
                 /* no more space; write as much as we can */
-                amt = s->maxsize - s->bpos;
+                amt = (size_t)(s->maxsize - s->bpos);
                 if (amt > 0) {
                     memcpy(&s->buf[s->bpos], data, amt);
                 }
@@ -250,7 +250,7 @@ static size_t _ios_read(ios_t *s, char *dest, size_t n, int all)
     s->state = bst_rd;
 
     while (n > 0) {
-        avail = s->size - s->bpos;
+        avail = (size_t)(s->size - s->bpos);
 
         if (avail > 0) {
             size_t ncopy = (avail >= n) ? n : avail;
@@ -292,7 +292,7 @@ static size_t _ios_read(ios_t *s, char *dest, size_t n, int all)
         }
         else {
             // refill buffer
-            if (_os_read(s->fd, s->buf, s->maxsize, &got)) {
+            if (_os_read(s->fd, s->buf, (size_t)s->maxsize, &got)) {
                 s->_eof = 1;
                 return tot;
             }
@@ -324,7 +324,7 @@ size_t ios_readprep(ios_t *s, size_t n)
         ios_flush(s);
         s->bpos = s->size = 0;
     }
-    size_t space = s->size - s->bpos;
+    size_t space = (size_t)(s->size - s->bpos);
     s->state = bst_rd;
     if (space >= n || s->bm == bm_mem || s->fd == -1)
         return space;
@@ -337,17 +337,17 @@ size_t ios_readprep(ios_t *s, size_t n)
             s->bpos = 0;
         }
         else {
-            if (_buf_realloc(s, s->bpos + n)==NULL)
+            if (_buf_realloc(s, (size_t)(s->bpos + n))==NULL)
                 return space;
         }
     }
     size_t got;
     s->fpos = -1;
-    int result = _os_read(s->fd, s->buf+s->size, s->maxsize - s->size, &got);
+    int result = _os_read(s->fd, s->buf+s->size, (size_t)(s->maxsize - s->size), &got);
     if (result)
         return space;
     s->size += got;
-    return s->size - s->bpos;
+    return (size_t)(s->size - s->bpos);
 }
 
 static void _write_update_pos(ios_t *s)
@@ -357,10 +357,10 @@ static void _write_update_pos(ios_t *s)
 }
 
 // directly copy a buffer to a descriptor
-DLLEXPORT size_t ios_write_direct(ios_t *dest, ios_t *src)
+JL_DLLEXPORT size_t ios_write_direct(ios_t *dest, ios_t *src)
 {
     char *data = src->buf;
-    size_t n = src->size;
+    size_t n = (size_t)src->size;
     size_t nwr;
     dest->fpos = -1;
     _os_write_all(dest->fd, data, n, &nwr);
@@ -378,7 +378,7 @@ size_t ios_write(ios_t *s, const char *data, size_t n)
         ios_seek(s, ios_pos(s));
     }
     s->state = bst_wr;
-    space = s->maxsize - s->bpos;
+    space = (size_t)(s->maxsize - s->bpos);
 
     if (s->bm == bm_mem) {
         wrote = _write_grow(s, data, n);
@@ -420,18 +420,18 @@ size_t ios_write(ios_t *s, const char *data, size_t n)
 // Returns 0 on success,
 //        -1 on error which set errno, and
 //        -2 on error which doesn't set errno.
-off_t ios_seek(ios_t *s, off_t pos)
+int64_t ios_seek(ios_t *s, int64_t pos)
 {
     s->_eof = 0;
     if (s->bm == bm_mem) {
-        if ((size_t)pos > s->size)
+        if (pos < 0 || pos > s->size)
             return -2;
         s->bpos = pos;
     }
     else {
         ios_flush(s);
-        off_t fdpos = lseek(s->fd, pos, SEEK_SET);
-        if (fdpos == (off_t)-1)
+        int64_t fdpos = lseek(s->fd, (off_t)pos, SEEK_SET);
+        if (fdpos == (int64_t)-1)
             return fdpos;
         s->fpos = fdpos;
         s->bpos = s->size = 0;
@@ -439,7 +439,7 @@ off_t ios_seek(ios_t *s, off_t pos)
     return 0;
 }
 
-off_t ios_seek_end(ios_t *s)
+int64_t ios_seek_end(ios_t *s)
 {
     s->_eof = 1;
     if (s->bm == bm_mem) {
@@ -447,8 +447,8 @@ off_t ios_seek_end(ios_t *s)
     }
     else {
         ios_flush(s);
-        off_t fdpos = lseek(s->fd, 0, SEEK_END);
-        if (fdpos == (off_t)-1)
+        int64_t fdpos = lseek(s->fd, 0, SEEK_END);
+        if (fdpos == (int64_t)-1)
             return fdpos;
         s->fpos = fdpos;
         s->bpos = s->size = 0;
@@ -459,11 +459,11 @@ off_t ios_seek_end(ios_t *s)
 // Returns 0 on success,
 //        -1 on error which set errno, and
 //        -2 on error which doesn't set errno.
-off_t ios_skip(ios_t *s, off_t offs)
+int64_t ios_skip(ios_t *s, int64_t offs)
 {
     if (offs != 0) {
         if (offs > 0) {
-            if (offs <= (off_t)(s->size-s->bpos)) {
+            if (offs <= (s->size - s->bpos)) {
                 s->bpos += offs;
                 return 0;
             }
@@ -473,7 +473,7 @@ off_t ios_skip(ios_t *s, off_t offs)
             }
         }
         else if (offs < 0) {
-            if (-offs <= (off_t)s->bpos) {
+            if (-offs <= (int64_t)s->bpos) {
                 s->bpos += offs;
                 s->_eof = 0;
                 return 0;
@@ -487,8 +487,8 @@ off_t ios_skip(ios_t *s, off_t offs)
             offs += s->bpos;
         else if (s->state == bst_rd)
             offs -= (s->size - s->bpos);
-        off_t fdpos = lseek(s->fd, offs, SEEK_CUR);
-        if (fdpos == (off_t)-1)
+        int64_t fdpos = lseek(s->fd, (off_t)offs, SEEK_CUR);
+        if (fdpos == (int64_t)-1)
             return fdpos;
         s->fpos = fdpos;
         s->bpos = s->size = 0;
@@ -497,15 +497,15 @@ off_t ios_skip(ios_t *s, off_t offs)
     return 0;
 }
 
-off_t ios_pos(ios_t *s)
+int64_t ios_pos(ios_t *s)
 {
     if (s->bm == bm_mem)
-        return (off_t)s->bpos;
+        return s->bpos;
 
-    off_t fdpos = s->fpos;
-    if (fdpos == (off_t)-1) {
+    int64_t fdpos = s->fpos;
+    if (fdpos == (int64_t)-1) {
         fdpos = lseek(s->fd, 0, SEEK_CUR);
-        if (fdpos == (off_t)-1)
+        if (fdpos == (int64_t)-1)
             return fdpos;
         s->fpos = fdpos;
     }
@@ -540,7 +540,7 @@ int ios_trunc(ios_t *s, size_t size)
     else {
         ios_flush(s);
         if (s->state == bst_rd) {
-            off_t p = ios_pos(s);
+            int64_t p = ios_pos(s);
             if (size < p + (s->size - s->bpos))
                 s->size -= (p + (s->size - s->bpos) - size);
         }
@@ -605,18 +605,18 @@ int ios_flush(ios_t *s)
     // todo: try recovering from some kinds of errors (e.g. retry)
 
     if (s->state == bst_rd) {
-        if (lseek(s->fd, s->size - nw, SEEK_CUR) == (off_t)-1) {
+        if (lseek(s->fd, (off_t)(s->size - nw), SEEK_CUR) == (off_t)-1) {
         }
     }
     else if (s->state == bst_wr) {
         if (s->bpos != nw &&
-            lseek(s->fd, (off_t)s->bpos - (off_t)nw, SEEK_CUR) == (off_t)-1) {
+            lseek(s->fd, (off_t)(s->bpos - nw), SEEK_CUR) == (off_t)-1) {
         }
         // now preserve the invariant that data to write
         // begins at the beginning of the buffer, and s->size refers
         // to how much valid file data is stored in the buffer.
         if (s->size > s->ndirty) {
-            size_t delta = s->size - s->ndirty;
+            size_t delta = (size_t)(s->size - s->ndirty);
             memmove(s->buf, s->buf + s->ndirty, delta);
         }
         s->size -= s->ndirty;
@@ -672,15 +672,15 @@ char *ios_takebuf(ios_t *s, size_t *psize)
     ios_flush(s);
 
     if (s->buf == &s->local[0]) {
-        buf = (char*)LLT_ALLOC(s->size+1);
+        buf = (char*)LLT_ALLOC((size_t)s->size + 1);
         if (buf == NULL)
             return NULL;
         if (s->size)
-            memcpy(buf, s->buf, s->size);
+            memcpy(buf, s->buf, (size_t)s->size);
     }
     else {
         if (s->buf == NULL)
-            buf = (char*)LLT_ALLOC(s->size+1);
+            buf = (char*)LLT_ALLOC((size_t)s->size + 1);
         else
             buf = s->buf;
     }
@@ -699,7 +699,7 @@ int ios_setbuf(ios_t *s, char *buf, size_t size, int own)
     ios_flush(s);
     size_t nvalid=0;
 
-    nvalid = (size < s->size) ? size : s->size;
+    nvalid = (size_t)((size < s->size) ? size : s->size);
     if (nvalid > 0)
         memcpy(buf, s->buf, nvalid);
     if (s->bpos > nvalid) {
@@ -786,7 +786,7 @@ size_t ios_copyall(ios_t *to, ios_t *from)
 
 size_t ios_copyuntil(ios_t *to, ios_t *from, char delim)
 {
-    size_t total = 0, avail=from->size - from->bpos;
+    size_t total = 0, avail = (size_t)(from->size - from->bpos);
     while (!ios_eof(from)) {
         if (avail == 0) {
             avail = ios_readprep(from, LINE_CHUNK_SIZE);
@@ -1126,7 +1126,7 @@ int ios_vprintf(ios_t *s, const char *format, va_list args)
 #endif /* _OS_WINDOWS_ */
 
     if (s->state == bst_wr && s->bpos < s->maxsize && s->bm != bm_none) {
-        size_t avail = s->maxsize - s->bpos;
+        size_t avail = (size_t)(s->maxsize - s->bpos);
         char *start = s->buf + s->bpos;
         c = vsnprintf(start, avail, format, args);
         if (c < 0) {
diff --git a/src/support/ios.h b/src/support/ios.h
index 9dc98d39e62f2..70e9353f62bda 100644
--- a/src/support/ios.h
+++ b/src/support/ios.h
@@ -35,12 +35,12 @@ typedef struct {
     bufmode_t bm;     //
     bufstate_t state;
 
-    off_t maxsize;    // space allocated to buffer
-    off_t size;       // length of valid data in buf, >=ndirty
-    off_t bpos;       // current position in buffer
-    off_t ndirty;     // # bytes at &buf[0] that need to be written
+    int64_t maxsize;    // space allocated to buffer
+    int64_t size;       // length of valid data in buf, >=ndirty
+    int64_t bpos;       // current position in buffer
+    int64_t ndirty;     // # bytes at &buf[0] that need to be written
 
-    off_t fpos;       // cached file pos
+    int64_t fpos;       // cached file pos
     size_t lineno;    // current line number
 
     // pointer-size integer to support platforms where it might have
@@ -71,65 +71,65 @@ typedef struct {
 } ios_t;
 
 /* low-level interface functions */
-DLLEXPORT size_t ios_read(ios_t *s, char *dest, size_t n);
-DLLEXPORT size_t ios_readall(ios_t *s, char *dest, size_t n);
-DLLEXPORT size_t ios_write(ios_t *s, const char *data, size_t n);
-DLLEXPORT off_t ios_seek(ios_t *s, off_t pos);   // absolute seek
-DLLEXPORT off_t ios_seek_end(ios_t *s);
-DLLEXPORT off_t ios_skip(ios_t *s, off_t offs);  // relative seek
-DLLEXPORT off_t ios_pos(ios_t *s);  // get current position
-DLLEXPORT int ios_trunc(ios_t *s, size_t size);
-DLLEXPORT int ios_eof(ios_t *s);
-DLLEXPORT int ios_eof_blocking(ios_t *s);
-DLLEXPORT int ios_flush(ios_t *s);
-DLLEXPORT void ios_close(ios_t *s);
-DLLEXPORT int ios_isopen(ios_t *s);
-DLLEXPORT char *ios_takebuf(ios_t *s, size_t *psize);  // release buffer to caller
+JL_DLLEXPORT size_t ios_read(ios_t *s, char *dest, size_t n);
+JL_DLLEXPORT size_t ios_readall(ios_t *s, char *dest, size_t n);
+JL_DLLEXPORT size_t ios_write(ios_t *s, const char *data, size_t n);
+JL_DLLEXPORT int64_t ios_seek(ios_t *s, int64_t pos);   // absolute seek
+JL_DLLEXPORT int64_t ios_seek_end(ios_t *s);
+JL_DLLEXPORT int64_t ios_skip(ios_t *s, int64_t offs);  // relative seek
+JL_DLLEXPORT int64_t ios_pos(ios_t *s);  // get current position
+JL_DLLEXPORT int ios_trunc(ios_t *s, size_t size);
+JL_DLLEXPORT int ios_eof(ios_t *s);
+JL_DLLEXPORT int ios_eof_blocking(ios_t *s);
+JL_DLLEXPORT int ios_flush(ios_t *s);
+JL_DLLEXPORT void ios_close(ios_t *s);
+JL_DLLEXPORT int ios_isopen(ios_t *s);
+JL_DLLEXPORT char *ios_takebuf(ios_t *s, size_t *psize);  // release buffer to caller
 // set buffer space to use
-DLLEXPORT int ios_setbuf(ios_t *s, char *buf, size_t size, int own);
-DLLEXPORT int ios_bufmode(ios_t *s, bufmode_t mode);
-DLLEXPORT int ios_get_readable(ios_t *s);
-DLLEXPORT int ios_get_writable(ios_t *s);
-DLLEXPORT void ios_set_readonly(ios_t *s);
-DLLEXPORT size_t ios_copy(ios_t *to, ios_t *from, size_t nbytes);
-DLLEXPORT size_t ios_copyall(ios_t *to, ios_t *from);
-DLLEXPORT size_t ios_copyuntil(ios_t *to, ios_t *from, char delim);
+JL_DLLEXPORT int ios_setbuf(ios_t *s, char *buf, size_t size, int own);
+JL_DLLEXPORT int ios_bufmode(ios_t *s, bufmode_t mode);
+JL_DLLEXPORT int ios_get_readable(ios_t *s);
+JL_DLLEXPORT int ios_get_writable(ios_t *s);
+JL_DLLEXPORT void ios_set_readonly(ios_t *s);
+JL_DLLEXPORT size_t ios_copy(ios_t *to, ios_t *from, size_t nbytes);
+JL_DLLEXPORT size_t ios_copyall(ios_t *to, ios_t *from);
+JL_DLLEXPORT size_t ios_copyuntil(ios_t *to, ios_t *from, char delim);
 // ensure at least n bytes are buffered if possible. returns # available.
-DLLEXPORT size_t ios_readprep(ios_t *from, size_t n);
+JL_DLLEXPORT size_t ios_readprep(ios_t *from, size_t n);
 
 /* stream creation */
-DLLEXPORT
+JL_DLLEXPORT
 ios_t *ios_file(ios_t *s, const char *fname, int rd, int wr, int create, int trunc);
-DLLEXPORT ios_t *ios_mkstemp(ios_t *f, char *fname);
-DLLEXPORT ios_t *ios_mem(ios_t *s, size_t initsize);
+JL_DLLEXPORT ios_t *ios_mkstemp(ios_t *f, char *fname);
+JL_DLLEXPORT ios_t *ios_mem(ios_t *s, size_t initsize);
 ios_t *ios_str(ios_t *s, char *str);
 ios_t *ios_static_buffer(ios_t *s, char *buf, size_t sz);
-DLLEXPORT ios_t *ios_fd(ios_t *s, long fd, int isfile, int own);
+JL_DLLEXPORT ios_t *ios_fd(ios_t *s, long fd, int isfile, int own);
 // todo: ios_socket
-extern DLLEXPORT ios_t *ios_stdin;
-extern DLLEXPORT ios_t *ios_stdout;
-extern DLLEXPORT ios_t *ios_stderr;
+extern JL_DLLEXPORT ios_t *ios_stdin;
+extern JL_DLLEXPORT ios_t *ios_stdout;
+extern JL_DLLEXPORT ios_t *ios_stderr;
 void ios_init_stdstreams(void);
 
 /* high-level functions - output */
-DLLEXPORT int ios_pututf8(ios_t *s, uint32_t wc);
-DLLEXPORT int ios_printf(ios_t *s, const char *format, ...);
-DLLEXPORT int ios_vprintf(ios_t *s, const char *format, va_list args);
+JL_DLLEXPORT int ios_pututf8(ios_t *s, uint32_t wc);
+JL_DLLEXPORT int ios_printf(ios_t *s, const char *format, ...);
+JL_DLLEXPORT int ios_vprintf(ios_t *s, const char *format, va_list args);
 
 /* high-level stream functions - input */
-DLLEXPORT int ios_getutf8(ios_t *s, uint32_t *pwc);
-DLLEXPORT int ios_peekutf8(ios_t *s, uint32_t *pwc);
-DLLEXPORT char *ios_readline(ios_t *s);
+JL_DLLEXPORT int ios_getutf8(ios_t *s, uint32_t *pwc);
+JL_DLLEXPORT int ios_peekutf8(ios_t *s, uint32_t *pwc);
+JL_DLLEXPORT char *ios_readline(ios_t *s);
 
 // discard data buffered for reading
-DLLEXPORT void ios_purge(ios_t *s);
+JL_DLLEXPORT void ios_purge(ios_t *s);
 
 /* stdio-style functions */
 #define IOS_EOF (-1)
-DLLEXPORT int ios_putc(int c, ios_t *s);
+JL_DLLEXPORT int ios_putc(int c, ios_t *s);
 //wint_t ios_putwc(ios_t *s, wchar_t wc);
-DLLEXPORT int ios_getc(ios_t *s);
-DLLEXPORT int ios_peekc(ios_t *s);
+JL_DLLEXPORT int ios_getc(ios_t *s);
+JL_DLLEXPORT int ios_peekc(ios_t *s);
 //wint_t ios_getwc(ios_t *s);
 int ios_ungetc(int c, ios_t *s);
 //wint_t ios_ungetwc(ios_t *s, wint_t wc);
diff --git a/src/support/libsupport.h b/src/support/libsupport.h
index 156a3d139063c..95935e8bb8869 100644
--- a/src/support/libsupport.h
+++ b/src/support/libsupport.h
@@ -23,7 +23,7 @@
 extern "C" {
 #endif
 
-DLLEXPORT void libsupport_init(void);
+JL_DLLEXPORT void libsupport_init(void);
 
 #ifdef __cplusplus
 }
diff --git a/src/support/platform.h b/src/support/platform.h
index 058ed0db5259a..c0e95343c855d 100644
--- a/src/support/platform.h
+++ b/src/support/platform.h
@@ -45,6 +45,10 @@
  */
 #if defined(__clang__)
 #define _COMPILER_CLANG_
+// Clang can also be used as a MinGW compiler
+#if defined(__MINGW32__)
+#define _COMPILER_MINGW_
+#endif
 #elif defined(__INTEL_COMPILER) || defined(__ICC)
 #define _COMPILER_INTEL_
 #elif defined(__MINGW32__)
@@ -77,6 +81,8 @@
 #define _CPU_X86_64_
 #elif defined(i386) || defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(_X86_)
 #define _CPU_X86_
+#elif defined(__aarch64__)
+#define _CPU_AARCH64_
 #elif defined(__arm__) || defined(_M_ARM)
 #define _CPU_ARM_
 #elif defined(__PPC64__)
diff --git a/src/support/strptime.c b/src/support/strptime.c
new file mode 100644
index 0000000000000..ab75ee05ee8db
--- /dev/null
+++ b/src/support/strptime.c
@@ -0,0 +1,822 @@
+/*	$NetBSD: strptime.c,v 1.58 2015/10/31 03:42:00 ginsbach Exp $	*/
+/*-
+ * Copyright (c) 1997, 1998, 2005, 2008 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code was contributed to The NetBSD Foundation by Klaus Klein.
+ * Heavily optimised by David Laight
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+__RCSID("$NetBSD: strptime.c,v 1.58 2015/10/31 03:42:00 ginsbach Exp $");
+#endif
+
+#include <sys/types.h>
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+#include <time.h>
+#include <stdint.h>
+#include "tzfile.h"
+#include "dtypes.h" // for strncasecmp on msvc
+
+typedef unsigned int uint;
+typedef unsigned char u_char;
+typedef _locale_t locale_t;
+#define _current_locale() NULL
+#define localtime_r(timep, result) (localtime_s(result, timep) ? NULL : result)
+
+__declspec(dllexport) char *
+strptime(const char *buf, const char *fmt, struct tm *tm);
+__declspec(dllexport) char *
+strptime_l(const char *buf, const char *fmt, struct tm *tm, locale_t loc);
+
+// disable timezone support
+typedef void* timezone_t;
+#define tzalloc(buf) (0)
+#define tzfree(tz)
+
+#ifdef __weak_alias
+__weak_alias(strptime,_strptime)
+__weak_alias(strptime_l, _strptime_l)
+#endif
+
+static const u_char *conv_num(const unsigned char *, int *, uint, uint);
+static const u_char *find_string(const u_char *, int *, const char * const *,
+	const char * const *, int);
+
+#if 0
+#include <sys/localedef.h>
+#define _TIME_LOCALE(loc) \
+    ((_TimeLocale *)((loc)->part_impl[(size_t)LC_TIME]))
+#else
+typedef struct {
+	const char* abday[7];
+	const char* day[7];
+	const char* abmon[12];
+	const char* mon[12];
+	const char* am_pm[2];
+	const char* t_fmt_ampm;
+	const char* d_t_fmt;
+	const char* d_fmt;
+	const char* t_fmt;
+} _TimeLocale;
+static const _TimeLocale _c_locale = {
+	{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"},
+	{"Sunday", "Monday", "Tuesday", "Wednesday",
+	 "Thursday", "Friday", "Saturday"},
+	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+	 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"},
+	{"January", "February", "March", "April", "May", "June",
+	 "July", "August", "September", "October", "November", "December"},
+	{"AM", "PM"},
+	"%I:%M:%S %p",
+	"%a %b %e %H:%M:%S %Y",
+	"%m/%d/%y",
+	"%H:%M:%S"
+};
+#define _TIME_LOCALE(loc) (&_c_locale)
+#endif
+
+/*
+ * We do not implement alternate representations. However, we always
+ * check whether a given modifier is allowed for a certain conversion.
+ */
+#define ALT_E			0x01
+#define ALT_O			0x02
+#define LEGAL_ALT(x)		{ if (alt_format & ~(x)) return NULL; }
+
+#define S_YEAR			(1 << 0)
+#define S_MON			(1 << 1)
+#define S_YDAY			(1 << 2)
+#define S_MDAY			(1 << 3)
+#define S_WDAY			(1 << 4)
+#define S_HOUR			(1 << 5)
+
+#define HAVE_MDAY(s)		(s & S_MDAY)
+#define HAVE_MON(s)		(s & S_MON)
+#define HAVE_WDAY(s)		(s & S_WDAY)
+#define HAVE_YDAY(s)		(s & S_YDAY)
+#define HAVE_YEAR(s)		(s & S_YEAR)
+#define HAVE_HOUR(s)		(s & S_HOUR)
+
+#ifdef TM_ZONE
+static char utc[] = { "UTC" };
+#endif
+/* RFC-822/RFC-2822 */
+static const char * const nast[5] = {
+       "EST",    "CST",    "MST",    "PST",    "\0\0\0"
+};
+static const char * const nadt[5] = {
+       "EDT",    "CDT",    "MDT",    "PDT",    "\0\0\0"
+};
+
+/*
+ * Table to determine the ordinal date for the start of a month.
+ * Ref: http://en.wikipedia.org/wiki/ISO_week_date
+ */
+static const int start_of_month[2][13] = {
+	/* non-leap year */
+	{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
+	/* leap year */
+	{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
+};
+
+/*
+ * Calculate the week day of the first day of a year. Valid for
+ * the Gregorian calendar, which began Sept 14, 1752 in the UK
+ * and its colonies. Ref:
+ * http://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
+ */
+
+static int
+first_wday_of(int yr)
+{
+	return ((2 * (3 - (yr / 100) % 4)) + (yr % 100) + ((yr % 100) /  4) +
+	    (isleap(yr) ? 6 : 0) + 1) % 7;
+}
+
+#define delim(p)	((p) == '\0' || isspace((unsigned char)(p)))
+
+static int
+fromzone(const unsigned char **bp, struct tm *tm, int mandatory)
+{
+	timezone_t tz;
+	char buf[512], *p;
+	const unsigned char *rp;
+
+	for (p = buf, rp = *bp; !delim(*rp) && p < &buf[sizeof(buf) - 1]; rp++)
+		*p++ = *rp;
+	*p = '\0';
+
+	if (mandatory)
+		*bp = rp;
+	tz = tzalloc(buf);
+	if (tz == NULL)
+		return 0;
+
+	*bp = rp;
+	tm->tm_isdst = 0;	/* XXX */
+#ifdef TM_GMTOFF
+	tm->TM_GMTOFF = tzgetgmtoff(tz, tm->tm_isdst);
+#endif
+#ifdef TM_ZONE
+	// Can't use tzgetname() here because we are going to free()
+	tm->TM_ZONE = NULL; /* XXX */
+#endif
+	tzfree(tz);
+	return 1;
+}
+
+char *
+strptime(const char *buf, const char *fmt, struct tm *tm)
+{
+	return strptime_l(buf, fmt, tm, _current_locale());
+}
+
+char *
+strptime_l(const char *buf, const char *fmt, struct tm *tm, locale_t loc)
+{
+	unsigned char c;
+	const unsigned char *bp, *ep, *zname;
+	int alt_format, i, split_year = 0, neg = 0, state = 0,
+	    day_offset = -1, week_offset = 0, offs, mandatory;
+	const char *new_fmt;
+
+	bp = (const u_char *)buf;
+
+	while (bp != NULL && (c = *fmt++) != '\0') {
+		/* Clear `alternate' modifier prior to new conversion. */
+		alt_format = 0;
+		i = 0;
+
+		/* Eat up white-space. */
+		if (isspace(c)) {
+			while (isspace(*bp))
+				bp++;
+			continue;
+		}
+
+		if (c != '%')
+			goto literal;
+
+
+again:		switch (c = *fmt++) {
+		case '%':	/* "%%" is converted to "%". */
+literal:
+			if (c != *bp++)
+				return NULL;
+			LEGAL_ALT(0);
+			continue;
+
+		/*
+		 * "Alternative" modifiers. Just set the appropriate flag
+		 * and start over again.
+		 */
+		case 'E':	/* "%E?" alternative conversion modifier. */
+			LEGAL_ALT(0);
+			alt_format |= ALT_E;
+			goto again;
+
+		case 'O':	/* "%O?" alternative conversion modifier. */
+			LEGAL_ALT(0);
+			alt_format |= ALT_O;
+			goto again;
+
+		/*
+		 * "Complex" conversion rules, implemented through recursion.
+		 */
+		case 'c':	/* Date and time, using the locale's format. */
+			new_fmt = _TIME_LOCALE(loc)->d_t_fmt;
+			state |= S_WDAY | S_MON | S_MDAY | S_YEAR;
+			goto recurse;
+
+		case 'D':	/* The date as "%m/%d/%y". */
+			new_fmt = "%m/%d/%y";
+			LEGAL_ALT(0);
+			state |= S_MON | S_MDAY | S_YEAR;
+			goto recurse;
+
+		case 'F':	/* The date as "%Y-%m-%d". */
+			new_fmt = "%Y-%m-%d";
+			LEGAL_ALT(0);
+			state |= S_MON | S_MDAY | S_YEAR;
+			goto recurse;
+
+		case 'R':	/* The time as "%H:%M". */
+			new_fmt = "%H:%M";
+			LEGAL_ALT(0);
+			goto recurse;
+
+		case 'r':	/* The time in 12-hour clock representation. */
+			new_fmt = _TIME_LOCALE(loc)->t_fmt_ampm;
+			LEGAL_ALT(0);
+			goto recurse;
+
+		case 'T':	/* The time as "%H:%M:%S". */
+			new_fmt = "%H:%M:%S";
+			LEGAL_ALT(0);
+			goto recurse;
+
+		case 'X':	/* The time, using the locale's format. */
+			new_fmt = _TIME_LOCALE(loc)->t_fmt;
+			goto recurse;
+
+		case 'x':	/* The date, using the locale's format. */
+			new_fmt = _TIME_LOCALE(loc)->d_fmt;
+			state |= S_MON | S_MDAY | S_YEAR;
+		    recurse:
+			bp = (const u_char *)strptime((const char *)bp,
+							    new_fmt, tm);
+			LEGAL_ALT(ALT_E);
+			continue;
+
+		/*
+		 * "Elementary" conversion rules.
+		 */
+		case 'A':	/* The day of week, using the locale's form. */
+		case 'a':
+			bp = find_string(bp, &tm->tm_wday,
+			    _TIME_LOCALE(loc)->day, _TIME_LOCALE(loc)->abday, 7);
+			LEGAL_ALT(0);
+			state |= S_WDAY;
+			continue;
+
+		case 'B':	/* The month, using the locale's form. */
+		case 'b':
+		case 'h':
+			bp = find_string(bp, &tm->tm_mon,
+			    _TIME_LOCALE(loc)->mon, _TIME_LOCALE(loc)->abmon,
+			    12);
+			LEGAL_ALT(0);
+			state |= S_MON;
+			continue;
+
+		case 'C':	/* The century number. */
+			i = 20;
+			bp = conv_num(bp, &i, 0, 99);
+
+			i = i * 100 - TM_YEAR_BASE;
+			if (split_year)
+				i += tm->tm_year % 100;
+			split_year = 1;
+			tm->tm_year = i;
+			LEGAL_ALT(ALT_E);
+			state |= S_YEAR;
+			continue;
+
+		case 'd':	/* The day of month. */
+		case 'e':
+			bp = conv_num(bp, &tm->tm_mday, 1, 31);
+			LEGAL_ALT(ALT_O);
+			state |= S_MDAY;
+			continue;
+
+		case 'k':	/* The hour (24-hour clock representation). */
+			LEGAL_ALT(0);
+			/* FALLTHROUGH */
+		case 'H':
+			bp = conv_num(bp, &tm->tm_hour, 0, 23);
+			LEGAL_ALT(ALT_O);
+			state |= S_HOUR;
+			continue;
+
+		case 'l':	/* The hour (12-hour clock representation). */
+			LEGAL_ALT(0);
+			/* FALLTHROUGH */
+		case 'I':
+			bp = conv_num(bp, &tm->tm_hour, 1, 12);
+			if (tm->tm_hour == 12)
+				tm->tm_hour = 0;
+			LEGAL_ALT(ALT_O);
+			state |= S_HOUR;
+			continue;
+
+		case 'j':	/* The day of year. */
+			i = 1;
+			bp = conv_num(bp, &i, 1, 366);
+			tm->tm_yday = i - 1;
+			LEGAL_ALT(0);
+			state |= S_YDAY;
+			continue;
+
+		case 'M':	/* The minute. */
+			bp = conv_num(bp, &tm->tm_min, 0, 59);
+			LEGAL_ALT(ALT_O);
+			continue;
+
+		case 'm':	/* The month. */
+			i = 1;
+			bp = conv_num(bp, &i, 1, 12);
+			tm->tm_mon = i - 1;
+			LEGAL_ALT(ALT_O);
+			state |= S_MON;
+			continue;
+
+		case 'p':	/* The locale's equivalent of AM/PM. */
+			bp = find_string(bp, &i, _TIME_LOCALE(loc)->am_pm,
+			    NULL, 2);
+			if (HAVE_HOUR(state) && tm->tm_hour > 11)
+				return NULL;
+			tm->tm_hour += i * 12;
+			LEGAL_ALT(0);
+			continue;
+
+		case 'S':	/* The seconds. */
+			bp = conv_num(bp, &tm->tm_sec, 0, 61);
+			LEGAL_ALT(ALT_O);
+			continue;
+
+#ifndef TIME_MAX
+#define TIME_MAX	INT64_MAX
+#endif
+		case 's':	/* seconds since the epoch */
+			{
+				time_t sse = 0;
+				uint64_t rulim = TIME_MAX;
+
+				if (*bp < '0' || *bp > '9') {
+					bp = NULL;
+					continue;
+				}
+
+				do {
+					sse *= 10;
+					sse += *bp++ - '0';
+					rulim /= 10;
+				} while ((sse * 10 <= TIME_MAX) &&
+					 rulim && *bp >= '0' && *bp <= '9');
+
+				if (sse < 0 || (uint64_t)sse > TIME_MAX) {
+					bp = NULL;
+					continue;
+				}
+
+				if (localtime_r(&sse, tm) == NULL)
+					bp = NULL;
+				else
+					state |= S_YDAY | S_WDAY |
+					    S_MON | S_MDAY | S_YEAR;
+			}
+			continue;
+
+		case 'U':	/* The week of year, beginning on sunday. */
+		case 'W':	/* The week of year, beginning on monday. */
+			/*
+			 * XXX This is bogus, as we can not assume any valid
+			 * information present in the tm structure at this
+			 * point to calculate a real value, so just check the
+			 * range for now.
+			 */
+			bp = conv_num(bp, &i, 0, 53);
+			LEGAL_ALT(ALT_O);
+			if (c == 'U')
+				day_offset = TM_SUNDAY;
+			else
+				day_offset = TM_MONDAY;
+			week_offset = i;
+			continue;
+
+		case 'w':	/* The day of week, beginning on sunday. */
+			bp = conv_num(bp, &tm->tm_wday, 0, 6);
+			LEGAL_ALT(ALT_O);
+			state |= S_WDAY;
+			continue;
+
+		case 'u':	/* The day of week, monday = 1. */
+			bp = conv_num(bp, &i, 1, 7);
+			tm->tm_wday = i % 7;
+			LEGAL_ALT(ALT_O);
+			state |= S_WDAY;
+			continue;
+
+		case 'g':	/* The year corresponding to the ISO week
+				 * number but without the century.
+				 */
+			bp = conv_num(bp, &i, 0, 99);
+			continue;
+
+		case 'G':	/* The year corresponding to the ISO week
+				 * number with century.
+				 */
+			do
+				bp++;
+			while (isdigit(*bp));
+			continue;
+
+		case 'V':	/* The ISO 8601:1988 week number as decimal */
+			bp = conv_num(bp, &i, 0, 53);
+			continue;
+
+		case 'Y':	/* The year. */
+			i = TM_YEAR_BASE;	/* just for data sanity... */
+			bp = conv_num(bp, &i, 0, 9999);
+			tm->tm_year = i - TM_YEAR_BASE;
+			LEGAL_ALT(ALT_E);
+			state |= S_YEAR;
+			continue;
+
+		case 'y':	/* The year within 100 years of the epoch. */
+			/* LEGAL_ALT(ALT_E | ALT_O); */
+			bp = conv_num(bp, &i, 0, 99);
+
+			if (split_year)
+				/* preserve century */
+				i += (tm->tm_year / 100) * 100;
+			else {
+				split_year = 1;
+				if (i <= 68)
+					i = i + 2000 - TM_YEAR_BASE;
+				else
+					i = i + 1900 - TM_YEAR_BASE;
+			}
+			tm->tm_year = i;
+			state |= S_YEAR;
+			continue;
+
+		case 'Z':
+		case 'z':
+			tzset();
+			mandatory = c == 'z';
+			/*
+			 * We recognize all ISO 8601 formats:
+			 * Z	= Zulu time/UTC
+			 * [+-]hhmm
+			 * [+-]hh:mm
+			 * [+-]hh
+			 * We recognize all RFC-822/RFC-2822 formats:
+			 * UT|GMT
+			 *          North American : UTC offsets
+			 * E[DS]T = Eastern : -4 | -5
+			 * C[DS]T = Central : -5 | -6
+			 * M[DS]T = Mountain: -6 | -7
+			 * P[DS]T = Pacific : -7 | -8
+			 *          Nautical/Military
+			 * [A-IL-M] = -1 ... -9 (J not used)
+			 * [N-Y]  = +1 ... +12
+			 * Note: J maybe used to denote non-nautical
+			 *       local time
+			 */
+			if (mandatory)
+				while (isspace(*bp))
+					bp++;
+
+			zname = bp;
+			switch (*bp++) {
+			case 'G':
+				if (*bp++ != 'M')
+					goto namedzone;
+				/*FALLTHROUGH*/
+			case 'U':
+				if (*bp++ != 'T')
+					goto namedzone;
+				else if (!delim(*bp) && *bp++ != 'C')
+					goto namedzone;
+				/*FALLTHROUGH*/
+			case 'Z':
+				if (!delim(*bp))
+					goto namedzone;
+				tm->tm_isdst = 0;
+#ifdef TM_GMTOFF
+				tm->TM_GMTOFF = 0;
+#endif
+#ifdef TM_ZONE
+				tm->TM_ZONE = utc;
+#endif
+				continue;
+			case '+':
+				neg = 0;
+				break;
+			case '-':
+				neg = 1;
+				break;
+			default:
+namedzone:
+				bp = zname;
+
+				/* Nautical / Military style */
+				if (delim(bp[1]) &&
+				    ((*bp >= 'A' && *bp <= 'I') ||
+				    (*bp >= 'L' && *bp <= 'Y'))) {
+#ifdef TM_GMTOFF
+					/* Argh! No 'J'! */
+					if (*bp >= 'A' && *bp <= 'I')
+						tm->TM_GMTOFF =
+						    ('A' - 1) - (int)*bp;
+					else if (*bp >= 'L' && *bp <= 'M')
+						tm->TM_GMTOFF = 'A' - (int)*bp;
+					else if (*bp >= 'N' && *bp <= 'Y')
+						tm->TM_GMTOFF = (int)*bp - 'M';
+					tm->TM_GMTOFF *= SECSPERHOUR;
+#endif
+#ifdef TM_ZONE
+					tm->TM_ZONE = NULL; /* XXX */
+#endif
+					bp++;
+					continue;
+				}
+				/* 'J' is local time */
+				if (delim(bp[1]) && *bp == 'J') {
+#ifdef TM_GMTOFF
+					tm->TM_GMTOFF = -timezone;
+#endif
+#ifdef TM_ZONE
+					tm->TM_ZONE = NULL; /* XXX */
+#endif
+					bp++;
+					continue;
+				}
+
+				/*
+				 * From our 3 letter hard-coded table
+				 * XXX: Can be removed, handled by tzload()
+				 */
+				if (delim(bp[0]) || delim(bp[1]) ||
+				    delim(bp[2]) || !delim(bp[3]))
+					goto loadzone;
+				ep = find_string(bp, &i, nast, NULL, 4);
+				if (ep != NULL) {
+#ifdef TM_GMTOFF
+					tm->TM_GMTOFF = (-5 - i) * SECSPERHOUR;
+#endif
+#ifdef TM_ZONE
+					tm->TM_ZONE = __UNCONST(nast[i]);
+#endif
+					bp = ep;
+					continue;
+				}
+				ep = find_string(bp, &i, nadt, NULL, 4);
+				if (ep != NULL) {
+					tm->tm_isdst = 1;
+#ifdef TM_GMTOFF
+					tm->TM_GMTOFF = (-4 - i) * SECSPERHOUR;
+#endif
+#ifdef TM_ZONE
+					tm->TM_ZONE = __UNCONST(nadt[i]);
+#endif
+					bp = ep;
+					continue;
+				}
+				/*
+				 * Our current timezone
+				 */
+				ep = find_string(bp, &i,
+					       	 (const char * const *)_tzname,
+					       	  NULL, 2);
+				if (ep != NULL) {
+					tm->tm_isdst = i;
+#ifdef TM_GMTOFF
+					tm->TM_GMTOFF = -timezone;
+#endif
+#ifdef TM_ZONE
+					tm->TM_ZONE = _tzname[i];
+#endif
+					bp = ep;
+					continue;
+				}
+loadzone:
+				/*
+				 * The hard way, load the zone!
+				 */
+				if (fromzone(&bp, tm, mandatory))
+					continue;
+				goto out;
+			}
+			offs = 0;
+			for (i = 0; i < 4; ) {
+				if (isdigit(*bp)) {
+					offs = offs * 10 + (*bp++ - '0');
+					i++;
+					continue;
+				}
+				if (i == 2 && *bp == ':') {
+					bp++;
+					continue;
+				}
+				break;
+			}
+			if (isdigit(*bp))
+				goto out;
+			switch (i) {
+			case 2:
+				offs *= SECSPERHOUR;
+				break;
+			case 4:
+				i = offs % 100;
+				offs /= 100;
+				if (i >= SECSPERMIN)
+					goto out;
+				/* Convert minutes into decimal */
+				offs = offs * SECSPERHOUR + i * SECSPERMIN;
+				break;
+			default:
+			out:
+				if (mandatory)
+					return NULL;
+				bp = zname;
+				continue;
+			}
+			if (offs >= (HOURSPERDAY * SECSPERHOUR))
+				goto out;
+			if (neg)
+				offs = -offs;
+			tm->tm_isdst = 0;	/* XXX */
+#ifdef TM_GMTOFF
+			tm->TM_GMTOFF = offs;
+#endif
+#ifdef TM_ZONE
+			tm->TM_ZONE = NULL;	/* XXX */
+#endif
+			continue;
+
+		/*
+		 * Miscellaneous conversions.
+		 */
+		case 'n':	/* Any kind of white-space. */
+		case 't':
+			while (isspace(*bp))
+				bp++;
+			LEGAL_ALT(0);
+			continue;
+
+
+		default:	/* Unknown/unsupported conversion. */
+			return NULL;
+		}
+	}
+
+	if (!HAVE_YDAY(state) && HAVE_YEAR(state)) {
+		if (HAVE_MON(state) && HAVE_MDAY(state)) {
+			/* calculate day of year (ordinal date) */
+			tm->tm_yday =  start_of_month[isleap_sum(tm->tm_year,
+			    TM_YEAR_BASE)][tm->tm_mon] + (tm->tm_mday - 1);
+			state |= S_YDAY;
+		} else if (day_offset != -1) {
+			/*
+			 * Set the date to the first Sunday (or Monday)
+			 * of the specified week of the year.
+			 */
+			if (!HAVE_WDAY(state)) {
+				tm->tm_wday = day_offset;
+				state |= S_WDAY;
+			}
+			tm->tm_yday = (7 -
+			    first_wday_of(tm->tm_year + TM_YEAR_BASE) +
+			    day_offset) % 7 + (week_offset - 1) * 7 +
+			    tm->tm_wday  - day_offset;
+			state |= S_YDAY;
+		}
+	}
+
+	if (HAVE_YDAY(state) && HAVE_YEAR(state)) {
+		int isleap;
+
+		if (!HAVE_MON(state)) {
+			/* calculate month of day of year */
+			i = 0;
+			isleap = isleap_sum(tm->tm_year, TM_YEAR_BASE);
+			while (tm->tm_yday >= start_of_month[isleap][i])
+				i++;
+			if (i > 12) {
+				i = 1;
+				tm->tm_yday -= start_of_month[isleap][12];
+				tm->tm_year++;
+			}
+			tm->tm_mon = i - 1;
+			state |= S_MON;
+		}
+
+		if (!HAVE_MDAY(state)) {
+			/* calculate day of month */
+			isleap = isleap_sum(tm->tm_year, TM_YEAR_BASE);
+			tm->tm_mday = tm->tm_yday -
+			    start_of_month[isleap][tm->tm_mon] + 1;
+			state |= S_MDAY;
+		}
+
+		if (!HAVE_WDAY(state)) {
+			/* calculate day of week */
+			i = 0;
+			week_offset = first_wday_of(tm->tm_year);
+			while (i++ <= tm->tm_yday) {
+				if (week_offset++ >= 6)
+					week_offset = 0;
+			}
+			tm->tm_wday = week_offset;
+			state |= S_WDAY;
+		}
+	}
+
+	return (char*)bp; // cast away const
+}
+
+
+static const u_char *
+conv_num(const unsigned char *buf, int *dest, uint llim, uint ulim)
+{
+	uint result = 0;
+	unsigned char ch;
+
+	/* The limit also determines the number of valid digits. */
+	uint rulim = ulim;
+
+	ch = *buf;
+	if (ch < '0' || ch > '9')
+		return NULL;
+
+	do {
+		result *= 10;
+		result += ch - '0';
+		rulim /= 10;
+		ch = *++buf;
+	} while ((result * 10 <= ulim) && rulim && ch >= '0' && ch <= '9');
+
+	if (result < llim || result > ulim)
+		return NULL;
+
+	*dest = result;
+	return buf;
+}
+
+static const u_char *
+find_string(const u_char *bp, int *tgt, const char * const *n1,
+		const char * const *n2, int c)
+{
+	int i;
+	size_t len;
+
+	/* check full name - then abbreviated ones */
+	for (; n1 != NULL; n1 = n2, n2 = NULL) {
+		for (i = 0; i < c; i++, n1++) {
+			len = strlen(*n1);
+			if (strncasecmp(*n1, (const char *)bp, len) == 0) {
+				*tgt = i;
+				return bp + len;
+			}
+		}
+	}
+
+	/* Nothing matched */
+	return NULL;
+}
diff --git a/src/support/strtod.c b/src/support/strtod.c
index 2d6b1f20a728e..1dc2b961576ca 100644
--- a/src/support/strtod.c
+++ b/src/support/strtod.c
@@ -18,7 +18,7 @@ extern "C" {
 static int c_locale_initialized = 0;
 static locale_t c_locale;
 
-locale_t get_c_locale()
+locale_t get_c_locale(void)
 {
   if(!c_locale_initialized)
   {
@@ -28,12 +28,12 @@ locale_t get_c_locale()
   return c_locale;
 }
 
-double strtod_c(const char *nptr, char **endptr)
+JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
 {
   return strtod_l(nptr, endptr, get_c_locale());
 }
 
-float strtof_c(const char *nptr, char **endptr)
+JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr)
 {
   return strtof_l(nptr, endptr, get_c_locale());
 }
@@ -98,7 +98,7 @@ double parse_inf_or_nan(const char *p, char **endptr)
 }
 
 
-double strtod_c(const char *nptr, char **endptr)
+JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr)
 {
     char *fail_pos;
     double val;
@@ -285,9 +285,9 @@ double strtod_c(const char *nptr, char **endptr)
 }
 
 
-float strtof_c(const char *nptr, char **endptr)
+JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr)
 {
-  return (float) strtod_c(nptr, endptr);
+  return (float) jl_strtod_c(nptr, endptr);
 }
 
 #endif
diff --git a/src/support/strtod.h b/src/support/strtod.h
index 1758d59b1506b..a63d22447f537 100644
--- a/src/support/strtod.h
+++ b/src/support/strtod.h
@@ -7,12 +7,11 @@
 extern "C" {
 #endif
 
-double strtod_c(const char *nptr, char **endptr);
-float strtof_c(const char *nptr, char **endptr);
+JL_DLLEXPORT double jl_strtod_c(const char *nptr, char **endptr);
+JL_DLLEXPORT float jl_strtof_c(const char *nptr, char **endptr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-
diff --git a/src/support/timefuncs.c b/src/support/timefuncs.c
index 00e4302e3ef6a..4548577de719f 100644
--- a/src/support/timefuncs.c
+++ b/src/support/timefuncs.c
@@ -28,31 +28,27 @@
 extern "C" {
 #endif
 
-#if defined(_OS_WINDOWS_)
-static double floattime(void)
+JL_DLLEXPORT int jl_gettimeofday(struct jl_timeval *jtv)
 {
-    struct timeb tstruct;
-
-    ftime(&tstruct);
-    return (double)tstruct.time + (double)tstruct.millitm/1.0e3;
-}
+#if defined(_OS_WINDOWS_)
+    struct __timeb64 tb;
+    errno_t code = _ftime64_s(&tb);
+    jtv->sec = tb.time;
+    jtv->usec = tb.millitm * 1000;
 #else
-static double tv2float(struct timeval *tv)
-{
-    return (double)tv->tv_sec + (double)tv->tv_usec/1.0e6;
-}
+    struct timeval tv;
+    int code = gettimeofday(&tv, NULL);
+    jtv->sec = tv.tv_sec;
+    jtv->usec = tv.tv_usec;
 #endif
+    return code;
+}
 
-double clock_now(void)
+JL_DLLEXPORT double jl_clock_now(void)
 {
-#if defined(_OS_WINDOWS_)
-    return floattime();
-#else
-    struct timeval now;
-
-    gettimeofday(&now, NULL);
-    return tv2float(&now);
-#endif
+    struct jl_timeval now;
+    jl_gettimeofday(&now);
+    return now.sec + now.usec * 1e-6;
 }
 
 void sleep_ms(int ms)
diff --git a/src/support/timefuncs.h b/src/support/timefuncs.h
index 91fb82b12301f..45d22184d29b1 100644
--- a/src/support/timefuncs.h
+++ b/src/support/timefuncs.h
@@ -7,7 +7,13 @@
 extern "C" {
 #endif
 
-DLLEXPORT double clock_now(void);
+struct jl_timeval {
+    int64_t sec;    /* seconds */
+    int64_t usec;   /* microseconds */
+};
+
+JL_DLLEXPORT int jl_gettimeofday(struct jl_timeval *jtv);
+JL_DLLEXPORT double jl_clock_now(void);
 void sleep_ms(int ms);
 
 #ifdef __cplusplus
diff --git a/src/support/tzfile.h b/src/support/tzfile.h
new file mode 100644
index 0000000000000..b19046c00d79c
--- /dev/null
+++ b/src/support/tzfile.h
@@ -0,0 +1,170 @@
+/*	$NetBSD: tzfile.h,v 1.8 2015/07/11 16:40:53 christos Exp $	*/
+
+#ifndef _TZFILE_H_
+#define _TZFILE_H_
+
+/*
+** This file is in the public domain, so clarified as of
+** 1996-06-05 by Arthur David Olson.
+*/
+
+/*
+** This header is for use ONLY with the time conversion code.
+** There is no guarantee that it will remain unchanged,
+** or that it will remain at all.
+** Do NOT copy it to any system include directory.
+** Thank you!
+*/
+
+/*
+** Information about time zone files.
+*/
+
+#ifndef TZDIR		/* Time zone object file directory */
+#define TZDIR		"/usr/share/zoneinfo"
+#endif /* !defined TZDIR */
+
+#ifndef TZDEFAULT
+#define TZDEFAULT	"/etc/localtime"
+#endif /* !defined TZDEFAULT */
+
+#ifndef TZDEFRULES
+#define TZDEFRULES	"posixrules"
+#endif /* !defined TZDEFRULES */
+
+/*
+** Each file begins with. . .
+*/
+
+#define	TZ_MAGIC	"TZif"
+
+struct tzhead {
+	char	tzh_magic[4];		/* TZ_MAGIC */
+	char	tzh_version[1];		/* '\0' or '2' or '3' as of 2013 */
+	char	tzh_reserved[15];	/* reserved; must be zero */
+	char	tzh_ttisgmtcnt[4];	/* coded number of trans. time flags */
+	char	tzh_ttisstdcnt[4];	/* coded number of trans. time flags */
+	char	tzh_leapcnt[4];		/* coded number of leap seconds */
+	char	tzh_timecnt[4];		/* coded number of transition times */
+	char	tzh_typecnt[4];		/* coded number of local time types */
+	char	tzh_charcnt[4];		/* coded number of abbr. chars */
+};
+
+/*
+** . . .followed by. . .
+**
+**	tzh_timecnt (char [4])s		coded transition times a la time(2)
+**	tzh_timecnt (unsigned char)s	types of local time starting at above
+**	tzh_typecnt repetitions of
+**		one (char [4])		coded UT offset in seconds
+**		one (unsigned char)	used to set tm_isdst
+**		one (unsigned char)	that's an abbreviation list index
+**	tzh_charcnt (char)s		'\0'-terminated zone abbreviations
+**	tzh_leapcnt repetitions of
+**		one (char [4])		coded leap second transition times
+**		one (char [4])		total correction after above
+**	tzh_ttisstdcnt (char)s		indexed by type; if 1, transition
+**					time is standard time, if 0,
+**					transition time is wall clock time
+**					if absent, transition times are
+**					assumed to be wall clock time
+**	tzh_ttisgmtcnt (char)s		indexed by type; if 1, transition
+**					time is UT, if 0,
+**					transition time is local time
+**					if absent, transition times are
+**					assumed to be local time
+*/
+
+/*
+** If tzh_version is '2' or greater, the above is followed by a second instance
+** of tzhead and a second instance of the data in which each coded transition
+** time uses 8 rather than 4 chars,
+** then a POSIX-TZ-environment-variable-style string for use in handling
+** instants after the last transition time stored in the file
+** (with nothing between the newlines if there is no POSIX representation for
+** such instants).
+**
+** If tz_version is '3' or greater, the above is extended as follows.
+** First, the POSIX TZ string's hour offset may range from -167
+** through 167 as compared to the POSIX-required 0 through 24.
+** Second, its DST start time may be January 1 at 00:00 and its stop
+** time December 31 at 24:00 plus the difference between DST and
+** standard time, indicating DST all year.
+*/
+
+/*
+** In the current implementation, "tzset()" refuses to deal with files that
+** exceed any of the limits below.
+*/
+
+#ifndef TZ_MAX_TIMES
+#define TZ_MAX_TIMES	2000
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZ_MAX_TYPES
+/* This must be at least 17 for Europe/Samara and Europe/Vilnius.  */
+#define TZ_MAX_TYPES	256 /* Limited by what (unsigned char)'s can hold */
+#endif /* !defined TZ_MAX_TYPES */
+
+#ifndef TZ_MAX_CHARS
+#define TZ_MAX_CHARS	50	/* Maximum number of abbreviation characters */
+				/* (limited by what unsigned chars can hold) */
+#endif /* !defined TZ_MAX_CHARS */
+
+#ifndef TZ_MAX_LEAPS
+#define TZ_MAX_LEAPS	50	/* Maximum number of leap second corrections */
+#endif /* !defined TZ_MAX_LEAPS */
+
+#define SECSPERMIN	60
+#define MINSPERHOUR	60
+#define HOURSPERDAY	24
+#define DAYSPERWEEK	7
+#define DAYSPERNYEAR	365
+#define DAYSPERLYEAR	366
+#define SECSPERHOUR	(SECSPERMIN * MINSPERHOUR)
+#define SECSPERDAY	((int_fast32_t) SECSPERHOUR * HOURSPERDAY)
+#define MONSPERYEAR	12
+
+#define TM_SUNDAY	0
+#define TM_MONDAY	1
+#define TM_TUESDAY	2
+#define TM_WEDNESDAY	3
+#define TM_THURSDAY	4
+#define TM_FRIDAY	5
+#define TM_SATURDAY	6
+
+#define TM_JANUARY	0
+#define TM_FEBRUARY	1
+#define TM_MARCH	2
+#define TM_APRIL	3
+#define TM_MAY		4
+#define TM_JUNE		5
+#define TM_JULY		6
+#define TM_AUGUST	7
+#define TM_SEPTEMBER	8
+#define TM_OCTOBER	9
+#define TM_NOVEMBER	10
+#define TM_DECEMBER	11
+
+#define TM_YEAR_BASE	1900
+
+#define EPOCH_YEAR	1970
+#define EPOCH_WDAY	TM_THURSDAY
+
+#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
+
+/*
+** Since everything in isleap is modulo 400 (or a factor of 400), we know that
+**	isleap(y) == isleap(y % 400)
+** and so
+**	isleap(a + b) == isleap((a + b) % 400)
+** or
+**	isleap(a + b) == isleap(a % 400 + b % 400)
+** This is true even if % means modulo rather than Fortran remainder
+** (which is allowed by C89 but not C99).
+** We use this to avoid addition overflow problems.
+*/
+
+#define isleap_sum(a, b)	isleap((a) % 400 + (b) % 400)
+
+#endif /* !defined _TZFILE_H_ */
diff --git a/src/support/utf8.c b/src/support/utf8.c
index 4a5e60a25f777..ea371d1a31689 100644
--- a/src/support/utf8.c
+++ b/src/support/utf8.c
@@ -21,7 +21,7 @@
 #include <wctype.h>
 
 #include "utf8proc.h"
-#undef DLLEXPORT /* avoid conflicting definition */
+#undef JL_DLLEXPORT /* avoid conflicting definition */
 
 #include "dtypes.h"
 
diff --git a/src/support/utf8.h b/src/support/utf8.h
index c609704f6d6cf..8593b35c8d3ae 100644
--- a/src/support/utf8.h
+++ b/src/support/utf8.h
@@ -22,10 +22,10 @@ size_t u8_toutf8(char *dest, size_t sz, const uint32_t *src, size_t srcsz);
 size_t u8_wc_toutf8(char *dest, uint32_t ch);
 
 /* character number to byte offset */
-DLLEXPORT size_t u8_offset(const char *str, size_t charnum);
+JL_DLLEXPORT size_t u8_offset(const char *str, size_t charnum);
 
 /* byte offset to character number */
-DLLEXPORT size_t u8_charnum(const char *str, size_t offset);
+JL_DLLEXPORT size_t u8_charnum(const char *str, size_t offset);
 
 /* return next character, updating an index variable */
 uint32_t u8_nextchar(const char *s, size_t *i);
@@ -86,7 +86,7 @@ char *u8_memchr(const char *s, uint32_t ch, size_t sz, size_t *charn);
 char *u8_memrchr(const char *s, uint32_t ch, size_t sz);
 
 /* number of columns occupied by a string */
-DLLEXPORT size_t u8_strwidth(const char *s);
+JL_DLLEXPORT size_t u8_strwidth(const char *s);
 
 /* printf where the format string and arguments may be in UTF-8.
    you can avoid this function and just use ordinary printf() if the current
@@ -95,7 +95,7 @@ size_t u8_vprintf(const char *fmt, va_list ap);
 size_t u8_printf(const char *fmt, ...);
 
 /* determine whether a sequence of bytes is valid UTF-8. length is in bytes */
-DLLEXPORT int u8_isvalid(const char *str, size_t length);
+JL_DLLEXPORT int u8_isvalid(const char *str, size_t length);
 
 #ifdef __cplusplus
 }
diff --git a/src/support/utils.h b/src/support/utils.h
index 0082e1c42cd09..caf6a7af25b5e 100644
--- a/src/support/utils.h
+++ b/src/support/utils.h
@@ -7,7 +7,7 @@
 extern "C" {
 #endif
 
-DLLEXPORT char *uint2str(char *dest, size_t len, uint64_t num, uint32_t base);
+JL_DLLEXPORT char *uint2str(char *dest, size_t len, uint64_t num, uint32_t base);
 int str2int(char *str, size_t len, int64_t *res, uint32_t base);
 int isdigit_base(char c, int base);
 
@@ -36,18 +36,18 @@ int cmp_eq(void *a, numerictype_t atag, void *b, numerictype_t btag,
 #endif
 
 #if (!defined(__INTEL_COMPILER) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))
-STATIC_INLINE u_int16_t ByteSwap16(u_int16_t x)
+STATIC_INLINE uint16_t ByteSwap16(uint16_t x)
 {
   __asm("xchgb %b0,%h0" :
-        LEGACY_REGS (x)	:
+        LEGACY_REGS (x) :
         "0" (x));
     return x;
 }
 #define bswap_16(x) ByteSwap16(x)
 
-STATIC_INLINE u_int32_t ByteSwap32(u_int32_t x)
+STATIC_INLINE uint32_t ByteSwap32(uint32_t x)
 {
- __asm("bswap	%0":
+ __asm("bswap   %0":
       "=r" (x)     :
       "0" (x));
   return x;
@@ -55,17 +55,17 @@ STATIC_INLINE u_int32_t ByteSwap32(u_int32_t x)
 
 #define bswap_32(x) ByteSwap32(x)
 
-STATIC_INLINE u_int64_t ByteSwap64(u_int64_t x)
+STATIC_INLINE uint64_t ByteSwap64(uint64_t x)
 {
 #ifdef __x86_64__
-  __asm("bswap	%0":
+  __asm("bswap  %0":
         "=r" (x)     :
         "0" (x));
   return x;
 #else
-  register union { __extension__ u_int64_t __ll;
-          u_int32_t __l[2]; } __x;
-  asm("xchgl	%0,%1":
+  register union { __extension__ uint64_t __ll;
+          uint32_t __l[2]; } __x;
+  asm("xchgl    %0,%1":
       "=r"(__x.__l[0]),"=r"(__x.__l[1]):
       "0"(bswap_32((unsigned long)x)),"1"(bswap_32((unsigned long)(x>>32))));
   return __x.__ll;
@@ -85,11 +85,11 @@ STATIC_INLINE u_int64_t ByteSwap64(u_int64_t x)
       (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
 #endif
 
-STATIC_INLINE u_int64_t ByteSwap64(u_int64_t x)
+STATIC_INLINE uint64_t ByteSwap64(uint64_t x)
 {
     union {
-        u_int64_t ll;
-        u_int32_t l[2];
+        uint64_t ll;
+        uint32_t l[2];
     } w, r;
     w.ll = x;
     r.l[0] = bswap_32 (w.l[1]);
diff --git a/src/sys.c b/src/sys.c
index 1953f06e810b3..9a48871c08e5d 100644
--- a/src/sys.c
+++ b/src/sys.c
@@ -10,7 +10,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
-#ifndef _OS_WINDOWS_
+#ifdef _OS_WINDOWS_
+#include <psapi.h>
+#else
 #include <sys/sysctl.h>
 #include <sys/wait.h>
 #include <sys/ptrace.h>
@@ -22,6 +24,13 @@
 #include <signal.h>
 #include <fcntl.h>
 
+#ifndef _OS_WINDOWS_
+// for getrusage
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
 #ifdef __APPLE__
 #include <mach-o/dyld.h>
 #include <mach-o/nlist.h>
@@ -30,10 +39,6 @@
 #include <link.h>
 #endif
 
-#define __STDC_CONSTANT_MACROS
-#define __STDC_LIMIT_MACROS
-#include <llvm-c/Target.h>
-
 #ifdef __SSE__
 #include <xmmintrin.h>
 #endif
@@ -54,64 +59,76 @@ extern "C" {
 #endif
 
 #if defined(_OS_WINDOWS_) && !defined(_COMPILER_MINGW_)
-DLLEXPORT char *dirname(char *);
+JL_DLLEXPORT char *dirname(char *);
 #else
 #include <libgen.h>
 #endif
 
-DLLEXPORT uint32_t jl_getutf8(ios_t *s)
+JL_DLLEXPORT uint32_t jl_getutf8(ios_t *s)
 {
     uint32_t wc=0;
     ios_getutf8(s, &wc);
     return wc;
 }
 
-DLLEXPORT int jl_sizeof_off_t(void) { return sizeof(off_t); }
+JL_DLLEXPORT int jl_sizeof_uv_mutex(void) { return sizeof(uv_mutex_t); }
+JL_DLLEXPORT int jl_sizeof_off_t(void) { return sizeof(off_t); }
 #ifndef _OS_WINDOWS_
-DLLEXPORT off_t jl_lseek(int fd, off_t offset, int whence) { return lseek(fd, offset, whence); }
-DLLEXPORT ssize_t jl_pwrite(int fd, const void *buf, size_t count, off_t offset)
+JL_DLLEXPORT int jl_sizeof_mode_t(void) { return sizeof(mode_t); }
+JL_DLLEXPORT int jl_ftruncate(int fd, int64_t length)
+{
+    return ftruncate(fd, (off_t)length);
+}
+JL_DLLEXPORT int64_t jl_lseek(int fd, int64_t offset, int whence)
+{
+    return lseek(fd, (off_t)offset, whence);
+}
+JL_DLLEXPORT ssize_t jl_pwrite(int fd, const void *buf, size_t count, int64_t offset)
 {
-    return pwrite(fd, buf, count, offset);
+    return pwrite(fd, buf, count, (off_t)offset);
 }
-DLLEXPORT void *jl_mmap(void *addr, size_t length, int prot, int flags,
-                        int fd, off_t offset)
+JL_DLLEXPORT void *jl_mmap(void *addr, size_t length, int prot, int flags,
+                           int fd, int64_t offset)
 {
-    return mmap(addr, length, prot, flags, fd, offset);
+    return mmap(addr, length, prot, flags, fd, (off_t)offset);
 }
 #else
-DLLEXPORT off_t jl_lseek(int fd, off_t offset, int whence) { return _lseek(fd, offset, whence); }
+JL_DLLEXPORT int64_t jl_lseek(int fd, int64_t offset, int whence)
+{
+    return _lseeki64(fd, offset, whence);
+}
 #endif
-DLLEXPORT int jl_sizeof_ios_t(void) { return sizeof(ios_t); }
+JL_DLLEXPORT int jl_sizeof_ios_t(void) { return sizeof(ios_t); }
 
-DLLEXPORT long jl_ios_fd(ios_t *s) { return s->fd; }
+JL_DLLEXPORT long jl_ios_fd(ios_t *s) { return s->fd; }
 
-DLLEXPORT int32_t jl_nb_available(ios_t *s)
+JL_DLLEXPORT int32_t jl_nb_available(ios_t *s)
 {
     return (int32_t)(s->size - s->bpos);
 }
 
 // --- dir/file stuff ---
 
-DLLEXPORT int jl_sizeof_uv_fs_t(void) { return sizeof(uv_fs_t); }
-DLLEXPORT void jl_uv_fs_req_cleanup(uv_fs_t *req)
+JL_DLLEXPORT int jl_sizeof_uv_fs_t(void) { return sizeof(uv_fs_t); }
+JL_DLLEXPORT void jl_uv_fs_req_cleanup(uv_fs_t *req)
 {
     uv_fs_req_cleanup(req);
 }
 
-DLLEXPORT int jl_readdir(const char *path, uv_fs_t *readdir_req)
+JL_DLLEXPORT int jl_readdir(const char *path, uv_fs_t *readdir_req)
 {
     // Note that the flags field is mostly ignored by libuv
     return uv_fs_readdir(uv_default_loop(), readdir_req, path, 0 /*flags*/, NULL);
 }
 
-DLLEXPORT char *jl_uv_fs_t_ptr(uv_fs_t *req) { return (char*)req->ptr; }
-DLLEXPORT char *jl_uv_fs_t_ptr_offset(uv_fs_t *req, int offset) { return (char*)req->ptr + offset; }
-DLLEXPORT int jl_uv_fs_result(uv_fs_t *f) { return f->result; }
+JL_DLLEXPORT char *jl_uv_fs_t_ptr(uv_fs_t *req) { return (char*)req->ptr; }
+JL_DLLEXPORT char *jl_uv_fs_t_ptr_offset(uv_fs_t *req, int offset) { return (char*)req->ptr + offset; }
+JL_DLLEXPORT int jl_uv_fs_result(uv_fs_t *f) { return f->result; }
 
 // --- stat ---
-DLLEXPORT int jl_sizeof_stat(void) { return sizeof(uv_stat_t); }
+JL_DLLEXPORT int jl_sizeof_stat(void) { return sizeof(uv_stat_t); }
 
-DLLEXPORT int32_t jl_stat(const char *path, char *statbuf)
+JL_DLLEXPORT int32_t jl_stat(const char *path, char *statbuf)
 {
     uv_fs_t req;
     int ret;
@@ -125,7 +142,7 @@ DLLEXPORT int32_t jl_stat(const char *path, char *statbuf)
     return ret;
 }
 
-DLLEXPORT int32_t jl_lstat(const char *path, char *statbuf)
+JL_DLLEXPORT int32_t jl_lstat(const char *path, char *statbuf)
 {
     uv_fs_t req;
     int ret;
@@ -137,7 +154,7 @@ DLLEXPORT int32_t jl_lstat(const char *path, char *statbuf)
     return ret;
 }
 
-DLLEXPORT int32_t jl_fstat(int fd, char *statbuf)
+JL_DLLEXPORT int32_t jl_fstat(int fd, char *statbuf)
 {
     uv_fs_t req;
     int ret;
@@ -149,59 +166,59 @@ DLLEXPORT int32_t jl_fstat(int fd, char *statbuf)
     return ret;
 }
 
-DLLEXPORT unsigned int jl_stat_dev(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_dev(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_dev;
 }
 
-DLLEXPORT unsigned int jl_stat_ino(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_ino(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_ino;
 }
 
-DLLEXPORT unsigned int jl_stat_mode(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_mode(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_mode;
 }
 
-DLLEXPORT unsigned int jl_stat_nlink(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_nlink(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_nlink;
 }
 
-DLLEXPORT unsigned int jl_stat_uid(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_uid(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_uid;
 }
 
-DLLEXPORT unsigned int jl_stat_gid(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_gid(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_gid;
 }
 
-DLLEXPORT unsigned int jl_stat_rdev(char *statbuf)
+JL_DLLEXPORT unsigned int jl_stat_rdev(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_rdev;
 }
 
-DLLEXPORT uint64_t jl_stat_size(char *statbuf)
+JL_DLLEXPORT uint64_t jl_stat_size(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_size;
 }
 
-DLLEXPORT uint64_t jl_stat_blksize(char *statbuf)
+JL_DLLEXPORT uint64_t jl_stat_blksize(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_blksize;
 }
 
-DLLEXPORT uint64_t jl_stat_blocks(char *statbuf)
+JL_DLLEXPORT uint64_t jl_stat_blocks(char *statbuf)
 {
     return ((uv_stat_t*)statbuf)->st_blocks;
 }
 
 /*
 // atime is stupid, let's not support it
-DLLEXPORT double jl_stat_atime(char *statbuf)
+JL_DLLEXPORT double jl_stat_atime(char *statbuf)
 {
   uv_stat_t *s;
   s = (uv_stat_t*)statbuf;
@@ -209,14 +226,14 @@ DLLEXPORT double jl_stat_atime(char *statbuf)
 }
 */
 
-DLLEXPORT double jl_stat_mtime(char *statbuf)
+JL_DLLEXPORT double jl_stat_mtime(char *statbuf)
 {
     uv_stat_t *s;
     s = (uv_stat_t*)statbuf;
     return (double)s->st_mtim.tv_sec + (double)s->st_mtim.tv_nsec * 1e-9;
 }
 
-DLLEXPORT double jl_stat_ctime(char *statbuf)
+JL_DLLEXPORT double jl_stat_ctime(char *statbuf)
 {
     uv_stat_t *s;
     s = (uv_stat_t*)statbuf;
@@ -225,7 +242,7 @@ DLLEXPORT double jl_stat_ctime(char *statbuf)
 
 // --- buffer manipulation ---
 
-jl_array_t *jl_takebuf_array(ios_t *s)
+JL_DLLEXPORT jl_array_t *jl_takebuf_array(ios_t *s)
 {
     size_t n;
     jl_array_t *a;
@@ -242,7 +259,7 @@ jl_array_t *jl_takebuf_array(ios_t *s)
     return a;
 }
 
-jl_value_t *jl_takebuf_string(ios_t *s)
+JL_DLLEXPORT jl_value_t *jl_takebuf_string(ios_t *s)
 {
     jl_array_t *a = jl_takebuf_array(s);
     JL_GC_PUSH1(&a);
@@ -253,22 +270,22 @@ jl_value_t *jl_takebuf_string(ios_t *s)
 
 // the returned buffer must be manually freed. To determine the size,
 // call position(s) before using this function.
-void *jl_takebuf_raw(ios_t *s)
+JL_DLLEXPORT void *jl_takebuf_raw(ios_t *s)
 {
     size_t sz;
     void *buf = ios_takebuf(s, &sz);
     return buf;
 }
 
-jl_value_t *jl_readuntil(ios_t *s, uint8_t delim)
+JL_DLLEXPORT jl_value_t *jl_readuntil(ios_t *s, uint8_t delim)
 {
     jl_array_t *a;
     // manually inlined common case
-    char *pd = (char*)memchr(s->buf+s->bpos, delim, s->size - s->bpos);
+    char *pd = (char*)memchr(s->buf+s->bpos, delim, (size_t)(s->size - s->bpos));
     if (pd) {
         size_t n = pd-(s->buf+s->bpos)+1;
         a = jl_alloc_array_1d(jl_array_uint8_type, n);
-        memcpy(jl_array_data(a), s->buf+s->bpos, n);
+        memcpy(jl_array_data(a), s->buf + s->bpos, n);
         s->bpos += n;
     }
     else {
@@ -291,19 +308,16 @@ jl_value_t *jl_readuntil(ios_t *s, uint8_t delim)
     return (jl_value_t*)a;
 }
 
-static void NORETURN throw_eof_error(void)
-{
-    jl_datatype_t *eof_error = (jl_datatype_t*)jl_get_global(jl_base_module, jl_symbol("EOFError"));
-    assert(eof_error != NULL);
-    jl_exceptionf(eof_error, "");
-}
-
-DLLEXPORT uint64_t jl_ios_get_nbyte_int(ios_t *s, const size_t n)
+JL_DLLEXPORT uint64_t jl_ios_get_nbyte_int(ios_t *s, const size_t n)
 {
     assert(n <= 8);
-    size_t ret = ios_readprep(s, n);
-    if (ret < n)
-        throw_eof_error();
+    size_t space, ret;
+    do {
+        space = (size_t)(s->size - s->bpos);
+        ret = ios_readprep(s, n);
+        if (space == ret && ret < n)
+            jl_eof_error();
+    } while(ret < n);
     uint64_t x = 0;
     uint8_t *buf = (uint8_t*)&s->buf[s->bpos];
     if (n == 8) {
@@ -328,8 +342,8 @@ DLLEXPORT uint64_t jl_ios_get_nbyte_int(ios_t *s, const size_t n)
 
 // -- syscall utilities --
 
-int jl_errno(void) { return errno; }
-void jl_set_errno(int e) { errno = e; }
+JL_DLLEXPORT int jl_errno(void) { return errno; }
+JL_DLLEXPORT void jl_set_errno(int e) { errno = e; }
 
 // -- get the number of CPU cores --
 
@@ -340,7 +354,7 @@ typedef DWORD (WINAPI *GAPC)(WORD);
 #endif
 #endif
 
-DLLEXPORT int jl_cpu_cores(void)
+JL_DLLEXPORT int jl_cpu_cores(void)
 {
 #if defined(HW_AVAILCPU) && defined(HW_NCPU)
     size_t len = 4;
@@ -377,7 +391,7 @@ DLLEXPORT int jl_cpu_cores(void)
 
 // -- high resolution timers --
 // Returns time in nanosec
-DLLEXPORT uint64_t jl_hrtime(void)
+JL_DLLEXPORT uint64_t jl_hrtime(void)
 {
     return uv_hrtime();
 }
@@ -392,7 +406,7 @@ extern char **environ;
 #endif
 #endif
 
-jl_value_t *jl_environ(int i)
+JL_DLLEXPORT jl_value_t *jl_environ(int i)
 {
 #ifdef __APPLE__
     char **environ = *_NSGetEnviron();
@@ -431,14 +445,14 @@ JL_STREAM *JL_STDIN  = (JL_STREAM*)STDIN_FILENO;
 JL_STREAM *JL_STDOUT = (JL_STREAM*)STDOUT_FILENO;
 JL_STREAM *JL_STDERR = (JL_STREAM*)STDERR_FILENO;
 
-JL_STREAM *jl_stdin_stream(void)  { return JL_STDIN; }
-JL_STREAM *jl_stdout_stream(void) { return JL_STDOUT; }
-JL_STREAM *jl_stderr_stream(void) { return JL_STDERR; }
+JL_DLLEXPORT JL_STREAM *jl_stdin_stream(void)  { return JL_STDIN; }
+JL_DLLEXPORT JL_STREAM *jl_stdout_stream(void) { return JL_STDOUT; }
+JL_DLLEXPORT JL_STREAM *jl_stderr_stream(void) { return JL_STDERR; }
 
 // CPUID
 
 #ifdef HAVE_CPUID
-DLLEXPORT void jl_cpuid(int32_t CPUInfo[4], int32_t InfoType)
+JL_DLLEXPORT void jl_cpuid(int32_t CPUInfo[4], int32_t InfoType)
 {
 #if defined _MSC_VER
     __cpuid(CPUInfo, InfoType);
@@ -471,7 +485,7 @@ DLLEXPORT void jl_cpuid(int32_t CPUInfo[4], int32_t InfoType)
 // subnormal_flags should be declared atomic.
 static volatile int32_t subnormal_flags = 1;
 
-static int32_t get_subnormal_flags()
+static int32_t get_subnormal_flags(void)
 {
     uint32_t f = subnormal_flags;
     if (f & 1) {
@@ -496,14 +510,14 @@ static int32_t get_subnormal_flags()
 }
 
 // Returns non-zero if subnormals go to 0; zero otherwise.
-DLLEXPORT int32_t jl_get_zero_subnormals(int8_t isZero)
+JL_DLLEXPORT int32_t jl_get_zero_subnormals(int8_t isZero)
 {
     uint32_t flags = get_subnormal_flags();
     return _mm_getcsr() & flags;
 }
 
 // Return zero on success, non-zero on failure.
-DLLEXPORT int32_t jl_set_zero_subnormals(int8_t isZero)
+JL_DLLEXPORT int32_t jl_set_zero_subnormals(int8_t isZero)
 {
     uint32_t flags = get_subnormal_flags();
     if (flags) {
@@ -523,12 +537,12 @@ DLLEXPORT int32_t jl_set_zero_subnormals(int8_t isZero)
 
 #else
 
-DLLEXPORT int32_t jl_get_zero_subnormals(int8_t isZero)
+JL_DLLEXPORT int32_t jl_get_zero_subnormals(int8_t isZero)
 {
     return 0;
 }
 
-DLLEXPORT int32_t jl_set_zero_subnormals(int8_t isZero)
+JL_DLLEXPORT int32_t jl_set_zero_subnormals(int8_t isZero)
 {
     return isZero;
 }
@@ -537,37 +551,27 @@ DLLEXPORT int32_t jl_set_zero_subnormals(int8_t isZero)
 
 // -- processor native alignment information --
 
-DLLEXPORT void jl_native_alignment(uint_t *int8align, uint_t *int16align, uint_t *int32align,
-                                   uint_t *int64align, uint_t *float32align, uint_t *float64align)
+JL_DLLEXPORT void jl_native_alignment(uint_t *int8align, uint_t *int16align, uint_t *int32align,
+                                      uint_t *int64align, uint_t *float32align, uint_t *float64align)
 {
-    LLVMTargetDataRef tgtdata = LLVMCreateTargetData("");
-    *int8align = LLVMPreferredAlignmentOfType(tgtdata, LLVMInt8Type());
-    *int16align = LLVMPreferredAlignmentOfType(tgtdata, LLVMInt16Type());
-    *int32align = LLVMPreferredAlignmentOfType(tgtdata, LLVMInt32Type());
-    *int64align = LLVMPreferredAlignmentOfType(tgtdata, LLVMInt64Type());
-    *float32align = LLVMPreferredAlignmentOfType(tgtdata, LLVMFloatType());
-    *float64align = LLVMPreferredAlignmentOfType(tgtdata, LLVMDoubleType());
-    LLVMDisposeTargetData(tgtdata);
+    *int8align = __alignof(uint8_t);
+    *int16align = __alignof(uint16_t);
+    *int32align = __alignof(uint32_t);
+    *int64align = __alignof(uint64_t);
+    *float32align = __alignof(float);
+    *float64align = __alignof(double);
 }
 
-DLLEXPORT jl_value_t *jl_is_char_signed()
+JL_DLLEXPORT jl_value_t *jl_is_char_signed(void)
 {
     return ((char)255) < 0 ? jl_true : jl_false;
 }
 
-DLLEXPORT void jl_field_offsets(jl_datatype_t *dt, ssize_t *offsets)
-{
-    size_t i;
-    for(i=0; i < jl_datatype_nfields(dt); i++) {
-        offsets[i] = jl_field_offset(dt, i);
-    }
-}
-
 // -- misc sysconf info --
 
 #ifdef _OS_WINDOWS_
 static long cachedPagesize = 0;
-long jl_getpagesize(void)
+JL_DLLEXPORT long jl_getpagesize(void)
 {
     if (!cachedPagesize) {
         SYSTEM_INFO systemInfo;
@@ -577,7 +581,7 @@ long jl_getpagesize(void)
     return cachedPagesize;
 }
 #else
-long jl_getpagesize(void)
+JL_DLLEXPORT long jl_getpagesize(void)
 {
     return sysconf(_SC_PAGESIZE);
 }
@@ -585,7 +589,7 @@ long jl_getpagesize(void)
 
 #ifdef _OS_WINDOWS_
 static long cachedAllocationGranularity = 0;
-long jl_getallocationgranularity(void)
+JL_DLLEXPORT long jl_getallocationgranularity(void)
 {
     if (!cachedAllocationGranularity) {
         SYSTEM_INFO systemInfo;
@@ -595,13 +599,13 @@ long jl_getallocationgranularity(void)
     return cachedAllocationGranularity;
 }
 #else
-long jl_getallocationgranularity(void)
+JL_DLLEXPORT long jl_getallocationgranularity(void)
 {
     return jl_getpagesize();
 }
 #endif
 
-DLLEXPORT long jl_SC_CLK_TCK(void)
+JL_DLLEXPORT long jl_SC_CLK_TCK(void)
 {
 #ifndef _OS_WINDOWS_
     return sysconf(_SC_CLK_TCK);
@@ -610,36 +614,34 @@ DLLEXPORT long jl_SC_CLK_TCK(void)
 #endif
 }
 
-DLLEXPORT size_t jl_get_field_offset(jl_datatype_t *ty, int field)
+JL_DLLEXPORT size_t jl_get_field_offset(jl_datatype_t *ty, int field)
 {
-    if (field > jl_datatype_nfields(ty))
-        jl_error("This type does not have that many fields");
-    return ty->fields[field].offset;
+    if (field > jl_datatype_nfields(ty) || field < 1)
+        jl_bounds_error_int((jl_value_t*)ty, field);
+    return jl_field_offset(ty, field - 1);
 }
 
-DLLEXPORT size_t jl_get_alignment(jl_datatype_t *ty)
+JL_DLLEXPORT size_t jl_get_alignment(jl_datatype_t *ty)
 {
     return ty->alignment;
 }
 
 // Takes a handle (as returned from dlopen()) and returns the absolute path to the image loaded
-DLLEXPORT const char *jl_pathname_for_handle(uv_lib_t *uv_lib)
+JL_DLLEXPORT const char *jl_pathname_for_handle(void *handle)
 {
-    if (!uv_lib)
+    if (!handle)
         return NULL;
 
-    void *handle = uv_lib->handle;
 #ifdef __APPLE__
     // Iterate through all images currently in memory
     for (int32_t i = _dyld_image_count(); i >= 0 ; i--) {
         // dlopen() each image, check handle
         const char *image_name = _dyld_get_image_name(i);
-        uv_lib_t *probe_lib = jl_load_dynamic_library(image_name, JL_RTLD_DEFAULT);
-        void *probe_handle = probe_lib->handle;
-        uv_dlclose(probe_lib);
+        void *probe_lib = jl_load_dynamic_library(image_name, JL_RTLD_DEFAULT);
+        jl_dlclose(probe_lib);
 
         // If the handle is the same as what was passed in (modulo mode bits), return this image name
-        if (((intptr_t)handle & (-4)) == ((intptr_t)probe_handle & (-4)))
+        if (((intptr_t)handle & (-4)) == ((intptr_t)probe_lib & (-4)))
             return image_name;
     }
 
@@ -674,8 +676,8 @@ DLLEXPORT const char *jl_pathname_for_handle(uv_lib_t *uv_lib)
 #if __has_feature(memory_sanitizer)
     __msan_unpoison(&map,sizeof(struct link_map*));
     if (map) {
-      __msan_unpoison(map, sizeof(struct link_map));
-      __msan_unpoison_string(map->l_name);
+        __msan_unpoison(map, sizeof(struct link_map));
+        __msan_unpoison_string(map->l_name);
     }
 #endif
 #endif
@@ -702,23 +704,23 @@ static BOOL CALLBACK jl_EnumerateLoadedModulesProc64(
     return TRUE;
 }
 // Takes a handle (as returned from dlopen()) and returns the absolute path to the image loaded
-DLLEXPORT int jl_dllist(jl_array_t *list)
+JL_DLLEXPORT int jl_dllist(jl_array_t *list)
 {
     return EnumerateLoadedModules64(GetCurrentProcess(), jl_EnumerateLoadedModulesProc64, list);
 }
 #endif
 
-DLLEXPORT void jl_raise_debugger(void)
+JL_DLLEXPORT void jl_raise_debugger(void)
 {
 #if defined(_OS_WINDOWS_)
     if (IsDebuggerPresent() == 1)
         DebugBreak();
 #else
-    raise(SIGINT);
+    raise(SIGTRAP);
 #endif // _OS_WINDOWS_
 }
 
-DLLEXPORT jl_sym_t* jl_get_OS_NAME()
+JL_DLLEXPORT jl_sym_t *jl_get_OS_NAME(void)
 {
 #if defined(_OS_WINDOWS_)
     return jl_symbol("Windows");
@@ -734,14 +736,36 @@ DLLEXPORT jl_sym_t* jl_get_OS_NAME()
 #endif
 }
 
-DLLEXPORT jl_sym_t* jl_get_ARCH()
+JL_DLLEXPORT jl_sym_t *jl_get_ARCH(void)
 {
-    static jl_sym_t* ARCH = NULL;
+    static jl_sym_t *ARCH = NULL;
     if (!ARCH)
         ARCH = (jl_sym_t*) jl_get_global(jl_base_module, jl_symbol("ARCH"));
     return ARCH;
 }
 
+JL_DLLEXPORT size_t jl_maxrss(void)
+{
+#if defined(_OS_WINDOWS_)
+    PROCESS_MEMORY_COUNTERS counter;
+    GetProcessMemoryInfo( GetCurrentProcess( ), &counter, sizeof(counter) );
+    return (size_t)counter.PeakWorkingSetSize;
+
+#elif defined(_OS_LINUX_) || defined(_OS_DARWIN_) || defined (_OS_FREEBSD_)
+    struct rusage rusage;
+    getrusage( RUSAGE_SELF, &rusage );
+
+#if defined(_OS_LINUX_)
+    return (size_t)(rusage.ru_maxrss * 1024);
+#else
+    return (size_t)rusage.ru_maxrss;
+#endif
+
+#else
+    return (size_t)0;
+#endif
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/table.c b/src/table.c
index eb15018c34f36..1a304ba5f3cbb 100644
--- a/src/table.c
+++ b/src/table.c
@@ -6,7 +6,7 @@
 #define max_probe(size) ((size)<=1024 ? 16 : (size)>>6)
 
 #define keyhash(k)     jl_object_id(k)
-#define h2index(hv,sz) (index_t)(((hv) & ((sz)-1))*2)
+#define h2index(hv,sz) (size_t)(((hv) & ((sz)-1))*2)
 
 static void **jl_table_lookup_bp(jl_array_t **pa, void *key);
 
@@ -113,7 +113,7 @@ static void **jl_table_peek_bp(jl_array_t *a, void *key)
     return NULL;
 }
 
-DLLEXPORT
+JL_DLLEXPORT
 jl_array_t *jl_eqtable_put(jl_array_t *h, void *key, void *val)
 {
     void **bp = jl_table_lookup_bp(&h, key);
@@ -122,7 +122,7 @@ jl_array_t *jl_eqtable_put(jl_array_t *h, void *key, void *val)
     return h;
 }
 
-DLLEXPORT
+JL_DLLEXPORT
 jl_value_t *jl_eqtable_get(jl_array_t *h, void *key, jl_value_t *deflt)
 {
     void **bp = jl_table_peek_bp(h, key);
@@ -131,7 +131,7 @@ jl_value_t *jl_eqtable_get(jl_array_t *h, void *key, jl_value_t *deflt)
     return (jl_value_t*)*bp;
 }
 
-DLLEXPORT
+JL_DLLEXPORT
 jl_value_t *jl_eqtable_pop(jl_array_t *h, void *key, jl_value_t *deflt)
 {
     void **bp = jl_table_peek_bp(h, key);
@@ -143,7 +143,7 @@ jl_value_t *jl_eqtable_pop(jl_array_t *h, void *key, jl_value_t *deflt)
     return val;
 }
 
-DLLEXPORT
+JL_DLLEXPORT
 size_t jl_eqtable_nextind(jl_array_t *t, size_t i)
 {
     if (i&1) i++;
diff --git a/src/task.c b/src/task.c
index 4fc7b28a003d6..66f5e83fa536a 100644
--- a/src/task.c
+++ b/src/task.c
@@ -14,6 +14,7 @@
 #include <inttypes.h>
 #include "julia.h"
 #include "julia_internal.h"
+#include "threading.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -26,9 +27,7 @@ extern "C" {
 volatile int jl_in_stackwalk = 0;
 #else
 #include <unistd.h>
-// This gives unwind only local unwinding options ==> faster code
-#define UNW_LOCAL_ONLY
-#include <libunwind.h>
+#include <sys/mman.h> // for mprotect
 #include <dlfcn.h>   // for dladdr
 #endif
 
@@ -130,33 +129,23 @@ static void _probe_arch(void)
 
 /* end probing code */
 
-/*
-  TODO:
-  - per-task storage (scheme-like parameters)
-  - stack growth
-*/
-
 static jl_sym_t *done_sym;
 static jl_sym_t *failed_sym;
 static jl_sym_t *runnable_sym;
 
 extern size_t jl_page_size;
 jl_datatype_t *jl_task_type;
-DLLEXPORT JL_THREAD jl_task_t * volatile jl_current_task;
-JL_THREAD jl_task_t *jl_root_task;
-DLLEXPORT JL_THREAD jl_value_t *jl_exception_in_transit;
-DLLEXPORT JL_THREAD jl_gcframe_t *jl_pgcstack = NULL;
+#define jl_root_task (jl_get_ptls_states()->root_task)
 
 #ifdef COPY_STACKS
-static JL_THREAD jl_jmp_buf * volatile jl_jmp_target;
+#define jl_jmp_target (jl_get_ptls_states()->jmp_target)
 
 #if (defined(_CPU_X86_64_) || defined(_CPU_X86_)) && !defined(_COMPILER_MICROSOFT_)
 #define ASM_COPY_STACKS
 #endif
-JL_THREAD void *jl_stackbase;
 
 #ifndef ASM_COPY_STACKS
-static JL_THREAD jl_jmp_buf jl_base_ctx; // base context of stack
+#define jl_base_ctx (jl_get_ptls_states()->base_ctx)
 #endif
 
 static void NOINLINE save_stack(jl_task_t *t)
@@ -182,7 +171,7 @@ static void NOINLINE save_stack(jl_task_t *t)
     jl_gc_wb_back(t);
 }
 
-void NOINLINE restore_stack(jl_task_t *t, jl_jmp_buf *where, char *p)
+static void NOINLINE restore_stack(jl_task_t *t, jl_jmp_buf *where, char *p)
 {
     char *_x = (char*)jl_stackbase - t->ssize;
     if (!p) {
@@ -201,7 +190,7 @@ void NOINLINE restore_stack(jl_task_t *t, jl_jmp_buf *where, char *p)
 
 static jl_function_t *task_done_hook_func=NULL;
 
-static void NORETURN finish_task(jl_task_t *t, jl_value_t *resultval)
+static void JL_NORETURN finish_task(jl_task_t *t, jl_value_t *resultval)
 {
     if (t->exception != jl_nothing)
         t->state = failed_sym;
@@ -211,15 +200,24 @@ static void NORETURN finish_task(jl_task_t *t, jl_value_t *resultval)
     jl_gc_wb(t, t->result);
     // TODO: early free of t->stkbuf
 #ifdef COPY_STACKS
-    t->stkbuf = NULL;
+    t->stkbuf = (void*)(intptr_t)-1;
 #endif
+    if (ti_tid != 0) {
+        // For now, only thread 0 runs the task scheduler.
+        // The others return to the thread loop
+        jl_switchto(jl_root_task, jl_nothing);
+        gc_debug_critical_error();
+        abort();
+    }
     if (task_done_hook_func == NULL) {
         task_done_hook_func = (jl_function_t*)jl_get_global(jl_base_module,
                                                             jl_symbol("task_done_hook"));
     }
     if (task_done_hook_func != NULL) {
-        jl_apply(task_done_hook_func, (jl_value_t**)&t, 1);
+        jl_value_t *args[2] = {task_done_hook_func, (jl_value_t*)t};
+        jl_apply(args, 2);
     }
+    gc_debug_critical_error();
     abort();
 }
 
@@ -232,57 +230,54 @@ static void throw_if_exception_set(jl_task_t *t)
     }
 }
 
-static void NOINLINE NORETURN start_task()
+static void record_backtrace(void);
+static void NOINLINE JL_NORETURN start_task(void)
 {
     // this runs the first time we switch to a task
     jl_task_t *t = jl_current_task;
-    throw_if_exception_set(t);
-    jl_value_t *res = jl_apply(t->start, NULL, 0);
+    jl_value_t *res;
+    t->started = 1;
+    if (t->exception != NULL && t->exception != jl_nothing) {
+        record_backtrace();
+        res = t->exception;
+    }
+    else {
+        JL_TRY {
+            res = jl_apply(&t->start, 1);
+        }
+        JL_CATCH {
+            res = jl_exception_in_transit;
+            t->exception = res;
+            jl_gc_wb(t, res);
+        }
+    }
     finish_task(t, res);
+    gc_debug_critical_error();
     abort();
 }
 
-#ifndef ASM_COPY_STACKS
-static void NOINLINE set_base_ctx(char *__stk)
+#ifdef COPY_STACKS
+void NOINLINE jl_set_base_ctx(char *__stk)
 {
+    jl_stackbase = (char*)(((uintptr_t)__stk + sizeof(*__stk))&-16); // also ensures stackbase is 16-byte aligned
+#ifndef ASM_COPY_STACKS
     if (jl_setjmp(jl_base_ctx, 1)) {
         start_task();
     }
+#endif
 }
-#else
-void set_base_ctx(char *__stk) { }
 #endif
 
-
-DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
-{ // keep this function small, since we want to keep the stack frame
-  // leading up to this also quite small
+JL_DLLEXPORT void julia_init(JL_IMAGE_SEARCH rel)
+{
+    // keep this function small, since we want to keep the stack frame
+    // leading up to this also quite small
     _julia_init(rel);
 #ifdef COPY_STACKS
     char __stk;
-    jl_stackbase = (char*)(((uptrint_t)&__stk + sizeof(__stk))&-16); // also ensures stackbase is 16-byte aligned
-    set_base_ctx(&__stk); // separate function, to record the size of a stack frame
-#endif
-}
-
-#ifndef COPY_STACKS
-static void init_task(jl_task_t *t)
-{
-    if (jl_setjmp(t->ctx, 0)) {
-        start_task();
-    }
-    // this runs when the task is created
-    ptrint_t local_sp = (ptrint_t)&t;
-    ptrint_t new_sp = (ptrint_t)t->stack + t->ssize - _frame_offset;
-#ifdef _P64
-    // SP must be 16-byte aligned
-    new_sp = new_sp&-16;
-    local_sp = local_sp&-16;
+    jl_set_base_ctx(&__stk); // separate function, to record the size of a stack frame
 #endif
-    memcpy((void*)new_sp, (void*)local_sp, _frame_offset);
-    rebase_state(&t->ctx, local_sp, new_sp);
 }
-#endif
 
 static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
 {
@@ -302,7 +297,7 @@ static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
     */
     //JL_SIGATOMIC_BEGIN();
     if (!jl_setjmp(jl_current_task->ctx, 0)) {
-        bt_size = 0;  // backtraces don't survive task switches, see e.g. issue #12485
+        jl_bt_size = 0;  // backtraces don't survive task switches, see e.g. issue #12485
 #ifdef COPY_STACKS
         jl_task_t *lastt = jl_current_task;
         save_stack(lastt);
@@ -311,6 +306,15 @@ static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
         // set up global state for new task
         jl_current_task->gcstack = jl_pgcstack;
         jl_pgcstack = t->gcstack;
+#ifdef JULIA_ENABLE_THREADING
+        // If the current task is not holding any locks, free the locks list
+        // so that it can be GC'd without leaking memory
+        arraylist_t *locks = &jl_current_task->locks;
+        if (locks->len == 0 && locks->items != locks->_space) {
+            arraylist_free(locks);
+            arraylist_new(locks, 0);
+        }
+#endif
 
         // restore task's current module, looking at parent tasks
         // if it hasn't set one.
@@ -322,8 +326,6 @@ static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
             jl_current_module = last->current_module;
         }
 
-        t->last = jl_current_task;
-        jl_gc_wb(t, t->last);
         jl_current_task = t;
 
 #ifdef COPY_STACKS
@@ -335,7 +337,7 @@ static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
             void *stackbase = jl_stackbase;
 #ifdef _CPU_X86_64_
 #ifdef _OS_WINDOWS_
-            stackbase -= 0x20;
+            stackbase = (char*)stackbase - 0x20;
 #endif
             asm(" movq %0, %%rsp;\n"
                 " xorq %%rbp, %%rbp;\n"
@@ -364,22 +366,27 @@ static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
     //JL_SIGATOMIC_END();
 }
 
-JL_THREAD jl_value_t * volatile jl_task_arg_in_transit;
-extern int jl_in_gc;
-DLLEXPORT jl_value_t *jl_switchto(jl_task_t *t, jl_value_t *arg)
+JL_DLLEXPORT jl_value_t *jl_switchto(jl_task_t *t, jl_value_t *arg)
 {
-    if (t->state == done_sym || t->state == failed_sym) {
+    if (t == jl_current_task) {
+        throw_if_exception_set(t);
+        return arg;
+    }
+    if (t->state == done_sym || t->state == failed_sym ||
+        (t->stkbuf == (void*)(intptr_t)-1)) {
         if (t->exception != jl_nothing)
             jl_throw(t->exception);
         return t->result;
     }
-    if (jl_in_gc)
+    if (jl_in_finalizer)
         jl_error("task switch not allowed from inside gc finalizer");
+    int8_t gc_state = jl_gc_unsafe_enter();
     jl_task_arg_in_transit = arg;
     ctx_switch(t, &t->ctx);
     jl_value_t *val = jl_task_arg_in_transit;
     jl_task_arg_in_transit = jl_nothing;
     throw_if_exception_set(jl_current_task);
+    jl_gc_unsafe_leave(gc_state);
     return val;
 }
 
@@ -434,8 +441,8 @@ static intptr_t ptr_demangle(intptr_t p)
 /* rebase any values in saved state to the new stack */
 static void rebase_state(jl_jmp_buf *ctx, intptr_t local_sp, intptr_t new_sp)
 {
-    ptrint_t *s = (ptrint_t*)ctx;
-    ptrint_t diff = new_sp - local_sp; /* subtract old base, and add new base */
+    intptr_t *s = (intptr_t*)ctx;
+    intptr_t diff = new_sp - local_sp; /* subtract old base, and add new base */
 #if defined(__linux__) && defined(__i386__)
     s[3] += diff;
     if (mangle_pointers)
@@ -461,23 +468,39 @@ static void rebase_state(jl_jmp_buf *ctx, intptr_t local_sp, intptr_t new_sp)
 #error "COPY_STACKS must be defined on this platform."
 #endif
 }
+static void init_task(jl_task_t *t, char *stack)
+{
+    if (jl_setjmp(t->ctx, 0)) {
+        start_task();
+    }
+    // this runs when the task is created
+    intptr_t local_sp = (intptr_t)&t;
+    intptr_t new_sp = (intptr_t)stack + t->ssize - _frame_offset;
+#ifdef _P64
+    // SP must be 16-byte aligned
+    new_sp = new_sp&-16;
+    local_sp = local_sp&-16;
+#endif
+    memcpy((void*)new_sp, (void*)local_sp, _frame_offset);
+    rebase_state(&t->ctx, local_sp, new_sp);
+}
 
 #endif /* !COPY_STACKS */
 
-ptrint_t bt_data[MAX_BT_SIZE+1];
-size_t bt_size = 0;
-
 // Always Set *func_name and *file_name to malloc'd pointers (non-NULL)
 static int frame_info_from_ip(char **func_name,
                               char **file_name, size_t *line_num,
                               char **inlinedat_file, size_t *inlinedat_line,
+                              jl_lambda_info_t **outer_linfo,
                               size_t ip, int skipC, int skipInline)
 {
+    // This function is not allowed to reference any TLS variables since
+    // it can be called from an unmanaged thread on OSX.
     static const char *name_unknown = "???";
     int fromC = 0;
 
-    jl_getFunctionInfo(func_name, file_name, line_num, inlinedat_file, inlinedat_line, ip, &fromC,
-                       skipC, skipInline);
+    jl_getFunctionInfo(func_name, file_name, line_num, inlinedat_file, inlinedat_line, outer_linfo,
+            ip, &fromC, skipC, skipInline);
     if (!*func_name) {
         *func_name = strdup(name_unknown);
         *line_num = ip;
@@ -547,14 +570,15 @@ static DWORD64 WINAPI JuliaGetModuleBase64(
 
 int needsSymRefreshModuleList;
 BOOL (WINAPI *hSymRefreshModuleList)(HANDLE);
-DLLEXPORT size_t rec_backtrace(ptrint_t *data, size_t maxsize)
+JL_DLLEXPORT size_t rec_backtrace(intptr_t *data, size_t maxsize)
 {
     CONTEXT Context;
     memset(&Context, 0, sizeof(Context));
     RtlCaptureContext(&Context);
     return rec_backtrace_ctx(data, maxsize, &Context);
 }
-DLLEXPORT size_t rec_backtrace_ctx(ptrint_t *data, size_t maxsize, CONTEXT *Context)
+JL_DLLEXPORT size_t rec_backtrace_ctx(intptr_t *data, size_t maxsize,
+                                      CONTEXT *Context)
 {
     if (needsSymRefreshModuleList && hSymRefreshModuleList != 0 && !jl_in_stackwalk) {
         jl_in_stackwalk = 1;
@@ -636,34 +660,47 @@ DLLEXPORT size_t rec_backtrace_ctx(ptrint_t *data, size_t maxsize, CONTEXT *Cont
 }
 #else
 // stacktrace using libunwind
-DLLEXPORT size_t rec_backtrace(ptrint_t *data, size_t maxsize)
+JL_DLLEXPORT size_t rec_backtrace(intptr_t *data, size_t maxsize)
 {
     unw_context_t uc;
     unw_getcontext(&uc);
     return rec_backtrace_ctx(data, maxsize, &uc);
 }
-DLLEXPORT size_t rec_backtrace_ctx(ptrint_t *data, size_t maxsize, unw_context_t *uc)
+JL_DLLEXPORT size_t rec_backtrace_ctx(intptr_t *data, size_t maxsize,
+                                      unw_context_t *uc)
 {
 #if !defined(_CPU_ARM_) && !defined(_CPU_PPC64_)
-    unw_cursor_t cursor;
-    unw_word_t ip;
-    size_t n=0;
-
-    unw_init_local(&cursor, uc);
-    do {
-        if (n >= maxsize)
-            break;
-        if (unw_get_reg(&cursor, UNW_REG_IP, &ip) < 0)
-            break;
-        data[n++] = ip;
-    } while (unw_step(&cursor) > 0);
+    volatile size_t n = 0;
+    jl_jmp_buf *old_buf = jl_safe_restore;
+    jl_jmp_buf buf;
+    jl_safe_restore = &buf;
+    if (!jl_setjmp(buf, 0)) {
+        unw_cursor_t cursor;
+        unw_init_local(&cursor, uc);
+        do {
+            unw_word_t ip;
+            if (n >= maxsize)
+                break;
+            if (unw_get_reg(&cursor, UNW_REG_IP, &ip) < 0)
+                break;
+            data[n++] = ip;
+        } while (unw_step(&cursor) > 0);
+    }
+    else {
+        // The unwinding fails likely because a invalid memory read.
+        // Back off one frame since it is likely invalid.
+        // This seems to be good enough on x86 to make the LLVM debug info
+        // reader happy.
+        n = n > 0 ? n - 1 : n;
+    }
+    jl_safe_restore = old_buf;
     return n;
 #else
     return 0;
 #endif
 }
 #ifdef LIBOSXUNWIND
-size_t rec_backtrace_ctx_dwarf(ptrint_t *data, size_t maxsize, unw_context_t *uc)
+size_t rec_backtrace_ctx_dwarf(intptr_t *data, size_t maxsize, unw_context_t *uc)
 {
     unw_cursor_t cursor;
     unw_word_t ip;
@@ -684,11 +721,11 @@ size_t rec_backtrace_ctx_dwarf(ptrint_t *data, size_t maxsize, unw_context_t *uc
 
 static void record_backtrace(void)
 {
-    bt_size = rec_backtrace(bt_data, MAX_BT_SIZE);
+    jl_bt_size = rec_backtrace(jl_bt_data, JL_MAX_BT_SIZE);
 }
 
 static jl_value_t *array_ptr_void_type = NULL;
-DLLEXPORT jl_value_t *jl_backtrace_from_here(void)
+JL_DLLEXPORT jl_value_t *jl_backtrace_from_here(void)
 {
     jl_svec_t *tp = NULL;
     jl_array_t *bt = NULL;
@@ -697,32 +734,35 @@ DLLEXPORT jl_value_t *jl_backtrace_from_here(void)
         tp = jl_svec2(jl_voidpointer_type, jl_box_long(1));
         array_ptr_void_type = jl_apply_type((jl_value_t*)jl_array_type, tp);
     }
-    bt = jl_alloc_array_1d(array_ptr_void_type, MAX_BT_SIZE);
-    size_t n = rec_backtrace((ptrint_t*)jl_array_data(bt), MAX_BT_SIZE);
-    if (n < MAX_BT_SIZE)
-        jl_array_del_end(bt, MAX_BT_SIZE-n);
+    bt = jl_alloc_array_1d(array_ptr_void_type, JL_MAX_BT_SIZE);
+    size_t n = rec_backtrace((intptr_t*)jl_array_data(bt), JL_MAX_BT_SIZE);
+    if (n < JL_MAX_BT_SIZE)
+        jl_array_del_end(bt, JL_MAX_BT_SIZE-n);
     JL_GC_POP();
     return (jl_value_t*)bt;
 }
 
-DLLEXPORT jl_value_t *jl_lookup_code_address(void *ip, int skipC)
+JL_DLLEXPORT jl_value_t *jl_lookup_code_address(void *ip, int skipC)
 {
     char *func_name;
     size_t line_num;
     char *file_name;
     size_t inlinedat_line;
     char *inlinedat_file;
+    jl_lambda_info_t *outer_linfo;
     int fromC = frame_info_from_ip(&func_name, &file_name, &line_num,
-                                   &inlinedat_file, &inlinedat_line, (size_t)ip, skipC, 0);
-    jl_value_t *r = (jl_value_t*)jl_alloc_svec(7);
+                                   &inlinedat_file, &inlinedat_line, &outer_linfo,
+                                   (size_t)ip, skipC, 0);
+    jl_value_t *r = (jl_value_t*)jl_alloc_svec(8);
     JL_GC_PUSH1(&r);
     jl_svecset(r, 0, jl_symbol(func_name));
     jl_svecset(r, 1, jl_symbol(file_name));
     jl_svecset(r, 2, jl_box_long(line_num));
     jl_svecset(r, 3, jl_symbol(inlinedat_file ? inlinedat_file : ""));
     jl_svecset(r, 4, jl_box_long(inlinedat_file ? inlinedat_line : -1));
-    jl_svecset(r, 5, jl_box_bool(fromC));
-    jl_svecset(r, 6, jl_box_long((intptr_t)ip));
+    jl_svecset(r, 5, outer_linfo != NULL ? (jl_value_t*)outer_linfo : jl_nothing);
+    jl_svecset(r, 6, jl_box_bool(fromC));
+    jl_svecset(r, 7, jl_box_long((intptr_t)ip));
     free(func_name);
     free(file_name);
     free(inlinedat_file);
@@ -730,7 +770,7 @@ DLLEXPORT jl_value_t *jl_lookup_code_address(void *ip, int skipC)
     return r;
 }
 
-DLLEXPORT jl_value_t *jl_get_backtrace(void)
+JL_DLLEXPORT jl_value_t *jl_get_backtrace(void)
 {
     jl_svec_t *tp = NULL;
     jl_array_t *bt = NULL;
@@ -739,45 +779,60 @@ DLLEXPORT jl_value_t *jl_get_backtrace(void)
         tp = jl_svec2(jl_voidpointer_type, jl_box_long(1));
         array_ptr_void_type = jl_apply_type((jl_value_t*)jl_array_type, tp);
     }
-    bt = jl_alloc_array_1d(array_ptr_void_type, bt_size);
-    memcpy(bt->data, bt_data, bt_size*sizeof(void*));
+    bt = jl_alloc_array_1d(array_ptr_void_type, jl_bt_size);
+    memcpy(bt->data, jl_bt_data, jl_bt_size*sizeof(void*));
     JL_GC_POP();
     return (jl_value_t*)bt;
 }
 
 //for looking up functions from gdb:
-DLLEXPORT void gdblookup(ptrint_t ip)
+JL_DLLEXPORT void jl_gdblookup(intptr_t ip)
 {
+    // This function is not allowed to reference any TLS variables since
+    // it can be called from an unmanaged thread on OSX.
     char *func_name;
     size_t line_num;
     char *file_name;
     size_t inlinedat_line;
     char *inlinedat_file;
-    frame_info_from_ip(&func_name, &file_name, &line_num, &inlinedat_file, &inlinedat_line, ip,
-                      /* skipC */ 0, /* skipInline */ 1);
+    jl_lambda_info_t *outer_linfo;
+    frame_info_from_ip(&func_name, &file_name, &line_num,
+            &inlinedat_file, &inlinedat_line, &outer_linfo, ip,
+            /* skipC */ 0, /* skipInline */ 0);
     if (line_num == ip) {
         jl_safe_printf("unknown function (ip: %p)\n", (void*)ip);
     }
-    else if (line_num == -1) {
-        jl_safe_printf("%s at %s (unknown line)\n", func_name, file_name);
-    }
     else {
-        jl_safe_printf("%s at %s:%" PRIuPTR "\n", func_name, file_name,
-                       (uintptr_t)line_num);
+        if (line_num != -1) {
+            jl_safe_printf("%s at %s:%" PRIuPTR "\n", inlinedat_file ? "[inline]" : func_name, file_name,
+                           (uintptr_t)line_num);
+        }
+        else {
+            jl_safe_printf("%s at %s (unknown line)\n", inlinedat_file ? "[inline]" : func_name, file_name);
+        }
+        if (inlinedat_file) {
+            if (inlinedat_line != -1) {
+                jl_safe_printf("%s at %s:%" PRIuPTR "\n", func_name, inlinedat_file,
+                               (uintptr_t)inlinedat_line);
+            }
+            else {
+                jl_safe_printf("%s at %s (unknown line)\n", func_name, inlinedat_file);
+            }
+        }
     }
     free(func_name);
     free(file_name);
     free(inlinedat_file);
 }
 
-DLLEXPORT void jlbacktrace()
+JL_DLLEXPORT void jlbacktrace(void)
 {
-    size_t n = bt_size; //bt_size > 40 ? 40 : bt_size;
-    for(size_t i=0; i < n; i++)
-        gdblookup(bt_data[i]);
+    size_t n = jl_bt_size; // jl_bt_size > 40 ? 40 : jl_bt_size;
+    for (size_t i=0; i < n; i++)
+        jl_gdblookup(jl_bt_data[i]);
 }
 
-DLLEXPORT void gdbbacktrace()
+JL_DLLEXPORT void jl_gdbbacktrace(void)
 {
     record_backtrace();
     jlbacktrace();
@@ -785,62 +840,58 @@ DLLEXPORT void gdbbacktrace()
 
 
 // yield to exception handler
-void NORETURN throw_internal(jl_value_t *e)
+void JL_NORETURN throw_internal(jl_value_t *e)
 {
+    if (jl_safe_restore)
+        jl_longjmp(*jl_safe_restore, 1);
+    jl_gc_unsafe_enter();
     assert(e != NULL);
     jl_exception_in_transit = e;
     if (jl_current_task->eh != NULL) {
         jl_longjmp(jl_current_task->eh->eh_ctx, 1);
     }
     else {
-        if (jl_current_task == jl_root_task) {
-            jl_printf(JL_STDERR, "fatal: error thrown and no exception handler available.\n");
-            jl_static_show(JL_STDERR, e);
-            jl_printf(JL_STDERR, "\n");
-            jlbacktrace();
-            jl_exit(1);
-        }
-        jl_current_task->exception = e;
-        jl_gc_wb(jl_current_task, e);
-        finish_task(jl_current_task, e);
-        assert(0);
+        jl_printf(JL_STDERR, "fatal: error thrown and no exception handler available.\n");
+        jl_static_show(JL_STDERR, e);
+        jl_printf(JL_STDERR, "\n");
+        jlbacktrace();
+        jl_exit(1);
     }
     assert(0);
 }
 
 // record backtrace and raise an error
-DLLEXPORT void jl_throw(jl_value_t *e)
+JL_DLLEXPORT void jl_throw(jl_value_t *e)
 {
     assert(e != NULL);
-    record_backtrace();
+    if (!jl_safe_restore)
+        record_backtrace();
     throw_internal(e);
 }
 
-DLLEXPORT void jl_rethrow(void)
+JL_DLLEXPORT void jl_rethrow(void)
 {
     throw_internal(jl_exception_in_transit);
 }
 
-DLLEXPORT void jl_rethrow_other(jl_value_t *e)
+JL_DLLEXPORT void jl_rethrow_other(jl_value_t *e)
 {
     throw_internal(e);
 }
 
-DLLEXPORT void jl_throw_with_superfluous_argument(jl_value_t *e, int line)
-{
-    jl_throw(e);
-}
-
-DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize)
+JL_DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize)
 {
     size_t pagesz = jl_page_size;
     jl_task_t *t = (jl_task_t*)jl_gc_allocobj(sizeof(jl_task_t));
     jl_set_typeof(t, jl_task_type);
+#ifndef COPY_STACKS
+    if (ssize == 0) // unspecified -- pick some default size
+        ssize = 1*1024*1024; // 1M (for now)
+#endif
     ssize = LLT_ALIGN(ssize, pagesz);
     t->ssize = ssize;
     t->current_module = NULL;
     t->parent = jl_current_task;
-    t->last = NULL;
     t->tls = jl_nothing;
     t->consumers = jl_nothing;
     t->state = runnable_sym;
@@ -853,6 +904,8 @@ DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize)
     t->eh = NULL;
     t->gcstack = NULL;
     t->stkbuf = NULL;
+    t->tid = 0;
+    t->started = 0;
 
 #ifdef COPY_STACKS
     t->bufsz = 0;
@@ -862,18 +915,20 @@ DLLEXPORT jl_task_t *jl_new_task(jl_function_t *start, size_t ssize)
     char *stk = allocb(ssize+pagesz+(pagesz-1));
     t->stkbuf = stk;
     jl_gc_wb_buf(t, t->stkbuf);
-    stk = (char*)LLT_ALIGN((uptrint_t)stk, pagesz);
+    stk = (char*)LLT_ALIGN((uintptr_t)stk, pagesz);
     // add a guard page to detect stack overflow
-    // the GC might read this area, which is ok, just prevent writes
-    if (mprotect(stk, pagesz-1, PROT_READ) == -1)
+    if (mprotect(stk, pagesz-1, PROT_NONE) == -1)
         jl_errorf("mprotect: %s", strerror(errno));
-    t->stack = stk+pagesz;
+    stk += pagesz;
 
-    init_task(t);
+    init_task(t, stk);
+    //jl_gc_add_finalizer((jl_value_t*)t, jl_unprotect_stack_func);
     JL_GC_POP();
-    jl_gc_add_finalizer((jl_value_t*)t, jl_unprotect_stack_func);
 #endif
 
+#ifdef JULIA_ENABLE_THREADING
+    arraylist_new(&t->locks, 0);
+#endif
     return t;
 }
 
@@ -881,14 +936,15 @@ JL_CALLABLE(jl_unprotect_stack)
 {
 #ifndef COPY_STACKS
     jl_task_t *t = (jl_task_t*)args[0];
-    char *stk = t->stack-jl_page_size;
+    size_t pagesz = jl_page_size;
+    char *stk = (char*)LLT_ALIGN((uintptr_t)t->stkbuf, pagesz);
     // unprotect stack so it can be reallocated for something else
-    mprotect(stk, jl_page_size-1, PROT_READ|PROT_WRITE|PROT_EXEC);
+    mprotect(stk, pagesz - 1, PROT_READ|PROT_WRITE);
 #endif
     return jl_nothing;
 }
 
-DLLEXPORT jl_value_t *jl_get_current_task(void)
+JL_DLLEXPORT jl_value_t *jl_get_current_task(void)
 {
     return (jl_value_t*)jl_current_task;
 }
@@ -902,9 +958,8 @@ void jl_init_tasks(void)
     jl_task_type = jl_new_datatype(jl_symbol("Task"),
                                    jl_any_type,
                                    jl_emptysvec,
-                                   jl_svec(10,
+                                   jl_svec(9,
                                             jl_symbol("parent"),
-                                            jl_symbol("last"),
                                             jl_symbol("storage"),
                                             jl_symbol("state"),
                                             jl_symbol("consumers"),
@@ -913,20 +968,20 @@ void jl_init_tasks(void)
                                             jl_symbol("exception"),
                                             jl_symbol("backtrace"),
                                             jl_symbol("code")),
-                                   jl_svec(10,
-                                            jl_any_type, jl_any_type,
+                                   jl_svec(9,
+                                            jl_any_type,
                                             jl_any_type, jl_sym_type,
                                             jl_any_type, jl_any_type,
                                             jl_any_type, jl_any_type,
-                                            jl_any_type, jl_function_type),
-                                   0, 1, 0);
+                                            jl_any_type, jl_any_type),
+                                   0, 1, 8);
     jl_svecset(jl_task_type->types, 0, (jl_value_t*)jl_task_type);
 
     done_sym = jl_symbol("done");
     failed_sym = jl_symbol("failed");
     runnable_sym = jl_symbol("runnable");
 
-    jl_unprotect_stack_func = jl_new_closure(jl_unprotect_stack, (jl_value_t*)jl_emptysvec, NULL);
+    //jl_unprotect_stack_func = jl_new_closure(jl_unprotect_stack, (jl_value_t*)jl_emptysvec, NULL);
 }
 
 // Initialize a root task using the given stack.
@@ -937,15 +992,15 @@ void jl_init_root_task(void *stack, size_t ssize)
 #ifdef COPY_STACKS
     jl_current_task->ssize = 0;  // size of saved piece
     jl_current_task->bufsz = 0;
+    jl_current_task->stkbuf = NULL;
 #else
-    jl_current_task->stack = stack;
     jl_current_task->ssize = ssize;
+    jl_current_task->stkbuf = stack;
 #endif
-    jl_current_task->stkbuf = NULL;
+    jl_current_task->started = 1;
     jl_current_task->parent = jl_current_task;
     jl_current_task->current_module = jl_current_module;
-    jl_current_task->last = jl_current_task;
-    jl_current_task->tls = NULL;
+    jl_current_task->tls = jl_nothing;
     jl_current_task->consumers = jl_nothing;
     jl_current_task->state = runnable_sym;
     jl_current_task->start = NULL;
@@ -955,6 +1010,10 @@ void jl_init_root_task(void *stack, size_t ssize)
     jl_current_task->backtrace = jl_nothing;
     jl_current_task->eh = NULL;
     jl_current_task->gcstack = NULL;
+    jl_current_task->tid = ti_tid;
+#ifdef JULIA_ENABLE_THREADING
+    arraylist_new(&jl_current_task->locks, 0);
+#endif
 
     jl_root_task = jl_current_task;
 
@@ -962,6 +1021,11 @@ void jl_init_root_task(void *stack, size_t ssize)
     jl_task_arg_in_transit = (jl_value_t*)jl_nothing;
 }
 
+JL_DLLEXPORT int jl_is_task_started(jl_task_t *t)
+{
+    return t->started;
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/threadgroup.c b/src/threadgroup.c
new file mode 100644
index 0000000000000..c728204c17d7b
--- /dev/null
+++ b/src/threadgroup.c
@@ -0,0 +1,208 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+/*
+  threading infrastructure
+  . threadgroup abstraction
+  . fork/join/barrier
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "julia.h"
+#include "julia_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "options.h"
+#include "threadgroup.h"
+
+int ti_threadgroup_create(uint8_t num_sockets, uint8_t num_cores,
+                          uint8_t num_threads_per_core,
+                          ti_threadgroup_t **newtg)
+{
+    int i;
+    ti_threadgroup_t *tg;
+    int num_threads = num_sockets * num_cores * num_threads_per_core;
+    char *cp;
+
+    tg = (ti_threadgroup_t*)jl_malloc_aligned(sizeof(ti_threadgroup_t), 64);
+    tg->tid_map = (int16_t*)jl_malloc_aligned(num_threads * sizeof(int16_t), 64);
+    for (i = 0;  i < num_threads;  ++i)
+        tg->tid_map[i] = -1;
+    tg->num_sockets = num_sockets;
+    tg->num_cores = num_cores;
+    tg->num_threads_per_core = num_threads_per_core;
+    tg->num_threads = num_threads;
+    tg->added_threads = 0;
+    tg->thread_sense = (ti_thread_sense_t**)
+        jl_malloc_aligned(num_threads * sizeof(ti_thread_sense_t*), 64);
+    for (i = 0;  i < num_threads;  i++)
+        tg->thread_sense[i] = NULL;
+    tg->group_sense = 0;
+
+    uv_mutex_init(&tg->alarm_lock);
+    uv_cond_init(&tg->alarm);
+
+    tg->sleep_threshold = DEFAULT_THREAD_SLEEP_THRESHOLD;
+    cp = getenv(THREAD_SLEEP_THRESHOLD_NAME);
+    if (cp) {
+        if (!strncasecmp(cp, "infinite", 8))
+            tg->sleep_threshold = 0;
+        else
+            tg->sleep_threshold = (uint64_t)strtol(cp, NULL, 10);
+    }
+
+    *newtg = tg;
+    return 0;
+}
+
+
+int ti_threadgroup_addthread(ti_threadgroup_t *tg, int16_t ext_tid,
+                             int16_t *tgtid)
+{
+    if (ext_tid < 0 || ext_tid >= tg->num_threads)
+        return -1;
+    if (tg->tid_map[ext_tid] != -1)
+        return -2;
+    if (tg->added_threads == tg->num_threads)
+        return -3;
+
+    tg->tid_map[ext_tid] = tg->added_threads++;
+    if (tgtid) *tgtid = tg->tid_map[ext_tid];
+
+    return 0;
+}
+
+
+int ti_threadgroup_initthread(ti_threadgroup_t *tg, int16_t ext_tid)
+{
+    ti_thread_sense_t *ts;
+
+    if (ext_tid < 0 || ext_tid >= tg->num_threads)
+        return -1;
+    if (tg->thread_sense[tg->tid_map[ext_tid]] != NULL)
+        return -2;
+    if (tg->num_threads == 0)
+        return -3;
+
+    ts = (ti_thread_sense_t*)jl_malloc_aligned(sizeof(ti_thread_sense_t), 64);
+    ts->sense = 1;
+    tg->thread_sense[tg->tid_map[ext_tid]] = ts;
+
+    return 0;
+}
+
+
+int ti_threadgroup_member(ti_threadgroup_t *tg, int16_t ext_tid, int16_t *tgtid)
+{
+    if (ext_tid < 0 || ext_tid >= tg->num_threads)
+        return -1;
+    if (tg == NULL) {
+        if (tgtid) *tgtid = -1;
+        return -2;
+    }
+    if (tg->tid_map[ext_tid] == -1) {
+        if (tgtid) *tgtid = -1;
+        return -3;
+    }
+    if (tgtid) *tgtid = tg->tid_map[ext_tid];
+
+    return 0;
+}
+
+
+int ti_threadgroup_size(ti_threadgroup_t *tg, int16_t *tgsize)
+{
+    *tgsize = tg->num_threads;
+    return 0;
+}
+
+
+int ti_threadgroup_fork(ti_threadgroup_t *tg, int16_t ext_tid, void **bcast_val)
+{
+    if (tg->tid_map[ext_tid] == 0) {
+        tg->envelope = bcast_val ? *bcast_val : NULL;
+        // synchronize `tg->envelope` and `tg->group_sense`
+        jl_atomic_store_release(&tg->group_sense, tg->thread_sense[0]->sense);
+
+        // if it's possible that threads are sleeping, signal them
+        if (tg->sleep_threshold) {
+            uv_mutex_lock(&tg->alarm_lock);
+            uv_cond_broadcast(&tg->alarm);
+            uv_mutex_unlock(&tg->alarm_lock);
+        }
+    }
+    else {
+        // spin up to threshold ns (count sheep), then sleep
+        uint64_t spin_ns;
+        uint64_t spin_start = 0;
+        // synchronize `tg->envelope` and `tg->group_sense`
+        while (jl_atomic_load_acquire(&tg->group_sense) !=
+               tg->thread_sense[tg->tid_map[ext_tid]]->sense) {
+            if (tg->sleep_threshold) {
+                if (!spin_start) {
+                    // Lazily initialize spin_start since uv_hrtime is expensive
+                    spin_start = uv_hrtime();
+                    continue;
+                }
+                spin_ns = uv_hrtime() - spin_start;
+                // In case uv_hrtime is not monotonic, we'll sleep earlier
+                if (spin_ns >= tg->sleep_threshold) {
+                    uv_mutex_lock(&tg->alarm_lock);
+                    if (tg->group_sense !=
+                        tg->thread_sense[tg->tid_map[ext_tid]]->sense) {
+                        uv_cond_wait(&tg->alarm, &tg->alarm_lock);
+                    }
+                    uv_mutex_unlock(&tg->alarm_lock);
+                    spin_start = 0;
+                    continue;
+                }
+            }
+            jl_cpu_pause();
+        }
+        if (bcast_val)
+            *bcast_val = tg->envelope;
+    }
+
+    return 0;
+}
+
+
+int ti_threadgroup_join(ti_threadgroup_t *tg, int16_t ext_tid)
+{
+    int i;
+
+    tg->thread_sense[tg->tid_map[ext_tid]]->sense
+        = !tg->thread_sense[tg->tid_map[ext_tid]]->sense;
+    if (tg->tid_map[ext_tid] == 0) {
+        for (i = 1;  i < tg->num_threads;  ++i) {
+            while (tg->thread_sense[i]->sense == tg->group_sense)
+                jl_cpu_pause();
+        }
+    }
+
+    return 0;
+}
+
+int ti_threadgroup_destroy(ti_threadgroup_t *tg)
+{
+    int i;
+
+    uv_mutex_destroy(&tg->alarm_lock);
+    uv_cond_destroy(&tg->alarm);
+
+    for (i = 0;  i < tg->num_threads;  i++)
+        jl_free_aligned(tg->thread_sense[i]);
+    jl_free_aligned(tg->thread_sense);
+    jl_free_aligned(tg->tid_map);
+    jl_free_aligned(tg);
+
+    return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/threadgroup.h b/src/threadgroup.h
new file mode 100644
index 0000000000000..4b5289032f6a7
--- /dev/null
+++ b/src/threadgroup.h
@@ -0,0 +1,48 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#ifndef THREADGROUP_H
+#define THREADGROUP_H
+
+#include <stdint.h>
+#include "uv.h"
+
+// for the barrier
+typedef struct {
+    volatile int sense;
+} ti_thread_sense_t;
+
+
+// thread group
+typedef struct {
+    int16_t             *tid_map, num_threads, added_threads;
+    uint8_t             num_sockets, num_cores, num_threads_per_core;
+
+    // fork/join/barrier
+    volatile uint8_t    group_sense;
+    ti_thread_sense_t  **thread_sense;
+    void                *envelope;
+
+    // to let threads sleep
+    uv_mutex_t  alarm_lock;
+    uv_cond_t   alarm;
+    uint64_t    sleep_threshold;
+} ti_threadgroup_t;
+
+
+int  ti_threadgroup_create(uint8_t num_sockets, uint8_t num_cores,
+                           uint8_t num_threads_per_core,
+                           ti_threadgroup_t **newtg);
+int  ti_threadgroup_addthread(ti_threadgroup_t *tg, int16_t ext_tid,
+                              int16_t *tgtid);
+int  ti_threadgroup_initthread(ti_threadgroup_t *tg, int16_t ext_tid);
+int  ti_threadgroup_member(ti_threadgroup_t *tg, int16_t ext_tid,
+                           int16_t *tgtid);
+int  ti_threadgroup_size(ti_threadgroup_t *tg, int16_t *tgsize);
+int  ti_threadgroup_fork(ti_threadgroup_t *tg, int16_t ext_tid,
+                         void **bcast_val);
+int  ti_threadgroup_join(ti_threadgroup_t *tg, int16_t ext_tid);
+int  ti_threadgroup_destroy(ti_threadgroup_t *tg);
+
+extern ti_threadgroup_t *tgworld;
+
+#endif  /* THREADGROUP_H */
diff --git a/src/threading.c b/src/threading.c
new file mode 100644
index 0000000000000..e0e4002717d04
--- /dev/null
+++ b/src/threading.c
@@ -0,0 +1,526 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+/*
+  threading infrastructure
+  . thread and threadgroup creation
+  . thread function
+  . invoke Julia function from multiple threads
+
+TODO:
+  . fix interface to properly support thread groups
+  . add queue per thread for tasks
+  . add reduction; reduce values returned from thread function
+  . make code generation thread-safe and remove the lock
+*/
+
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "julia.h"
+#include "julia_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "threadgroup.h"
+#include "threading.h"
+
+#ifdef JULIA_ENABLE_THREADING
+// fallback provided for embedding
+static JL_CONST_FUNC jl_tls_states_t *jl_get_ptls_states_fallback(void)
+{
+#  if !defined(_COMPILER_MICROSOFT_)
+    static __thread jl_tls_states_t tls_states;
+#  else
+    static __declspec(thread) jl_tls_states_t tls_states;
+#  endif
+    return &tls_states;
+}
+static jl_tls_states_t *jl_get_ptls_states_init(void);
+static jl_get_ptls_states_func jl_tls_states_cb = jl_get_ptls_states_init;
+static jl_tls_states_t *jl_get_ptls_states_init(void)
+{
+    // This 2-step initialization is used to detect calling
+    // `jl_set_ptls_states_getter` after the address of the TLS variables
+    // are used. Since the address of TLS variables should be constant,
+    // changing the getter address can result in wierd crashes.
+
+    // This is clearly not thread safe but should be fine since we
+    // make sure the tls states callback is finalized before adding
+    // multiple threads
+    jl_tls_states_cb = jl_get_ptls_states_fallback;
+    return jl_get_ptls_states_fallback();
+}
+JL_DLLEXPORT JL_CONST_FUNC jl_tls_states_t *(jl_get_ptls_states)(void)
+{
+    return (*jl_tls_states_cb)();
+}
+JL_DLLEXPORT void jl_set_ptls_states_getter(jl_get_ptls_states_func f)
+{
+    // only allow setting this once
+    if (f && f != jl_get_ptls_states_init &&
+        jl_tls_states_cb == jl_get_ptls_states_init) {
+        jl_tls_states_cb = f;
+    }
+    else {
+        jl_safe_printf("ERROR: Attempt to change TLS address.\n");
+        exit(1);
+    }
+}
+jl_get_ptls_states_func jl_get_ptls_states_getter(void)
+{
+    if (jl_tls_states_cb == jl_get_ptls_states_init)
+        jl_get_ptls_states_init();
+    // for codegen
+    return jl_tls_states_cb;
+}
+#else
+JL_DLLEXPORT jl_tls_states_t jl_tls_states;
+JL_DLLEXPORT JL_CONST_FUNC jl_tls_states_t *(jl_get_ptls_states)(void)
+{
+    return &jl_tls_states;
+}
+#endif
+
+// thread ID
+JL_DLLEXPORT int jl_n_threads;     // # threads we're actually using
+jl_thread_task_state_t *jl_all_task_states;
+
+// return calling thread's ID
+// Also update the suspended_threads list in signals-mach when changing the
+// type of the thread id.
+JL_DLLEXPORT int16_t jl_threadid(void) { return ti_tid; }
+
+struct _jl_thread_heap_t *jl_mk_thread_heap(void);
+// must be called by each thread at startup
+
+static void ti_initthread(int16_t tid)
+{
+    jl_tls_states_t *ptls = jl_get_ptls_states();
+    ptls->tid = tid;
+    ptls->pgcstack = NULL;
+    ptls->gc_state = 0; // GC unsafe
+    ptls->current_module = NULL;
+#ifdef JULIA_ENABLE_THREADING
+    jl_all_heaps[tid] = jl_mk_thread_heap();
+#else
+    jl_mk_thread_heap();
+#endif
+
+    jl_all_task_states[tid].ptls = ptls;
+    jl_all_task_states[tid].signal_stack = jl_install_thread_signal_handler();
+}
+
+static void ti_init_master_thread(void)
+{
+#ifdef _OS_WINDOWS_
+    if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
+                         GetCurrentProcess(), &hMainThread, 0,
+                         TRUE, DUPLICATE_SAME_ACCESS)) {
+        jl_printf(JL_STDERR, "WARNING: failed to access handle to main thread\n");
+        hMainThread = INVALID_HANDLE_VALUE;
+    }
+    jl_all_task_states[0].system_id = hMainThread;
+#else
+    jl_all_task_states[0].system_id = pthread_self();
+#endif
+    ti_initthread(0);
+}
+
+// all threads call this function to run user code
+static jl_value_t *ti_run_fun(jl_svec_t *args)
+{
+    JL_TRY {
+        jl_apply(jl_svec_data(args), jl_svec_len(args));
+    }
+    JL_CATCH {
+        return jl_exception_in_transit;
+    }
+    return jl_nothing;
+}
+
+
+// lock for code generation
+JL_DEFINE_MUTEX(codegen)
+JL_DEFINE_MUTEX(typecache)
+
+#ifdef JULIA_ENABLE_THREADING
+
+// thread heap
+struct _jl_thread_heap_t **jl_all_heaps;
+
+// only one thread group for now
+ti_threadgroup_t *tgworld;
+
+// for broadcasting work to threads
+ti_threadwork_t threadwork;
+
+#if PROFILE_JL_THREADING
+uint64_t prep_ns;
+uint64_t *fork_ns;
+uint64_t *user_ns;
+uint64_t *join_ns;
+#endif
+
+static uv_barrier_t thread_init_done;
+
+// thread function: used by all except the main thread
+void ti_threadfun(void *arg)
+{
+    ti_threadarg_t *ta = (ti_threadarg_t *)arg;
+    ti_threadgroup_t *tg;
+    ti_threadwork_t *work;
+
+    // initialize this thread (set tid, create heap, etc.)
+    ti_initthread(ta->tid);
+    jl_init_stack_limits(0);
+
+    // set up tasking
+    jl_init_root_task(jl_stack_lo, jl_stack_hi - jl_stack_lo);
+#ifdef COPY_STACKS
+    jl_set_base_ctx((char*)&arg);
+#endif
+
+    // set the thread-local tid and wait for a thread group
+    while (jl_atomic_load_acquire(&ta->state) == TI_THREAD_INIT)
+        jl_cpu_pause();
+
+    // Assuming the functions called below doesn't contain unprotected GC
+    // critical region. In general, the following part of this function
+    // shouldn't call any managed code without calling `jl_gc_unsafe_enter`
+    // first.
+    jl_gc_state_set(JL_GC_STATE_SAFE, 0);
+    uv_barrier_wait(&thread_init_done);
+    // initialize this thread in the thread group
+    tg = ta->tg;
+    ti_threadgroup_initthread(tg, ti_tid);
+
+    // free the thread argument here
+    free(ta);
+
+    // work loop
+    for (; ;) {
+#if PROFILE_JL_THREADING
+        uint64_t tstart = uv_hrtime();
+#endif
+
+        ti_threadgroup_fork(tg, ti_tid, (void **)&work);
+
+#if PROFILE_JL_THREADING
+        uint64_t tfork = uv_hrtime();
+        fork_ns[ti_tid] += tfork - tstart;
+#endif
+
+        if (work) {
+            if (work->command == TI_THREADWORK_DONE) {
+                break;
+            }
+            else if (work->command == TI_THREADWORK_RUN) {
+                // TODO: return value? reduction?
+                // TODO: before we support getting return value from
+                //       the work, and after we have proper GC transition
+                //       support in the codegen and runtime we don't need to
+                //       enter GC unsafe region when starting the work.
+                int8_t gc_state = jl_gc_unsafe_enter();
+                // This is probably always NULL for now
+                jl_module_t *last_m = jl_current_module;
+                JL_GC_PUSH1(&last_m);
+                jl_current_module = work->current_module;
+                ti_run_fun(work->args);
+                jl_current_module = last_m;
+                JL_GC_POP();
+                jl_gc_unsafe_leave(gc_state);
+            }
+        }
+
+#if PROFILE_JL_THREADING
+        uint64_t tuser = uv_hrtime();
+        user_ns[ti_tid] += tuser - tfork;
+#endif
+
+        ti_threadgroup_join(tg, ti_tid);
+
+#if PROFILE_JL_THREADING
+        uint64_t tjoin = uv_hrtime();
+        join_ns[ti_tid] += tjoin - tuser;
+#endif
+
+        // TODO:
+        // nowait should skip the join, but confirm that fork is reentrant
+    }
+}
+
+#if PROFILE_JL_THREADING
+void ti_reset_timings(void);
+#endif
+
+// interface to Julia; sets up to make the runtime thread-safe
+void jl_init_threading(void)
+{
+    char *cp;
+
+    // how many threads available, usable
+    int max_threads = jl_cpu_cores();
+    jl_n_threads = DEFAULT_NUM_THREADS;
+    cp = getenv(NUM_THREADS_NAME);
+    if (cp) {
+        jl_n_threads = (uint64_t)strtol(cp, NULL, 10);
+    }
+    if (jl_n_threads > max_threads)
+        jl_n_threads = max_threads;
+
+    // set up space for per-thread heaps
+    jl_all_heaps = (struct _jl_thread_heap_t **)malloc(jl_n_threads * sizeof(void*));
+    jl_all_task_states = (jl_thread_task_state_t *)malloc(jl_n_threads * sizeof(jl_thread_task_state_t));
+
+#if PROFILE_JL_THREADING
+    // set up space for profiling information
+    fork_ns = (uint64_t*)jl_malloc_aligned(jl_n_threads * sizeof(uint64_t), 64);
+    user_ns = (uint64_t*)jl_malloc_aligned(jl_n_threads * sizeof(uint64_t), 64);
+    join_ns = (uint64_t*)jl_malloc_aligned(jl_n_threads * sizeof(uint64_t), 64);
+    ti_reset_timings();
+#endif
+
+    // initialize this master thread (set tid, create heap, etc.)
+    ti_init_master_thread();
+}
+
+void jl_start_threads(void)
+{
+    char *cp, mask[UV_CPU_SETSIZE];
+    int i, exclusive;
+    uv_thread_t uvtid;
+    ti_threadarg_t **targs;
+
+    // do we have exclusive use of the machine? default is no
+    exclusive = DEFAULT_MACHINE_EXCLUSIVE;
+    cp = getenv(MACHINE_EXCLUSIVE_NAME);
+    if (cp)
+        exclusive = strtol(cp, NULL, 10);
+
+    // exclusive use: affinitize threads, master thread on proc 0, rest
+    // according to a 'compact' policy
+    // non-exclusive: no affinity settings; let the kernel move threads about
+    if (exclusive) {
+        memset(mask, 0, UV_CPU_SETSIZE);
+        mask[0] = 1;
+        uvtid = (uv_thread_t)uv_thread_self();
+        uv_thread_setaffinity(&uvtid, mask, NULL, UV_CPU_SETSIZE);
+    }
+
+    // create threads
+    targs = (ti_threadarg_t **)malloc((jl_n_threads - 1) * sizeof (ti_threadarg_t *));
+
+    uv_barrier_init(&thread_init_done, jl_n_threads);
+
+    for (i = 0;  i < jl_n_threads - 1;  ++i) {
+        targs[i] = (ti_threadarg_t *)malloc(sizeof (ti_threadarg_t));
+        targs[i]->state = TI_THREAD_INIT;
+        targs[i]->tid = i + 1;
+        uv_thread_create(&uvtid, ti_threadfun, targs[i]);
+        if (exclusive) {
+            memset(mask, 0, UV_CPU_SETSIZE);
+            mask[i+1] = 1;
+            uv_thread_setaffinity(&uvtid, mask, NULL, UV_CPU_SETSIZE);
+        }
+        uv_thread_detach(&uvtid);
+        jl_all_task_states[i + 1].system_id = uvtid;
+    }
+
+    // set up the world thread group
+    ti_threadgroup_create(1, jl_n_threads, 1, &tgworld);
+    for (i = 0;  i < jl_n_threads;  ++i)
+        ti_threadgroup_addthread(tgworld, i, NULL);
+    ti_threadgroup_initthread(tgworld, ti_tid);
+
+    // give the threads the world thread group; they will block waiting for fork
+    for (i = 0;  i < jl_n_threads - 1;  ++i) {
+        targs[i]->tg = tgworld;
+        jl_atomic_store_release(&targs[i]->state, TI_THREAD_WORK);
+    }
+
+    uv_barrier_wait(&thread_init_done);
+
+    // free the argument array; the threads will free their arguments
+    free(targs);
+}
+
+// TODO: is this needed? where/when/how to call it?
+void jl_shutdown_threading(void)
+{
+    // stop the spinning threads by sending them a command
+    ti_threadwork_t *work = &threadwork;
+
+    work->command = TI_THREADWORK_DONE;
+    ti_threadgroup_fork(tgworld, ti_tid, (void **)&work);
+
+    sleep(1);
+
+    // destroy the world thread group
+    ti_threadgroup_destroy(tgworld);
+
+    // TODO: clean up and free the per-thread heaps
+
+#if PROFILE_JL_THREADING
+    jl_free_aligned(join_ns);
+    jl_free_aligned(user_ns);
+    jl_free_aligned(fork_ns);
+    fork_ns = user_ns = join_ns = NULL;
+#endif
+}
+
+// return thread's thread group
+JL_DLLEXPORT void *jl_threadgroup(void) { return (void *)tgworld; }
+
+// interface to user code: specialize and compile the user thread function
+// and run it in all threads
+JL_DLLEXPORT jl_value_t *jl_threading_run(jl_svec_t *args)
+{
+    // GC safe
+#if PROFILE_JL_THREADING
+    uint64_t tstart = uv_hrtime();
+#endif
+
+    jl_tupletype_t *argtypes = NULL;
+    JL_TYPECHK(jl_threading_run, simplevector, (jl_value_t*)args);
+
+    int8_t gc_state = jl_gc_unsafe_enter();
+    JL_GC_PUSH1(&argtypes);
+    argtypes = arg_type_tuple(jl_svec_data(args), jl_svec_len(args));
+    jl_lambda_info_t *li = jl_get_specialization1(argtypes, NULL);
+    jl_generate_fptr(li);
+
+    threadwork.command = TI_THREADWORK_RUN;
+    // TODO jb/functions: lookup and store jlcall fptr here
+    threadwork.fun = NULL;
+    threadwork.args = args;
+    threadwork.ret = jl_nothing;
+    threadwork.current_module = jl_current_module;
+
+#if PROFILE_JL_THREADING
+    uint64_t tcompile = uv_hrtime();
+    prep_ns += (tcompile - tstart);
+#endif
+
+    // fork the world thread group
+    ti_threadwork_t *tw = &threadwork;
+    ti_threadgroup_fork(tgworld, ti_tid, (void **)&tw);
+
+#if PROFILE_JL_THREADING
+    uint64_t tfork = uv_hrtime();
+    fork_ns[ti_tid] += (tfork - tcompile);
+#endif
+
+    // this thread must do work too (TODO: reduction?)
+    tw->ret = ti_run_fun(args);
+
+#if PROFILE_JL_THREADING
+    uint64_t trun = uv_hrtime();
+    user_ns[ti_tid] += (trun - tfork);
+#endif
+
+    jl_gc_state_set(JL_GC_STATE_SAFE, 0);
+    // wait for completion (TODO: nowait?)
+    ti_threadgroup_join(tgworld, ti_tid);
+    jl_gc_state_set(0, JL_GC_STATE_SAFE);
+
+#if PROFILE_JL_THREADING
+    uint64_t tjoin = uv_hrtime();
+    join_ns[ti_tid] += (tjoin - trun);
+#endif
+
+    JL_GC_POP();
+    jl_gc_unsafe_leave(gc_state);
+
+    return tw->ret;
+}
+
+#if PROFILE_JL_THREADING
+
+void ti_reset_timings(void)
+{
+    int i;
+    prep_ns = 0;
+    for (i = 0;  i < jl_n_threads;  i++)
+        fork_ns[i] = user_ns[i] = join_ns[i] = 0;
+}
+
+void ti_timings(uint64_t *times, uint64_t *min, uint64_t *max, uint64_t *avg)
+{
+    int i;
+    *min = UINT64_MAX;
+    *max = *avg = 0;
+    for (i = 0;  i < jl_n_threads;  i++) {
+        if (times[i] < *min)
+            *min = times[i];
+        if (times[i] > *max)
+            *max = times[i];
+        *avg += times[i];
+    }
+    *avg /= jl_n_threads;
+}
+
+#define NS_TO_SECS(t)        ((t) / (double)1e9)
+
+JL_DLLEXPORT void jl_threading_profile(void)
+{
+    if (!fork_ns) return;
+
+    printf("\nti profile:\n");
+    printf("prep: %g (%llu)\n", NS_TO_SECS(prep_ns), (unsigned long long)prep_ns);
+
+    uint64_t min, max, avg;
+    ti_timings(fork_ns, &min, &max, &avg);
+    printf("fork: %g (%g - %g)\n", NS_TO_SECS(min), NS_TO_SECS(max),
+            NS_TO_SECS(avg));
+    ti_timings(user_ns, &min, &max, &avg);
+    printf("user: %g (%g - %g)\n", NS_TO_SECS(min), NS_TO_SECS(max),
+            NS_TO_SECS(avg));
+    ti_timings(join_ns, &min, &max, &avg);
+    printf("join: %g (%g - %g)\n", NS_TO_SECS(min), NS_TO_SECS(max),
+            NS_TO_SECS(avg));
+}
+
+#else //!PROFILE_JL_THREADING
+
+JL_DLLEXPORT void jl_threading_profile(void)
+{
+}
+
+#endif //!PROFILE_JL_THREADING
+
+#else // !JULIA_ENABLE_THREADING
+
+JL_DLLEXPORT jl_value_t *jl_threading_run(jl_svec_t *args)
+{
+    JL_TYPECHK(jl_threading_run, simplevector, (jl_value_t*)args);
+    return ti_run_fun(args);
+}
+
+void jl_init_threading(void)
+{
+    static jl_thread_task_state_t _jl_all_task_states;
+    jl_all_task_states = &_jl_all_task_states;
+    jl_n_threads = 1;
+
+#if defined(__linux__) && defined(JL_USE_INTEL_JITEVENTS)
+    if (jl_using_intel_jitevents)
+        // Intel VTune Amplifier needs at least 64k for alternate stack.
+        if (SIGSTKSZ < 1<<16)
+            sig_stack_size = 1<<16;
+#endif
+
+    ti_init_master_thread();
+}
+
+void jl_start_threads(void) { }
+
+#endif // !JULIA_ENABLE_THREADING
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/threading.h b/src/threading.h
new file mode 100644
index 0000000000000..ac28ba35bd67b
--- /dev/null
+++ b/src/threading.h
@@ -0,0 +1,68 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#ifndef THREADING_H
+#define THREADING_H
+
+#include <stdint.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "threadgroup.h"
+#include "julia.h"
+
+#define PROFILE_JL_THREADING            1
+
+// thread ID
+#define ti_tid (jl_get_ptls_states()->tid)
+extern jl_thread_task_state_t *jl_all_task_states;
+extern JL_DLLEXPORT int jl_n_threads;  // # threads we're actually using
+
+#ifdef JULIA_ENABLE_THREADING
+// GC
+extern struct _jl_thread_heap_t **jl_all_heaps;
+#endif
+
+// thread state
+enum {
+    TI_THREAD_INIT,
+    TI_THREAD_WORK
+};
+
+
+// passed to thread function
+typedef struct {
+    int16_t volatile    state;
+    int16_t             tid;
+    ti_threadgroup_t    *tg;
+} ti_threadarg_t;
+
+
+// commands to thread function
+enum {
+    TI_THREADWORK_DONE,
+    TI_THREADWORK_RUN
+};
+
+
+// work command to thread function
+typedef struct {
+    uint8_t             command;
+    jl_function_t       *fun;
+    jl_svec_t           *args;
+    jl_value_t          *ret;
+    jl_module_t         *current_module;
+} ti_threadwork_t;
+
+
+// thread function
+void ti_threadfun(void *arg);
+
+// helpers for thread function
+jl_value_t *ti_runthread(jl_function_t *f, jl_svec_t *args, size_t nargs);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* THREADING_H */
diff --git a/src/toplevel.c b/src/toplevel.c
index 1e5f34aef1214..b45696874a015 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -25,33 +25,29 @@ extern "C" {
 #endif
 
 // current line number in a file
-DLLEXPORT int jl_lineno = 0;
+JL_DLLEXPORT int jl_lineno = 0; // need to update jl_critical_error if this is TLS
 // current file name
-DLLEXPORT const char *jl_filename = "no file";
+JL_DLLEXPORT const char *jl_filename = "no file"; // need to update jl_critical_error if this is TLS
 
 jl_module_t *jl_old_base_module = NULL;
 // the Main we started with, in case it is switched
 jl_module_t *jl_internal_main_module = NULL;
 
-jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast);
-
-void jl_add_standard_imports(jl_module_t *m)
+JL_DLLEXPORT void jl_add_standard_imports(jl_module_t *m)
 {
     assert(jl_base_module != NULL);
     // using Base
     jl_module_using(m, jl_base_module);
-    // import Base.call
-    jl_module_import(m, jl_base_module, jl_symbol("call"));
     m->std_imports = 1;
 }
 
-jl_module_t *jl_new_main_module(void)
+JL_DLLEXPORT jl_module_t *jl_new_main_module(void)
 {
     if (jl_generating_output() && jl_options.incremental)
         jl_error("cannot call workspace() in incremental compile mode");
 
     // switch to a new top-level module
-    if (jl_current_module != jl_main_module && jl_current_module != NULL)
+    if (jl_current_module != jl_main_module && jl_current_module != NULL && jl_main_module != NULL)
         jl_error("Main can only be replaced from the top level");
 
     jl_module_t *old_main = jl_main_module;
@@ -69,13 +65,11 @@ jl_module_t *jl_new_main_module(void)
                   (jl_value_t*)jl_main_module);
     jl_current_task->current_module = jl_main_module;
 
-    jl_module_import(jl_main_module, jl_core_module, jl_symbol("eval"));
-
     return old_main;
 }
 
 // load time init procedure: in build mode, only record order
-void jl_module_load_time_initialize(jl_module_t *m)
+static void jl_module_load_time_initialize(jl_module_t *m)
 {
     int build_mode = jl_generating_output();
     if (build_mode) {
@@ -83,7 +77,13 @@ void jl_module_load_time_initialize(jl_module_t *m)
             jl_module_init_order = jl_alloc_cell_1d(0);
         jl_cell_1d_push(jl_module_init_order, (jl_value_t*)m);
         jl_function_t *f = jl_module_get_initializer(m);
-        if (f) jl_get_specialization(f, (jl_tupletype_t*)jl_typeof(jl_emptytuple));
+        if (f) {
+            jl_value_t *tt = jl_is_type(f) ? (jl_value_t*)jl_wrap_Type(f) : jl_typeof(f);
+            JL_GC_PUSH1(&tt);
+            tt = (jl_value_t*)jl_apply_tuple_type_v(&tt, 1);
+            jl_get_specialization1((jl_tupletype_t*)tt, NULL);
+            JL_GC_POP();
+        }
     }
     else {
         jl_module_run_initializer(m);
@@ -115,14 +115,17 @@ jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
     jl_declare_constant(b);
     if (b->value != NULL) {
         if (!jl_is_module(b->value)) {
-            jl_errorf("invalid redefinition of constant %s", name->name);
+            jl_errorf("invalid redefinition of constant %s",
+                      jl_symbol_name(name));
         }
         if (jl_generating_output() && jl_options.incremental) {
-            jl_errorf("cannot replace module %s during incremental compile", name->name);
+            jl_errorf("cannot replace module %s during incremental compile",
+                      jl_symbol_name(name));
         }
         if (!jl_generating_output()) {
             // suppress warning "replacing module Core.Inference" during bootstrapping
-            jl_printf(JL_STDERR, "WARNING: replacing module %s\n", name->name);
+            jl_printf(JL_STDERR, "WARNING: replacing module %s\n",
+                      jl_symbol_name(name));
         }
     }
     jl_module_t *newm = jl_new_module(name);
@@ -190,13 +193,14 @@ jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
         if (table[i] != HT_NOTFOUND) {
             jl_binding_t *b = (jl_binding_t*)table[i];
             // remove non-exported macros
-            if (b->name->name[0]=='@' && !b->exportp && b->owner==newm)
+            if (jl_symbol_name(b->name)[0]=='@' &&
+                !b->exportp && b->owner == newm)
                 b->value = NULL;
             // error for unassigned exports
             /*
             if (b->exportp && b->owner==newm && b->value==NULL)
                 jl_errorf("identifier %s exported from %s is not initialized",
-                          b->name->name, newm->name->name);
+                          jl_symbol_name(b->name), jl_symbol_name(newm->name));
             */
         }
     }
@@ -226,7 +230,7 @@ jl_value_t *jl_eval_module_expr(jl_expr_t *ex)
 // this is only needed because of the bootstrapping process:
 // - initially Base doesn't exist and top === Core
 // - later, it refers to either old Base or new Base
-DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m)
+JL_DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m)
 {
     while (m != m->parent) {
         if (m->istopmod)
@@ -236,21 +240,28 @@ DLLEXPORT jl_module_t *jl_base_relative_to(jl_module_t *m)
     return jl_top_module;
 }
 
-int jl_has_intrinsics(jl_expr_t *ast, jl_expr_t *e, jl_module_t *m)
+int jl_has_intrinsics(jl_lambda_info_t *li, jl_expr_t *e, jl_module_t *m)
 {
     if (jl_array_len(e->args) == 0)
         return 0;
-    if (e->head == static_typeof_sym) return 1;
-    jl_value_t *e0 = jl_exprarg(e,0);
+    if (e->head == static_typeof_sym)
+        return 1;
+    jl_value_t *e0 = jl_exprarg(e, 0);
     if (e->head == call_sym) {
-        jl_value_t *sv = jl_static_eval(e0, NULL, m, (jl_value_t*)jl_emptysvec, ast, 0, 0);
+        jl_value_t *sv = jl_static_eval(e0, NULL, m, li, li != NULL, 0);
+        if (sv && jl_typeis(sv, jl_intrinsic_type))
+            return 1;
+    }
+    if (0 && e->head == assign_sym && jl_is_gensym(e0)) { // code branch needed for *very-linear-mode*, but not desirable otherwise
+        jl_value_t *e1 = jl_exprarg(e, 1);
+        jl_value_t *sv = jl_static_eval(e1, NULL, m, li, li != NULL, 0);
         if (sv && jl_typeis(sv, jl_intrinsic_type))
             return 1;
     }
     int i;
-    for(i=0; i < jl_array_len(e->args); i++) {
+    for (i=0; i < jl_array_len(e->args); i++) {
         jl_value_t *a = jl_exprarg(e,i);
-        if (jl_is_expr(a) && jl_has_intrinsics(ast, (jl_expr_t*)a, m))
+        if (jl_is_expr(a) && jl_has_intrinsics(li, (jl_expr_t*)a, m))
             return 1;
     }
     return 0;
@@ -258,7 +269,7 @@ int jl_has_intrinsics(jl_expr_t *ast, jl_expr_t *e, jl_module_t *m)
 
 // heuristic for whether a top-level input should be evaluated with
 // the compiler or the interpreter.
-int jl_eval_with_compiler_p(jl_expr_t *ast, jl_expr_t *expr, int compileloops, jl_module_t *m)
+static int jl_eval_with_compiler_p(jl_lambda_info_t *li, jl_expr_t *expr, int compileloops, jl_module_t *m)
 {
     assert(jl_is_expr(expr));
     if (expr->head==body_sym && compileloops) {
@@ -302,7 +313,7 @@ int jl_eval_with_compiler_p(jl_expr_t *ast, jl_expr_t *expr, int compileloops, j
             }
         }
     }
-    if (jl_has_intrinsics(ast, expr, m)) return 1;
+    if (jl_has_intrinsics(li, expr, m)) return 1;
     return 0;
 }
 
@@ -349,7 +360,8 @@ static jl_module_t *eval_import_path_(jl_array_t *args, int retrying)
                 m = (jl_module_t*)mb->value;
                 if ((mb->owner == m0 && m != NULL && !jl_is_module(m)) ||
                     (isimp && (m == NULL || !jl_is_module(m))))
-                    jl_errorf("invalid module path (%s does not name a module)", var->name);
+                    jl_errorf("invalid module path (%s does not name a module)",
+                              jl_symbol_name(var));
                 // If the binding has been resolved but is (1) undefined, and (2) owned
                 // by the module we're importing into, then allow the import into the
                 // undefined variable (by setting m back to m0).
@@ -364,17 +376,19 @@ static jl_module_t *eval_import_path_(jl_array_t *args, int retrying)
                 if (require_func == NULL && jl_base_module != NULL)
                     require_func = jl_get_global(jl_base_module, jl_symbol("require"));
                 if (require_func != NULL) {
-                    jl_apply((jl_function_t*)require_func, (jl_value_t**)&var, 1);
+                    jl_value_t *reqargs[2] = {require_func, (jl_value_t*)var};
+                    jl_apply(reqargs, 2);
                     return eval_import_path_(args, 1);
                 }
             }
         }
         if (retrying && require_func) {
-            jl_printf(JL_STDERR, "WARNING: requiring \"%s\" in module \"%s\" did not define a corresponding module.\n", var->name, jl_current_module->name->name);
+            jl_printf(JL_STDERR, "WARNING: requiring \"%s\" in module \"%s\" did not define a corresponding module.\n", jl_symbol_name(var),
+                      jl_symbol_name(jl_current_module->name));
             return NULL;
         }
         else {
-            jl_errorf("in module path: %s not defined", var->name);
+            jl_errorf("in module path: %s not defined", jl_symbol_name(var));
         }
     }
 
@@ -403,6 +417,7 @@ int jl_is_toplevel_only_expr(jl_value_t *e)
          ((jl_expr_t*)e)->head == import_sym ||
          ((jl_expr_t*)e)->head == using_sym ||
          ((jl_expr_t*)e)->head == export_sym ||
+         ((jl_expr_t*)e)->head == thunk_sym ||
          ((jl_expr_t*)e)->head == toplevel_sym);
 }
 
@@ -432,7 +447,7 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast)
             jl_error("syntax: malformed \"importall\" statement");
         m = (jl_module_t*)jl_eval_global_var(m, name);
         if (!jl_is_module(m))
-            jl_errorf("invalid %s statement: name exists but does not refer to a module", ex->head->name);
+            jl_errorf("invalid %s statement: name exists but does not refer to a module", jl_symbol_name(ex->head));
         jl_module_importall(jl_current_module, m);
         return jl_nothing;
     }
@@ -506,10 +521,11 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast)
     if (head == thunk_sym) {
         thk = (jl_lambda_info_t*)jl_exprarg(ex,0);
         assert(jl_is_lambda_info(thk));
-        assert(jl_is_expr(thk->ast));
-        ewc = jl_eval_with_compiler_p((jl_expr_t*)thk->ast, jl_lam_body((jl_expr_t*)thk->ast), fast, jl_current_module) ||
-            // interpreter doesn't handle closure environment
-            jl_lam_vars_captured((jl_expr_t*)thk->ast);
+        if (!jl_is_expr(thk->ast)) {
+            thk->ast = jl_uncompress_ast(thk, thk->ast);
+            jl_gc_wb(thk, thk->ast);
+        }
+        ewc = jl_eval_with_compiler_p(thk, jl_lam_body((jl_expr_t*)thk->ast), fast, jl_current_module);
     }
     else {
         if (head && jl_eval_with_compiler_p(NULL, (jl_expr_t*)ex, fast, jl_current_module)) {
@@ -531,12 +547,13 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast)
         }
     }
 
+    thk->specTypes = (jl_tupletype_t*)jl_typeof(jl_emptytuple); // no gc_wb needed
     if (ewc) {
-        thunk = (jl_value_t*)jl_new_closure(NULL, (jl_value_t*)jl_emptysvec, thk);
         if (!jl_in_inference) {
-            jl_type_infer(thk, (jl_tupletype_t*)jl_typeof(jl_emptytuple), thk);
+            jl_type_infer(thk, thk);
         }
-        result = jl_apply((jl_function_t*)thunk, NULL, 0);
+        jl_value_t *dummy_f_arg=NULL;
+        result = jl_call_method_internal(thk, &dummy_f_arg, 1);
     }
     else {
         result = jl_interpret_toplevel_thunk(thk);
@@ -545,60 +562,12 @@ jl_value_t *jl_toplevel_eval_flex(jl_value_t *e, int fast)
     return result;
 }
 
-jl_value_t *jl_toplevel_eval(jl_value_t *v)
+JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_value_t *v)
 {
     return jl_toplevel_eval_flex(v, 1);
 }
 
-// repeatedly call jl_parse_next and eval everything
-jl_value_t *jl_parse_eval_all(const char *fname, size_t len)
-{
-    //jl_printf(JL_STDERR, "***** loading %s\n", fname);
-    int last_lineno = jl_lineno;
-    const char *last_filename = jl_filename;
-    jl_lineno = 0;
-    jl_filename = fname;
-    jl_value_t *fn=NULL, *ln=NULL, *form=NULL, *result=jl_nothing;
-    JL_GC_PUSH4(&fn, &ln, &form, &result);
-    JL_TRY {
-        // handle syntax error
-        while (1) {
-            form = jl_parse_next();
-            if (form == NULL)
-                break;
-            if (jl_is_expr(form)) {
-                if (((jl_expr_t*)form)->head == jl_incomplete_sym) {
-                    jl_errorf("syntax: %s", jl_string_data(jl_exprarg(form,0)));
-                }
-                if (((jl_expr_t*)form)->head == error_sym) {
-                    jl_interpret_toplevel_expr(form);
-                }
-            }
-            result = jl_toplevel_eval_flex(form, 1);
-        }
-    }
-    JL_CATCH {
-        jl_stop_parsing();
-        fn = jl_pchar_to_string(fname, len);
-        ln = jl_box_long(jl_lineno);
-        jl_lineno = last_lineno;
-        jl_filename = last_filename;
-        if (jl_loaderror_type == NULL) {
-            jl_rethrow();
-        }
-        else {
-            jl_rethrow_other(jl_new_struct(jl_loaderror_type, fn, ln,
-                                           jl_exception_in_transit));
-        }
-    }
-    jl_stop_parsing();
-    jl_lineno = last_lineno;
-    jl_filename = last_filename;
-    JL_GC_POP();
-    return result;
-}
-
-jl_value_t *jl_load(const char *fname, size_t len)
+JL_DLLEXPORT jl_value_t *jl_load(const char *fname, size_t len)
 {
     if (jl_current_module->istopmod) {
         jl_printf(JL_STDOUT, "%s\r\n", fname);
@@ -611,42 +580,15 @@ jl_value_t *jl_load(const char *fname, size_t len)
     if (jl_stat(fpath, (char*)&stbuf) != 0 || (stbuf.st_mode & S_IFMT) != S_IFREG) {
         jl_errorf("could not open file %s", fpath);
     }
-    if (jl_start_parsing_file(fpath) != 0) {
-        jl_errorf("could not open file %s", fpath);
-    }
-    jl_value_t *result = jl_parse_eval_all(fpath, len);
-    if (fpath != fname) free(fpath);
-    return result;
+    return jl_parse_eval_all(fpath, len, NULL, 0);
 }
 
 // load from filename given as a ByteString object
-DLLEXPORT jl_value_t *jl_load_(jl_value_t *str)
+JL_DLLEXPORT jl_value_t *jl_load_(jl_value_t *str)
 {
     return jl_load(jl_string_data(str), jl_string_len(str));
 }
 
-// type definition ------------------------------------------------------------
-
-void jl_reinstantiate_inner_types(jl_datatype_t *t);
-
-void jl_set_datatype_super(jl_datatype_t *tt, jl_value_t *super)
-{
-    if (!jl_is_datatype(super) || !jl_is_abstracttype(super) ||
-        tt->name == ((jl_datatype_t*)super)->name ||
-        jl_subtype(super,(jl_value_t*)jl_vararg_type,0) ||
-        jl_is_tuple_type(super) ||
-        jl_subtype(super,(jl_value_t*)jl_type_type,0)) {
-        jl_errorf("invalid subtyping in definition of %s",tt->name->name->name);
-    }
-    tt->super = (jl_datatype_t*)super;
-    jl_gc_wb(tt, tt->super);
-    if (jl_svec_len(tt->parameters) > 0) {
-        tt->name->cache = jl_emptysvec;
-        tt->name->linearcache = jl_emptysvec;
-        jl_reinstantiate_inner_types(tt);
-    }
-}
-
 // method definition ----------------------------------------------------------
 
 extern int jl_boot_file_loaded;
@@ -676,24 +618,51 @@ static int type_contains(jl_value_t *ty, jl_value_t *x)
 
 void print_func_loc(JL_STREAM *s, jl_lambda_info_t *li);
 
+void jl_check_static_parameter_conflicts(jl_lambda_info_t *li, jl_svec_t *t, jl_sym_t *fname)
+{
+    jl_array_t *vinfo;
+    size_t nvars;
+
+    if (li->ast && jl_is_expr(li->ast)) {
+        vinfo = jl_lam_vinfo((jl_expr_t*)li->ast);
+        nvars = jl_array_len(vinfo);
+        for(size_t i=0; i < jl_svec_len(t); i++) {
+            for(size_t j=0; j < nvars; j++) {
+                jl_value_t *tv = jl_svecref(t,i);
+                if (jl_is_typevar(tv)) {
+                    if ((jl_sym_t*)jl_cellref((jl_array_t*)jl_cellref(vinfo,j),0) ==
+                        ((jl_tvar_t*)tv)->name) {
+                        jl_printf(JL_STDERR,
+                                  "WARNING: local variable %s conflicts with a static parameter in %s",
+                                  jl_symbol_name(((jl_tvar_t*)tv)->name),
+                                  jl_symbol_name(fname));
+                        print_func_loc(JL_STDERR, li);
+                        jl_printf(JL_STDERR, ".\n");
+                    }
+                }
+            }
+        }
+    }
+}
+
 // empty generic function def
-// TODO: maybe have jl_method_def call this
-DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp, jl_value_t *bp_owner,
-                                              jl_binding_t *bnd)
+JL_DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp, jl_value_t *bp_owner,
+                                                 jl_binding_t *bnd)
 {
     jl_value_t *gf=NULL;
 
+    assert(name && bp);
     if (bnd && bnd->value != NULL && !bnd->constp)
-        jl_errorf("cannot define function %s; it already has a value", bnd->name->name);
+        jl_errorf("cannot define function %s; it already has a value", jl_symbol_name(bnd->name));
     if (*bp != NULL) {
         gf = *bp;
-        if (!jl_is_gf(gf))
-            jl_errorf("cannot define function %s; it already has a value", name->name);
+        if (!jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(gf)) && !jl_is_type(gf))
+            jl_errorf("cannot define function %s; it already has a value", jl_symbol_name(name));
     }
     if (bnd)
         bnd->constp = 1;
     if (*bp == NULL) {
-        jl_module_t *module = (bnd ? bnd->owner : NULL);
+        jl_module_t *module = (bnd ? bnd->owner : jl_current_module);
         gf = (jl_value_t*)jl_new_generic_function(name, module);
         *bp = gf;
         if (bp_owner) jl_gc_wb(bp_owner, gf);
@@ -701,180 +670,137 @@ DLLEXPORT jl_value_t *jl_generic_function_def(jl_sym_t *name, jl_value_t **bp, j
     return gf;
 }
 
-static jl_lambda_info_t *jl_copy_lambda_info(jl_lambda_info_t *linfo)
+jl_datatype_t *first_arg_datatype(jl_value_t *a, int got_tuple1)
 {
-    jl_lambda_info_t *new_linfo =
-        jl_new_lambda_info(linfo->ast, linfo->sparams, linfo->module);
-    new_linfo->tfunc = linfo->tfunc;
-    new_linfo->name = linfo->name;
-    new_linfo->roots = linfo->roots;
-    new_linfo->specTypes = linfo->specTypes;
-    new_linfo->unspecialized = linfo->unspecialized;
-    new_linfo->specializations = linfo->specializations;
-    new_linfo->def = linfo->def;
-    new_linfo->capt = linfo->capt;
-    new_linfo->file = linfo->file;
-    new_linfo->line = linfo->line;
-    return new_linfo;
+    if (jl_is_datatype(a)) {
+        if (got_tuple1)
+            return (jl_datatype_t*)a;
+        if (jl_is_tuple_type(a)) {
+            if (jl_nparams(a) < 1)
+                return NULL;
+            return first_arg_datatype(jl_tparam0(a), 1);
+        }
+        return NULL;
+    }
+    else if (jl_is_typevar(a)) {
+        return first_arg_datatype(((jl_tvar_t*)a)->ub, got_tuple1);
+    }
+    else if (jl_is_typector(a)) {
+        return first_arg_datatype(((jl_typector_t*)a)->body, got_tuple1);
+    }
+    else if (jl_is_uniontype(a)) {
+        jl_svec_t *ts = ((jl_uniontype_t*)a)->types;
+        if (jl_svec_len(ts) == 0) return NULL;
+        jl_datatype_t *dt = first_arg_datatype(jl_svecref(ts,0), got_tuple1);
+        if (dt == NULL) return NULL;
+        int i;
+        for(i=1; i < jl_svec_len(ts); i++) {
+            jl_datatype_t *ti = first_arg_datatype(jl_svecref(ts,i), got_tuple1);
+            if (ti==NULL || ti->name != dt->name)
+                return NULL;
+        }
+        return dt;
+    }
+    return NULL;
 }
 
-DLLEXPORT jl_value_t *jl_method_def(jl_sym_t *name, jl_value_t **bp, jl_value_t *bp_owner,
-                                    jl_binding_t *bnd,
-                                    jl_svec_t *argdata, jl_function_t *f, jl_value_t *isstaged,
-                                    jl_value_t *call_func, int iskw)
+// get DataType of first tuple element, or NULL if cannot be determined
+jl_value_t *jl_first_argument_datatype(jl_value_t *argtypes)
+{
+    return (jl_value_t*)first_arg_datatype(argtypes, 0);
+}
+
+static jl_lambda_info_t *expr_to_lambda(jl_expr_t *f)
+{
+    // this occurs when there is a closure being added to an out-of-scope function
+    // the user should only do this at the toplevel
+    // the result is that the closure variables get interpolated directly into the AST
+    jl_svec_t *tvar_syms = NULL;
+    JL_GC_PUSH2(&f, &tvar_syms);
+    assert(jl_is_expr(f) && ((jl_expr_t*)f)->head == lambda_sym);
+    // move tvar symbol array from args[1][4] to linfo
+    jl_array_t *le = (jl_array_t*)jl_exprarg(f, 1);
+    assert(jl_is_array(le) && jl_array_len(le) == 4);
+    jl_array_t *tvar_syms_arr = (jl_array_t*)jl_cellref(le, 3);
+    jl_array_del_end(le, 1);
+    size_t i, l = jl_array_len(tvar_syms_arr);
+    tvar_syms = jl_alloc_svec_uninit(l);
+    for (i = 0; i < l; i++) {
+        jl_svecset(tvar_syms, i, jl_arrayref(tvar_syms_arr, i));
+    }
+    // wrap in a LambdaInfo
+    jl_lambda_info_t *li = jl_new_lambda_info((jl_value_t*)f, tvar_syms, jl_emptysvec, jl_current_module);
+    jl_preresolve_globals(li->ast, li);
+    JL_GC_POP();
+    return li;
+}
+
+JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata, jl_lambda_info_t *f, jl_value_t *isstaged)
 {
-    jl_module_t *module = (bnd ? bnd->owner : NULL);
     // argdata is svec({types...}, svec(typevars...))
     jl_tupletype_t *argtypes = (jl_tupletype_t*)jl_svecref(argdata,0);
     jl_svec_t *tvars = (jl_svec_t*)jl_svecref(argdata,1);
-    jl_value_t *gf = NULL;
-    JL_GC_PUSH4(&gf, &tvars, &argtypes, &f);
+    jl_methtable_t *mt;
+    jl_sym_t *name;
+    JL_GC_PUSH1(&f);
 
-    if (bnd && bnd->value != NULL && !bnd->constp) {
-        jl_errorf("cannot define function %s; it already has a value", bnd->name->name);
-    }
+    if (!jl_is_lambda_info(f))
+        f = expr_to_lambda((jl_expr_t*)f);
 
-    if (*bp != NULL) {
-        gf = *bp;
-        if (!jl_is_gf(gf)) {
-            if (jl_is_datatype(gf)) {
-                // DataType: define `call`, for backwards compat with outer constructors
-                if (call_func == NULL)
-                    call_func = (jl_value_t*)jl_module_call_func(jl_current_module);
-                size_t na = jl_nparams(argtypes);
-                jl_svec_t *newargtypes = jl_alloc_svec(1 + na);
-                jl_lambda_info_t *new_linfo = NULL;
-                JL_GC_PUSH2(&newargtypes, &new_linfo);
-                new_linfo = jl_copy_lambda_info(f->linfo);
-                f = jl_new_closure(f->fptr, f->env, new_linfo);
-                size_t i=0;
-                if (iskw) {
-                    assert(na > 0);
-                    // for kw sorter, keep container argument first
-                    jl_svecset(newargtypes, 0, jl_tparam(argtypes, 0));
-                    i++;
-                }
-                jl_svecset(newargtypes, i, jl_wrap_Type(gf));
-                i++;
-                for(; i < na+1; i++) {
-                    jl_svecset(newargtypes, i, jl_tparam(argtypes, i-1));
-                }
-                argtypes = jl_apply_tuple_type(newargtypes);
-                JL_GC_POP();
-                gf = call_func;
-                name = call_sym;
-                // edit args, insert type first
-                if (!jl_is_expr(f->linfo->ast)) {
-                    f->linfo->ast = jl_uncompress_ast(f->linfo, f->linfo->ast);
-                    jl_gc_wb(f->linfo, f->linfo->ast);
-                }
-                else {
-                    // Do not mutate the original ast since it might
-                    // be reused somewhere else
-                    f->linfo->ast = jl_copy_ast(f->linfo->ast);
-                    jl_gc_wb(f->linfo, f->linfo->ast);
-                }
-                jl_array_t *al = jl_lam_args((jl_expr_t*)f->linfo->ast);
-                if (jl_array_len(al) == 0) {
-                    al = jl_alloc_cell_1d(1);
-                    jl_exprargset(f->linfo->ast, 0, (jl_value_t*)al);
-                }
-                else {
-                    jl_array_grow_beg(al, 1);
-                }
-                if (iskw) {
-                    jl_cellset(al, 0, jl_cellref(al, 1));
-                    jl_cellset(al, 1, (jl_value_t*)jl_gensym());
-                }
-                else {
-                    jl_cellset(al, 0, (jl_value_t*)jl_gensym());
-                }
-            }
-            if (!jl_is_gf(gf)) {
-                jl_errorf("cannot define function %s; it already has a value", name->name);
-            }
-        }
-        if (iskw) {
-            jl_methtable_t *mt = jl_gf_mtable(gf);
-            assert(!module);
-            module = mt->module;
-            bp = (jl_value_t**)&mt->kwsorter;
-            bp_owner = (jl_value_t*)mt;
-            gf = *bp;
-        }
-    }
+    assert(jl_is_lambda_info(f));
+    assert(jl_is_tuple_type(argtypes));
+    assert(jl_is_svec(tvars));
+    assert(jl_nparams(argtypes)>0);
+
+    if (jl_is_tuple_type(argtypes) && jl_nparams(argtypes) > 0 && !jl_is_type(jl_tparam0(argtypes)))
+        jl_error("function type in method definition is not a type");
+    jl_value_t *ftype = jl_first_argument_datatype((jl_value_t*)argtypes);
+    if (ftype == NULL ||
+        !(jl_is_type_type(ftype) ||
+          (jl_is_datatype(ftype) &&
+           (!((jl_datatype_t*)ftype)->abstract || jl_is_leaf_type(ftype)) &&
+           ((jl_datatype_t*)ftype)->name->mt != NULL)))
+        jl_error("cannot add methods to an abstract type");
+    mt = ((jl_datatype_t*)ftype)->name->mt;
+    name = mt->name;
+
+    if (jl_subtype(ftype, (jl_value_t*)jl_builtin_type, 0))
+        jl_error("cannot add methods to a builtin function");
+
+    jl_check_static_parameter_conflicts(f, tvars, name);
 
     // TODO
     size_t na = jl_nparams(argtypes);
     for(size_t i=0; i < na; i++) {
         jl_value_t *elt = jl_tparam(argtypes,i);
         if (!jl_is_type(elt) && !jl_is_typevar(elt)) {
-            jl_lambda_info_t *li = f->linfo;
             jl_exceptionf(jl_argumenterror_type, "invalid type for argument %s in method definition for %s at %s:%d",
-                          jl_lam_argname(li,i)->name, name->name, li->file->name, li->line);
+                          jl_symbol_name(jl_lam_argname(f,i)),
+                          jl_symbol_name(name), jl_symbol_name(f->file),
+                          f->line);
         }
     }
 
-    int ishidden = !!strchr(name->name, '#');
+    int ishidden = !!strchr(jl_symbol_name(name), '#');
     for(size_t i=0; i < jl_svec_len(tvars); i++) {
         jl_value_t *tv = jl_svecref(tvars,i);
         if (!jl_is_typevar(tv))
-            jl_type_error_rt(name->name, "method definition", (jl_value_t*)jl_tvar_type, tv);
+            jl_type_error_rt(jl_symbol_name(name), "method definition", (jl_value_t*)jl_tvar_type, tv);
         if (!ishidden && !type_contains((jl_value_t*)argtypes, tv)) {
             jl_printf(JL_STDERR, "WARNING: static parameter %s does not occur in signature for %s",
-                      ((jl_tvar_t*)tv)->name->name, name->name);
-            print_func_loc(JL_STDERR, f->linfo);
+                      jl_symbol_name(((jl_tvar_t*)tv)->name),
+                      jl_symbol_name(name));
+            print_func_loc(JL_STDERR, f);
             jl_printf(JL_STDERR, ".\nThe method will not be callable.\n");
         }
     }
 
-    if (bnd) {
-        bnd->constp = 1;
-    }
-    if (*bp == NULL) {
-        gf = (jl_value_t*)jl_new_generic_function(name, module);
-        *bp = gf;
-        if (bp_owner) jl_gc_wb(bp_owner, gf);
-    }
-    assert(jl_is_function(f));
-    assert(jl_is_tuple_type(argtypes));
-    assert(jl_is_svec(tvars));
-
-    jl_add_method((jl_function_t*)gf, argtypes, f, tvars, isstaged == jl_true);
-    if (jl_boot_file_loaded &&
-        f->linfo && f->linfo->ast && jl_is_expr(f->linfo->ast)) {
-        jl_lambda_info_t *li = f->linfo;
-        li->ast = jl_compress_ast(li, li->ast);
-        jl_gc_wb(li, li->ast);
+    jl_add_method_to_table(mt, argtypes, f, tvars, isstaged == jl_true);
+    if (jl_boot_file_loaded && f->ast && jl_is_expr(f->ast)) {
+        f->ast = jl_compress_ast(f, f->ast);
+        jl_gc_wb(f, f->ast);
     }
     JL_GC_POP();
-    return gf;
-}
-
-void jl_check_static_parameter_conflicts(jl_lambda_info_t *li, jl_svec_t *t, jl_sym_t *fname)
-{
-    jl_array_t *vinfo;
-    size_t nvars;
-
-    if (li->ast && jl_is_expr(li->ast)) {
-        vinfo = jl_lam_vinfo((jl_expr_t*)li->ast);
-        nvars = jl_array_len(vinfo);
-        for(size_t i=0; i < jl_svec_len(t); i++) {
-            for(size_t j=0; j < nvars; j++) {
-                jl_value_t *tv = jl_svecref(t,i);
-                if (jl_is_typevar(tv)) {
-                    if ((jl_sym_t*)jl_cellref((jl_array_t*)jl_cellref(vinfo,j),0) ==
-                        ((jl_tvar_t*)tv)->name) {
-                        jl_printf(JL_STDERR,
-                                  "WARNING: local variable %s conflicts with a static parameter in %s",
-                                  ((jl_tvar_t*)tv)->name->name, fname->name);
-                        print_func_loc(JL_STDERR, li);
-                        jl_printf(JL_STDERR, ".\n");
-                    }
-                }
-            }
-        }
-    }
 }
 
 #ifdef __cplusplus
diff --git a/src/utils.scm b/src/utils.scm
index 08121e8eebf04..97842a387b544 100644
--- a/src/utils.scm
+++ b/src/utils.scm
@@ -15,6 +15,9 @@
         ((memq (car s1) s2) (diff (cdr s1) s2))
         (else               (cons (car s1) (diff (cdr s1) s2)))))
 
+(define (intersect s1 s2)
+  (filter (lambda (x) (memq x s2)) s1))
+
 (define (has-dups lst)
   (if (null? lst)
       #f
@@ -45,16 +48,18 @@
                 (cdr expr)))))
 
 ;; find all subexprs satisfying `p`, applying `key` to each one
-(define (expr-find-all p expr key)
-  (let ((found (if (p expr)
-                   (list (key expr))
-                   '())))
-    (if (or (atom? expr) (quoted? expr))
-        found
-        (apply nconc
-               found
-               (map (lambda (x) (expr-find-all p x key))
-                    (cdr expr))))))
+(define (expr-find-all p expr key (filt (lambda (x) #t)))
+  (if (filt expr)
+      (let ((found (if (p expr)
+                       (list (key expr))
+                       '())))
+        (if (or (atom? expr) (quoted? expr))
+            found
+            (apply nconc
+                   found
+                   (map (lambda (x) (expr-find-all p x key filt))
+                        (cdr expr)))))
+      '()))
 
 (define (butlast lst)
   (if (or (null? lst) (null? (cdr lst)))
@@ -66,20 +71,16 @@
       (car lst)
       (last (cdr lst))))
 
-(define *gensyms* '())
-(define *current-gensyms* '())
-(define *gensy-counter* 1)
-(define (gensy)
-  (if (null? *current-gensyms*)
-      (let ((g (symbol (string "#s" *gensy-counter*))))
-        (set! *gensy-counter* (+ *gensy-counter* 1))
-        (set! *gensyms* (cons g *gensyms*))
-        g)
-      (begin0 (car *current-gensyms*)
-              (set! *current-gensyms* (cdr *current-gensyms*)))))
-(define (named-gensy name)
-  (let ((g (symbol (string "#" *gensy-counter* "#" name))))
-    (set! *gensy-counter* (+ *gensy-counter* 1))
-    g))
-(define (reset-gensyms)
-  (set! *current-gensyms* *gensyms*))
+(define (take-while f xs)
+  (cond ((null? xs) '())
+        ((f (car xs)) (cons (car xs) (take-while f (cdr xs))))
+        (else '())))
+
+(define (without alst remove)
+  (cond ((null? alst)               '())
+        ((null? remove)             alst)
+        ((memq (caar alst) remove)  (without (cdr alst) remove))
+        (else                       (cons (car alst)
+                                          (without (cdr alst) remove)))))
+
+(define (caddddr x) (car (cdr (cdr (cdr (cdr x))))))
diff --git a/test/Makefile b/test/Makefile
index c7848e0644c45..6e3dfc1c77eb4 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -1,25 +1,20 @@
-JULIAHOME = $(abspath ..)
-include ../Make.inc
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/..)
+BUILDDIR := .
+include $(JULIAHOME)/Make.inc
+# TODO: this Makefile ignores BUILDDIR, except for computing JULIA_EXECUTABLE
 
-TESTS = all linalg $(filter-out TestHelpers runtests testdefs,$(subst .jl,,$(wildcard *.jl linalg/*.jl)))
+TESTS = all linalg $(filter-out TestHelpers runtests testdefs,$(patsubst $(SRCDIR)/%.jl,%,$(wildcard $(SRCDIR)/*.jl $(SRCDIR)/linalg/*.jl)))
 
 default: all
 
 $(TESTS):
-	@$(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no ./runtests.jl $@)
+	@cd $(SRCDIR) && $(call PRINT_JULIA, $(call spawn,$(JULIA_EXECUTABLE)) --check-bounds=yes --startup-file=no ./runtests.jl $@)
 
 perf:
-	@$(MAKE) -C perf all
+	@$(MAKE) -C $(SRCDIR)/perf all
 
 clean:
 	@$(MAKE) -C perf $@
-	-rm -f libccalltest.$(SHLIB_EXT) ccalltest
 
-.PHONY: $(TESTS) perf clean libccalltest
-
-all ccall libccalltest: libccalltest.$(SHLIB_EXT)
-libccalltest.$(SHLIB_EXT): ccalltest.c
-	@$(call PRINT_CC, $(CC) $(CFLAGS) $(DEBUGFLAGS) -O3 $< $(fPIC) -shared -o $@ $(LDFLAGS) -DCC="$(CC)")
-
-ccalltest: ccalltest.c libccalltest.$(SHLIB_EXT)
-	@$(call PRINT_CC, $(CC) $(CFLAGS) $(DEBUGFLAGS) -O3 $< -o $@ $(LDFLAGS) -DCC="$(CC)")
+.PHONY: $(TESTS) perf clean
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index 58503c6cde14a..363ad822840d1 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -370,6 +370,17 @@ function test_ind2sub(::Type{TestAbstractArray})
     end
 end
 
+# A custom linear slow array that insists upon Cartesian indexing
+type TSlowNIndexes{T,N} <: AbstractArray{T,N}
+    data::Array{T,N}
+end
+Base.linearindexing{A<:TSlowNIndexes}(::Type{A}) = Base.LinearSlow()
+Base.size(A::TSlowNIndexes) = size(A.data)
+Base.getindex(A::TSlowNIndexes, index::Int...) = error("Must use $(ndims(A)) indexes")
+Base.getindex{T}(A::TSlowNIndexes{T,2}, i::Int, j::Int) = A.data[i,j]
+
+
+
 type GenericIterator{N} end
 Base.start{N}(::GenericIterator{N}) = 1
 Base.next{N}(::GenericIterator{N}, i) = (i, i + 1)
@@ -452,6 +463,19 @@ function test_vcat_depwarn(::Type{TestAbstractArray})
     end
 end
 
+# Issue 13315
+function test_13315(::Type{TestAbstractArray})
+    U = UInt(1):UInt(2)
+    @test [U;[U;]] == [UInt(1), UInt(2), UInt(1), UInt(2)]
+end
+
+# checksquare
+function test_checksquare()
+    @test LinAlg.checksquare(zeros(2,2)) == 2
+    @test LinAlg.checksquare(zeros(2,2),zeros(3,3)) == [2,3]
+    @test_throws DimensionMismatch LinAlg.checksquare(zeros(2,3))
+end
+
 #----- run tests -------------------------------------------------------------#
 
 for T in (T24Linear, TSlow), shape in ((24,), (2, 12), (2,3,4), (1,2,3,4), (4,3,2,1))
@@ -471,3 +495,10 @@ test_map(TestAbstractArray)
 test_map_promote(TestAbstractArray)
 test_UInt_indexing(TestAbstractArray)
 test_vcat_depwarn(TestAbstractArray)
+test_13315(TestAbstractArray)
+test_checksquare()
+
+A = TSlowNIndexes(rand(2,2))
+@test_throws ErrorException A[1]
+@test A[1,1] == A.data[1]
+@test first(A) == A.data[1]
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 132e3275cdc56..edff1668b653d 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -24,6 +24,15 @@ b = a+a
 @test isequal(1./[1,2,5], [1.0,0.5,0.2])
 @test isequal([1,2,3]/5, [0.2,0.4,0.6])
 
+@test isequal(2.%[1,2,3], [0,0,2])
+@test isequal([1,2,3].%2, [1,0,1])
+@test isequal(2.÷[1,2,3], [2,1,0])
+@test isequal([1,2,3].÷2, [0,1,1])
+@test isequal(-2.%[1,2,3], [0,0,-2])
+@test isequal([-1,-2,-3].%2, [-1,0,-1])
+@test isequal(-2.÷[1,2,3], [-2,-1,0])
+@test isequal([-1,-2,-3].÷2, [0,-1,-1])
+
 @test isequal(1.<<[1,2,5], [2,4,32])
 @test isequal(128.>>[1,2,5], [64,32,4])
 @test isequal(2.>>1, 1)
@@ -93,7 +102,7 @@ a = rand(1, 1, 8, 8, 1)
 sz = (5,8,7)
 A = reshape(1:prod(sz),sz...)
 @test A[2:6] == [2:6;]
-@test A[1:3,2,2:4] == cat(3,46:48,86:88,126:128)
+@test A[1:3,2,2:4] == cat(2,46:48,86:88,126:128)
 @test A[:,7:-3:1,5] == [191 176 161; 192 177 162; 193 178 163; 194 179 164; 195 180 165]
 @test A[:,3:9] == reshape(11:45,5,7)
 rng = (2,2:3,2:2:5)
@@ -111,7 +120,7 @@ tmp = cat([1,3],blk,blk)
 
 x = rand(2,2)
 b = x[1,:]
-@test isequal(size(b), (1, 2))
+@test isequal(size(b), (2,))
 b = x[:,1]
 @test isequal(size(b), (2,))
 
@@ -129,7 +138,7 @@ B[[3,1],[2,4]] = [21 22; 23 24]
 B[4,[2,3]] = 7
 @test B == [0 23 1 24 0; 11 12 13 14 15; 0 21 3 22 0; 0 7 7 0 0]
 
-@test isequal(reshape(1:27, 3, 3, 3)[1,:], [1  4  7  10  13  16  19  22  25])
+@test isequal(reshape(1:27, 3, 3, 3)[1,:], [1,  4,  7,  10,  13,  16,  19,  22,  25])
 
 a = [3, 5, -7, 6]
 b = [4, 6, 2, -7, 1]
@@ -306,7 +315,7 @@ for i = 1:3
 end
 @test isequal(a,findn(z))
 
-#argmin argmax
+#findmin findmax indmin indmax
 @test indmax([10,12,9,11]) == 2
 @test indmin([10,12,9,11]) == 3
 @test findmin([NaN,3.2,1.8]) == (1.8,3)
@@ -316,6 +325,16 @@ end
 @test findmin([3.2,1.8,NaN,2.0]) == (1.8,2)
 @test findmax([3.2,1.8,NaN,2.0]) == (3.2,1)
 
+# #14085
+@test findmax(4:9) == (9,6)
+@test indmax(4:9) == 6
+@test findmin(4:9) == (4,1)
+@test indmin(4:9) == 1
+@test findmax(5:-2:1) == (5,1)
+@test indmax(5:-2:1) == 1
+@test findmin(5:-2:1) == (1,3)
+@test indmin(5:-2:1) == 3
+
 ## permutedims ##
 
 #keeps the num of dim
@@ -575,12 +594,12 @@ let
 
     @test isequal(c[:,1], cv)
     @test isequal(c[:,3], cv2)
-    @test isequal(c[4,:], [2.0 2.0 2.0 2.0]*1000)
+    @test isequal(c[4,:], [2.0, 2.0, 2.0, 2.0]*1000)
 
     c = cumsum_kbn(A, 2)
 
-    @test isequal(c[1,:], cv2')
-    @test isequal(c[3,:], cv')
+    @test isequal(c[1,:], cv2)
+    @test isequal(c[3,:], cv)
     @test isequal(c[:,4], [2.0,2.0,2.0,2.0]*1000)
 
 end
@@ -838,6 +857,11 @@ end
 @test isequal([1,2,3], [a for (a,b) in enumerate(2:4)])
 @test isequal([2,3,4], [b for (a,b) in enumerate(2:4)])
 
+# comprehension in let-bound function
+let x⊙y = sum([x[i]*y[i] for i=1:length(x)])
+    @test [1,2] ⊙ [3,4] == 11
+end
+
 @test_throws DomainError (10.^[-1])[1] == 0.1
 @test (10.^[-1.])[1] == 0.1
 
@@ -940,7 +964,7 @@ end
 
 # Handle block matrices
 A = [randn(2,2) for i = 1:2, j = 1:2]
-@test issym(A.'A)
+@test issymmetric(A.'A)
 A = [complex(randn(2,2), randn(2,2)) for i = 1:2, j = 1:2]
 @test ishermitian(A'A)
 
@@ -1090,6 +1114,15 @@ I2 = CartesianIndex((-1,5,2))
 @test min(CartesianIndex((2,3)), CartesianIndex((5,2))) == CartesianIndex((2,2))
 @test max(CartesianIndex((2,3)), CartesianIndex((5,2))) == CartesianIndex((5,3))
 
+# CartesianIndex allows construction at a particular dimensionality
+@test length(CartesianIndex{3}()) == 3
+@test length(CartesianIndex{3}(1,2)) == 3
+@test length(CartesianIndex{3}((1,2))) == 3
+@test length(CartesianIndex{3}(1,2,3)) == 3
+@test length(CartesianIndex{3}((1,2,3))) == 3
+@test_throws DimensionMismatch CartesianIndex{3}(1,2,3,4)
+@test_throws DimensionMismatch CartesianIndex{3}((1,2,3,4))
+
 @test length(I1) == 3
 
 a = spzeros(2,3)
@@ -1141,10 +1174,10 @@ R = CartesianRange((0,3))
 R = CartesianRange((3,0))
 @test done(R, start(R)) == true
 
-@test eachindex(Base.LinearSlow(),zeros(3),zeros(2,2),zeros(2,2,2),zeros(2,2)) == CartesianRange((3,2,2))
-@test eachindex(Base.LinearFast(),zeros(3),zeros(2,2),zeros(2,2,2),zeros(2,2)) == 1:8
-@test eachindex(zeros(3),sub(zeros(3,3),1:2,1:2),zeros(2,2,2),zeros(2,2)) == CartesianRange((3,2,2))
-@test eachindex(zeros(3),zeros(2,2),zeros(2,2,2),zeros(2,2)) == 1:8
+@test @inferred(eachindex(Base.LinearSlow(),zeros(3),zeros(2,2),zeros(2,2,2),zeros(2,2))) == CartesianRange((3,2,2))
+@test @inferred(eachindex(Base.LinearFast(),zeros(3),zeros(2,2),zeros(2,2,2),zeros(2,2))) == 1:8
+@test @inferred(eachindex(zeros(3),sub(zeros(3,3),1:2,1:2),zeros(2,2,2),zeros(2,2))) == CartesianRange((3,2,2))
+@test @inferred(eachindex(zeros(3),zeros(2,2),zeros(2,2,2),zeros(2,2))) == 1:8
 
 
 #rotates
@@ -1233,7 +1266,7 @@ b = rand(6,7)
 # return type declarations (promote_op)
 module RetTypeDecl
     using Base.Test
-    import Base: +, *, .*
+    import Base: +, *, .*, zero
 
     immutable MeterUnits{T,P} <: Number
         val::T
@@ -1243,9 +1276,11 @@ module RetTypeDecl
     m  = MeterUnits(1.0, 1)   # 1.0 meter, i.e. units of length
     m2 = MeterUnits(1.0, 2)   # 1.0 meter^2, i.e. units of area
 
-    (+){T}(x::MeterUnits{T,1}, y::MeterUnits{T,1}) = MeterUnits{T,1}(x.val+y.val)
+    (+){T,pow}(x::MeterUnits{T,pow}, y::MeterUnits{T,pow}) = MeterUnits{T,pow}(x.val+y.val)
+    (*){T,pow}(x::Int, y::MeterUnits{T,pow}) = MeterUnits{typeof(x*one(T)),pow}(x*y.val)
     (*){T}(x::MeterUnits{T,1}, y::MeterUnits{T,1}) = MeterUnits{T,2}(x.val*y.val)
     (.*){T}(x::MeterUnits{T,1}, y::MeterUnits{T,1}) = MeterUnits{T,2}(x.val*y.val)
+    zero{T,pow}(x::MeterUnits{T,pow}) = MeterUnits{T,pow}(zero(T))
 
     Base.promote_op{R,S}(::Base.AddFun, ::Type{MeterUnits{R,1}}, ::Type{MeterUnits{S,1}}) = MeterUnits{promote_type(R,S),1}
     Base.promote_op{R,S}(::Base.MulFun, ::Type{MeterUnits{R,1}}, ::Type{MeterUnits{S,1}}) = MeterUnits{promote_type(R,S),2}
@@ -1255,6 +1290,8 @@ module RetTypeDecl
     @test @inferred([m,m]+m) == [m+m,m+m]
     @test @inferred(m.*[m,m]) == [m2,m2]
     @test @inferred([m,m].*m) == [m2,m2]
+    @test @inferred([m 2m; m m]*[m,m]) == [3m2,2m2]
+    @test @inferred([m m].*[m,m]) == [m2 m2; m2 m2]
 end
 
 # range, range ops
@@ -1265,3 +1302,168 @@ B = 1.5:5.5
 #slice dim error
 A = zeros(5,5)
 @test_throws ArgumentError slicedim(A,0,1)
+
+###
+### LinearSlow workout
+###
+immutable LinSlowMatrix{T} <: DenseArray{T,2}
+    data::Matrix{T}
+end
+
+# This is the default, but just to be sure
+Base.linearindexing{A<:LinSlowMatrix}(::Type{A}) = Base.LinearSlow()
+
+Base.size(A::LinSlowMatrix) = size(A.data)
+
+Base.getindex(A::LinSlowMatrix, i::Integer) = error("Not defined")
+Base.getindex(A::LinSlowMatrix, i::Integer, j::Integer) = A.data[i,j]
+
+Base.setindex!(A::LinSlowMatrix, v, i::Integer) = error("Not defined")
+Base.setindex!(A::LinSlowMatrix, v, i::Integer, j::Integer) = A.data[i,j] = v
+
+A = rand(3,5)
+B = LinSlowMatrix(A)
+S = sub(A, :, :)
+
+@test A == B
+@test B == A
+@test isequal(A, B)
+@test isequal(B, A)
+
+for (a,b) in zip(A, B)
+    @test a == b
+end
+for (a,s) in zip(A, S)
+    @test a == s
+end
+
+C = copy(B)
+@test A == C
+@test B == C
+
+@test vec(A) == vec(B) == vec(S)
+@test minimum(A) == minimum(B) == minimum(S)
+@test maximum(A) == maximum(B) == maximum(S)
+
+a, ai = findmin(A)
+b, bi = findmin(B)
+s, si = findmin(S)
+@test a == b == s
+@test ai == bi == si
+
+a, ai = findmax(A)
+b, bi = findmax(B)
+s, si = findmax(S)
+@test a == b == s
+@test ai == bi == si
+
+fill!(B, 2)
+@test all(x->x==2, B)
+
+iall = (1:size(A,1)).*ones(Int,size(A,2))'
+jall = ones(Int,size(A,1)).*(1:size(A,2))'
+i,j = findn(B)
+@test vec(i) == vec(iall)
+@test vec(j) == vec(jall)
+fill!(S, 2)
+i,j = findn(S)
+@test vec(i) == vec(iall)
+@test vec(j) == vec(jall)
+
+copy!(B, A)
+copy!(S, A)
+
+@test cat(1, A, B, S) == cat(1, A, A, A)
+@test cat(2, A, B, S) == cat(2, A, A, A)
+
+@test cumsum(A, 1) == cumsum(B, 1) == cumsum(S, 1)
+@test cumsum(A, 2) == cumsum(B, 2) == cumsum(S, 2)
+
+@test mapslices(v->sort(v), A, 1) == mapslices(v->sort(v), B, 1) == mapslices(v->sort(v), S, 1)
+@test mapslices(v->sort(v), A, 2) == mapslices(v->sort(v), B, 2) == mapslices(v->sort(v), S, 2)
+
+@test flipdim(A, 1) == flipdim(B, 1) == flipdim(S, 2)
+@test flipdim(A, 2) == flipdim(B, 2) == flipdim(S, 2)
+
+@test A + 1 == B + 1 == S + 1
+@test 2*A == 2*B == 2*S
+@test A/3 == B/3 == S/3
+
+# issue #13250
+x13250 = zeros(3)
+x13250[UInt(1):UInt(2)] = 1.0
+@test x13250[1] == 1.0
+@test x13250[2] == 1.0
+@test x13250[3] == 0.0
+
+immutable SquaresVector <: AbstractArray{Int, 1}
+    count::Int
+end
+Base.size(S::SquaresVector) = (S.count,)
+Base.linearindexing(::Type{SquaresVector}) = Base.LinearFast()
+Base.getindex(S::SquaresVector, i::Int) = i*i
+foo_squares = SquaresVector(5)
+@test convert(Array{Int}, foo_squares) == [1,4,9,16,25]
+@test convert(Array{Int, 1}, foo_squares) == [1,4,9,16,25]
+
+# issue #13254
+let A = zeros(Int, 2, 2), B = zeros(Float64, 2, 2)
+    f1() = [1]
+    f2() = [1;]
+    f3() = [1;2]
+    f4() = [1;2.0]
+    f5() = [1 2]
+    f6() = [1 2.0]
+    f7() = Int[1]
+    f8() = Float64[1]
+    f9() = Int[1;]
+    f10() = Float64[1;]
+    f11() = Int[1;2]
+    f12() = Float64[1;2]
+    f13() = Int[1;2.0]
+    f14() = Int[1 2]
+    f15() = Float64[1 2]
+    f16() = Int[1 2.0]
+    f17() = [1:2;]
+    f18() = Int[1:2;]
+    f19() = Float64[1:2;]
+    f20() = [1:2;1:2]
+    f21() = Int[1:2;1:2]
+    f22() = Float64[1:2;1:2]
+    f23() = [1:2;1.0:2.0]
+    f24() = Int[1:2;1.0:2.0]
+    f25() = [1:2 1:2]
+    f26() = Int[1:2 1:2]
+    f27() = Float64[1:2 1:2]
+    f28() = [1:2 1.0:2.0]
+    f29() = Int[1:2 1.0:2.0]
+    f30() = [A;]
+    f31() = Int[A;]
+    f32() = Float64[A;]
+    f33() = [A;A]
+    f34() = Int[A;A]
+    f35() = Float64[A;A]
+    f36() = [A;B]
+    f37() = Int[A;B]
+    f38() = [A A]
+    f39() = Int[A A]
+    f40() = Float64[A A]
+    f41() = [A B]
+    f42() = Int[A B]
+
+    for f in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16,
+              f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30,
+              f31, f32, f33, f34, f35, f36, f37, f38, f39, f40, f41, f42]
+        @test isleaftype(Base.return_types(f, ())[1])
+    end
+end
+
+# issue #14482
+@inferred Base.map_to!(Int8, 1, 1, Int8[0], Int[0])
+
+# make sure @inbounds isn't used too much
+type OOB_Functor{T}; a::T; end
+(f::OOB_Functor)(i::Int) = f.a[i]
+let f = OOB_Functor([1,2])
+    @test_throws BoundsError map(f, [1,2,3,4,5])
+end
diff --git a/test/backtrace.jl b/test/backtrace.jl
index 4b516dbc0c258..3dec42bf6b39f 100644
--- a/test/backtrace.jl
+++ b/test/backtrace.jl
@@ -5,7 +5,7 @@ have_backtrace = false
 for l in bt
     lkup = ccall(:jl_lookup_code_address, Any, (Ptr{Void},), l)
     if lkup[1] == :backtrace
-        @test lkup[6] == false # fromC
+        @test lkup[7] == false # fromC
         have_backtrace = true
         break
     end
@@ -32,33 +32,33 @@ eval(Expr(:function, Expr(:call, :test_inline_1),
                      Expr(:call, :throw, "foo"))))
 
 # different-file inline
+const absfilepath = OS_NAME == :Windows ? "C:\\foo\\bar\\baz.jl" : "/foo/bar/baz.jl"
 eval(Expr(:function, Expr(:call, :test_inline_2),
                      Expr(:block, LineNumberNode(symbol("backtrace.jl"), 99),
-                     LineNumberNode(symbol("/foo/bar/baz.jl"), 111),
+                     LineNumberNode(symbol("foobar.jl"), 666),
+                     LineNumberNode(symbol(absfilepath), 111),
                      Expr(:call, :throw, "foo"))))
 
 try
     eval(:(test_inline_1()))
+    error("unexpected")
 catch err
     lkup = get_bt_frame(:test_inline_1, catch_backtrace())
-    if is(lkup, nothing)
-        throw(Test.Failure("Missing backtrace in inlining test"))
-    end
+    @test lkup !== nothing || "Missing backtrace in inlining test"
 
-    fname, file, line, inlinedfile, inlinedline, fromC = lkup
+    fname, file, line, inlinedfile, inlinedline, linfo, fromC = lkup
     @test endswith(string(inlinedfile), "backtrace.jl")
     @test inlinedline == 42
 end
 try
     eval(:(test_inline_2()))
+    error("unexpected")
 catch err
     lkup = get_bt_frame(:test_inline_2, catch_backtrace())
-    if is(lkup, nothing)
-        throw(Test.Failure("Missing backtrace in inlining test"))
-    end
+    @test lkup !== nothing || "Missing backtrace in inlining test"
 
-    fname, file, line, inlinedfile, inlinedline, fromC = lkup
-    @test string(file) == "/foo/bar/baz.jl"
+    fname, file, line, inlinedfile, inlinedline, linfo, fromC = lkup
+    @test string(file) == absfilepath
     @test line == 111
     @test endswith(string(inlinedfile), "backtrace.jl")
     @test inlinedline == 99
@@ -71,3 +71,31 @@ linenum = @__LINE__; f12977(; args...) = ()
 loc = functionloc(f12977)
 @test endswith(loc[1], "backtrace.jl")
 @test loc[2] == linenum
+
+# issue #922: SimplifyCFG pass merges throws
+code_loc(p, skipC=true) = ccall(:jl_lookup_code_address, Any, (Ptr{Void},Cint), p-1, skipC)
+
+@noinline function test_throw_commoning(x)
+    if x==1; throw(AssertionError()); end
+    if x==2; throw(AssertionError()); end
+end
+
+let
+    local b1, b2
+    try
+        test_throw_commoning(1)
+    catch
+        b1 = catch_backtrace()
+    end
+    try
+        test_throw_commoning(2)
+    catch
+        b2 = catch_backtrace()
+    end
+    ind1 = find(:test_throw_commoning .== map(b->code_loc(b)[1], b1))
+    ind2 = find(:test_throw_commoning .== map(b->code_loc(b)[1], b2))
+    @test !isempty(ind1)
+    @test !isempty(ind2)
+    @test (code_loc(b1[ind1[1]])[3]::Int == code_loc(b2[ind2[1]])[3]::Int) != # source line, for example: essentials.jl:58
+          (code_loc(b1[ind1[1]])[5]::Int == code_loc(b2[ind2[1]])[5]::Int)    # inlined line, for example: backtrace.jl:82
+end
diff --git a/test/base64.jl b/test/base64.jl
index 76f31dee69881..5cc6ea2025663 100644
--- a/test/base64.jl
+++ b/test/base64.jl
@@ -18,7 +18,7 @@ end
 
 open(fname, "r") do f
     ipipe = Base64DecodePipe(f)
-    @test readall(ipipe) == inputText
+    @test readstring(ipipe) == inputText
     close(ipipe)
 end
 rm(fname)
@@ -28,16 +28,16 @@ rm(fname)
 
 # Decode with max line chars = 76 and padding
 ipipe = Base64DecodePipe(IOBuffer(encodedMaxLine76))
-@test readall(ipipe) == inputText
+@test readstring(ipipe) == inputText
 
 # Decode with max line chars = 76 and no padding
 ipipe = Base64DecodePipe(IOBuffer(encodedMaxLine76[1:end-1]))
-@test readall(ipipe) == inputText
+@test readstring(ipipe) == inputText
 
 # Decode with two padding characters ("==")
 ipipe = Base64DecodePipe(IOBuffer(string(encodedMaxLine76[1:end-2],"==")))
-@test readall(ipipe) == inputText[1:end-1]
+@test readstring(ipipe) == inputText[1:end-1]
 
 # Test incorrect format
 ipipe = Base64DecodePipe(IOBuffer(encodedMaxLine76[1:end-3]))
-@test_throws ArgumentError readall(ipipe)
+@test_throws ArgumentError readstring(ipipe)
diff --git a/test/bigint.jl b/test/bigint.jl
index 50bb8bc3137e6..c2a11443c2d78 100644
--- a/test/bigint.jl
+++ b/test/bigint.jl
@@ -280,3 +280,19 @@ ndigits_mismatch(n) = ndigits(n) != ndigits(BigInt(n))
 @test BigInt(2.0) == BigInt(2.0f0) == BigInt(big(2.0)) == 2
 @test_throws InexactError convert(BigInt, 2.1)
 @test_throws InexactError convert(BigInt, big(2.1))
+
+# issue #13367
+@test trunc(BigInt,2.1) == 2
+@test round(BigInt,2.1) == 2
+@test floor(BigInt,2.1) == 2
+@test ceil(BigInt,2.1) == 3
+
+@test trunc(BigInt,2.1f0) == 2
+@test round(BigInt,2.1f0) == 2
+@test floor(BigInt,2.1f0) == 2
+@test ceil(BigInt,2.1f0) == 3
+
+@test_throws InexactError trunc(BigInt,Inf)
+@test_throws InexactError round(BigInt,Inf)
+@test_throws InexactError floor(BigInt,Inf)
+@test_throws InexactError ceil(BigInt,Inf)
diff --git a/test/bitarray.jl b/test/bitarray.jl
index 514e784d60220..d57ec2b7fc221 100644
--- a/test/bitarray.jl
+++ b/test/bitarray.jl
@@ -171,10 +171,10 @@ function gen_getindex_data()
     m1, m2 = rand_m1m2()
     produce((m1, m2, Bool))
     m1, m2 = rand_m1m2()
-    produce((m1, 1:m2, BitMatrix))
-    produce((m1, :, BitMatrix))
+    produce((m1, 1:m2, BitVector))
+    produce((m1, :, BitVector))
     m1, m2 = rand_m1m2()
-    produce((m1, randperm(m2), BitMatrix))
+    produce((m1, randperm(m2), BitVector))
     m1, m2 = rand_m1m2()
     produce((1:m1, m2, BitVector))
     produce((:, m2, BitVector))
@@ -1201,7 +1201,7 @@ b1 = triu(bitrand(n2, n1))
 
 b1 = bitrand(n1,n1)
 b1 |= b1.'
-@check_bit_operation issym(b1) Bool
+@check_bit_operation issymmetric(b1) Bool
 @check_bit_operation ishermitian(b1) Bool
 
 b1 = bitrand(n1)
diff --git a/test/blas.jl b/test/blas.jl
index b20e166ed41c3..6671a919f0d75 100644
--- a/test/blas.jl
+++ b/test/blas.jl
@@ -84,8 +84,8 @@ for elty in [Float32, Float64, Complex64, Complex128]
             @test_approx_eq BLAS.axpy!(α,copy(x1),copy(x2)) x2 + α*x1
             @test_throws DimensionMismatch BLAS.axpy!(α, copy(x1), rand(elty, n + 1))
             @test_throws DimensionMismatch BLAS.axpy!(α, copy(x1), 1:div(n,2), copy(x2), 1:n)
-            @test_throws BoundsError BLAS.axpy!(α, copy(x1), 0:div(n,2), copy(x2), 1:(div(n, 2) + 1))
-            @test_throws BoundsError BLAS.axpy!(α, copy(x1), 1:div(n,2), copy(x2), 0:(div(n, 2) - 1))
+            @test_throws ArgumentError BLAS.axpy!(α, copy(x1), 0:div(n,2), copy(x2), 1:(div(n, 2) + 1))
+            @test_throws ArgumentError BLAS.axpy!(α, copy(x1), 1:div(n,2), copy(x2), 0:(div(n, 2) - 1))
             @test_approx_eq BLAS.axpy!(α,copy(x1),1:n,copy(x2),1:n) x2 + α*x1
         else
             z1 = convert(Vector{elty}, complex(randn(n), randn(n)))
@@ -94,8 +94,8 @@ for elty in [Float32, Float64, Complex64, Complex128]
             @test_approx_eq BLAS.axpy!(α, copy(z1), copy(z2)) z2 + α * z1
             @test_throws DimensionMismatch BLAS.axpy!(α, copy(z1), rand(elty, n + 1))
             @test_throws DimensionMismatch BLAS.axpy!(α, copy(z1), 1:div(n, 2), copy(z2), 1:(div(n, 2) + 1))
-            @test_throws BoundsError BLAS.axpy!(α, copy(z1), 0:div(n,2), copy(z2), 1:(div(n, 2) + 1))
-            @test_throws BoundsError BLAS.axpy!(α, copy(z1), 1:div(n,2), copy(z2), 0:(div(n, 2) - 1))
+            @test_throws ArgumentError BLAS.axpy!(α, copy(z1), 0:div(n,2), copy(z2), 1:(div(n, 2) + 1))
+            @test_throws ArgumentError BLAS.axpy!(α, copy(z1), 1:div(n,2), copy(z2), 0:(div(n, 2) - 1))
             @test_approx_eq BLAS.axpy!(α,copy(z1),1:n,copy(z2),1:n) z2 + α*z1
         end
 
@@ -113,7 +113,7 @@ for elty in [Float32, Float64, Complex64, Complex128]
 
         # scal
         α = rand(elty)
-        @test BLAS.scal(n,α,a,1) ≈ scale(α,a)
+        @test BLAS.scal(n,α,a,1) ≈ α * a
 
         # trsv
         A = triu(rand(elty,n,n))
@@ -132,7 +132,7 @@ for elty in [Float32, Float64, Complex64, Complex128]
 
         A = rand(elty,n,n)
         A = A + A.'
-        @test issym(A)
+        @test issymmetric(A)
         @test_approx_eq triu(BLAS.syr!('U',α,x,copy(A))) triu(A + α*x*x.')
         @test_throws DimensionMismatch BLAS.syr!('U',α,ones(elty,n+1),copy(A))
 
@@ -150,8 +150,8 @@ for elty in [Float32, Float64, Complex64, Complex128]
         BLAS.copy!(x2, 1:n, x1, 1:n)
         @test x2 == x1
         @test_throws DimensionMismatch BLAS.copy!(x2, 1:n, x1, 1:(n - 1))
-        @test_throws BoundsError BLAS.copy!(x1, 0:div(n, 2), x2, 1:(div(n, 2) + 1))
-        @test_throws BoundsError BLAS.copy!(x1, 1:(div(n, 2) + 1), x2, 0:div(n, 2))
+        @test_throws ArgumentError BLAS.copy!(x1, 0:div(n, 2), x2, 1:(div(n, 2) + 1))
+        @test_throws ArgumentError BLAS.copy!(x1, 1:(div(n, 2) + 1), x2, 0:div(n, 2))
 
         # symv and hemv
 
diff --git a/test/boundscheck.jl b/test/boundscheck.jl
new file mode 100644
index 0000000000000..a17fc8ed74279
--- /dev/null
+++ b/test/boundscheck.jl
@@ -0,0 +1,113 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+module TestBoundsCheck
+
+using Base.Test
+
+# test for boundscheck block eliminated at same level
+@inline function A1()
+    r = 0
+    @boundscheck r += 1
+    return r
+end
+
+@noinline function A1_noinline()
+    r = 0
+    @boundscheck r += 1
+    return r
+end
+
+function A1_inbounds()
+    r = 0
+    @inbounds begin
+        @boundscheck r += 1
+    end
+    return r
+end
+
+@test A1() == 1
+@test A1_inbounds() == 0
+
+# test for boundscheck block eliminated one layer deep, if the called method is inlined
+@inline function A2()
+    r = A1()+1
+    return r
+end
+
+function A2_inbounds()
+    @inbounds r = A1()+1
+    return r
+end
+
+function A2_notinlined()
+    @inbounds r = A1_noinline()+1
+    return r
+end
+
+Base.@propagate_inbounds function A2_propagate_inbounds()
+    r = A1()+1
+    return r
+end
+
+@test A2() == 2
+@test A2_inbounds() == 1
+@test A2_notinlined() == 2
+@test A2_propagate_inbounds() == 2
+
+# test boundscheck NOT eliminated two layers deep, unless propagated
+
+function A3()
+    r = A2()+1
+    return r
+end
+
+function A3_inbounds()
+    @inbounds r = A2()+1
+    return r
+end
+
+function A3_inbounds2()
+    @inbounds r = A2_propagate_inbounds()+1
+    return r
+end
+
+@test A3() == 3
+@test A3_inbounds() == 3
+@test A3_inbounds2() == 2
+
+# swapped nesting order of @boundscheck and @inbounds
+function A1_nested()
+    r = 0
+    @boundscheck @inbounds r += 1
+    return r
+end
+
+@test A1_nested() == 1
+
+# elide a throw
+cb(x) = x > 0 || throw("cb:error")
+
+function B1()
+    y = [1,2,3]
+    @inbounds begin
+        @boundscheck cb(0)
+    end
+    return 0
+end
+
+@test B1() == 0
+
+# elide a simple branch
+cond(x) = x > 0 ? x : -x
+
+function B2()
+    y = [1,2,3]
+    @inbounds begin
+        @boundscheck cond(0)
+    end
+    return 0
+end
+
+@test B2() == 0
+
+end
diff --git a/test/ccall.jl b/test/ccall.jl
index f1e51c9d33c22..c9268b55e4a45 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1,23 +1,27 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 import Base.copy, Base.==
+
+const libccalltest = "libccalltest"
+
 const verbose = false
-const libccalltest = joinpath(dirname(@__FILE__), "libccalltest")
 ccall((:set_verbose, libccalltest), Void, (Int32,), verbose)
 
+
 # Test for proper argument register truncation
 ccall_test_func(x) = ccall((:testUcharX, libccalltest), Int32, (UInt8,), x % UInt8)
 @test ccall_test_func(3) == 1
 @test ccall_test_func(259) == 1
 
+
 # Test for proper round-trip of Ref{T} type
 ccall_echo_func{T,U}(x, ::Type{T}, ::Type{U}) = ccall((:test_echo_p, libccalltest), T, (U,), x)
 # Make sure object x is still valid (rooted as argument)
 # when loading the pointer. This works as long as we still keep the argument
 # rooted but might fail if we are smarter about eliminating dead root.
-ccall_echo_load{T,U}(x, ::Type{T}, ::Type{U}) =
+@noinline ccall_echo_load{T,U}(x, ::Type{T}, ::Type{U}) =
     unsafe_load(ccall_echo_func(x, T, U))
-ccall_echo_objref{T,U}(x, ::Type{T}, ::Type{U}) =
+@noinline ccall_echo_objref{T,U}(x, ::Type{T}, ::Type{U}) =
     unsafe_pointer_to_objref(ccall_echo_func(x, Ptr{T}, U))
 type IntLike
     x::Int
@@ -40,101 +44,374 @@ end
 @test ccall_echo_load(Ref([144,172],2), Ptr{Int}, Ref{Int}) === 172
 # @test ccall_echo_load(Ref([8],1,1), Ptr{Int}, Ref{Int}) === 8
 
-# Tests for passing and returning structs
-ci = 20+51im
-b = ccall((:ctest, libccalltest), Complex{Int}, (Complex{Int},), ci)
-@test b == ci + 1 - 2im
-ci_ary = [ci] # Make sure the array is alive during unsafe_load
-b = unsafe_load(ccall((:cptest, libccalltest), Ptr{Complex{Int}},
-                      (Ptr{Complex{Int}},), ci_ary))
-@test b == ci + 1 - 2im
-@test ci == 20+51im
 
-b = ccall((:cptest_static, libccalltest), Ptr{Complex{Int}}, (Ptr{Complex{Int}},), &ci)
-@test unsafe_load(b) == ci
-Libc.free(convert(Ptr{Void},b))
+## Tests for passing and returning structs
 
-cf64 = 2.84+5.2im
-b = ccall((:cgtest, libccalltest), Complex128, (Complex128,), cf64)
-@test b == cf64 + 1 - 2im
-cf64_ary = [cf64] # Make sure the array is alive during unsafe_load
-b = unsafe_load(ccall((:cgptest, libccalltest), Ptr{Complex128}, (Ptr{Complex128},), cf64_ary))
-@test b == cf64 + 1 - 2im
-@test cf64 == 2.84+5.2im
+let
+    a = 20 + 51im
 
-cf32 = 3.34f0+53.2f0im
-b = ccall((:cftest, libccalltest), Complex64, (Complex64,), cf32)
-@test b == cf32 + 1 - 2im
-cf32_ary = [cf32] # Make sure the array is alive during unsafe_load
-b = unsafe_load(ccall((:cfptest, libccalltest), Ptr{Complex64}, (Ptr{Complex64},), cf32_ary))
-@test b == cf32 + 1 - 2im
-@test cf32 == 3.34f0+53.2f0im
+    x = ccall((:ctest, libccalltest), Complex{Int}, (Complex{Int},), a)
+
+    @test x == a + 1 - 2im
+
+    ci_ary = [a] # Make sure the array is alive during unsafe_load
+    x = unsafe_load(ccall((:cptest, libccalltest), Ptr{Complex{Int}},
+                          (Ptr{Complex{Int}},), ci_ary))
+
+    @test x == a + 1 - 2im
+    @test a == 20 + 51im
+
+    x = ccall((:cptest_static, libccalltest), Ptr{Complex{Int}}, (Ptr{Complex{Int}},), &a)
+    @test unsafe_load(x) == a
+    Libc.free(convert(Ptr{Void},x))
+end
+
+let
+    a = 2.84 + 5.2im
+
+    x = ccall((:cgtest, libccalltest), Complex128, (Complex128,), a)
+
+    @test x == a + 1 - 2im
+
+    b = [a] # Make sure the array is alive during unsafe_load
+    x = unsafe_load(ccall((:cgptest, libccalltest), Ptr{Complex128}, (Ptr{Complex128},), b))
 
+    @test x == a + 1 - 2im
+    @test a == 2.84 + 5.2im
+end
+
+let
+    a = 3.34f0 + 53.2f0im
+
+    x = ccall((:cftest, libccalltest), Complex64, (Complex64,), a)
 
-# Tests for native Julia data types
-@test_throws MethodError ccall((:cptest, libccalltest), Ptr{Complex{Int}}, (Ptr{Complex{Int}},), cf32)
-@test_throws MethodError ccall((:cptest, libccalltest), Ptr{Complex{Int}}, (Complex{Int},), &cf32)
+    @test x == a + 1 - 2im
+
+    b = [a] # Make sure the array is alive during unsafe_load
+    x = unsafe_load(ccall((:cfptest, libccalltest), Ptr{Complex64}, (Ptr{Complex64},), b))
+
+    @test x == a + 1 - 2im
+    @test a == 3.34f0 + 53.2f0im
+end
+
+
+## Tests for native Julia data types
+
+let
+    a = 2.84 + 5.2im
+
+    @test_throws MethodError ccall((:cptest, libccalltest), Ptr{Complex{Int}}, (Ptr{Complex{Int}},), a)
+    @test_throws MethodError ccall((:cptest, libccalltest), Ptr{Complex{Int}}, (Complex{Int},), &a)
+end
+
+
+## Tests for various sized data types (ByVal)
 
-# Tests for various sized data types (ByVal)
 type Struct1
     x::Float32
     y::Float64
 end
-==(a::Struct1,b::Struct1) = a.x == b.x && a.y == b.y
 copy(a::Struct1) = Struct1(a.x, a.y)
-s1 = Struct1(352.39422f23, 19.287577)
-a = copy(s1)
-b = ccall((:test_1, libccalltest), Struct1, (Struct1,), a)
-@test a.x == s1.x && a.y == s1.y
-@test !(a === b)
-@test b.x == s1.x + 1 && b.y == s1.y - 2
 
-function foos1(s::Struct1)
-    @test !(s === a)
-    @test s == a
-    s
+let
+    a = Struct1(352.39422f23, 19.287577)
+    b = Float32(123.456)
+
+    a2 = copy(a)
+    x = ccall((:test_1, libccalltest), Struct1, (Struct1, Float32), a2, b)
+
+    @test a2.x == a.x && a2.y == a.y
+    @test !(a2 === x)
+
+    @test_approx_eq x.x a.x + 1*b
+    @test_approx_eq x.y a.y - 2*b
 end
 
-ci32 = Complex{Int32}(Int32(10),Int32(31))
-ba = ccall((:test_2a, libccalltest), Complex{Int32}, (Complex{Int32},), ci32)
-bb = ccall((:test_2b, libccalltest), Complex{Int32}, (Complex{Int32},), ci32)
-@test ba == bb == ci32 + 1 - 2im
-@test ci32 == Complex{Int32}(Int32(10),Int32(31))
+let
+    a = Complex{Int32}(Int32(10),Int32(31))
+    b = Int32(42)
 
-ci64 = Complex{Int64}(Int64(20),Int64(51))
-ba = ccall((:test_3a, libccalltest), Complex{Int64}, (Complex{Int64},), ci64)
-bb = ccall((:test_3b, libccalltest), Complex{Int64}, (Complex{Int64},), ci64)
-bc = ccall((:test_128, libccalltest), Complex{Int64}, (Complex{Int64},), ci64)
-@test ba == bb == ci64 + 1 - 2im
-@test bc == ci64 + 1
-@test ci64 == Complex{Int64}(Int64(20),Int64(51))
-
-i128 = Int128(0x7f00123456789abc)<<64 + typemax(UInt64)
-b = ccall((:test_128, libccalltest), Int128, (Int128,), i128)
-@test b == i128 + 1
-@test i128 == Int128(0x7f00123456789abc)<<64 + typemax(UInt64)
+    x = ccall((:test_2a, libccalltest), Complex{Int32}, (Complex{Int32}, Int32), a, b)
+    y = ccall((:test_2b, libccalltest), Complex{Int32}, (Complex{Int32},Int32), a, b)
+
+    @test a == Complex{Int32}(Int32(10),Int32(31))
+
+    @test x == y
+    @test x == a + b*1 - b*2im
+end
+
+let
+    a = Complex{Int64}(Int64(20),Int64(51))
+    b = Int64(42)
+
+    x = ccall((:test_3a, libccalltest), Complex{Int64}, (Complex{Int64}, Int64), a, b)
+    y = ccall((:test_3b, libccalltest), Complex{Int64}, (Complex{Int64}, Int64), a, b)
+    z = ccall((:test_128, libccalltest), Complex{Int64}, (Complex{Int64}, Int64), a, b)
+
+    @test a == Complex{Int64}(Int64(20),Int64(51))
+
+    @test x == y
+    @test x == a + b*1 - b*2im
+
+    @test z == a + 1*b
+end
+
+type Struct4
+    x::Int32
+    y::Int32
+    z::Int32
+end
+
+let
+    a = Struct4(-512275808,882558299,-2133022131)
+    b = Int32(42)
+
+    x = ccall((:test_4, libccalltest), Struct4, (Struct4,Int32), a, b)
+
+    @test x.x == a.x+b*1
+    @test x.y == a.y-b*2
+    @test x.z == a.z+b*3
+end
+
+type Struct5
+    x::Int32
+    y::Int32
+    z::Int32
+    a::Int32
+end
+
+let
+    a = Struct5(1771319039, 406394736, -1269509787, -745020976)
+    b = Int32(42)
+
+    x = ccall((:test_5, libccalltest), Struct5, (Struct5,Int32), a, b)
+
+    @test x.x == a.x+b*1
+    @test x.y == a.y-b*2
+    @test x.z == a.z+b*3
+    @test x.a == a.a-b*4
+end
+
+type Struct6
+    x::Int64
+    y::Int64
+    z::Int64
+end
+
+let
+    a = Struct6(-654017936452753226, -5573248801240918230, -983717165097205098)
+    b = Int64(42)
+
+    x = ccall((:test_6, libccalltest), Struct6, (Struct6, Int64), a, b)
+
+    @test x.x == a.x+b*1
+    @test x.y == a.y-b*2
+    @test x.z == a.z+b*3
+end
+
+type Struct7
+    x::Int64
+    y::Cchar
+end
+
+let
+    a = Struct7(-384082741977533896, 'h')
+    b = Int8(42)
+
+    x = ccall((:test_7, libccalltest), Struct7, (Struct7,Int8), a, b)
+
+    @test x.x == a.x+Int(b)*1
+    @test x.y == a.y-Int(b)*2
+end
+
+type Struct8
+    x::Int32
+    y::Cchar
+end
+
+let
+    a = Struct8(-384082896, 'h')
+    b = Int8(42)
+
+    r8 = ccall((:test_8, libccalltest), Struct8, (Struct8,Int8), a, b)
+
+    @test r8.x == a.x+b*1
+    @test r8.y == a.y-b*2
+end
+
+type Struct9
+    x::Int32
+    y::Int16
+end
+
+let
+    a = Struct9(-394092996, -3840)
+    b = Int16(42)
+
+    x = ccall((:test_9, libccalltest), Struct9, (Struct9,Int16), a, b)
+
+    @test x.x == a.x+b*1
+    @test x.y == a.y-b*2
+end
+
+type Struct10
+    x::Cchar
+    y::Cchar
+    z::Cchar
+    a::Cchar
+end
+
+let
+    a = Struct10('0', '1', '2', '3')
+    b = Int8(2)
+
+    x = ccall((:test_10, libccalltest), Struct10, (Struct10,Int8), a, b)
+
+    @test x.x == a.x+b*1
+    @test x.y == a.y-b*2
+    @test x.z == a.z+b*3
+    @test x.a == a.a-b*4
+end
+
+type Struct11
+    x::Complex64
+end
+
+let
+    a = Struct11(0.8877077f0 + 0.4591081f0im)
+    b = Float32(42)
+
+    x = ccall((:test_11, libccalltest), Struct11, (Struct11,Float32), a, b)
+
+    @test_approx_eq x.x a.x + b*1 - b*2im
+end
+
+type Struct12
+    x::Complex64
+    y::Complex64
+end
+
+let
+    a = Struct12(0.8877077f5 + 0.4591081f2im, 0.0004842868f0 - 6982.3265f3im)
+    b = Float32(42)
+
+    x = ccall((:test_12, libccalltest), Struct12, (Struct12,Float32), a, b)
+
+    @test_approx_eq x.x a.x + b*1 - b*2im
+    @test_approx_eq x.y a.y + b*3 - b*4im
+end
+
+type Struct13
+    x::Complex128
+end
+
+let
+    a = Struct13(42968.97560380495 - 803.0576845153616im)
+    b = Float64(42)
+
+    x = ccall((:test_13, libccalltest), Struct13, (Struct13,Float64), a, b)
+
+    @test_approx_eq x.x a.x + b*1 - b*2im
+end
+
+type Struct14
+    x::Float32
+    y::Float32
+end
+
+let
+    a = Struct14(0.024138331f0, 0.89759064f32)
+    b = Float32(42)
+
+    x = ccall((:test_14, libccalltest), Struct14, (Struct14,Float32), a, b)
+
+    @test_approx_eq x.x a.x + b*1
+    @test_approx_eq x.y a.y - b*2
+end
+
+type Struct15
+    x::Float64
+    y::Float64
+end
+
+let
+    a = Struct15(4.180997967273657, -0.404218594294923)
+    b = Float64(42)
+
+    x = ccall((:test_15, libccalltest), Struct15, (Struct15,Float64), a, b)
+
+    @test_approx_eq x.x a.x + b*1
+    @test_approx_eq x.y a.y - b*2
+end
+
+type Struct16
+    x::Float32
+    y::Float32
+    z::Float32
+    a::Float64
+    b::Float64
+    c::Float64
+end
+
+let
+    a = Struct16(0.1604656f0, 0.6297606f0, 0.83588994f0,
+                 0.6460273620993535, 0.9472692581106656, 0.47328535437352093)
+    b = Float32(42)
+
+    x = ccall((:test_16, libccalltest), Struct16, (Struct16,Float32), a, b)
+
+    @test_approx_eq x.x a.x + b*1
+    @test_approx_eq x.y a.y - b*2
+    @test_approx_eq x.z a.z + b*3
+    @test_approx_eq x.a a.a - b*4
+    @test_approx_eq x.b a.b + b*5
+    @test_approx_eq x.c a.c - b*6
+end
+
+let
+    a = Int128(0x7f00123456789abc)<<64 + typemax(UInt64)
+    b = Int64(1)
+
+    x = ccall((:test_128, libccalltest), Int128, (Int128, Int64), a, b)
+
+    @test x == a + b*1
+    @test a == Int128(0x7f00123456789abc)<<64 + typemax(UInt64)
+end
 
 type Struct_Big
     x::Int
     y::Int
     z::Int8
 end
-==(a::Struct_Big,b::Struct_Big) = a.x == b.x && a.y == b.y && a.z == b.z
 copy(a::Struct_Big) = Struct_Big(a.x, a.y, a.z)
-sbig = Struct_Big(424,-5,Int8('Z'))
 
-a = copy(sbig)
-b = ccall((:test_big, libccalltest), Struct_Big, (Struct_Big,), a)
-@test a.x == sbig.x && a.y == sbig.y && a.z == sbig.z
-@test b.x == sbig.x + 1
-@test b.y == sbig.y - 2
-@test b.z == sbig.z - Int('A')
+let
+    a = Struct_Big(424,-5,Int8('Z'))
+    a2 = copy(a)
+
+    x = ccall((:test_big, libccalltest), Struct_Big, (Struct_Big,), a2)
+
+    @test a2.x == a.x && a2.y == a.y && a2.z == a.z
+    @test x.x == a.x + 1
+    @test x.y == a.y - 2
+    @test x.z == a.z - Int('A')
+end
+
+
+## cfunction roundtrip
 
 verbose && Libc.flush_cstdio()
 verbose && println("Testing cfunction roundtrip: ")
-# cfunction roundtrip
+
+cf64 = 2.84+5.2im
+cf32 = 3.34f0+53.2f0im
+ci32 = Complex{Int32}(Int32(10),Int32(31))
+ci64 = Complex{Int64}(Int64(20),Int64(51))
+s1 = Struct1(352.39422f23, 19.287577)
+==(a::Struct1,b::Struct1) = a.x == b.x && a.y == b.y
+
 for (t,v) in ((Complex{Int32},:ci32),(Complex{Int64},:ci64),
-            (Complex64,:cf32),(Complex128,:cf64),(Struct1,:s1))
+              (Complex64,:cf32),(Complex128,:cf64),(Struct1,:s1))
     fname = symbol("foo"*string(v))
     fname1 = symbol("foo1"*string(v))
     @eval begin
@@ -209,3 +486,40 @@ for (t,v) in ((Complex{Int32},:ci32),(Complex{Int64},:ci64),
         #b = ccall(cfunction($fname,Any,(Ref{Any},)),Any,(Ref{Any},),$v) # unimplemented
     end
 end
+
+# issue 13031
+foo13031(x) = Cint(1)
+foo13031p = cfunction(foo13031, Cint, (Ref{Tuple{}},))
+ccall(foo13031p, Cint, (Ref{Tuple{}},), ())
+
+foo13031(x,y,z) = z
+foo13031p = cfunction(foo13031, Cint, (Ref{Tuple{}},Ref{Tuple{}},Cint))
+ccall(foo13031p, Cint, (Ref{Tuple{}},Ref{Tuple{}},Cint), (), (), 8)
+
+# @threadcall functionality
+threadcall_test_func(x) =
+    @threadcall((:testUcharX, libccalltest), Int32, (UInt8,), x % UInt8)
+
+@test threadcall_test_func(3) == 1
+@test threadcall_test_func(259) == 1
+
+let n=3
+    tids=[]
+    @sync for i in 1:10^n
+        @unix_only @async push!(tids, @threadcall(:pthread_self, Cuint, ()))
+        @windows_only @async push!(tids, @threadcall(:GetCurrentThreadId, Cuint, ()))
+    end
+
+    d=Dict()
+    for t in tids
+        d[t] = get(d, t, 0) + 1
+    end
+
+    @test sum(values(d)) == 10^n
+
+    for v in values(d)
+        @test v < 10^n
+    end
+end
+
+@test ccall(:jl_getpagesize, Clong, ()) == @threadcall(:jl_getpagesize, Clong, ())
diff --git a/test/ccalltest.c b/test/ccalltest.c
deleted file mode 100644
index ef16718ef3ca4..0000000000000
--- a/test/ccalltest.c
+++ /dev/null
@@ -1,376 +0,0 @@
-// This file is a part of Julia. License is MIT: http://julialang.org/license
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <complex.h>
-#include <stdint.h>
-#include <inttypes.h>
-int verbose = 1;
-
-#include "../src/support/platform.h"
-
-#ifdef _P64
-#define jint int64_t
-#else
-#define jint int32_t
-#endif
-
-//////////////////////////////////
-// Test for proper argument register truncation
-
-int xs[300] = {0,0,0,1,0};
-
-//int testUcharX(unsigned char x);
-#ifdef _COMPILER_MICROSOFT_
-int __declspec(noinline)
-#else
-int __attribute__((noinline))
-#endif
-testUcharX(unsigned char x) {
-    return xs[x];
-}
-
-#define xstr(s) str(s)
-#define str(s) #s
-int (*volatile fptr)(unsigned char x);
-volatile int a;
-volatile int b;
-
-//////////////////////////////////
-// Tests for passing and returning Structs
-
-// Complex-like data types
-typedef struct {
-    jint real;
-    jint imag;
-} complex_t;
-
-complex_t ctest(complex_t a) {
-    a.real += 1;
-    a.imag -= 2;
-    return a;
-}
-
-complex double cgtest(complex double a) {
-    //Unpack a ComplexPair{Float64} struct
-    if (verbose) fprintf(stderr,"%g + %g i\n", creal(a), cimag(a));
-    a += 1 - (2.0*I);
-    return a;
-}
-
-complex double* cgptest(complex double *a) {
-    //Unpack a ComplexPair{Float64} struct
-    if (verbose) fprintf(stderr,"%g + %g i\n", creal(*a), cimag(*a));
-    *a += 1 - (2.0*I);
-    return a;
-}
-
-complex float cftest(complex float a) {
-    //Unpack a ComplexPair{Float32} struct
-    if (verbose) fprintf(stderr,"%g + %g i\n", creal(a), cimag(a));
-    a += 1 - (2.0*I);
-    return a;
-}
-
-complex float* cfptest(complex float *a) {
-    //Unpack a ComplexPair{Float64} struct
-    if (verbose) fprintf(stderr,"%g + %g i\n", creal(*a), cimag(*a));
-    *a += 1 - (2.0*I);
-    return a;
-}
-
-complex_t* cptest(complex_t *a) {
-    //Unpack a ComplexPair{Int} struct pointer
-    if (verbose) fprintf(stderr,"%lld + %lld i\n", (long long)a->real, (long long)a->imag);
-    a->real += 1;
-    a->imag -= 2;
-    return a;
-}
-
-complex_t* cptest_static(complex_t *a) {
-    complex_t *b = (complex_t*)malloc(sizeof(complex_t));
-    b->real = a->real;
-    b->imag = a->imag;
-    return b;
-}
-
-// Native-like data types
-char* stest(char *x) {
-    //Print a character Array
-    if (verbose) fprintf(stderr,"%s\n", x);
-    return x;
-}
-
-struct jl_asciistring_t { struct { void* type; char* data; } *data; };
-char* sptest(struct jl_asciistring_t str) {
-    //Unpack an ASCIIString
-    return stest(str.data->data);
-}
-
-// Various sized data types
-typedef struct {
-    float x;
-    double y;
-} struct1;
-
-typedef struct {
-    struct { int32_t x; } x;
-    struct { int32_t y; } y;
-} struct2a;
-
-typedef struct {
-    int32_t x;
-    int32_t y;
-} struct2b;
-
-typedef struct {
-    struct { int64_t x; } x;
-    struct { int64_t y; } y;
-} struct3a;
-
-typedef struct {
-    int64_t x;
-    int64_t y;
-} struct3b;
-
-typedef struct {
-    int32_t x;
-    int32_t y;
-    int32_t z;
-} struct4;
-
-typedef struct {
-    int32_t x;
-    int32_t y;
-    int32_t z;
-    int32_t a;
-} struct5;
-
-typedef struct {
-    int64_t x;
-    int64_t y;
-    int64_t z;
-} struct6;
-
-typedef struct {
-    int64_t x;
-    char y;
-} struct7;
-
-typedef struct {
-    int32_t x;
-    char y;
-} struct8;
-
-typedef struct {
-    int32_t x;
-    int16_t y;
-} struct9;
-
-typedef struct {
-    char x;
-    char y;
-    char z;
-    char a;
-} struct10;
-
-typedef struct {
-    complex float x;
-} struct11;
-
-typedef struct {
-    complex float x;
-    complex float y;
-} struct12;
-
-typedef struct {
-    complex double x;
-} struct13;
-
-typedef struct {
-    float x;
-    float y;
-} struct14;
-
-typedef struct {
-    double x;
-    double y;
-} struct15;
-
-typedef struct {
-    jint x;
-    jint y;
-    char z;
-} struct_big;
-
-struct1 test_1(struct1 a) {
-    //Unpack a "small" struct { float, double }
-    if (verbose) fprintf(stderr,"%g + %g i\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct1 add_1(struct1 a, struct1 b) {
-    // Two small structs
-    struct1 c;
-    c.x = a.x + b.x;
-    c.y = a.y + b.y;
-    return c;
-}
-
-struct2a test_2a(struct2a a) {
-    //Unpack a ComplexPair{Int32} struct
-    if (verbose) fprintf(stderr,"%" PRId32 " + %" PRId32 " i\n", a.x.x, a.y.y);
-    a.x.x += 1;
-    a.y.y -= 2;
-    return a;
-}
-
-struct2b test_2b(struct2b a) {
-    //Unpack a ComplexPair{Int32} struct
-    if (verbose) fprintf(stderr,"%" PRId32 " + %" PRId32 " i\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct3a test_3a(struct3a a) {
-    //Unpack a ComplexPair{Int64} struct
-    if (verbose) fprintf(stderr,"%" PRId64 " + %" PRId64 " i\n", a.x.x, a.y.y);
-    a.x.x += 1;
-    a.y.y -= 2;
-    return a;
-}
-
-struct3b test_3b(struct3b a) {
-    //Unpack a ComplexPair{Int64} struct
-    if (verbose) fprintf(stderr,"%" PRId64 " + %" PRId64 " i\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct4 test_4(struct4 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId32 ",%" PRId32 ",%" PRId32 ")\n", a.x, a.y, a.z);
-    a.x += 1;
-    a.y -= 2;
-    a.z += 3;
-    return a;
-}
-
-
-struct5 test_5(struct5 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId32 ",%" PRId32 ",%" PRId32 ",%" PRId32 ")\n", a.x, a.y, a.z, a.a);
-    a.x += 1;
-    a.y -= 2;
-    a.z += 3;
-    a.a -= 4;
-
-    return a;
-}
-
-
-struct6 test_6(struct6 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId64 ",%" PRId64 ",%" PRId64 ")\n", a.x, a.y, a.z);
-    a.x += 1;
-    a.y -= 2;
-    a.z += 3;
-    return a;
-}
-
-struct7 test_7(struct7 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId64 ",%" PRId8 ")\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct8 test_8(struct8 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId32 ",%" PRId8 ")\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct9 test_9(struct9 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId32 ",%" PRId16 ")\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct10 test_10(struct10 a)
-{
-    if (verbose) fprintf(stderr,"(%" PRId8 ",%" PRId8 ",%" PRId8 ",%" PRId8 ")\n", a.x, a.y, a.z, a.a);
-    a.x += 1;
-    a.y -= 2;
-    a.z += 3;
-    a.a -= 4;
-
-    return a;
-}
-
-struct14 test_14(struct14 a) {
-    //The C equivalent of a  ComplexPair{Float32} struct (but without special complex ABI)
-    if (verbose) fprintf(stderr,"%g + %g i\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-struct15 test_15(struct15 a) {
-    //The C equivalent of a  ComplexPair{Float32} struct (but without special complex ABI)
-    if (verbose) fprintf(stderr,"%g + %g i\n", a.x, a.y);
-    a.x += 1;
-    a.y -= 2;
-    return a;
-}
-
-#define int128_t struct3b
-int128_t test_128(int128_t a) {
-    //Unpack a Int128
-    if (verbose) fprintf(stderr,"0x%016" PRIx64 "%016" PRIx64 "\n", a.y, a.x);
-    a.x += 1;
-    if (a.x == 0)
-        a.y += 1;
-    return a;
-}
-
-struct_big test_big(struct_big a) {
-    //Unpack a "big" struct { int, int, char }
-    if (verbose) fprintf(stderr,"%lld %lld %c\n", (long long)a.x, (long long)a.y, a.z);
-    a.x += 1;
-    a.y -= 2;
-    a.z -= 'A';
-    return a;
-}
-
-int main() {
-    fprintf(stderr,"all of the following should be 1 except xs[259] = 0\n");
-    a = 3;
-    b = 259;
-    fptr = (int (*)(unsigned char x))&testUcharX;
-    if ((((size_t)fptr)&((size_t)1)) == 1) fptr = NULL;
-    fprintf(stderr,"compiled with: '%s'\nxs[3] = %d\nxs[259] = %d\ntestUcharX(3) = %d\ntestUcharX(%d) = %d\nfptr(3) = %d\nfptr(259) = %d\n",
-           xstr(CC), xs[a], xs[b], testUcharX(a), b, testUcharX((unsigned char)b), fptr(a), fptr(b));
-    fprintf(stderr,"misc tests:\n");
-    struct1 a = {352.39422e23, 19.287577};
-    a = test_1(a);
-}
-
-//////////////////////////////////
-// Turn off verbose for automated tests, leave on for debugging
-void set_verbose(int level) {
-    verbose = level;
-}
-
-void *test_echo_p(void *p) {
-    return p;
-}
diff --git a/test/char.jl b/test/char.jl
index 838466a313c12..0d2f55e3f659f 100644
--- a/test/char.jl
+++ b/test/char.jl
@@ -13,6 +13,13 @@
 # should be swapped
 @test bswap('\U10200') == '\U20100'
 
+@test 'b' + 1 == 'c'
+@test typeof('b' + 1) == Char
+@test 1 + 'b' == 'c'
+@test typeof(1 + 'b') == Char
+@test 'b' - 1 == 'a'
+@test typeof('b' - 1) == Char
+
 let
 
 numberchars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
@@ -171,3 +178,18 @@ end #end of let block
 
 @test convert(Signed, 'A') === Int32(65)
 @test convert(Unsigned, 'A') === UInt32(65)
+
+# issue #14573
+let
+    array = ['a', 'b', 'c'] + [1, 2, 3]
+    @test array == ['b', 'd', 'f']
+    @test eltype(array) == Char
+
+    array = [1, 2, 3] + ['a', 'b', 'c']
+    @test array == ['b', 'd', 'f']
+    @test eltype(array) == Char
+
+    array = ['a', 'b', 'c'] - [0, 1, 2]
+    @test array == ['a', 'a', 'a']
+    @test eltype(array) == Char
+end
diff --git a/test/checked.jl b/test/checked.jl
new file mode 100644
index 0000000000000..9d8cfa87d1c85
--- /dev/null
+++ b/test/checked.jl
@@ -0,0 +1,269 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# Checked integer arithmetic
+
+import Base: checked_abs, checked_neg, checked_add, checked_sub, checked_mul,
+             checked_div, checked_rem, checked_fld, checked_mod, checked_cld
+
+# Test return types
+for T in (Int8,Int16,Int32,Int64,Int128, UInt8,UInt16,UInt32,UInt64,UInt128)
+    z, o = T(0), T(1)
+    @test typeof(checked_neg(z)) === T
+    @test typeof(checked_abs(z)) === T
+    @test typeof(checked_add(z)) === T
+    @test typeof(checked_mul(z)) === T
+    @test typeof(checked_add(z,z)) === T
+    @test typeof(checked_sub(z,z)) === T
+    @test typeof(checked_mul(z,z)) === T
+    @test typeof(checked_div(z,o)) === T
+    @test typeof(checked_rem(z,o)) === T
+    @test typeof(checked_fld(z,o)) === T
+    @test typeof(checked_mod(z,o)) === T
+    @test typeof(checked_cld(z,o)) === T
+end
+
+# checked operations
+
+for T in (Int8, Int16, Int32, Int64, Int128)
+    # regular cases
+    for s in (-1, +1)
+        @test checked_abs(T(0s)) === T(abs(0s))
+        @test checked_neg(T(0s)) === T(-(0s))
+        @test checked_add(T(0s)) === T(0s)
+        @test checked_mul(T(0s)) === T(0s)
+        @test checked_abs(T(3s)) === T(abs(3s))
+        @test checked_neg(T(3s)) === T(-(3s))
+        @test checked_add(T(3s)) === T(3s)
+        @test checked_mul(T(3s)) === T(3s)
+        @test checked_abs(T(s*typemax(T))) === typemax(T)
+        @test checked_neg(T(s*typemax(T))) === T(-s*typemax(T))
+        @test checked_add(T(s*typemax(T))) === T(s*typemax(T))
+        @test checked_mul(T(s*typemax(T))) === T(s*typemax(T))
+    end
+
+    # corner cases
+    @test_throws OverflowError checked_abs(typemin(T))
+    @test_throws OverflowError checked_neg(typemin(T))
+
+    # regular cases
+    for s1 in (-1, +1), s2 in (-1,+1)
+        @test checked_add(T(4s1), T(3s2)) === T(4s1 + 3s2)
+        @test checked_sub(T(4s1), T(3s2)) === T(4s1 - 3s2)
+        @test checked_mul(T(4s1), T(3s2)) === T(4s1 * 3s2)
+        @test checked_div(T(4s1), T(3s2)) === T(div(4s1, 3s2))
+        @test checked_rem(T(4s1), T(3s2)) === T(rem(4s1, 3s2))
+        @test checked_fld(T(4s1), T(3s2)) === T(fld(4s1, 3s2))
+        @test checked_mod(T(4s1), T(3s2)) === T(mod(4s1, 3s2))
+        @test checked_cld(T(4s1), T(3s2)) === T(cld(4s1, 3s2))
+    end
+
+    # corner cases
+    halfmax = T(typemax(T)÷2)
+    halfmax_plus1 = T(halfmax+1)
+    halfmin = T(typemin(T)÷2)
+    halfmin_minus1 = T(halfmin-1)
+    sqrtmax = T(1) << T(sizeof(T)*4)
+    half_sqrtmax = sqrtmax >> T(1)
+    half_sqrtmax_plus1 = half_sqrtmax + T(1)
+
+    @test checked_add(typemax(T), T(-1)) === T(typemax(T) - 1)
+    @test_throws OverflowError checked_add(typemin(T), T(-1))
+    @test checked_add(typemax(T), T(0)) === typemax(T)
+    @test checked_add(typemin(T), T(0)) === typemin(T)
+    @test_throws OverflowError checked_add(typemax(T), T(1))
+    @test checked_add(typemin(T), T(1)) === T(typemin(T) + 1)
+    @test checked_add(T(-1), typemax(T)) === T(typemax(T) - 1)
+    @test_throws OverflowError checked_add(T(-1), typemin(T))
+    @test checked_add(T(0), typemax(T)) === typemax(T)
+    @test checked_add(T(0), typemin(T)) === typemin(T)
+    @test_throws OverflowError checked_add(T(1), typemax(T))
+    @test checked_add(T(1), typemin(T)) === T(typemin(T) + 1)
+    @test checked_add(typemax(T), typemin(T)) === T(-1)
+    @test checked_add(typemin(T), typemax(T)) === T(-1)
+    @test_throws OverflowError checked_add(halfmax_plus1, halfmax_plus1)
+    @test_throws OverflowError checked_add(halfmin, halfmin_minus1)
+
+    @test_throws OverflowError checked_sub(typemax(T), T(-1))
+    @test checked_sub(typemax(T), T(0)) === typemax(T)
+    @test checked_sub(typemax(T), T(1)) === T(typemax(T) - 1)
+    @test checked_sub(typemin(T), T(-1)) === T(typemin(T) + 1)
+    @test checked_sub(typemin(T), T(0)) === typemin(T)
+    @test_throws OverflowError checked_sub(typemin(T), T(1))
+    @test checked_sub(T(0), typemax(T)) === T(typemin(T) + 1)
+    @test checked_sub(T(1), typemax(T)) === T(typemin(T) + 2)
+    @test checked_sub(T(-1), typemin(T)) === typemax(T)
+    @test_throws OverflowError checked_sub(T(0), typemin(T))
+    @test checked_sub(typemax(T), typemax(T)) === T(0)
+    @test checked_sub(typemin(T), typemin(T)) === T(0)
+    @test checked_sub(halfmax, T(-halfmin)) === T(-1)
+    @test_throws OverflowError checked_sub(halfmin, T(-halfmin_minus1))
+
+    @test checked_mul(typemax(T), T(0)) === T(0)
+    @test checked_mul(typemin(T), T(0)) === T(0)
+    @test checked_mul(typemax(T), T(1)) === typemax(T)
+    @test checked_mul(typemin(T), T(1)) === typemin(T)
+    @test_throws OverflowError checked_mul(sqrtmax, half_sqrtmax)
+    @test checked_mul(sqrtmax, -half_sqrtmax) === T(sqrtmax * -half_sqrtmax)
+    @test_throws OverflowError checked_mul(sqrtmax, -half_sqrtmax_plus1)
+    @test checked_mul(-sqrtmax, half_sqrtmax) === T(-sqrtmax * half_sqrtmax)
+    @test_throws OverflowError checked_mul(-sqrtmax, half_sqrtmax_plus1)
+    @test_throws OverflowError checked_mul(-sqrtmax, -half_sqrtmax)
+
+    @test checked_div(typemax(T), T(1)) === typemax(T)
+    @test_throws DivideError checked_div(typemax(T), T(0))
+    @test checked_div(typemax(T), T(-1)) === T(-typemax(T))
+    @test checked_div(typemin(T), T(1)) === typemin(T)
+    @test_throws DivideError checked_div(typemin(T), T(0))
+    @test_throws DivideError checked_div(typemin(T), T(-1))
+    @test checked_rem(typemax(T), T(1)) === T(0)
+    @test_throws DivideError checked_rem(typemax(T), T(0))
+    @test checked_rem(typemax(T), T(-1)) === T(0)
+    @test checked_rem(typemin(T), T(1)) === T(0)
+    @test_throws DivideError checked_rem(typemin(T), T(0))
+    @test checked_rem(typemin(T), T(-1)) === T(0)
+    @test checked_fld(typemax(T), T(1)) === typemax(T)
+    @test_throws DivideError checked_fld(typemax(T), T(0))
+    @test checked_fld(typemax(T), T(-1)) === T(-typemax(T))
+    @test checked_fld(typemin(T), T(1)) === typemin(T)
+    @test_throws DivideError checked_fld(typemin(T), T(0))
+    @test_throws DivideError checked_fld(typemin(T), T(-1))
+    @test checked_mod(typemax(T), T(1)) === T(0)
+    @test_throws DivideError checked_mod(typemax(T), T(0))
+    @test checked_mod(typemax(T), T(-1)) === T(0)
+    @test checked_mod(typemin(T), T(1)) === T(0)
+    @test_throws DivideError checked_mod(typemin(T), T(0))
+    @test checked_mod(typemin(T), T(-1)) === T(0)
+    @test_throws DivideError checked_cld(typemax(T), T(0))
+    @test checked_cld(typemax(T), T(-1)) === T(-typemax(T))
+    @test checked_cld(typemin(T), T(1)) === typemin(T)
+    @test_throws DivideError checked_cld(typemin(T), T(0))
+    @test_throws DivideError checked_cld(typemin(T), T(-1))
+end
+
+for T in (UInt8, UInt16, UInt32, UInt64, UInt128)
+    # regular cases
+    @test checked_abs(T(0)) === T(0)
+    @test checked_neg(T(0)) === T(0)
+    @test checked_abs(T(3)) === T(3)
+    @test_throws OverflowError checked_neg(T(3))
+
+    # regular cases
+    @test checked_add(T(4), T(3)) === T(7)
+    @test checked_sub(T(4), T(3)) === T(1)
+    @test checked_mul(T(4), T(3)) === T(12)
+
+    # corner cases
+    halfmax = T(typemax(T)÷2)
+    halfmax_plus1 = T(halfmax+1)
+    sqrtmax = T(1) << T(sizeof(T)*4)
+
+    @test checked_add(typemax(T), T(0)) === typemax(T)
+    @test checked_add(T(0), T(0)) === T(0)
+    @test_throws OverflowError checked_add(typemax(T), T(1))
+    @test checked_add(T(0), T(1)) === T(T(0) + 1)
+    @test checked_add(T(0), typemax(T)) === typemax(T)
+    @test checked_add(T(0), T(0)) === T(0)
+    @test_throws OverflowError checked_add(T(1), typemax(T))
+    @test checked_add(T(1), T(0)) === T(T(0) + 1)
+    @test checked_add(typemax(T), T(0)) === typemax(T)
+    @test checked_add(T(0), typemax(T)) === typemax(T)
+    @test_throws OverflowError checked_add(halfmax_plus1, halfmax_plus1)
+
+    @test checked_sub(typemax(T), T(0)) === typemax(T)
+    @test checked_sub(typemax(T), T(1)) === T(typemax(T) - 1)
+    @test checked_sub(T(0), T(0)) === T(0)
+    @test_throws OverflowError checked_sub(T(0), T(1))
+    @test_throws OverflowError checked_sub(T(0), typemax(T))
+    @test_throws OverflowError checked_sub(T(1), typemax(T))
+    @test checked_sub(T(0), T(0)) === T(0)
+    @test checked_sub(typemax(T), typemax(T)) === T(0)
+
+    @test checked_mul(typemax(T), T(0)) === T(0)
+    @test checked_mul(T(0), T(0)) === T(0)
+    @test checked_mul(typemax(T), T(1)) === typemax(T)
+    @test checked_mul(T(0), T(1)) === T(0)
+    @test_throws OverflowError checked_mul(sqrtmax, sqrtmax)
+
+    @test checked_div(typemax(T), T(1)) === typemax(T)
+    @test_throws DivideError checked_div(typemax(T), T(0))
+    @test checked_rem(typemax(T), T(1)) === T(0)
+    @test_throws DivideError checked_rem(typemax(T), T(0))
+    @test checked_fld(typemax(T), T(1)) === typemax(T)
+    @test_throws DivideError checked_fld(typemax(T), T(0))
+    @test checked_mod(typemax(T), T(1)) === T(0)
+    @test_throws DivideError checked_mod(typemax(T), T(0))
+    @test checked_cld(typemax(T), T(1)) === typemax(T)
+    @test_throws DivideError checked_cld(typemax(T), T(0))
+end
+
+# Boolean
+@test checked_add(false) === 0
+@test checked_add(true) === 1
+@test checked_sub(false) === 0
+@test checked_sub(true) === -1
+@test checked_neg(false) === 0
+@test checked_neg(true) === -1
+@test checked_abs(true) === true
+@test checked_abs(false) === false
+@test checked_mul(false) === false
+@test checked_mul(true) === true
+
+@test checked_add(true, true) === 2
+@test checked_add(true, false) === 1
+@test checked_add(false, false) === 0
+@test checked_add(false, true) === 1
+
+@test checked_sub(true, true) === 0
+@test checked_sub(true, false) === 1
+@test checked_sub(false, false) === 0
+@test checked_sub(false, true) === -1
+
+@test checked_mul(true, false) === false
+@test checked_mul(false, false) === false
+@test checked_mul(true, true) === true
+@test checked_mul(false, true) === false
+
+@test checked_div(true, true) === true
+@test checked_div(false, true) === false
+@test_throws DivideError checked_div(true, false)
+@test checked_rem(true, true) === false
+@test checked_rem(false, true) === false
+@test_throws DivideError checked_rem(true, false)
+@test checked_fld(true, true) === true
+@test checked_fld(false, true) === false
+@test_throws DivideError checked_fld(true, false)
+@test checked_mod(true, true) === false
+@test checked_mod(false, true) === false
+@test_throws DivideError checked_mod(true, false)
+@test checked_cld(true, true) === true
+@test checked_cld(false, true) === false
+@test_throws DivideError checked_cld(true, false)
+
+# BigInt
+@test checked_abs(BigInt(-1)) == BigInt(1)
+@test checked_abs(BigInt(1)) == BigInt(1)
+@test checked_neg(BigInt(-1)) == BigInt(1)
+@test checked_neg(BigInt(1)) == BigInt(-1)
+
+# Additional tests
+
+@test checked_sub(UInt(4), UInt(3)) === UInt(1)
+@test_throws OverflowError checked_sub(UInt(5), UInt(6))
+@test checked_mul(UInt(4), UInt(3)) === UInt(12)
+
+@test checked_sub(Int128(-1),Int128(-2)) === Int128(1)
+
+if WORD_SIZE == 32
+    @test_throws OverflowError checked_mul(UInt(2)^30, UInt(2)^2)
+else
+    @test_throws OverflowError checked_mul(UInt(2)^62, UInt(2)^2)
+end
+
+@test checked_add(UInt128(1), UInt128(2)) === UInt128(3)
+@test_throws OverflowError checked_add(UInt128(2)^127, UInt128(2)^127)
+
+@test checked_sub(UInt128(2), UInt128(1)) === UInt128(1)
+@test_throws OverflowError checked_sub(UInt128(3), UInt128(4))
+
+@test checked_mul(UInt128(3), UInt128(4)) === UInt128(12)
+@test_throws OverflowError checked_mul(UInt128(2)^127, UInt128(2))
diff --git a/test/choosetests.jl b/test/choosetests.jl
index 2a2eecfcbe248..1e8f35743beda 100644
--- a/test/choosetests.jl
+++ b/test/choosetests.jl
@@ -23,16 +23,17 @@ function choosetests(choices = [])
         "bitarray", "copy", "math", "fastmath", "functional",
         "operators", "path", "ccall", "parse", "loading",
         "bigint", "sorting", "statistics", "spawn", "backtrace",
-        "priorityqueue", "file", "mmap", "version", "resolve",
+        "priorityqueue", "file", "read", "mmap", "version", "resolve",
         "pollfd", "mpfr", "broadcast", "complex", "socket",
-        "floatapprox", "readdlm", "reflection", "regex", "float16",
+        "floatapprox", "datafmt", "reflection", "regex", "float16",
         "combinatorics", "sysinfo", "rounding", "ranges", "mod2pi",
         "euler", "show", "lineedit", "replcompletions", "repl",
         "replutil", "sets", "test", "goto", "llvmcall", "grisu",
-        "nullable", "meta", "profile", "libgit2", "docs", "markdown",
-        "base64", "serialize", "functors", "misc",
+        "nullable", "meta", "stacktraces", "profile", "libgit2", "docs",
+        "markdown", "base64", "serialize", "functors", "misc", "threads",
         "enums", "cmdlineargs", "i18n", "workspace", "libdl", "int",
-        "intset", "floatfuncs", "compile"
+        "checked", "intset", "floatfuncs", "compile", "parallel", "inline",
+        "boundscheck"
     ]
 
     if Base.USE_GPL_LIBS
@@ -43,9 +44,6 @@ function choosetests(choices = [])
         push!(testnames, "examples")
     end
 
-    # parallel tests depend on other workers - do them last
-    push!(testnames, "parallel")
-
     tests = []
     skip_tests = []
 
@@ -68,7 +66,7 @@ function choosetests(choices = [])
                    "linalg/lapack", "linalg/tridiag", "linalg/bidiag",
                    "linalg/diagonal", "linalg/pinv", "linalg/givens",
                    "linalg/cholesky", "linalg/lu", "linalg/symmetric",
-                   "linalg/generic", "linalg/uniformscaling"]
+                   "linalg/generic", "linalg/uniformscaling", "linalg/lq"]
     if Base.USE_GPL_LIBS
         push!(linalgtests, "linalg/arnoldi")
     end
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index ab1736524519c..c70639dea4077 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -1,16 +1,16 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-let exename = `$(joinpath(JULIA_HOME, Base.julia_exename())) --precompiled=yes`
+let exename = `$(Base.julia_cmd()) --precompiled=yes`
     # --version
-    let v = split(readall(`$exename -v`), "julia version ")[end]
+    let v = split(readstring(`$exename -v`), "julia version ")[end]
         @test Base.VERSION_STRING == chomp(v)
     end
-    @test readall(`$exename -v`) == readall(`$exename --version`)
+    @test readstring(`$exename -v`) == readstring(`$exename --version`)
 
     # --help
     let header = "julia [switches] -- [programfile] [args...]"
-        @test startswith(readall(`$exename -h`), header)
-        @test startswith(readall(`$exename --help`), header)
+        @test startswith(readstring(`$exename -h`), header)
+        @test startswith(readstring(`$exename --help`), header)
     end
 
     # --quiet
@@ -29,8 +29,8 @@ let exename = `$(joinpath(JULIA_HOME, Base.julia_exename())) --precompiled=yes`
     @test !success(`$exename --eval`)
 
     # --print
-    @test readall(`$exename -E "1+1"`) == "2\n"
-    @test readall(`$exename --print="1+1"`) == "2\n"
+    @test readstring(`$exename -E "1+1"`) == "2\n"
+    @test readstring(`$exename --print="1+1"`) == "2\n"
     @test !success(`$exename -E`)
     @test !success(`$exename --print`)
 
@@ -45,9 +45,7 @@ let exename = `$(joinpath(JULIA_HOME, Base.julia_exename())) --precompiled=yes`
     # --load
     let testfile = tempname()
         try
-            open(testfile, "w") do io
-                println(io, "testvar = :test")
-            end
+            write(testfile, "testvar = :test\n")
             @test split(readchomp(`$exename --load=$testfile -P "println(testvar)"`), '\n')[end] == "test"
             @test split(readchomp(`$exename -P "println(testvar)" -L $testfile`), '\n')[end] == "test"
         finally
@@ -124,9 +122,10 @@ let exename = `$(joinpath(JULIA_HOME, Base.julia_exename())) --precompiled=yes`
     @test readchomp(`$exename -E "Bool(Base.JLOptions().malloc_log)" --track-allocation=user`) == "true"
 
     # --optimize
-    @test readchomp(`$exename -E "Bool(Base.JLOptions().opt_level)"`) == "false"
-    @test readchomp(`$exename -E "Bool(Base.JLOptions().opt_level)" -O`) == "true"
-    @test readchomp(`$exename -E "Bool(Base.JLOptions().opt_level)" --optimize`) == "true"
+    @test readchomp(`$exename -E "Base.JLOptions().opt_level"`) == "2"
+    @test readchomp(`$exename -E "Base.JLOptions().opt_level" -O`) == "3"
+    @test readchomp(`$exename -E "Base.JLOptions().opt_level" --optimize`) == "3"
+    @test readchomp(`$exename -E "Base.JLOptions().opt_level" -O0`) == "0"
 
     # --check-bounds
     let JL_OPTIONS_CHECK_BOUNDS_DEFAULT = 0,
@@ -152,6 +151,40 @@ let exename = `$(joinpath(JULIA_HOME, Base.julia_exename())) --precompiled=yes`
         foo()
     " --depwarn=error`)
 
+    # test deprecated bindings, #13269
+    let code = """
+        module Foo
+            import Base: @deprecate_binding
+
+            const NotDeprecated = true
+            @deprecate_binding Deprecated NotDeprecated
+        end
+
+        Foo.Deprecated
+        """
+
+        @test !success(`$exename -E "$code" --depwarn=error`)
+
+        # FIXME these should also be run on windows once the bug causing them to hang gets fixed
+        @unix_only let out  = Pipe(),
+                       proc = spawn(pipeline(`$exename -E "$code" --depwarn=yes`, stderr=out))
+
+            wait(proc)
+            close(out.in)
+            @test success(proc)
+            @test readchomp(out) == "WARNING: Foo.Deprecated is deprecated.\n  likely near no file:5"
+        end
+
+        @unix_only let out  = Pipe(),
+                       proc = spawn(pipeline(`$exename -E "$code" --depwarn=no`, stderr=out))
+
+            wait(proc)
+            close(out.in)
+            @test success(proc)
+            @test isempty(readstring(out))
+        end
+    end
+
     # --inline
     @test readchomp(`$exename -E "Bool(Base.JLOptions().can_inline)"`) == "true"
     @test readchomp(`$exename --inline=yes -E "Bool(Base.JLOptions().can_inline)"`) == "true"
@@ -172,25 +205,73 @@ let exename = `$(joinpath(JULIA_HOME, Base.julia_exename())) --precompiled=yes`
     # --worker takes default / custom as arugment (default/custom arguments tested in test/parallel.jl, test/examples.jl)
     @test !success(`$exename --worker=true`)
 
+    escape(str) = replace(str, "\\", "\\\\")
+
     # test passing arguments
     let testfile = tempname()
         try
-            # write a julia source file that just prints ARGS to STDOUT and exits
-            open(testfile, "w") do io
-                println(io, "println(ARGS)")
-                println(io, "exit(0)")
-            end
-            @test readchomp(`$exename $testfile foo -bar --baz`) ==  "UTF8String[\"foo\",\"-bar\",\"--baz\"]"
-            @test readchomp(`$exename $testfile -- foo -bar --baz`) ==  "UTF8String[\"foo\",\"-bar\",\"--baz\"]"
-            @test readchomp(`$exename -L $testfile -- foo -bar --baz`) ==  "UTF8String[\"foo\",\"-bar\",\"--baz\"]"
+            # write a julia source file that just prints ARGS to STDOUT
+            write(testfile, """
+                println(ARGS)
+            """)
+            @test readchomp(`$exename $testfile foo -bar --baz`) == "UTF8String[\"foo\",\"-bar\",\"--baz\"]"
+            @test readchomp(`$exename $testfile -- foo -bar --baz`) == "UTF8String[\"foo\",\"-bar\",\"--baz\"]"
+            @test readchomp(`$exename -L $testfile -e 'exit(0)' -- foo -bar --baz`) == "UTF8String[\"foo\",\"-bar\",\"--baz\"]"
+            @test split(readchomp(`$exename -L $testfile $testfile`), '\n') == ["UTF8String[\"$(escape(testfile))\"]", "UTF8String[]"]
             @test !success(`$exename --foo $testfile`)
-            @test !success(`$exename -L $testfile -- foo -bar -- baz`)
+            @test !success(`$exename -L $testfile -e 'exit(0)' -- foo -bar -- baz`)
         finally
             rm(testfile)
         end
     end
 
+    # test the script name
+    let a = tempname(), b = tempname()
+        try
+            write(a, """
+                println(@__FILE__)
+                println(PROGRAM_FILE)
+                println(length(ARGS))
+                include(\"$(escape(b))\")
+            """)
+            write(b, """
+                println(@__FILE__)
+                println(PROGRAM_FILE)
+                println(length(ARGS))
+            """)
+            @test split(readchomp(`$exename $a`), '\n') == ["$a", "$a", "0", "$b", "$a", "0"]
+            @test split(readchomp(`$exename -L $b -e 'exit(0)'`), '\n') == ["$(realpath(b))", "", "0"]
+            @test split(readchomp(`$exename -L $b $a`), '\n') == ["$(realpath(b))", "", "1", "$a", "$a", "0", "$b", "$a", "0"]
+        finally
+            rm(a)
+            rm(b)
+        end
+    end
+
     # issue #10562
     @test readchomp(`$exename -e 'println(ARGS);' ''`) == "UTF8String[\"\"]"
 
+    # issue #12679
+    extrapath = @windows? joinpath(JULIA_HOME,"..","Git","usr","bin")*";" : ""
+    withenv("PATH" => extrapath * ENV["PATH"]) do
+        @test readchomp(pipeline(ignorestatus(`$exename -f --compile=yes -foo`),stderr=`cat`)) == "ERROR: unknown option `-o`"
+        @test readchomp(pipeline(ignorestatus(`$exename -f -p`),stderr=`cat`)) == "ERROR: option `-p/--procs` is missing an argument"
+        @test readchomp(pipeline(ignorestatus(`$exename -f --inline`),stderr=`cat`)) == "ERROR: option `--inline` is missing an argument"
+        @test readchomp(pipeline(ignorestatus(`$exename -f -e "@show ARGS" -now -- julia RUN.jl`),stderr=`cat`)) == "ERROR: unknown option `-n`"
+    end
+
+    # --compilecache={yes|no}
+    @test readchomp(`$exename -E "Bool(Base.JLOptions().use_compilecache)"`) == "true"
+    @test readchomp(`$exename --compilecache=yes -E "Bool(Base.JLOptions().use_compilecache)"`) == "true"
+    @test readchomp(`$exename --compilecache=no -E "Bool(Base.JLOptions().use_compilecache)"`) == "false"
+    @test !success(`$exename --compilecache=foo -e "exit(0)"`)
+
+    # issue #12671, starting from a non-directory
+    @unix_only if VersionNumber(Base.libllvm_version) > v"3.3"
+        testdir = mktempdir()
+        cd(testdir) do
+            rm(testdir)
+            @test success(`$exename -e "exit(0)"`)
+        end
+    end
 end
diff --git a/test/combinatorics.jl b/test/combinatorics.jl
index 4989e9645663f..d54903402cf6a 100644
--- a/test/combinatorics.jl
+++ b/test/combinatorics.jl
@@ -29,42 +29,6 @@ let a = 2:-1:1
     @test ipermute!(permute!([1, 2], a), a) == [1, 2]
 end
 
-@test collect(combinations("abc",3)) == Any[['a','b','c']]
-@test collect(combinations("abc",2)) == Any[['a','b'],['a','c'],['b','c']]
-@test collect(combinations("abc",1)) == Any[['a'],['b'],['c']]
-@test collect(combinations("abc",0)) == Any[Char[]]
-@test collect(combinations("abc",-1)) == Any[]
-@test collect(permutations("abc")) == Any[['a','b','c'],['a','c','b'],['b','a','c'],
-                                          ['b','c','a'],['c','a','b'],['c','b','a']]
-
-@test collect(filter(x->(iseven(x[1])),permutations([1,2,3]))) == Any[[2,1,3],[2,3,1]]
-@test collect(filter(x->(iseven(x[3])),permutations([1,2,3]))) == Any[[1,3,2],[3,1,2]]
-@test collect(filter(x->(iseven(x[1])),combinations([1,2,3],2))) == Any[[2,3]]
-
-@test collect(partitions(4)) ==  Any[[4], [3,1], [2,2], [2,1,1], [1,1,1,1]]
-@test collect(partitions(8,3)) == Any[[6,1,1], [5,2,1], [4,3,1], [4,2,2], [3,3,2]]
-@test collect(partitions(8, 1)) == Any[[8]]
-@test collect(partitions(8, 9)) == []
-@test collect(partitions([1,2,3])) == Any[Any[[1,2,3]], Any[[1,2],[3]], Any[[1,3],[2]], Any[[1],[2,3]], Any[[1],[2],[3]]]
-@test collect(partitions([1,2,3,4],3)) == Any[Any[[1,2],[3],[4]], Any[[1,3],[2],[4]], Any[[1],[2,3],[4]],
-                                              Any[[1,4],[2],[3]], Any[[1],[2,4],[3]], Any[[1],[2],[3,4]]]
-@test collect(partitions([1,2,3,4],1)) == Any[Any[[1, 2, 3, 4]]]
-@test collect(partitions([1,2,3,4],5)) == []
-
-@test length(permutations(0)) == 1
-@test length(partitions(0)) == 1
-@test length(partitions(-1)) == 0
-@test length(collect(partitions(30))) == length(partitions(30))
-@test length(collect(partitions(90,4))) == length(partitions(90,4))
-@test length(collect(partitions('a':'h'))) == length(partitions('a':'h'))
-@test length(collect(partitions('a':'h',5))) == length(partitions('a':'h',5))
-
-for n = 0:7, k = 1:factorial(n)
-    p = nthperm!([1:n;], k)
-    @test isperm(p)
-    @test nthperm(p) == k
-end
-
 @test factorial(7) == 5040
 @test factorial(Int8(7)) == 5040
 @test factorial(UInt8(7)) == 5040
@@ -76,16 +40,8 @@ end
 @test factorial(UInt64(7)) == 5040
 @test factorial(Int128(7)) == 5040
 @test factorial(UInt128(7)) == 5040
-@test factorial(7,3) == 7*6*5*4
-@test_throws DomainError factorial(3,7)
-@test_throws DomainError factorial(-3,-7)
-@test_throws DomainError factorial(-7,-3)
 @test factorial(0) == 1
 @test_throws DomainError factorial(-1)
-#Issue 9943
-@test factorial(big(100), (80)) == 1303995018204712451095685346159820800000
-#Issue 9950
-@test_throws OverflowError factorial(1000,80)
 @test factorial(Int64(20)) == 2432902008176640000
 # issue #6579
 @test_throws OverflowError factorial(Int64(21))
@@ -94,14 +50,3 @@ if Int === Int32
     @test factorial(Int32(12)) === Int32(479001600)
     @test_throws OverflowError factorial(Int32(13))
 end
-
-@test_throws ArgumentError parity([0])
-@test_throws ArgumentError parity([1,2,3,3])
-@test levicivita([1,1,2,3]) == 0
-@test levicivita([1]) == 1 && parity([1]) == 0
-@test map(levicivita, collect(permutations([1,2,3]))) == [1, -1, -1, 1, 1, -1]
-@test let p = [3, 4, 6, 10, 5, 2, 1, 7, 8, 9]; levicivita(p) == 1 && parity(p) == 0; end
-@test let p = [4, 3, 6, 10, 5, 2, 1, 7, 8, 9]; levicivita(p) == -1 && parity(p) == 1; end
-
-@test Base.nsetpartitions(-1) == 0
-@test collect(permutations([])) == Vector[[]]
diff --git a/test/compile.jl b/test/compile.jl
index 49b6c5cfdc57b..acff0038437a8 100644
--- a/test/compile.jl
+++ b/test/compile.jl
@@ -3,26 +3,26 @@
 using Base.Test
 
 dir = mktempdir()
+dir2 = mktempdir()
 insert!(LOAD_PATH, 1, dir)
 insert!(Base.LOAD_CACHE_PATH, 1, dir)
 Foo_module = :Foo4b3a94a1a081a8cb
 try
     Foo_file = joinpath(dir, "$Foo_module.jl")
 
-    open(Foo_file, "w") do f
-        print(f, """
-              __precompile__(true)
-              module $Foo_module
-              @doc "foo function" foo(x) = x + 1
-              include_dependency("foo.jl")
-              include_dependency("foo.jl")
-              module Bar
-              @doc "bar function" bar(x) = x + 2
-              include_dependency("bar.jl")
-              end
-              end
-              """)
-    end
+    write(Foo_file,
+          """
+          __precompile__(true)
+          module $Foo_module
+          @doc "foo function" foo(x) = x + 1
+          include_dependency("foo.jl")
+          include_dependency("foo.jl")
+          module Bar
+          @doc "bar function" bar(x) = x + 2
+          include_dependency("bar.jl")
+          end
+          end
+          """)
 
     # Issue #12623
     @test __precompile__(true) === nothing
@@ -50,39 +50,108 @@ try
     end
 
     Baz_file = joinpath(dir, "Baz.jl")
-    open(Baz_file, "w") do f
-        print(f, """
-              __precompile__(false)
-              module Baz
-              end
-              """)
-    end
+    write(Baz_file,
+          """
+          __precompile__(false)
+          module Baz
+          end
+          """)
+
     println(STDERR, "\nNOTE: The following 'LoadError: __precompile__(false)' indicates normal operation")
     @test_throws ErrorException Base.compilecache("Baz") # from __precompile__(false)
 
     # Issue #12720
     FooBar_file = joinpath(dir, "FooBar.jl")
-    open(FooBar_file, "w") do f
-        print(f, """
-              __precompile__(true)
-              module FooBar
-              end
-              """)
-    end
+    write(FooBar_file,
+          """
+          __precompile__(true)
+          module FooBar
+          end
+          """)
+
     Base.compilecache("FooBar")
     sleep(2)
-    open(FooBar_file, "w") do f
-        print(f, """
-              __precompile__(true)
-              module FooBar
-              error("break me")
-              end
-              """)
-    end
+    @test isfile(joinpath(dir, "FooBar.ji"))
+
+    touch(FooBar_file)
+    insert!(Base.LOAD_CACHE_PATH, 1, dir2)
+    Base.recompile_stale(:FooBar, joinpath(dir, "FooBar.ji"))
+    sleep(2)
+    @test isfile(joinpath(dir2, "FooBar.ji"))
+    @test Base.stale_cachefile(FooBar_file, joinpath(dir, "FooBar.ji"))
+    @test !Base.stale_cachefile(FooBar_file, joinpath(dir2, "FooBar.ji"))
+
+    write(FooBar_file,
+          """
+          __precompile__(true)
+          module FooBar
+          error("break me")
+          end
+          """)
+
     println(STDERR, "\nNOTE: The following 'LoadError: break me' indicates normal operation")
     @test_throws ErrorException Base.require(:FooBar)
+
 finally
-    splice!(Base.LOAD_CACHE_PATH, 1)
+    splice!(Base.LOAD_CACHE_PATH, 1:2)
     splice!(LOAD_PATH, 1)
     rm(dir, recursive=true)
+    rm(dir2, recursive=true)
+end
+
+# test --compilecache=no command line option
+dir = mktempdir()
+let dir = mktempdir(),
+    Time_module = :Time4b3a94a1a081a8cb
+
+    try
+        write(joinpath(dir, "$Time_module.jl"),
+              """
+              module $Time_module
+                  __precompile__(true)
+                  time = Base.time()
+              end
+              """)
+
+        eval(quote
+            insert!(LOAD_PATH, 1, $(dir))
+            insert!(Base.LOAD_CACHE_PATH, 1, $(dir))
+            Base.compilecache(:Time4b3a94a1a081a8cb)
+        end)
+
+        exename = `$(Base.julia_cmd()) --precompiled=yes`
+
+        testcode = """
+            insert!(LOAD_PATH, 1, $(repr(dir)))
+            insert!(Base.LOAD_CACHE_PATH, 1, $(repr(dir)))
+            using $Time_module
+            getfield($Time_module, :time)
+        """
+
+        t1_yes = readchomp(`$exename --compilecache=yes -E $(testcode)`)
+        t2_yes = readchomp(`$exename --compilecache=yes -E $(testcode)`)
+        @test t1_yes == t2_yes
+
+        t1_no = readchomp(`$exename --compilecache=no -E $(testcode)`)
+        t2_no = readchomp(`$exename --compilecache=no -E $(testcode)`)
+        @test t1_no != t2_no
+        @test parse(Float64, t1_no) < parse(Float64, t2_no)
+
+    finally
+        splice!(Base.LOAD_CACHE_PATH, 1)
+        splice!(LOAD_PATH, 1)
+        rm(dir, recursive=true)
+    end
+end
+
+let module_name = string("a",randstring())
+    insert!(LOAD_PATH, 1, pwd())
+    file_name = string(module_name, ".jl")
+    touch(file_name)
+    code = """module $(module_name)\nend\n"""
+    write(file_name, code)
+    reload(module_name)
+    @test typeof(eval(symbol(module_name))) == Module
+    deleteat!(LOAD_PATH,1)
+    rm(file_name)
 end
diff --git a/test/complex.jl b/test/complex.jl
index fe3c1188001cb..39ea11b52c107 100644
--- a/test/complex.jl
+++ b/test/complex.jl
@@ -2,6 +2,17 @@
 
 @test reim(2 + 3im) == (2, 3)
 
+for T in (Int64, Float64)
+    @test real(T) == T
+    @test real(Complex{T}) == T
+    @test complex(T) == Complex{T}
+    @test complex(Complex{T}) == Complex{T}
+end
+
+#showcompact
+@test sprint(io -> showcompact(io,complex(1,0))) == "1+0im"
+@test sprint(io -> show(io,complex(true,true))) == "Complex(true,true)"
+
 # Basic arithmetic
 for T in (Float16, Float32, Float64, BigFloat)
     t = true
@@ -54,6 +65,9 @@ for T in (Float32, Float64)
     # Test random values
     @test_approx_eq x^y big(x)^big(y)
     @test_approx_eq x^yi big(x)^yi
+    @test_approx_eq x^true big(x)^true
+    @test_approx_eq x^false big(x)^false
+    @test_approx_eq x^1 big(x)^1
     @test_approx_eq abs(x) abs(big(x))
     @test_approx_eq abs2(x) abs2(big(x))
     @test_approx_eq acos(x) acos(big(x))
@@ -112,6 +126,26 @@ for T in (Float32, Float64)
     @test_approx_eq tanh(x) sinh(x)/cosh(x)
 end
 
+#isimag and isinf
+@test isimag(complex(0.0,1.0))
+@test !isimag(complex(1.0,1.0))
+@test isinf(complex(Inf,0))
+@test isinf(complex(-Inf,0))
+@test isinf(complex(0,Inf))
+@test isinf(complex(0,-Inf))
+@test !isinf(complex(0,0))
+
+# flipsign:
+@test isequal(complex( 0.0, 0.0 ), flipsign(complex( 0.0, 0.0 ), 1))
+@test isequal(complex( -0.0, -0.0 ), flipsign(complex( 0.0, 0.0 ), -1))
+@test isequal(complex( Inf, 0.0 ), flipsign(complex( Inf, 0.0 ), 1))
+@test isequal(complex( -Inf, -0.0 ), flipsign(complex( Inf, 0.0 ), -1))
+@test isequal(complex( 0.0, NaN ), flipsign(complex( 0.0, NaN ), 1.0))
+@test isequal(complex( -0.0, NaN ), flipsign(complex( 0.0, NaN ), -1.0))
+
+@test isequal(complex( 5.0, 4.0 ), flipsign(complex(-5.0, -4.0), -1))
+@test isequal(complex( 0.5, -0.5 ), flipsign(complex(-0.5, 0.5), -2))
+
 # sqrt:
 # tests special values from csqrt man page
 # as well as conj(sqrt(z)) = sqrt(conj(z))
@@ -321,40 +355,6 @@ end
 #  sinh(conj(z)) = conj(sinh(z))
 #  sinh(-z) = -sinh(z)
 
-@test isequal(sinh(complex( 0.0, 0.0)), complex( 0.0, 0.0))
-@test isequal(sinh(complex( 0.0,-0.0)), complex( 0.0,-0.0))
-@test isequal(sinh(complex( 0.0, Inf)), complex( 0.0, NaN))
-@test isequal(sinh(complex( 0.0,-Inf)), complex( 0.0, NaN))
-@test isequal(sinh(complex( 0.0, NaN)), complex( 0.0, NaN))
-
-@test isequal(sinh(complex(-0.0, 0.0)), complex(-0.0, 0.0))
-@test isequal(sinh(complex(-0.0,-0.0)), complex(-0.0,-0.0))
-@test isequal(sinh(complex(-0.0, Inf)), complex(-0.0, NaN))
-@test isequal(sinh(complex(-0.0,-Inf)), complex(-0.0, NaN))
-@test isequal(sinh(complex(-0.0, NaN)), complex(-0.0, NaN))
-
-@test isequal(sinh(complex( 5.0, Inf)), complex( NaN, NaN))
-@test isequal(sinh(complex( 5.0, NaN)), complex( NaN, NaN))
-
-@test isequal(sinh(complex( Inf, 0.0)), complex( Inf, 0.0))
-@test isequal(sinh(complex( Inf,-0.0)), complex( Inf,-0.0))
-@test isequal(sinh(complex( Inf, 5.0)), complex(cos(5.0)*Inf,sin(5.0)*Inf))
-@test isequal(sinh(complex( Inf, Inf)), complex( Inf, NaN))
-@test isequal(sinh(complex( Inf,-Inf)), complex( Inf, NaN))
-@test isequal(sinh(complex( Inf, NaN)), complex( Inf, NaN))
-
-@test isequal(sinh(complex(-Inf, 0.0)), complex(-Inf, 0.0))
-@test isequal(sinh(complex(-Inf,-0.0)), complex(-Inf,-0.0))
-@test isequal(sinh(complex(-Inf, 5.0)), complex(cos(5.0)*-Inf,sin(5.0)*Inf))
-@test isequal(sinh(complex(-Inf, Inf)), complex(-Inf, NaN))
-@test isequal(sinh(complex(-Inf,-Inf)), complex(-Inf, NaN))
-@test isequal(sinh(complex(-Inf, NaN)), complex(-Inf, NaN))
-
-@test isequal(sinh(complex( NaN, 0.0)), complex( NaN, 0.0))
-@test isequal(sinh(complex( NaN,-0.0)), complex( NaN,-0.0))
-@test isequal(sinh(complex( NaN, 5.0)), complex( NaN, NaN))
-@test isequal(sinh(complex( NaN, NaN)), complex( NaN, NaN))
-
 # sin: defined in terms of sinh
 #  sin(z) = -i*sinh(i*z)
 #  i.e. if sinh(a+ib) = x+iy
@@ -362,80 +362,49 @@ end
 #  sin(conj(z)) = conj(sin(z))
 #  sin(-z) = -sin(z)
 
-@test isequal(sin(complex( 0.0,-0.0)),complex( 0.0,-0.0))
-@test isequal(sin(complex( 0.0, 0.0)),complex( 0.0, 0.0))
-@test isequal(sin(complex( 0.0, Inf)),complex( 0.0, Inf))
-@test isequal(sin(complex( 0.0,-Inf)),complex( 0.0,-Inf))
-@test isequal(sin(complex( 0.0, NaN)),complex( 0.0, NaN))
-
-@test isequal(sin(complex(-0.0, 0.0)),complex(-0.0, 0.0))
-@test isequal(sin(complex(-0.0,-0.0)),complex(-0.0,-0.0))
-@test isequal(sin(complex(-0.0, Inf)),complex(-0.0, Inf))
-@test isequal(sin(complex(-0.0,-Inf)),complex(-0.0,-Inf))
-@test isequal(sin(complex(-0.0, NaN)),complex(-0.0, NaN))
-
-@test isequal(sin(complex( 5.0, Inf)),complex(sin(5.0)*Inf,cos(5.0)* Inf))
-@test isequal(sin(complex( 5.0,-Inf)),complex(sin(5.0)*Inf,cos(5.0)*-Inf))
-@test isequal(sin(complex( 5.0, NaN)),complex( NaN, NaN))
-
-@test isequal(sin(complex( Inf, 0.0)), complex( NaN, 0.0))
-@test isequal(sin(complex( Inf,-0.0)), complex( NaN,-0.0))
-@test isequal(sin(complex( Inf, 5.0)), complex( NaN, NaN))
-@test isequal(sin(complex( Inf, Inf)), complex( Inf, NaN))
-@test isequal(sin(complex( Inf,-Inf)), complex( Inf, NaN))
-
-@test isequal(sin(complex(-Inf, 0.0)), complex( NaN, 0.0))
-@test isequal(sin(complex(-Inf,-0.0)), complex( NaN,-0.0))
-@test isequal(sin(complex(-Inf, 5.0)), complex( NaN, NaN))
-@test isequal(sin(complex(-Inf, Inf)), complex(-Inf, NaN))
-@test isequal(sin(complex(-Inf,-Inf)), complex(-Inf, NaN))
-
-@test isequal(sin(complex( NaN, 0.0)),complex( NaN, 0.0))
-@test isequal(sin(complex( NaN,-0.0)),complex( NaN,-0.0))
-@test isequal(sin(complex( NaN, 5.0)),complex( NaN, NaN))
-@test isequal(sin(complex( NaN, Inf)),complex( NaN, Inf))
-@test isequal(sin(complex( NaN,-Inf)),complex( NaN,-Inf))
-@test isequal(sin(complex( NaN, NaN)),complex( NaN, NaN))
+# @test isequal(sin(complex( 0, 10000)),complex( 0.0, Inf))
+# @test isequal(sin(complex( 0,-10000)),complex( 0.0,-Inf))
+
+for (x,y) in [(complex( 0.0, 0.0), complex( 0.0, 0.0)),
+              (complex( 0.0, Inf), complex( 0.0, NaN)),
+              (complex( 0.0, NaN), complex( 0.0, NaN)),
+              (complex( 7.2, Inf), complex( NaN, NaN)),
+              (complex( 7.2, NaN), complex( NaN, NaN)),
+              (complex( 7.2, 0.0), complex( sinh(7.2), 0.0)),
+              (complex( 1e5, 0.0), complex( sinh(1e5), 0.0)),
+              (complex( Inf, 0.0), complex( Inf, 0.0)),
+              (complex( Inf, 7.2), Inf*cis(7.2)),
+              (complex( Inf, Inf), complex( Inf, NaN)),
+              (complex( Inf, NaN), complex( Inf, NaN)),
+              (complex( NaN, 0.0), complex( NaN, 0.0)),
+              (complex( NaN, 7.2), complex( NaN, NaN)),
+              (complex( NaN, NaN), complex( NaN, NaN)),
+              ]
+
+    @test isequal(sinh(x), y)
+    @test isequal(sinh(conj(x)), conj(y))
+    @test isequal(sinh(-x), -y)
+    @test isequal(sinh(-conj(x)), -conj(y))
+
+    xx = complex(imag(x),-real(x))
+    yy = complex(imag(y),-real(y))
+
+    @test isequal(sin(xx),yy)
+    @test isequal(sin(conj(xx)), conj(yy))
+    @test isequal(sin(-xx), -yy)
+    @test isequal(sin(-conj(xx)), -conj(yy))
+
+    yyy = sin(pi*xx)
+    @test isequal(sinpi(xx), yyy)
+    @test isequal(sinpi(conj(xx)),conj(yyy))
+    @test isequal(sinpi(-xx),-yyy)
+    @test isequal(sinpi(-conj(xx)),-conj(yyy))
+end
 
 # cosh: has properties
 #  cosh(conj(z)) = conj(cosh(z))
 #  coshh(-z) = cosh(z)
 
-@test isequal(cosh(complex( 0.0, 0.0)), complex( 1.0, 0.0))
-@test isequal(cosh(complex( 0.0,-0.0)), complex( 1.0,-0.0))
-@test isequal(cosh(complex( 0.0, Inf)), complex( NaN, 0.0))
-@test isequal(cosh(complex( 0.0,-Inf)), complex( NaN,-0.0))
-@test isequal(cosh(complex( 0.0, NaN)), complex( NaN, 0.0))
-
-@test isequal(cosh(complex(-0.0,-0.0)), complex( 1.0, 0.0))
-@test isequal(cosh(complex(-0.0, 0.0)), complex( 1.0,-0.0))
-@test isequal(cosh(complex(-0.0, NaN)), complex( NaN, 0.0))
-
-@test isequal(cosh(complex( 5.0, Inf)), complex( NaN, NaN))
-@test isequal(cosh(complex( 5.0, NaN)), complex( NaN, NaN))
-
-@test isequal(cosh(complex( Inf, 0.0)), complex( Inf, 0.0))
-@test isequal(cosh(complex( Inf,-0.0)), complex( Inf,-0.0))
-@test isequal(cosh(complex( Inf, 5.0)), complex(cos(5.0)*Inf,sin(5.0)* Inf))
-@test isequal(cosh(complex( Inf,-5.0)), complex(cos(5.0)*Inf,sin(5.0)*-Inf))
-@test isequal(cosh(complex( Inf, Inf)), complex( Inf, NaN))
-@test isequal(cosh(complex( Inf,-Inf)), complex( Inf, NaN))
-@test isequal(cosh(complex( Inf, NaN)), complex( Inf, NaN))
-
-@test isequal(cosh(complex(-Inf,-0.0)), complex( Inf, 0.0))
-@test isequal(cosh(complex(-Inf, 0.0)), complex( Inf,-0.0))
-@test isequal(cosh(complex(-Inf,-5.0)), complex(cos(5.0)*Inf,sin(5.0)* Inf))
-@test isequal(cosh(complex(-Inf, 5.0)), complex(cos(5.0)*Inf,sin(5.0)*-Inf))
-@test isequal(cosh(complex(-Inf, Inf)), complex( Inf, NaN))
-@test isequal(cosh(complex(-Inf,-Inf)), complex( Inf, NaN))
-@test isequal(cosh(complex(-Inf, NaN)), complex( Inf, NaN))
-
-@test isequal(cosh(complex( NaN, 0.0)), complex( NaN, 0.0))
-@test isequal(cosh(complex( NaN, 5.0)), complex( NaN, NaN))
-@test isequal(cosh(complex( NaN,-0.0)), complex( NaN,-0.0))
-@test isequal(cosh(complex( NaN,-5.0)), complex( NaN, NaN))
-@test isequal(cosh(complex( NaN, NaN)), complex( NaN, NaN))
-
 # cos
 #  cos(z) = cosh(iz)
 #   i.e cos(b-ia) = cosh(a+ib)
@@ -443,42 +412,54 @@ end
 #  cos(conj(z)) = conj(cos(z))
 #  cos(-z) = cos(z)
 
-@test isequal(cos(complex( 0.0, 0.0)), complex( 1.0,-0.0))
-@test isequal(cos(complex( 0.0,-0.0)), complex( 1.0, 0.0))
-@test isequal(cos(complex( 0.0,-Inf)), complex( Inf, 0.0))
-@test isequal(cos(complex( 0.0, Inf)), complex( Inf,-0.0))
-@test isequal(cos(complex( 0.0, NaN)), complex( NaN, 0.0))
-@test isequal(cos(complex(-0.0, 0.0)), complex( 1.0, 0.0))
-@test isequal(cos(complex(-0.0,-0.0)), complex( 1.0,-0.0))
-@test isequal(cos(complex(-0.0,-Inf)), complex( Inf,-0.0))
-@test isequal(cos(complex(-0.0, Inf)), complex( Inf, 0.0))
-@test isequal(cos(complex(-0.0, NaN)), complex( NaN,-0.0))
-
-@test isequal(cos(complex( 5.0,-Inf)), complex(cos(5.0)*Inf,sin(5.0)* Inf))
-@test isequal(cos(complex( 5.0, Inf)), complex(cos(5.0)*Inf,sin(5.0)*-Inf))
-@test isequal(cos(complex( 5.0, NaN)), complex( NaN, NaN))
-@test isequal(cos(complex(-5.0,-Inf)), complex(cos(5.0)*Inf,sin(5.0)*-Inf))
-@test isequal(cos(complex(-5.0, Inf)), complex(cos(5.0)*Inf,sin(5.0)* Inf))
-@test isequal(cos(complex(-5.0, NaN)), complex( NaN, NaN))
-
-@test isequal(cos(complex( Inf, 0.0)), complex( NaN,-0.0))
-@test isequal(cos(complex( Inf, 5.0)), complex( NaN, NaN))
-@test isequal(cos(complex( Inf, Inf)), complex( Inf, NaN))
-@test isequal(cos(complex( Inf,-Inf)), complex( Inf, NaN))
-@test isequal(cos(complex(-Inf, 0.0)), complex( NaN, 0.0))
-@test isequal(cos(complex(-Inf, Inf)), complex( Inf, NaN))
-@test isequal(cos(complex(-Inf,-Inf)), complex( Inf, NaN))
-
-@test isequal(cos(complex( NaN, 0.0)), complex( NaN, 0.0))
-@test isequal(cos(complex( NaN,-0.0)), complex( NaN, 0.0))
-@test isequal(cos(complex( NaN, 5.0)), complex( NaN, NaN))
-@test isequal(cos(complex( NaN, Inf)), complex( Inf, NaN))
-@test isequal(cos(complex( NaN,-Inf)), complex( Inf, NaN))
-@test isequal(cos(complex( NaN, NaN)), complex( NaN, NaN))
+
+for (x,y) in [(complex( 0.0, 0.0), complex( 1.0, 0.0)),
+              (complex( 0.0, Inf), complex( NaN, 0.0)),
+              (complex( 0.0, NaN), complex( NaN, 0.0)),
+              (complex( 7.2, Inf), complex( NaN, NaN)),
+              (complex( 7.2, NaN), complex( NaN, NaN)),
+              (complex( 7.2, 0.0), complex( cosh(7.2), 0.0)),
+              (complex( 1e5, 0.0), complex( Inf, 0.0)),
+              (complex( Inf, 0.0), complex( Inf, 0.0)),
+              (complex( Inf, 7.2), Inf*cis(7.2)),
+              (complex( Inf, Inf), complex( Inf, NaN)),
+              (complex( Inf, NaN), complex( Inf, NaN)),
+              (complex( NaN, 0.0), complex( NaN, 0.0)),
+              (complex( NaN, 7.2), complex( NaN, NaN)),
+              (complex( NaN, NaN), complex( NaN, NaN)),
+              ]
+    undef_sign = isequal(x,complex( NaN, 0.0)) || isequal(x,complex( 0.0, NaN))
+
+    @test isequal(cosh(x), y)
+    if !undef_sign
+        @test isequal(cosh(conj(x)), conj(y))
+        @test isequal(cosh(-x), y)
+        @test isequal(cosh(-conj(x)), conj(y))
+    end
+
+    xx = complex(imag(x),-real(x))
+    yy = y
+    @test isequal(cos(xx),yy)
+    if !undef_sign
+        @test isequal(cos(conj(xx)), conj(yy))
+        @test isequal(cos(-xx), yy)
+        @test isequal(cos(-conj(xx)), conj(yy))
+    end
+
+    yyy = cos(pi*xx)
+    @test isequal(cospi(xx), yyy)
+    if !undef_sign
+        @test isequal(cospi(conj(xx)), conj(yyy))
+        @test isequal(cospi(-xx), yyy)
+        @test isequal(cospi(-conj(xx)), conj(yyy))
+    end
+end
+
 
 # tanh
 #  tanh(conj(z)) = conj(tanh(z))
 #  tanh(-z) = -tanh(z)
+@test isequal(tanh(complex( 0, 0)),complex(0.0,0.0)) #integer fallback
 @test isequal(tanh(complex( 0.0, 0.0)),complex(0.0,0.0))
 @test isequal(tanh(complex( 0.0,-0.0)),complex(0.0,-0.0))
 @test_throws DomainError  tanh(complex( 0.0, Inf))
@@ -578,6 +559,7 @@ end
 ## acos
 ##  acos(conj(z)) = conj(acos(z))
 
+@test isequal(acos(complex( 0, 0)),complex(pi/2,-0.0)) #integer fallback
 @test isequal(acos(complex( 0.0, 0.0)),complex(pi/2,-0.0))
 @test isequal(acos(complex( 0.0,-0.0)),complex(pi/2, 0.0))
 @test isequal(acos(complex( 0.0, Inf)),complex(pi/2,-Inf))
@@ -687,6 +669,7 @@ end
 #  atanh(conj(z)) = conj(atanh(z))
 #  atanh(-z) = -atanh(z)
 
+@test isequal(atanh(complex( 0, 0)),complex( 0.0, 0.0)) #integer fallback
 @test isequal(atanh(complex( 0.0, 0.0)),complex( 0.0, 0.0))
 @test isequal(atanh(complex( 0.0,-0.0)),complex( 0.0,-0.0))
 @test isequal(atanh(complex( 0.0, NaN)),complex( 0.0, NaN))
@@ -868,6 +851,14 @@ end
 @test sign(1 + im) ≈ (1 + im) / sqrt(2)
 @test sign(1 - im) ≈ (1 - im) / sqrt(2)
 
+for T in (Float16, Float32, Float64)
+    z = Complex(zero(T), zero(T))
+    @test sign(z) === z
+    @test sign(-z) === -z
+    @test sign(conj(z)) === conj(z)
+    @test sign(-conj(z)) === -conj(z)
+end
+
 # cis
 @test_approx_eq cis(0.0+1.0im) 0.367879441171442321595523770161460867445811131031767834507836+0.0im
 @test_approx_eq cis(1.0+0.0im) 0.54030230586813971740093660744297660373231042061+0.84147098480789650665250232163029899962256306079im
@@ -908,3 +899,9 @@ end
 
 # issue #10926
 @test typeof(π - 1im) == Complex{Float64}
+
+# issue #11839: type stability for Complex{Int64}
+let x = 1+im
+    @inferred sin(x)
+    @inferred cos(x)
+end
diff --git a/test/copy.jl b/test/copy.jl
index cd5ca21cb3567..26a5c1b00008d 100644
--- a/test/copy.jl
+++ b/test/copy.jl
@@ -57,3 +57,13 @@ let a = Any[[1]], q = QuoteNode([1])
     @test dca[1] !== a[1]
     @test deepcopy(q).value !== q.value
 end
+
+# issue #13124
+let a = rand(3, 5)
+    b = (a,a)
+    c = deepcopy(b)
+    @test c[1] === c[2]
+end
+
+# issue #14027
+@test isnull(deepcopy(Nullable{Array}()))
diff --git a/test/core.jl b/test/core.jl
index 363789ef9f0b3..83e7184da143d 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -319,15 +319,17 @@ function fooo_3()
     y
 end
 @test fooo_3() === 100
-function foo()
-    local x::Int8
-    function bar()
-        x = 100
-    end
+let
+    function foo()
+        local x::Int8
+        function bar()
+            x = 100
+        end
     bar()
-    x
+        x
+    end
+    @test foo() === convert(Int8,100)
 end
-@test foo() === convert(Int8,100)
 
 function bar{T}(x::T)
     local z::Complex{T}
@@ -421,14 +423,14 @@ glotest()
 # issue #7234
 begin
     glob_x2 = 24
-    f7234() = (glob_x2 += 1)
+    f7234_a() = (glob_x2 += 1)
 end
-@test_throws UndefVarError f7234()
+@test_throws UndefVarError f7234_a()
 begin
     global glob_x2 = 24
-    f7234() = (glob_x2 += 1)
+    f7234_b() = (glob_x2 += 1)
 end
-@test_throws UndefVarError f7234()
+@test_throws UndefVarError f7234_b()
 # existing globals can be inherited by non-function blocks
 for i = 1:2
     glob_x2 += 1
@@ -689,7 +691,7 @@ let A = [1]
 end
 
 # Module() constructor
-@test names(Module(:anonymous), true, true) != [:anonymous]
+@test names(Module(:anonymous), true, true) == [:anonymous]
 @test names(Module(:anonymous, false), true, true) == [:anonymous]
 
 # exception from __init__()
@@ -810,8 +812,7 @@ let
     local my_func, a, c
     my_func{T}(P::Vector{T}, Q::Vector{T}) = 0
     my_func{T}(x::T, P::Vector{T}) = 1
-    # todo: this gives an ambiguity warning
-    #my_func{T}(P::Vector{T}, x::T) = 2
+    my_func{T}(P::Vector{T}, x::T) = 2
     a = Int[3]
     c = Vector[a]
 
@@ -1233,14 +1234,15 @@ end
 @test isa(foo4075(Foo4075(Int64(1),2.0),:y), Float64)
 
 # issue #3167
-function foo(x)
-    ret=Array(typeof(x[1]), length(x))
-    for j = 1:length(x)
-        ret[j] = x[j]
+let
+    function foo(x)
+        ret=Array(typeof(x[1]), length(x))
+        for j = 1:length(x)
+            ret[j] = x[j]
+        end
+        return ret
     end
-    return ret
-end
-let x = Array(Union{Dict{Int64,AbstractString},Array{Int64,3},Number,AbstractString,Void}, 3)
+    x = Array(Union{Dict{Int64,AbstractString},Array{Int64,3},Number,AbstractString,Void}, 3)
     x[1] = 1.0
     x[2] = 2.0
     x[3] = 3.0
@@ -1594,6 +1596,12 @@ end
 h5142(true)
 @test_throws TypeError h5142(1)
 h5142(2)
+f5142() = h5142(1)
+try
+    # try running this code in a different context that triggers the codegen
+    # assertion `assert(isboxed || v.typ == typ)`.
+    f5142()
+end
 
 bitstype 8 Int5142b
 function h5142b(a::Int)
@@ -2075,7 +2083,7 @@ let ex = Expr(:(=), :(f8338(x;y=4)), :(x*y))
 end
 
 # call overloading (#2403)
-Base.call(x::Int, y::Int) = x + 3y
+(x::Int)(y::Int) = x + 3y
 issue2403func(f) = f(7)
 let x = 10
     @test x(3) == 19
@@ -2085,7 +2093,7 @@ end
 type Issue2403
     x
 end
-Base.call(i::Issue2403, y) = i.x + 2y
+(i::Issue2403)(y) = i.x + 2y
 let x = Issue2403(20)
     @test x(3) == 26
     @test issue2403func(x) == 34
@@ -2174,6 +2182,21 @@ f9520c(::Any, ::Any, ::Any, ::Any, ::Any, ::Any, args...) = 46
 @test invoke(f9520c, (Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6) == 46
 @test invoke(f9520c, (Any, Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6, 7) == 46
 
+call_lambda1() = (()->x)(1)
+call_lambda2() = ((x)->x)()
+call_lambda3() = ((x)->x)(1,2)
+call_lambda4() = ((x,y...)->x)()
+@test_throws MethodError call_lambda1()
+@test_throws MethodError call_lambda2()
+@test_throws MethodError call_lambda3()
+@test_throws MethodError call_lambda4()
+call_lambda5() = ((x...)->x)()
+call_lambda6() = ((x...)->x)(1)
+call_lambda7() = ((x...)->x)(1,2)
+@test call_lambda5() == ()
+@test call_lambda6() == (1,)
+@test call_lambda7() == (1,2)
+
 # jl_new_bits testing
 let x = [1,2,3]
     @test ccall(:jl_new_bits, Any, (Any,Ptr{Void},), Int, x) === 1
@@ -2184,9 +2207,14 @@ let x = [1,2,3]
 end
 
 # sig 2 is SIGINT per the POSIX.1-1990 standard
-if Base.is_unix(OS_NAME)
+@unix_only begin
     ccall(:jl_exit_on_sigint, Void, (Cint,), 0)
-    @test_throws InterruptException ccall(:raise, Void, (Cint,), 2)
+    @test_throws InterruptException begin
+        #ccall(:raise, Void, (Cint,), 2) # llvm installs a custom version on Darwin that resolves to pthread_kill(pthread_self(), sig), which isn't what we want
+        Libc.systemsleep(0.1)
+        ccall(:kill, Void, (Cint, Cint,), getpid(), 2)
+        Libc.systemsleep(0.2) # wait for SIGINT to arrive
+    end
     ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
 end
 
@@ -2244,7 +2272,7 @@ end
 
 # weak references
 type Obj; x; end
-function mk_wr(r, wr)
+@noinline function mk_wr(r, wr)
     x = Obj(1)
     push!(r, x)
     push!(wr, WeakRef(x))
@@ -2352,13 +2380,13 @@ type newtype10373
 end
 let f
     for f in (f10373,g10373)
-        f(x::newtype10373) = println("$f")
+        (::typeof(f))(x::newtype10373) = println("$f")
     end
 end
-@test f10373.env.defs.func.code.name == :f10373
-@test f10373.env.defs.next.func.code.name == :f10373
-@test g10373.env.defs.func.code.name == :g10373
-@test g10373.env.defs.next.func.code.name == :g10373
+@test methods(f10373).defs.func.name == :f10373
+@test methods(f10373).defs.next.func.name == :f10373
+@test methods(g10373).defs.func.name == :g10373
+@test methods(g10373).defs.next.func.name == :g10373
 
 # issue #7221
 f7221{T<:Number}(::T) = 1
@@ -2968,7 +2996,7 @@ end
 
 # issue #8283
 function func8283 end
-@test isa(func8283,Function) && isgeneric(func8283)
+@test isa(func8283,Function)
 @test_throws MethodError func8283()
 
 # issue #11243
@@ -3064,17 +3092,19 @@ end
 # issue 11858
 type Foo11858
     x::Float64
+    Foo11858(x::Float64) = new(x)
 end
 
 type Bar11858
     x::Float64
+    Bar11858(x::Float64) = new(x)
 end
 
 g11858(x::Float64) = x
 f11858(a) = for Baz in a
-    Baz(x) = Baz(float(x))
+    (f::Baz)(x) = f(float(x))
 end
-f11858(Any[Foo11858, Bar11858, g11858])
+f11858(Any[Type{Foo11858}, Type{Bar11858}, typeof(g11858)])
 
 @test g11858(1) == 1.0
 @test Foo11858(1).x == 1.0
@@ -3151,9 +3181,9 @@ failure12003(dt=DATE12003) = Dates.year(dt)
 @test isa(failure12003(), Integer)
 
 # issue #12023 Test error checking in bitstype
-@test_throws ErrorException bitstype 0 SPJa12023
-@test_throws ErrorException bitstype 4294967312 SPJb12023
-@test_throws ErrorException bitstype -4294967280 SPJc12023
+@test_throws ErrorException (@eval bitstype 0 SPJa12023)
+@test_throws ErrorException (@eval bitstype 4294967312 SPJb12023)
+@test_throws ErrorException (@eval bitstype -4294967280 SPJc12023)
 
 # issue #12089
 type A12089{K, N}
@@ -3292,7 +3322,7 @@ immutable RGB{T<:AbstractFloat} <: Paint{T}
 end
 
 myeltype{T}(::Type{Paint{T}}) = T
-myeltype{P<:Paint}(::Type{P}) = myeltype(super(P))
+myeltype{P<:Paint}(::Type{P}) = myeltype(supertype(P))
 myeltype(::Type{Any}) = Any
 
 end
@@ -3300,21 +3330,6 @@ end
 @test @inferred(MyColors.myeltype(MyColors.RGB{Float32})) == Float32
 @test @inferred(MyColors.myeltype(MyColors.RGB)) == Any
 
-# issue #12612 (handle the case when `call` is not defined)
-Main.eval(:(type Foo12612 end))
-
-baremodule A12612
-import Main: Foo12612
-f1() = Foo12612()
-f2() = Main.Foo12612()
-end
-
-## Don't panic in type inference if call is not defined
-code_typed(A12612.f1, Tuple{})
-code_typed(A12612.f2, Tuple{})
-@test_throws ErrorException A12612.f1()
-@test_throws ErrorException A12612.f2()
-
 # issue #12569
 @test_throws ArgumentError symbol("x"^10_000_000)
 @test_throws ArgumentError gensym("x"^10_000_000)
@@ -3322,7 +3337,7 @@ code_typed(A12612.f2, Tuple{})
 @test split(string(gensym("abc")),'#')[3] == "abc"
 
 # meta nodes for optional positional arguments
-@test Base.uncompressed_ast(expand(:(@inline f(p::Int=2) = 3)).args[1].args[3]).args[3].args[1].args[1] === :inline
+@test Base.uncompressed_ast(expand(:(@inline f(p::Int=2) = 3)).args[2].args[3]).args[3].args[1].args[1] === :inline
 
 # issue #12826
 f12826{I<:Integer}(v::Vector{I}) = v[1]
@@ -3357,3 +3372,493 @@ for j = 1:1
         continue
     end
 end
+
+# PR 11888
+immutable A11888{T}
+    a::NTuple{16,T}
+end
+
+typealias B11888{T} A11888{A11888{A11888{T}}}
+
+@test sizeof(B11888{B11888{Int64}}) == (1 << 24) * 8
+
+# issue #13175
+immutable EmptyImmutable13175 end
+immutable EmptyIIOtherField13175
+    x::EmptyImmutable13175
+    y::Float64
+end
+@test EmptyIIOtherField13175(EmptyImmutable13175(), 1.0) == EmptyIIOtherField13175(EmptyImmutable13175(), 1.0)
+@test EmptyIIOtherField13175(EmptyImmutable13175(), 1.0) != EmptyIIOtherField13175(EmptyImmutable13175(), 2.0)
+
+# issue #13183
+gg13183{X}(x::X...) = 1==0 ? gg13183(x, x) : 0
+@test gg13183(5) == 0
+
+# issue 8932 (llvm return type legalizer error)
+immutable Vec3_8932
+   x::Float32
+   y::Float32
+   z::Float32
+end
+f8932(a::Vec3_8932, b::Vec3_8932) = Vec3_8932(a.x % b.x, a.y % b.y, a.z % b.z)
+a8932 = Vec3_8932(1,1,1)
+b8932 = Vec3_8932(2,2,2)
+@test f8932(a8932, b8932) == Vec3_8932(1.0, 1.0, 1.0)
+
+# issue #13261
+f13261() = (x = (error("oops"),); +(x...))
+g13261() = f13261()
+@test_throws ErrorException g13261()
+
+# issue 13432
+@noinline function f13432(x)
+    offset = x ? Base.Bottom : 1
+    return is(offset, Base.Bottom)
+end
+@test f13432(true) == true
+@test f13432(false) == false
+@noinline function f13432b(x)
+    a = x ? 1 : 1.0
+    b = x ? 1 : 1.0f0
+    return is(a, b)
+end
+@test f13432b(true) == true
+@test f13432b(false) == false
+
+#13433, read!(::IO, a::Vector{UInt8}) should return a
+type IO13433 <: IO end
+Base.read(::IO13433, ::Type{UInt8}) = 0x01
+@test read!(IO13433(), Array(UInt8, 4)) == [0x01, 0x01, 0x01, 0x01]
+
+# issue #13647, comparing boxed isbits immutables
+immutable X13647
+    a::Int
+    b::Bool
+end
+function f13647(x, y)
+   z = false
+   z = y
+   x === z
+end
+@test f13647(X13647(1, false), X13647(1, false))
+@test !f13647(X13647(1, false), X13647(1, true))
+@test !f13647(X13647(2, false), X13647(1, false))
+
+# issue #13636
+module I13636
+foo(x) = 1
+end
+let cache = Dict()
+    function I13636.foo(y::Int;k::Int=1)
+        cache[1] = y+k
+    end
+end
+@test I13636.foo(1,k=2) == 3
+
+# issue #11327 and #13547
+@test_throws MethodError convert(Type{Int}, Float32)
+@test_throws MethodError Array{Type{Int64}}([Float32])
+abstract A11327
+abstract B11327 <: A11327
+f11327{T}(::Type{T},x::T) = x
+@test_throws MethodError f11327(Type{A11327},B11327)
+let T=TypeVar(:T,true)
+    @test typeintersect(Tuple{Type{T},T}, Tuple{Type{Type{Float64}},Type{Int}}) === Union{}
+end
+
+# issue 13855
+macro m13855()
+    Expr(:localize, :(() -> x))
+end
+@noinline function foo13855(x)
+    @m13855()
+end
+@test foo13855(Base.AddFun())() == Base.AddFun()
+@test foo13855(Base.MulFun())() == Base.MulFun()
+
+# issue #8487
+@test [x for x in 1:3] == [x for x ∈ 1:3] == [x for x = 1:3]
+let A = Array(Int, 4,3)
+    for i ∈ 1:size(A,1), j ∈ 1:size(A,2)
+        A[i,j] = 17*i + 51*j
+    end
+    @test A == [17*i + 51*j for i ∈ 1:size(A,1), j ∈ 1:size(A,2)]
+end
+
+# check if finalizers for the old gen can be triggered manually
+# issue #13986
+let
+    obj = Ref(1)
+    finalized = 0
+    finalizer(obj, (obj) -> (finalized = 1))
+    # obj should be marked for promotion after the second gc and be promoted
+    # after the third GC
+    # GC_CLEAN; age = 0
+    gc(false)
+    # GC_CLEAN; age = 1
+    gc(false)
+    # GC_QUEUED; age = 1
+    gc(false)
+    # GC_MARKED; age = 1
+    finalize(obj)
+    @test finalized == 1
+end
+
+# check if finalizers for the old gen can be triggered manually
+# PR #14181
+let
+    # The following three `gc(false)` clears the `finalizer_list`. It is
+    # not strictly necessary to make the test pass but should make the failure
+    # more repeatable if something breaks.
+    gc(false)
+    # At least: GC_CLEAN; age = 1
+    gc(false)
+    # At least: GC_QUEUED; age = 1
+    gc(false)
+    # all objects in `finalizer_list` are now moved to `finalizer_list_marked`
+
+    obj1 = Ref(1)
+    obj2 = Ref(1)
+    finalized = 0
+    finalizer(obj1, (obj) -> (finalized += 1))
+    finalizer(obj1, (obj) -> (finalized += 1))
+    finalizer(obj2, (obj) -> (finalized += 1; finalize(obj1)))
+    finalizer(obj2, (obj) -> (finalized += 1; finalize(obj1)))
+    finalize(obj2)
+    @test finalized == 4
+end
+
+# issue #14323
+@test_throws ErrorException eval(Expr(:body, :(1)))
+
+# issue #14339
+f14339{T<:Union{}}(x::T, y::T) = 0
+@test_throws MethodError f14339(1, 2)
+
+# Make sure jlcall objects are rooted
+# PR #14301
+module JLCall14301
+
+# Define f
+function f end
+
+let i = Any[[1.23], [2.34]]
+    # f() with capture variables
+    # Intentionally type unstable so that the dynamic dispatch will
+    # read the corrupted tag if the object is incorrectly GC'd.
+    global @noinline f() = i[1][1] * i[2][1]
+end
+
+# Another function that use f()
+g() = f() * 100
+# Compile it
+g()
+
+let i = 9.0
+    # Override f()
+    global @noinline f() = i + 1
+end
+
+# Make sure the old f() method is GC'd if it was not rooted properly
+gc()
+gc()
+gc()
+
+# Run again.
+g()
+
+end
+
+# make sure codegen doesn't remove argument to `isa`
+@noinline __g_isa_test_1(a) = push!(a,1)
+function __f_isa_arg_1()
+    a = []
+    isa(__g_isa_test_1(a), Any)
+    length(a)
+end
+@test __f_isa_arg_1() == 1
+
+# non-terminating inference, issue #14009
+type A14009{T}; end
+A14009{T}(a::T) = A14009{T}()
+f14009(a) = rand(Bool) ? f14009(A14009(a)) : a
+code_typed(f14009, (Int,))
+
+type B14009{T}; end
+g14009(a) = g14009(B14009{a})
+code_typed(g14009, (Type{Int},))
+
+# issue #14477
+immutable Z14477
+    fld::Z14477
+    Z14477() = new(new())
+end
+let z1 = Z14477()
+    @test isa(z1, Z14477)
+    @test isa(z1.fld, Z14477)
+end
+
+# issue #14482
+let T = TypeVar(:T, true)
+    @test typeintersect(T, Type{Int8}) == Type{Int8}
+    @test typeintersect(Tuple{T}, Tuple{Type{Int8}}) == Tuple{Type{Int8}}
+end
+
+# issue #8846, generic macros
+macro m8846(a, b=0)
+    a, b
+end
+@test @m8846(a) === (:a, 0)
+@test @m8846(a,1) === (:a, 1)
+@test_throws MethodError eval(:(@m8846(a,b,c)))
+
+# a simple case of parametric dispatch with unions
+let foo{T}(x::Union{T,Void},y::Union{T,Void}) = 1
+    @test foo(1, nothing) === 1
+    @test_throws MethodError foo(nothing, nothing)  # can't determine T
+end
+
+module TestMacroGlobalFunction
+macro makefn(f,g)
+    quote
+        global $(f)
+        function $(f)(x)
+            x+1
+        end
+        global $(g)
+        $(g)(x) = x+2
+    end
+end
+@makefn ff gg
+end
+@test TestMacroGlobalFunction.ff(1) == 2
+@test TestMacroGlobalFunction.gg(1) == 3
+
+# issue #14564
+@test isa(object_id(Tuple.name.cache), Integer)
+
+# issue #14691
+type T14691; a::UInt; end
+@test (T14691(0).a = 0) === 0
+
+# issue #14245
+f14245() = (v = []; push!(v, length(v)); v)
+@test f14245()[1] == 0
+
+# issue #9677
+@generated function foo9677{T,N}(x::AbstractArray{T,N})
+    quote
+        x=$N
+        y=x+1
+        return y
+    end
+end
+foo9677(x::Array) = invoke(foo9677,(AbstractArray,),x)
+@test foo9677(1:5) == foo9677(randn(3))
+
+# issue #6846
+f6846() = (please6846; 2)
+@test_throws UndefVarError f6846()
+
+# issue #14758
+@test isa(eval(:(f14758(; $([]...)) = ())), Function)
+
+# issue #14767
+@inline f14767(x) = x ? A14767 : ()
+const A14767 = f14767(false)
+@test A14767 === ()
+
+# issue #10985
+f10985(::Any...) = 1
+@test f10985(1, 2, 3) == 1
+
+# a tricky case for closure conversion
+type _CaptureInCtor
+    yy
+    function _CaptureInCtor(list_file::AbstractString="")
+        y = 0
+        f = x->add_node(y)
+        new(f(2))
+    end
+    add_node(y) = y+1
+end
+@test _CaptureInCtor().yy == 1
+
+# issue #14610
+let sometypes = (Int,Int8)
+    f(::Union{ntuple(i->Type{sometypes[i]}, length(sometypes))...}) = 1
+    @test method_exists(f, (Union{Type{Int},Type{Int8}},))
+end
+
+let
+    b=()->c
+    c=1
+    @test b() == 1
+end
+
+# issue #14825
+abstract abstest_14825
+
+type t1_14825{A <: abstest_14825, B}
+  x::A
+  y::B
+end
+
+type t2_14825{C, B} <: abstest_14825
+  x::C
+  y::t1_14825{t2_14825{C, B}, B}
+end
+
+@test t2_14825{Int,Int}.types[2] <: t1_14825
+
+# issue #14917
+@test isa(let generic
+          function generic end
+          end,
+          Function)
+
+# let syntax with multiple lhs
+let z = (3,9,42)
+    let (a,b,c) = z
+        @test a == 3 && b == 9 && c == 42
+    end
+    let (a,b::Float64,c::Int8) = z
+        @test a == 3 && b === 9.0 && c === Int8(42)
+    end
+    z = (1, z, 10)
+    let (a, (b,c,d), e) = z
+        @test (a,b,c,d,e) == (1,3,9,42,10)
+    end
+end
+
+# issue #15072
+let grphtest = ((1, [2]),)
+    for (s, g) in grphtest
+        g_ = map(s -> s+1, g)
+        @test g_ == [3]
+    end
+    for s = 1:1
+    end
+end
+
+let f(T) = Type{T}
+    @test Base.return_types(f, Tuple{Type{Int}}) == [Type{Type{Int}}]
+end
+
+# issue #13229
+module I13229
+    using Base.Test
+    global z = 0
+    @timed @profile for i = 1:5
+        function f(x)
+            return x + i
+        end
+        global z = f(i)
+    end
+    @test z == 10
+end
+
+# issue #12474
+@generated function f12474(::Any)
+    :(for i in 1
+      end)
+end
+let
+    ast12474 = code_typed(f12474, Tuple{Float64})
+    for (_, vartype) in ast12474[1].args[2][1]
+        @test isleaftype(vartype)
+    end
+end
+
+# issue #15186
+let ex = quote
+             $(if true; :(test); end)
+         end
+    @test ex.args[2] == :test
+end
+
+# issue #15180
+function f15180{T}(x::T)
+    X = Array(T, 1)
+    X[1] = x
+    @noinline ef{J}(::J) = (J,X[1]) # Use T
+    ef{J}(::J, ::Int) = (T,J)
+    return ef
+end
+@test map(f15180(1), [1,2]) == [(Int,1),(Int,1)]
+
+let ary = Vector{Any}(10)
+    check_undef_and_fill(ary, rng) = for i in rng
+        @test !isdefined(ary, i)
+        ary[i] = (Float64(i), i) # some non-cached content
+        @test isdefined(ary, i)
+    end
+    # Check if the memory is initially zerod and fill it with value
+    # to check if these values are not reused later.
+    check_undef_and_fill(ary, 1:10)
+    # Check if the memory grown at the end are zerod
+    ccall(:jl_array_grow_end, Void, (Any, Csize_t), ary, 10)
+    check_undef_and_fill(ary, 11:20)
+    # Make sure the content of the memory deleted at the end are not reused
+    ccall(:jl_array_del_end, Void, (Any, Csize_t), ary, 5)
+    ccall(:jl_array_grow_end, Void, (Any, Csize_t), ary, 5)
+    check_undef_and_fill(ary, 16:20)
+
+    # Now check grow/del_end
+    ary = Vector{Any}(1010)
+    check_undef_and_fill(ary, 1:1010)
+    # This del_beg should move the buffer
+    ccall(:jl_array_del_beg, Void, (Any, Csize_t), ary, 1000)
+    ccall(:jl_array_grow_beg, Void, (Any, Csize_t), ary, 1000)
+    check_undef_and_fill(ary, 1:1000)
+    ary = Vector{Any}(1010)
+    check_undef_and_fill(ary, 1:1010)
+    # This del_beg should not move the buffer
+    ccall(:jl_array_del_beg, Void, (Any, Csize_t), ary, 10)
+    ccall(:jl_array_grow_beg, Void, (Any, Csize_t), ary, 10)
+    check_undef_and_fill(ary, 1:10)
+
+    ary = Vector{Any}(1010)
+    check_undef_and_fill(ary, 1:1010)
+    ccall(:jl_array_grow_end, Void, (Any, Csize_t), ary, 10)
+    check_undef_and_fill(ary, 1011:1020)
+    ccall(:jl_array_del_end, Void, (Any, Csize_t), ary, 10)
+    ccall(:jl_array_grow_beg, Void, (Any, Csize_t), ary, 10)
+    check_undef_and_fill(ary, 1:10)
+
+    # Make sure newly malloc'd buffers are filled with 0
+    # test this for a few different sizes since we need to make sure
+    # we are malloc'ing the buffer after the grow_end and malloc is not using
+    # mmap directly (which may return a zero'd new page).
+    for n in [50, 51, 100, 101, 200, 201, 300, 301]
+        ary = Vector{Any}(n)
+        # Try to free the previous buffer that was filled with random content
+        # and to increase the chance of getting a non-zero'd buffer next time
+        gc()
+        gc()
+        gc()
+        ccall(:jl_array_grow_beg, Void, (Any, Csize_t), ary, 4)
+        ccall(:jl_array_del_beg, Void, (Any, Csize_t), ary, 4)
+        ccall(:jl_array_grow_end, Void, (Any, Csize_t), ary, n)
+        ccall(:jl_array_grow_beg, Void, (Any, Csize_t), ary, 4)
+        check_undef_and_fill(ary, 1:(2n + 4))
+    end
+end
+
+# pr #15259
+immutable A15259
+    x
+    y
+end
+# check that allocation was ellided
+@eval f15259(x,y) = (a = $(Expr(:new, :A15259, :x, :y)); (a.x, a.y, getfield(a,1), getfield(a, 2)))
+@test isempty(filter(x -> isa(x,Expr) && x.head === :(=) &&
+                          isa(x.args[2], Expr) && x.args[2].head === :new,
+                     code_typed(f15259, (Any,Int))[1].args[3].args))
+@test f15259(1,2) == (1,2,1,2)
+# check that error cases are still correct
+@eval g15259(x,y) = (a = $(Expr(:new, :A15259, :x, :y)); a.z)
+@test_throws ErrorException g15259(1,1)
+@eval h15259(x,y) = (a = $(Expr(:new, :A15259, :x, :y)); getfield(a, 3))
+@test_throws BoundsError h15259(1,1)
diff --git a/test/readdlm.jl b/test/datafmt.jl
similarity index 89%
rename from test/readdlm.jl
rename to test/datafmt.jl
index c0032acc27049..8e7cba730e8ce 100644
--- a/test/readdlm.jl
+++ b/test/datafmt.jl
@@ -7,9 +7,7 @@
 @test countlines(IOBuffer("\n \n \n \n \n \n \n \n \n \n")) == 10
 @test countlines(IOBuffer("\r\n \r\n \r\n \r\n \r\n")) == 5
 file = tempname()
-open(file,"w") do f
-    write(f,"Spiffy header\nspectacular first row\neven better 2nd row\nalmost done\n")
-end
+write(file,"Spiffy header\nspectacular first row\neven better 2nd row\nalmost done\n")
 @test countlines(file) == 4
 @test countlines(file,'\r') == 0
 @test countlines(file,'\n') == 4
@@ -93,6 +91,18 @@ let x = [1,2,3], y = [4,5,6], io = IOBuffer()
     @test readcsv(io) == [x y]
 end
 
+let x = [0.1 0.3 0.5], io = IOBuffer()
+    writedlm(io, x, ", ")
+    seek(io, 0)
+    @test readstring(io) == "0.1, 0.3, 0.5\n"
+end
+
+let x = [0.1 0.3 0.5], io = IOBuffer()
+    writedlm(io, x, ", ")
+    seek(io, 0)
+    @test readcsv(io) == [0.1 0.3 0.5]
+end
+
 let x = ["abc", "def\"ghi", "jk\nl"], y = [1, ",", "\"quoted\""], io = IOBuffer()
     writedlm(io, zip(x,y), ',')
     seek(io, 0)
@@ -205,7 +215,7 @@ let i18n_data = ["Origin (English)", "Name (English)", "Origin (Native)", "Name
     writedlm(i18n_buff, i18n_arr, ',')
     @test i18n_arr == readcsv(i18n_buff)
 
-    hdr = i18n_arr[1, :]
+    hdr = i18n_arr[1:1, :]
     data = i18n_arr[2:end, :]
     writedlm(i18n_buff, i18n_arr, ',')
     @test (data, hdr) == readcsv(i18n_buff, header=true)
@@ -218,3 +228,38 @@ end
     reshape(Any[1,2000.1,Float64(22222222222222222222222222222222222222),true,0x3,false,10e6,-10.34], 2, 4), Any)
 
 @test isequaldlm(readcsv(IOBuffer("-9223355253176920979,9223355253176920979"), Int64), Int64[-9223355253176920979  9223355253176920979], Int64)
+
+# fix #13028
+for data in ["A B C", "A B C\n"]
+    data,hdr = readdlm(IOBuffer(data), header=true)
+    @test hdr == AbstractString["A" "B" "C"]
+    @test data == Array(Float64, 0, 3)
+end
+
+# fix #13179 parsing unicode lines with default delmiters
+@test isequaldlm(readdlm(IOBuffer("# Should ignore this π\n1\tα\n2\tβ\n")), Any[1 "α"; 2 "β"], Any)
+
+# BigInt parser
+let data = "1 2 3"
+    readdlm(IOBuffer(data), ' ', BigInt) == BigInt[1 2 3]
+end
+
+# test writemime
+@test sprint(io -> writemime(io, "text/csv", [1 2; 3 4])) == "1,2\n3,4\n"
+
+for writefunc in ((io,x) -> writemime(io, "text/csv", x),
+                  (io,x) -> invoke(writedlm, (IO, Any, Any), io, x, ","))
+    # iterable collections of iterable rows:
+    let x = [(1,2), (3,4)], io = IOBuffer()
+        writefunc(io, x)
+        seek(io, 0)
+        @test readcsv(io) == [1 2; 3 4]
+    end
+    # vectors of strings:
+    let x = ["foo", "bar"], io = IOBuffer()
+        writefunc(io, x)
+        seek(io, 0)
+        @test collect(readcsv(io)) == x
+    end
+end
+
diff --git a/test/dates/accessors.jl b/test/dates/accessors.jl
index 5462de0848639..62d7a653ce50e 100644
--- a/test/dates/accessors.jl
+++ b/test/dates/accessors.jl
@@ -40,7 +40,7 @@
 # test_dates(-10000,10000) takes about 15 seconds
 # test_dates(year(typemin(Date)),year(typemax(Date))) is full range
 # and would take.......a really long time
-function test_dates(from,to)
+function test_dates1(from,to)
     y = m = d = 0
     test_day = Dates.totaldays(from,1,1)
     for y in from:to
@@ -54,10 +54,10 @@ function test_dates(from,to)
         end
     end
 end
-test_dates(0,2100)
+test_dates1(0,2100)
 
 # Test year, month, day, hour, minute
-function test_dates()
+function test_dates1()
     y = m = d = h = mi = 0
     for m = 1:12
         for d = 1:Dates.daysinmonth(y,m)
@@ -77,10 +77,10 @@ function test_dates()
         end
     end
 end
-test_dates()
+test_dates1()
 
 # Test second, millisecond
-function test_dates()
+function test_dates2()
     y = m = d = h = mi = s = ms = 0
     for y in [-2013,-1,0,1,2013]
         for m in [1,6,12]
@@ -102,9 +102,9 @@ function test_dates()
         end
     end
 end
-test_dates()
+test_dates2()
 
-function test_dates(from,to)
+function test_dates2(from,to)
     y = m = d = 0
     for y in from:to
         for m = 1:12
@@ -117,7 +117,7 @@ function test_dates(from,to)
         end
     end
 end
-test_dates(0,2100)
+test_dates2(0,2100)
 
 # week function
 # Tests from https://en.wikipedia.org/wiki/ISO_week_date
diff --git a/test/dates/conversions.jl b/test/dates/conversions.jl
index 68136d9a1d8b4..630207f4de063 100644
--- a/test/dates/conversions.jl
+++ b/test/dates/conversions.jl
@@ -47,6 +47,11 @@
 @test typeof(Dates.today()) <: Dates.Date
 @test typeof(Dates.now(Dates.UTC)) <: Dates.DateTime
 
+@osx_only withenv("TZ" => "UTC") do
+    @test abs(Dates.now() - now(Dates.UTC)) < Dates.Second(1)
+end
+@test abs(Dates.now() - now(Dates.UTC)) < Dates.Hour(16)
+
 # Issue #9171, #9169
 let t = Dates.Period[Dates.Week(2), Dates.Day(14), Dates.Hour(14*24), Dates.Minute(14*24*60), Dates.Second(14*24*60*60), Dates.Millisecond(14*24*60*60*1000)]
     for i = 1:length(t)
@@ -71,3 +76,27 @@ end
 @test Dates.Year(3) < Dates.Month(37)
 @test_throws InexactError convert(Dates.Year, Dates.Month(37))
 @test_throws InexactError Dates.Month(Dates.Year(typemax(Int64)))
+
+# Ensure that conversion of 32-bit integers work
+let dt = DateTime(1915,1,1,12)
+    unix = Int32(Dates.datetime2unix(dt))
+    julian = Int32(Dates.datetime2julian(dt))
+
+    @test Dates.unix2datetime(unix) == dt
+    @test Dates.julian2datetime(julian) == dt
+end
+
+# Conversions to/from numbers
+a = Dates.DateTime(2000)
+b = Dates.Date(2000)
+@test convert(Real,b) == 730120
+@test convert(Float64,b) == 730120.0
+@test convert(Int32,b) == 730120
+@test convert(Real,a) == 63082368000000
+@test convert(Float64,a) == 63082368000000.0
+@test convert(Int64,a) == 63082368000000
+@test convert(DateTime,63082368000000) == a
+@test convert(DateTime,63082368000000.0) == a
+@test convert(Date,730120) == b
+@test convert(Date,730120.0) == b
+@test convert(Date,Int32(730120)) == b
diff --git a/test/dates/types.jl b/test/dates/types.jl
index 8975099d8d2a6..42446fa614404 100644
--- a/test/dates/types.jl
+++ b/test/dates/types.jl
@@ -114,12 +114,7 @@ b = Dates.Date(2000)
 @test typemax(Dates.DateTime) - typemin(Dates.DateTime) == Dates.Millisecond(9223372017043199000)
 @test string(typemax(Dates.Date)) == "252522163911149-12-31"
 @test string(typemin(Dates.Date)) == "-252522163911150-01-01"
-@test convert(Real,b) == 730120
-@test convert(Float64,b) == 730120.0
-@test convert(Int32,b) == 730120
-@test convert(Real,a) == 63082368000000
-@test convert(Float64,a) == 63082368000000.0
-@test convert(Int64,a) == 63082368000000
+
 # Date-DateTime conversion/promotion
 @test Dates.DateTime(a) == a
 @test Dates.Date(a) == b
@@ -147,7 +142,7 @@ b = Dates.Date(2001)
 @test a != b
 @test Dates.Date(Dates.DateTime(Dates.Date(2012,7,1))) == Dates.Date(2012,7,1)
 
-#=y = Dates.Year(1)
+y = Dates.Year(1)
 m = Dates.Month(1)
 w = Dates.Week(1)
 d = Dates.Day(1)
@@ -173,4 +168,3 @@ ms = Dates.Millisecond(1)
 @test Dates.Date(d,y) == Dates.Date(1,1,1)
 @test Dates.Date(d,m) == Dates.Date(1,1,1)
 @test Dates.Date(m,y) == Dates.Date(1,1,1)
-=#
diff --git a/test/dict.jl b/test/dict.jl
index 1de632b7a3c5d..ad2972c4206a7 100644
--- a/test/dict.jl
+++ b/test/dict.jl
@@ -10,6 +10,7 @@ p = Pair(1,2)
 @test !done(p,2)
 @test done(p,3)
 @test !done(p,0)
+@test endof(p) == length(p) == 2
 @test Base.indexed_next(p, 1, (1,2)) == (1,2)
 @test Base.indexed_next(p, 2, (1,2)) == (2,3)
 @test (1=>2) < (2=>3)
@@ -81,6 +82,8 @@ let
     @test eltype(td) == Pair{AbstractString,Float64}
     @test keytype(td) == AbstractString
     @test valtype(td) == Float64
+    @test keytype(Dict{AbstractString,Float64}) === AbstractString
+    @test valtype(Dict{AbstractString,Float64}) === Float64
 end
 
 let
@@ -255,7 +258,8 @@ for d in (Dict("\n" => "\n", "1" => "\n", "\n" => "2"),
     for cols in (12, 40, 80), rows in (2, 10, 24)
         # Ensure output is limited as requested
         s = IOBuffer()
-        Base.showdict(s, d, limit=true, sz=(rows, cols))
+        io = Base.IOContext(Base.IOContext(s, :limit_output => true), :displaysize => (rows, cols))
+        Base.showdict(io, d)
         out = split(takebuf_string(s),'\n')
         for line in out[2:end]
             @test strwidth(line) <= cols
@@ -264,7 +268,8 @@ for d in (Dict("\n" => "\n", "1" => "\n", "\n" => "2"),
 
         for f in (keys, values)
             s = IOBuffer()
-            Base.showkv(s, f(d), limit=true, sz=(rows, cols))
+            io = Base.IOContext(Base.IOContext(s, :limit_output => true), :displaysize => (rows, cols))
+            Base.showkv(io, f(d))
             out = split(takebuf_string(s),'\n')
             for line in out[2:end]
                 @test strwidth(line) <= cols
@@ -273,7 +278,7 @@ for d in (Dict("\n" => "\n", "1" => "\n", "\n" => "2"),
         end
     end
     # Simply ensure these do not throw errors
-    Base.showdict(IOBuffer(), d, limit=false)
+    Base.showdict(IOBuffer(), d)
     @test !isempty(summary(d))
     @test !isempty(summary(keys(d)))
     @test !isempty(summary(values(d)))
@@ -282,17 +287,23 @@ end
 # issue #9463
 type Alpha end
 Base.show(io::IO, ::Alpha) = print(io,"α")
-sbuff = IOBuffer()
-Base.showdict(sbuff, Dict(Alpha()=>1), limit=true, sz=(10,20))
-@test !contains(bytestring(sbuff), "…")
+let sbuff = IOBuffer(),
+    io = Base.IOContext(Base.IOContext(sbuff, :limit_output => true), :displaysize => (10, 20))
+
+    Base.showdict(io, Dict(Alpha()=>1))
+    @test !contains(bytestring(sbuff), "…")
+    @test endswith(bytestring(sbuff), "α => 1")
+end
 
 # issue #2540
-d = Dict{Any,Any}([x => 1 for x in ['a', 'b', 'c']])
-@test d == Dict('a'=>1, 'b'=>1, 'c'=> 1)
+let d = Dict{Any,Any}([x => 1 for x in ['a', 'b', 'c']])
+    @test d == Dict('a'=>1, 'b'=>1, 'c'=> 1)
+end
 
 # issue #2629
-d = Dict{AbstractString,AbstractString}([ a => "foo" for a in ["a","b","c"]])
-@test d == Dict("a"=>"foo","b"=>"foo","c"=>"foo")
+let d = Dict{AbstractString,AbstractString}([ a => "foo" for a in ["a","b","c"]])
+    @test d == Dict("a"=>"foo","b"=>"foo","c"=>"foo")
+end
 
 # issue #5886
 d5886 = Dict()
@@ -327,17 +338,20 @@ let
 end
 
 # issue #10647
+type T10647{T}; x::T; end
 let
     a = ObjectIdDict()
     a[1] = a
     a[a] = 2
-    type T10647{T}; x::T; end
     a[3] = T10647(a)
+    @test a == a
     show(IOBuffer(), a)
+    Base.show(Base.IOContext(IOBuffer(), :limit_output => true), a)
     Base.showdict(IOBuffer(), a)
-    Base.showdict(IOBuffer(), a; limit=true)
+    Base.showdict(Base.IOContext(IOBuffer(), :limit_output => true), a)
 end
 
+
 # Issue #7944
 let d = Dict{Int,Int}()
     get!(d, 0) do
@@ -356,3 +370,100 @@ d = Dict('a'=>1, 'b'=>1, 'c'=> 3)
 @test_throws ArgumentError Dict(0)
 @test_throws ArgumentError Dict([1])
 @test_throws ArgumentError Dict([(1,2),0])
+
+# ImmutableDict
+import Base.ImmutableDict
+let d = ImmutableDict{UTF8String, UTF8String}(),
+    k1 = UTF8String("key1"),
+    k2 = UTF8String("key2"),
+    v1 = UTF8String("value1"),
+    v2 = UTF8String("value2"),
+    d1 = ImmutableDict(d, k1 => v1),
+    d2 = ImmutableDict(d1, k2 => v2),
+    d3 = ImmutableDict(d2, k1 => v2),
+    d4 = ImmutableDict(d3, k2 => v1),
+    dnan = ImmutableDict{UTF8String, Float64}(k2, NaN),
+    dnum = ImmutableDict(dnan, k2 => 1)
+
+    @test isempty(collect(d))
+    @test !isempty(collect(d1))
+    @test isempty(d)
+    @test !isempty(d1)
+    @test length(d) == 0
+    @test length(d1) == 1
+    @test length(d2) == 2
+    @test length(d3) == 3
+    @test length(d4) == 4
+    @test !(k1 in keys(d))
+    @test k1 in keys(d1)
+    @test k1 in keys(d2)
+    @test k1 in keys(d3)
+    @test k1 in keys(d4)
+
+    @test !haskey(d, k1)
+    @test haskey(d1, k1)
+    @test haskey(d2, k1)
+    @test haskey(d3, k1)
+    @test haskey(d4, k1)
+    @test !(k2 in keys(d1))
+    @test k2 in keys(d2)
+    @test !(k1 in values(d4))
+    @test v1 in values(d4)
+    @test collect(d1) == [Pair(k1, v1)]
+    @test collect(d4) == reverse([Pair(k1, v1), Pair(k2, v2), Pair(k1, v2), Pair(k2, v1)])
+    @test d1 == ImmutableDict(d, k1 => v1)
+    @test !((k1 => v2) in d2)
+    @test (k1 => v2) in d3
+    @test (k1 => v1) in d4
+    @test (k1 => v2) in d4
+    @test !in(k2 => "value2", d4, is)
+    @test in(k2 => v2, d4, is)
+    @test in(k2 => NaN, dnan, isequal)
+    @test in(k2 => NaN, dnan, is)
+    @test !in(k2 => NaN, dnan, ==)
+    @test !in(k2 => 1, dnum, is)
+    @test in(k2 => 1.0, dnum, is)
+    @test !in(k2 => 1, dnum, <)
+    @test in(k2 => 0, dnum, <)
+    @test get(d1, "key1", :default) === v1
+    @test get(d4, "key1", :default) === v2
+    @test get(d4, "foo", :default) === :default
+    @test get(d, k1, :default) === :default
+    @test d1["key1"] === v1
+    @test d4["key1"] === v2
+    @test copy(d4) === d4
+    @test copy(d) === d
+    @test similar(d3) === d
+    @test similar(d) === d
+
+    @test_throws KeyError d[k1]
+    @test_throws KeyError d1["key2"]
+end
+
+# filtering
+let d = Dict(zip(1:1000,1:1000)), f = (k,v) -> iseven(k)
+    @test filter(f, d) == filter!(f, copy(d)) ==
+          invoke(filter!, (Function, Associative), f, copy(d)) ==
+          Dict(zip(2:2:1000, 2:2:1000))
+end
+
+# issue #15077
+let badKeys = ASCIIString["FINO_emv5.0","FINO_ema0.1","RATE_ema1.0","NIBPM_ema1.0",
+                          "SAO2_emv5.0","O2FLOW_ema5.0","preop_Neuro/Psych_","gender_",
+                          "FIO2_ema0.1","PEAK_ema5.0","preop_Reproductive_denies","O2FLOW_ema0.1",
+                          "preop_Endocrine_denies","preop_Respiratory_",
+                          "NIBPM_ema0.1","PROPOFOL_MCG/KG/MIN_decay5.0","NIBPD_ema1.0","NIBPS_ema5.0",
+                          "anesthesiaStartTime","NIBPS_ema1.0","RESPRATE_ema1.0","PEAK_ema0.1",
+                          "preop_GU_denies","preop_Cardiovascular_","PIP_ema5.0","preop_ENT_denies",
+                          "preop_Skin_denies","preop_Renal_denies","asaCode_IIIE","N2OFLOW_emv5.0",
+                          "NIBPD_emv5.0", # <--- here is the key that we later can't find
+                          "NIBPM_ema5.0","preop_Respiratory_complete","ETCO2_ema5.0",
+                          "RESPRATE_ema0.1","preop_Functional Status_<2","preop_Renal_symptoms",
+                          "ECGRATE_ema5.0","FIO2_emv5.0","RESPRATE_emv5.0","7wu3ty0a4fs","BVO",
+                          "4UrCWXUsaT"]
+    d = Dict{AbstractString,Float64}()
+    for k in badKeys
+        d[k] = 1
+    end
+    @test d["NIBPD_emv5.0"] == 1
+end
diff --git a/test/docs.jl b/test/docs.jl
index 3566edcb0ae9a..deeb9e008969e 100644
--- a/test/docs.jl
+++ b/test/docs.jl
@@ -1,5 +1,26 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+import Base.Docs: meta, @var, DocStr, parsedoc
+
+# Test helpers.
+function docstrings_equal(d1, d2)
+    io1 = IOBuffer()
+    io2 = IOBuffer()
+    writemime(io1, MIME"text/markdown"(), d1)
+    writemime(io2, MIME"text/markdown"(), d2)
+    takebuf_string(io1) == takebuf_string(io2)
+end
+docstrings_equal(d1::DocStr, d2) = docstrings_equal(parsedoc(d1), d2)
+
+function docstring_startswith(d1, d2)
+    io1 = IOBuffer()
+    io2 = IOBuffer()
+    writemime(io1, MIME"text/markdown"(), d1)
+    writemime(io2, MIME"text/markdown"(), d2)
+    startswith(takebuf_string(io1), takebuf_string(io2))
+end
+docstring_startswith(d1::DocStr, d2) = docstring_startswith(parsedoc(d1), d2)
+
 @doc "Doc abstract type" ->
 abstract C74685 <: AbstractArray
 @test stringmime("text/plain", Docs.doc(C74685))=="Doc abstract type\n"
@@ -16,11 +37,11 @@ module ModuleMacroDoc
 macro m() end
 end
 
-@doc ("I am a module";) ModuleMacroDoc
-@doc ("I am a macro";)  :@ModuleMacroDoc.m
+@doc "I am a module" ModuleMacroDoc
+@doc "I am a macro"  :@ModuleMacroDoc.m
 
-@test (@doc ModuleMacroDoc)    == "I am a module"
-@test (@doc ModuleMacroDoc.@m) == "I am a macro"
+@test docstrings_equal(@doc(ModuleMacroDoc), doc"I am a module")
+@test docstrings_equal(@doc(ModuleMacroDoc.@m), doc"I am a macro")
 
 # General tests for docstrings.
 
@@ -76,9 +97,18 @@ end
 "TA"
 typealias TA Union{T, IT}
 
-"@mac"
+"@mac()"
 macro mac() end
 
+"@mac(x)"
+macro mac(x) end
+
+"@mac(x::Int, y::Expr, z = 0)"
+macro mac(x::Int, y::Expr, z = 0) end
+
+":@mac"
+:@mac
+
 "G"
 G = :G
 
@@ -126,79 +156,94 @@ end
 # value with no docs
 const val = Foo(1.0)
 
-end
-
-import Base.Docs: meta
+"doc multiple expressions"
+function multidoc  end,
+function multidoc! end
 
-function docstrings_equal(d1, d2)
-    io1 = IOBuffer()
-    io2 = IOBuffer()
-    writemime(io1, MIME"text/markdown"(), d1)
-    writemime(io2, MIME"text/markdown"(), d2)
-    takebuf_string(io1) == takebuf_string(io2)
 end
 
-@test meta(DocsTest)[DocsTest] == doc"DocsTest"
+@test docstrings_equal(@doc(DocsTest), doc"DocsTest")
 
 # Check that plain docstrings store a module reference.
 # https://github.com/JuliaLang/julia/pull/13017#issuecomment-138618663
-@test meta(DocsTest)[DocsTest].meta[:module] == DocsTest
+@test meta(DocsTest)[@var(DocsTest)].docs[Union{}].data[:module] == DocsTest
 
-let f = DocsTest.f
-    funcdoc = meta(DocsTest)[f]
-    @test funcdoc.main == nothing
-    @test docstrings_equal(funcdoc.meta[Tuple{Any}], doc"f-1")
-    @test docstrings_equal(funcdoc.meta[Tuple{Any,Any}], doc"f-2")
+let f = @var(DocsTest.f)
+    md = meta(DocsTest)[f]
+    @test docstrings_equal(md.docs[Tuple{Any}], doc"f-1")
+    @test docstrings_equal(md.docs[Tuple{Any,Any}], doc"f-2")
 end
 
-let s = DocsTest.s
-    funcdoc = meta(DocsTest)[s]
-    @test funcdoc.main == nothing
-    @test docstrings_equal(funcdoc.meta[Tuple{Any,}], doc"s-1")
-    @test docstrings_equal(funcdoc.meta[Tuple{Any,Any}], doc"s-2")
+let s = @var(DocsTest.s)
+    md = meta(DocsTest)[s]
+    @test docstrings_equal(md.docs[Tuple{Any,}], doc"s-1")
+    @test docstrings_equal(md.docs[Tuple{Any,Any}], doc"s-2")
 end
 
-let g = DocsTest.g
-    funcdoc = meta(DocsTest)[g]
-    @test docstrings_equal(funcdoc.meta[Union{}], doc"g")
+let g = @var(DocsTest.g)
+    md = meta(DocsTest)[g]
+    @test docstrings_equal(md.docs[Union{}], doc"g")
 end
 
-let h = DocsTest.h
-    funcdoc = meta(DocsTest)[h]
+let h = @var(DocsTest.h)
+    md = meta(DocsTest)[h]
     sig = Union{Tuple{}, Tuple{Any}, Tuple{Any, Any}, Tuple{Any, Any, Any}}
-    @test docstrings_equal(funcdoc.meta[sig], doc"h/0-3")
+    @test docstrings_equal(md.docs[sig], doc"h/0-3")
 end
 
-let AT = DocsTest.AT
-    @test meta(DocsTest)[AT] == doc"AT"
+let AT = @var(DocsTest.AT)
+    md = meta(DocsTest)[AT]
+    @test docstrings_equal(md.docs[Union{}], doc"AT")
 end
 
-let BT = DocsTest.BT
-    @test meta(DocsTest)[BT] == doc"BT"
+let BT = @var(DocsTest.BT)
+    md = meta(DocsTest)[BT]
+    @test docstrings_equal(md.docs[Union{}], doc"BT")
 end
 
-@test meta(DocsTest)[DocsTest.BT2] == doc"BT2"
+let BT2 = @var(DocsTest.BT2)
+    md = meta(DocsTest)[BT2]
+    @test docstrings_equal(md.docs[Union{}], doc"BT2")
+end
 
-let T = DocsTest.T
-    typedoc = meta(DocsTest)[T]
-    @test docstrings_equal(typedoc.main, doc"T")
-    @test docstrings_equal(typedoc.fields[:x], doc"T.x")
-    @test docstrings_equal(typedoc.fields[:y], doc"T.y")
+let T = @var(DocsTest.T)
+    md = meta(DocsTest)[T]
+    d  = md.docs[Union{}]
+    @test docstrings_equal(d, doc"T")
+    @test d.data[:fields][:x] == "T.x"
+    @test d.data[:fields][:y] == "T.y"
 end
 
-let IT = DocsTest.IT
-    typedoc = meta(DocsTest)[IT]
-    @test docstrings_equal(typedoc.main, doc"IT")
-    @test docstrings_equal(typedoc.fields[:x], doc"IT.x")
-    @test docstrings_equal(typedoc.fields[:y], doc"IT.y")
+let IT = @var(DocsTest.IT)
+    md = meta(DocsTest)[IT]
+    d  = md.docs[Union{}]
+    @test docstrings_equal(d, doc"IT")
+    @test d.data[:fields][:x] == "IT.x"
+    @test d.data[:fields][:y] == "IT.y"
 end
 
-@test @doc(DocsTest.TA) == doc"TA"
+@test docstrings_equal(@doc(DocsTest.TA), doc"TA")
+
+@test docstrings_equal(@doc(DocsTest.@mac), doc"@mac()")
+@test docstrings_equal(@doc(DocsTest.@mac()), doc"@mac()")
+@test docstrings_equal(@doc(DocsTest.@mac(x)), doc"@mac(x)")
+@test docstrings_equal(@doc(DocsTest.@mac(x::Int, y::Expr)), doc"@mac(x::Int, y::Expr, z = 0)")
+@test docstrings_equal(@doc(DocsTest.@mac(x::Int, y::Expr, z)), doc"@mac(x::Int, y::Expr, z = 0)")
+let m = doc"""
+        @mac()
 
-@test @doc(DocsTest.@mac) == doc"@mac"
+        @mac(x)
 
-@test @doc(DocsTest.G) == doc"G"
-@test @doc(DocsTest.K) == doc"K"
+        @mac(x::Int, y::Expr, z = 0)
+
+        :@mac
+        """
+    @test docstrings_equal(@doc(:@DocsTest.mac), m)
+    @test docstrings_equal(@doc(:(DocsTest.@mac)), m)
+end
+
+@test docstrings_equal(@doc(DocsTest.G), doc"G")
+@test docstrings_equal(@doc(DocsTest.K), doc"K")
 
 let d1 = @doc(DocsTest.t(::AbstractString)),
     d2 = doc"t-1"
@@ -220,11 +265,16 @@ let d1 = @doc(DocsTest.t{S <: Integer}(::S)),
     @test docstrings_equal(d1,d2)
 end
 
-let fields = meta(DocsTest)[DocsTest.FieldDocs].fields
-    @test haskey(fields, :one) && fields[:one] == doc"one"
+let fields = meta(DocsTest)[@var(DocsTest.FieldDocs)].docs[Union{}].data[:fields]
+    @test haskey(fields, :one) && fields[:one] == "one"
     @test haskey(fields, :two) && fields[:two] == doc"two"
 end
 
+let a = @doc(DocsTest.multidoc),
+    b = @doc(DocsTest.multidoc!)
+    @test docstrings_equal(a, b)
+end
+
 "BareModule"
 baremodule BareModule
 
@@ -264,14 +314,68 @@ end
 @test docstrings_equal(@doc(BareModule.A), doc"A")
 @test docstrings_equal(@doc(BareModule.T), doc"T")
 
+@test_throws ErrorException @doc("...", "error")
+@test_throws ErrorException @doc("...", @time 0)
+
 # test that when no docs exist, they fallback to
 # the docs for the typeof(value)
 let d1 = @doc(DocsTest.val)
     @test d1 !== nothing
 end
 
+# Document specific expressions generated by macro calls.
+module MacroGenerated
+
+import Base.@__doc__
+
+macro example_1(f)
+    quote
+        $(f)() = 0
+        @__doc__ $(f)(x) = x
+        $(f)(x, y) = x + y
+    end |> esc
+end
+
+"f"
+@example_1 f
+
+@example_1 _f
+
+macro example_2(f)
+    quote
+        $(f)() = 0
+        @__doc__ $(f)(x) = x
+        @__doc__ $(f)(x, y) = x + y
+    end |> esc
+end
+
+"g"
+@example_2 g
+
+@example_2 _g
+
+end
+
+let md = meta(MacroGenerated)[@var(MacroGenerated.f)]
+    @test md.order == [Tuple{Any}]
+    @test docstrings_equal(md.docs[Tuple{Any}], doc"f")
+end
+
+@test isdefined(MacroGenerated, :_f)
+
+let md = meta(MacroGenerated)[@var(MacroGenerated.g)]
+    @test md.order == [Tuple{Any}, Tuple{Any, Any}]
+    @test docstrings_equal(md.docs[Tuple{Any}], doc"g")
+    @test docstrings_equal(md.docs[Tuple{Any, Any}], doc"g")
+end
+
+@test isdefined(MacroGenerated, :_g)
+
+# Issue #13385.
+@test @doc(I) !== nothing
+
 # Issue #12700.
-@test @doc(DocsTest.@m) == doc"Inner.@m"
+@test docstrings_equal(@doc(DocsTest.@m), doc"Inner.@m")
 
 # issue 11993
 # Check if we are documenting the expansion of the macro
@@ -284,14 +388,11 @@ end
 
 @doc "This should document @m1... since its the result of expansion" @m2_11993
 @test (@doc @m1_11993) !== nothing
-let d = (@doc @m2_11993)
-    @test docstrings_equal(d, doc"""
+let d = (@doc :@m2_11993)
+    @test docstring_startswith(d, doc"""
     No documentation found.
 
-    ```julia
-    @m2_11993()
-    ```
-    """)
+    `@m2_11993` is a macro.""")
 end
 
 @doc "Now @m2... should be documented" :@m2_11993
@@ -320,8 +421,8 @@ read(x) = x
 
 end
 
-let fd = Base.Docs.meta(I11798)[I11798.read],
-    d1 = fd.meta[fd.order[1]],
+let md = Base.Docs.meta(I11798)[@var(I11798.read)],
+    d1 = md.docs[md.order[1]],
     d2 = doc"read"
     @test docstrings_equal(d1,d2)
 end
@@ -335,7 +436,7 @@ Base.collect{T}(::Type{EmptyType{T}}) = "borked"
 
 end
 
-let fd = meta(I12515)[Base.collect]
+let fd = meta(I12515)[@var(Base.collect)]
     @test fd.order[1] == Tuple{Type{I12515.EmptyType{TypeVar(:T, Any, true)}}}
 end
 
@@ -350,7 +451,7 @@ f12593_2() = 1
 @test (@doc f12593_1) !== nothing
 @test (@doc f12593_2) !== nothing
 
-@test Docs.doc(svdvals, Tuple{Vector{Float64}}) === nothing
+# @test Docs.doc(svdvals, Tuple{Vector{Float64}}) === nothing
 @test Docs.doc(svdvals, Tuple{Float64}) !== nothing
 
 # crude test to make sure we sort docstring output by method specificity
@@ -358,10 +459,20 @@ f12593_2() = 1
                         Docs.doc(getindex, Tuple{Type{Int64},Int}))
 
 # test that macro documentation works
-@test (Docs.@repl @assert) !== nothing
+@test (Docs.@repl :@assert) !== nothing
+
+@test (Docs.@repl 0) !== nothing
+
+let t = @doc(DocsTest.t(::Int, ::Int))
+    @test docstrings_equal(Docs.@repl(DocsTest.t(0, 0)), t)
+    @test docstrings_equal(Docs.@repl(DocsTest.t(::Int, ::Int)), t)
+end
+
+# Issue #13467.
+@test (Docs.@repl :@r_str) !== nothing
 
 # Simple tests for apropos:
-@test contains(sprint(apropos, "pearson"), "cov")
+@test contains(sprint(apropos, "pearson"), "cor")
 @test contains(sprint(apropos, r"ind(exes|ices)"), "eachindex")
 @test contains(sprint(apropos, "print"), "Profile.print")
 
@@ -405,7 +516,16 @@ end
 )
 @test docstrings_equal(Docs.doc(I13068.A.foo, Tuple{Int}), doc"foo from A")
 @test docstrings_equal(Docs.doc(I13068.A.foo, Tuple{Float64}), doc"foo from B")
-@test Docs.doc(I13068.A.foo, Tuple{Char}) === nothing
+@test docstrings_equal(Docs.doc(I13068.A.foo, Tuple{Char}),
+    doc"""
+    foo from A
+
+    foo from B
+    """
+)
+
+# Issue #13905.
+@test macroexpand(:(@doc "" f() = @x)) == Expr(:error, UndefVarError(symbol("@x")))
 
 # Undocumented DataType Summaries.
 
@@ -430,16 +550,22 @@ undocumented(x,y) = 3
 
 end
 
+@test docstrings_equal(@doc(Undocumented.bindingdoesnotexist), doc"""
+No documentation found.
+
+Binding `Undocumented.bindingdoesnotexist` does not exist.
+""")
+
 @test docstrings_equal(@doc(Undocumented.A), doc"""
 No documentation found.
 
 **Summary:**
-```julia
+```
 abstract Undocumented.A <: Any
 ```
 
 **Subtypes:**
-```julia
+```
 Undocumented.B
 Undocumented.C
 ```
@@ -449,12 +575,12 @@ Undocumented.C
 No documentation found.
 
 **Summary:**
-```julia
+```
 abstract Undocumented.B <: Undocumented.A
 ```
 
 **Subtypes:**
-```julia
+```
 Undocumented.D
 ```
 """)
@@ -463,7 +589,7 @@ Undocumented.D
 No documentation found.
 
 **Summary:**
-```julia
+```
 type Undocumented.C <: Undocumented.A
 ```
 """)
@@ -472,12 +598,12 @@ type Undocumented.C <: Undocumented.A
 No documentation found.
 
 **Summary:**
-```julia
+```
 immutable Undocumented.D <: Undocumented.B
 ```
 
 **Fields:**
-```julia
+```
 one   :: Any
 two   :: UTF8String
 three :: Float64
@@ -490,7 +616,7 @@ let d = @doc Undocumented.f
     @test startswith(takebuf_string(io),"""
     No documentation found.
 
-    `Undocumented.f` is an anonymous `Function`.
+    `Undocumented.f` is a `Function`.
     """)
 end
 
@@ -500,22 +626,53 @@ let d = @doc Undocumented.undocumented
     @test startswith(takebuf_string(io), """
     No documentation found.
 
-    `Undocumented.undocumented` is a generic `Function`.
+    `Undocumented.undocumented` is a `Function`.
     """)
 end
 
+# `@doc` "metadata".
+
+let m = @doc(DocsTest).meta
+    @test length(m[:results]) == 1
+    @test m[:results][1] === Docs.meta(DocsTest)[@var(DocsTest)].docs[Union{}]
+    @test m[:binding] == @var(DocsTest)
+    @test m[:typesig] == Union
+end
+
+let m = @doc(DocsTest.f).meta
+    @test length(m[:results]) == 2
+    @test m[:results][1] === Docs.meta(DocsTest)[@var(DocsTest.f)].docs[Tuple{Any}]
+    @test m[:results][2] === Docs.meta(DocsTest)[@var(DocsTest.f)].docs[Tuple{Any, Any}]
+    @test m[:binding] == @var(DocsTest.f)
+    @test m[:typesig] == Union
+end
+
+let m = @doc(DocsTest.f(x)).meta
+    @test length(m[:results]) == 1
+    @test m[:results][1] === Docs.meta(DocsTest)[@var(DocsTest.f)].docs[Tuple{Any}]
+    @test m[:binding] == @var(DocsTest.f)
+    @test m[:typesig] == Tuple{Any}
+end
+
+let m = @doc(Undocumented.f).meta
+    @test isempty(m[:results])
+    @test m[:binding] == @var(Undocumented.f)
+    @test m[:typesig] == Union
+end
 
 # Bindings.
 
-import Base.Docs: @var, Binding
+import Base.Docs: @var, Binding, defined
 
 let x = Binding(Base, symbol("@time"))
+    @test defined(x) == true
     @test @var(@time) == x
     @test @var(Base.@time) == x
     @test @var(Base.Pkg.@time) == x
 end
 
 let x = Binding(Base.LinAlg, :norm)
+    @test defined(x) == true
     @test @var(norm) == x
     @test @var(Base.norm) == x
     @test @var(Base.LinAlg.norm) == x
@@ -523,6 +680,7 @@ let x = Binding(Base.LinAlg, :norm)
 end
 
 let x = Binding(Core, :Int)
+    @test defined(x) == true
     @test @var(Int) == x
     @test @var(Base.Int) == x
     @test @var(Core.Int) == x
@@ -530,12 +688,43 @@ let x = Binding(Core, :Int)
 end
 
 let x = Binding(Base, :Pkg)
+    @test defined(x) == true
     @test @var(Pkg) == x
     @test @var(Base.Pkg) == x
     @test @var(Main.Pkg) == x
 end
 
 let x = Binding(Base, :VERSION)
+    @test defined(x) == true
     @test @var(VERSION) == x
     @test @var(Base.VERSION) == x
 end
+
+let x = Binding(Base, :bindingdoesnotexist)
+    @test defined(x) == false
+    @test @var(Base.bindingdoesnotexist) == x
+end
+
+let x = Binding(Main, :bindingdoesnotexist)
+    @test defined(x) == false
+    @test @var(bindingdoesnotexist) == x
+end
+
+# Docs.helpmode tests: we test whether the correct expressions are being generated here,
+# rather than complete integration with Julia's REPL mode system.
+for (line, expr) in Pair[
+    "sin"          => :sin,
+    "Base.sin"     => :(Base.sin),
+    "@time(x)"     => :(@time(x)),
+    "@time"        => :(:@time),
+    ":@time"       => :(:@time),
+    "@time()"      => :(@time),
+    "Base.@time()" => :(Base.@time),
+    "ccall"        => :ccall, # keyword
+    "while       " => :while, # keyword, trailing spaces should be stripped.
+    "0"            => 0,
+    "\"...\""      => "...",
+    "r\"...\""     => :(r"..."),
+    ]
+    @test Docs.helpmode(line) == :(Base.Docs.@repl($expr))
+end
diff --git a/test/enums.jl b/test/enums.jl
index 15bd35b22baaa..7a8ff2feee99e 100644
--- a/test/enums.jl
+++ b/test/enums.jl
@@ -152,9 +152,11 @@ end
 # test for unique Enum values
 @test_throws ArgumentError eval(:(@enum(Test14, _zero_Test14, _one_Test14, _two_Test14=0)))
 
-@test repr(apple) == "apple::"*string(Fruit)
+@test repr(apple) == "apple::$(string(Fruit)) = 0"
 @test string(apple) == "apple"
 
+@test reprmime("text/plain", Fruit) == "Enum $(string(Fruit)):\napple = 0\norange = 1\nkiwi = 2"
+
 @enum LogLevel DEBUG INFO WARN ERROR CRITICAL
 @test DEBUG < CRITICAL
 
diff --git a/test/euler.jl b/test/euler.jl
index 06734d8d849d6..b3aef922012ab 100644
--- a/test/euler.jl
+++ b/test/euler.jl
@@ -254,10 +254,7 @@ end
 #21: 31626
 #22: 871198282
 #23: 4179871
-
 #24: 2783915460
-@test nthperm!([0:9;],1000000) == [2,7,8,3,9,1,5,4,6,0]
-
 #25: 4782
 #26: 983
 #27: -59231
diff --git a/test/examples.jl b/test/examples.jl
index 0425fa15aace0..9c8b4a7b543d6 100644
--- a/test/examples.jl
+++ b/test/examples.jl
@@ -39,25 +39,22 @@ include(joinpath(dir, "queens.jl"))
 @unix_only begin
     script = joinpath(dir, "clustermanager/simple/test_simple.jl")
     cmd = `$(Base.julia_cmd()) $script`
-
-    (strm, proc) = open(cmd)
-    errors = readall(strm)
-    wait(proc)
-    if !success(proc) && ccall(:jl_running_on_valgrind,Cint,()) == 0
-        println(errors);
+    if !success(pipeline(cmd; stdout=STDOUT, stderr=STDERR)) && ccall(:jl_running_on_valgrind,Cint,()) == 0
         error("UnixDomainCM failed test, cmd : $cmd")
     end
 end
 
 dc_path = joinpath(dir, "dictchannel.jl")
-include(dc_path)
-
-w_set=filter!(x->x != myid(), workers())
-pid = length(w_set) > 0 ? w_set[1] : myid()
+myid() == 1 || include(dc_path)
 
-remotecall_fetch(pid, f->(include(f); nothing), dc_path)
-dc=RemoteRef(()->DictChannel(), pid)
-@test typeof(dc) == RemoteRef{DictChannel}
+# Run the remote on pid 1, since runtests may terminate workers
+# at any time depending on memory usage
+remotecall_fetch(1, dc_path) do f
+    include(f)
+    nothing
+end
+dc=RemoteChannel(()->DictChannel(), 1)
+@test typeof(dc) == RemoteChannel{DictChannel}
 
 @test isready(dc) == false
 put!(dc, 1, 2)
diff --git a/test/fastmath.jl b/test/fastmath.jl
index 98315ff146cbb..ccd4532071990 100644
--- a/test/fastmath.jl
+++ b/test/fastmath.jl
@@ -2,6 +2,14 @@
 
 # fast math
 
+# check expansions
+
+@test macroexpand(:(@fastmath 1+2)) == :(Base.FastMath.add_fast(1,2))
+@test macroexpand(:(@fastmath +)) == :(Base.FastMath.add_fast)
+@test macroexpand(:(@fastmath min(1))) == :(Base.FastMath.min_fast(1))
+@test macroexpand(:(@fastmath min)) == :(Base.FastMath.min_fast)
+@test macroexpand(:(@fastmath x.min)) == :(x.min)
+
 # basic arithmetic
 
 const one32 = one(Float32)
diff --git a/test/file.jl b/test/file.jl
index ed3a385229bbd..c316a4c6c0a55 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -13,6 +13,16 @@ subdir = joinpath(dir, "adir")
 mkdir(subdir)
 subdir2 = joinpath(dir, "adir2")
 mkdir(subdir2)
+@test_throws SystemError mkdir(file)
+let err = nothing
+    try
+        mkdir(file)
+    catch err
+        io = IOBuffer()
+        showerror(io, err)
+        @test startswith(takebuf_string(io), "SystemError (with $file): mkdir:")
+    end
+end
 
 if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
     dirlink = joinpath(dir, "dirlink")
@@ -46,13 +56,50 @@ end
 @test !isdir(file)
 @test isfile(file)
 @test !islink(file)
-@test isreadable(file)
-@test iswritable(file)
+
+@test filemode(file) & 0o444 > 0 # readable
+@test filemode(file) & 0o222 > 0 # writable
 chmod(file, filemode(file) & 0o7555)
-@test !iswritable(file)
+@test filemode(file) & 0o222 == 0
 chmod(file, filemode(file) | 0o222)
-@test !isexecutable(file)
+@test filemode(file) & 0o111 == 0
 @test filesize(file) == 0
+
+@windows_only begin
+    permissions = 0o444
+    @test filemode(dir) & 0o777 != permissions
+    @test filemode(subdir) & 0o777 != permissions
+    @test filemode(file) & 0o777 != permissions
+    chmod(dir, permissions, recursive=true)
+    @test filemode(dir) & 0o777 == permissions
+    @test filemode(subdir) & 0o777 == permissions
+    @test filemode(file) & 0o777 == permissions
+    chmod(dir, 0o666, recursive=true)  # Reset permissions in case someone wants to use these later
+end
+@unix_only begin
+    mktempdir() do tmpdir
+        tmpfile=joinpath(tmpdir, "tempfile.txt")
+        touch(tmpfile)
+        chmod(tmpfile, 0o707)
+        linkfile=joinpath(dir, "tempfile.txt")
+        symlink(tmpfile, linkfile)
+        permissions=0o776
+        @test filemode(dir) & 0o777 != permissions
+        @test filemode(subdir) & 0o777 != permissions
+        @test filemode(file) & 0o777 != permissions
+        @test filemode(linkfile) & 0o777 != permissions
+        @test filemode(tmpfile) & 0o777 != permissions
+        chmod(dir, permissions, recursive=true)
+        @test filemode(dir) & 0o777 == permissions
+        @test filemode(subdir) & 0o777 == permissions
+        @test filemode(file) & 0o777 == permissions
+        @test lstat(link).mode & 0o777 != permissions  # Symbolic links are not modified.
+        @test filemode(linkfile) & 0o777 != permissions  # Symbolic links are not followed.
+        @test filemode(tmpfile) & 0o777 != permissions
+        rm(linkfile)
+    end
+end
+
 # On windows the filesize of a folder is the accumulation of all the contained
 # files and is thus zero in this case.
 @windows_only @test filesize(dir) == 0
@@ -89,6 +136,7 @@ cp(newfile, c_file)
 @test isdir(c_subdir)
 @test isfile(c_file)
 @test_throws SystemError rm(c_tmpdir)
+@test_throws SystemError rm(c_tmpdir, force=true)
 
 # create temp dir in specific directory
 d_tmpdir = mktempdir(c_tmpdir)
@@ -103,7 +151,27 @@ close(f)
 
 rm(c_tmpdir, recursive=true)
 @test !isdir(c_tmpdir)
+@test_throws Base.UVError rm(c_tmpdir)
+@test rm(c_tmpdir, force=true) === nothing
+@test_throws Base.UVError rm(c_tmpdir, recursive=true)
+@test rm(c_tmpdir, force=true, recursive=true) === nothing
+
+# chown will give an error if the user does not have permissions to change files
+@unix_only if get(ENV, "USER", "") == "root"
+    chown(file, -2, -1)  # Change the file owner to nobody
+    @test stat(file).uid !=0
+    chown(file, 0, -2)  # Change the file group to nogroup (and owner back to root)
+    @test stat(file).gid !=0
+    @test stat(file).uid ==0
+    chown(file, -1, 0)
+    @test stat(file).gid ==0
+    @test stat(file).uid ==0
+else
+    @test_throws Base.UVError chown(file, -2, -1)  # Non-root user cannot change ownership to another user
+    @test_throws Base.UVError chown(file, -1, -2)  # Non-root user cannot change group to a group they are not a member of (eg: nogroup)
+end
 
+@windows_only @test chown(file, -2, -2) == nothing  # chown shouldn't cause any errors for Windows
 
 #######################################################################
 # This section tests file watchers.                                   #
@@ -145,6 +213,7 @@ function test_monitor_wait(tval)
         close(f)
     end
     fname, events = wait(fm)
+    close(fm)
     @test fname == basename(file)
     @test events.changed
 end
@@ -158,6 +227,7 @@ function test_monitor_wait_poll()
         close(f)
     end
     (old, new) = wait(pfw)
+    close(pfw)
     @test new.mtime - old.mtime > 2.5 - 1.5 # mtime may only have second-level accuracy (plus add some hysteresis)
 end
 
@@ -216,7 +286,7 @@ path = tempname()
 print(f, "Here is some text")
 close(f)
 @test isfile(p) == true
-@test readall(p) == "Here is some text"
+@test readstring(p) == "Here is some text"
 rm(p)
 
 let
@@ -284,7 +354,7 @@ function check_cp(orig_path::AbstractString, copied_path::AbstractString, follow
                 # copied_path must also be a file.
                 @test isfile(copied_path)
                 # copied_path must have same content
-                @test readall(orig_path) == readall(copied_path)
+                @test readstring(orig_path) == readstring(copied_path)
             end
         end
     elseif isdir(orig_path)
@@ -293,7 +363,7 @@ function check_cp(orig_path::AbstractString, copied_path::AbstractString, follow
         # copied_path must also be a file.
         @test isfile(copied_path)
         # copied_path must have same content
-        @test readall(orig_path) == readall(copied_path)
+        @test readstring(orig_path) == readstring(copied_path)
     end
 end
 
@@ -322,9 +392,7 @@ bfile = joinpath(dir, "b.txt")
 cp(afile, bfile)
 
 cfile = joinpath(dir, "c.txt")
-open(cfile, "w") do cf
-    write(cf, "This is longer than the contents of afile")
-end
+write(cfile, "This is longer than the contents of afile")
 cp(afile, cfile; remove_destination=true)
 
 a_stat = stat(afile)
@@ -395,13 +463,9 @@ if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
 
         cfile = joinpath(srcdir, "c.txt")
         file_txt = "This is some text with unicode - 这是一个文件"
-        open(cfile, "w") do cf
-            write(cf, file_txt)
-        end
+        write(cfile, file_txt)
         hidden_cfile = joinpath(hidden_srcsubdir, "c.txt")
-        open(hidden_cfile, "w") do cf
-            write(cf, file_txt)
-        end
+        write(hidden_cfile, file_txt)
 
         abs_dirlink_cp = joinpath(tmpdir, "abs_dirlink_cp")
         hidden_srcsubdir_cp = joinpath(tmpdir, ".hidden_srcsubdir_cp")
@@ -528,12 +592,9 @@ if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
         mkdir(subdir1)
 
         cfile = abspath(joinpath(maindir, "c.txt"))
-        open(cfile, "w") do cf
-            write(cf, "This is c.txt - 这是一个文件")
-        end
-        open(abspath(joinpath(targetdir, "file1.txt")), "w") do cf
-            write(cf, "This is file1.txt - 这是一个文件")
-        end
+        write(cfile, "This is c.txt - 这是一个文件")
+        write(abspath(joinpath(targetdir, "file1.txt")),
+              "This is file1.txt - 这是一个文件")
 
         abs_dl = joinpath(maindir, "abs_linkto_targetdir")
         symlink(targetdir, abs_dl)
@@ -601,12 +662,8 @@ end
         srcfile_new = joinpath(tmpdir, "srcfile_new.txt")
         hidden_srcfile_new = joinpath(tmpdir, ".hidden_srcfile_new.txt")
         file_txt = "This is some text with unicode - 这是一个文件"
-        open(srcfile, "w") do f
-            write(f, file_txt)
-        end
-        open(hidden_srcfile, "w") do f
-            write(f, file_txt)
-        end
+        write(srcfile, file_txt)
+        write(hidden_srcfile, file_txt)
         abs_filelink = joinpath(tmpdir, "abs_filelink")
         symlink(abspath(srcfile), abs_filelink)
         cd(tmpdir)
@@ -630,7 +687,7 @@ end
         islink(s) && @test readlink(s) == readlink(d)
         islink(s) && @test isabspath(readlink(s)) == isabspath(readlink(d))
         # all should contain the same
-        @test readall(s) == readall(d) == file_txt
+        @test readstring(s) == readstring(d) == file_txt
     end
 
     function mv_check(s, d, d_mv, file_txt; remove_destination=true)
@@ -648,7 +705,7 @@ end
         islink(s) && @test readlink(s) == readlink(d_mv)
         islink(s) && @test isabspath(readlink(s)) == isabspath(readlink(d_mv))
         # all should contain the same
-        @test readall(s) == readall(d_mv) == file_txt
+        @test readstring(s) == readstring(d_mv) == file_txt
         # d => d_mv same file/dir
         @test Base.samefile(stat_d, stat_d_mv)
     end
@@ -686,15 +743,13 @@ end
         # Test remove the existing path first and copy an other file
         otherfile = joinpath(tmpdir, "otherfile.txt")
         otherfile_content = "This is otherfile.txt with unicode - 这是一个文件"
-        open(otherfile, "w") do f
-            write(f, otherfile_content)
-        end
+        write(otherfile, otherfile_content)
         for d in test_new_paths1
             cp(otherfile, d; remove_destination=true, follow_symlinks=false)
             # Expect no link because a file is copied (follow_symlinks=false does not effect this)
             @test isfile(d) && !islink(d)
             # all should contain otherfile_content
-            @test readall(d) == otherfile_content
+            @test readstring(d) == otherfile_content
         end
     end
     # mv ----------------------------------------------------
@@ -738,12 +793,9 @@ end
         mkdir(subdir1)
 
         cfile = abspath(joinpath(maindir, "c.txt"))
-        open(cfile, "w") do cf
-            write(cf, "This is c.txt - 这是一个文件")
-        end
-        open(abspath(joinpath(targetdir, "file1.txt")), "w") do cf
-            write(cf, "This is file1.txt - 这是一个文件")
-        end
+        write(cfile, "This is c.txt - 这是一个文件")
+        write(abspath(joinpath(targetdir, "file1.txt")),
+                      "This is file1.txt - 这是一个文件")
 
         abs_fl = joinpath(maindir, "abs_linkto_c.txt")
         symlink(cfile, abs_fl)
@@ -757,7 +809,7 @@ end
         rel_dl = "rel_linkto_targetdir"
         rel_dir = joinpath("..", "targetdir")
         symlink(rel_dir, rel_dl)
-        rel_file_read_txt = readall(rel_file)
+        rel_file_read_txt = readstring(rel_file)
         cd(pwd_)
         # Setup copytodir
         copytodir = joinpath(tmpdir, "copytodir")
@@ -835,12 +887,12 @@ close(f)
 f = open(file, "r")
 test_LibcFILE(convert(Libc.FILE, f))
 close(f)
-@unix_only f = RawFD(ccall(:open, Cint, (Ptr{UInt8}, Cint), file, Base.FS.JL_O_RDONLY))
-@windows_only f = RawFD(ccall(:_open, Cint, (Ptr{UInt8}, Cint), file, Base.FS.JL_O_RDONLY))
+@unix_only f = RawFD(ccall(:open, Cint, (Ptr{UInt8}, Cint), file, Base.Filesystem.JL_O_RDONLY))
+@windows_only f = RawFD(ccall(:_open, Cint, (Ptr{UInt8}, Cint), file, Base.Filesystem.JL_O_RDONLY))
 test_LibcFILE(Libc.FILE(f,Libc.modestr(true,false)))
 
 # issue #10994: pathnames cannot contain embedded NUL chars
-for f in (mkdir, cd, Base.FS.unlink, readlink, rm, touch, readdir, mkpath, stat, lstat, ctime, mtime, filemode, filesize, uperm, gperm, operm, touch, isblockdev, ischardev, isdir, isexecutable, isfifo, isfile, islink, ispath, isreadable, issetgid, issetuid, issocket, issticky, iswritable, realpath, watch_file, poll_file)
+for f in (mkdir, cd, Base.Filesystem.unlink, readlink, rm, touch, readdir, mkpath, stat, lstat, ctime, mtime, filemode, filesize, uperm, gperm, operm, touch, isblockdev, ischardev, isdir, isfifo, isfile, islink, ispath, issetgid, issetuid, issocket, issticky, realpath, watch_file, poll_file)
     @test_throws ArgumentError f("adir\0bad")
 end
 @test_throws ArgumentError chmod("ba\0d", 0o222)
@@ -855,6 +907,107 @@ end
 @test_throws ArgumentError download("good", "ba\0d")
 @test_throws ArgumentError download("ba\0d", "good")
 
+###################
+#     walkdir     #
+###################
+
+dirwalk = mktempdir()
+cd(dirwalk) do
+    for i=1:2
+        mkdir("sub_dir$i")
+        open("file$i", "w") do f end
+
+        mkdir(joinpath("sub_dir1", "subsub_dir$i"))
+        touch(joinpath("sub_dir1", "file$i"))
+    end
+    touch(joinpath("sub_dir2", "file_dir2"))
+    has_symlinks = @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
+    follow_symlink_vec = has_symlinks ? [true, false] : [false]
+    has_symlinks && symlink(abspath("sub_dir2"), joinpath("sub_dir1", "link"))
+    for follow_symlinks in follow_symlink_vec
+        task = walkdir(".", follow_symlinks=follow_symlinks)
+        root, dirs, files = consume(task)
+        @test root == "."
+        @test dirs == ["sub_dir1", "sub_dir2"]
+        @test files == ["file1", "file2"]
+
+        root, dirs, files = consume(task)
+        @test root == joinpath(".", "sub_dir1")
+        @test dirs == (has_symlinks ? ["link", "subsub_dir1", "subsub_dir2"] : ["subsub_dir1", "subsub_dir2"])
+        @test files == ["file1", "file2"]
+
+        root, dirs, files = consume(task)
+        if follow_symlinks
+            @test root == joinpath(".", "sub_dir1", "link")
+            @test dirs == []
+            @test files == ["file_dir2"]
+            root, dirs, files = consume(task)
+        end
+        for i=1:2
+            @test root == joinpath(".", "sub_dir1", "subsub_dir$i")
+            @test dirs == []
+            @test files == []
+            root, dirs, files = consume(task)
+        end
+
+        @test root == joinpath(".", "sub_dir2")
+        @test dirs == []
+        @test files == ["file_dir2"]
+    end
+
+    for follow_symlinks in follow_symlink_vec
+        task = walkdir(".", follow_symlinks=follow_symlinks, topdown=false)
+        root, dirs, files = consume(task)
+        if follow_symlinks
+            @test root == joinpath(".", "sub_dir1", "link")
+            @test dirs == []
+            @test files == ["file_dir2"]
+            root, dirs, files = consume(task)
+        end
+        for i=1:2
+            @test root == joinpath(".", "sub_dir1", "subsub_dir$i")
+            @test dirs == []
+            @test files == []
+            root, dirs, files = consume(task)
+        end
+        @test root == joinpath(".", "sub_dir1")
+        @test dirs ==  (has_symlinks ? ["link", "subsub_dir1", "subsub_dir2"] : ["subsub_dir1", "subsub_dir2"])
+        @test files == ["file1", "file2"]
+
+        root, dirs, files = consume(task)
+        @test root == joinpath(".", "sub_dir2")
+        @test dirs == []
+        @test files == ["file_dir2"]
+
+        root, dirs, files = consume(task)
+        @test root == "."
+        @test dirs == ["sub_dir1", "sub_dir2"]
+        @test files == ["file1", "file2"]
+    end
+    #test of error handling
+    task_error = walkdir(".")
+    task_noerror = walkdir(".", onerror=x->x)
+    root, dirs, files = consume(task_error)
+    @test root == "."
+    @test dirs == ["sub_dir1", "sub_dir2"]
+    @test files == ["file1", "file2"]
+
+    rm(joinpath("sub_dir1"), recursive=true)
+    @test_throws SystemError consume(task_error) # throws an error because sub_dir1 do not exist
+
+    root, dirs, files = consume(task_noerror)
+    @test root == "."
+    @test dirs == ["sub_dir1", "sub_dir2"]
+    @test files == ["file1", "file2"]
+
+    root, dirs, files = consume(task_noerror) # skips sub_dir1 as it no longer exist
+    @test root == joinpath(".", "sub_dir2")
+    @test dirs == []
+    @test files == ["file_dir2"]
+
+end
+rm(dirwalk, recursive=true)
+
 ############
 # Clean up #
 ############
@@ -880,10 +1033,10 @@ let n = tempname()
     w = open(n, "a")
     io = open(n)
     write(w, "A"); flush(w)
-    @test readbytes(io) == UInt8[0x41]
-    @test readbytes(io) == UInt8[]
+    @test read(io) == UInt8[0x41]
+    @test read(io) == UInt8[]
     write(w, "A"); flush(w)
-    @test readbytes(io) == UInt8[0x41]
+    @test read(io) == UInt8[0x41]
     close(io); close(w)
     rm(n)
 end
@@ -922,3 +1075,24 @@ test_12992()
 test2_12992()
 test2_12992()
 test2_12992()
+
+# issue 13559
+
+function test_13559()
+    fn = tempname()
+    run(`mkfifo $fn`)
+    # use subprocess to write 127 bytes to FIFO
+    writer_cmds = "x=open(\"$fn\", \"w\"); for i=1:127 write(x,0xaa); flush(x); sleep(0.1) end; close(x); quit()"
+    open(pipeline(`$(Base.julia_cmd()) -e $writer_cmds`, stderr=STDERR))
+    #quickly read FIFO, draining it and blocking but not failing with EOFError yet
+    r = open(fn, "r")
+    # 15 proper reads
+    for i=1:15
+        @test read(r, Int64) == -6148914691236517206
+    end
+    # last read should throw EOFError when FIFO closes, since there are only 7 bytes available.
+    @test_throws EOFError read(r, Int64)
+    close(r)
+    rm(fn)
+end
+@unix_only test_13559()
diff --git a/test/float16.jl b/test/float16.jl
index 2cdd1b4a98f99..54bd3461759e8 100644
--- a/test/float16.jl
+++ b/test/float16.jl
@@ -23,6 +23,16 @@ g = Float16(1.)
 @test convert(Int128,Float16(-2.0)) == Int128(-2)
 @test convert(UInt128,Float16(2.0)) == UInt128(2)
 
+# convert(::Type{Int128},  x::Float16)
+@test convert(Int128, Float16(1.0)) === Int128(1.0)
+@test convert(Int128, Float16(-1.0)) === Int128(-1.0)
+@test_throws InexactError convert(Int128, Float16(3.5))
+
+# convert(::Type{UInt128}, x::Float16)
+@test convert(UInt128, Float16(1.0)) === UInt128(1.0)
+@test_throws InexactError convert(UInt128, Float16(3.5))
+@test_throws InexactError convert(UInt128, Float16(-1))
+
 x = Float32(rand())
 y = Float32(rand())
 z = Float32(rand())
diff --git a/test/floatfuncs.jl b/test/floatfuncs.jl
index e0d14096fa7ef..fc4a27f204fee 100644
--- a/test/floatfuncs.jl
+++ b/test/floatfuncs.jl
@@ -20,6 +20,21 @@ for elty in (Float16,Float32,Float64)
 end
 @test maxintfloat() == maxintfloat(Float64)
 
+# isinteger
+for elty in (Float16,Float32,Float64)
+    @test !isinteger(elty(1.2))
+    @test isinteger(elty(12))
+    @test isinteger(zero(elty))
+    @test isinteger(-zero(elty))
+    @test !isinteger(nextfloat(zero(elty)))
+    @test !isinteger(prevfloat(zero(elty)))
+    @test isinteger(maxintfloat(elty))
+    @test isinteger(-maxintfloat(elty))
+    @test !isinteger(elty(Inf))
+    @test !isinteger(-elty(Inf))
+    @test !isinteger(elty(NaN))
+end
+
 #num2hex
 for elty in (Float16,Float32,Float64)
     x = rand(elty)
diff --git a/test/functional.jl b/test/functional.jl
index 9df37f2d4c52f..826e4e8d2792c 100644
--- a/test/functional.jl
+++ b/test/functional.jl
@@ -42,6 +42,22 @@ end
 # issue #4718
 @test collect(filter(x->x[1], zip([true, false, true, false],"abcd"))) == [(true,'a'),(true,'c')]
 
+let z = zip(1:2)
+    @test collect(z) == [(1,), (2,)]
+    # Issue #13979
+    @test eltype(z) == Tuple{Int}
+end
+
+let z = zip(1:2, 3:4)
+    @test collect(z) == [(1,3), (2,4)]
+    @test eltype(z) == Tuple{Int,Int}
+end
+
+let z = zip(1:2, 3:4, 5:6)
+    @test collect(z) == [(1,3,5), (2,4,6)]
+    @test eltype(z) == Tuple{Int,Int,Int}
+end
+
 # enumerate (issue #6284)
 let b = IOBuffer("1\n2\n3\n"), a = []
     for (i,x) in enumerate(eachline(b))
@@ -138,3 +154,53 @@ let i = 0
         i <= 10 || break
     end
 end
+
+# product
+# -------
+
+@test isempty(Base.product(1:2,1:0))
+@test isempty(Base.product(1:2,1:0,1:10))
+@test isempty(Base.product(1:2,1:10,1:0))
+@test isempty(Base.product(1:0,1:2,1:10))
+@test collect(Base.product(1:2,3:4)) == [(1,3),(2,3),(1,4),(2,4)]
+@test isempty(collect(Base.product(1:0,1:2)))
+@test length(Base.product(1:2,1:10,4:6)) == 60
+
+# foreach
+let
+    a = []
+    foreach(()->push!(a,0))
+    @test a == [0]
+    a = []
+    foreach(x->push!(a,x), [1,5,10])
+    @test a == [1,5,10]
+    a = []
+    foreach((args...)->push!(a,args), [2,4,6], [10,20,30])
+    @test a == [(2,10),(4,20),(6,30)]
+end
+
+# generators (#4470, #14848)
+
+@test sum(i/2 for i=1:2) == 1.5
+@test collect(2i for i=2:5) == [4,6,8,10]
+@test collect((i+10j for i=1:2,j=3:4)) == [31 41; 32 42]
+@test collect((i+10j for i=1:2,j=3:4,k=1:1)) == reshape([31 41; 32 42], (2,2,1))
+
+let I = Base.IteratorND(1:27,(3,3,3))
+    @test collect(I) == reshape(1:27,(3,3,3))
+    @test size(I) == (3,3,3)
+    @test length(I) == 27
+    @test eltype(I) === Int
+    @test ndims(I) == 3
+end
+
+let A = collect(Base.Generator(x->2x, Real[1.5,2.5]))
+    @test A == [3,5]
+    @test isa(A,Vector{Float64})
+end
+
+let f(g) = (@test size(g.iter)==(2,3))
+    f(i+j for i=1:2, j=3:5)
+end
+
+@test_throws DimensionMismatch Base.IteratorND(1:2, (2,3))
diff --git a/test/git.jl b/test/git.jl
deleted file mode 100644
index a5e5ed7a2673e..0000000000000
--- a/test/git.jl
+++ /dev/null
@@ -1,39 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-import Base.Git
-include("gitutils.jl")
-
-@test Git.version() >= v"1.7.3"
-
-dir = string("tmp.",randstring())
-@test !ispath(dir)
-mkdir(dir)
-@test isdir(dir)
-try cd(dir) do
-
-    run(`git init -q`)
-    run(`git config user.name "Julia Tester"`)
-    run(`git config user.email test@julialang.org`)
-    run(`git commit -q --allow-empty -m "initial empty commit"`)
-    git_verify(Dict(), Dict(), Dict())
-
-    # each path can have one of these content in each of head, index, work
-    # for a total of length(contents)^3 = 4^3 = 64 combinations.
-    # each path can be in any of these 64 "superpositions" before & after
-    # for a total of 64^2 = 4096 files needed to test all transitions
-    # between before and after superpositions of git repo states.
-
-    contents = [nothing, "foo", "bar", Dict{Any,Any}("baz"=>"qux")]
-    b = length(contents)
-    states = [ [ base(b,k,6) => contents[rem(div(k,b^p),b)+1] for k=0:(b^3)^2-1 ] for p=0:5 ]
-
-    git_setup(states[1:3]...)
-    try Git.transact() do
-        git_setup(states[4:6]...)
-        throw(nothing)
-    end catch x
-        is(x,nothing) || rethrow()
-    end
-    git_verify(states[1:3]...)
-
-end finally rm(dir, recursive=true) end
diff --git a/test/gitutils.jl b/test/gitutils.jl
deleted file mode 100644
index 9485719ebf880..0000000000000
--- a/test/gitutils.jl
+++ /dev/null
@@ -1,114 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-function write_and_readchomp(data, cmd::Cmd)
-    r, w, p = readandwrite(cmd)
-    print(w,data); close(w)
-    v = readchomp(r)
-    wait(p)
-    return v
-end
-
-function mktree(d::Dict)
-    lstree = ""
-    for (name, data) in d
-        if isa(data, AbstractString)
-            sha1 = write_and_readchomp(data, `git hash-object -w --stdin`)
-            lstree *= "100644 blob $sha1\t$name\n"
-        elseif isa(data, Dict)
-            sha1 = mktree(data)
-            lstree *= "040000 tree $sha1\t$name\n"
-        elseif is(data, nothing)
-            # ignore it
-        else
-            error("mktree: don't know what to do with $name => $data")
-        end
-    end
-    write_and_readchomp(lstree, `git mktree`)
-end
-
-function verify_tree(d::Dict, tree::AbstractString)
-    # check that tree matches d
-    seen = Set()
-    for line in eachline(`git ls-tree $tree`)
-        m = match(r"^(\d{6}) (\w+) ([0-9a-f]{40})\t(.*)$", line)
-        @test m != nothing
-        perm, kind, sha1, name = m.captures
-        @test haskey(d,name)
-        data = d[name]
-        if isa(data, AbstractString)
-            @test kind == "blob"
-            @test data == readall(`git cat-file blob $sha1`)
-        elseif isa(data, Dict)
-            @test kind == "tree"
-            verify_tree(data, sha1)
-        else
-            error("verify_tree: don't know what to do with $name => $data")
-        end
-        push!(seen, name)
-    end
-    # check that nothing was missing from tree
-    for (name, data) in d
-        @test is(data,nothing) || in(name,seen)
-    end
-end
-
-function verify_work(d::Dict)
-    # check what's in d
-    for (name, data) in d
-        if is(data, nothing)
-            @test !ispath(name)
-            continue
-        end
-        @test ispath(name)
-        if isa(data, AbstractString)
-            @test isfile(name)
-            @test readall(name) == data
-        elseif isa(data, Dict)
-            cd(name) do
-                verify_work(data)
-            end
-        else
-            error("verify_work: don't know what to do with $name => $data")
-        end
-    end
-    # check for anything that's not in d
-    for line in eachline(`ls -A`)
-        name = chomp(line)
-        @test name == ".git" || haskey(d,name)
-    end
-end
-
-function git_verify(h::Dict, i::Dict, w::Dict)
-    verify_tree(h, "HEAD")
-    verify_tree(i, readchomp(`git write-tree`))
-    verify_work(w)
-end
-
-function git_setup(h::Dict, i::Dict, w::Dict, parents::AbstractString...)
-    # create tree objects
-    headt = mktree(h)
-    index = mktree(i)
-    work  = mktree(w)
-
-    # clear the repo
-    for line in eachline(`ls -A`)
-        name = chomp(line)
-        name == ".git" || rm(name, recursive=true)
-    end
-
-    # create the head commit
-    commit_tree = `git commit-tree $headt`
-    for parent in parents
-        commit_tree = `$commit_tree -p $parent`
-    end
-    head = write_and_readchomp(headt, commit_tree)
-    run(`git reset -q --soft $head`)
-
-    run(`git read-tree $work`)      # read work into the index
-    run(`git checkout-index -fa`)   # check the index out
-    run(`git read-tree $index`)     # setup the index
-
-    # verify that everything is as expected
-    git_verify(h, i, w)
-end
-git_setup(h::Dict, i::Dict, w::Dict) = git_setup(h, i, w, readchomp(`git rev-parse HEAD`))
diff --git a/test/grisu.jl b/test/grisu.jl
index 1582cc971fbd2..554e436005d0e 100644
--- a/test/grisu.jl
+++ b/test/grisu.jl
@@ -1428,190 +1428,190 @@ status,len,point = Grisu.fastfixedtoa(Float16(0.5), 0,0, buffer)
 fill!(buffer,0);
 
 #dtoa
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.SHORTEST, 0, buffer)
 @test "0" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(Float32(0.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(0.0), Grisu.SHORTEST, 0, buffer)
 @test "0" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.FIXED, 2, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.FIXED, 2, buffer)
 @test 1 >= len-1
 @test "0" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.PRECISION, 3, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.PRECISION, 3, buffer)
 @test 1 >= len-1
 @test "0" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.SHORTEST, 0, buffer)
 @test "1" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(Float32(1.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(1.0), Grisu.SHORTEST, 0, buffer)
 @test "1" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.FIXED, 3, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.FIXED, 3, buffer)
 @test 3 >= len-1-point
 @test "1" == trimrep(buffer)
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.PRECISION, 3, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.PRECISION, 3, buffer)
 @test 3 >= len-1
 @test "1" == trimrep(buffer)
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(1.5, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(1.5, Grisu.SHORTEST, 0, buffer)
 @test "15" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(Float32(1.5), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(1.5), Grisu.SHORTEST, 0, buffer)
 @test "15" == bytestring(pointer(buffer))
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(1.5, Grisu.FIXED, 10, buffer)
+len,point,neg = Grisu.grisu(1.5, Grisu.FIXED, 10, buffer)
 @test 10 >= len-1-point
 @test "15" == trimrep(buffer)
 @test 1 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(1.5, Grisu.PRECISION, 10, buffer)
+len,point,neg = Grisu.grisu(1.5, Grisu.PRECISION, 10, buffer)
 @test 10 >= len-1
 @test "15" == trimrep(buffer)
 @test 1 == point
 fill!(buffer,0);
 
 min_double = 5e-324
-len,point,neg,buffer = Grisu.grisu(min_double, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(min_double, Grisu.SHORTEST, 0, buffer)
 @test "5" == bytestring(pointer(buffer))
 @test -323 == point
 fill!(buffer,0);
 
 min_float = 1e-45
-len,point,neg,buffer = Grisu.grisu(Float32(min_float), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(min_float), Grisu.SHORTEST, 0, buffer)
 @test "1" == bytestring(pointer(buffer))
 @test -44 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(min_double, Grisu.FIXED, 5, buffer)
+len,point,neg = Grisu.grisu(min_double, Grisu.FIXED, 5, buffer)
 @test 5 >= len-1-point
 @test "" == trimrep(buffer)
 @test -5 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(min_double, Grisu.PRECISION, 5, buffer)
+len,point,neg = Grisu.grisu(min_double, Grisu.PRECISION, 5, buffer)
 @test 5 >= len-1
 @test "49407" == trimrep(buffer)
 @test -323 == point
 fill!(buffer,0);
 
 max_double = 1.7976931348623157e308
-len,point,neg,buffer = Grisu.grisu(max_double, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(max_double, Grisu.SHORTEST, 0, buffer)
 @test "17976931348623157" == bytestring(pointer(buffer))
 @test 309 == point
 fill!(buffer,0);
 
 max_float = 3.4028234e38
-len,point,neg,buffer = Grisu.grisu(Float32(max_float), Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(Float32(max_float), Grisu.SHORTEST, 0, buffer)
 @test "34028235" == bytestring(pointer(buffer))
 @test 39 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(max_double, Grisu.PRECISION, 7, buffer)
+len,point,neg = Grisu.grisu(max_double, Grisu.PRECISION, 7, buffer)
 @test 7 >= len-1
 @test "1797693" == trimrep(buffer)
 @test 309 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(4294967272.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(4294967272.0, Grisu.SHORTEST, 0, buffer)
 @test "4294967272" == bytestring(pointer(buffer))
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(Float32(4294967272.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(4294967272.0), Grisu.SHORTEST, 0, buffer)
 @test "42949673" == bytestring(pointer(buffer))
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(4294967272.0, Grisu.FIXED, 5, buffer)
+len,point,neg = Grisu.grisu(4294967272.0, Grisu.FIXED, 5, buffer)
 @test 5 >= len-1-point
 @test "4294967272" == trimrep(buffer)
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(4294967272.0, Grisu.PRECISION, 14,buffer)
+len,point,neg = Grisu.grisu(4294967272.0, Grisu.PRECISION, 14, buffer)
 @test 14 >= len-1
 @test "4294967272" == trimrep(buffer)
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(4.1855804968213567e298, Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(4.1855804968213567e298, Grisu.SHORTEST, 0, buffer)
 @test "4185580496821357" == bytestring(pointer(buffer))
 @test 299 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(4.1855804968213567e298, Grisu.PRECISION, 20,buffer)
+len,point,neg = Grisu.grisu(4.1855804968213567e298, Grisu.PRECISION, 20, buffer)
 @test 20 >= len-1
 @test "41855804968213567225" == trimrep(buffer)
 @test 299 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(5.5626846462680035e-309, Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(5.5626846462680035e-309, Grisu.SHORTEST, 0, buffer)
 @test "5562684646268003" == bytestring(pointer(buffer))
 @test -308 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(5.5626846462680035e-309, Grisu.PRECISION, 1,buffer)
+len,point,neg = Grisu.grisu(5.5626846462680035e-309, Grisu.PRECISION, 1, buffer)
 @test 1 >= len-1
 @test "6" == trimrep(buffer)
 @test -308 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(-2147483648.0, Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(-2147483648.0, Grisu.SHORTEST, 0, buffer)
 @test 1 == neg
 @test "2147483648" == bytestring(pointer(buffer))
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(Float32(-2147483648.), Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(Float32(-2147483648.), Grisu.SHORTEST, 0, buffer)
 @test 1 == neg
 @test "21474836" == bytestring(pointer(buffer))
 @test 10 == point
 fill!(buffer,0);
 
 
-len,point,neg,buffer = Grisu.grisu(-2147483648.0, Grisu.FIXED, 2, buffer)
+len,point,neg = Grisu.grisu(-2147483648.0, Grisu.FIXED, 2, buffer)
 @test 2 >= len-1-point
 @test "2147483648" == trimrep(buffer)
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(-2147483648.0, Grisu.PRECISION, 5,buffer)
+len,point,neg = Grisu.grisu(-2147483648.0, Grisu.PRECISION, 5, buffer)
 @test 5 >= len-1
 @test "21475" == trimrep(buffer)
 @test 10 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(-3.5844466002796428e+298, Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(-3.5844466002796428e+298, Grisu.SHORTEST, 0, buffer)
 @test 1 == neg
 @test "35844466002796428" == bytestring(pointer(buffer))
 @test 299 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(-3.5844466002796428e+298, Grisu.PRECISION, 10,buffer)
+len,point,neg = Grisu.grisu(-3.5844466002796428e+298, Grisu.PRECISION, 10, buffer)
 @test 1 == neg
 @test 10 >= len-1
 @test "35844466" == trimrep(buffer)
@@ -1619,135 +1619,135 @@ len,point,neg,buffer = Grisu.grisu(-3.5844466002796428e+298, Grisu.PRECISION, 10
 fill!(buffer,0);
 
 v = reinterpret(Float64,0x0010000000000000)
-len,point,neg,buffer = Grisu.grisu(v, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.SHORTEST, 0, buffer)
 @test "22250738585072014" == bytestring(pointer(buffer))
 @test -307 == point
 fill!(buffer,0);
 
 f = reinterpret(Float32,0x00800000)
-len,point,neg,buffer = Grisu.grisu(f, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(f, Grisu.SHORTEST, 0, buffer)
 @test "11754944" == bytestring(pointer(buffer))
 @test -37 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(v, Grisu.PRECISION, 20, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.PRECISION, 20, buffer)
 @test 20 >= len-1
 @test "22250738585072013831" == trimrep(buffer)
 @test -307 == point
 fill!(buffer,0);
 
 v = reinterpret(Float64,0x000FFFFFFFFFFFFF)
-len,point,neg,buffer = Grisu.grisu(v, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.SHORTEST, 0, buffer)
 @test "2225073858507201" == bytestring(pointer(buffer))
 @test -307 == point
 fill!(buffer,0);
 
 f = reinterpret(Float32,0x007FFFFF)
-len,point,neg,buffer = Grisu.grisu(f, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(f, Grisu.SHORTEST, 0, buffer)
 @test "11754942" == bytestring(pointer(buffer))
 @test -37 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(v, Grisu.PRECISION, 20, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.PRECISION, 20, buffer)
 @test 20 >= len-1
 @test "2225073858507200889" == trimrep(buffer)
 @test -307 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(4128420500802942e-24, Grisu.SHORTEST, 0,buffer)
+len,point,neg = Grisu.grisu(4128420500802942e-24, Grisu.SHORTEST, 0, buffer)
 @test 0 == neg
 @test "4128420500802942" == bytestring(pointer(buffer))
 @test -8 == point
 fill!(buffer,0);
 
 v = -3.9292015898194142585311918e-10
-len,point,neg,buffer = Grisu.grisu(v, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.SHORTEST, 0, buffer)
 @test "39292015898194143" == bytestring(pointer(buffer))
 fill!(buffer,0);
 
 f = Float32(-3.9292015898194142585311918e-10)
-len,point,neg,buffer = Grisu.grisu(f, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(f, Grisu.SHORTEST, 0, buffer)
 @test "39292017" == bytestring(pointer(buffer))
 fill!(buffer,0);
 
 v = 4194304.0
-len,point,neg,buffer = Grisu.grisu(v, Grisu.FIXED, 5, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.FIXED, 5, buffer)
 @test 5 >= len-1-point
 @test "4194304" == trimrep(buffer)
 fill!(buffer,0);
 
 v = 3.3161339052167390562200598e-237
-len,point,neg,buffer = Grisu.grisu(v, Grisu.PRECISION, 19, buffer)
+len,point,neg = Grisu.grisu(v, Grisu.PRECISION, 19, buffer)
 @test 19 >= len-1
 @test "3316133905216739056" == trimrep(buffer)
 @test -236 == point
 fill!(buffer,0);
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.SHORTEST, 0, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-0.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(-0.0, Grisu.SHORTEST, 0, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.SHORTEST, 0, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-1.0, Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(-1.0, Grisu.SHORTEST, 0, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(Float32(0.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(0.0), Grisu.SHORTEST, 0, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-Float32(0.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(-Float32(0.0), Grisu.SHORTEST, 0, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(Float32(1.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(Float32(1.0), Grisu.SHORTEST, 0, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-Float32(1.0), Grisu.SHORTEST, 0, buffer)
+len,point,neg = Grisu.grisu(-Float32(1.0), Grisu.SHORTEST, 0, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.PRECISION, 1, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.PRECISION, 1, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-0.0, Grisu.PRECISION, 1, buffer)
+len,point,neg = Grisu.grisu(-0.0, Grisu.PRECISION, 1, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.PRECISION, 1, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.PRECISION, 1, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-1.0, Grisu.PRECISION, 1, buffer)
+len,point,neg = Grisu.grisu(-1.0, Grisu.PRECISION, 1, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.FIXED, 1, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.FIXED, 1, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-0.0, Grisu.FIXED, 1, buffer)
+len,point,neg = Grisu.grisu(-0.0, Grisu.FIXED, 1, buffer)
 @test neg
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.FIXED, 1, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.FIXED, 1, buffer)
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(-1.0, Grisu.FIXED, 1, buffer)
+len,point,neg = Grisu.grisu(-1.0, Grisu.FIXED, 1, buffer)
 @test neg
 
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.PRECISION, 0, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.PRECISION, 0, buffer)
 @test 0 >= len-1
 @test "" == bytestring(pointer(buffer))
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.PRECISION, 0, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.PRECISION, 0, buffer)
 @test 0 >= len-1
 @test "" == bytestring(pointer(buffer))
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(0.0, Grisu.FIXED, 0, buffer)
+len,point,neg = Grisu.grisu(0.0, Grisu.FIXED, 0, buffer)
 @test 1 >= len-1
 @test "0" == bytestring(pointer(buffer))
 @test !neg
 
-len,point,neg,buffer = Grisu.grisu(1.0, Grisu.FIXED, 0, buffer)
+len,point,neg = Grisu.grisu(1.0, Grisu.FIXED, 0, buffer)
 @test 1 >= len-1
 @test "1" == bytestring(pointer(buffer))
 @test !neg
diff --git a/test/hashing.jl b/test/hashing.jl
index 59ac72182ec8f..3b0d4fe4f0d26 100644
--- a/test/hashing.jl
+++ b/test/hashing.jl
@@ -94,3 +94,13 @@ x.nzval[1] = 0
 let a = QuoteNode(1), b = QuoteNode(1.0)
     @test (hash(a)==hash(b)) == (a==b)
 end
+
+let a = Expr(:block, SymbolNode(:a, Any)),
+    b = Expr(:block, SymbolNode(:a, Any)),
+    c = Expr(:block, SymbolNode(:c, Any))
+    @test a == b && hash(a) == hash(b)
+    @test a != c && hash(a) != hash(c)
+    @test b != c && hash(b) != hash(c)
+end
+
+@test hash(Dict(),hash(Set())) != hash(Set(),hash(Dict()))
diff --git a/test/inline.jl b/test/inline.jl
new file mode 100644
index 0000000000000..752d5918aad25
--- /dev/null
+++ b/test/inline.jl
@@ -0,0 +1,68 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+using Base.Test
+
+"""
+Helper to walk the AST and call a function on every node.
+"""
+function walk(func, expr)
+    func(expr)
+    if isa(expr, Expr)
+        func(expr.head)
+        for o in expr.args
+            walk(func, o)
+        end
+    end
+end
+
+"""
+Helper to test that every SymbolNode/NewvarNode has a
+corresponding varinfo entry after inlining.
+"""
+function test_inlined_symbols(func, argtypes)
+    linfo = code_typed(func, argtypes)[1]
+    locals = linfo.args[2][1]
+    local_names = Set([name for (name, typ, flag) in locals])
+    ast = linfo.args[3]
+    walk(ast) do e
+        if isa(e, NewvarNode) || isa(e, SymbolNode)
+            @test e.name in local_names
+        end
+    end
+end
+
+# Test case 1:
+# Make sure that all symbols are properly escaped after inlining
+# https://github.com/JuliaLang/julia/issues/12620
+@inline function test_inner(count)
+    x = 1
+    i = 0
+    while i <= count
+        y = x
+        x = x + y
+        i += 1
+    end
+end
+function test_outer(a)
+    test_inner(a)
+end
+test_inlined_symbols(test_outer, Tuple{Int64})
+
+# Test case 2:
+# Make sure that an error is thrown for the undeclared
+# y in the else branch.
+# https://github.com/JuliaLang/julia/issues/12620
+@inline function foo_inl(x)
+    if x
+        y = 2
+    else
+        return y
+    end
+end
+function bar()
+    for i = 1:3
+        foo_inl(i==1)
+    end
+end
+@test_throws UndefVarError bar()
+
diff --git a/test/int.jl b/test/int.jl
index 1ac3394795b6f..725075c721ffd 100644
--- a/test/int.jl
+++ b/test/int.jl
@@ -17,6 +17,24 @@ for y in (4, Float32(4), 4.0, big(4.0))
     @test copysign(-3, y) == 3
 end
 
+# Result type must be type of first argument
+for T in (Base.BitInteger_types..., BigInt,
+          Rational{Int}, Rational{BigInt},
+          Float16, Float32, Float64)
+    for U in (Base.BitInteger_types..., BigInt,
+              Rational{Int}, Rational{BigInt},
+              Float16, Float32, Float64)
+        @test typeof(copysign(T(3), U(4))) === T
+        @test typeof(flipsign(T(3), U(4))) === T
+    end
+end
+
+for s1 in (-1,+1), s2 in (-1,+1)
+    @test flipsign(Int16(3s1), Float16(3s2)) === Int16(3s1*s2)
+    @test flipsign(Int32(3s1), Float32(3s2)) === Int32(3s1*s2)
+    @test flipsign(Int64(3s1), Float64(3s2)) === Int64(3s1*s2)
+end
+
 @test signed(3) == 3
 @test signed(UInt(3)) == 3
 @test isa(signed(UInt(3)), Int)
@@ -71,8 +89,8 @@ end
 bitstype 8 MyBitsType <: Integer
 @test_throws MethodError ~reinterpret(MyBitsType, 0x7b)
 
-UItypes = (UInt8, UInt16, UInt32, UInt64, UInt128)
-SItypes = (Int8, Int16, Int32, Int64, Int128)
+UItypes = Base.BitUnsigned_types
+SItypes = Base.BitSigned_types
 
 for T in UItypes, S in UItypes
     @test promote(S(3), T(3)) === (sizeof(T) < sizeof(S) ? (S(3), S(3)) : (T(3), T(3)))
@@ -105,51 +123,24 @@ for T in (UInt8, UInt16, UInt32, UInt64)
     @test_throws InexactError convert(T, -1)
 end
 
-for i in 1:length(UItypes)-1
-    T = UItypes[i]
-    S = UItypes[i+1]
-    R = sizeof(S) < sizeof(UInt) ? S : UInt
-    @test widen(T(3)) == R(3)
-end
+@test widen(UInt8(3)) === UInt32(3)
+@test widen(UInt16(3)) === UInt32(3)
+@test widen(UInt32(3)) === UInt64(3)
+@test widen(UInt64(3)) === UInt128(3)
+@test widen(UInt128(3)) == 3
+@test typeof(widen(UInt128(3))) == BigInt
 
-for i in 1:length(SItypes)-1
-    T = SItypes[i]
-    S = SItypes[i+1]
-    R = sizeof(S) < sizeof(Int) ? S : Int
-    @test widen(T(3)) == R(3)
-end
+@test widen(Int8(-3)) === Int32(-3)
+@test widen(Int16(-3)) === Int32(-3)
+@test widen(Int32(-3)) === Int64(-3)
+@test widen(Int64(-3)) === Int128(-3)
+@test widen(Int128(-3)) == -3
+@test typeof(widen(Int128(-3))) == BigInt
 
 @test widemul(false, false) == false
 @test widemul(false, 3) == 0
 @test widemul(3, true) == widemul(true, 3) == 3
 
-# checked operations
-
-import Base: checked_add, checked_sub, checked_mul
-@test checked_sub(UInt(4), UInt(3)) === UInt(1)
-@test_throws OverflowError checked_sub(UInt(5), UInt(6))
-@test checked_mul(UInt(4), UInt(3)) === UInt(12)
-
-@test checked_sub(Int128(-1),Int128(-2)) === Int128(1)
-
-if WORD_SIZE == 32
-    @test_throws OverflowError checked_mul(UInt(2)^30, UInt(2)^2)
-else
-    @test_throws OverflowError checked_mul(UInt(2)^62, UInt(2)^2)
-end
-
-# Checked operations on UInt128 are currently broken
-# FIXME: #4905
-
-@test checked_add(UInt128(1), UInt128(2)) === UInt128(3)
-#@test_throws OverflowError checked_add(UInt128(2)^127, UInt128(2)^127)
-@test checked_add(UInt128(2)^127, UInt128(2)^127) === UInt128(0)  # broken
-
-@test checked_sub(UInt128(2), UInt128(1)) === UInt128(1)
-#@test_throws OverflowError checked_sub(UInt128(3), UInt128(4))
-@test checked_sub(UInt128(3), UInt128(4)) === UInt128(0) - 1  # broken
-
-@test checked_mul(UInt128(3), UInt128(4)) === UInt128(12)
-#@test_throws OverflowError checked_mul(UInt128(2)^127, UInt128(2))
-@test checked_mul(UInt128(2)^127, UInt128(2)) === UInt128(0)
-# broken
+# issue #3596
+@test Int128(1)<<0 == 1
+@test repr(Int128(1)<<1) == "2"
diff --git a/test/intfuncs.jl b/test/intfuncs.jl
index 856ce156380d4..c1b70447d0bc4 100644
--- a/test/intfuncs.jl
+++ b/test/intfuncs.jl
@@ -1,26 +1,35 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-@test gcd(3, 5) == 1
-@test gcd(3, 15) == 3
-@test gcd(0, 15) == 15
-@test gcd(3, -15) == 3
-@test gcd(-3, -15) == 3
-@test gcd(0, 0) == 0
-
-@test gcd(2, 4, 6) == 2
-
-@test typeof(gcd(Int32(3), Int32(15))) == Int32
-
-@test lcm(2, 3) == 6
-@test lcm(4, 6) == 12
-@test lcm(3, 0) == 0
-@test lcm(0, 0) == 0
-@test lcm(4, -6) == 12
-@test lcm(-4, -6) == 12
-
-@test lcm(2, 4, 6) == 12
-
-@test typeof(lcm(Int32(2), Int32(3))) == Int32
+# Int32 and Int64 take different code paths -- test both
+for T in (Int32, Int64)
+    @test gcd(T(3), T(5)) === T(1)
+    @test gcd(T(3), T(15)) === T(3)
+    @test gcd(T(0), T(15)) === T(15)
+    @test gcd(T(3), T(-15)) === T(3)
+    @test gcd(T(-3), T(-15)) === T(3)
+    @test gcd(T(0), T(0)) === T(0)
+
+    @test gcd(T(2), T(4), T(6)) === T(2)
+
+    @test gcd(typemax(T), T(1)) === T(1)
+    @test gcd(-typemax(T), T(1)) === T(1)
+    @test gcd(typemin(T), T(1)) === T(1)
+    @test_throws OverflowError gcd(typemin(T), typemin(T))
+
+    @test lcm(T(2), T(3)) === T(6)
+    @test lcm(T(4), T(6)) === T(12)
+    @test lcm(T(3), T(0)) === T(0)
+    @test lcm(T(0), T(0)) === T(0)
+    @test lcm(T(4), T(-6)) === T(12)
+    @test lcm(T(-4), T(-6)) === T(12)
+
+    @test lcm(T(2), T(4), T(6)) === T(12)
+
+    @test lcm(typemax(T), T(1)) === typemax(T)
+    @test lcm(-typemax(T), T(1)) === typemax(T)
+    @test_throws OverflowError lcm(typemin(T), T(1))
+    @test_throws OverflowError lcm(typemin(T), typemin(T))
+end
 
 @test gcdx(5, 12) == (1, 5, -2)
 @test gcdx(5, -12) == (1, 5, 2)
diff --git a/test/intset.jl b/test/intset.jl
index 4564582e6821c..5ebd531a46e09 100644
--- a/test/intset.jl
+++ b/test/intset.jl
@@ -86,6 +86,8 @@ k = IntSet([4, 5])
 copy!(k, i)
 @test k == i
 @test !(k === i)
+copy!(k, k)
+@test k == i
 
 # unions
 i = IntSet([1, 2, 3])
diff --git a/test/iobuffer.jl b/test/iobuffer.jl
index 3b801288f0966..9935c02cdaca5 100644
--- a/test/iobuffer.jl
+++ b/test/iobuffer.jl
@@ -6,6 +6,9 @@ let io = IOBuffer()
 @test eof(io)
 @test_throws EOFError read(io,UInt8)
 @test write(io,"abc") == 3
+@test isreadable(io)
+@test iswritable(io)
+@test isopen(io)
 @test ioslength(io) == 3
 @test position(io) == 3
 @test eof(io)
@@ -36,6 +39,8 @@ truncate(io, 0)
 @test write(io,"boston\ncambridge\n") > 0
 @test takebuf_string(io) == "boston\ncambridge\n"
 @test takebuf_string(io) == ""
+@test write(io, Complex{Float64}(0)) == 16
+@test write(io, Rational{Int64}(1//2)) == 16
 close(io)
 @test_throws ArgumentError write(io,UInt8[0])
 @test_throws ArgumentError seek(io,0)
@@ -45,7 +50,7 @@ end
 let io = IOBuffer("hamster\nguinea pig\nturtle")
 @test position(io) == 0
 @test readline(io) == "hamster\n"
-@test readall(io) == "guinea pig\nturtle"
+@test readstring(io) == "guinea pig\nturtle"
 @test_throws EOFError read(io,UInt8)
 seek(io,0)
 @test read(io,UInt8) == convert(UInt8, 'h')
@@ -101,7 +106,7 @@ skip(io,3)
 @test write(io,"apples".data) == 3
 skip(io,71)
 @test write(io,'y') == 1
-@test readall(io) == "happy"
+@test readstring(io) == "happy"
 @test eof(io)
 write(io,zeros(UInt8,73))
 write(io,'a')
@@ -158,22 +163,22 @@ let io=IOBuffer(SubString("***αhelloworldω***",4,16)), io2 = IOBuffer(b"goodni
     @test read(io, Char) == 'ω'
     @test_throws EOFError read(io,UInt8)
     skip(io, -3)
-    @test readall(io) == "dω"
+    @test readstring(io) == "dω"
     @test bytestring(io) == "αhelloworldω"
     @test_throws ArgumentError write(io,"!")
     @test takebuf_array(io) == b"αhelloworldω"
     seek(io, 2)
     seekend(io2)
     write(io2, io)
-    @test readall(io) == ""
-    @test readall(io2) == ""
+    @test readstring(io) == ""
+    @test readstring(io2) == ""
     @test takebuf_string(io) == "αhelloworldω"
     seek(io2, 0)
     truncate(io2, io2.size - 2)
-    @test readall(io2) == "goodnightmoonhelloworld"
+    @test readstring(io2) == "goodnightmoonhelloworld"
     seek(io2, 0)
     write(io2, io2)
-    @test readall(io2) == ""
+    @test readstring(io2) == ""
     @test bytestring(io2) == "goodnightmoonhelloworld"
 end
 
@@ -182,3 +187,27 @@ end
 let io = IOBuffer(0)
    write(io, ones(UInt8, 1048577))
 end
+
+let bstream = BufferStream()
+    @test isopen(bstream)
+    @test isreadable(bstream)
+    @test iswritable(bstream)
+    @test nb_available(bstream) == 0
+    @test sprint(io -> show(io,bstream)) == "BufferStream() bytes waiting:$(nb_available(bstream.buffer)), isopen:true"
+    a = rand(UInt8,10)
+    write(bstream,a)
+    @test !eof(bstream)
+    flush(bstream)
+    b = read(bstream,UInt8)
+    @test a[1] == b
+    b = read(bstream,UInt8)
+    @test a[2] == b
+    c = zeros(UInt8,8)
+    @test nb_available(bstream) == 8
+    @test !eof(bstream)
+    read!(bstream,c)
+    @test c == a[3:10]
+    close(bstream)
+    @test eof(bstream)
+    @test nb_available(bstream) == 0
+end
diff --git a/test/keywordargs.jl b/test/keywordargs.jl
index 5ffa4aeea3980..ce2c979f051af 100644
--- a/test/keywordargs.jl
+++ b/test/keywordargs.jl
@@ -185,3 +185,16 @@ let
     @test kwf1(0; p, q) == 310
     @test kwf1(0; q, hundreds=4) == 410
 end
+
+# with anonymous functions, issue #2773
+let f = (x;a=1,b=2)->(x, a, b)
+    @test f(0) === (0, 1, 2)
+    @test f(1,a=10,b=20) === (1,10,20)
+    @test f(0,b=88) === (0, 1, 88)
+    @test_throws ErrorException f(0,z=1)
+end
+@test ((a=2)->10a)(3) == 30
+@test ((a=2)->10a)() == 20
+@test ((a=1,b=2)->(a,b))() == (1,2)
+@test ((a=1,b=2)->(a,b))(5) == (5,2)
+@test ((a=1,b=2)->(a,b))(5,6) == (5,6)
diff --git a/test/libdl.jl b/test/libdl.jl
index 5a1cdfb761b06..0b89589588de1 100644
--- a/test/libdl.jl
+++ b/test/libdl.jl
@@ -22,12 +22,21 @@ end
 
 cd(dirname(@__FILE__)) do
 
-# @test !isempty(Libdl.find_library(["libccalltest"], [dirname(@__FILE__)]))
+# Find the private library directory by finding the path of libjulia (or libjulia-debug, as the case may be)
+private_libdir = if ccall(:jl_is_debugbuild, Cint, ()) != 0
+    dirname(abspath(Libdl.dlpath("libjulia-debug")))
+else
+    dirname(abspath(Libdl.dlpath("libjulia")))
+end
+
+@test !isempty(Libdl.find_library(["libccalltest"], [private_libdir]))
+@test !isempty(Libdl.find_library("libccalltest", [private_libdir]))
+@test !isempty(Libdl.find_library(:libccalltest, [private_libdir]))
 
 # dlopen should be able to handle absolute and relative paths, with and without dlext
 let dl = C_NULL
     try
-        dl = Libdl.dlopen_e(abspath("./libccalltest"))
+        dl = Libdl.dlopen_e(abspath(joinpath(private_libdir, "libccalltest")))
         @test dl != C_NULL
     finally
         Libdl.dlclose(dl)
@@ -36,7 +45,7 @@ end
 
 let dl = C_NULL
     try
-        dl = Libdl.dlopen_e(join((abspath("./libccalltest"), string(".", Libdl.dlext))))
+        dl = Libdl.dlopen_e(abspath(joinpath(private_libdir, "libccalltest.$(Libdl.dlext)")))
         @test dl != C_NULL
     finally
         Libdl.dlclose(dl)
@@ -45,7 +54,7 @@ end
 
 let dl = C_NULL
     try
-        dl = Libdl.dlopen_e("./libccalltest")
+        dl = Libdl.dlopen_e(relpath(joinpath(private_libdir, "libccalltest")))
         @test dl != C_NULL
     finally
         Libdl.dlclose(dl)
@@ -54,7 +63,7 @@ end
 
 let dl = C_NULL
     try
-        dl = Libdl.dlopen_e(join(("./libccalltest", string(".", Libdl.dlext))))
+        dl = Libdl.dlopen_e(relpath(joinpath(private_libdir, "libccalltest.$(Libdl.dlext)")))
         @test dl != C_NULL
     finally
         Libdl.dlclose(dl)
@@ -72,24 +81,20 @@ end
 
 # unqualified names present in DL_LOAD_PATH
 let dl = C_NULL
-    push!(Libdl.DL_LOAD_PATH, pwd())
     try
         dl = Libdl.dlopen_e("libccalltest")
         @test dl != C_NULL
     finally
         Libdl.dlclose(dl)
-        pop!(Libdl.DL_LOAD_PATH)
     end
 end
 
 let dl = C_NULL
-    push!(Libdl.DL_LOAD_PATH, pwd())
     try
         dl = Libdl.dlopen_e(string("libccalltest",".",Libdl.dlext))
         @test dl != C_NULL
     finally
         Libdl.dlclose(dl)
-        pop!(Libdl.DL_LOAD_PATH)
     end
 end
 
@@ -134,12 +139,13 @@ end
 # test dlpath
 let dl = C_NULL
     try
-        dl = Libdl.dlopen("./libccalltest")
+        path = abspath(joinpath(private_libdir, "libccalltest"))
+        dl = Libdl.dlopen(path)
         @test dl != C_NULL
         @test Base.samefile(abspath(Libdl.dlpath(dl)),
-                            abspath(Libdl.dlpath("./libccalltest")))
+                            abspath(Libdl.dlpath(path)))
         @test Base.samefile(abspath(Libdl.dlpath(dl)),
-                            abspath(string("./libccalltest",".", Libdl.dlext)))
+                            string(path,".",Libdl.dlext))
     finally
         Libdl.dlclose(dl)
     end
@@ -151,7 +157,7 @@ end
 # test dlsym
 let dl = C_NULL
     try
-        dl = Libdl.dlopen("./libccalltest")
+        dl = Libdl.dlopen(abspath(joinpath(private_libdir, "libccalltest")))
         fptr = Libdl.dlsym(dl, :set_verbose)
         @test fptr != C_NULL
         @test_throws ErrorException Libdl.dlsym(dl, :foo)
diff --git a/test/libgit2-online.jl b/test/libgit2-online.jl
new file mode 100644
index 0000000000000..55f7f297f4171
--- /dev/null
+++ b/test/libgit2-online.jl
@@ -0,0 +1,43 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+#@testset "libgit2-online" begin
+
+#########
+# TESTS #
+#########
+# init & clone
+mktempdir() do dir
+    repo_url = "github.com/JuliaLang/Example.jl"
+    https_prefix = "https://"
+    ssh_prefix = "git@"
+    #@testset "Cloning repository" begin
+        #@testset "with 'https' protocol" begin
+            repo_path = joinpath(dir, "Example1")
+            repo = LibGit2.clone(https_prefix*repo_url, repo_path)
+            try
+                @test isdir(repo_path)
+                @test isdir(joinpath(repo_path, ".git"))
+            finally
+                finalize(repo)
+            end
+        #end
+        #@testset "with incorrect url" begin
+            repo_path = joinpath(dir, "Example2")
+            # credential are required because github try authenticate on uknown repo
+            x = Nullable(LibGit2.UserPasswordCredentials("X","X"))
+            @test_throws LibGit2.Error.GitError LibGit2.clone(https_prefix*repo_url*randstring(10), repo_path, payload=x)
+        #end
+
+        try
+            #@testset "with 'ssh' protocol (by default is not supported)" begin
+                repo_path = joinpath(dir, "Example3")
+                @test_throws LibGit2.Error.GitError LibGit2.clone(ssh_prefix*repo_url, repo_path)
+            #end
+        catch ex
+            # but we cloned succesfully, so check that repo was created
+            ex.fail == 1 && @test isdir(joinpath(path, ".git"))
+        end
+    #end
+end
+
+#end
diff --git a/test/libgit2.jl b/test/libgit2.jl
index 27054bc7c331c..283794481e7a4 100644
--- a/test/libgit2.jl
+++ b/test/libgit2.jl
@@ -1,19 +1,384 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-# check that libgit2 has been installed correctly
-
-const LIBGIT2_VER = v"0.21+"
-
-function check_version()
-    major, minor, patch = Cint[0], Cint[0], Cint[0]
-    ccall((:git_libgit2_version, :libgit2), Void,
-          (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), major, minor, patch)
-    v = VersionNumber(major[1], minor[1], patch[1])
-    if v.major == LIBGIT2_VER.major && v.minor >= LIBGIT2_VER.minor
-        return true
-    else
-        return false
+#@testset "libgit2" begin
+
+const LIBGIT2_VER = v"0.23.0"
+
+#########
+# TESTS #
+#########
+
+#@testset "Check library verison" begin
+    v = LibGit2.version()
+    @test  v.major == LIBGIT2_VER.major && v.minor >= LIBGIT2_VER.minor
+#end
+
+#@testset "OID" begin
+    z = LibGit2.Oid()
+    @test LibGit2.iszero(z)
+    @test z == zero(LibGit2.Oid)
+    rs = string(z)
+    rr = LibGit2.raw(z)
+    @test z == LibGit2.Oid(rr)
+    @test z == LibGit2.Oid(rs)
+    @test z == LibGit2.Oid(pointer(rr))
+    for i in 11:length(rr); rr[i] = 0; end
+    @test LibGit2.Oid(rr) == LibGit2.Oid(rs[1:20])
+#end
+
+#@testset "StrArrayStruct" begin
+    p1 = "XXX"
+    p2 = "YYY"
+    sa1 = LibGit2.StrArrayStruct(p1)
+    try
+        arr = convert(Vector{AbstractString}, sa1)
+        @test arr[1] == p1
+    finally
+        finalize(sa1)
+    end
+
+    sa2 = LibGit2.StrArrayStruct(p1, p2)
+    try
+        arr1 = convert(Vector{AbstractString}, sa2)
+        @test arr1[1] == p1
+        @test arr1[2] == p2
+        sa3 = copy(sa2)
+        arr2 = convert(Vector{AbstractString}, sa3)
+        @test arr1[1] == arr2[1]
+        @test arr1[2] == arr2[2]
+        finalize(sa3)
+    finally
+        finalize(sa2)
     end
+#end
+
+#@testset "Signature" begin
+    sig = LibGit2.Signature("AAA", "AAA@BBB.COM", round(time(), 0), 0)
+    git_sig = convert(LibGit2.GitSignature, sig)
+    sig2 = LibGit2.Signature(git_sig)
+    finalize(git_sig)
+    @test sig.name == sig2.name
+    @test sig.email == sig2.email
+    @test sig.time == sig2.time
+#end
+
+mktempdir() do dir
+
+    # test parameters
+    repo_url = "https://github.com/JuliaLang/Example.jl"
+    ssh_prefix = "git@"
+    cache_repo = joinpath(dir, "Example")
+    test_repo = joinpath(dir, "Example.Test")
+    test_sig = LibGit2.Signature("TEST", "TEST@TEST.COM", round(time(), 0), 0)
+    test_file = "testfile"
+    config_file = "testconfig"
+    commit_msg1 = randstring(10)
+    commit_msg2 = randstring(10)
+    commit_oid1 = LibGit2.Oid()
+    commit_oid2 = LibGit2.Oid()
+    test_branch = "test_branch"
+    tag1 = "tag1"
+    tag2 = "tag2"
+
+    #@testset "Configuration" begin
+        cfg = LibGit2.GitConfig(joinpath(dir, config_file), LibGit2.Consts.CONFIG_LEVEL_APP)
+        try
+            @test_throws LibGit2.Error.GitError LibGit2.get(AbstractString, cfg, "tmp.str")
+            @test isempty(LibGit2.get(cfg, "tmp.str", "")) == true
+
+            LibGit2.set!(cfg, "tmp.str", "AAAA")
+            LibGit2.set!(cfg, "tmp.int32", Int32(1))
+            LibGit2.set!(cfg, "tmp.int64", Int64(1))
+            LibGit2.set!(cfg, "tmp.bool", true)
+
+            @test LibGit2.get(cfg, "tmp.str", "") == "AAAA"
+            @test LibGit2.get(cfg, "tmp.int32", Int32(0)) == Int32(1)
+            @test LibGit2.get(cfg, "tmp.int64", Int64(0)) == Int64(1)
+            @test LibGit2.get(cfg, "tmp.bool", false) == true
+        finally
+            finalize(cfg)
+        end
+    #end
+
+    #@testset "Initializing repository" begin
+        #@testset "with remote branch" begin
+            repo = LibGit2.init(cache_repo)
+            try
+                @test isdir(cache_repo)
+                @test isdir(joinpath(cache_repo, ".git"))
+
+                # set a remote branch
+                branch = "upstream"
+                LibGit2.GitRemote(repo, branch, repo_url) |> finalize
+
+                config = joinpath(cache_repo, ".git", "config")
+                lines = split(open(readstring, config, "r"), "\n")
+                @test any(map(x->x == "[remote \"upstream\"]", lines))
+
+                remote = LibGit2.get(LibGit2.GitRemote, repo, branch)
+                @test LibGit2.url(remote) == repo_url
+                finalize(remote)
+            finally
+                finalize(repo)
+            end
+        #end
+
+        #@testset "bare" begin
+            path = joinpath(dir, "Example.Bare")
+            repo = LibGit2.init(path, true)
+            try
+                @test isdir(path)
+                @test isfile(joinpath(path, LibGit2.Consts.HEAD_FILE))
+            finally
+                finalize(repo)
+            end
+        #end
+    #end
+
+    #@testset "Cloning repository" begin
+
+        #@testset "bare" begin
+            repo_path = joinpath(dir, "Example.Bare1")
+            repo = LibGit2.clone(cache_repo, repo_path, isbare = true)
+            try
+                @test isdir(repo_path)
+                @test isfile(joinpath(repo_path, LibGit2.Consts.HEAD_FILE))
+            finally
+                finalize(repo)
+            end
+        #end
+        #@testset "bare with remote callback" begin
+            repo_path = joinpath(dir, "Example.Bare2")
+            repo = LibGit2.clone(cache_repo, repo_path, isbare = true, remote_cb = LibGit2.mirror_cb())
+            try
+                @test isdir(repo_path)
+                @test isfile(joinpath(repo_path, LibGit2.Consts.HEAD_FILE))
+                rmt = LibGit2.get(LibGit2.GitRemote, repo, "origin")
+                try
+                    @test LibGit2.fetch_refspecs(rmt)[1] == "+refs/*:refs/*"
+                finally
+                    finalize(rmt)
+                end
+            finally
+                finalize(repo)
+            end
+        #end
+        #@testset "normal" begin
+            repo = LibGit2.clone(cache_repo, test_repo, remote_cb = LibGit2.mirror_cb())
+            try
+                @test isdir(test_repo)
+                @test isdir(joinpath(test_repo, ".git"))
+            finally
+                finalize(repo)
+            end
+        #end
+    #end
+
+    #@testset "Update cache repository" begin
+
+        #@testset "with commits" begin
+            repo = LibGit2.GitRepo(cache_repo)
+            repo_file = open(joinpath(cache_repo,test_file), "a")
+            try
+                # create commits
+                println(repo_file, commit_msg1)
+                flush(repo_file)
+                LibGit2.add!(repo, test_file)
+                @test LibGit2.iszero(commit_oid1)
+                commit_oid1 = LibGit2.commit(repo, commit_msg1; author=test_sig, committer=test_sig)
+                @test !LibGit2.iszero(commit_oid1)
+
+                println(repo_file, randstring(10))
+                flush(repo_file)
+                LibGit2.add!(repo, test_file)
+                LibGit2.commit(repo, randstring(10); author=test_sig, committer=test_sig)
+
+                println(repo_file, commit_msg2)
+                flush(repo_file)
+                LibGit2.add!(repo, test_file)
+                @test LibGit2.iszero(commit_oid2)
+                commit_oid2 = LibGit2.commit(repo, commit_msg2; author=test_sig, committer=test_sig)
+                @test !LibGit2.iszero(commit_oid2)
+
+                # lookup commits
+                cmt = LibGit2.get(LibGit2.GitCommit, repo, commit_oid1)
+                try
+                    @test commit_oid1 == LibGit2.Oid(cmt)
+                    auth = LibGit2.author(cmt)
+                    @test isa(auth, LibGit2.Signature)
+                    @test auth.name == test_sig.name
+                    @test auth.time == test_sig.time
+                    @test auth.email == test_sig.email
+                    cmtr = LibGit2.committer(cmt)
+                    @test isa(cmtr, LibGit2.Signature)
+                    @test cmtr.name == test_sig.name
+                    @test cmtr.time == test_sig.time
+                    @test cmtr.email == test_sig.email
+                    @test LibGit2.message(cmt) == commit_msg1
+                finally
+                    finalize(cmt)
+                end
+            finally
+                finalize(repo)
+                close(repo_file)
+            end
+        #end
+
+        #@testset "with branch" begin
+            repo = LibGit2.GitRepo(cache_repo)
+            try
+                brnch = LibGit2.branch(repo)
+                @test brnch == "master"
+
+                LibGit2.branch!(repo, test_branch, string(commit_oid1), set_head=false)
+
+                branches = map(b->LibGit2.shortname(b[1]), LibGit2.GitBranchIter(repo))
+                @test "master" in branches
+                @test test_branch in branches
+            finally
+                finalize(repo)
+            end
+        #end
+
+        #@testset "with default configuration" begin
+            repo = LibGit2.GitRepo(cache_repo)
+            try
+                try
+                    LibGit2.Signature(repo)
+                catch ex
+                    # these test configure repo with new signature
+                    # in case when global one does not exsist
+                    @test isa(ex, LibGit2.Error.GitError) == true
+
+                    cfg = LibGit2.GitConfig(repo)
+                    LibGit2.set!(cfg, "user.name", "AAAA")
+                    LibGit2.set!(cfg, "user.email", "BBBB@BBBB.COM")
+                    sig = LibGit2.Signature(repo)
+                    @test sig.name == "AAAA"
+                    @test sig.email == "BBBB@BBBB.COM"
+                end
+            finally
+                finalize(repo)
+            end
+        #end
+
+
+        #@testset "with tags" begin
+            repo = LibGit2.GitRepo(cache_repo)
+            try
+                tags = LibGit2.tag_list(repo)
+                @test length(tags) == 0
+
+                tag_oid1 = LibGit2.tag_create(repo, tag1, commit_oid1, sig=test_sig)
+                @test !LibGit2.iszero(tag_oid1)
+                tags = LibGit2.tag_list(repo)
+                @test length(tags) == 1
+                @test tag1 in tags
+
+                tag_oid2 = LibGit2.tag_create(repo, tag2, commit_oid2)
+                @test !LibGit2.iszero(tag_oid2)
+                tags = LibGit2.tag_list(repo)
+                @test length(tags) == 2
+                @test tag2 in tags
+
+                LibGit2.tag_delete(repo, tag1)
+                tags = LibGit2.tag_list(repo)
+                @test length(tags) == 1
+                @test tag2 ∈ tags
+                @test tag1 ∉ tags
+            finally
+                finalize(repo)
+            end
+        #end
+    #end
+
+    #@testset "Fetch from cache repository" begin
+        repo = LibGit2.GitRepo(test_repo)
+        try
+            # fetch changes
+            @test LibGit2.fetch(repo) == 0
+            @test !isfile(joinpath(test_repo, test_file))
+
+            # ff merge them
+            @test LibGit2.merge!(repo, fastforward=true)
+
+            # because there was not any file we need to reset branch
+            head_oid = LibGit2.head_oid(repo)
+            LibGit2.reset!(repo, head_oid, LibGit2.Consts.RESET_HARD)
+            @test isfile(joinpath(test_repo, test_file))
+        finally
+            finalize(repo)
+        end
+    #end
+
+    #@testset "Examine test repository" begin
+        #@testset "files" begin
+            @test readstring(joinpath(test_repo, test_file)) == readstring(joinpath(cache_repo, test_file))
+        #end
+
+        #@testset "tags & branches" begin
+            repo = LibGit2.GitRepo(test_repo)
+            try
+                # all tag in place
+                tags = LibGit2.tag_list(repo)
+                @test length(tags) == 1
+                @test tag2 in tags
+
+                # all tag in place
+                branches = map(b->LibGit2.shortname(b[1]), LibGit2.GitBranchIter(repo))
+                @test "master" in branches
+                @test test_branch in branches
+            finally
+                finalize(repo)
+            end
+        #end
+
+        #@testset "commits with revwalk" begin
+            repo = LibGit2.GitRepo(test_repo)
+            cache = LibGit2.GitRepo(cache_repo)
+            try
+                oids = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
+                    LibGit2.map((oid,repo)->(oid,repo), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
+                end
+                @test length(oids) == 1
+
+                test_oids = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
+                    LibGit2.map((oid,repo)->string(oid), walker, by = LibGit2.Consts.SORT_TIME)
+                end
+                cache_oids = LibGit2.with(LibGit2.GitRevWalker(cache)) do walker
+                    LibGit2.map((oid,repo)->string(oid), walker, by = LibGit2.Consts.SORT_TIME)
+                end
+                for i in eachindex(oids)
+                    @test cache_oids[i] == test_oids[i]
+                end
+            finally
+                finalize(repo)
+                finalize(cache)
+            end
+        #end
+    #end
+
+    #@testset "Transact test repository" begin
+        repo = LibGit2.GitRepo(test_repo)
+        try
+            cp(joinpath(test_repo, test_file), joinpath(test_repo, "CCC"))
+            cp(joinpath(test_repo, test_file), joinpath(test_repo, "AAA"))
+            LibGit2.add!(repo, "AAA")
+            @test_throws ErrorException LibGit2.transact(repo) do trepo
+                mv(joinpath(test_repo, test_file), joinpath(test_repo, "BBB"))
+                LibGit2.add!(trepo, "BBB")
+                oid = LibGit2.commit(trepo, "test commit"; author=test_sig, committer=test_sig)
+                error("Force recovery")
+            end
+            @test isfile(joinpath(test_repo, "AAA"))
+            @test isfile(joinpath(test_repo, "CCC"))
+            @test !isfile(joinpath(test_repo, "BBB"))
+            @test isfile(joinpath(test_repo, test_file))
+        finally
+            finalize(repo)
+        end
+    #end
+
 end
 
-@test check_version()
+#end
diff --git a/test/linalg/arnoldi.jl b/test/linalg/arnoldi.jl
index 78b14e84b2ba8..4ce632206cc47 100644
--- a/test/linalg/arnoldi.jl
+++ b/test/linalg/arnoldi.jl
@@ -102,13 +102,13 @@ let A6965 = [
 end
 
 # Example from Quantum Information Theory
-import Base: size, issym, ishermitian
+import Base: size, issymmetric, ishermitian
 
 type CPM{T<:Base.LinAlg.BlasFloat}<:AbstractMatrix{T} # completely positive map
     kraus::Array{T,3} # kraus operator representation
 end
 size(Phi::CPM)=(size(Phi.kraus,1)^2,size(Phi.kraus,3)^2)
-issym(Phi::CPM)=false
+issymmetric(Phi::CPM)=false
 ishermitian(Phi::CPM)=false
 import Base: *
 function *{T<:Base.LinAlg.BlasFloat}(Phi::CPM{T},rho::Vector{T})
@@ -204,3 +204,11 @@ let # complex svds test
     @test_throws ArgumentError svds(A,nsv=0)
     @test_throws ArgumentError svds(A,nsv=20)
 end
+
+# test promotion
+eigs(rand(1:10, 10, 10))
+eigs(rand(1:10, 10, 10), rand(1:10, 10, 10) |> t -> t't)
+svds(rand(1:10, 10, 8))
+@test_throws MethodError eigs(big(rand(1:10, 10, 10)))
+@test_throws MethodError eigs(big(rand(1:10, 10, 10)), rand(1:10, 10, 10))
+@test_throws MethodError svds(big(rand(1:10, 10, 8)))
diff --git a/test/linalg/bidiag.jl b/test/linalg/bidiag.jl
index 74e1eb1b11e8c..a049254431791 100644
--- a/test/linalg/bidiag.jl
+++ b/test/linalg/bidiag.jl
@@ -8,16 +8,22 @@ n = 10 #Size of test matrix
 srand(1)
 
 debug && println("Bidiagonal matrices")
-for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
+for relty in (Int, Float32, Float64, BigFloat), elty in (relty, Complex{relty})
     debug && println("elty is $(elty), relty is $(relty)")
-    dv = convert(Vector{elty}, randn(n))
-    ev = convert(Vector{elty}, randn(n-1))
-    b = convert(Matrix{elty}, randn(n, 2))
-    c = convert(Matrix{elty}, randn(n, n))
-    if (elty <: Complex)
-        dv += im*convert(Vector{elty}, randn(n))
-        ev += im*convert(Vector{elty}, randn(n-1))
-        b += im*convert(Matrix{elty}, randn(n, 2))
+    if relty <: AbstractFloat
+        dv = convert(Vector{elty}, randn(n))
+        ev = convert(Vector{elty}, randn(n-1))
+        if (elty <: Complex)
+            dv += im*convert(Vector{elty}, randn(n))
+            ev += im*convert(Vector{elty}, randn(n-1))
+        end
+    elseif relty <: Integer
+        dv = convert(Vector{elty}, rand(1:10, n))
+        ev = convert(Vector{elty}, rand(1:10, n-1))
+        if (elty <: Complex)
+            dv += im*convert(Vector{elty}, rand(1:10, n))
+            ev += im*convert(Vector{elty}, rand(1:10, n-1))
+        end
     end
 
     debug && println("Test constructors")
@@ -26,11 +32,21 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
     @test_throws DimensionMismatch Bidiagonal(dv,ones(elty,n),true)
     @test_throws ArgumentError Bidiagonal(dv,ev)
 
-    #getindex and size
-    BD = Bidiagonal(dv,ev,true)
+    debug && println("getindex, setindex!, size, and similar")
+    BD = Bidiagonal(dv, ev, true)
     @test_throws BoundsError BD[n+1,1]
+    @test BD[2,2] == dv[2]
+    @test BD[2,3] == ev[2]
+    @test_throws ArgumentError BD[2,1] = 1
+    @test_throws ArgumentError BD[3,1] = 1
+    cBD = copy(BD)
+    cBD[2,2] = BD[2,2]
+    @test BD == cBD
     @test_throws ArgumentError size(BD,0)
     @test size(BD,3) == 1
+    @test isa(similar(BD), Bidiagonal{elty})
+    @test isa(similar(BD, Int), Bidiagonal{Int})
+    @test isa(similar(BD, Int, (3,2)), Matrix{Int})
 
     debug && println("show")
     dstring = sprint(Base.print_matrix,BD.dv')
@@ -84,44 +100,72 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
         @test triu!(Bidiagonal(dv,ev,'U'))    == Bidiagonal(dv,ev,'U')
         @test_throws ArgumentError triu!(Bidiagonal(dv,ev,'U'),n+1)
 
-        debug && println("Linear solver")
+        if relty <: AbstractFloat
+            c = convert(Matrix{elty}, randn(n,n))
+            b = convert(Matrix{elty}, randn(n, 2))
+            if (elty <: Complex)
+                b += im*convert(Matrix{elty}, randn(n, 2))
+            end
+        elseif relty <: Integer
+            c = convert(Matrix{elty}, rand(1:10, n, n))
+            b = convert(Matrix{elty}, rand(1:10, n, 2))
+            if (elty <: Complex)
+                b += im*convert(Matrix{elty}, rand(1:10, n, 2))
+            end
+        end
         Tfull = full(T)
         condT = cond(map(Complex128,Tfull))
-        x = T \ b
-        tx = Tfull \ b
-        @test_throws DimensionMismatch Base.LinAlg.naivesub!(T,ones(elty,n+1))
-        @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(relty)*norm(x,Inf))
-        @test_throws DimensionMismatch T \ ones(elty,n+1,2)
-        @test_throws DimensionMismatch T.' \ ones(elty,n+1,2)
-        @test_throws DimensionMismatch T' \ ones(elty,n+1,2)
+        promty = typeof((zero(relty)*zero(relty) + zero(relty)*zero(relty))/one(relty))
         if relty != BigFloat
             x = T.'\c.'
             tx = Tfull.' \ c.'
-            @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(relty)*norm(x,Inf))
+            elty <: AbstractFloat && @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(promty)*norm(x,Inf))
             @test_throws DimensionMismatch T.'\b.'
             x = T'\c.'
             tx = Tfull' \ c.'
-            @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(relty)*norm(x,Inf))
+            @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(promty)*norm(x,Inf))
             @test_throws DimensionMismatch T'\b.'
             x = T\c.'
             tx = Tfull\c.'
-            @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(relty)*norm(x,Inf))
+            @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(promty)*norm(x,Inf))
             @test_throws DimensionMismatch T\b.'
         end
+        @test_throws DimensionMismatch T \ ones(elty,n+1,2)
+        @test_throws DimensionMismatch T.' \ ones(elty,n+1,2)
+        @test_throws DimensionMismatch T' \ ones(elty,n+1,2)
+        let bb = b, cc = c
+            for atype in ("Array", "SubArray")
+                if atype == "Array"
+                    b = bb
+                    c = cc
+                else
+                    b = sub(bb, 1:n)
+                    c = sub(cc, 1:n, 1:2)
+                end
+            end
+            debug && println("Linear solver")
+            x = T \ b
+            tx = Tfull \ b
+            @test_throws DimensionMismatch Base.LinAlg.naivesub!(T,ones(elty,n+1))
+            @test norm(x-tx,Inf) <= 4*condT*max(eps()*norm(tx,Inf), eps(promty)*norm(x,Inf))
+            debug && println("Generic Mat-vec ops")
+            @test_approx_eq T*b Tfull*b
+            @test_approx_eq T'*b Tfull'*b
+            if relty != BigFloat # not supported by pivoted QR
+                @test_approx_eq T/b' Tfull/b'
+            end
+        end
 
         debug && println("Round,float,trunc,ceil")
         if elty <: BlasReal
             @test floor(Int,T) == Bidiagonal(floor(Int,T.dv),floor(Int,T.ev),T.isupper)
+            @test isa(floor(Int,T), Bidiagonal)
             @test trunc(Int,T) == Bidiagonal(trunc(Int,T.dv),trunc(Int,T.ev),T.isupper)
+            @test isa(trunc(Int,T), Bidiagonal)
             @test round(Int,T) == Bidiagonal(round(Int,T.dv),round(Int,T.ev),T.isupper)
+            @test isa(round(Int,T), Bidiagonal)
             @test ceil(Int,T) == Bidiagonal(ceil(Int,T.dv),ceil(Int,T.ev),T.isupper)
-        end
-
-        debug && println("Generic Mat-vec ops")
-        @test_approx_eq T*dv Tfull*dv
-        @test_approx_eq T'*dv Tfull'*dv
-        if relty != BigFloat # not supported by pivoted QR
-            @test_approx_eq T/dv' Tfull/dv'
+            @test isa(ceil(Int,T), Bidiagonal)
         end
 
         debug && println("Diagonals")
@@ -129,11 +173,13 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
         @test_throws ArgumentError diag(T,n+1)
 
         debug && println("Eigensystems")
-        d1, v1 = eig(T)
-        d2, v2 = eig(map(elty<:Complex ? Complex128 : Float64,Tfull))
-        @test_approx_eq isupper?d1:reverse(d1) d2
-        if elty <: Real
-            Test.test_approx_eq_modphase(v1, isupper?v2:v2[:,n:-1:1])
+        if relty <: AbstractFloat
+            d1, v1 = eig(T)
+            d2, v2 = eig(map(elty<:Complex ? Complex128 : Float64,Tfull))
+            @test_approx_eq isupper?d1:reverse(d1) d2
+            if elty <: Real
+                Test.test_approx_eq_modphase(v1, isupper?v2:v2[:,n:-1:1])
+            end
         end
 
         debug && println("Singular systems")
@@ -157,8 +203,8 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
         @test convert(elty,-1.0) * T == Bidiagonal(-T.dv,-T.ev,T.isupper)
         @test T * convert(elty,-1.0) == Bidiagonal(-T.dv,-T.ev,T.isupper)
         for isupper2 in (true, false)
-            dv = convert(Vector{elty}, randn(n))
-            ev = convert(Vector{elty}, randn(n-1))
+            dv = convert(Vector{elty}, relty <: AbstractFloat ? randn(n) : rand(1:10, n))
+            ev = convert(Vector{elty}, relty <: AbstractFloat ? randn(n-1) : rand(1:10, n-1))
             T2 = Bidiagonal(dv, ev, isupper2)
             Tfull2 = full(T2)
             for op in (+, -, *)
@@ -180,9 +226,13 @@ let A = Bidiagonal([1,2,3], [0,0], true)
     @test isdiag(A)
 end
 
+# test construct from range
+@test Bidiagonal(1:3, 1:2, true) == [1 1 0; 0 2 2; 0 0 3]
+
 #test promote_rule
 A = Bidiagonal(ones(Float32,10),ones(Float32,9),true)
 B = rand(Float64,10,10)
 C = Tridiagonal(rand(Float64,9),rand(Float64,10),rand(Float64,9))
+@test promote_rule(Matrix{Float64}, Bidiagonal{Float64}) == Matrix{Float64}
 @test promote(B,A) == (B,convert(Matrix{Float64},full(A)))
 @test promote(C,A) == (C,Tridiagonal(zeros(Float64,9),convert(Vector{Float64},A.dv),convert(Vector{Float64},A.ev)))
diff --git a/test/linalg/bunchkaufman.jl b/test/linalg/bunchkaufman.jl
index 0d32225daa39e..715b280e9d73c 100644
--- a/test/linalg/bunchkaufman.jl
+++ b/test/linalg/bunchkaufman.jl
@@ -38,18 +38,22 @@ debug && println("(Automatic) Bunch-Kaufman factor of indefinite matrix")
         bc1 = factorize(asym)
         @test_approx_eq inv(bc1) * asym eye(n)
         @test_approx_eq_eps asym * (bc1\b) b 1000ε
-        @test_approx_eq inv(bkfact(a.' + a)) * (a.' + a) eye(n)
-        @test size(bc1) == size(bc1.LD)
-        @test size(bc1,1) == size(bc1.LD,1)
-        @test size(bc1,2) == size(bc1.LD,2)
-        if eltya <: BlasReal
-            @test_throws ArgumentError bkfact(a)
+        for rook in (false, true)
+            @test_approx_eq inv(bkfact(a.' + a, :U, true, rook)) * (a.' + a) eye(n)
+            @test size(bc1) == size(bc1.LD)
+            @test size(bc1,1) == size(bc1.LD,1)
+            @test size(bc1,2) == size(bc1.LD,2)
+            if eltya <: BlasReal
+                @test_throws ArgumentError bkfact(a)
+            end
         end
 debug && println("Bunch-Kaufman factors of a pos-def matrix")
-        bc2 = bkfact(apd)
-        @test_approx_eq inv(bc2) * apd eye(n)
-        @test_approx_eq_eps apd * (bc2\b) b 150000ε
-        @test ishermitian(bc2) == !issym(bc2)
+        for rook in (false, true)
+            bc2 = bkfact(apd, :U, issymmetric(apd), rook)
+            @test_approx_eq inv(bc2) * apd eye(n)
+            @test_approx_eq_eps apd * (bc2\b) b 150000ε
+            @test ishermitian(bc2) == !issymmetric(bc2)
+        end
 
     end
 end
diff --git a/test/linalg/cholesky.jl b/test/linalg/cholesky.jl
index 2e0e4887a1af8..8c31c85cc16fb 100644
--- a/test/linalg/cholesky.jl
+++ b/test/linalg/cholesky.jl
@@ -67,6 +67,8 @@ for eltya in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
     @test_approx_eq full(lapd) apd
     l = lapd[:L]
     @test_approx_eq l*l' apd
+    @test triu(capd.factors) ≈ lapd[:U]
+    @test tril(lapd.factors) ≈ capd[:L]
 
     #pivoted upper Cholesky
     if eltya != BigFloat
@@ -125,8 +127,8 @@ begin
     # Cholesky factor of Matrix with non-commutative elements, here 2x2-matrices
 
     X = Matrix{Float64}[0.1*rand(2,2) for i in 1:3, j = 1:3]
-    L = full(Base.LinAlg.chol!(X*X', Val{:L}))
-    U = full(Base.LinAlg.chol!(X*X', Val{:U}))
+    L = full(Base.LinAlg.chol!(X*X', LowerTriangular))
+    U = full(Base.LinAlg.chol!(X*X', UpperTriangular))
     XX = full(X*X')
 
     @test sum(sum(norm, L*L' - XX)) < eps()
@@ -141,7 +143,16 @@ for elty in (Float32, Float64, Complex{Float32}, Complex{Float64})
         A = randn(5,5)
     end
     A = convert(Matrix{elty}, A'A)
-    for ul in (:U, :L)
-        @test_approx_eq full(cholfact(A, ul)[ul]) full(invoke(Base.LinAlg.chol!, Tuple{AbstractMatrix, Type{Val{ul}}},copy(A), Val{ul}))
+    @test_approx_eq full(cholfact(A)[:L]) full(invoke(Base.LinAlg.chol!, Tuple{AbstractMatrix, Type{LowerTriangular}}, copy(A), LowerTriangular))
+    @test_approx_eq full(cholfact(A)[:U]) full(invoke(Base.LinAlg.chol!, Tuple{AbstractMatrix, Type{UpperTriangular}}, copy(A), UpperTriangular))
+end
+
+# Test up- and downdates
+let A = complex(randn(10,5), randn(10, 5)), v = complex(randn(5), randn(5))
+    for uplo in (:U, :L)
+        AcA = A'A
+        F = cholfact(AcA, uplo)
+        @test LinAlg.lowrankupdate(F, v)[uplo] ≈ cholfact(AcA + v*v')[uplo]
+        @test LinAlg.lowrankdowndate(F, v)[uplo] ≈ cholfact(AcA - v*v')[uplo]
     end
 end
diff --git a/test/linalg/dense.jl b/test/linalg/dense.jl
index d1f3ce90cdd4c..eafd5ae6792da 100644
--- a/test/linalg/dense.jl
+++ b/test/linalg/dense.jl
@@ -408,18 +408,11 @@ for elty in (Float64, Complex{Float64})
                                  1/5 1/6 1/7 1/8])
     @test_approx_eq expm(logm(A4)) A4
 
-    OLD_STDERR = STDERR
-    rd,wr = redirect_stderr()
     A5  = convert(Matrix{elty}, [1 1 0 1; 0 1 1 0; 0 0 1 1; 1 0 0 1])
     @test_approx_eq expm(logm(A5)) A5
-    s = readline(rd)
-    @test contains(s, "WARNING: Matrix with nonpositive real eigenvalues, a nonprincipal matrix logarithm will be returned.")
 
     A6  = convert(Matrix{elty}, [-5 2 0 0 ; 1/2 -7 3 0; 0 1/3 -9 4; 0 0 1/4 -11])
     @test_approx_eq expm(logm(A6)) A6
-    s = readline(rd)
-    @test contains(s, "WARNING: Matrix with nonpositive real eigenvalues, a nonprincipal matrix logarithm will be returned.")
-    redirect_stderr(OLD_STDERR)
 
     A7  = convert(Matrix{elty}, [1 0 0 1e-8; 0 1 0 0; 0 0 1 0; 0 0 0 1])
     @test_approx_eq expm(logm(A7)) A7
diff --git a/test/linalg/diagonal.jl b/test/linalg/diagonal.jl
index 9ea170e7005e6..c046fad165d9f 100644
--- a/test/linalg/diagonal.jl
+++ b/test/linalg/diagonal.jl
@@ -10,6 +10,7 @@ srand(1)
 
 debug && println("Diagonal matrices")
 for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
+
     debug && println("elty is $(elty), relty is $(relty)")
     d=convert(Vector{elty}, randn(n))
     v=convert(Vector{elty}, randn(n))
@@ -21,9 +22,8 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
     end
     D = Diagonal(d)
     DM = diagm(d)
-
-    @test_throws ArgumentError size(D,0)
     @test eye(Diagonal{elty},n) == Diagonal(ones(elty,n))
+    @test_throws ArgumentError size(D,0)
     @test typeof(convert(Diagonal{Complex64},D)) == Diagonal{Complex64}
     @test typeof(convert(AbstractMatrix{Complex64},D))   == Diagonal{Complex64}
 
@@ -31,35 +31,9 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
     @test full(abs(D)) == abs(DM)
     @test full(imag(D)) == imag(DM)
 
-    debug && println("Linear solve")
-    @test_approx_eq_eps D*v DM*v n*eps(relty)*(elty<:Complex ? 2:1)
-    @test_approx_eq_eps D*U DM*U n^2*eps(relty)*(elty<:Complex ? 2:1)
-    if relty != BigFloat
-        @test_approx_eq_eps D\v DM\v 2n^2*eps(relty)*(elty<:Complex ? 2:1)
-        @test_approx_eq_eps D\U DM\U 2n^3*eps(relty)*(elty<:Complex ? 2:1)
-        @test_approx_eq_eps A_ldiv_B!(D,copy(v)) DM\v 2n^2*eps(relty)*(elty<:Complex ? 2:1)
-        @test_approx_eq_eps A_ldiv_B!(D,copy(U)) DM\U 2n^3*eps(relty)*(elty<:Complex ? 2:1)
-        @test_approx_eq_eps A_ldiv_B!(D,eye(D)) D\eye(D) 2n^3*eps(relty)*(elty<:Complex ? 2:1)
-        @test_throws DimensionMismatch A_ldiv_B!(D, ones(elty, n + 1))
-        @test_throws SingularException A_ldiv_B!(Diagonal(zeros(relty,n)),copy(v))
-        b = rand(elty,n,n)
-        b = sparse(b)
-        @test A_ldiv_B!(D,copy(b)) ≈ full(D)\full(b)
-        @test_throws SingularException A_ldiv_B!(Diagonal(zeros(elty,n)),copy(b))
-        b = sub(rand(elty,n),collect(1:n))
-        b2 = copy(b)
-        c = A_ldiv_B!(D,b)
-        d = full(D)\b2
-        for i in 1:n
-            @test c[i] ≈ d[i]
-        end
-        @test_throws SingularException A_ldiv_B!(Diagonal(zeros(elty,n)),b)
-        b = rand(elty,n+1,n+1)
-        b = sparse(b)
-        @test_throws DimensionMismatch A_ldiv_B!(D,copy(b))
-        b = sub(rand(elty,n+1),collect(1:n+1))
-        @test_throws DimensionMismatch A_ldiv_B!(D,b)
-    end
+    @test parent(D) == d
+    @test D[1,1] == d[1]
+    @test D[1,2] == 0
 
     debug && println("Simple unary functions")
     for op in (-,)
@@ -81,91 +55,134 @@ for relty in (Float32, Float64, BigFloat), elty in (relty, Complex{relty})
         end
     end
 
-    debug && println("Binary operations")
-    d = convert(Vector{elty}, randn(n))
-    D2 = Diagonal(d)
-    DM2= diagm(d)
-    for op in (+, -, *)
-        @test full(op(D, D2)) ≈ op(DM, DM2)
-    end
-    # binary ops with plain numbers
-    a = rand()
-    @test full(a*D) ≈ a*DM
-    @test full(D*a) ≈ DM*a
-    @test full(D/a) ≈ DM/a
-    if relty <: BlasFloat
-        b = rand(elty,n,n)
-        b = sparse(b)
-        @test A_mul_B!(copy(D), copy(b)) ≈ full(D)*full(b)
-        @test At_mul_B!(copy(D), copy(b)) ≈ full(D).'*full(b)
-        @test Ac_mul_B!(copy(D), copy(b)) ≈ full(D)'*full(b)
-    end
+    let vv = v, UU = U
+        for atype in ("Array", "SubArray")
+            if atype == "Array"
+                v = vv
+                U = UU
+            else
+                v = sub(vv, 1:n)
+                U = sub(UU, 1:n, 1:2)
+            end
 
-    #division of two Diagonals
-    @test D/D2 ≈ Diagonal(D.diag./D2.diag)
-    @test D\D2 ≈ Diagonal(D2.diag./D.diag)
-    # test triu/tril
-    @test istriu(D)
-    @test istril(D)
-    @test triu(D,1)  == zeros(D)
-    @test triu(D,0)  == D
-    @test triu(D,-1) == D
-    @test tril(D,1)  == D
-    @test tril(D,-1) == zeros(D)
-    @test tril(D,0)  == D
-    @test_throws ArgumentError tril(D,n+1)
-    @test_throws ArgumentError triu(D,n+1)
-
-    # factorize
-    @test factorize(D) == D
-
-    debug && println("Eigensystem")
-    eigD = eigfact(D)
-    @test Diagonal(eigD[:values]) ≈ D
-    @test eigD[:vectors] == eye(D)
-
-    debug && println("ldiv")
-    v = rand(n + 1)
-    @test_throws DimensionMismatch D\v
-    v = rand(n)
-    @test D\v ≈ DM\v
-    V = rand(n + 1, n)
-    @test_throws DimensionMismatch D\V
-    V = rand(n, n)
-    @test D\V ≈ DM\V
-
-    debug && println("conj and transpose")
-    @test transpose(D) == D
-    if elty <: BlasComplex
-        @test full(conj(D)) ≈ conj(DM)
-        @test ctranspose(D) == conj(D)
-    end
+            debug && println("Linear solve")
+            @test_approx_eq_eps D*v DM*v n*eps(relty)*(elty<:Complex ? 2:1)
+            @test_approx_eq_eps D*U DM*U n^2*eps(relty)*(elty<:Complex ? 2:1)
+            if relty != BigFloat
+                @test_approx_eq_eps D\v DM\v 2n^2*eps(relty)*(elty<:Complex ? 2:1)
+                @test_approx_eq_eps D\U DM\U 2n^3*eps(relty)*(elty<:Complex ? 2:1)
+                @test_approx_eq_eps A_ldiv_B!(D,copy(v)) DM\v 2n^2*eps(relty)*(elty<:Complex ? 2:1)
+                @test_approx_eq_eps A_ldiv_B!(D,copy(U)) DM\U 2n^3*eps(relty)*(elty<:Complex ? 2:1)
+                @test_approx_eq_eps A_ldiv_B!(D,eye(D)) D\eye(D) 2n^3*eps(relty)*(elty<:Complex ? 2:1)
+                @test_throws DimensionMismatch A_ldiv_B!(D, ones(elty, n + 1))
+                @test_throws SingularException A_ldiv_B!(Diagonal(zeros(relty,n)),copy(v))
+                b = rand(elty,n,n)
+                b = sparse(b)
+                @test A_ldiv_B!(D,copy(b)) ≈ full(D)\full(b)
+                @test_throws SingularException A_ldiv_B!(Diagonal(zeros(elty,n)),copy(b))
+                b = sub(rand(elty,n),collect(1:n))
+                b2 = copy(b)
+                c = A_ldiv_B!(D,b)
+                d = full(D)\b2
+                for i in 1:n
+                    @test c[i] ≈ d[i]
+                end
+                @test_throws SingularException A_ldiv_B!(Diagonal(zeros(elty,n)),b)
+                b = rand(elty,n+1,n+1)
+                b = sparse(b)
+                @test_throws DimensionMismatch A_ldiv_B!(D,copy(b))
+                b = sub(rand(elty,n+1),collect(1:n+1))
+                @test_throws DimensionMismatch A_ldiv_B!(D,b)
+            end
 
-    #logdet
-    if relty <: Real
-        ld=convert(Vector{relty},rand(n))
-        @test logdet(Diagonal(ld)) ≈ logdet(diagm(ld))
-    end
+            debug && println("Binary operations")
+            d = convert(Vector{elty}, randn(n))
+            D2 = Diagonal(d)
+            DM2= diagm(d)
+            for op in (+, -, *)
+                @test full(op(D, D2)) ≈ op(DM, DM2)
+            end
+            # binary ops with plain numbers
+            a = rand()
+            @test full(a*D) ≈ a*DM
+            @test full(D*a) ≈ DM*a
+            @test full(D/a) ≈ DM/a
+            if relty <: BlasFloat
+                b = rand(elty,n,n)
+                b = sparse(b)
+                @test A_mul_B!(copy(D), copy(b)) ≈ full(D)*full(b)
+                @test At_mul_B!(copy(D), copy(b)) ≈ full(D).'*full(b)
+                @test Ac_mul_B!(copy(D), copy(b)) ≈ full(D)'*full(b)
+            end
 
-    #similar
-    @test_throws ArgumentError similar(D, eltype(D), (n,n+1))
-    @test length(diag(similar(D, eltype(D), (n,n)))) == n
+            #division of two Diagonals
+            @test D/D2 ≈ Diagonal(D.diag./D2.diag)
+            @test D\D2 ≈ Diagonal(D2.diag./D.diag)
+            # test triu/tril
+            @test istriu(D)
+            @test istril(D)
+            @test triu(D,1)  == zeros(D)
+            @test triu(D,0)  == D
+            @test triu(D,-1) == D
+            @test tril(D,1)  == D
+            @test tril(D,-1) == zeros(D)
+            @test tril(D,0)  == D
+            @test_throws ArgumentError tril(D,n+1)
+            @test_throws ArgumentError triu(D,n+1)
+
+            # factorize
+            @test factorize(D) == D
+
+            debug && println("Eigensystem")
+            eigD = eigfact(D)
+            @test Diagonal(eigD[:values]) ≈ D
+            @test eigD[:vectors] == eye(D)
+
+            debug && println("ldiv")
+            v = rand(n + 1)
+            @test_throws DimensionMismatch D\v
+            v = rand(n)
+            @test D\v ≈ DM\v
+            V = rand(n + 1, n)
+            @test_throws DimensionMismatch D\V
+            V = rand(n, n)
+            @test D\V ≈ DM\V
+
+            debug && println("conj and transpose")
+            @test transpose(D) == D
+            if elty <: BlasComplex
+                @test full(conj(D)) ≈ conj(DM)
+                @test ctranspose(D) == conj(D)
+            end
 
-    #10036
-    @test issym(D2)
-    @test ishermitian(D2)
-    if elty <: Complex
-        dc = d + im*convert(Vector{elty}, ones(n))
-        D3 = Diagonal(dc)
-        @test issym(D3)
-        @test !ishermitian(D3)
-    end
+            #logdet
+            if relty <: Real
+                ld=convert(Vector{relty},rand(n))
+                @test logdet(Diagonal(ld)) ≈ logdet(diagm(ld))
+            end
 
-    U, s, V = svd(D)
-    @test (U*Diagonal(s))*V' ≈ D
-    @test svdvals(D) == s
-    @test svdfact(D)[:V] == V
+            #similar
+            @test isa(similar(D), Diagonal{elty})
+            @test isa(similar(D, Int), Diagonal{Int})
+            @test isa(similar(D, (3,2)), Matrix{elty})
+            @test isa(similar(D, Int, (3,2)), Matrix{Int})
+
+            #10036
+            @test issymmetric(D2)
+            @test ishermitian(D2)
+            if elty <: Complex
+                dc = d + im*convert(Vector{elty}, ones(n))
+                D3 = Diagonal(dc)
+                @test issymmetric(D3)
+                @test !ishermitian(D3)
+            end
 
+            U, s, V = svd(D)
+            @test (U*Diagonal(s))*V' ≈ D
+            @test svdvals(D) == s
+            @test svdfact(D)[:V] == V
+        end
+    end
 end
 
 D = Diagonal(Matrix{Float64}[randn(3,3), randn(2,2)])
@@ -210,7 +227,18 @@ let d = randn(n), D = Diagonal(d)
 end
 
 # inv
-let d = randn(n), D = Diagonal(d)
+for d in (randn(n), [1, 2, 3], [1im, 2im, 3im])
+    D = Diagonal(d)
     @test inv(D) ≈ inv(full(D))
 end
 @test_throws SingularException inv(Diagonal(zeros(n)))
+@test_throws SingularException inv(Diagonal([0, 1, 2]))
+@test_throws SingularException inv(Diagonal([0im, 1im, 2im]))
+
+# allow construct from range
+@test Diagonal(linspace(1,3,3)) == Diagonal([1.,2.,3.])
+
+# Issue 12803
+for t in (Float32, Float64, Int, Complex{Float64}, Rational{Int})
+    @test Diagonal(Matrix{t}[ones(t, 2, 2), ones(t, 3, 3)])[2,1] == zeros(t, 3, 2)
+end
diff --git a/test/linalg/eigen.jl b/test/linalg/eigen.jl
index 8ef499beb9bad..cbddd64b93044 100644
--- a/test/linalg/eigen.jl
+++ b/test/linalg/eigen.jl
@@ -22,6 +22,12 @@ for eltya in (Float32, Float64, Complex64, Complex128, Int)
     apd  = a'*a                 # symmetric positive-definite
     ε = εa = eps(abs(float(one(eltya))))
 
+    α = rand(eltya)
+    β = rand(eltya)
+    eab = eig(α,β)
+    @test eab[1] == eigvals(fill(α,1,1),fill(β,1,1))
+    @test eab[2] == eigvecs(fill(α,1,1),fill(β,1,1))
+
 debug && println("\ntype of a: ", eltya,"\n")
 debug && println("non-symmetric eigen decomposition")
     d,v   = eig(a)
@@ -44,7 +50,7 @@ debug && println("symmetric generalized eigenproblem")
     asym_sg = asym[1:n1, 1:n1]
     a_sg = a[:,n1+1:n2]
     f = eigfact(asym_sg, a_sg'a_sg)
-    @test_approx_eq asym_sg*f[:vectors] scale(a_sg'a_sg*f[:vectors], f[:values])
+    @test_approx_eq asym_sg*f[:vectors] (a_sg'a_sg*f[:vectors]) * Diagonal(f[:values])
     @test_approx_eq f[:values] eigvals(asym_sg, a_sg'a_sg)
     @test_approx_eq_eps prod(f[:values]) prod(eigvals(asym_sg/(a_sg'a_sg))) 200ε
     @test eigvecs(asym_sg, a_sg'a_sg) == f[:vectors]
@@ -60,7 +66,7 @@ debug && println("Non-symmetric generalized eigenproblem")
     a1_nsg = a[1:n1, 1:n1]
     a2_nsg = a[n1+1:n2, n1+1:n2]
     f = eigfact(a1_nsg, a2_nsg)
-    @test_approx_eq a1_nsg*f[:vectors] scale(a2_nsg*f[:vectors], f[:values])
+    @test_approx_eq a1_nsg*f[:vectors] (a2_nsg*f[:vectors]) * Diagonal(f[:values])
     @test_approx_eq f[:values] eigvals(a1_nsg, a2_nsg)
     @test_approx_eq_eps prod(f[:values]) prod(eigvals(a1_nsg/a2_nsg)) 50000ε
     @test eigvecs(a1_nsg, a2_nsg) == f[:vectors]
@@ -70,3 +76,9 @@ debug && println("Non-symmetric generalized eigenproblem")
     @test d == f[:values]
     @test v == f[:vectors]
 end
+
+# test a matrix larger than 140-by-140 for #14174
+let a = rand(200, 200)
+    f = eigfact(a)
+    @test a ≈ f[:vectors] * Diagonal(f[:values]) / f[:vectors]
+end
diff --git a/test/linalg/generic.jl b/test/linalg/generic.jl
index a1ce1a5061419..8034dae36954b 100644
--- a/test/linalg/generic.jl
+++ b/test/linalg/generic.jl
@@ -1,7 +1,26 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+import Base: *
 using Base.Test
 
+# A custom Quaternion type with minimal defined interface and methods.
+# Used to test scale and scale! methods to show non-commutativity.
+immutable Quaternion{T<:Real} <: Number
+    s::T
+    v1::T
+    v2::T
+    v3::T
+    norm::Bool
+end
+Quaternion(s::Real, v1::Real, v2::Real, v3::Real, n::Bool = false) =
+    Quaternion( promote(s, v1, v2, v3)..., n)
+Quaternion(a::Vector) = Quaternion(0, a[1], a[2], a[3])
+(*)(q::Quaternion, w::Quaternion) = Quaternion(q.s*w.s - q.v1*w.v1 - q.v2*w.v2 - q.v3*w.v3,
+                                               q.s*w.v1 + q.v1*w.s + q.v2*w.v3 - q.v3*w.v2,
+                                               q.s*w.v2 - q.v1*w.v3 + q.v2*w.s + q.v3*w.v1,
+                                               q.s*w.v3 + q.v1*w.v2 - q.v2*w.v1 + q.v3*w.s,
+                                               q.norm && w.norm)
+
 debug = false
 
 srand(123)
@@ -22,11 +41,13 @@ for elty in (Int, Rational{BigInt}, Float32, Float64, BigFloat, Complex{Float32}
     debug && println("element type: $elty")
 
     @test_approx_eq logdet(A) log(det(A))
+    @test_approx_eq logabsdet(A)[1] log(abs(det(A)))
+    @test logabsdet(convert(Matrix{elty}, -eye(n)))[2] == -1
     if elty <: Real
-        @test_approx_eq logabsdet(A)[1] log(abs(det(A)))
-        @test logabsdet(A)[2] == sign(abs(det(A)))
+        @test logabsdet(A)[2] == sign(det(A))
         @test_throws DomainError logdet(convert(Matrix{elty}, -eye(n)))
-        @test logabsdet(convert(Matrix{elty}, -eye(n)))[2] == -1
+    else
+        @test logabsdet(A)[2] ≈ sign(det(A))
     end
 end
 
@@ -36,6 +57,10 @@ let X = [3  9   5;
          2  1  10]
     @test diff(X,1) == [4  -5 -3; -5  -3  8]
     @test diff(X,2) == [6 -4; -3 -2; -1 9]
+    @test diff(sub(X, 1:2, 1:2),1) == [4 -5]
+    @test diff(sub(X, 1:2, 1:2),2) == reshape([6; -3], (2,1))
+    @test diff(sub(X, 2:3, 2:3),1) == [-3 8]
+    @test diff(sub(X, 2:3, 2:3),2) == reshape([-2; 9], (2,1))
     @test_throws ArgumentError diff(X,3)
     @test_throws ArgumentError diff(X,-1)
 end
@@ -43,11 +68,13 @@ end
 x = float([1:12;])
 y = [5.5; 6.3; 7.6; 8.8; 10.9; 11.79; 13.48; 15.02; 17.77; 20.81; 22.0; 22.99]
 @test_approx_eq linreg(x,y) [2.5559090909090867, 1.6960139860139862]
+@test_approx_eq linreg(sub(x,1:6),sub(y,1:6)) [3.8366666666666642,1.3271428571428574]
 
 # test diag
 let A = eye(4)
     @test diag(A) == ones(4)
     @test diag(sub(A, 1:3, 1:3)) == ones(3)
+    @test diag(sub(A, 1:2, 1:2)) == ones(2)
 end
 
 # test generic axpy
@@ -62,58 +89,80 @@ y = ['a','b','c','d','e']
 @test_throws DimensionMismatch Base.LinAlg.axpy!(α,x,collect(1:2),['a','b'],collect(1:2))
 
 @test_throws ArgumentError diag(rand(10))
-@test !issym(ones(5,3))
+@test !issymmetric(ones(5,3))
 @test !ishermitian(ones(5,3))
 @test cross(ones(3),ones(3)) == zeros(3)
 
 @test trace(Bidiagonal(ones(5),zeros(4),true)) == 5
 
-# 2-argument version of scale
-a = reshape([1.:6;], (2,3))
-@test scale(a, 5.) == a*5
-@test scale(5., a) == a*5
-@test scale(a, [1.; 2.; 3.]) == a.*[1 2 3]
-@test scale([1.; 2.], a) == a.*[1; 2]
-@test scale(a, [1; 2; 3]) == a.*[1 2 3]
-@test scale([1; 2], a) == a.*[1; 2]
-@test scale(eye(Int, 2), 0.5) == 0.5*eye(2)
-@test_throws DimensionMismatch scale(a, ones(2))
-@test_throws DimensionMismatch scale(ones(3), a)
-
-# 2-argument version of scale!
-@test scale!(copy(a), 5.) == a*5
-@test scale!(5., copy(a)) == a*5
-b = randn(Base.LinAlg.SCAL_CUTOFF) # make sure we try BLAS path
-@test scale!(copy(b), 5.) == b*5
-@test scale!(copy(a), [1.; 2.; 3.]) == a.*[1 2 3]
-@test scale!([1.; 2.], copy(a)) == a.*[1; 2]
-@test scale!(copy(a), [1; 2; 3]) == a.*[1 2 3]
-@test scale!([1; 2], copy(a)) == a.*[1; 2]
-@test_throws DimensionMismatch scale!(a, ones(2))
-@test_throws DimensionMismatch scale!(ones(3), a)
-
-# 3-argument version of scale!
-@test scale!(similar(a), 5., a) == a*5
-@test scale!(similar(a), a, 5.) == a*5
-@test scale!(similar(a), a, [1.; 2.; 3.]) == a.*[1 2 3]
-@test scale!(similar(a), [1.; 2.], a) == a.*[1; 2]
-@test scale!(similar(a), a, [1; 2; 3]) == a.*[1 2 3]
-@test scale!(similar(a), [1; 2], a) == a.*[1; 2]
-@test_throws DimensionMismatch scale!(similar(a), a, ones(2))
-@test_throws DimensionMismatch scale!(similar(a), ones(3), a)
-@test_throws DimensionMismatch scale!(Array(Float64, 3, 2), a, ones(3))
+
+# array and subarray tests
+let aa = reshape([1.:6;], (2,3))
+    for atype in ("Array", "SubArray")
+        if atype == "Array"
+            a = aa
+        else
+            a = sub(aa, 1:2, 1:2)
+        end
+
+        # 2-argument version of scale!
+        @test scale!(copy(a), 5.) == a*5
+        @test scale!(5., copy(a)) == a*5
+        b = randn(Base.LinAlg.SCAL_CUTOFF) # make sure we try BLAS path
+        subB = sub(b, :, :)
+        @test scale!(copy(b), 5.) == b*5
+        @test scale!(copy(subB), 5.) == subB*5
+        @test scale!([1.; 2.], copy(a)) == a.*[1; 2]
+        @test scale!([1; 2], copy(a)) == a.*[1; 2]
+        @test_throws DimensionMismatch scale!(ones(3), a)
+
+        if atype == "Array"
+            @test scale!(copy(a), [1.; 2.; 3.]) == a.*[1 2 3]
+            @test scale!(copy(a), [1; 2; 3]) == a.*[1 2 3]
+            @test_throws DimensionMismatch scale!(a, ones(2))
+        else
+            @test scale!(copy(a), [1.; 2.]) == a.*[1 2]
+            @test scale!(copy(a), [1; 2]) == a.*[1 2]
+            @test_throws DimensionMismatch scale!(a, ones(3))
+        end
+
+        # 3-argument version of scale!
+        @test scale!(similar(a), 5., a) == a*5
+        @test scale!(similar(a), a, 5.) == a*5
+        @test scale!(similar(a), [1.; 2.], a) == a.*[1; 2]
+        @test scale!(similar(a), [1; 2], a) == a.*[1; 2]
+        @test_throws DimensionMismatch scale!(similar(a), ones(3), a)
+        @test_throws DimensionMismatch scale!(Array(Float64, 3, 2), a, ones(3))
+
+        if atype == "Array"
+            @test scale!(similar(a), a, [1.; 2.; 3.]) == a.*[1 2 3]
+            @test scale!(similar(a), a, [1; 2; 3]) == a.*[1 2 3]
+            @test_throws DimensionMismatch scale!(similar(a), a, ones(2))
+        else
+            @test scale!(similar(a), a, [1.; 2.]) == a.*[1 2]
+            @test scale!(similar(a), a, [1; 2]) == a.*[1 2]
+            @test_throws DimensionMismatch scale!(similar(a), a, ones(3))
+        end
+    end
+end
 
 # scale real matrix by complex type
 @test_throws InexactError scale!([1.0], 2.0im)
-@test isequal(scale([1.0], 2.0im),             Complex{Float64}[2.0im])
-@test isequal(scale(2.0im, [1.0]),             Complex{Float64}[2.0im])
-@test isequal(scale(Float32[1.0], 2.0f0im),    Complex{Float32}[2.0im])
-@test isequal(scale(Float32[1.0], 2.0im),      Complex{Float64}[2.0im])
-@test isequal(scale(Float64[1.0], 2.0f0im),    Complex{Float64}[2.0im])
-@test isequal(scale(Float32[1.0], big(2.0)im), Complex{BigFloat}[2.0im])
-@test isequal(scale(Float64[1.0], big(2.0)im), Complex{BigFloat}[2.0im])
-@test isequal(scale(BigFloat[1.0], 2.0im),     Complex{BigFloat}[2.0im])
-@test isequal(scale(BigFloat[1.0], 2.0f0im),   Complex{BigFloat}[2.0im])
+@test isequal([1.0] * 2.0im,             Complex{Float64}[2.0im])
+@test isequal(2.0im * [1.0],             Complex{Float64}[2.0im])
+@test isequal(Float32[1.0] * 2.0f0im,    Complex{Float32}[2.0im])
+@test isequal(Float32[1.0] * 2.0im,      Complex{Float64}[2.0im])
+@test isequal(Float64[1.0] * 2.0f0im,    Complex{Float64}[2.0im])
+@test isequal(Float32[1.0] * big(2.0)im, Complex{BigFloat}[2.0im])
+@test isequal(Float64[1.0] * big(2.0)im, Complex{BigFloat}[2.0im])
+@test isequal(BigFloat[1.0] * 2.0im,     Complex{BigFloat}[2.0im])
+@test isequal(BigFloat[1.0] * 2.0f0im,   Complex{BigFloat}[2.0im])
+
+# test scale and scale! for non-commutative multiplication
+q = Quaternion([0.44567, 0.755871, 0.882548, 0.423612])
+qmat = []
+push!(qmat, Quaternion([0.015007, 0.355067, 0.418645, 0.318373]))
+@test scale!(q, copy(qmat)) != scale!(copy(qmat), q)
 
 # test ops on Numbers
 for elty in [Float32,Float64,Complex64,Complex128]
@@ -124,7 +173,7 @@ for elty in [Float32,Float64,Complex64,Complex128]
     @test !isfinite(cond(zero(elty)))
     @test cond(a)          == one(elty)
     @test cond(a,1)        == one(elty)
-    @test issym(a)
+    @test issymmetric(a)
     @test ishermitian(one(elty))
     @test det(a) == a
 end
@@ -141,3 +190,41 @@ let x = Vector{Int}[[1,2], [3,4]]
     @test norm(x, 1) ≈ sqrt(5) + 5
     @test norm(x, 3) ≈ cbrt(sqrt(125)+125)
 end
+
+# test that LinAlg.axpy! works for element type without commutative multiplication
+let
+    α = ones(Int, 2, 2)
+    x = fill([1 0; 1 1], 3)
+    y = fill(zeros(Int, 2, 2), 3)
+    @test LinAlg.axpy!(α, x, deepcopy(y)) == x .* Matrix{Int}[α]
+    @test LinAlg.axpy!(α, x, deepcopy(y)) != Matrix{Int}[α] .* x
+end
+
+let
+    vr = [3.0, 4.0]
+    for Tr in (Float32, Float64)
+        for T in (Tr, Complex{Tr})
+            v = convert(Vector{T}, vr)
+            @test norm(v) == 5.0
+            w = normalize(v)
+            @test norm(w - [0.6, 0.8], Inf) < eps(Tr)
+            @test norm(w) == 1.0
+            @test norm(normalize!(copy(v)) - w, Inf) < eps(Tr)
+        end
+    end
+end
+
+#Test potential overflow in normalize!
+let
+    δ = inv(prevfloat(typemax(Float64)))
+    v = [δ, -δ]
+
+    @test norm(v) === 7.866824069956793e-309
+    w = normalize(v)
+    @test w ≈ [1/√2, -1/√2]
+    @test norm(w) === 1.0
+    @test norm(normalize!(v) - w, Inf) < eps()
+end
+
+# Issue 14657
+@test det([true false; false true]) == det(eye(Int, 2))
diff --git a/test/linalg/givens.jl b/test/linalg/givens.jl
index 1b8b73b45de8c..68592d6a5745f 100644
--- a/test/linalg/givens.jl
+++ b/test/linalg/givens.jl
@@ -24,6 +24,8 @@ for elty in (Float32, Float64, Complex64, Complex128)
             A_mul_Bc!(A, G)
             A_mul_B!(G, R)
 
+            @test A_mul_B!(G,eye(elty,10,10)) == [G[i,j] for i=1:10,j=1:10]
+
             # test transposes
             @test_approx_eq ctranspose(G)*G*eye(10) eye(elty, 10)
             @test_approx_eq ctranspose(R)*(R*eye(10)) eye(elty, 10)
@@ -31,8 +33,8 @@ for elty in (Float32, Float64, Complex64, Complex128)
             @test_throws ErrorException transpose(R)
         end
     end
-    @test_throws ArgumentError givens(A, 3, 2, 2)
-    @test_throws ArgumentError givens(one(elty),zero(elty),3,2)
+    @test_throws ArgumentError givens(A, 3, 3, 2)
+    @test_throws ArgumentError givens(one(elty),zero(elty),2,2)
     G, _ = givens(one(elty),zero(elty),11,12)
     @test_throws DimensionMismatch A_mul_B!(G, A)
     @test_throws DimensionMismatch A_mul_Bc!(A,G)
@@ -50,5 +52,13 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test (G*x)[2] ≈ r
     @test abs((G*x)[4]) < eps(real(elty))
 
+    x = A[:,1]
+    G, r = givens(x, 2, 4)
+    @test (G*x)[2] ≈ r
+    @test abs((G*x)[4]) < eps(real(elty))
+
+    G, r = givens(x, 4, 2)
+    @test (G*x)[4] ≈ r
+    @test abs((G*x)[2]) < eps(real(elty))
 end
 end #let
diff --git a/test/linalg/lapack.jl b/test/linalg/lapack.jl
index 2f68d611546e7..8b33caec387ea 100644
--- a/test/linalg/lapack.jl
+++ b/test/linalg/lapack.jl
@@ -16,7 +16,7 @@ let # syevr
         A = convert(Array{elty, 2}, A)
         Asym = A'A
         vals, Z = LAPACK.syevr!('V', copy(Asym))
-        @test_approx_eq Z*scale(vals, Z') Asym
+        @test_approx_eq Z * (Diagonal(vals) * Z') Asym
         @test all(vals .> 0.0)
         @test_approx_eq LAPACK.syevr!('N','V','U',copy(Asym),0.0,1.0,4,5,-1.0)[1] vals[vals .< 1.0]
         @test_approx_eq LAPACK.syevr!('N','I','U',copy(Asym),0.0,1.0,4,5,-1.0)[1] vals[4:5]
@@ -36,7 +36,7 @@ let # Test gglse
     end
 end
 
-let # bdsqr & throw for bdsdc
+let # gebrd, bdsqr & throw for bdsdc
     n = 10
     for elty in (Float32, Float64)
         d, e = convert(Vector{elty}, randn(n)), convert(Vector{elty}, randn(n - 1))
@@ -51,6 +51,13 @@ let # bdsqr & throw for bdsdc
         @test_throws DimensionMismatch LAPACK.bdsqr!('U', d, e, Vt, U, C[1:end - 1, :])
 
         @test_throws ArgumentError LAPACK.bdsdc!('U','Z',d,e)
+
+        A = rand(elty,n,n)
+        B = copy(A)
+        B, d, e, tauq, taup = LAPACK.gebrd!(B)
+        U, Vt, C = eye(elty, n), eye(elty, n), eye(elty, n)
+        s, _ = LAPACK.bdsqr!('U',d,e[1:n-1],Vt, U, C)
+        @test s ≈ svdvals(A)
     end
 end
 
@@ -144,7 +151,12 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test_approx_eq S lS
     @test_approx_eq V' lVt
     B = rand(elty,10,10)
-    @test_throws DimensionMismatch LAPACK.ggsvd!('S','S','S',A,B)
+    # xggsvd3 replaced xggsvd in LAPACK 3.6.0
+    if LAPACK.VERSION[] < v"3.6.0"
+        @test_throws DimensionMismatch LAPACK.ggsvd!('S','S','S',A,B)
+    else
+        @test_throws DimensionMismatch LAPACK.ggsvd3!('S','S','S',A,B)
+    end
 end
 
 #geevx, ggev errors
@@ -234,8 +246,7 @@ end
 #orglq and friends errors
 for elty in (Float32, Float64, Complex64, Complex128)
     A = rand(elty,10,10)
-    tau = zeros(elty,10)
-    A,tau = LAPACK.gelqf!(A,tau)
+    A,tau = LAPACK.gelqf!(A)
     @test_throws DimensionMismatch LAPACK.orglq!(A,tau,11)
     @test_throws DimensionMismatch LAPACK.ormlq!('R','N',A,tau,rand(elty,11,11))
     @test_throws DimensionMismatch LAPACK.ormlq!('L','N',A,tau,rand(elty,11,11))
@@ -247,8 +258,7 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test LAPACK.ormlq!('R','N',A,tau,eye(elty,10)) ≈ C
 
     A = rand(elty,10,10)
-    tau = zeros(elty,10)
-    A,tau = LAPACK.geqrf!(A,tau)
+    A,tau = LAPACK.geqrf!(A)
     @test_throws DimensionMismatch LAPACK.orgqr!(A,tau,11)
     B = copy(A)
     @test LAPACK.orgqr!(B,tau) ≈ LAPACK.ormqr!('R','N',A,tau,eye(elty,10))
@@ -258,8 +268,7 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test_throws DimensionMismatch LAPACK.ormqr!('L','N',A,zeros(elty,11),rand(elty,10,10))
 
     A = rand(elty,10,10)
-    tau = zeros(elty,10)
-    A,tau = LAPACK.geqlf!(A,tau)
+    A,tau = LAPACK.geqlf!(A)
     @test_throws DimensionMismatch LAPACK.orgql!(A,tau,11)
     B = copy(A)
     @test LAPACK.orgql!(B,tau) ≈ LAPACK.ormql!('R','N',A,tau,eye(elty,10))
@@ -269,8 +278,7 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test_throws DimensionMismatch LAPACK.ormql!('L','N',A,zeros(elty,11),rand(elty,10,10))
 
     A = rand(elty,10,10)
-    tau = zeros(elty,10)
-    A,tau = LAPACK.gerqf!(A,tau)
+    A,tau = LAPACK.gerqf!(A)
     @test_throws DimensionMismatch LAPACK.orgrq!(A,tau,11)
     B = copy(A)
     @test LAPACK.orgrq!(B,tau) ≈ LAPACK.ormrq!('R','N',A,tau,eye(elty,10))
@@ -314,6 +322,23 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test LAPACK.sytrf!('U',zeros(elty,0,0)) == (zeros(elty,0,0),zeros(BlasInt,0))
 end
 
+for elty in (Float32, Float64, Complex64, Complex128)
+    A = rand(elty,10,10)
+    A = A + A.' #symmetric!
+    B = copy(A)
+    B,ipiv = LAPACK.sytrf_rook!('U',B)
+    @test_approx_eq triu(inv(A)) triu(LAPACK.sytri_rook!('U',B,ipiv))
+    @test_throws DimensionMismatch LAPACK.sytrs_rook!('U',B,ipiv,rand(elty,11,5))
+    @test LAPACK.sytrf_rook!('U',zeros(elty,0,0)) == (zeros(elty,0,0),zeros(BlasInt,0))
+    A = rand(elty,10,10)
+    A = A + A.' #symmetric!
+    b = rand(elty,10)
+    c = A \ b
+    b,A = LAPACK.sysv_rook!('U',A,b)
+    @test_approx_eq b c
+    @test_throws DimensionMismatch LAPACK.sysv_rook!('U',A,rand(elty,11))
+end
+
 # hetrs
 for elty in (Complex64, Complex128)
     A = rand(elty,10,10)
@@ -373,6 +398,13 @@ for elty in (Complex64, Complex128)
     b,A = LAPACK.hesv!('U',A,b)
     @test_approx_eq b c
     @test_throws DimensionMismatch LAPACK.hesv!('U',A,rand(elty,11))
+    A = rand(elty,10,10)
+    A = A + A' #hermitian!
+    b = rand(elty,10)
+    c = A \ b
+    b,A = LAPACK.hesv_rook!('U',A,b)
+    @test_approx_eq b c
+    @test_throws DimensionMismatch LAPACK.hesv_rook!('U',A,rand(elty,11))
 end
 
 #ptsv
@@ -429,6 +461,8 @@ for elty in (Float32, Float64, Complex64, Complex128)
     @test_approx_eq A\B C
     @test_throws DimensionMismatch LAPACK.posv!('U',D,ones(elty,12,12))
     @test_throws DimensionMismatch LAPACK.potrs!('U',D,ones(elty,12,12))
+
+    @test LAPACK.potrs!('U',zeros(elty,0,0),ones(elty,0)) == ones(elty,0)
 end
 
 #gesvx
@@ -518,10 +552,19 @@ for elty in (Float32, Float64, Complex{Float32}, Complex{Float64})
         end
 
         ## QR
-        FJulia  = invoke(qrfact!, Tuple{AbstractMatrix, Type{Val{false}}},
-                         copy(A), Val{false})
+        FJulia  = LinAlg.qrfactUnblocked!(copy(A))
         FLAPACK = Base.LinAlg.LAPACK.geqrf!(copy(A))
         @test_approx_eq FJulia.factors FLAPACK[1]
         @test_approx_eq FJulia.τ FLAPACK[2]
     end
 end
+
+# Issue 13976
+let A = [NaN 0.0 NaN; 0 0 0; NaN 0 NaN]
+    @test_throws ArgumentError expm(A)
+end
+
+# Issue 14065 (and 14220)
+let A = [NaN NaN; NaN NaN]
+    @test_throws ArgumentError eigfact(A)
+end
diff --git a/test/linalg/lq.jl b/test/linalg/lq.jl
new file mode 100644
index 0000000000000..9fdb40f3361d0
--- /dev/null
+++ b/test/linalg/lq.jl
@@ -0,0 +1,85 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+debug = false
+using Base.Test
+
+using Base.LinAlg: BlasComplex, BlasFloat, BlasReal
+
+
+n = 10
+
+# Split n into 2 parts for tests needing two matrices
+n1 = div(n, 2)
+n2 = 2*n1
+
+srand(1234321)
+
+areal = randn(n,n)/2
+aimg  = randn(n,n)/2
+a2real = randn(n,n)/2
+a2img  = randn(n,n)/2
+breal = randn(n,2)/2
+bimg  = randn(n,2)/2
+
+for eltya in (Float32, Float64, Complex64, Complex128)
+    a = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex(areal, aimg) : areal)
+    a2 = eltya == Int ? rand(1:7, n, n) : convert(Matrix{eltya}, eltya <: Complex ? complex(a2real, a2img) : a2real)
+    asym = a'+a                  # symmetric indefinite
+    apd  = a'*a                 # symmetric positive-definite
+    ε = εa = eps(abs(float(one(eltya))))
+
+    for eltyb in (Float32, Float64, Complex64, Complex128, Int)
+        b = eltyb == Int ? rand(1:5, n, 2) : convert(Matrix{eltyb}, eltyb <: Complex ? complex(breal, bimg) : breal)
+        εb = eps(abs(float(one(eltyb))))
+        ε = max(εa,εb)
+
+        α = rand(eltya)
+        aα = fill(α,1,1)
+        @test lqfact(α)[:L]*lqfact(α)[:Q] ≈ lqfact(aα)[:L]*lqfact(aα)[:Q]
+        @test lq(α)[1]*lq(α)[2] ≈ lqfact(aα)[:L]*lqfact(aα)[:Q]
+        @test abs(lqfact(α)[:Q][1,1]) ≈ one(eltya)
+        tab = promote_type(eltya,eltyb)
+
+debug && println("\ntype of a: ", eltya, " type of b: ", eltyb, "\n")
+debug && println("LQ decomposition")
+        for i = 1:2
+            let a = i == 1 ? a : sub(a, 1:n - 1, 1:n - 1), b = i == 1 ? b : sub(b, 1:n - 1), n = i == 1 ? n : n - 1
+                lqa   = lqfact(a)
+                l,q   = lqa[:L], lqa[:Q]
+                qra   = qrfact(a)
+                @test size(lqa,1) == size(a,1)
+                @test size(lqa,3) == 1
+                @test Base.LinAlg.getq(lqa) == lqa[:Q]
+                @test_throws KeyError lqa[:Z]
+                @test full(lqa') ≈ a'
+                @test lqa * lqa' ≈ a * a'
+                @test lqa' * lqa ≈ a' * a
+                @test q*full(q, thin = false)' ≈ eye(eltya,n)
+                @test l*q ≈ a
+                @test full(lqa) ≈ a
+                @test full(copy(lqa)) ≈ a
+                @test_approx_eq_eps a*(lqa\b) b 3000ε
+                @test_approx_eq_eps lqa*b qra[:Q]*qra[:R]*b 3000ε
+                @test_approx_eq_eps A_mul_Bc(eye(eltyb,size(q.factors,2)),q)*full(q, thin=false) eye(n) 5000ε
+                if eltya != Int
+                    @test eye(eltyb,n)*q ≈ convert(AbstractMatrix{tab},q)
+                end
+                @test_approx_eq_eps q*b full(q, thin=false)*b 100ε
+                @test_approx_eq_eps q'*b full(q, thin=false)'*b 100ε
+                @test_throws DimensionMismatch q*b[1:n1 + 1]
+                @test_throws DimensionMismatch Ac_mul_B(q,ones(eltya,n+2,n+2))
+                @test_throws DimensionMismatch ones(eltyb,n+2,n+2)*q
+            end
+        end
+
+debug && println("Matmul with LQ factorizations")
+        lqa = lqfact(a[:,1:n1])
+        l,q = lqa[:L], lqa[:Q]
+        @test full(q)*full(q)' ≈ eye(eltya,n1)
+        @test (full(q,thin=false)'*full(q,thin=false))[1:n1,:] ≈ eye(eltya,n1,n)
+        @test_throws DimensionMismatch A_mul_B!(eye(eltya,n+1),q)
+        @test Ac_mul_B!(q,full(q)) ≈ eye(eltya,n1)
+        @test_throws DimensionMismatch A_mul_Bc!(eye(eltya,n+1),q)
+        @test_throws BoundsError size(q,-1)
+    end
+end
diff --git a/test/linalg/lu.jl b/test/linalg/lu.jl
index 89d67e9fb7e6e..435013ac63cb0 100644
--- a/test/linalg/lu.jl
+++ b/test/linalg/lu.jl
@@ -140,7 +140,7 @@ nHilbert = 50
 H = Rational{BigInt}[1//(i+j-1) for i = 1:nHilbert,j = 1:nHilbert]
 Hinv = Rational{BigInt}[(-1)^(i+j)*(i+j-1)*binomial(nHilbert+i-1,nHilbert-j)*binomial(nHilbert+j-1,nHilbert-i)*binomial(i+j-2,i-1)^2 for i = big(1):nHilbert,j=big(1):nHilbert]
 @test inv(H) == Hinv
-with_bigfloat_precision(2^10) do
+setprecision(2^10) do
     @test norm(Array{Float64}(inv(float(H)) - float(Hinv))) < 1e-100
 end
 
diff --git a/test/linalg/matmul.jl b/test/linalg/matmul.jl
index 0ccdcb0b9f917..1b21f6d215afb 100644
--- a/test/linalg/matmul.jl
+++ b/test/linalg/matmul.jl
@@ -32,6 +32,7 @@ Bi = B+(2.5*im).*A[[2,1],[2,1]]
 @test Ac_mul_B(Ai, Bi) == [68.5-12im 57.5-28im; 88-3im 76.5-25im]
 @test A_mul_Bc(Ai, Bi) == [64.5+5.5im 43+31.5im; 104-18.5im 80.5+31.5im]
 @test Ac_mul_Bc(Ai, Bi) == [-28.25-66im 9.75-58im; -26-89im 21-73im]
+@test_throws DimensionMismatch [1 2; 0 0; 0 0] * [1 2]
 
 # 3x3
 A = [1 2 3; 4 5 6; 7 8 9].-5
@@ -46,6 +47,7 @@ Bi = B+(2.5*im).*A[[2,1,3],[2,3,1]]
 @test Ac_mul_B(Ai, Bi) == [-21+2im -1.75+49im -51.25+19.5im; 25.5+56.5im -7-35.5im 22+35.5im; -3+12im -32.25+43im -34.75-2.5im]
 @test A_mul_Bc(Ai, Bi) == [-20.25+15.5im -28.75-54.5im 22.25+68.5im; -12.25+13im -15.5+75im -23+27im; 18.25+im 1.5+94.5im -27-54.5im]
 @test Ac_mul_Bc(Ai, Bi) == [1+2im 20.75+9im -44.75+42im; 19.5+17.5im -54-36.5im 51-14.5im; 13+7.5im 11.25+31.5im -43.25-14.5im]
+@test_throws DimensionMismatch [1 2 3; 0 0 0; 0 0 0] * [1 2 3]
 
 # Generic integer matrix multiplication
 A = [1 2 3; 4 5 6] .- 3
@@ -59,6 +61,9 @@ A = rand(1:20, 5, 5) .- 10
 B = rand(1:20, 5, 5) .- 10
 @test At_mul_B(A, B) == A'*B
 @test A_mul_Bt(A, B) == A*B'
+v = [1,2]
+C = Array(Int, 2, 2)
+@test @inferred(A_mul_Bc!(C, v, v)) == [1 2; 2 4]
 
 # Preallocated
 C = Array(Int, size(A, 1), size(B, 2))
@@ -66,6 +71,18 @@ C = Array(Int, size(A, 1), size(B, 2))
 @test At_mul_B!(C, A, B) == A'*B
 @test A_mul_Bt!(C, A, B) == A*B'
 @test At_mul_Bt!(C, A, B) == A'*B'
+@test Base.LinAlg.Ac_mul_Bt!(C, A, B) == A'*B.'
+
+#test DimensionMismatch for generic_matmatmul
+@test_throws DimensionMismatch Base.LinAlg.Ac_mul_Bt!(C,A,ones(Int,4,4))
+@test_throws DimensionMismatch Base.LinAlg.Ac_mul_Bt!(C,ones(Int,4,4),B)
+
+#and for generic_matvecmul
+A = rand(5,5)
+B = rand(5)
+@test_throws DimensionMismatch Base.LinAlg.generic_matvecmul!(zeros(6),'N',A,B)
+@test_throws DimensionMismatch Base.LinAlg.generic_matvecmul!(B,'N',A,zeros(6))
+
 v = [1,2,3]
 C = Array(Int, 3, 3)
 @test A_mul_Bt!(C, v, v) == v*v'
@@ -73,6 +90,14 @@ vf = map(Float64,v)
 C = Array(Float64, 3, 3)
 @test A_mul_Bt!(C, v, v) == v*v'
 
+# fallbacks & such for BlasFloats
+A = rand(Float64,6,6)
+B = rand(Float64,6,6)
+C = zeros(Float64,6,6)
+@test Base.LinAlg.At_mul_Bt!(C,A,B) == A.'*B.'
+@test Base.LinAlg.A_mul_Bc!(C,A,B) == A*B.'
+@test Base.LinAlg.Ac_mul_B!(C,A,B) == A.'*B
+
 # matrix algebra with subarrays of floats (stride != 1)
 A = reshape(map(Float64,1:20),5,4)
 Aref = A[1:2:end,1:2:end]
@@ -86,6 +111,16 @@ Aref = Ai[1:2:end,1:2:end]
 Asub = sub(Ai, 1:2:5, 1:2:4)
 @test Ac_mul_B(Asub, Asub) == Ac_mul_B(Aref, Aref)
 @test A_mul_Bc(Asub, Asub) == A_mul_Bc(Aref, Aref)
+# issue #15286
+let C = zeros(8, 8), sC = sub(C, 1:2:8, 1:2:8), B = reshape(map(Float64,-9:10),5,4)
+    @test At_mul_B!(sC, A, A) == A'*A
+    @test At_mul_B!(sC, A, B) == A'*B
+end
+let Aim = A .- im, C = zeros(Complex128,8,8), sC = sub(C, 1:2:8, 1:2:8), B = reshape(map(Float64,-9:10),5,4) .+ im
+    @test Ac_mul_B!(sC, Aim, Aim) == Aim'*Aim
+    @test Ac_mul_B!(sC, Aim, B) == Aim'*B
+end
+
 
 # syrk & herk
 A = reshape(1:1503, 501, 3).-750.0
@@ -166,3 +201,27 @@ for elty in [Float32,Float64,Complex128,Complex64]
     A = rand(elty,3,3)
     @test Base.LinAlg.matmul3x3('T','N',A,eye(elty,3)) == A.'
 end
+
+# 13593, #13488
+a = rand(3,3)
+b = rand(3,3)
+@test_throws ArgumentError A_mul_B!(a, a, b)
+@test_throws ArgumentError A_mul_B!(a, b, a)
+@test_throws ArgumentError A_mul_B!(a, a, a)
+
+# Number types that lack conversion to the destination type (#14293)
+immutable RootInt
+    i::Int
+end
+import Base: *, promote_op
+(*)(x::RootInt, y::RootInt) = x.i*y.i
+promote_op(::Base.MulFun, ::Type{RootInt}, ::Type{RootInt}) = Int
+
+a = [RootInt(3)]
+C = [0]
+A_mul_Bt!(C, a, a)
+@test C[1] == 9
+a = [RootInt(2),RootInt(10)]
+@test a*a' == [4 20; 20 100]
+A = [RootInt(3) RootInt(5)]
+@test A*a == [56]
diff --git a/test/linalg/qr.jl b/test/linalg/qr.jl
index cc77f34f4b072..519289dc225aa 100644
--- a/test/linalg/qr.jl
+++ b/test/linalg/qr.jl
@@ -54,6 +54,8 @@ debug && println("QR decomposition (without pivoting)")
                 @test_approx_eq_eps A_mul_Bc(eye(eltyb,size(q.factors,2)),q)*full(q, thin=false) eye(n) 5000ε
                 if eltya != Int
                     @test eye(eltyb,n)*q ≈ convert(AbstractMatrix{tab},q)
+                    ac = copy(a)
+                    @test qrfact!(a[:, 1:5])\b == qrfact!(sub(ac, :, 1:5))\b
                 end
 
 debug && println("Thin QR decomposition (without pivoting)")
@@ -73,21 +75,20 @@ debug && println("Thin QR decomposition (without pivoting)")
                     @test eye(eltyb,n)*q ≈ convert(AbstractMatrix{tab},q)
                 end
 
-debug && println("(Automatic) Fat (pivoted) QR decomposition") # Pivoting is only implemented for BlasFloats
-                if eltya <: BlasFloat
-                    @inferred qrfact(a, Val{true})
-                    @inferred qr(a, Val{true})
-                end
+debug && println("(Automatic) Fat (pivoted) QR decomposition")
+                @inferred qrfact(a, Val{true})
+                @inferred qr(a, Val{true})
+
                 qrpa  = factorize(a[1:n1,:])
                 q,r = qrpa[:Q], qrpa[:R]
                 @test_throws KeyError qrpa[:Z]
-                if isa(qrpa,QRPivoted) p = qrpa[:p] end # Reconsider if pivoted QR gets implemented in julia
+                p = qrpa[:p]
                 @test_approx_eq q'*full(q, thin=false) eye(n1)
                 @test_approx_eq q*full(q, thin=false)' eye(n1)
                 @test_approx_eq (UpperTriangular(eye(eltya,size(q,2)))*q')*full(q, thin=false) eye(n1)
                 @test_approx_eq q*r isa(qrpa,QRPivoted) ? a[1:n1,p] : a[1:n1,:]
-                @test_approx_eq isa(qrpa, QRPivoted) ? q*r[:,invperm(p)] : q*r a[1:n1,:]
-                @test_approx_eq isa(qrpa, QRPivoted) ? q*r*qrpa[:P].' : q*r a[1:n1,:]
+                @test_approx_eq q*r[:,invperm(p)] a[1:n1,:]
+                @test_approx_eq q*r*qrpa[:P].' a[1:n1,:]
                 @test_approx_eq_eps a[1:n1,:]*(qrpa\b[1:n1]) b[1:n1] 5000ε
                 @test_approx_eq full(qrpa) a[1:5,:]
                 @test_throws DimensionMismatch q*b[1:n1 + 1]
@@ -96,15 +97,15 @@ debug && println("(Automatic) Fat (pivoted) QR decomposition") # Pivoting is onl
                     @test eye(eltyb,n1)*q ≈ convert(AbstractMatrix{tab},q)
                 end
 
-debug && println("(Automatic) Thin (pivoted) QR decomposition") # Pivoting is only implemented for BlasFloats
+debug && println("(Automatic) Thin (pivoted) QR decomposition")
                 qrpa  = factorize(a[:,1:n1])
                 q,r = qrpa[:Q], qrpa[:R]
                 @test_throws KeyError qrpa[:Z]
-                if isa(qrpa, QRPivoted) p = qrpa[:p] end # Reconsider if pivoted QR gets implemented in julia
+                p = qrpa[:p]
                 @test_approx_eq q'*full(q, thin=false) eye(n)
                 @test_approx_eq q*full(q, thin=false)' eye(n)
-                @test_approx_eq q*r isa(qrpa, QRPivoted) ? a[:,p] : a[:,1:n1]
-                @test_approx_eq isa(qrpa, QRPivoted) ? q*r[:,invperm(p)] : q*r a[:,1:n1]
+                @test_approx_eq q*r a[:,p]
+                @test_approx_eq q*r[:,invperm(p)] a[:,1:n1]
                 @test_approx_eq full(qrpa) a[:,1:5]
                 @test_throws DimensionMismatch q*b[1:n1 + 1]
                 @test_throws DimensionMismatch b[1:n1 + 1]*q'
@@ -124,10 +125,8 @@ debug && println("Matmul with QR factorizations")
             @test_approx_eq A_mul_Bc!(full(q,thin=false),q) eye(n)
             @test_throws DimensionMismatch A_mul_Bc!(eye(eltya,n+1),q)
             @test_throws BoundsError size(q,-1)
-            if eltya == BigFloat
-                @test_throws DimensionMismatch Base.LinAlg.A_mul_B!(q,zeros(eltya,n1+1))
-                @test_throws DimensionMismatch Base.LinAlg.Ac_mul_B!(q,zeros(eltya,n1+1))
-            end
+            @test_throws DimensionMismatch Base.LinAlg.A_mul_B!(q,zeros(eltya,n1+1))
+            @test_throws DimensionMismatch Base.LinAlg.Ac_mul_B!(q,zeros(eltya,n1+1))
 
             qra   = qrfact(a[:,1:n1], Val{false})
             q,r   = qra[:Q], qra[:R]
@@ -161,12 +160,22 @@ end
 
 #Issue 7304
 let
-    A=[-√.5 -√.5; -√.5 √.5]
-    Q=full(qrfact(A)[:Q])
+    A = [-√.5 -√.5; -√.5 √.5]
+    Q = full(qrfact(A)[:Q])
     @test vecnorm(A-Q) < eps()
 end
 
-qrpa = qrfact(areal,Val{true})
-qrpa = convert(QRPivoted{BigFloat},qrpa)
-@test qrpa \ zeros(BigFloat,n) ≈ zeros(BigFloat,n)
-@test qrpa \ zeros(BigFloat,n,n) ≈ zeros(BigFloat,n,n)
+let
+    debug && println("qr on AbstractVector")
+
+    vr = [3.0, 4.0]
+    for Tr in (Float32, Float64)
+        for T in (Tr, Complex{Tr})
+            v = convert(Vector{T}, vr)
+            nv, nm = qr(v)
+            @test norm(nv - [0.6, 0.8], Inf) < eps(Tr)
+            @test nm == 5.0
+        end
+    end
+end
+
diff --git a/test/linalg/schur.jl b/test/linalg/schur.jl
index 1c96c25135bee..aa983d323c37e 100644
--- a/test/linalg/schur.jl
+++ b/test/linalg/schur.jl
@@ -43,8 +43,8 @@ debug && println("Reorder Schur")
     sum(select) != 0 && @test_approx_eq S[:values][find(select)] O[:values][1:sum(select)]
     @test_approx_eq O[:vectors]*O[:Schur]*O[:vectors]' ordschura
     @test_throws KeyError f[:A]
-    Snew = Base.LinAlg.Schur(copy(S.T),copy(S.Z),copy(S.values))
-    SchurNew = ordschur!(Snew,select)
+    Snew = Base.LinAlg.Schur(copy(S.T), copy(S.Z), copy(S.values))
+    SchurNew = ordschur!(Snew, select)
     @test O[:vectors] ≈ SchurNew[:vectors]
     @test O[:Schur] ≈ SchurNew[:Schur]
 
@@ -72,8 +72,8 @@ debug && println("Reorder Generalized Schur")
     # Make sure that we have sorted it correctly
     @test_approx_eq NS[:values][find(select)] S[:values][1:m]
 
-    Snew = Base.LinAlg.GeneralizedSchur(copy(NS.S),copy(NS.T),copy(NS.alpha),copy(NS.beta),copy(NS.Q),copy(NS.Z))
-    SchurNew = ordschur!(Snew,select)
+    Snew = Base.LinAlg.GeneralizedSchur(copy(NS.S), copy(NS.T), copy(NS.alpha), copy(NS.beta), copy(NS.Q), copy(NS.Z))
+    SchurNew = ordschur!(Snew, select)
     @test S[:Q] ≈ SchurNew[:Q]
     @test S[:S] ≈ SchurNew[:S]
     @test S[:T] ≈ SchurNew[:T]
diff --git a/test/linalg/svd.jl b/test/linalg/svd.jl
index 9431cf0d0884b..86985a429557b 100644
--- a/test/linalg/svd.jl
+++ b/test/linalg/svd.jl
@@ -30,7 +30,7 @@ debug && println("\ntype of a: ", eltya, "\n")
 debug && println("singular value decomposition")
     usv = svdfact(a)
     @test usv[:S] === svdvals(usv)
-    @test usv[:U]*scale(usv[:S],usv[:Vt]) ≈ a
+    @test usv[:U] * (Diagonal(usv[:S]) * usv[:Vt]) ≈ a
     @test full(usv) ≈ a
     @test usv[:Vt]' ≈ usv[:V]
     @test_throws KeyError usv[:Z]
diff --git a/test/linalg/symmetric.jl b/test/linalg/symmetric.jl
index 3d820b44fa12c..c6edbc1bfd6a2 100644
--- a/test/linalg/symmetric.jl
+++ b/test/linalg/symmetric.jl
@@ -46,15 +46,33 @@ let n=10
 
         debug && println("\ntype of a: ", eltya, "\n")
 
+        # similar
+        @test isa(similar(Symmetric(asym)), Symmetric{eltya})
+        @test isa(similar(Hermitian(asym)), Hermitian{eltya})
+        @test isa(similar(Symmetric(asym), Int), Symmetric{Int})
+        @test isa(similar(Hermitian(asym), Int), Hermitian{Int})
+        @test isa(similar(Symmetric(asym), (3,2)), Matrix{eltya})
+        @test isa(similar(Hermitian(asym), (3,2)), Matrix{eltya})
+        @test isa(similar(Symmetric(asym), Int, (3,2)), Matrix{Int})
+        @test isa(similar(Hermitian(asym), Int, (3,2)), Matrix{Int})
+
         # full
         @test asym == full(Hermitian(asym))
 
+        # parent
+
+        @test asym == parent(Hermitian(asym))
+
+        # getindex
+        @test asym[1,1] == Hermitian(asym)[1,1]
+        @test asym[1,1] == Symmetric(asym)[1,1]
+
         #trace
         @test trace(asym) == trace(Hermitian(asym))
 
-        # issym, ishermitian
+        # issymmetric, ishermitian
         if eltya <: Real
-            @test issym(Symmetric(asym))
+            @test issymmetric(Symmetric(asym))
             @test ishermitian(Symmetric(asym))
         end
         if eltya <: Complex
@@ -101,6 +119,16 @@ let n=10
         # cond
         @test cond(Hermitian(asym)) ≈ cond(asym)
 
+        # det
+        @test det(asym) ≈ det(Hermitian(asym, :U))
+        @test det(asym) ≈ det(Hermitian(asym, :L))
+        if eltya <: Real
+            @test det(asym) ≈ det(Symmetric(asym, :U))
+            @test det(asym) ≈ det(Symmetric(asym, :L))
+        end
+        @test det(a + a.') ≈ det(Symmetric(a + a.', :U))
+        @test det(a + a.') ≈ det(Symmetric(a + a.', :L))
+
         # rank
         let A = a[:,1:5]*a[:,1:5]'
             @test rank(A) == rank(Hermitian(A))
@@ -199,3 +227,9 @@ let A = [1.0+im 2.0; 2.0 0.0]
     @test !ishermitian(A)
     @test_throws ArgumentError Hermitian(A)
 end
+
+# Unary minus for Symmetric matrices
+let A = Symmetric(randn(5,5))
+    B = -A
+    @test A + B ≈ zeros(5,5)
+end
diff --git a/test/linalg/triangular.jl b/test/linalg/triangular.jl
index f7b7af9a73a05..bff1e05d4b050 100644
--- a/test/linalg/triangular.jl
+++ b/test/linalg/triangular.jl
@@ -2,7 +2,7 @@
 
 debug = false
 using Base.Test
-using Base.LinAlg: BlasFloat, errorbounds, full!, naivesub!, transpose!, UnitUpperTriangular, UnitLowerTriangular, A_rdiv_B!, A_rdiv_Bc!
+using Base.LinAlg: BlasFloat, errorbounds, full!, naivesub!, transpose!, UnitUpperTriangular, UnitLowerTriangular, A_rdiv_B!, A_rdiv_Bt!, A_rdiv_Bc!
 
 debug && println("Triangular matrices")
 
@@ -14,7 +14,7 @@ debug && println("Test basic type functionality")
 @test LowerTriangular(randn(3, 3)) |> t -> [size(t, i) for i = 1:3] == [size(full(t), i) for i = 1:3]
 
 # The following test block tries to call all methods in base/linalg/triangular.jl in order for a combination of input element types. Keep the ordering when adding code.
-for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
+for elty1 in (Float32, Float64, BigFloat, Complex64, Complex128, Complex{BigFloat}, Int)
     # Begin loop for first Triangular matrix
     for (t1, uplo1) in ((UpperTriangular, :U),
                         (UnitUpperTriangular, :U),
@@ -22,7 +22,7 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
                         (UnitLowerTriangular, :L))
 
         # Construct test matrix
-        A1 = t1(elty1 == Int ? rand(1:7, n, n) : convert(Matrix{elty1}, (elty1 <: Complex ? complex(randn(n, n), randn(n, n)) : randn(n, n)) |> t -> chol(t't, Val{uplo1})))
+        A1 = t1(elty1 == Int ? rand(1:7, n, n) : convert(Matrix{elty1}, (elty1 <: Complex ? complex(randn(n, n), randn(n, n)) : randn(n, n)) |> t -> chol(t't) |> t -> uplo1 == :U ? t : ctranspose(t)))
 
         debug && println("elty1: $elty1, A1: $t1")
 
@@ -38,14 +38,18 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
 
         # similar
         @test isa(similar(A1), t1)
-        @test_throws ArgumentError similar(A1,typeof(A1),(n,n+1))
-        @test_throws ArgumentError similar(A1,typeof(A1),(n,n,n))
+        @test eltype(similar(A1)) == elty1
+        @test isa(similar(A1, Int), t1)
+        @test eltype(similar(A1, Int)) == Int
+        @test isa(similar(A1, (3,2)), Matrix{elty1})
+        @test isa(similar(A1, Int, (3,2)), Matrix{Int})
 
         # getindex
         ## Linear indexing
         for i = 1:length(A1)
             @test A1[i] == full(A1)[i]
         end
+        @test isa(A1[2:4,1], Vector)
 
         ## Cartesian indexing
         for i = 1:size(A1, 1)
@@ -59,15 +63,23 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         for i = 1:size(A1, 1)
             for j = 1:size(A1, 2)
                 if uplo1 == :U
-                    if i > j || (i == j && t1 == UnitUpperTriangular)
-                        @test_throws BoundsError A1c[i,j] = 0
+                    if i > j
+                        A1c[i,j] = 0
+                        @test_throws ArgumentError A1c[i,j] = 1
+                    elseif i == j && t1 == UnitUpperTriangular
+                        A1c[i,j] = 1
+                        @test_throws ArgumentError A1c[i,j] = 0
                     else
                         A1c[i,j] = 0
                         @test A1c[i,j] == 0
                     end
                 else
-                    if i < j || (i == j && t1 == UnitLowerTriangular)
-                        @test_throws BoundsError A1c[i,j] = 0
+                    if i < j
+                        A1c[i,j] = 0
+                        @test_throws ArgumentError A1c[i,j] = 1
+                    elseif i == j && t1 == UnitLowerTriangular
+                        A1c[i,j] = 1
+                        @test_throws ArgumentError A1c[i,j] = 0
                     else
                         A1c[i,j] = 0
                         @test A1c[i,j] == 0
@@ -109,11 +121,21 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         # factorize
         @test factorize(A1) == A1
 
-        # (c)transpose
-        @test full(A1') == full(A1)'
-        @test full(A1.') == full(A1).'
-        @test transpose!(copy(A1)) == A1.'
-        @test ctranspose!(copy(A1)) == A1'
+        # [c]transpose[!] (test views as well, see issue #14317)
+        let vrange = 1:n-1, viewA1 = t1(sub(A1.data, vrange, vrange))
+            # transpose
+            @test full(A1.') == full(A1).'
+            @test full(viewA1.') == full(viewA1).'
+            # ctranspose
+            @test full(A1') == full(A1)'
+            @test full(viewA1') == full(viewA1)'
+            # transpose!
+            @test transpose!(copy(A1)) == A1.'
+            @test transpose!(t1(sub(copy(A1).data, vrange, vrange))) == viewA1.'
+            # ctranspose!
+            @test ctranspose!(copy(A1)) == A1'
+            @test ctranspose!(t1(sub(copy(A1).data, vrange, vrange))) == viewA1'
+        end
 
         # diag
         @test diag(A1) == diag(full(A1))
@@ -126,13 +148,30 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         # Unary operations
         @test full(-A1) == -full(A1)
 
-        # copy
-        B = similar(A1)
-        copy!(B,A1)
-        @test B == A1
-        B = similar(A1.')
-        copy!(B, A1.')
-        @test B == A1.'
+        # copy and copy! (test views as well, see issue #14317)
+        let vrange = 1:n-1, viewA1 = t1(sub(A1.data, vrange, vrange))
+            # copy
+            @test copy(A1) == copy(full(A1))
+            @test copy(viewA1) == copy(full(viewA1))
+            # copy!
+            B = similar(A1)
+            copy!(B, A1)
+            @test B == A1
+            B = similar(A1.')
+            copy!(B, A1.')
+            @test B == A1.'
+            B = similar(viewA1)
+            copy!(B, viewA1)
+            @test B == viewA1
+            B = similar(viewA1.')
+            copy!(B, viewA1.')
+            @test B == viewA1.'
+        end
+
+        #expm/logm
+        if (elty1 == Float64 || elty1 == Complex128) && (t1 == UpperTriangular || t1 == LowerTriangular)
+            @test expm(full(logm(A1))) ≈ full(A1)
+        end
 
         # scale
         if (t1 == UpperTriangular || t1 == LowerTriangular)
@@ -168,12 +207,6 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
             end
         end
 
-        @test scale(A1,0.5) == 0.5*A1
-        @test scale(0.5,A1) == 0.5*A1
-        @test scale(A1,0.5im) == 0.5im*A1
-        @test scale(0.5im,A1) == 0.5im*A1
-
-
         # Binary operations
         @test A1*0.5 == full(A1)*0.5
         @test 0.5*A1 == 0.5*full(A1)
@@ -199,7 +232,7 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         @test_throws DimensionMismatch naivesub!(A1,ones(elty1,n+1))
 
         # eigenproblems
-        if elty1 != BigFloat # Not handled yet
+        if !(elty1 in (BigFloat, Complex{BigFloat})) # Not handled yet
             vals, vecs = eig(A1)
             if (t1 == UpperTriangular || t1 == LowerTriangular) && elty1 != Int # Cannot really handle degenerate eigen space and Int matrices will probably have repeated eigenvalues.
                 @test_approx_eq_eps vecs*diagm(vals)/vecs full(A1) sqrt(eps(float(real(one(vals[1])))))*(norm(A1, Inf)*n)^2
@@ -214,7 +247,7 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
             @test cond(A1,2) == cond(full(A1),2)
         end
 
-        if elty1 != BigFloat # Not implemented yet
+        if !(elty1 in (BigFloat, Complex{BigFloat})) # Not implemented yet
             svd(A1)
             svdfact(A1)
             elty1 <: BlasFloat && svdfact!(copy(A1))
@@ -222,7 +255,7 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
         end
 
         # Begin loop for second Triangular matrix
-        for elty2 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
+        for elty2 in (Float32, Float64, BigFloat, Complex64, Complex128, Complex{BigFloat}, Int)
             for (t2, uplo2) in ((UpperTriangular, :U),
                                 (UnitUpperTriangular, :U),
                                 (LowerTriangular, :L),
@@ -230,7 +263,7 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
 
                 debug && println("elty1: $elty1, A1: $t1, elty2: $elty2")
 
-                A2 = t2(elty2 == Int ? rand(1:7, n, n) : convert(Matrix{elty2}, (elty2 <: Complex ? complex(randn(n, n), randn(n, n)) : randn(n, n)) |> t-> chol(t't, Val{uplo2})))
+                A2 = t2(elty2 == Int ? rand(1:7, n, n) : convert(Matrix{elty2}, (elty2 <: Complex ? complex(randn(n, n), randn(n, n)) : randn(n, n)) |> t -> chol(t't) |> t -> uplo2 == :U ? t : ctranspose(t)))
 
                 # Convert
                 if elty1 <: Real && !(elty2 <: Integer)
@@ -243,68 +276,100 @@ for elty1 in (Float32, Float64, Complex64, Complex128, BigFloat, Int)
                 @test full(A1 + A2) == full(A1) + full(A2)
                 @test full(A1 - A2) == full(A1) - full(A2)
 
-                # Triangular-Triangular multiplication and division
-                elty1 != BigFloat && elty2 != BigFloat && @test_approx_eq full(A1*A2) full(A1)*full(A2)
+                # Triangular-Triangualar multiplication and division
+                @test_approx_eq full(A1*A2) full(A1)*full(A2)
+                @test_approx_eq full(A1.'A2) full(A1).'full(A2)
                 @test_approx_eq full(A1'A2) full(A1)'full(A2)
+                @test_approx_eq full(A1*A2.') full(A1)*full(A2).'
                 @test_approx_eq full(A1*A2') full(A1)*full(A2)'
+                @test_approx_eq full(A1.'A2.') full(A1).'full(A2).'
                 @test_approx_eq full(A1'A2') full(A1)'full(A2)'
                 @test_approx_eq full(A1/A2) full(A1)/full(A2)
-                if elty2 != BigFloat
-                    @test_throws DimensionMismatch eye(n+1)/A2
-                    @test_throws DimensionMismatch eye(n+1)/A2'
-                    @test_throws DimensionMismatch eye(n+1)*A2
-                    @test_throws DimensionMismatch eye(n+1)*A2'
-                    @test_throws DimensionMismatch A2'*eye(n+1)
-                    @test_throws DimensionMismatch A2*eye(n+1)
-                    @test_throws DimensionMismatch A2*ones(n+1)
-                end
+                @test_throws DimensionMismatch eye(n+1)/A2
+                @test_throws DimensionMismatch eye(n+1)/A2.'
+                @test_throws DimensionMismatch eye(n+1)/A2'
+                @test_throws DimensionMismatch eye(n+1)*A2
+                @test_throws DimensionMismatch eye(n+1)*A2.'
+                @test_throws DimensionMismatch eye(n+1)*A2'
+                @test_throws DimensionMismatch A2.'*eye(n+1)
+                @test_throws DimensionMismatch A2'*eye(n+1)
+                @test_throws DimensionMismatch A2*eye(n+1)
+                @test_throws DimensionMismatch A2*ones(n+1) # redundant with immediately preceding test?
             end
         end
 
-        for eltyB in (Float32, Float64, Complex64, Complex128)
+        for eltyB in (Float32, Float64, BigFloat, Complex64, Complex128, Complex{BigFloat})
             B = convert(Matrix{eltyB}, elty1 <: Complex ? real(A1)*ones(n, n) : A1*ones(n, n))
 
             debug && println("elty1: $elty1, A1: $t1, B: $eltyB")
 
-            Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1))
-            @test_approx_eq Base.LinAlg.A_mul_B!(Tri,copy(A1)) Tri*full(A1)
+            if !(eltyB in (BigFloat, Complex{BigFloat})) # rand does not support BigFloat and Complex{BigFloat} as of Dec 2015
+                Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1))
+                @test_approx_eq Base.LinAlg.A_mul_B!(Tri,copy(A1)) Tri*full(A1)
+            end
 
             # Triangular-dense Matrix/vector multiplication
             @test_approx_eq A1*B[:,1] full(A1)*B[:,1]
             @test_approx_eq A1*B full(A1)*B
+            @test_approx_eq A1.'B[:,1] full(A1).'B[:,1]
             @test_approx_eq A1'B[:,1] full(A1)'B[:,1]
+            @test_approx_eq A1.'B full(A1).'B
             @test_approx_eq A1'B full(A1)'B
+            @test_approx_eq A1*B.' full(A1)*B.'
             @test_approx_eq A1*B' full(A1)*B'
             @test_approx_eq B*A1 B*full(A1)
+            @test_approx_eq B[:,1].'A1 B[:,1].'full(A1)
             @test_approx_eq B[:,1]'A1 B[:,1]'full(A1)
+            @test_approx_eq B.'A1 B.'full(A1)
             @test_approx_eq B'A1 B'full(A1)
+            @test_approx_eq B*A1.' B*full(A1).'
             @test_approx_eq B*A1' B*full(A1)'
+            @test_approx_eq B[:,1].'A1.' B[:,1].'full(A1).'
             @test_approx_eq B[:,1]'A1' B[:,1]'full(A1)'
+            @test_approx_eq B.'A1.' B.'full(A1).'
             @test_approx_eq B'A1' B'full(A1)'
 
+            if eltyB == elty1
+                @test_approx_eq A_mul_B!(zeros(B),A1,B) A1*B
+                @test_approx_eq A_mul_Bc!(zeros(B),A1,B) A1*B'
+                @test_approx_eq A_mul_Bt!(zeros(B),A1,B) A1*B.'
+            end
             #error handling
             @test_throws DimensionMismatch Base.LinAlg.A_mul_B!(A1, ones(eltyB,n+1))
             @test_throws DimensionMismatch Base.LinAlg.A_mul_B!(ones(eltyB,n+1,n+1), A1)
+            @test_throws DimensionMismatch Base.LinAlg.At_mul_B!(A1, ones(eltyB,n+1))
             @test_throws DimensionMismatch Base.LinAlg.Ac_mul_B!(A1, ones(eltyB,n+1))
             @test_throws DimensionMismatch Base.LinAlg.A_mul_Bc!(ones(eltyB,n+1,n+1),A1)
+            @test_throws DimensionMismatch Base.LinAlg.A_mul_Bt!(ones(eltyB,n+1,n+1),A1)
 
             # ... and division
             @test_approx_eq A1\B[:,1] full(A1)\B[:,1]
             @test_approx_eq A1\B full(A1)\B
+            @test_approx_eq A1.'\B[:,1] full(A1).'\B[:,1]
             @test_approx_eq A1'\B[:,1] full(A1)'\B[:,1]
+            @test_approx_eq A1.'\B full(A1).'\B
             @test_approx_eq A1'\B full(A1)'\B
+            @test_approx_eq A1\B.' full(A1)\B.'
             @test_approx_eq A1\B' full(A1)\B'
+            @test_approx_eq A1.'\B.' full(A1).'\B.'
             @test_approx_eq A1'\B' full(A1)'\B'
+            @test_throws DimensionMismatch A1\ones(elty1,n+2)
+            @test_throws DimensionMismatch A1'\ones(elty1,n+2)
+            @test_throws DimensionMismatch A1.'\ones(elty1,n+2)
             if t1 == UpperTriangular || t1 == LowerTriangular
                 @test_throws Base.LinAlg.SingularException naivesub!(t1(zeros(elty1,n,n)),ones(eltyB,n))
             end
             @test_approx_eq B/A1 B/full(A1)
+            @test_approx_eq B/A1.' B/full(A1).'
             @test_approx_eq B/A1' B/full(A1)'
+            @test_approx_eq B.'/A1 B.'/full(A1)
             @test_approx_eq B'/A1 B'/full(A1)
+            @test_approx_eq B.'/A1.' B.'/full(A1).'
             @test_approx_eq B'/A1' B'/full(A1)'
 
             # Error bounds
-            elty1 != BigFloat && errorbounds(A1, A1\B, B)
+            !(elty1 in (BigFloat, Complex{BigFloat})) && !(eltyB in (BigFloat, Complex{BigFloat})) && errorbounds(A1, A1\B, B)
+
         end
     end
 end
@@ -414,4 +479,9 @@ let
     @test_throws DimensionMismatch A_rdiv_Bc!(A, UpperTriangular(B))
     @test_throws DimensionMismatch A_rdiv_Bc!(A, UnitLowerTriangular(B))
     @test_throws DimensionMismatch A_rdiv_Bc!(A, UnitUpperTriangular(B))
+
+    @test_throws DimensionMismatch A_rdiv_Bt!(A, LowerTriangular(B))
+    @test_throws DimensionMismatch A_rdiv_Bt!(A, UpperTriangular(B))
+    @test_throws DimensionMismatch A_rdiv_Bt!(A, UnitLowerTriangular(B))
+    @test_throws DimensionMismatch A_rdiv_Bt!(A, UnitUpperTriangular(B))
 end
diff --git a/test/linalg/tridiag.jl b/test/linalg/tridiag.jl
index 972ed266a453d..9441244a24d85 100644
--- a/test/linalg/tridiag.jl
+++ b/test/linalg/tridiag.jl
@@ -63,16 +63,34 @@ for elty in (Float32, Float64, Complex64, Complex128, Int)
     @test SymTridiagonal(d, dl) + Tridiagonal(dl, d, du) == Tridiagonal(dl + dl, d+d, dl+du)
     @test convert(SymTridiagonal,Tridiagonal(Ts)) == Ts
     @test full(convert(SymTridiagonal{Complex64},Tridiagonal(Ts))) == convert(Matrix{Complex64},full(Ts))
+    if elty == Int
+        vv = rand(1:100, n)
+        BB = rand(1:100, n, 2)
+    else
+        vv = convert(Vector{elty}, v)
+        BB = convert(Matrix{elty}, B)
+    end
+    let Bs = BB, vs = vv
+        for atype in ("Array", "SubArray")
+            if atype == "Array"
+                BB = Bs
+                vv = vs
+            else
+                BB = sub(Bs, 1:n, 1)
+                vv = sub(vs, 1:n)
+            end
+        end
 
-    # tridiagonal linear algebra
-    @test_approx_eq T*v F*v
-    invFv = F\v
-    @test_approx_eq T\v invFv
-    # @test_approx_eq Base.solve(T,v) invFv
-    # @test_approx_eq Base.solve(T, B) F\B
-    Tlu = factorize(T)
-    x = Tlu\v
-    @test_approx_eq x invFv
+        # tridiagonal linear algebra
+        @test_approx_eq T*vv F*vv
+        invFv = F\vv
+        @test_approx_eq T\vv invFv
+        # @test_approx_eq Base.solve(T,v) invFv
+        # @test_approx_eq Base.solve(T, B) F\B
+        Tlu = factorize(T)
+        x = Tlu\vv
+        @test_approx_eq x invFv
+    end
     @test_approx_eq det(T) det(F)
 
     @test_approx_eq T * Base.LinAlg.UnitUpperTriangular(eye(n)) F*eye(n)
@@ -84,27 +102,47 @@ for elty in (Float32, Float64, Complex64, Complex128, Int)
     if elty <: Real
         Ts = SymTridiagonal(d, dl)
         Fs = full(Ts)
-        invFsv = Fs\v
         Tldlt = factorize(Ts)
-        x = Tldlt\v
-        @test_approx_eq x invFsv
-        @test_approx_eq full(full(Tldlt)) Fs
         @test_throws DimensionMismatch Tldlt\rand(elty,n+1)
         @test size(Tldlt) == size(Ts)
         if elty <: AbstractFloat
             @test typeof(convert(Base.LinAlg.LDLt{Float32},Tldlt)) == Base.LinAlg.LDLt{Float32,SymTridiagonal{elty}}
         end
+        let vs = vv
+            for atype in ("Array", "SubArray")
+                if atype == "Array"
+                    vv = vs
+                else
+                    vv = sub(vs, 1:n)
+                end
+            end
+            invFsv = Fs\vv
+            x = Ts\vv
+            @test_approx_eq x invFsv
+            @test_approx_eq full(full(Tldlt)) Fs
+        end
+
+        # similar
+        @test isa(similar(Ts), SymTridiagonal{elty})
+        @test isa(similar(Ts, Int), SymTridiagonal{Int})
+        @test isa(similar(Ts, Int, (3,2)), Matrix{Int})
     end
 
     # eigenvalues/eigenvectors of symmetric tridiagonal
     if elty === Float32 || elty === Float64
-        DT, VT = eig(Ts)
+        DT, VT = @inferred eig(Ts)
+        @inferred eig(Ts, 2:4)
+        @inferred eig(Ts, 1.0, 2.0)
         D, Vecs = eig(Fs)
         @test_approx_eq DT D
         @test_approx_eq abs(VT'Vecs) eye(elty, n)
         @test eigvecs(Ts) == eigvecs(Fs)
         #call to LAPACK.stein here
         Test.test_approx_eq_modphase(eigvecs(Ts,eigvals(Ts)),eigvecs(Fs))
+    elseif elty != Int
+        # check that undef is determined accurately even if type inference
+        # bails out due to the number of try/catch blocks in this code.
+        @test_throws UndefVarError Fs
     end
 
     # Test det(A::Matrix)
@@ -207,12 +245,20 @@ let n = 12 #Size of matrix problem to test
         @test A[1,n] == convert(elty,0.0)
         @test A[1,1] == a[1]
 
+        debug && println("setindex!")
+        @test_throws ArgumentError A[n,1] = 1
+        @test_throws ArgumentError A[1,n] = 1
+        A[3,3] = A[3,3]
+        A[2,3] = A[2,3]
+        A[3,2] = A[3,2]
+        @test A == fA
+
         debug && println("Diagonal extraction")
         @test diag(A,1) == b
         @test diag(A,-1) == b
         @test diag(A,0) == a
         @test diag(A,n-1) == zeros(elty,1)
-        @test_throws BoundsError diag(A,n+1)
+        @test_throws ArgumentError diag(A,n+1)
 
         debug && println("Idempotent tests")
         for func in (conj, transpose, ctranspose)
@@ -227,9 +273,13 @@ let n = 12 #Size of matrix problem to test
         debug && println("Rounding to Ints")
         if elty <: Real
             @test round(Int,A) == round(Int,fA)
+            @test isa(round(Int,A), SymTridiagonal)
             @test trunc(Int,A) == trunc(Int,fA)
+            @test isa(trunc(Int,A), SymTridiagonal)
             @test ceil(Int,A) == ceil(Int,fA)
+            @test isa(ceil(Int,A), SymTridiagonal)
             @test floor(Int,A) == floor(Int,fA)
+            @test isa(floor(Int,A), SymTridiagonal)
         end
 
         debug && println("Tridiagonal/SymTridiagonal mixing ops")
@@ -320,9 +370,9 @@ let n = 12 #Size of matrix problem to test
         @test size(B) == size(A)
         copy!(B,A)
         @test B == A
-        @test_throws DimensionMismatch similar(A,(n,n,2))
-        @test_throws DimensionMismatch similar(A,(n+1,n))
-        @test_throws DimensionMismatch similar(A,(n,n+1))
+        @test isa(similar(A), Tridiagonal{elty})
+        @test isa(similar(A, Int), Tridiagonal{Int})
+        @test isa(similar(A, Int, (3,2)), Matrix{Int})
         @test size(A,3) == 1
         @test_throws ArgumentError size(A,0)
 
@@ -331,7 +381,7 @@ let n = 12 #Size of matrix problem to test
         @test diag(A,0) == b
         @test diag(A,1) == c
         @test diag(A,n-1) == zeros(elty,1)
-        @test_throws BoundsError diag(A,n+1)
+        @test_throws ArgumentError diag(A,n+1)
 
         debug && println("Simple unary functions")
         for func in (det, inv)
@@ -341,9 +391,13 @@ let n = 12 #Size of matrix problem to test
         debug && println("Rounding to Ints")
         if elty <: Real
             @test round(Int,A) == round(Int,fA)
+            @test isa(round(Int,A), Tridiagonal)
             @test trunc(Int,A) == trunc(Int,fA)
+            @test isa(trunc(Int,A), Tridiagonal)
             @test ceil(Int,A) == ceil(Int,fA)
+            @test isa(ceil(Int,A), Tridiagonal)
             @test floor(Int,A) == floor(Int,fA)
+            @test isa(floor(Int,A), Tridiagonal)
         end
 
         debug && println("Binary operations")
@@ -383,6 +437,14 @@ let n = 12 #Size of matrix problem to test
         debug && println("getindex")
         @test_throws BoundsError A[n+1,1]
         @test_throws BoundsError A[1,n+1]
+
+        debug && println("setindex!")
+        @test_throws ArgumentError A[n,1] = 1
+        @test_throws ArgumentError A[1,n] = 1
+        A[3,3] = A[3,3]
+        A[2,3] = A[2,3]
+        A[3,2] = A[3,2]
+        @test A == fA
     end
 end
 
@@ -392,3 +454,11 @@ SymTridiagonal([1, 2], [0])^3 == [1 0; 0 8]
 #test convert for SymTridiagonal
 @test convert(SymTridiagonal{Float64},SymTridiagonal(ones(Float32,5),ones(Float32,4))) == SymTridiagonal(ones(Float64,5),ones(Float64,4))
 @test convert(AbstractMatrix{Float64},SymTridiagonal(ones(Float32,5),ones(Float32,4))) == SymTridiagonal(ones(Float64,5),ones(Float64,4))
+
+# Test constructors from matrix
+@test SymTridiagonal([1 2 3; 2 5 6; 0 6 9]) == [1 2 0; 2 5 6; 0 6 9]
+@test Tridiagonal([1 2 3; 4 5 6; 7 8 9]) == [1 2 0; 4 5 6; 0 8 9]
+
+# Test constructors with range and other abstract vectors
+@test SymTridiagonal(1:3, 1:2) == [1 1 0; 1 2 2; 0 2 3]
+@test Tridiagonal(4:5, 1:3, 1:2) == [1 1 0; 4 2 2; 0 5 3]
diff --git a/test/linalg/uniformscaling.jl b/test/linalg/uniformscaling.jl
index 2a72e94116051..c16cf1f31f4c9 100644
--- a/test/linalg/uniformscaling.jl
+++ b/test/linalg/uniformscaling.jl
@@ -36,57 +36,86 @@ B = bitrand(2,2)
 @test B + I == B + eye(B)
 @test I + B == B + eye(B)
 
-A = randn(2,2)
-@test A + I == A + eye(A)
-@test I + A == A + eye(A)
-@test I - I === UniformScaling(0)
-@test B - I == B - eye(B)
-@test I - B == eye(B) - B
-@test A - I == A - eye(A)
-@test I - A == eye(A) - A
-@test I*J === UniformScaling(λ)
-@test B*J == B*λ
-@test J*B == B*λ
+let AA = randn(2,2), SS = sprandn(3,3,0.5)
+    for atype in ("Array", "SubArray")
+        if atype == "Array"
+            A = AA
+            S = SS
+        else
+            A = sub(AA, 1:2, 1:2)
+            S = sub(SS, 1:3, 1:3)
+        end
 
-S = sprandn(3,3,0.5)
-@test S*J == S*λ
-@test J*S == S*λ
-@test A*J == A*λ
-@test J*A == A*λ
-@test J*ones(3) == ones(3)*λ
-@test λ*J === UniformScaling(λ*J.λ)
-@test J*λ === UniformScaling(λ*J.λ)
-@test J/I === J
-@test I/A == inv(A)
-@test A/I == A
-@test I/λ === UniformScaling(1/λ)
-@test I\J === J
+        @test A + I == A + eye(A)
+        @test I + A == A + eye(A)
+        @test I - I === UniformScaling(0)
+        @test B - I == B - eye(B)
+        @test I - B == eye(B) - B
+        @test A - I == A - eye(A)
+        @test I - A == eye(A) - A
+        @test I*J === UniformScaling(λ)
+        @test B*J == B*λ
+        @test J*B == B*λ
 
-T = LowerTriangular(randn(3,3))
-@test T + J == full(T) + J
-@test J + T == J + full(T)
-@test T - J == full(T) - J
-@test J - T == J - full(T)
-@test T\I == inv(T)
-T = LinAlg.UnitLowerTriangular(randn(3,3))
-@test T + J == full(T) + J
-@test J + T == J + full(T)
-@test T - J == full(T) - J
-@test J - T == J - full(T)
-@test T\I == inv(T)
-T = UpperTriangular(randn(3,3))
-@test T + J == full(T) + J
-@test J + T == J + full(T)
-@test T - J == full(T) - J
-@test J - T == J - full(T)
-@test T\I == inv(T)
-T = LinAlg.UnitUpperTriangular(randn(3,3))
-@test T + J == full(T) + J
-@test J + T == J + full(T)
-@test T - J == full(T) - J
-@test J - T == J - full(T)
-@test T\I == inv(T)
+        @test S*J == S*λ
+        @test J*S == S*λ
+        @test A*J == A*λ
+        @test J*A == A*λ
+        @test J*ones(3) == ones(3)*λ
+        @test λ*J === UniformScaling(λ*J.λ)
+        @test J*λ === UniformScaling(λ*J.λ)
+        @test J/I === J
+        @test I/A == inv(A)
+        @test A/I == A
+        @test I/λ === UniformScaling(1/λ)
+        @test I\J === J
 
-@test I\A == A
-@test A\I == inv(A)
-@test λ\I === UniformScaling(1/λ)
\ No newline at end of file
+        if atype == "Array"
+            T = LowerTriangular(randn(3,3))
+        else
+            T = LowerTriangular(sub(randn(3,3), 1:3, 1:3))
+        end
+        @test T + J == full(T) + J
+        @test J + T == J + full(T)
+        @test T - J == full(T) - J
+        @test J - T == J - full(T)
+        @test T\I == inv(T)
+
+        if atype == "Array"
+            T = LinAlg.UnitLowerTriangular(randn(3,3))
+        else
+            T = LinAlg.UnitLowerTriangular(sub(randn(3,3), 1:3, 1:3))
+        end
+        @test T + J == full(T) + J
+        @test J + T == J + full(T)
+        @test T - J == full(T) - J
+        @test J - T == J - full(T)
+        @test T\I == inv(T)
+
+        if atype == "Array"
+            T = UpperTriangular(randn(3,3))
+        else
+            T = UpperTriangular(sub(randn(3,3), 1:3, 1:3))
+        end
+        @test T + J == full(T) + J
+        @test J + T == J + full(T)
+        @test T - J == full(T) - J
+        @test J - T == J - full(T)
+        @test T\I == inv(T)
+
+        if atype == "Array"
+            T = LinAlg.UnitUpperTriangular(randn(3,3))
+        else
+            T = LinAlg.UnitUpperTriangular(sub(randn(3,3), 1:3, 1:3))
+        end
+        @test T + J == full(T) + J
+        @test J + T == J + full(T)
+        @test T - J == full(T) - J
+        @test J - T == J - full(T)
+        @test T\I == inv(T)
+
+        @test I\A == A
+        @test A\I == inv(A)
+        @test λ\I === UniformScaling(1/λ)
+    end
+end
diff --git a/test/llvmcall.jl b/test/llvmcall.jl
index fc0c663f5ec5c..4f2216d9e1f62 100644
--- a/test/llvmcall.jl
+++ b/test/llvmcall.jl
@@ -68,3 +68,82 @@ end
     """%3 = add i32 %1, %0
        ret i32 %3""", Int32, Tuple{Int32, Int32},
         Int32(1), Int32(2))) == 3
+
+# Test whether declarations work properly
+# This test only work properly for llvm 3.5+
+# On llvm <3.5+ even though the the compilation fails on the first try,
+# llvm still adds the intrinsice declaration to the module and subsequent calls
+# are succesfull.
+#if convert(VersionNumber, Base.libllvm_version) > v"3.5-"
+#
+#function undeclared_ceil(x::Float64)
+#    llvmcall("""%2 = call double @llvm.ceil.f64(double %0)
+#        ret double %2""", Float64, Tuple{Float64}, x)
+#end
+#@test_throws ErrorException undeclared_ceil(4.2)
+#
+#end
+
+function declared_floor(x::Float64)
+    llvmcall(
+        ("""declare double @llvm.floor.f64(double)""",
+         """%2 = call double @llvm.floor.f64(double %0)
+            ret double %2"""),
+    Float64, Tuple{Float64}, x)
+end
+@test_approx_eq declared_floor(4.2) 4.
+
+function doubly_declared_floor(x::Float64)
+    llvmcall(
+        ("""declare double @llvm.floor.f64(double)""",
+         """%2 = call double @llvm.floor.f64(double %0)
+            ret double %2"""),
+    Float64, Tuple{Float64}, x+1)-1
+end
+@test_approx_eq doubly_declared_floor(4.2) 4.
+
+function doubly_declared2_trunc(x::Float64)
+    a = llvmcall(
+        ("""declare double @llvm.trunc.f64(double)""",
+         """%2 = call double @llvm.trunc.f64(double %0)
+            ret double %2"""),
+    Float64, Tuple{Float64}, x)
+    b = llvmcall(
+        ("""declare double @llvm.trunc.f64(double)""",
+         """%2 = call double @llvm.trunc.f64(double %0)
+            ret double %2"""),
+    Float64, Tuple{Float64}, x+1)-1
+    a + b
+end
+@test_approx_eq doubly_declared2_trunc(4.2) 8.
+
+# Test for single line
+function declared_ceil(x::Float64)
+    llvmcall(
+        ("declare double @llvm.ceil.f64(double)",
+         """%2 = call double @llvm.ceil.f64(double %0)
+            ret double %2"""),
+    Float64, Tuple{Float64}, x)
+end
+@test_approx_eq declared_ceil(4.2) 5.0
+
+# Test for multiple lines
+function ceilfloor(x::Float64)
+    llvmcall(
+        ("""declare double @llvm.ceil.f64(double)
+            declare double @llvm.floor.f64(double)""",
+         """%2 = call double @llvm.ceil.f64(double %0)
+            %3 = call double @llvm.floor.f64(double %2)
+            ret double %3"""),
+    Float64, Tuple{Float64}, x)
+end
+@test_approx_eq ceilfloor(7.4) 8.0
+
+# Test for proper declaration extraction
+function confuse_declname_parsing()
+    llvmcall(
+        ("""declare i64 addrspace(0)* @foobar()""",
+         """ret void"""),
+    Void, Tuple{})
+end
+confuse_declname_parsing()
diff --git a/test/loading.jl b/test/loading.jl
index 0e7f05aeeba76..773180084cf7b 100644
--- a/test/loading.jl
+++ b/test/loading.jl
@@ -10,3 +10,18 @@ thefname = "the fname!//\\&\0\1*"
 @test include_string("Base.source_path()", thefname) == Base.source_path()
 @test basename(@__FILE__) == "loading.jl"
 @test isabspath(@__FILE__)
+
+# Issue #5789 and PR #13542:
+let true_filename = "cAsEtEsT.jl", lowered_filename="casetest.jl"
+    touch(true_filename)
+    @test Base.isfile_casesensitive(true_filename)
+    @test !Base.isfile_casesensitive(lowered_filename)
+    rm(true_filename)
+end
+
+# Test Unicode normalization; pertinent for OS X
+let nfc_name = "\U00F4.jl"
+    touch(nfc_name)
+    @test Base.isfile_casesensitive(nfc_name)
+    rm(nfc_name)
+end
diff --git a/test/markdown.jl b/test/markdown.jl
index 774083d9499ba..b5efb2c56bea3 100644
--- a/test/markdown.jl
+++ b/test/markdown.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 using Base.Markdown
-import Base.Markdown: MD, Paragraph, Header, Italic, Bold, plain, term, html, Table, Code, LaTeX
+import Base.Markdown: MD, Paragraph, Header, Italic, Bold, LineBreak, plain, term, html, rst, Table, Code, LaTeX, Footnote
 import Base: writemime
 
 # Basics
@@ -10,6 +10,10 @@ import Base: writemime
 
 @test md"foo" == MD(Paragraph("foo"))
 @test md"foo *bar* baz" == MD(Paragraph(["foo ", Italic("bar"), " baz"]))
+@test md"""foo
+bar""" == MD(Paragraph(["foo bar"]))
+@test md"""foo\
+bar""" == MD(Paragraph(["foo", LineBreak(), "bar"]))
 
 @test md"#no title" == MD(Paragraph(["#no title"]))
 @test md"# title" == MD(Header{1}("title"))
@@ -34,8 +38,26 @@ h2
 foo
 ```
 """ == MD(Code("julia", "foo"))
-@test md"``code```more code``" == MD(Any[Paragraph(Any[Code("","code```more code")])])
-@test md"``code``````more code``" == MD(Any[Paragraph(Any[Code("","code``````more code")])])
+
+@test md"foo ``bar`` baz" == MD(Paragraph(["foo ", LaTeX("bar"), " baz"]))
+
+@test md"""
+```math
+...
+```
+""" == MD(LaTeX("..."))
+
+code_in_code = md"""
+````
+```
+````
+"""
+@test code_in_code == MD(Code("```"))
+@test plain(code_in_code) == "````\n```\n````\n"
+
+@test md"A footnote [^foo]." == MD(Paragraph(["A footnote ", Footnote("foo", nothing), "."]))
+
+@test md"[^foo]: footnote" == MD(Paragraph([Footnote("foo", Any[" footnote"])]))
 
 @test md"""
 * one
@@ -60,7 +82,7 @@ foo
 @test md"""Hello
 
 ---
-World""" |> plain == "Hello\n\n–––\n\nWorld\n"
+World""" |> plain == "Hello\n\n---\n\nWorld\n"
 @test md"[*a*](b)" |> plain == "[*a*](b)\n"
 @test md"""
 > foo
@@ -71,6 +93,20 @@ World""" |> plain == "Hello\n\n–––\n\nWorld\n"
 > baz
 > ```""" |> plain == """> foo\n>\n>   * bar\n>\n> ```\n> baz\n> ```\n\n"""
 
+# Terminal (markdown) output
+
+# multiple whitespace is ignored
+@test sprint(term, md"a  b") == "  a b\n"
+@test sprint(term, md"- a
+        not code") == "    •  a not code\n"
+@test sprint(term, md"[x](https://julialang.org)") == "  x\n"
+@test sprint(term, md"![x](https://julialang.org)") == "  (Image: x)\n"
+
+# enumeration is normalized
+@test sprint(term, md"""
+    1. a
+    3. b""") == "    1. a\n    2. b\n"
+
 # HTML output
 
 @test md"foo *bar* baz" |> html == "<p>foo <em>bar</em> baz</p>\n"
@@ -195,12 +231,40 @@ let out =
 
     Some **bolded**
 
-      * list1
-      * list2
+    * list1
+    * list2
     """
     @test sprint(io -> writemime(io, "text/rst", book)) == out
 end
 
+# rst rendering
+
+for (input, output) in (
+        md"foo *bar* baz"     => "foo *bar* baz\n",
+        md"something ***"     => "something ***\n",
+        md"# h1## "           => "h1##\n****\n\n",
+        md"## h2 ### "        => "h2\n==\n\n",
+        md"###### h6"         => "h6\n..\n\n",
+        md"####### h7"        => "####### h7\n",
+        md"   >"              => "    \n\n",
+        md"1. Hello"          => "1. Hello\n",
+        md"* World"           => "* World\n",
+        md"``x + y``"         => ":math:`x + y`\n",
+        md"# title *blah*"    => "title *blah*\n************\n\n",
+        md"## title *blah*"   => "title *blah*\n============\n\n",
+        md"[`x`](:func:`x`)"  => ":func:`x`\n",
+        md"[`x`](:obj:`x`)"   => ":obj:`x`\n",
+        md"[`x`](:ref:`x`)"   => ":ref:`x`\n",
+        md"[`x`](:exc:`x`)"   => ":exc:`x`\n",
+        md"[`x`](:class:`x`)" => ":class:`x`\n",
+        md"[`x`](:const:`x`)" => ":const:`x`\n",
+        md"[`x`](:data:`x`)"  => ":data:`x`\n",
+        md"[`x`](:???:`x`)"   => "```x`` <:???:`x`>`_\n",
+        md"[x](y)"            => "`x <y>`_\n",
+    )
+    @test rst(input) == output
+end
+
 # Interpolation / Custom types
 
 type Reference
@@ -209,24 +273,20 @@ end
 
 ref(x) = Reference(x)
 
-if Base.USE_GPL_LIBS
-
-ref(fft)
+ref(mean)
 
 writemime(io::IO, m::MIME"text/plain", r::Reference) =
     print(io, "$(r.ref) (see Julia docs)")
 
-fft_ref = md"Behaves like $(ref(fft))"
-@test plain(fft_ref) == "Behaves like fft (see Julia docs)\n"
-@test html(fft_ref) == "<p>Behaves like fft &#40;see Julia docs&#41;</p>\n"
+mean_ref = md"Behaves like $(ref(mean))"
+@test plain(mean_ref) == "Behaves like mean (see Julia docs)\n"
+@test html(mean_ref) == "<p>Behaves like mean &#40;see Julia docs&#41;</p>\n"
 
 writemime(io::IO, m::MIME"text/html", r::Reference) =
     Markdown.withtag(io, :a, :href=>"test") do
         Markdown.htmlesc(io, Markdown.plaininline(r))
     end
-@test html(fft_ref) == "<p>Behaves like <a href=\"test\">fft &#40;see Julia docs&#41;</a></p>\n"
-
-end # USE_GPL_LIBS
+@test html(mean_ref) == "<p>Behaves like <a href=\"test\">mean &#40;see Julia docs&#41;</a></p>\n"
 
 @test md"""
 ````julia
@@ -267,12 +327,15 @@ t = """a   |   b
 latex_doc = md"""
 We have $x^2 < x$ whenever:
 
-$|x| < 1$"""
+$|x| < 1$
+
+etc."""
 
 @test latex_doc == MD(Any[Paragraph(Any["We have ",
                                         LaTeX("x^2 < x"),
                                         " whenever:"]),
-                          LaTeX("|x| < 1")])
-
+                          LaTeX("|x| < 1"),
+                          Paragraph(Any["etc."])])
 
-@test latex(latex_doc) == "We have \$x^2 < x\$ whenever:\n\$\$|x| < 1\$\$"
+@test plain(latex_doc) == "We have \$x^2 < x\$ whenever:\n\n\$|x| < 1\$\n\netc.\n"
+@test latex(latex_doc) == "We have \$x^2 < x\$ whenever:\n\$\$|x| < 1\$\$\netc.\n"
diff --git a/test/math.jl b/test/math.jl
index dddc7dcf4664d..6354370982b85 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -13,6 +13,17 @@
 @test clamp(4.0, 1, 3) == 3.0
 
 @test clamp([0, 1, 2, 3, 4], 1.0, 3.0) == [1.0, 1.0, 2.0, 3.0, 3.0]
+@test clamp([0 1; 2 3], 1.0, 3.0) == [1.0 1.0; 2.0 3.0]
+
+@test !(pi == e)
+@test !(e == 1//2)
+@test 1//2 <= e
+@test big(1//2) < e
+@test e < big(20//6)
+@test e^pi == exp(pi)
+@test e^2 == exp(2)
+@test e^2.4 == exp(2.4)
+@test e^(2//3) == exp(2//3)
 
 begin
     x = [0.0, 1.0, 2.0, 3.0, 4.0]
@@ -108,6 +119,7 @@ for T in (Float32, Float64)
     @test_approx_eq_eps expm1(T(1)) T(e)-1 10*eps(T)
     @test isequal(hypot(T(3),T(4)), T(5))
     @test isequal(log(T(1)), T(0))
+    @test isequal(log(e,T(1)), T(0))
     @test_approx_eq_eps log(T(e)) T(1) eps(T)
     @test isequal(log10(T(1)), T(0))
     @test isequal(log10(T(10)), T(1))
@@ -157,13 +169,26 @@ for T in (Float32, Float64)
     @test_approx_eq sinh(x) (exp(x)-exp(-x))/2
     @test_approx_eq tan(x) sin(x)/cos(x)
     @test_approx_eq tanh(x) sinh(x)/cosh(x)
+
+    #Edge cases
+    @test isinf(log(zero(T)))
+    @test isnan(log(convert(T,NaN)))
+    @test_throws DomainError log(-one(T))
+    @test isinf(log1p(-one(T)))
+    @test isnan(log1p(convert(T,NaN)))
+    @test_throws DomainError log1p(convert(T,-2.0))
 end
+@test_approx_eq exp10(5) exp10(5.0)
+@test_approx_eq exp2(Float16(2.)) exp2(2.)
+@test log(e) == 1
 
 for T in (Int, Float64, BigFloat)
     @test_approx_eq deg2rad(T(180)) 1pi
     @test_approx_eq deg2rad(T[45, 60]) [pi/T(4), pi/T(3)]
     @test_approx_eq rad2deg([pi/T(4), pi/T(3)]) [45, 60]
     @test_approx_eq rad2deg(T(1)*pi) 180
+    @test_approx_eq rad2deg(T(1)) rad2deg(true)
+    @test_approx_eq deg2rad(T(1)) deg2rad(true)
 end
 
 # degree-based trig functions
@@ -186,7 +211,6 @@ for T = (Float32,Float64,Rational{Int})
     @test cosd(convert(T,-90))::fT === zero(fT)
     @test cosd(convert(T,-270))::fT === zero(fT)
 
-
     for x = -3:0.3:3
         @test_approx_eq_eps sinpi(convert(T,x))::fT convert(fT,sin(pi*x)) eps(pi*convert(fT,x))
         @test_approx_eq_eps cospi(convert(T,x))::fT convert(fT,cos(pi*x)) eps(pi*convert(fT,x))
@@ -198,21 +222,38 @@ for T = (Float32,Float64,Rational{Int})
     T != Rational{Int} && @test sinpi(convert(T,-0.0))::fT === -zero(fT)
     @test sinpi(convert(T,-1.0))::fT === -zero(fT)
     @test sinpi(convert(T,-2.0))::fT === -zero(fT)
+    @test_throws DomainError sinpi(convert(T,Inf))
 
     @test cospi(convert(T,0.5))::fT === zero(fT)
     @test cospi(convert(T,1.5))::fT === zero(fT)
     @test cospi(convert(T,-0.5))::fT === zero(fT)
     @test cospi(convert(T,-1.5))::fT === zero(fT)
+    @test_throws DomainError cospi(convert(T,Inf))
 
     # check exact values
     @test sind(convert(T,30)) == 0.5
     @test cosd(convert(T,60)) == 0.5
     @test sind(convert(T,150)) == 0.5
     @test sinpi(one(T)/convert(T,6)) == 0.5
+    @test_throws DomainError sind(convert(T,Inf))
+    @test_throws DomainError cosd(convert(T,Inf))
     T != Float32 && @test cospi(one(T)/convert(T,3)) == 0.5
     T == Rational{Int} && @test sinpi(5//6) == 0.5
 end
 
+@test sinpi(1) == 0
+@test sinpi(-1) == -0
+@test cospi(1) == -1
+@test cospi(2) == 1
+
+@test sinc(1) == 0
+@test sinc(complex(1,0)) == 0
+@test sinc(0) == 1
+@test sinc(Inf) == 0
+@test cosc(1) == -1
+@test cosc(0) == 0
+@test cosc(complex(1,0)) == -1
+@test cosc(Inf) == 0
 
 # check type stability
 for T = (Float32,Float64,BigFloat)
@@ -221,11 +262,14 @@ for T = (Float32,Float64,BigFloat)
     end
 end
 
-
 # error functions
+@test_approx_eq erf(Float16(1)) 0.84270079294971486934
 @test_approx_eq erf(1) 0.84270079294971486934
 @test_approx_eq erfc(1) 0.15729920705028513066
+@test_approx_eq erfc(Float16(1)) 0.15729920705028513066
 @test_approx_eq erfcx(1) 0.42758357615580700442
+@test_approx_eq erfcx(Float32(1)) 0.42758357615580700442
+@test_approx_eq erfcx(Complex64(1)) 0.42758357615580700442
 @test_approx_eq erfi(1) 1.6504257587975428760
 @test_approx_eq erfinv(0.84270079294971486934) 1
 @test_approx_eq erfcinv(0.15729920705028513066) 1
@@ -251,7 +295,7 @@ for elty in [Float32,Float64]
     end
     @test erfinv(one(elty)) == Inf
     @test erfinv(-one(elty)) == -Inf
-    @test_throws DomainError erfinv(2.0*one(elty))
+    @test_throws DomainError erfinv(convert(elty,2.0))
 
     @test erfcinv(zero(elty)) == Inf
     @test_throws DomainError erfcinv(-one(elty))
@@ -280,6 +324,7 @@ for elty in [Complex64,Complex128]
     @test_approx_eq airyx(3, z) airy(3, z) * exp(-abs(real(2/3 * z * sqrt(z))))
     @test_throws ArgumentError airyx(5,z)
 end
+@test_throws MethodError airy(complex(big(1.0)))
 
 # bessely0, bessely1, besselj0, besselj1
 @test_approx_eq besselj0(Float32(2.0)) besselj0(Float64(2.0))
@@ -295,6 +340,11 @@ end
 @test_approx_eq bessely0(2.0 + im) bessely(0, 2.0 + im)
 @test_approx_eq bessely1(2.0 + im) bessely(1, 2.0 + im)
 
+@test_throws MethodError besselj(1.2,big(1.0))
+@test_throws MethodError besselj(1,complex(big(1.0)))
+@test_throws MethodError besseljx(1,big(1.0))
+@test_throws MethodError besseljx(1,complex(big(1.0)))
+
 # besselh
 true_h133 = 0.30906272225525164362 - 0.53854161610503161800im
 @test_approx_eq besselh(3,1,3) true_h133
@@ -303,6 +353,10 @@ true_h133 = 0.30906272225525164362 - 0.53854161610503161800im
 @test_approx_eq besselh(-3,2,3) -conj(true_h133)
 @test_throws Base.Math.AmosException besselh(1,0)
 
+@test_throws MethodError besselh(1,big(1.0))
+@test_throws MethodError besselh(1,complex(big(1.0)))
+@test_throws MethodError besselhx(1,big(1.0))
+@test_throws MethodError besselhx(1,complex(big(1.0)))
 
 # besseli
 true_i33 = 0.95975362949600785698
@@ -313,6 +367,12 @@ true_i33 = 0.95975362949600785698
 @test_throws Base.Math.AmosException besseli(1,1000)
 @test_throws DomainError besseli(0.4,-1.0)
 
+@test_throws MethodError besseli(1,big(1.0))
+@test_throws MethodError besseli(1,complex(big(1.0)))
+@test_throws MethodError besselix(1,big(1.0))
+@test_throws MethodError besselix(1,complex(big(1.0)))
+
+
 # besselj
 @test besselj(0,0) == 1
 for i = 1:5
@@ -327,12 +387,20 @@ j33 = besselj(3,3.)
 @test besselj(-3,-3) == j33
 @test besselj(-3,3) == -j33
 @test besselj(3,-3) == -j33
+@test besselj(3,3f0) ≈ j33
+@test besselj(3,complex(3.)) ≈ j33
+@test besselj(3,complex(3f0)) ≈ j33
+@test besselj(3,complex(3)) ≈ j33
 
 j43 = besselj(4,3.)
 @test besselj(4,3) == j43
 @test besselj(-4,-3) == j43
 @test besselj(-4,3) == j43
 @test besselj(4,-3) == j43
+@test besselj(4,3f0) ≈ j43
+@test besselj(4,complex(3.)) ≈ j43
+@test besselj(4,complex(3f0)) ≈ j43
+@test besselj(4,complex(3)) ≈ j43
 
 @test_approx_eq j33 0.30906272225525164362
 @test_approx_eq j43 0.13203418392461221033
@@ -342,6 +410,7 @@ j43 = besselj(4,3.)
 @test_approx_eq besselj(1, 3im) 3.953370217402609396im
 @test_approx_eq besselj(1.0,3im) besselj(1,3im)
 @test_throws Base.Math.AmosException besselj(20,1000im)
+@test_throws MethodError besselj(big(1.0),3im)
 
 # besselk
 true_k33 = 0.12217037575718356792
@@ -355,6 +424,12 @@ true_k3m3 = -0.1221703757571835679 - 3.0151549516807985776im
 # issue #6564
 @test besselk(1.0,0.0) == Inf
 
+@test_throws MethodError besselk(1,big(1.0))
+@test_throws MethodError besselk(1,complex(big(1.0)))
+@test_throws MethodError besselkx(1,big(1.0))
+@test_throws MethodError besselkx(1,complex(big(1.0)))
+
+
 # bessely
 y33 = bessely(3,3.)
 @test bessely(3,3) == y33
@@ -369,12 +444,23 @@ y33 = bessely(3,3.)
 @test_throws DomainError bessely(0.4,Float32(-1.0))
 @test_throws DomainError bessely(1,Float32(-1.0))
 
+@test_throws MethodError bessely(1.2,big(1.0))
+@test_throws MethodError bessely(1,complex(big(1.0)))
+@test_throws MethodError besselyx(1,big(1.0))
+@test_throws MethodError besselyx(1,complex(big(1.0)))
+
+
 #besselhx
 for elty in [Complex64,Complex128]
     z = convert(elty, 1.0 + 1.9im)
     @test_approx_eq besselhx(1.0, 1, z) convert(elty,-0.5949634147786144 - 0.18451272807835967im)
 end
 
+@test_throws MethodError besselh(1,1,big(1.0))
+@test_throws MethodError besselh(1,1,complex(big(1.0)))
+@test_throws MethodError besselhx(1,1,big(1.0))
+@test_throws MethodError besselhx(1,1,complex(big(1.0)))
+
 # issue #6653
 for f in (besselj,bessely,besseli,besselk,hankelh1,hankelh2)
     @test_approx_eq f(0,1) f(0,Complex128(1))
@@ -407,8 +493,13 @@ end
 @test_approx_eq beta(3,5) 1/105
 @test_approx_eq lbeta(5,4) log(beta(5,4))
 @test_approx_eq beta(5,4) beta(4,5)
-@test_approx_eq beta(-1/2, 3) -16/3
+@test beta(-1/2, 3) ≈ beta(-1/2 + 0im, 3 + 0im) ≈ -16/3
 @test_approx_eq lbeta(-1/2, 3) log(16/3)
+@test beta(Float32(5),Float32(4)) == beta(Float32(4),Float32(5))
+@test beta(3,5) ≈ beta(3+0im,5+0im)
+@test(beta(3.2+0.1im,5.3+0.3im) ≈ exp(lbeta(3.2+0.1im,5.3+0.3im)) ≈
+      0.00634645247782269506319336871208405439180447035257028310080 -
+      0.00169495384841964531409376316336552555952269360134349446910im)
 
 # gamma, lgamma (complex argument)
 if Base.Math.libm == "libopenlibm"
@@ -428,6 +519,8 @@ end
 for x in (3.2, 2+1im, 3//2, 3.2+0.1im)
     @test factorial(x) == gamma(1+x)
 end
+@test lfact(1) == 0
+@test lfact(2) == lgamma(3)
 
 # digamma
 for elty in (Float32, Float64)
@@ -472,16 +565,27 @@ for elty in (Float32, Float64)
         @test abs(invdigamma(digamma(convert(elty, val))) - convert(elty, val)) < 1e-8
     end
 end
+@test abs(invdigamma(2)) == abs(invdigamma(2.))
 
 @test_approx_eq polygamma(20, 7.) -4.644616027240543262561198814998587152547
+@test_approx_eq polygamma(20, Float16(7.)) -4.644616027240543262561198814998587152547
 
 # eta, zeta
 @test_approx_eq eta(1) log(2)
 @test_approx_eq eta(2) pi^2/12
+@test_approx_eq eta(Float32(2)) eta(2)
+@test_approx_eq eta(Complex64(2)) eta(2)
 @test_approx_eq zeta(0) -0.5
 @test_approx_eq zeta(2) pi^2/6
+@test_approx_eq zeta(Complex64(2)) zeta(2)
 @test_approx_eq zeta(4) pi^4/90
 @test_approx_eq zeta(one(Float32)) Float32(zeta(one(Float64)))
+@test_approx_eq zeta(1,Float16(2.)) zeta(1,2.)
+@test_approx_eq zeta(1.,Float16(2.)) zeta(1,2.)
+@test_approx_eq zeta(Float16(1.),Float16(2.)) zeta(1,2.)
+@test isnan(zeta(NaN))
+@test isnan(zeta(complex(0,Inf)))
+@test isnan(zeta(complex(-Inf,0)))
 
 # quadgk
 @test_approx_eq quadgk(cos, 0,0.7,1)[1] sin(1)
@@ -536,6 +640,9 @@ end
 @test polygamma(4, -0.0) == Inf == -polygamma(4, +0.0)
 @test zeta(4, +0.0) == Inf == zeta(4, -0.0)
 @test zeta(5, +0.0) == Inf == -zeta(5, -0.0)
+@test zeta(Inf, 1.) == 1
+@test zeta(Inf, 2.) == 0
+@test isnan(zeta(NaN, 1.))
 @test isa([digamma(x) for x in [1.0]], Vector{Float64})
 @test isa([trigamma(x) for x in [1.0]], Vector{Float64})
 @test isa([polygamma(3,x) for x in [1.0]], Vector{Float64})
@@ -576,7 +683,7 @@ for z in (1.234, 1.234 + 5.678im, [1.234, 5.678])
 end
 
 # modf
-for elty in (Float32, Float64)
+for elty in (Float16, Float32, Float64)
     @test_approx_eq modf( convert(elty,1.2) )[1] convert(elty,0.2)
     @test_approx_eq modf( convert(elty,1.2) )[2] convert(elty,1.0)
     @test_approx_eq modf( convert(elty,1.0) )[1] convert(elty,0.0)
@@ -624,7 +731,7 @@ end
 for n = 0:28
     @test log(2,2^n) == n
 end
-with_bigfloat_precision(10_000) do
+setprecision(10_000) do
     @test log(2,big(2)^100) == 100
     @test log(2,big(2)^200) == 200
     @test log(2,big(2)^300) == 300
@@ -658,3 +765,8 @@ end
 @test_throws DomainError 2 ^ -2
 @test_throws DomainError (-2)^(2.2)
 @test_throws DomainError (-2.0)^(2.2)
+
+# issue #13748
+let A = [1 2; 3 4]; B = [5 6; 7 8]; C = [9 10; 11 12]
+    @test muladd(A,B,C) == A*B + C
+end
diff --git a/test/meta.jl b/test/meta.jl
index 51cf1239aa134..e1e076aec6cac 100644
--- a/test/meta.jl
+++ b/test/meta.jl
@@ -34,15 +34,15 @@ h_noinlined() = g_noinlined()
 
 function foundfunc(bt, funcname)
     for b in bt
-        lkup = Profile.lookup(b)
+        lkup = StackTraces.lookup(b)
         if lkup.func == funcname
             return true
         end
     end
     false
 end
-@test !foundfunc(h_inlined(), "g_inlined")
-@test foundfunc(h_noinlined(), "g_noinlined")
+@test !foundfunc(h_inlined(), :g_inlined)
+@test foundfunc(h_noinlined(), :g_noinlined)
 
 using Base.pushmeta!, Base.popmeta!
 
diff --git a/test/misc.jl b/test/misc.jl
index b605fd6f2f1cd..ff310d4df1e91 100644
--- a/test/misc.jl
+++ b/test/misc.jl
@@ -94,6 +94,7 @@ let deepthought(x, y) = 42
     try
         @assert 1 == 2 string("the answer to the ultimate question: ",
                               deepthought(6, 9))
+        error("unexpected")
     catch ex
         @test isa(ex, AssertionError)
         @test ex.msg == "the answer to the ultimate question: 42"
@@ -120,20 +121,23 @@ end
 immutable NoMethodHasThisType end
 @test isempty(methodswith(NoMethodHasThisType))
 @test !isempty(methodswith(Int))
+immutable Type4Union end
+func4union(::Union{Type4Union,Int}) = ()
+@test !isempty(methodswith(Type4Union))
 
 # PR #10984
 # Disable on windows because of issue (missing flush) when redirecting STDERR.
 let
     redir_err = "redirect_stderr(STDOUT)"
-    exename = joinpath(JULIA_HOME, Base.julia_exename())
+    exename = Base.julia_cmd()
     script = "$redir_err; f(a::Number, b...) = 1;f(a, b::Number) = 1"
-    warning_str = readall(`$exename -f -e $script`)
+    warning_str = readstring(`$exename -f -e $script`)
     @test contains(warning_str, "f(Any, Number)")
     @test contains(warning_str, "f(Number, Any...)")
     @test contains(warning_str, "f(Number, Number)")
 
     script = "$redir_err; module A; f() = 1; end; A.f() = 1"
-    warning_str = readall(`$exename -f -e $script`)
+    warning_str = readstring(`$exename -f -e $script`)
     @test contains(warning_str, "f()")
 end
 
@@ -180,7 +184,7 @@ x = 1.0
 end
 @test sprint(whos, Main, r"^$") == ""
 let v = sprint(whos, _test_whos_)
-    @test contains(v, "x      8 bytes  Float64 : 1.0")
+    @test contains(v, "x      8 bytes  Float64")
 end
 
 # issue #13021
@@ -192,3 +196,192 @@ catch ex
 end
     @test isa(ex, ErrorException) && ex.msg == "cannot assign variables in other modules"
 end
+
+@test Base.is_unix(:Darwin)
+@test Base.is_unix(:FreeBSD)
+@test_throws ArgumentError Base.is_unix(:BeOS)
+@unix_only @test Base.windows_version() == (0,0)
+
+# Issue 14173
+module Tmp14173
+    export A
+    A = randn(2000, 2000)
+end
+whos(IOBuffer(), Tmp14173) # warm up
+@test @allocated(whos(IOBuffer(), Tmp14173)) < 10000
+
+## test conversion from UTF-8 to UTF-16 (for Windows APIs)
+import Base: utf8to16, utf16to8
+
+# empty arrays
+@test utf8to16(UInt8[]) == UInt16[]
+@test utf16to8(UInt16[]) == UInt8[]
+
+# UTF-8-like sequences
+V8 = [
+    # 1-byte (ASCII)
+    ([0x00],[0x0000])
+    ([0x0a],[0x000a])
+    ([0x7f],[0x007f])
+    # 2-byte
+    ([0xc0,0x80],[0x0000]) # overlong encoding
+    ([0xc1,0xbf],[0x007f]) # overlong encoding
+    ([0xc2,0x80],[0x0080])
+    ([0xc3,0xbf],[0x00ff])
+    ([0xc4,0x80],[0x0100])
+    ([0xc4,0xa3],[0x0123])
+    ([0xdf,0xbf],[0x07ff])
+    # 3-byte
+    ([0xe0,0x80,0x80],[0x0000]) # overlong encoding
+    ([0xe0,0x81,0xbf],[0x007f]) # overlong encoding
+    ([0xe0,0x82,0x80],[0x0080]) # overlong encoding
+    ([0xe0,0x9f,0xbf],[0x07ff]) # overlong encoding
+    ([0xe0,0xa0,0x80],[0x0800])
+    ([0xe0,0xa2,0x9a],[0x089a])
+    ([0xe1,0x88,0xb4],[0x1234])
+    ([0xea,0xaf,0x8d],[0xabcd])
+    ([0xed,0x9f,0xbf],[0xd7ff])
+    ([0xed,0xa0,0x80],[0xd800]) # invalid code point – high surrogate
+    ([0xed,0xaf,0xbf],[0xdbff]) # invalid code point – high surrogate
+    ([0xed,0xb0,0x80],[0xdc00]) # invalid code point – low surrogate
+    ([0xed,0xbf,0xbf],[0xdfff]) # invalid code point – low surrogate
+    ([0xee,0x80,0x80],[0xe000])
+    ([0xef,0xbf,0xbf],[0xffff])
+    # 4-byte
+    ([0xf0,0x80,0x80,0x80],[0x0000]) # overlong encoding
+    ([0xf0,0x80,0x81,0xbf],[0x007f]) # overlong encoding
+    ([0xf0,0x80,0x82,0x80],[0x0080]) # overlong encoding
+    ([0xf0,0x80,0x9f,0xbf],[0x07ff]) # overlong encoding
+    ([0xf0,0x80,0xa0,0x80],[0x0800]) # overlong encoding
+    ([0xf0,0x8f,0xbf,0xbf],[0xffff]) # overlong encoding
+    ([0xf0,0x90,0x80,0x80],[0xd800,0xdc00]) # U+10000
+    ([0xf0,0x90,0x8d,0x88],[0xd800,0xdf48]) # U+10348
+    ([0xf0,0x90,0x90,0xb7],[0xd801,0xdc37]) # U+10437
+    ([0xf0,0xa4,0xad,0xa2],[0xd852,0xdf62]) # U+24b62
+    ([0xf2,0xab,0xb3,0x9e],[0xda6f,0xdcde]) # U+abcde
+    ([0xf3,0xbf,0xbf,0xbf],[0xdbbf,0xdfff]) # U+fffff
+    ([0xf4,0x80,0x80,0x80],[0xdbc0,0xdc00]) # U+100000
+    ([0xf4,0x8a,0xaf,0x8d],[0xdbea,0xdfcd]) # U+10abcd
+    ([0xf4,0x8f,0xbf,0xbf],[0xdbff,0xdfff]) # U+10ffff
+]
+
+# non UTF-8-like sequences
+X8 = Vector{UInt8}[
+    # invalid 1-byte sequences
+    [0x80], # 1 leading ones
+    [0xbf],
+    [0xc0], # 2 leading ones
+    [0xdf],
+    [0xe0], # 3 leading ones
+    [0xef],
+    [0xf0], # 4 leading ones
+    [0xf7],
+    [0xf8], # 5 leading ones
+    [0xfb],
+    [0xfc], # 6 leading ones
+    [0xfd],
+    [0xfe], # 7 leading ones
+    [0xff], # 8 leading ones
+    # other invalid sequences
+    [0xf4,0x90,0xbf,0xbf],
+    [0xf4,0x91,0x80,0x80],
+    [0xf7,0x80,0x80,0x80],
+    [0xf7,0xbf,0xbf,0xbf],
+    [0xf8,0x80,0x80,0x80],
+    [0xf8,0xbf,0xbf,0xbf],
+    [0xff,0x80,0x80,0x80],
+    [0xff,0xbf,0xbf,0xbf],
+]
+
+for s in [map(first,V8); X8],
+    i = 1:length(s)-1,
+    j = i+1:length(s)-(i==1)
+    ss = s[i:j]
+    ss in X8 || push!(X8, ss)
+end
+sort!(X8, lt=lexless)
+sort!(X8, by=length)
+
+I8 = [(s,map(UInt16,s)) for s in X8]
+
+for (X,Y,Z) in ((V8,V8,V8), (I8,V8,I8), (V8,I8,V8), (V8,V8,I8), (I8,V8,V8))
+    for (a8, a16) in X
+        @test utf8to16(a8) == a16
+        for (b8, b16) in Y
+            ab8 = [a8; b8]
+            ab16 = [a16; b16]
+            @test utf8to16(ab8) == ab16
+            for (c8, c16) in Z
+                abc8 = [ab8; c8]
+                abc16 = [ab16; c16]
+                @test utf8to16(abc8) == abc16
+            end
+        end
+    end
+end
+
+# UTF-16-like sequences
+V16 = [
+    # 1-unit UTF-16, 1-byte UTF-8 (ASCII)
+    ([0x0000],[0x00])
+    ([0x000a],[0x0a])
+    ([0x007f],[0x7f])
+    # 1-unit UTF-16, 2-byte UTF-8
+    ([0x0080],[0xc2,0x80])
+    ([0x00ff],[0xc3,0xbf])
+    ([0x0100],[0xc4,0x80])
+    ([0x0123],[0xc4,0xa3])
+    ([0x07ff],[0xdf,0xbf])
+    # 1-unit UTF-16, 3-byte UTF-8
+    ([0x0800],[0xe0,0xa0,0x80])
+    ([0x089a],[0xe0,0xa2,0x9a])
+    ([0x1234],[0xe1,0x88,0xb4])
+    ([0xabcd],[0xea,0xaf,0x8d])
+    ([0xd7ff],[0xed,0x9f,0xbf])
+    ([0xe000],[0xee,0x80,0x80])
+    ([0xffff],[0xef,0xbf,0xbf])
+    # 2-unit UTF-16, 4-byte UTF-8
+    ([0xd800,0xdc00],[0xf0,0x90,0x80,0x80]) # U+10000
+    ([0xd800,0xdf48],[0xf0,0x90,0x8d,0x88]) # U+10348
+    ([0xd801,0xdc37],[0xf0,0x90,0x90,0xb7]) # U+10437
+    ([0xd852,0xdf62],[0xf0,0xa4,0xad,0xa2]) # U+24b62
+    ([0xda6f,0xdcde],[0xf2,0xab,0xb3,0x9e]) # U+abcde
+    ([0xdbbf,0xdfff],[0xf3,0xbf,0xbf,0xbf]) # U+fffff
+    ([0xdbc0,0xdc00],[0xf4,0x80,0x80,0x80]) # U+100000
+    ([0xdbea,0xdfcd],[0xf4,0x8a,0xaf,0x8d]) # U+10abcd
+    ([0xdbff,0xdfff],[0xf4,0x8f,0xbf,0xbf]) # U+10ffff
+]
+
+I16 = [
+    ([0xd800],[0xed,0xa0,0x80]) # high surrogate
+    ([0xdbff],[0xed,0xaf,0xbf]) # high surrogate
+    ([0xdc00],[0xed,0xb0,0x80]) # low surrogate
+    ([0xdfff],[0xed,0xbf,0xbf]) # low surrogate
+]
+
+for (X,Y,Z) in ((V16,V16,V16), (I16,V16,I16), (V16,I16,V16), (V16,V16,I16), (I16,V16,V16))
+    for (a16, a8) in X
+        @test utf16to8(a16) == a8
+        @test utf8to16(a8) == a16
+        for (b16, b8) in Y
+            ab16 = [a16; b16]
+            ab8 = [a8; b8]
+            @test utf16to8(ab16) == ab8
+            @test utf8to16(ab8) == ab16
+            for (c16, c8) in Z
+                abc16 = [ab16; c16]
+                abc8 = [ab8; c8]
+                @test utf16to8(abc16) == abc8
+                @test utf8to16(abc8) == abc16
+            end
+        end
+    end
+end
+
+# clipboard functionality
+if OS_NAME == :Windows || OS_NAME == :Darwin
+    for str in ("Hello, world.","∀ x ∃ y","")
+        clipboard(str)
+        @test clipboard() == str
+    end
+end
diff --git a/test/mmap.jl b/test/mmap.jl
index 2a7b493bd1b68..b378427890926 100644
--- a/test/mmap.jl
+++ b/test/mmap.jl
@@ -1,9 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 file = tempname()
-s = open(file, "w") do f
-    write(f, "Hello World\n")
-end
+write(file, "Hello World\n")
 t = "Hello World".data
 @test Mmap.mmap(file, Array{UInt8,3}, (11,1,1)) == reshape(t,(11,1,1))
 gc(); gc()
@@ -11,12 +9,12 @@ gc(); gc()
 gc(); gc()
 @test Mmap.mmap(file, Array{UInt8,3}, (1,1,11)) == reshape(t,(1,1,11))
 gc(); gc()
-@test_throws ArgumentError Mmap.mmap(file, Array{UInt8,3}, (11,0,1)) # 0-dimension results in len=0
+@test Mmap.mmap(file, Array{UInt8,3}, (11,0,1)) == Array(UInt8,(0,0,0))
 @test Mmap.mmap(file, Vector{UInt8}, (11,)) == t
 gc(); gc()
 @test Mmap.mmap(file, Array{UInt8,2}, (1,11)) == t'
 gc(); gc()
-@test_throws ArgumentError Mmap.mmap(file, Array{UInt8,2}, (0,12))
+@test Mmap.mmap(file, Array{UInt8,2}, (0,12)) == Array(UInt8,(0,0))
 m = Mmap.mmap(file, Array{UInt8,3}, (1,2,1))
 @test m == reshape("He".data,(1,2,1))
 finalize(m); m=nothing; gc()
@@ -48,13 +46,13 @@ close(s)
 gc(); gc()
 
 s = open(f->f,file,"w")
-@test_throws ArgumentError Mmap.mmap(file) # requested len=0 on empty file
-@test_throws ArgumentError Mmap.mmap(file,Vector{UInt8},0)
+@test Mmap.mmap(file) == Array(UInt8, 0) # requested len=0 on empty file
+@test Mmap.mmap(file,Vector{UInt8},0) == Array(UInt8, 0)
 m = Mmap.mmap(file,Vector{UInt8},12)
 m[:] = "Hello World\n".data
 Mmap.sync!(m)
 finalize(m); m=nothing; gc()
-@test open(readall,file) == "Hello World\n"
+@test open(readstring,file) == "Hello World\n"
 
 s = open(file, "r")
 close(s)
@@ -89,15 +87,12 @@ m = Mmap.mmap(file, Vector{UInt8}, 1, sz+1)
 @test m[1] == 0x00
 finalize(m); m=nothing; gc()
 
-# Uncomment out once #11351 is resolved
-# s = open(file, "r")
-# m = Mmap.mmap(s)
-# @test_throws ReadOnlyMemoryError m[5] = Vector{UInt8}('x') # tries to setindex! on read-only array
-# finalize(m); m=nothing; gc()
+s = open(file, "r")
+m = Mmap.mmap(s)
+@test_throws ReadOnlyMemoryError m[5] = UInt8('x') # tries to setindex! on read-only array
+finalize(m); m=nothing; gc()
 
-s = open(file, "w") do f
-    write(f, "Hello World\n")
-end
+write(file, "Hello World\n")
 
 s = open(file, "r")
 m = Mmap.mmap(s)
@@ -115,9 +110,7 @@ close(s)
 finalize(m); finalize(c); finalize(d)
 m=nothing; c=nothing; d=nothing; gc()
 
-s = open(file, "w") do f
-    write(f, "Hello World\n")
-end
+write(file, "Hello World\n")
 
 s = open(file, "r")
 @test isreadonly(s) == true
@@ -237,9 +230,9 @@ n = read(s, Int)
 A2 = Mmap.mmap(s, Matrix{Int}, (m,n))
 @test A == A2
 seek(s, 0)
-A3 = Mmap.mmap(s, Matrix{Int}, (m,n), convert(FileOffset,2*sizeof(Int)))
+A3 = Mmap.mmap(s, Matrix{Int}, (m,n), convert(Int64, 2*sizeof(Int)))
 @test A == A3
-A4 = Mmap.mmap(s, Matrix{Int}, (m,150), convert(FileOffset,(2+150*m)*sizeof(Int)))
+A4 = Mmap.mmap(s, Matrix{Int}, (m,150), convert(Int64, (2+150*m)*sizeof(Int)))
 @test A[:, 151:end] == A4
 close(s)
 finalize(A2); finalize(A3); finalize(A4)
@@ -284,4 +277,17 @@ n = similar(m, (2,2))
 n = similar(m, 12)
 @test length(n) == 12
 @test size(n) == (12,)
-finalize(m); m = nothing; gc()
\ No newline at end of file
+finalize(m); m = nothing; gc()
+
+# test #14885
+file = tempname()
+touch(file)
+open(file, "r+") do s
+    A = Mmap.mmap(s, Vector{UInt8}, (10,), 0);
+    Mmap.sync!(A)
+    finalize(A); A = nothing; gc()
+    A = Mmap.mmap(s, Vector{UInt8}, (10,), 1);
+    Mmap.sync!(A)
+    finalize(A); A = nothing; gc()
+end
+rm(file)
diff --git a/test/mpfr.jl b/test/mpfr.jl
index f4849a3878d06..40f5759ec370e 100644
--- a/test/mpfr.jl
+++ b/test/mpfr.jl
@@ -2,7 +2,7 @@
 
 import Base.MPFR
 # constructors
-with_bigfloat_precision(53) do
+setprecision(53) do
     x = BigFloat()
     x = BigFloat(12)
 end
@@ -90,16 +90,16 @@ z = BigFloat(30)
 @test !(y <= z)
 
 # rounding modes
-with_bigfloat_precision(4) do
+setprecision(4) do
     # default mode is round to nearest
-    down, up =  with_rounding(BigFloat,RoundNearest) do
+    down, up =  setrounding(BigFloat,RoundNearest) do
         parse(BigFloat,"0.0938"), parse(BigFloat,"0.102")
     end
-    with_rounding(BigFloat,RoundDown) do
+    setrounding(BigFloat,RoundDown) do
         @test BigFloat(0.1) == down
         @test BigFloat(0.1) != up
     end
-    with_rounding(BigFloat,RoundUp) do
+    setrounding(BigFloat,RoundUp) do
         @test BigFloat(0.1) != down
         @test BigFloat(0.1) == up
     end
@@ -188,14 +188,14 @@ prevfloat(y)
 @test_throws DomainError sqrt(BigFloat(-1))
 
 # precision
-old_precision = get_bigfloat_precision()
+old_precision = precision(BigFloat)
 x = BigFloat(0)
 @test precision(x) == old_precision
-set_bigfloat_precision(256)
+setprecision(256)
 x = BigFloat(0)
 @test precision(x) == 256
-set_bigfloat_precision(old_precision)
-z = with_bigfloat_precision(240) do
+setprecision(old_precision)
+z = setprecision(240) do
     z = x + 20
     return z
 end
@@ -203,14 +203,23 @@ end
 @test precision(z) == 240
 x = BigFloat(12)
 @test precision(x) == old_precision
-@test_throws DomainError set_bigfloat_precision(1)
+@test_throws DomainError setprecision(1)
 
 # isinteger
+@test !isinteger(BigFloat(1.2))
 @test isinteger(BigFloat(12))
-@test !isinteger(BigFloat(12.12))
+@test isinteger(zero(BigFloat))
+@test isinteger(-zero(BigFloat))
+@test !isinteger(nextfloat(zero(BigFloat)))
+@test !isinteger(prevfloat(zero(BigFloat)))
+@test isinteger(maxintfloat(BigFloat))
+@test isinteger(-maxintfloat(BigFloat))
+@test !isinteger(BigFloat(Inf))
+@test !isinteger(-BigFloat(Inf))
+@test !isinteger(BigFloat(NaN))
 
 # nextfloat / prevfloat
-with_bigfloat_precision(53) do
+setprecision(53) do
     x = BigFloat(12.12)
     @test BigFloat(nextfloat(12.12)) == nextfloat(x)
     @test BigFloat(prevfloat(12.12)) == prevfloat(x)
@@ -274,7 +283,7 @@ y = modf(x)
 @test (isnan(y[1]), isinf(y[2])) == (true, true)
 
 # rem
-with_bigfloat_precision(53) do
+setprecision(53) do
     x = BigFloat(2)
     y = BigFloat(1.67)
     @test rem(x,y) == rem(2, 1.67)
@@ -310,13 +319,13 @@ big_array = ones(BigFloat, 100)
 # promotion
 # the array converts everyone to the DEFAULT_PRECISION!
 x = BigFloat(12)
-y = with_bigfloat_precision(60) do
+y = setprecision(60) do
     BigFloat(42)
 end
 @test [x,y] == [BigFloat(12), BigFloat(42)]
 
 # log / log2 / log10
-with_bigfloat_precision(53) do
+setprecision(53) do
 x = BigFloat(42)
     @test log(x) == log(42)
     @test isinf(log(BigFloat(0)))
@@ -330,7 +339,7 @@ x = BigFloat(42)
 end
 
 # exp / exp2 / exp10
-with_bigfloat_precision(53) do
+setprecision(53) do
     x = BigFloat(10)
     @test exp(x) == exp(10)
     @test exp2(x) == 1024
@@ -353,7 +362,7 @@ y = BigFloat(42)
 
 # round
 x = BigFloat(42.42)
-y = with_bigfloat_precision(256) do
+y = setprecision(256) do
     parse(BigFloat,"9223372036854775809.2324")
 end
 z = parse(BigInt,"9223372036854775809")
@@ -369,20 +378,20 @@ z = parse(BigInt,"9223372036854775809")
 
 # string representation
 str = "1.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012"
-with_bigfloat_precision(406) do
+setprecision(406) do
     @test string(nextfloat(BigFloat(1))) == str
 end
-with_bigfloat_precision(21) do
+setprecision(21) do
     @test string(zero(BigFloat)) == "0.0000000"
     @test string(parse(BigFloat, "0.1")) == "1.0000002e-01"
     @test string(parse(BigFloat, "-9.9")) == "-9.9000015"
 end
-with_bigfloat_precision(40) do
+setprecision(40) do
     @test string(zero(BigFloat)) == "0.0000000000000"
     @test string(parse(BigFloat, "0.1")) == "1.0000000000002e-01"
     @test string(parse(BigFloat, "-9.9")) == "-9.8999999999942"
 end
-with_bigfloat_precision(123) do
+setprecision(123) do
     @test string(zero(BigFloat)) == "0.00000000000000000000000000000000000000"
     @test string(parse(BigFloat, "0.1")) == "9.99999999999999999999999999999999999953e-02"
     @test string(parse(BigFloat, "-9.9")) == "-9.8999999999999999999999999999999999997"
@@ -402,7 +411,7 @@ x = realmax(BigFloat)
 @test isinf(nextfloat(x))
 
 # factorial
-with_bigfloat_precision(256) do
+setprecision(256) do
     x = BigFloat(42)
     @test factorial(x) == factorial(BigInt(42))
     x = BigFloat(10)
@@ -412,7 +421,7 @@ with_bigfloat_precision(256) do
 end
 
 # bessel functions
-with_bigfloat_precision(53) do
+setprecision(53) do
     @test_approx_eq besselj(4, BigFloat(2)) besselj(4, 2.)
     @test_approx_eq besselj0(BigFloat(2))  besselj0(2.)
     @test_approx_eq besselj1(BigFloat(2))  besselj1(2.)
@@ -422,7 +431,7 @@ with_bigfloat_precision(53) do
 end
 
 # trigonometric functions
-with_bigfloat_precision(53) do
+setprecision(53) do
     for f in (:sin,:cos,:tan,:sec,:csc,:cot,:acos,:asin,:atan,
             :cosh,:sinh,:tanh,:sech,:csch,:coth,:asinh),
         j in (-1., -0.5, -0.25, .25, .5, 1.)
@@ -452,12 +461,12 @@ end
 @test hypot(BigFloat(3), BigFloat(4)) == 5
 
 # atan2
-with_bigfloat_precision(53) do
+setprecision(53) do
     @test atan2(12,2) == atan2(BigFloat(12), BigFloat(2))
 end
 
 # ldexp
-with_bigfloat_precision(53) do
+setprecision(53) do
     @test ldexp(BigFloat(24.5), 72) == ldexp(24.5, 72)
     @test ldexp(BigFloat(24.5), Int16(72)) == ldexp(24.5, 72)
     @test ldexp(BigFloat(24.5), -72) == ldexp(24.5, -72)
@@ -839,9 +848,10 @@ i3 = trunc(Integer,f)
 @test i3+1 > f
 @test i3+1 >= f
 
-err(z, x) = abs(z - x) / abs(x)
-@test 1e-60 > err(eta(parse(BigFloat,"1.005")), parse(BigFloat,"0.693945708117842473436705502427198307157819636785324430166786"))
-@test 1e-60 > err(exp(eta(big(1.0))), 2.0)
+let err(z, x) = abs(z - x) / abs(x)
+    @test 1e-60 > err(eta(parse(BigFloat,"1.005")), parse(BigFloat,"0.693945708117842473436705502427198307157819636785324430166786"))
+    @test 1e-60 > err(exp(eta(big(1.0))), 2.0)
+end
 
 # issue #8318
 @test convert(Int64,big(500_000_000_000_000.)) == 500_000_000_000_000
diff --git a/test/netload/memtest.jl b/test/netload/memtest.jl
index aea2239a06f18..627b03ea2a215 100644
--- a/test/netload/memtest.jl
+++ b/test/netload/memtest.jl
@@ -54,7 +54,7 @@ end
 
 function mtest_remotecall_fetch()
     for i in 1:10^5
-        remotecall_fetch(1, myid)
+        remotecall_fetch(myid, 1)
     end
     gc()
 end
diff --git a/test/netload/nettest.jl b/test/netload/nettest.jl
index 057622ddbbc5c..8fb3b7732bbec 100644
--- a/test/netload/nettest.jl
+++ b/test/netload/nettest.jl
@@ -7,9 +7,9 @@ function test_connect_disconnect(exp)
     print("Testing 10^$exp connect/disconnects:\n")
 
     (port, server) = listenany(8000)
-    server_started = RemoteRef()
-    server_exited = RemoteRef()
-    client_exited = RemoteRef()
+    server_started = RemoteChannel()
+    server_exited = RemoteChannel()
+    client_exited = RemoteChannel()
 
     @async begin
         clients_served = 0
@@ -55,9 +55,9 @@ function test_send(exp)
 
     print("Testing open, send of 10^$exp bytes and closing:\n")
 
-    server_started = RemoteRef()
-    server_exited = RemoteRef()
-    client_exited = RemoteRef()
+    server_started = RemoteChannel()
+    server_exited = RemoteChannel()
+    client_exited = RemoteChannel()
 
     @async begin
         print("\t\t\t[SERVER] Started on port $(port)\n")
@@ -148,9 +148,9 @@ function test_bidirectional(exp)
     (port, server) = listenany(8000)
 
     # For both the server and the client, we will transfer/receive 10^exp bytes
-    server_started = RemoteRef()
-    server_exited = RemoteRef()
-    client_exited = RemoteRef()
+    server_started = RemoteChannel()
+    server_exited = RemoteChannel()
+    client_exited = RemoteChannel()
 
     @async begin
         print("\t\t\t[SERVER] Started on port $(port)\n")
diff --git a/test/nullable.jl b/test/nullable.jl
index 974b9bd15b5d8..b7c00a8c3c48e 100644
--- a/test/nullable.jl
+++ b/test/nullable.jl
@@ -94,37 +94,37 @@ p1s = [
 ]
 
 p2s = [
-    "Nullable(false)",
-    "Nullable('\0')",
-    "Nullable(Float16(0.0))",
-    "Nullable(0.0f0)",
-    "Nullable(0.0)",
-    "Nullable(0)",
-    "Nullable(0)",
-    "Nullable(0)",
-    "Nullable(0)",
-    "Nullable(0)",
-    "Nullable(0x0000)",
-    "Nullable(0x00000000)",
-    "Nullable(0x0000000000000000)",
-    "Nullable(0x00)",
+    "Nullable{Bool}(false)",
+    "Nullable{Char}('\0')",
+    "Nullable{Float16}(Float16(0.0))",
+    "Nullable{Float32}(0.0f0)",
+    "Nullable{Float64}(0.0)",
+    "Nullable{Int128}(0)",
+    "Nullable{Int16}(0)",
+    "Nullable{Int32}(0)",
+    "Nullable{Int64}(0)",
+    "Nullable{Int8}(0)",
+    "Nullable{UInt16}(0x0000)",
+    "Nullable{UInt32}(0x00000000)",
+    "Nullable{UInt64}(0x0000000000000000)",
+    "Nullable{UInt8}(0x00)",
 ]
 
 p3s = [
-    "Nullable(true)",
-    "Nullable('\x01')",
-    "Nullable(Float16(1.0))",
-    "Nullable(1.0f0)",
-    "Nullable(1.0)",
-    "Nullable(1)",
-    "Nullable(1)",
-    "Nullable(1)",
-    "Nullable(1)",
-    "Nullable(1)",
-    "Nullable(0x0001)",
-    "Nullable(0x00000001)",
-    "Nullable(0x0000000000000001)",
-    "Nullable(0x01)",
+    "Nullable{Bool}(true)",
+    "Nullable{Char}('\x01')",
+    "Nullable{Float16}(Float16(1.0))",
+    "Nullable{Float32}(1.0f0)",
+    "Nullable{Float64}(1.0)",
+    "Nullable{Int128}(1)",
+    "Nullable{Int16}(1)",
+    "Nullable{Int32}(1)",
+    "Nullable{Int64}(1)",
+    "Nullable{Int8}(1)",
+    "Nullable{UInt16}(0x0001)",
+    "Nullable{UInt32}(0x00000001)",
+    "Nullable{UInt64}(0x0000000000000001)",
+    "Nullable{UInt8}(0x01)",
 ]
 
 # show{T}(io::IO, x::Nullable{T})
@@ -266,7 +266,16 @@ end
 # issue #9462
 for T in types
     @test isa(convert(Nullable{Number}, Nullable(one(T))), Nullable{Number})
+    @test isa(convert(Nullable{Number}, one(T)), Nullable{Number})
+    @test isa(convert(Nullable{T}, one(T)), Nullable{T})
     @test isa(convert(Nullable{Any}, Nullable(one(T))), Nullable{Any})
+    @test isa(convert(Nullable{Any}, one(T)), Nullable{Any})
+
+    # one(T) is convertible to every type in types
+    # let's test that with Nullables
+    for S in types
+        @test isa(convert(Nullable{T}, one(S)), Nullable{T})
+    end
 end
 
 @test isnull(convert(Nullable, nothing))
diff --git a/test/numbers.jl b/test/numbers.jl
index 907157acf52c4..2fb58ff21a945 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -55,6 +55,9 @@
 @test min(1.0,1) == 1
 
 # min, max and minmax
+@test min(1) === 1
+@test max(1) === 1
+@test minmax(1) === (1, 1)
 @test minmax(5, 3) == (3, 5)
 @test minmax(3., 5.) == (3., 5.)
 @test minmax(5., 3.) == (3., 5.)
@@ -473,6 +476,118 @@ end
 
 @test copysign(big(1.0),big(-2.0)) == big(-1.0)
 
+#copysign
+@test copysign(-1,1) == 1
+@test copysign(1,-1) == -1
+
+@test copysign(-1,1.0) == 1
+@test copysign(1,-1.0) == -1
+
+@test copysign(-1,1//2) == 1
+@test copysign(1,-1//2) == -1
+
+@test copysign(1.0,-1) == -1.0
+@test copysign(-1.0,1) == 1.0
+
+@test copysign(1.0,-1.0) == -1.0
+@test copysign(-1.0,1.0) == 1.0
+
+@test copysign(1.0,-1//2) == -1.0
+@test copysign(-1.0,1//2) == 1.0
+
+@test copysign(1//2,-1) == -1//2
+@test copysign(-1//2,1) == 1//2
+
+@test copysign(1//2,-1//2) == -1//2
+@test copysign(-1//2,1//2) == 1//2
+
+@test copysign(1//2,-1.0) == -1//2
+@test copysign(-1//2,1.0) == 1//2
+
+# verify type stability with integer (x is negative)
+@test eltype(copysign(-1,1)) <: Integer
+@test eltype(copysign(-1,BigInt(1))) <: Integer
+@test eltype(copysign(-1,1.0)) <: Integer
+@test eltype(copysign(-1,1//2)) <: Integer
+@test eltype(copysign(-BigInt(1),1)) <: Integer
+@test eltype(copysign(-BigInt(1),1.0)) <: Integer
+@test eltype(copysign(-BigInt(1),1//2)) <: Integer
+@test eltype(copysign(-BigInt(1),BigInt(1))) <: Integer
+@test eltype(copysign(-1,-1)) <: Integer
+@test eltype(copysign(-1,-BigInt(1))) <: Integer
+@test eltype(copysign(-1,-1.0)) <: Integer
+@test eltype(copysign(-1,-1//2)) <: Integer
+@test eltype(copysign(-BigInt(1),-1)) <: Integer
+@test eltype(copysign(-BigInt(1),-1.0)) <: Integer
+@test eltype(copysign(-BigInt(1),-1//2)) <: Integer
+@test eltype(copysign(-BigInt(1),-BigInt(1))) <: Integer
+
+# verify type stability with integer (x is positive)
+@test eltype(copysign(1,1)) <: Integer
+@test eltype(copysign(1,BigInt(1))) <: Integer
+@test eltype(copysign(1,1.0)) <: Integer
+@test eltype(copysign(1,1//2)) <: Integer
+@test eltype(copysign(BigInt(1),1)) <: Integer
+@test eltype(copysign(BigInt(1),1.0)) <: Integer
+@test eltype(copysign(BigInt(1),1//2)) <: Integer
+@test eltype(copysign(BigInt(1),BigInt(1))) <: Integer
+@test eltype(copysign(1,-1)) <: Integer
+@test eltype(copysign(1,-BigInt(1))) <: Integer
+@test eltype(copysign(1,-1.0)) <: Integer
+@test eltype(copysign(1,-1//2)) <: Integer
+@test eltype(copysign(BigInt(1),-1)) <: Integer
+@test eltype(copysign(BigInt(1),-1.0)) <: Integer
+@test eltype(copysign(BigInt(1),-1//2)) <: Integer
+@test eltype(copysign(BigInt(1),-BigInt(1))) <: Integer
+
+# verify type stability with real (x is negative)
+@test eltype(copysign(-1.0,1)) <: Real
+@test eltype(copysign(-1.0,BigInt(1))) <: Real
+@test eltype(copysign(-1.0,1.0)) <: Real
+@test eltype(copysign(-1.0,1//2)) <: Real
+@test eltype(copysign(-1.0,-1)) <: Real
+@test eltype(copysign(-1.0,-BigInt(1))) <: Real
+@test eltype(copysign(-1.0,-1.0)) <: Real
+@test eltype(copysign(-1.0,-1//2)) <: Real
+
+# Verify type stability with real (x is positive)
+@test eltype(copysign(1.0,1)) <: Real
+@test eltype(copysign(1.0,BigInt(1))) <: Real
+@test eltype(copysign(1.0,1.0)) <: Real
+@test eltype(copysign(1.0,1//2)) <: Real
+@test eltype(copysign(1.0,-1)) <: Real
+@test eltype(copysign(1.0,-BigInt(1))) <: Real
+@test eltype(copysign(1.0,-1.0)) <: Real
+@test eltype(copysign(1.0,-1//2)) <: Real
+
+# Verify type stability with rational (x is negative)
+@test eltype(copysign(-1//2,1)) <: Rational
+@test eltype(copysign(-1//2,BigInt(1))) <: Rational
+@test eltype(copysign(-1//2,1.0)) <: Rational
+@test eltype(copysign(-1//2,1//2)) <: Rational
+@test eltype(copysign(-1//2,-1)) <: Rational
+@test eltype(copysign(-1//2,-BigInt(1))) <: Rational
+@test eltype(copysign(-1//2,-1.0)) <: Rational
+@test eltype(copysign(-1//2,-1//2)) <: Rational
+
+# Verify type stability with rational (x is positive)
+@test eltype(copysign(-1//2,1)) <: Rational
+@test eltype(copysign(-1//2,BigInt(1))) <: Rational
+@test eltype(copysign(-1//2,1.0)) <: Rational
+@test eltype(copysign(-1//2,1//2)) <: Rational
+@test eltype(copysign(-1//2,-1)) <: Rational
+@test eltype(copysign(-1//2,-BigInt(1))) <: Rational
+@test eltype(copysign(-1//2,-1.0)) <: Rational
+@test eltype(copysign(-1//2,-1//2)) <: Rational
+
+# test x = NaN
+@test isnan(copysign(0/0,1))
+@test isnan(copysign(0/0,-1))
+
+# test x = Inf
+@test isinf(copysign(1/0,1))
+@test isinf(copysign(1/0,-1))
+
 @test isnan(1)     == false
 @test isnan(1.0)   == false
 @test isnan(-1.0)  == false
@@ -818,6 +933,9 @@ end
 @test 2.0^63 != UInt64(2)^63+1
 
 @test typemax(UInt64) != 2.0^64
+# issue #9085
+f9085() = typemax(UInt64) != 2.0^64
+@test f9085()
 
 @test typemax(UInt64) < Float64(typemax(UInt64))
 @test typemax(Int64) < Float64(typemax(Int64))
@@ -1010,7 +1128,7 @@ end
 @test_approx_eq (Complex(1,2)/Complex(2.5,3.0))*Complex(2.5,3.0) Complex(1,2)
 @test 0.7 < real(sqrt(Complex(0,1))) < 0.707107
 
-for T in [Int8, Int16, Int32, Int64, Int128]
+for T in Base.BitSigned_types
     @test abs(typemin(T)) == -typemin(T)
     #for x in (typemin(T),convert(T,-1),zero(T),one(T),typemax(T))
     #    @test signed(unsigned(x)) == x
@@ -1022,8 +1140,8 @@ end
 #    @test unsigned(signed(x)) == x
 #end
 
-for S = [Int8,  Int16,  Int32,  Int64],
-    U = [UInt8, UInt16, UInt32, UInt64]
+for S = Base.BitSigned64_types,
+    U = Base.BitUnsigned64_types
     @test !(-one(S) == typemax(U))
     @test -one(S) != typemax(U)
     @test -one(S) < typemax(U)
@@ -1031,7 +1149,7 @@ for S = [Int8,  Int16,  Int32,  Int64],
 end
 
 # check type of constructed rationals
-int_types = [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64]
+int_types = Base.BitInteger64_types
 for N = int_types, D = int_types
     T = promote_type(N,D)
     @test typeof(convert(N,2)//convert(D,3)) <: Rational{T}
@@ -1041,9 +1159,9 @@ end
 @test typeof(convert(Rational{Integer},1)) === Rational{Integer}
 
 # check type of constructed complexes
-real_types = [Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Float32, Float64,
-              Rational{Int8}, Rational{UInt8}, Rational{Int16}, Rational{UInt16},
-              Rational{Int32}, Rational{UInt32}, Rational{Int64}, Rational{UInt64}]
+real_types = [Base.BitInteger64_types...,
+              [Rational{T} for T in Base.BitInteger64_types]...,
+              Float32, Float64]
 for A = real_types, B = real_types
     T = promote_type(A,B)
     @test typeof(Complex(convert(A,2),convert(B,3))) <: Complex{T}
@@ -1478,6 +1596,41 @@ end
 @test signed(cld(typemax(UInt),typemin(Int)>>1))     == -3
 @test signed(cld(typemax(UInt),(typemin(Int)>>1)+1)) == -4
 
+# Test exceptions and special cases
+for T in (Int8,Int16,Int32,Int64,Int128, UInt8,UInt16,UInt32,UInt64,UInt128)
+    @test_throws DivideError div(T(1), T(0))
+    @test_throws DivideError fld(T(1), T(0))
+    @test_throws DivideError cld(T(1), T(0))
+    @test_throws DivideError rem(T(1), T(0))
+    @test_throws DivideError mod(T(1), T(0))
+end
+for T in (Int8,Int16,Int32,Int64,Int128)
+    @test_throws DivideError div(typemin(T), T(-1))
+    @test_throws DivideError fld(typemin(T), T(-1))
+    @test_throws DivideError cld(typemin(T), T(-1))
+    @test rem(typemin(T), T(-1)) === T(0)
+    @test mod(typemin(T), T(-1)) === T(0)
+end
+
+# Test return types
+for T in (Int8,Int16,Int32,Int64,Int128, UInt8,UInt16,UInt32,UInt64,UInt128)
+    z, o = T(0), T(1)
+    @test typeof(+z) === T
+    @test typeof(-z) === T
+    @test typeof(abs(z)) === T
+    @test typeof(sign(z)) === T
+    @test typeof(copysign(z,z)) === T
+    @test typeof(flipsign(z,z)) === T
+    @test typeof(z+z) === T
+    @test typeof(z-z) === T
+    @test typeof(z*z) === T
+    @test typeof(z÷o) === T
+    @test typeof(z%o) === T
+    @test typeof(fld(z,o)) === T
+    @test typeof(mod(z,o)) === T
+    @test typeof(cld(z,o)) === T
+end
+
 # issue #4156
 @test fld(1.4,0.35667494393873234) == 3.0
 @test div(1.4,0.35667494393873234) == 3.0
@@ -1510,10 +1663,10 @@ end
 @test isnan(eps(-Inf))
 
 @test .1+.1+.1 != .3
-# TODO: uncomment when isapprox() becomes part of base.
-# @test isapprox(.1+.1+.1, .3)
-# @test !isapprox(.1+.1+.1-.3, 0)
-# @test isapprox(.1+.1+.1-.3, 0, eps(.3))
+@test isapprox(.1+.1+.1, .3)
+@test !isapprox(.1+.1+.1-.3, 0)
+@test isapprox(.1+.1+.1-.3, 0, atol=eps(.3))
+@test isapprox(1.1,1.1f0)
 
 @test div(1e50,1) == 1e50
 @test fld(1e50,1) == 1e50
@@ -2126,6 +2279,11 @@ end
 @test !isprime(0xffffffffffffffc7)
 @test !isprime(0xffffffffffffffc9)
 
+for T in [Int8,UInt8,Int16,UInt16,Int128,UInt128]
+    @test isprime(T(2))
+    @test !isprime(T(4))
+end
+
 # issue #5210
 @test prod([ k^v for (k,v) in factor(typemax(UInt32)) ]) == typemax(UInt32)
 @test prod([ k^v for (k,v) in factor(typemax(Int8)) ]) == typemax(Int8)
@@ -2177,25 +2335,32 @@ for T in (Int32,Int64), ii = -20:20, jj = -20:20
     end
 end
 
-# check powermod function against GMP
+# check powermod function against few types (in particular [U]Int128 and BigInt)
 for i = -10:10, p = 0:5, m = -10:10
-    if m != 0
-        @test powermod(i,p,m) == powermod(i,p,big(m)) == powermod(big(i),big(p),big(m))
-        @test mod(i^p,m) == powermod(i,p,m) == mod(big(i)^p,big(m))
+    m == 0 && continue
+    x = powermod(i, p, m)
+    for T in [Int32, Int64, Int128, UInt128, BigInt]
+        T <: Unsigned && m < 0 && continue
+        let xT = powermod(i, p, T(m))
+            @test x == xT
+            @test isa(xT, T)
+        end
+        T <: Unsigned && i < 0 && continue
+        @test x == mod(T(i)^p, T(m))
     end
 end
 
 # with m==1 should give 0
 @test powermod(1,0,1) == 0
-@test powermod(big(1),0,1) == 0
+@test powermod(1,0,big(1)) == 0
 @test powermod(1,0,-1) == 0
-@test powermod(big(1),0,-1) == 0
+@test powermod(1,0,big(-1)) == 0
 # divide by zero error
 @test_throws DivideError powermod(1,0,0)
-@test_throws DivideError powermod(big(1),0,0)
+@test_throws DivideError powermod(1,0,big(0))
 # negative power domain error
 @test_throws DomainError powermod(1,-2,1)
-@test_throws DomainError powermod(big(1),-2,1)
+@test_throws DomainError powermod(1,-2,big(1))
 
 # other divide-by-zero errors
 @test_throws DivideError div(1,0)
@@ -2267,10 +2432,6 @@ end
 @test nextprod([2,3,5],30) == 30
 @test nextprod([2,3,5],33) == 36
 
-@test_throws ArgumentError prevprod([2,3,5],Int128(typemax(Int))+1)
-@test prevprod([2,3,5],30) == 30
-@test prevprod([2,3,5],33) == 32
-
 @test nextfloat(0.0) == 5.0e-324
 @test prevfloat(0.0) == -5.0e-324
 @test nextfloat(-0.0) == 5.0e-324
@@ -2304,6 +2465,9 @@ end
 @test true*pi === Float64(pi)
 @test pi*true === Float64(pi)
 
+# issue #5492
+@test -0.0 + false === -0.0
+
 # issue #5881
 @test bits(true) == "00000001"
 @test bits(false) == "00000000"
@@ -2323,7 +2487,7 @@ end
 # widen
 @test widen(1.5f0) === 1.5
 @test widen(Int32(42)) === Int64(42)
-@test widen(Int8) === Int
+@test widen(Int8) === Int32
 @test widen(Float32) === Float64
 ## Note: this should change to e.g. Float128 at some point
 @test widen(Float64) === BigFloat
@@ -2353,6 +2517,12 @@ end
 # issue #7508
 @test_throws ErrorException reinterpret(Int, 0x01)
 
+# issue #12832
+@test_throws ErrorException reinterpret(Float64, Complex{Int64}(1))
+@test_throws ErrorException reinterpret(Float64, Complex64(1))
+@test_throws ErrorException reinterpret(Complex64, Float64(1))
+@test_throws ErrorException reinterpret(Int32, false)
+
 # issue #41
 ndigf(n) = Float64(log(Float32(n)))
 @test Float64(log(Float32(256))) == ndigf(256) == 5.545177459716797
@@ -2408,6 +2578,9 @@ end
 # test second branch, after all small primes in list have been searched
 @test factor(10009 * Int128(1000000000000037)) == Dict(10009=>1,1000000000000037=>1)
 
+@test all(x -> (m=mod1(x,3); 0<m<=3), -5:+5)
+@test all(x -> x == (fld1(x,3)-1)*3 + mod1(x,3), -5:+5)
+@test all(x -> fldmod1(x,3) == (fld1(x,3), mod1(x,3)), -5:+5)
 #Issue #5570
 @test map(x -> Int(mod1(UInt(x),UInt(5))), 0:15) == [5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
 
@@ -2444,17 +2617,33 @@ for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
     @test getindex(x) == x
 end
 
-#copysign(x::Real, y::Real) = ifelse(signbit(x)!=signbit(y), -x, x)
-#same sign
-for x in [1.23, 7, e, 4//5]
-    for y in [1.23, 7, e, 4//5]
-        @test copysign(x,y) == x
-    end
+#getindex(x::Number,-1) throws BoundsError
+#getindex(x::Number,0) throws BoundsError
+#getindex(x::Number,2) throws BoundsError
+#getindex(x::Array,-1) throws BoundsError
+#getindex(x::Array,0 throws BoundsError
+#getindex(x::Array,length(x::Array)+1) throws BoundsError
+for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
+    @test_throws BoundsError getindex(x,-1)
+    @test_throws BoundsError getindex(x,0)
+    @test_throws BoundsError getindex(x,2)
+    @test_throws BoundsError getindex([x x],-1)
+    @test_throws BoundsError getindex([x x],0)
+    @test_throws BoundsError getindex([x x],length([x,x])+1)
 end
-#different sign
+
+# copysign(x::Real, y::Real) = ifelse(signbit(x)!=signbit(y), -x, x)
+# flipsign(x::Real, y::Real) = ifelse(signbit(y), -x, x)
 for x in [1.23, 7, e, 4//5]
     for y in [1.23, 7, e, 4//5]
+        @test copysign(x, y) == x
         @test copysign(x, -y) == -x
+        @test copysign(-x, y) == x
+        @test copysign(-x, -y) == -x
+        @test flipsign(x, y) == x
+        @test flipsign(x, -y) == -x
+        @test flipsign(-x, y) == -x
+        @test flipsign(-x, -y) == x
     end
 end
 
@@ -2471,11 +2660,13 @@ end
 @test in(1+2im, 1+2im) == true #Imag
 @test in(3, 3.0) == true #mixed
 
-#map(f::Callable, x::Number) = f(x)
+#map(f::Callable, x::Number, ys::Number...) = f(x)
 @test map(sin, 3) == sin(3)
 @test map(cos, 3) == cos(3)
 @test map(tan, 3) == tan(3)
 @test map(log, 3) == log(3)
+@test map(copysign, 1.0, -2.0) == -1.0
+@test map(muladd, 2, 3, 4) == 10
 
 @test_throws InexactError convert(UInt8, big(300))
 
@@ -2522,3 +2713,146 @@ end
 # issue #12536
 @test Rational{Int16}(1,2) === Rational(Int16(1),Int16(2))
 @test Rational{Int16}(500000,1000000) === Rational(Int16(1),Int16(2))
+
+
+rand_int = rand(Int8)
+
+for T in [Int8, Int16, Int32, Int128, BigInt]
+    @test num(convert(T, rand_int)) == rand_int
+    @test den(convert(T, rand_int)) == 1
+
+    @test typemin(Rational{T}) == -one(T)//zero(T)
+    @test typemax(Rational{T}) == one(T)//zero(T)
+    @test widen(Rational{T}) == Rational{widen(T)}
+end
+
+@test Rational(Float32(rand_int)) == Rational(rand_int)
+
+@test Rational(Rational(rand_int)) == Rational(rand_int)
+
+@test begin
+    var = -Rational(UInt32(0))
+    var == UInt32(0)
+end
+
+@test Rational(rand_int, 3)/Complex(3, 2) == Complex(Rational(rand_int, 13), -Rational(rand_int*2, 39))
+
+@test Complex(rand_int, 0) == Rational(rand_int)
+@test Rational(rand_int) == Complex(rand_int, 0)
+
+@test (Complex(rand_int, 4) == Rational(rand_int)) == false
+@test (Rational(rand_int) == Complex(rand_int, 4)) == false
+
+@test trunc(Rational(BigInt(rand_int), BigInt(3))) == Rational(trunc(BigInt, Rational(BigInt(rand_int),BigInt(3))))
+@test  ceil(Rational(BigInt(rand_int), BigInt(3))) == Rational( ceil(BigInt, Rational(BigInt(rand_int),BigInt(3))))
+@test round(Rational(BigInt(rand_int), BigInt(3))) == Rational(round(BigInt, Rational(BigInt(rand_int),BigInt(3))))
+
+
+for a = -3:3
+    @test Rational(Float32(a)) == Rational(a)
+    @test Rational(a)//2 == a//2
+    @test a//Rational(2) == Rational(a/2)
+    @test a.//[-2, -1, 1, 2] == [-a//2, -a//1, a//1, a//2]
+    for b=-3:3, c=1:3
+        @test b//(a+c*im) == b*a//(a^2+c^2)-(b*c//(a^2+c^2))*im
+        for d=-3:3
+            @test (a+b*im)//(c+d*im) == (a*c+b*d+(b*c-a*d)*im)//(c^2+d^2)
+            @test Complex(Rational(a)+b*im)//Complex(Rational(c)+d*im) == Complex(a+b*im)//Complex(c+d*im)
+        end
+    end
+end
+
+# issue #15205
+let T = Rational
+    x = Complex{T}(1//3 + 1//4*im)
+    y = Complex{T}(1//2 + 1//5*im)
+    xf = Complex{Float64}(1//3 + 1//4*im)
+    yf = Complex{Float64}(1//2 + 1//5*im)
+    yi = 4
+
+    @test_approx_eq x^y big(xf)^big(yf)
+    @test_approx_eq x^yi big(xf)^yi
+    @test_approx_eq x^true big(xf)^true
+    @test_approx_eq x^false big(xf)^false
+    @test_approx_eq x^1 big(xf)^1
+end
+
+for Tf = (Float16, Float32, Float64), Ti = (Int16, Int32, Int64)
+    almost_half  = Rational(div(typemax(Ti),Ti(2))  , typemax(Ti))
+    over_half    = Rational(div(typemax(Ti),Ti(2))+one(Ti), typemax(Ti))
+    exactly_half = Rational(one(Ti)  , Ti(2))
+
+    @test round( almost_half) == 0//1
+    @test round(-almost_half) == 0//1
+    @test round(Tf,  almost_half, RoundNearestTiesUp) == 0.0
+    @test round(Tf, -almost_half, RoundNearestTiesUp) == 0.0
+    @test round(Tf,  almost_half, RoundNearestTiesAway) == 0.0
+    @test round(Tf, -almost_half, RoundNearestTiesAway) == 0.0
+
+    @test round( exactly_half) == 0//1 # rounds to closest _even_ integer
+    @test round(-exactly_half) == 0//1 # rounds to closest _even_ integer
+    @test round(Tf,  exactly_half, RoundNearestTiesUp) == 1.0
+    @test round(Tf, -exactly_half, RoundNearestTiesUp) == 0.0
+    @test round(Tf,  exactly_half, RoundNearestTiesAway) == 1.0
+    @test round(Tf, -exactly_half, RoundNearestTiesAway) == -1.0
+
+
+    @test round(over_half) == 1//1
+    @test round(-over_half) == -1//1
+    @test round(Tf,  over_half, RoundNearestTiesUp) == 1.0
+    @test round(Tf,  over_half, RoundNearestTiesAway) == 1.0
+    @test round(Tf, -over_half, RoundNearestTiesUp) == -1.0
+    @test round(Tf, -over_half, RoundNearestTiesAway) == -1.0
+
+    @test round(Tf, 11//2, RoundNearestTiesUp) == 6.0
+    @test round(Tf, -11//2, RoundNearestTiesUp) == -5.0
+    @test round(Tf, 11//2, RoundNearestTiesAway) == 6.0
+    @test round(Tf, -11//2, RoundNearestTiesAway) == -6.0
+
+    @test round(Tf, Ti(-1)//zero(Ti)) == -Inf
+    @test round(Tf, one(1)//zero(Ti)) == Inf
+    @test round(Tf, Ti(-1)//zero(Ti), RoundNearestTiesUp) == -Inf
+    @test round(Tf, one(1)//zero(Ti), RoundNearestTiesUp) == Inf
+    @test round(Tf, Ti(-1)//zero(Ti), RoundNearestTiesAway) == -Inf
+    @test round(Tf, one(1)//zero(Ti), RoundNearestTiesAway) == Inf
+
+    @test round(Tf, zero(Ti)//one(Ti)) == 0
+    @test round(Tf, zero(Ti)//one(Ti), RoundNearestTiesUp) == 0
+    @test round(Tf, zero(Ti)//one(Ti), RoundNearestTiesAway) == 0
+end
+
+let
+    io = IOBuffer()
+    rational1 = Rational(1465, 8593)
+    rational2 = Rational(-4500, 9000)
+    @test sprint(io -> show(io, rational1)) == "1465//8593"
+    @test sprint(io -> show(io, rational2)) == "-1//2"
+    let
+        io1 = IOBuffer()
+        write(io1, rational1)
+        io1.ptr = 1
+        @test read(io1, typeof(rational1)) == rational1
+
+        io2 = IOBuffer()
+        write(io2, rational2)
+        io2.ptr = 1
+        @test read(io2, typeof(rational2)) == rational2
+    end
+end
+
+@test round(11//2) == 6//1 # rounds to closest _even_ integer
+@test round(-11//2) == -6//1 # rounds to closest _even_ integer
+@test round(11//3) == 4//1 # rounds to closest _even_ integer
+@test round(-11//3) == -4//1 # rounds to closest _even_ integer
+
+for T in (Float16, Float32, Float64)
+    @test round(T, true//false) === convert(T, Inf)
+    @test round(T, true//true) === one(T)
+    @test round(T, false//true) === zero(T)
+end
+
+for T in (Int8, Int16, Int32, Int64, Bool)
+    @test_throws DivideError round(T, true//false)
+    @test round(T, true//true) === one(T)
+    @test round(T, false//true) === zero(T)
+end
diff --git a/test/operators.jl b/test/operators.jl
index 88116b88decf9..1b562f4004598 100644
--- a/test/operators.jl
+++ b/test/operators.jl
@@ -20,6 +20,7 @@ B = [true true false]
 
 @test reverse(Pair(1,2)) == Pair(2,1)
 @test reverse(Pair("13","24")) == Pair("24","13")
+@test typeof(reverse(Pair{ByteString,Int64}("a",1))) == Pair{Int64,ByteString}
 
 p = 1=>:foo
 @test first(p) == 1
@@ -47,3 +48,10 @@ p = 1=>:foo
 @test 1 .== 1
 @test 1 .< 2
 @test 1 .<= 2
+
+# issue #13144: max() with 4 or more array arguments
+let xs = [[i:i+4;] for i in 1:10]
+    for n in 2:10
+        @test max(xs[1:n]...) == [n:n+4;]
+    end
+end
diff --git a/test/parallel.jl b/test/parallel.jl
index 021fb2ed23a54..3d1cb906c6c24 100644
--- a/test/parallel.jl
+++ b/test/parallel.jl
@@ -1,519 +1,18 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-# NOTE: worker processes cannot add more workers, only the client process can.
-using Base.Test
+# Run the parallel test outside of the main driver since it needs its own
+# set of dedicated workers.
 
-if nworkers() < 3
-    remotecall_fetch(1, () -> addprocs(3 - nworkers()))
+inline_flag = Base.JLOptions().can_inline == 1 ? `` : `--inline=no`
+cov_flag = ``
+if Base.JLOptions().code_coverage == 1
+    cov_flag = `--code-coverage=user`
+elseif Base.JLOptions().code_coverage == 2
+    cov_flag = `--code-coverage=all`
 end
 
-id_me = myid()
-id_other = filter(x -> x != id_me, procs())[rand(1:(nprocs()-1))]
+cmd = `$(Base.julia_cmd()) $inline_flag $cov_flag --check-bounds=yes --depwarn=error parallel_exec.jl`
 
-@test fetch(@spawnat id_other myid()) == id_other
-@test @fetchfrom id_other begin myid() end == id_other
-@fetch begin myid() end
-
-rr=RemoteRef()
-@test typeof(rr) == RemoteRef{Channel{Any}}
-a = rand(5,5)
-put!(rr, a)
-@test rr[2,3] == a[2,3]
-@test rr[] == a
-
-rr=RemoteRef(workers()[1])
-@test typeof(rr) == RemoteRef{Channel{Any}}
-a = rand(5,5)
-put!(rr, a)
-@test rr[1,5] == a[1,5]
-@test rr[] == a
-
-dims = (20,20,20)
-
-@linux_only begin
-    S = SharedArray(Int64, dims)
-    @test startswith(S.segname, "/jl")
-    @test !ispath("/dev/shm" * S.segname)
-
-    S = SharedArray(Int64, dims; pids=[id_other])
-    @test startswith(S.segname, "/jl")
-    @test !ispath("/dev/shm" * S.segname)
-end
-
-# TODO : Need a similar test of shmem cleanup for OSX
-
-##### SharedArray tests
-
-function check_pids_all(S::SharedArray)
-    pidtested = falses(size(S))
-    for p in procs(S)
-        idxes_in_p = remotecall_fetch(p, D -> parentindexes(D.loc_subarr_1d)[1], S)
-        @test all(sdata(S)[idxes_in_p] .== p)
-        pidtested[idxes_in_p] = true
-    end
-    @test all(pidtested)
-end
-
-d = Base.shmem_rand(1:100, dims)
-a = convert(Array, d)
-
-partsums = Array(Int, length(procs(d)))
-@sync begin
-    for (i, p) in enumerate(procs(d))
-        @async partsums[i] = remotecall_fetch(p, D->sum(D.loc_subarr_1d), d)
-    end
-end
-@test sum(a) == sum(partsums)
-
-d = Base.shmem_rand(dims)
-for p in procs(d)
-    idxes_in_p = remotecall_fetch(p, D -> parentindexes(D.loc_subarr_1d)[1], d)
-    idxf = first(idxes_in_p)
-    idxl = last(idxes_in_p)
-    d[idxf] = Float64(idxf)
-    rv = remotecall_fetch(p, (D,idxf,idxl) -> begin assert(D[idxf] == Float64(idxf)); D[idxl] = Float64(idxl); D[idxl];  end, d,idxf,idxl)
-    @test d[idxl] == rv
-end
-
-@test ones(10, 10, 10) == Base.shmem_fill(1.0, (10,10,10))
-@test zeros(Int32, 10, 10, 10) == Base.shmem_fill(0, (10,10,10))
-
-d = Base.shmem_rand(dims)
-s = Base.shmem_rand(dims)
-copy!(s, d)
-@test s == d
-s = Base.shmem_rand(dims)
-copy!(s, sdata(d))
-@test s == d
-a = rand(dims)
-@test sdata(a) == a
-
-d = SharedArray(Int, dims; init = D->fill!(D.loc_subarr_1d, myid()))
-for p in procs(d)
-    idxes_in_p = remotecall_fetch(p, D -> parentindexes(D.loc_subarr_1d)[1], d)
-    idxf = first(idxes_in_p)
-    idxl = last(idxes_in_p)
-    @test d[idxf] == p
-    @test d[idxl] == p
-end
-
-d = SharedArray(Float64, (2,3))
-@test isa(d[:,2], Vector{Float64})
-
-### SharedArrays from a file
-
-# Mapping an existing file
-fn = tempname()
-open(fn, "w") do io
-    write(io, 1:30)
-end
-sz = (6,5)
-Atrue = reshape(1:30, sz)
-
-S = SharedArray(fn, Int, sz)
-@test S == Atrue
-@test length(procs(S)) > 1
-@sync begin
-    for p in procs(S)
-        @async remotecall_wait(p, D->fill!(D.loc_subarr_1d, myid()), S)
-    end
-end
-check_pids_all(S)
-
-filedata = similar(Atrue)
-open(fn, "r") do io
-    read!(io, filedata)
-end
-@test filedata == sdata(S)
-
-# Error for write-only files
-@test_throws ArgumentError SharedArray(fn, Int, sz, mode="w")
-
-# Error for file doesn't exist, but not allowed to create
-@test_throws ArgumentError SharedArray(tempname(), Int, sz, mode="r")
-
-# Creating a new file
-fn2 = tempname()
-S = SharedArray(fn2, Int, sz, init=D->D[localindexes(D)] = myid())
-@test S == filedata
-filedata2 = similar(Atrue)
-open(fn2, "r") do io
-    read!(io, filedata2)
-end
-@test filedata == filedata2
-
-# Appending to a file
-fn3 = tempname()
-open(fn3, "w") do io
-    write(io, ones(UInt8, 4))
-end
-S = SharedArray(fn3, UInt8, sz, 4, mode="a+", init=D->D[localindexes(D)]=0x02)
-len = prod(sz)+4
-@test filesize(fn3) == len
-filedata = Array(UInt8, len)
-open(fn3, "r") do io
-    read!(io, filedata)
-end
-@test all(filedata[1:4] .== 0x01)
-@test all(filedata[5:end] .== 0x02)
-
-@unix_only begin # these give unlink: operation not permitted (EPERM) on Windows
-    rm(fn); rm(fn2); rm(fn3)
-end
-
-### Utility functions
-
-# reshape
-
-d = Base.shmem_fill(1.0, (10,10,10))
-@test ones(100, 10) == reshape(d,(100,10))
-d = Base.shmem_fill(1.0, (10,10,10))
-@test_throws DimensionMismatch reshape(d,(50,))
-
-# rand, randn
-d = Base.shmem_rand(dims)
-@test size(rand!(d)) == dims
-d = Base.shmem_fill(1.0, dims)
-@test size(randn!(d)) == dims
-
-# similar
-d = Base.shmem_rand(dims)
-@test size(similar(d, Complex128)) == dims
-@test size(similar(d, dims)) == dims
-
-# issue #6362
-d = Base.shmem_rand(dims)
-s = copy(sdata(d))
-ds = deepcopy(d)
-@test ds == d
-pids_d = procs(d)
-remotecall_fetch(pids_d[findfirst(id->(id != myid()), pids_d)], setindex!, d, 1.0, 1:10)
-@test ds != d
-@test s != d
-
-
-# SharedArray as an array
-# Since the data in d will depend on the nprocs, just test that these operations work
-a = d[1:5]
-@test_throws BoundsError d[-1:5]
-a = d[1,1,1:3:end]
-d[2:4] = 7
-d[5,1:2:4,8] = 19
-
-AA = rand(4,2)
-A = convert(SharedArray, AA)
-B = convert(SharedArray, AA')
-@test B*A == ctranspose(AA)*AA
-
-d=SharedArray(Int64, (10,10); init = D->fill!(D.loc_subarr_1d, myid()), pids=[id_me, id_other])
-d2 = map(x->1, d)
-@test reduce(+, d2) == 100
-
-@test reduce(+, d) == ((50*id_me) + (50*id_other))
-map!(x->1, d)
-@test reduce(+, d) == 100
-
-@test fill!(d, 1) == ones(10, 10)
-@test fill!(d, 2.) == fill(2, 10, 10)
-@test d[:] == fill(2, 100)
-@test d[:,1] == fill(2, 10)
-@test d[1,:] == fill(2, 1, 10)
-
-# Boundary cases where length(S) <= length(pids)
-@test 2.0 == remotecall_fetch(id_other, D->D[2], Base.shmem_fill(2.0, 2; pids=[id_me, id_other]))
-@test 3.0 == remotecall_fetch(id_other, D->D[1], Base.shmem_fill(3.0, 1; pids=[id_me, id_other]))
-
-# Test @parallel load balancing - all processors should get either M or M+1
-# iterations out of the loop range for some M.
-workloads = hist(@parallel((a,b)->[a;b], for i=1:7; myid(); end), nprocs())[2]
-@test maximum(workloads) - minimum(workloads) <= 1
-
-# @parallel reduction should work even with very short ranges
-@test @parallel(+, for i=1:2; i; end) == 3
-
-# Testing timedwait on multiple channels
-@sync begin
-    rr1 = Channel()
-    rr2 = Channel()
-    rr3 = Channel()
-
-    @async begin sleep(0.5); put!(rr1, :ok) end
-    @async begin sleep(1.0); put!(rr2, :ok) end
-    @async begin sleep(2.0); put!(rr3, :ok) end
-
-    tic()
-    timedwait(1.0) do
-        all(map(isready, [rr1, rr2, rr3]))
-    end
-    et=toq()
-    # assuming that 0.5 seconds is a good enough buffer on a typical modern CPU
-    try
-        @test (et >= 1.0) && (et <= 1.5)
-        @test !isready(rr3)
-    catch
-        warn("timedwait tests delayed. et=$et, isready(rr3)=$(isready(rr3))")
-    end
-    @test isready(rr1)
-end
-
-@test_throws ArgumentError sleep(-1)
-@test_throws ArgumentError timedwait(()->false, 0.1, pollint=-0.5)
-
-# specify pids for pmap
-@test sort(workers()[1:2]) == sort(unique(pmap(x->(sleep(0.1);myid()), 1:10, pids = workers()[1:2])))
-
-# Testing buffered  and unbuffered reads
-# This large array should write directly to the socket
-a = ones(10^6)
-@test a == remotecall_fetch(id_other, (x)->x, a)
-
-# Not a bitstype, should be buffered
-s = [randstring() for x in 1:10^5]
-@test s == remotecall_fetch(id_other, (x)->x, s)
-
-#large number of small requests
-num_small_requests = 10000
-@test fill(id_other, num_small_requests) == [remotecall_fetch(id_other, myid) for i in 1:num_small_requests]
-
-# test parallel sends of large arrays from multiple tasks to the same remote worker
-ntasks = 10
-rr_list = [Channel() for x in 1:ntasks]
-a=ones(2*10^5);
-for rr in rr_list
-    @async let rr=rr
-        try
-            for i in 1:10
-                @test a == remotecall_fetch(id_other, (x)->x, a)
-                yield()
-            end
-            put!(rr, :OK)
-        catch
-            put!(rr, :ERROR)
-        end
-    end
-end
-
-@test [fetch(rr) for rr in rr_list] == [:OK for x in 1:ntasks]
-
-function test_channel(c)
-    put!(c, 1)
-    put!(c, "Hello")
-    put!(c, 5.0)
-
-    @test isready(c) == true
-    @test fetch(c) == 1
-    @test fetch(c) == 1   # Should not have been popped previously
-    @test take!(c) == 1
-    @test take!(c) == "Hello"
-    @test fetch(c) == 5.0
-    @test take!(c) == 5.0
-    @test isready(c) == false
-    close(c)
-end
-
-test_channel(Channel(10))
-test_channel(RemoteRef(()->Channel(10)))
-
-c=Channel{Int}(1)
-@test_throws MethodError put!(c, "Hello")
-
-c=Channel(256)
-# Test growth of channel
-@test c.szp1 <= 33
-for x in 1:40
-  put!(c, x)
-end
-@test c.szp1 <= 65
-for x in 1:39
-  take!(c)
-end
-for x in 1:64
-  put!(c, x)
-end
-@test (c.szp1 > 65) && (c.szp1 <= 129)
-for x in 1:39
-  take!(c)
-end
-@test fetch(c) == 39
-for x in 1:26
-  take!(c)
-end
-@test isready(c) == false
-
-# test channel iterations
-function test_iteration(in_c, out_c)
-    t=@schedule for v in in_c
-        put!(out_c, v)
-    end
-
-    isa(in_c, Channel) && @test isopen(in_c) == true
-    put!(in_c, 1)
-    @test take!(out_c) == 1
-    put!(in_c, "Hello")
-    close(in_c)
-    @test take!(out_c) == "Hello"
-    isa(in_c, Channel) && @test isopen(in_c) == false
-    @test_throws InvalidStateException put!(in_c, :foo)
-    yield()
-    @test istaskdone(t) == true
-end
-
-test_iteration(Channel(10), Channel(10))
-# make sure exceptions propagate when waiting on Tasks
-@test_throws CompositeException (@sync (@async error("oops")))
-try
-    @sync begin
-        for i in 1:5
-            @async error(i)
-        end
-    end
-catch ex
-    @test typeof(ex) == CompositeException
-    @test length(ex) == 5
-    @test typeof(ex.exceptions[1]) == CapturedException
-    @test typeof(ex.exceptions[1].ex) == ErrorException
-    errors = map(x->x.ex.msg, ex.exceptions)
-    @test collect(1:5) == sort(map(x->parse(Int, x), errors))
-end
-
-try
-    remotecall_fetch(id_other, ()->throw(ErrorException("foobar")))
-catch ex
-    @test typeof(ex) == RemoteException
-    @test typeof(ex.captured) == CapturedException
-    @test typeof(ex.captured.ex) == ErrorException
-    @test ex.captured.ex.msg == "foobar"
-end
-
-# The below block of tests are usually run only on local development systems, since:
-# - tests which print errors
-# - addprocs tests are memory intensive
-# - ssh addprocs requires sshd to be running locally with passwordless login enabled.
-# The test block is enabled by defining env JULIA_TESTFULL=1
-
-DoFullTest = Bool(parse(Int,(get(ENV, "JULIA_TESTFULL", "0"))))
-
-if DoFullTest
-    # pmap tests
-    # needs at least 4 processors dedicated to the below tests
-    ppids = remotecall_fetch(1, ()->addprocs(4))
-    s = "abcdefghijklmnopqrstuvwxyz";
-    ups = uppercase(s);
-    @test ups == bytestring(UInt8[UInt8(c) for c in pmap(x->uppercase(x), s)])
-    @test ups == bytestring(UInt8[UInt8(c) for c in pmap(x->uppercase(Char(x)), s.data)])
-
-    # retry, on error exit
-    res = pmap(x->(x=='a') ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=true, err_stop=true, pids=ppids);
-    @test (length(res) < length(ups))
-    @test isa(res[1], Exception)
-
-    # no retry, on error exit
-    res = pmap(x->(x=='a') ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=false, err_stop=true, pids=ppids);
-    @test (length(res) < length(ups))
-    @test isa(res[1], Exception)
-
-    # retry, on error continue
-    res = pmap(x->iseven(myid()) ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=true, err_stop=false, pids=ppids);
-    @test length(res) == length(ups)
-    @test ups == bytestring(UInt8[UInt8(c) for c in res])
-
-    # no retry, on error continue
-    res = pmap(x->(x=='a') ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=false, err_stop=false, pids=ppids);
-    @test length(res) == length(ups)
-    @test isa(res[1], Exception)
-
-    # Topology tests need to run externally since a given cluster at any
-    # time can only support a single topology and the current session
-    # is already running in parallel under the default topology.
-    script = joinpath(dirname(@__FILE__), "topology.jl")
-    cmd = `$(joinpath(JULIA_HOME,Base.julia_exename())) $script`
-
-    (strm, proc) = open(cmd)
-    wait(proc)
-    if !success(proc) && ccall(:jl_running_on_valgrind,Cint,()) == 0
-        println(readall(strm))
-        error("Topology tests failed : $cmd")
-    end
-
-    println("Testing exception printing on remote worker from a `remote_do` call")
-    println("Please ensure the remote error and backtrace is displayed on screen")
-
-    Base.remote_do(id_other, ()->throw(ErrorException("TESTING EXCEPTION ON REMOTE DO. PLEASE IGNORE")))
-    sleep(0.5)  # Give some time for the above error to be printed
-
-@unix_only begin
-    function test_n_remove_pids(new_pids)
-        for p in new_pids
-            w_in_remote = sort(remotecall_fetch(p, workers))
-            try
-                @test intersect(new_pids, w_in_remote) == new_pids
-            catch e
-                print("p       :     $p\n")
-                print("newpids :     $new_pids\n")
-                print("w_in_remote : $w_in_remote\n")
-                print("intersect   : $(intersect(new_pids, w_in_remote))\n\n\n")
-                rethrow(e)
-            end
-        end
-
-        @test :ok == remotecall_fetch(1, (p)->rmprocs(p; waitfor=5.0), new_pids)
-    end
-
-    print("\n\nTesting SSHManager. A minimum of 4GB of RAM is recommended.\n")
-    print("Please ensure sshd is running locally with passwordless login enabled.\n")
-
-    sshflags = `-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o LogLevel=ERROR `
-    #Issue #9951
-    hosts=[]
-    localhost_aliases = ["localhost", string(getipaddr()), "127.0.0.1"]
-    num_workers = parse(Int,(get(ENV, "JULIA_ADDPROCS_NUM", "9")))
-
-    for i in 1:(num_workers/length(localhost_aliases))
-        append!(hosts, localhost_aliases)
-    end
-
-    print("\nTesting SSH addprocs with $(length(hosts)) workers...\n")
-    new_pids = remotecall_fetch(1, (h, sf) -> addprocs(h; sshflags=sf), hosts, sshflags)
-    @test length(new_pids) == length(hosts)
-    test_n_remove_pids(new_pids)
-
-    print("\nMixed ssh addprocs with :auto\n")
-    new_pids = sort(remotecall_fetch(1, (h, sf) -> addprocs(h; sshflags=sf), ["localhost", ("127.0.0.1", :auto), "localhost"], sshflags))
-    @test length(new_pids) == (2 + Sys.CPU_CORES)
-    test_n_remove_pids(new_pids)
-
-    print("\nMixed ssh addprocs with numeric counts\n")
-    new_pids = sort(remotecall_fetch(1, (h, sf) -> addprocs(h; sshflags=sf), [("localhost", 2), ("127.0.0.1", 2), "localhost"], sshflags))
-    @test length(new_pids) == 5
-    test_n_remove_pids(new_pids)
-
-    print("\nssh addprocs with tunnel\n")
-    new_pids = sort(remotecall_fetch(1, (h, sf) -> addprocs(h; tunnel=true, sshflags=sf), [("localhost", num_workers)], sshflags))
-    @test length(new_pids) == num_workers
-    test_n_remove_pids(new_pids)
-
-end
-end
-
-# issue #7727
-let A = [], B = []
-    t = @task produce(11)
-    @sync begin
-        @async for x in t; push!(A,x); end
-        @async for x in t; push!(B,x); end
-    end
-    @test (A == [11]) != (B == [11])
-end
-
-let t = @task 42
-    schedule(t, ErrorException(""), error=true)
-    @test_throws ErrorException wait(t)
-end
-
-# issue #8207
-let A = Any[]
-    @parallel (+) for i in (push!(A,1); 1:2)
-        i
-    end
-    @test length(A) == 1
+if !success(pipeline(cmd; stdout=STDOUT, stderr=STDERR)) && ccall(:jl_running_on_valgrind,Cint,()) == 0
+    error("Parallel test failed, cmd : $cmd")
 end
diff --git a/test/parallel_exec.jl b/test/parallel_exec.jl
new file mode 100644
index 0000000000000..57106f2b5b821
--- /dev/null
+++ b/test/parallel_exec.jl
@@ -0,0 +1,755 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+using Base.Test
+
+inline_flag = Base.JLOptions().can_inline == 1 ? `` : `--inline=no`
+cov_flag = ``
+if Base.JLOptions().code_coverage == 1
+    cov_flag = `--code-coverage=user`
+elseif Base.JLOptions().code_coverage == 2
+    cov_flag = `--code-coverage=all`
+end
+addprocs(3; exeflags=`$cov_flag $inline_flag --check-bounds=yes --depwarn=error`)
+
+id_me = myid()
+id_other = filter(x -> x != id_me, procs())[rand(1:(nprocs()-1))]
+
+# Test Futures
+function testf(id)
+    f=Future(id)
+    @test isready(f) == false
+    @test isnull(f.v) == true
+    put!(f, :OK)
+    @test isready(f) == true
+    @test isnull(f.v) == false
+
+    @test_throws ErrorException put!(f, :OK) # Cannot put! to a already set future
+    @test_throws MethodError take!(f) # take! is unsupported on a Future
+
+    @test fetch(f) == :OK
+end
+
+testf(id_me)
+testf(id_other)
+
+# Distributed GC tests for Futures
+function test_futures_dgc(id)
+    f = remotecall(myid, id)
+    fid = Base.remoteref_id(f)
+
+    # remote value should be deleted after a fetch
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, fid) == true
+    @test isnull(f.v) == true
+    @test fetch(f) == id
+    @test isnull(f.v) == false
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, fid) == false
+
+
+    # if unfetched, it should be deleted after a finalize
+    f = remotecall(myid, id)
+    fid = Base.remoteref_id(f)
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, fid) == true
+    @test isnull(f.v) == true
+    finalize(f)
+    Base.flush_gc_msgs()
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, fid) == false
+end
+
+test_futures_dgc(id_me)
+test_futures_dgc(id_other)
+
+# if sent to another worker, it should not be deleted till the other worker has fetched.
+wid1 = workers()[1]
+wid2 = workers()[2]
+f = remotecall(myid, wid1)
+fid = Base.remoteref_id(f)
+
+fstore = RemoteChannel(wid2)
+put!(fstore, f)
+
+@test fetch(f) == wid1
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, fid) == true
+remotecall_fetch(r->fetch(fetch(r)), wid2, fstore)
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, fid) == false
+
+# put! should release remote reference since it would have been cached locally
+f = Future(wid1)
+fid = Base.remoteref_id(f)
+
+# should not be created remotely till accessed
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, fid) == false
+# create it remotely
+isready(f)
+
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, fid) == true
+put!(f, :OK)
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, fid) == false
+@test fetch(f) == :OK
+
+# RemoteException should be thrown on a put! when another process has set the value
+f = Future(wid1)
+fid = Base.remoteref_id(f)
+
+fstore = RemoteChannel(wid2)
+put!(fstore, f) # send f to wid2
+put!(f, :OK) # set value from master
+
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, fid) == true
+
+testval = remotecall_fetch(wid2, fstore) do x
+    try
+        put!(fetch(x), :OK)
+        return 0
+    catch e
+        if isa(e, RemoteException)
+            return 1
+        else
+            return 2
+        end
+    end
+end
+@test testval == 1
+
+# Distributed GC tests for RemoteChannels
+function test_remoteref_dgc(id)
+    rr = RemoteChannel(id)
+    put!(rr, :OK)
+    rrid = Base.remoteref_id(rr)
+
+    # remote value should be deleted after finalizing the ref
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, rrid) == true
+    @test fetch(rr) == :OK
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, rrid) == true
+    finalize(rr)
+    Base.flush_gc_msgs()
+    @test remotecall_fetch(k->(yield();haskey(Base.PGRP.refs, k)), id, rrid) == false
+end
+test_remoteref_dgc(id_me)
+test_remoteref_dgc(id_other)
+
+# if sent to another worker, it should not be deleted till the other worker has also finalized.
+wid1 = workers()[1]
+wid2 = workers()[2]
+rr = RemoteChannel(wid1)
+rrid = Base.remoteref_id(rr)
+
+fstore = RemoteChannel(wid2)
+put!(fstore, rr)
+
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, rrid) == true
+finalize(rr); Base.flush_gc_msgs() # finalize locally
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, rrid) == true
+remotecall_fetch(r->(finalize(take!(r)); Base.flush_gc_msgs(); nothing), wid2, fstore) # finalize remotely
+sleep(0.5) # to ensure that wid2 messages have been executed on wid1
+@test remotecall_fetch(k->haskey(Base.PGRP.refs, k), wid1, rrid) == false
+
+@test fetch(@spawnat id_other myid()) == id_other
+@test @fetchfrom id_other begin myid() end == id_other
+@fetch begin myid() end
+
+# test getindex on Futures and RemoteChannels
+function test_indexing(rr)
+    a = rand(5,5)
+    put!(rr, a)
+    @test rr[2,3] == a[2,3]
+    @test rr[] == a
+end
+
+test_indexing(Future())
+test_indexing(Future(id_other))
+test_indexing(RemoteChannel())
+test_indexing(RemoteChannel(id_other))
+
+dims = (20,20,20)
+
+@linux_only begin
+    S = SharedArray(Int64, dims)
+    @test startswith(S.segname, "/jl")
+    @test !ispath("/dev/shm" * S.segname)
+
+    S = SharedArray(Int64, dims; pids=[id_other])
+    @test startswith(S.segname, "/jl")
+    @test !ispath("/dev/shm" * S.segname)
+end
+
+# TODO : Need a similar test of shmem cleanup for OSX
+
+##### SharedArray tests
+
+function check_pids_all(S::SharedArray)
+    pidtested = falses(size(S))
+    for p in procs(S)
+        idxes_in_p = remotecall_fetch(p, S) do D
+            parentindexes(D.loc_subarr_1d)[1]
+        end
+        @test all(sdata(S)[idxes_in_p] .== p)
+        pidtested[idxes_in_p] = true
+    end
+    @test all(pidtested)
+end
+
+d = Base.shmem_rand(1:100, dims)
+a = convert(Array, d)
+
+partsums = Array(Int, length(procs(d)))
+@sync begin
+    for (i, p) in enumerate(procs(d))
+        @async partsums[i] = remotecall_fetch(p, d) do D
+            sum(D.loc_subarr_1d)
+        end
+    end
+end
+@test sum(a) == sum(partsums)
+
+d = Base.shmem_rand(dims)
+for p in procs(d)
+    idxes_in_p = remotecall_fetch(p, d) do D
+        parentindexes(D.loc_subarr_1d)[1]
+    end
+    idxf = first(idxes_in_p)
+    idxl = last(idxes_in_p)
+    d[idxf] = Float64(idxf)
+    rv = remotecall_fetch(p, d,idxf,idxl) do D,idxf,idxl
+        assert(D[idxf] == Float64(idxf))
+        D[idxl] = Float64(idxl)
+        D[idxl]
+    end
+    @test d[idxl] == rv
+end
+
+@test ones(10, 10, 10) == Base.shmem_fill(1.0, (10,10,10))
+@test zeros(Int32, 10, 10, 10) == Base.shmem_fill(0, (10,10,10))
+
+d = Base.shmem_rand(dims)
+s = Base.shmem_rand(dims)
+copy!(s, d)
+@test s == d
+s = Base.shmem_rand(dims)
+copy!(s, sdata(d))
+@test s == d
+a = rand(dims)
+@test sdata(a) == a
+
+d = SharedArray(Int, dims; init = D->fill!(D.loc_subarr_1d, myid()))
+for p in procs(d)
+    idxes_in_p = remotecall_fetch(p, d) do D
+        parentindexes(D.loc_subarr_1d)[1]
+    end
+    idxf = first(idxes_in_p)
+    idxl = last(idxes_in_p)
+    @test d[idxf] == p
+    @test d[idxl] == p
+end
+
+d = SharedArray(Float64, (2,3))
+@test isa(d[:,2], Vector{Float64})
+
+### SharedArrays from a file
+
+# Mapping an existing file
+fn = tempname()
+write(fn, 1:30)
+sz = (6,5)
+Atrue = reshape(1:30, sz)
+
+S = SharedArray(fn, Int, sz)
+@test S == Atrue
+@test length(procs(S)) > 1
+@sync begin
+    for p in procs(S)
+        @async remotecall_wait(p, S) do D
+            fill!(D.loc_subarr_1d, myid())
+        end
+    end
+end
+check_pids_all(S)
+
+filedata = similar(Atrue)
+read!(fn, filedata)
+@test filedata == sdata(S)
+
+# Error for write-only files
+@test_throws ArgumentError SharedArray(fn, Int, sz, mode="w")
+
+# Error for file doesn't exist, but not allowed to create
+@test_throws ArgumentError SharedArray(tempname(), Int, sz, mode="r")
+
+# Creating a new file
+fn2 = tempname()
+S = SharedArray(fn2, Int, sz, init=D->D[localindexes(D)] = myid())
+@test S == filedata
+filedata2 = similar(Atrue)
+read!(fn2, filedata2)
+@test filedata == filedata2
+
+# Appending to a file
+fn3 = tempname()
+write(fn3, ones(UInt8, 4))
+S = SharedArray(fn3, UInt8, sz, 4, mode="a+", init=D->D[localindexes(D)]=0x02)
+len = prod(sz)+4
+@test filesize(fn3) == len
+filedata = Array(UInt8, len)
+read!(fn3, filedata)
+@test all(filedata[1:4] .== 0x01)
+@test all(filedata[5:end] .== 0x02)
+
+@unix_only begin # these give unlink: operation not permitted (EPERM) on Windows
+    rm(fn); rm(fn2); rm(fn3)
+end
+
+### Utility functions
+
+# construct PR #13514
+S = SharedArray{Int}((1,2,3))
+@test size(S) == (1,2,3)
+@test typeof(S) <: SharedArray{Int}
+S = SharedArray{Int}(2)
+@test size(S) == (2,)
+@test typeof(S) <: SharedArray{Int}
+S = SharedArray{Int}(1,2)
+@test size(S) == (1,2)
+@test typeof(S) <: SharedArray{Int}
+S = SharedArray{Int}(1,2,3)
+@test size(S) == (1,2,3)
+@test typeof(S) <: SharedArray{Int}
+
+# reshape
+
+d = Base.shmem_fill(1.0, (10,10,10))
+@test ones(100, 10) == reshape(d,(100,10))
+d = Base.shmem_fill(1.0, (10,10,10))
+@test_throws DimensionMismatch reshape(d,(50,))
+
+# rand, randn
+d = Base.shmem_rand(dims)
+@test size(rand!(d)) == dims
+d = Base.shmem_fill(1.0, dims)
+@test size(randn!(d)) == dims
+
+# similar
+d = Base.shmem_rand(dims)
+@test size(similar(d, Complex128)) == dims
+@test size(similar(d, dims)) == dims
+
+# issue #6362
+d = Base.shmem_rand(dims)
+s = copy(sdata(d))
+ds = deepcopy(d)
+@test ds == d
+pids_d = procs(d)
+remotecall_fetch(setindex!, pids_d[findfirst(id->(id != myid()), pids_d)], d, 1.0, 1:10)
+@test ds != d
+@test s != d
+
+
+# SharedArray as an array
+# Since the data in d will depend on the nprocs, just test that these operations work
+a = d[1:5]
+@test_throws BoundsError d[-1:5]
+a = d[1,1,1:3:end]
+d[2:4] = 7
+d[5,1:2:4,8] = 19
+
+AA = rand(4,2)
+A = convert(SharedArray, AA)
+B = convert(SharedArray, AA')
+@test B*A == ctranspose(AA)*AA
+
+d=SharedArray(Int64, (10,10); init = D->fill!(D.loc_subarr_1d, myid()), pids=[id_me, id_other])
+d2 = map(x->1, d)
+@test reduce(+, d2) == 100
+
+@test reduce(+, d) == ((50*id_me) + (50*id_other))
+map!(x->1, d)
+@test reduce(+, d) == 100
+
+@test fill!(d, 1) == ones(10, 10)
+@test fill!(d, 2.) == fill(2, 10, 10)
+@test d[:] == fill(2, 100)
+@test d[:,1] == fill(2, 10)
+@test d[1,:] == fill(2, 10)
+
+# Boundary cases where length(S) <= length(pids)
+@test 2.0 == remotecall_fetch(D->D[2], id_other, Base.shmem_fill(2.0, 2; pids=[id_me, id_other]))
+@test 3.0 == remotecall_fetch(D->D[1], id_other, Base.shmem_fill(3.0, 1; pids=[id_me, id_other]))
+
+# Issue #14664
+d = SharedArray(Int,10)
+@sync @parallel for i=1:10
+    d[i] = i
+end
+
+for (x,i) in enumerate(d)
+    @test x == i
+end
+
+# Test @parallel load balancing - all processors should get either M or M+1
+# iterations out of the loop range for some M.
+workloads = hist(@parallel((a,b)->[a;b], for i=1:7; myid(); end), nprocs())[2]
+@test maximum(workloads) - minimum(workloads) <= 1
+
+# @parallel reduction should work even with very short ranges
+@test @parallel(+, for i=1:2; i; end) == 3
+
+# Testing timedwait on multiple channels
+@sync begin
+    rr1 = Channel()
+    rr2 = Channel()
+    rr3 = Channel()
+
+    callback() = all(map(isready, [rr1, rr2, rr3]))
+    # precompile functions which will be tested for execution time
+    @test !callback()
+    @test timedwait(callback, 0.0) === :timed_out
+
+    @async begin sleep(0.5); put!(rr1, :ok) end
+    @async begin sleep(1.0); put!(rr2, :ok) end
+    @async begin sleep(2.0); put!(rr3, :ok) end
+
+    tic()
+    timedwait(callback, 1.0)
+    et=toq()
+    # assuming that 0.5 seconds is a good enough buffer on a typical modern CPU
+    try
+        @test (et >= 1.0) && (et <= 1.5)
+        @test !isready(rr3)
+    catch
+        warn("timedwait tests delayed. et=$et, isready(rr3)=$(isready(rr3))")
+    end
+    @test isready(rr1)
+end
+
+# Test multiple concurrent put!/take! on a channel
+function testcpt()
+    c = Channel()
+    size = 0
+    inc() = size += 1
+    dec() = size -= 1
+    @sync for i = 1:10^4
+        @async (sleep(rand()); put!(c, i); inc())
+        @async (sleep(rand()); take!(c); dec())
+    end
+    @test size == 0
+end
+testcpt()
+
+@test_throws ArgumentError sleep(-1)
+@test_throws ArgumentError timedwait(()->false, 0.1, pollint=-0.5)
+
+# specify pids for pmap
+@test sort(workers()[1:2]) == sort(unique(pmap(x->(sleep(0.1);myid()), 1:10, pids = workers()[1:2])))
+
+# Testing buffered  and unbuffered reads
+# This large array should write directly to the socket
+a = ones(10^6)
+@test a == remotecall_fetch((x)->x, id_other, a)
+
+# Not a bitstype, should be buffered
+s = [randstring() for x in 1:10^5]
+@test s == remotecall_fetch((x)->x, id_other, s)
+
+#large number of small requests
+num_small_requests = 10000
+@test fill(id_other, num_small_requests) == [remotecall_fetch(myid, id_other) for i in 1:num_small_requests]
+
+# test parallel sends of large arrays from multiple tasks to the same remote worker
+ntasks = 10
+rr_list = [Channel() for x in 1:ntasks]
+a=ones(2*10^5);
+for rr in rr_list
+    @async let rr=rr
+        try
+            for i in 1:10
+                @test a == remotecall_fetch((x)->x, id_other, a)
+                yield()
+            end
+            put!(rr, :OK)
+        catch
+            put!(rr, :ERROR)
+        end
+    end
+end
+
+@test [fetch(rr) for rr in rr_list] == [:OK for x in 1:ntasks]
+
+function test_channel(c)
+    put!(c, 1)
+    put!(c, "Hello")
+    put!(c, 5.0)
+
+    @test isready(c) == true
+    @test fetch(c) == 1
+    @test fetch(c) == 1   # Should not have been popped previously
+    @test take!(c) == 1
+    @test take!(c) == "Hello"
+    @test fetch(c) == 5.0
+    @test take!(c) == 5.0
+    @test isready(c) == false
+    close(c)
+end
+
+test_channel(Channel(10))
+test_channel(RemoteChannel(()->Channel(10)))
+
+c=Channel{Int}(1)
+@test_throws MethodError put!(c, "Hello")
+
+# test channel iterations
+function test_iteration(in_c, out_c)
+    t=@schedule for v in in_c
+        put!(out_c, v)
+    end
+
+    isa(in_c, Channel) && @test isopen(in_c) == true
+    put!(in_c, 1)
+    @test take!(out_c) == 1
+    put!(in_c, "Hello")
+    close(in_c)
+    @test take!(out_c) == "Hello"
+    isa(in_c, Channel) && @test isopen(in_c) == false
+    @test_throws InvalidStateException put!(in_c, :foo)
+    yield()
+    @test istaskdone(t) == true
+end
+
+test_iteration(Channel(10), Channel(10))
+# make sure exceptions propagate when waiting on Tasks
+@test_throws CompositeException (@sync (@async error("oops")))
+try
+    @sync begin
+        for i in 1:5
+            @async error(i)
+        end
+    end
+    error("unexpected")
+catch ex
+    @test typeof(ex) == CompositeException
+    @test length(ex) == 5
+    @test typeof(ex.exceptions[1]) == CapturedException
+    @test typeof(ex.exceptions[1].ex) == ErrorException
+    errors = map(x->x.ex.msg, ex.exceptions)
+    @test collect(1:5) == sort(map(x->parse(Int, x), errors))
+end
+
+function test_remoteexception_thrown(expr)
+    try
+        expr()
+        error("unexpected")
+    catch ex
+        @test typeof(ex) == RemoteException
+        @test typeof(ex.captured) == CapturedException
+        @test typeof(ex.captured.ex) == ErrorException
+        @test ex.captured.ex.msg == "foobar"
+    end
+end
+
+for id in [id_other, id_me]
+    test_remoteexception_thrown() do
+        remotecall_fetch(id) do
+            throw(ErrorException("foobar"))
+        end
+    end
+    test_remoteexception_thrown() do
+        remotecall_wait(id) do
+            throw(ErrorException("foobar"))
+        end
+    end
+    test_remoteexception_thrown() do
+        wait(remotecall(id) do
+            throw(ErrorException("foobar"))
+        end)
+    end
+end
+
+# make sure the stackframe from the remote error can be serialized
+let ex
+    try
+        remotecall_fetch(id_other) do
+            @eval module AModuleLocalToOther
+                foo() = error("A.error")
+                foo()
+            end
+        end
+    catch ex
+    end
+    @test (ex::RemoteException).pid == id_other
+    @test ((ex.captured::CapturedException).ex::ErrorException).msg == "A.error"
+    bt = ex.captured.processed_bt::Array{Any,1}
+    @test length(bt) > 1
+    frame, repeated = bt[1]::Tuple{StackFrame, Int}
+    @test frame.func == :foo
+    @test isnull(frame.outer_linfo)
+    @test repeated == 1
+end
+
+# The below block of tests are usually run only on local development systems, since:
+# - tests which print errors
+# - addprocs tests are memory intensive
+# - ssh addprocs requires sshd to be running locally with passwordless login enabled.
+# The test block is enabled by defining env JULIA_TESTFULL=1
+
+DoFullTest = Bool(parse(Int,(get(ENV, "JULIA_TESTFULL", "0"))))
+
+if DoFullTest
+    # pmap tests
+    # needs at least 4 processors dedicated to the below tests
+    ppids = remotecall_fetch(()->addprocs(4), 1)
+    s = "abcdefghijklmnopqrstuvwxyz";
+    ups = uppercase(s);
+    @test ups == bytestring(UInt8[UInt8(c) for c in pmap(x->uppercase(x), s)])
+    @test ups == bytestring(UInt8[UInt8(c) for c in pmap(x->uppercase(Char(x)), s.data)])
+
+    # retry, on error exit
+    res = pmap(x->(x=='a') ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=true, err_stop=true, pids=ppids);
+    @test (length(res) < length(ups))
+    @test isa(res[1], Exception)
+
+    # no retry, on error exit
+    res = pmap(x->(x=='a') ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=false, err_stop=true, pids=ppids);
+    @test (length(res) < length(ups))
+    @test isa(res[1], Exception)
+
+    # retry, on error continue
+    res = pmap(x->iseven(myid()) ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=true, err_stop=false, pids=ppids);
+    @test length(res) == length(ups)
+    @test ups == bytestring(UInt8[UInt8(c) for c in res])
+
+    # no retry, on error continue
+    res = pmap(x->(x=='a') ? error("EXPECTED TEST ERROR. TO BE IGNORED.") : (sleep(0.1);uppercase(x)), s; err_retry=false, err_stop=false, pids=ppids);
+    @test length(res) == length(ups)
+    @test isa(res[1], Exception)
+
+    # Topology tests need to run externally since a given cluster at any
+    # time can only support a single topology and the current session
+    # is already running in parallel under the default topology.
+    script = joinpath(dirname(@__FILE__), "topology.jl")
+    cmd = `$(Base.julia_cmd()) $script`
+
+    (strm, proc) = open(pipeline(cmd, stderr=STDERR))
+    wait(proc)
+    if !success(proc) && ccall(:jl_running_on_valgrind,Cint,()) == 0
+        println(readstring(strm))
+        error("Topology tests failed : $cmd")
+    end
+
+    println("Testing exception printing on remote worker from a `remote_do` call")
+    println("Please ensure the remote error and backtrace is displayed on screen")
+
+    Base.remote_do(id_other) do
+        throw(ErrorException("TESTING EXCEPTION ON REMOTE DO. PLEASE IGNORE"))
+    end
+    sleep(0.5)  # Give some time for the above error to be printed
+
+@unix_only begin
+    function test_n_remove_pids(new_pids)
+        for p in new_pids
+            w_in_remote = sort(remotecall_fetch(workers, p))
+            try
+                @test intersect(new_pids, w_in_remote) == new_pids
+            catch e
+                print("p       :     $p\n")
+                print("newpids :     $new_pids\n")
+                print("w_in_remote : $w_in_remote\n")
+                print("intersect   : $(intersect(new_pids, w_in_remote))\n\n\n")
+                rethrow(e)
+            end
+        end
+
+        @test :ok == remotecall_fetch(1, new_pids) do p
+            rmprocs(p; waitfor=5.0)
+        end
+    end
+
+    print("\n\nTesting SSHManager. A minimum of 4GB of RAM is recommended.\n")
+    print("Please ensure sshd is running locally with passwordless login enabled.\n")
+
+    sshflags = `-o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o LogLevel=ERROR `
+    #Issue #9951
+    hosts=[]
+    localhost_aliases = ["localhost", string(getipaddr()), "127.0.0.1"]
+    num_workers = parse(Int,(get(ENV, "JULIA_ADDPROCS_NUM", "9")))
+
+    for i in 1:(num_workers/length(localhost_aliases))
+        append!(hosts, localhost_aliases)
+    end
+
+    print("\nTesting SSH addprocs with $(length(hosts)) workers...\n")
+    new_pids = remotecall_fetch(1, hosts, sshflags) do h, sf
+        addprocs(h; sshflags=sf)
+    end
+    @test length(new_pids) == length(hosts)
+    test_n_remove_pids(new_pids)
+
+    print("\nMixed ssh addprocs with :auto\n")
+    new_pids = sort(remotecall_fetch(1, ["localhost", ("127.0.0.1", :auto), "localhost"], sshflags) do h, sf
+        addprocs(h; sshflags=sf)
+    end)
+    @test length(new_pids) == (2 + Sys.CPU_CORES)
+    test_n_remove_pids(new_pids)
+
+    print("\nMixed ssh addprocs with numeric counts\n")
+    new_pids = sort(remotecall_fetch(1, [("localhost", 2), ("127.0.0.1", 2), "localhost"], sshflags) do h, sf
+        addprocs(h; sshflags=sf)
+    end)
+    @test length(new_pids) == 5
+    test_n_remove_pids(new_pids)
+
+    print("\nssh addprocs with tunnel\n")
+    new_pids = sort(remotecall_fetch(1, [("localhost", num_workers)], sshflags) do h, sf
+        addprocs(h; tunnel=true, sshflags=sf)
+    end)
+    @test length(new_pids) == num_workers
+    test_n_remove_pids(new_pids)
+
+end
+end
+
+# issue #7727
+let A = [], B = []
+    t = @task produce(11)
+    @sync begin
+        @async for x in t; push!(A,x); end
+        @async for x in t; push!(B,x); end
+    end
+    @test (A == [11]) != (B == [11])
+end
+
+let t = @task 42
+    schedule(t, ErrorException(""), error=true)
+    @test_throws ErrorException wait(t)
+end
+
+# issue #8207
+let A = Any[]
+    @parallel (+) for i in (push!(A,1); 1:2)
+        i
+    end
+    @test length(A) == 1
+end
+
+# issue #13168
+function f13168(n)
+    val = 0
+    for i=1:n val+=sum(rand(n,n)^2) end
+    val
+end
+let t = schedule(@task f13168(100))
+    @test t.state == :queued
+    @test_throws ErrorException schedule(t)
+    yield()
+    @test t.state == :done
+    @test_throws ErrorException schedule(t)
+    @test isa(wait(t),Float64)
+end
+
+# issue #13122
+@test remotecall_fetch(identity, workers()[1], C_NULL) === C_NULL
+
+# issue #11062
+function t11062()
+    @async v11062 = 1
+    v11062 = 2
+end
+
+@test t11062() == 2
+
diff --git a/test/parse.jl b/test/parse.jl
index e463d8734f586..88d02a14c10ea 100644
--- a/test/parse.jl
+++ b/test/parse.jl
@@ -99,9 +99,6 @@ macro test999_str(args...); args; end
 # issue #10994
 @test parse("1 + #= \0 =# 2") == :(1 + 2)
 
-# issue #10985
-@test expand(:(f(::Int...) = 1)).head == :method
-
 # issue #10910
 @test parse(":(using A)") == Expr(:quote, Expr(:using, :A))
 @test parse(":(using A.b, B)") == Expr(:quote,
@@ -154,6 +151,26 @@ macro f(args...) end; @f ""
             Expr(:macro, Expr(:call, :f, Expr(:..., :args)), Expr(:block,)),
             Expr(:macrocall, symbol("@f"), ""))
 
+# blocks vs. tuples
+@test parse("()") == Expr(:tuple)
+@test parse("(;)") == Expr(:block)
+@test parse("(;;;;)") == Expr(:block)
+@test_throws ParseError parse("(,)")
+@test_throws ParseError parse("(;,)")
+@test_throws ParseError parse("(,;)")
+@test parse("(x;)") == Expr(:block, :x)
+@test parse("(;x)") == Expr(:tuple, Expr(:parameters, :x))
+@test parse("(;x,)") == Expr(:tuple, Expr(:parameters, :x))
+@test parse("(x,)") == Expr(:tuple, :x)
+@test parse("(x,;)") == Expr(:tuple, :x)
+@test parse("(x;y)") == Expr(:block, :x, :y)
+@test parse("(x=1;y=2)") == Expr(:block, Expr(:(=), :x, 1), Expr(:(=), :y, 2))
+@test parse("(x,;y)") == Expr(:tuple, Expr(:parameters, :y), :x)
+@test parse("(x,;y=1)") == Expr(:tuple, Expr(:parameters, Expr(:kw, :y, 1)), :x)
+@test parse("(x,a;y=1)") == Expr(:tuple, Expr(:parameters, Expr(:kw, :y, 1)), :x, :a)
+@test parse("(x,a;y=1,z=2)") == Expr(:tuple, Expr(:parameters, Expr(:kw,:y,1), Expr(:kw,:z,2)), :x, :a)
+@test parse("(a=1, b=2)") == Expr(:tuple, Expr(:(=), :a, 1), Expr(:(=), :b, 2))
+
 # integer parsing
 @test is(parse(Int32,"0",36),Int32(0))
 @test is(parse(Int32,"1",36),Int32(1))
@@ -293,3 +310,42 @@ parse("""
 
 # issue #12771
 @test -(3)^2 == -9
+
+# issue #13302
+let p = parse("try
+           a
+       catch
+           b, c = t
+       end")
+    @test isa(p,Expr) && p.head === :try
+    @test p.args[2] === false
+    @test p.args[3].args[end] == parse("b,c = t")
+end
+
+# pr #13078
+@test parse("a in b in c") == Expr(:comparison, :a, :in, :b, :in, :c)
+@test parse("a||b→c&&d") == Expr(:call, :→,
+                                 Expr(symbol("||"), :a, :b),
+                                 Expr(symbol("&&"), :c, :d))
+
+# issue #11988 -- normalize \r and \r\n in literal strings to \n
+@test "foo\nbar" == parse("\"\"\"\r\nfoo\r\nbar\"\"\"") == parse("\"\"\"\nfoo\nbar\"\"\"") == parse("\"\"\"\rfoo\rbar\"\"\"") == parse("\"foo\r\nbar\"") == parse("\"foo\rbar\"") == parse("\"foo\nbar\"")
+@test '\r' == first("\r") == first("\r\n") # still allow explicit \r
+
+# issue #14561 - generating 0-method generic function def
+let fname = :f
+    @test :(function $fname end) == Expr(:function, :f)
+end
+
+# issue #14977
+@test parse("x = 1", 1) == (:(x = 1), 6)
+@test parse("x = 1", 6) == (nothing, 6)
+@test_throws BoundsError parse("x = 1", 0)
+@test_throws BoundsError parse("x = 1", -1)
+@test_throws BoundsError parse("x = 1", 7)
+
+# issue #14683
+@test_throws ParseError parse("'\\A\"'")
+@test parse("'\"'") == parse("'\\\"'") == '"' == "\""[1] == '\42'
+
+@test_throws ParseError parse("f(2x for x=1:10, y")
diff --git a/test/path.jl b/test/path.jl
index a1e4d5535cef1..30fc7c3546aec 100644
--- a/test/path.jl
+++ b/test/path.jl
@@ -10,7 +10,7 @@
 # This section tests relpath computation. #
 ###########################################
 function test_relpath()
-    sep = Base.path_separator
+    sep = Base.Filesystem.path_separator
     filepaths = [
         "$(sep)home$(sep)user$(sep).julia$(sep)Test1$(sep)docs$(sep)api$(sep)Test1.md",
         "$(sep)home$(sep)user$(sep).julia$(sep)Test1$(sep)docs$(sep)api$(sep)lib$(sep)file1.md",
diff --git a/test/perf/Makefile b/test/perf/Makefile
index 848dfbcbe3f28..0ff723aa70f7b 100644
--- a/test/perf/Makefile
+++ b/test/perf/Makefile
@@ -1,34 +1,37 @@
-JULIAHOME = $(abspath ../..)
-include ../../Make.inc
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/../..)
+BUILDDIR := .
+include $(JULIAHOME)/Make.inc
+# TODO: this Makefile ignores BUILDDIR, except for computing JULIA_EXECUTABLE
+
 
 all: micro kernel cat shootout blas lapack simd sort spell sparse
 
 micro kernel cat shootout blas lapack simd sort spell sparse:
-	@$(MAKE) $(QUIET_MAKE) -C shootout
+	@$(MAKE) $(QUIET_MAKE) -C $(SRCDIR)/shootout
 ifneq ($(OS),WINNT)
-	@$(call spawn,$(JULIA_EXECUTABLE)) $@/perf.jl | perl -nle '@_=split/,/; printf "%-18s %8.3f %8.3f %8.3f %8.3f\n", $$_[1], $$_[2], $$_[3], $$_[4], $$_[5]'
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/$@/perf.jl | perl -nle '@_=split/,/; printf "%-18s %8.3f %8.3f %8.3f %8.3f\n", $$_[1], $$_[2], $$_[3], $$_[4], $$_[5]'
 else
-	@$(call spawn,$(JULIA_EXECUTABLE)) $@/perf.jl 2> /dev/null
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/$@/perf.jl 2> /dev/null
 endif
 
 codespeed:
-	@$(MAKE) $(QUIET_MAKE) -C shootout
-	@$(call spawn,$(JULIA_EXECUTABLE)) micro/perf.jl codespeed
-	@$(call spawn,$(JULIA_EXECUTABLE)) kernel/perf.jl codespeed
-	@$(call spawn,$(JULIA_EXECUTABLE)) shootout/perf.jl codespeed
-#	@$(call spawn,$(JULIA_EXECUTABLE)) cat/perf.jl codespeed
-#	@$(call spawn,$(JULIA_EXECUTABLE)) blas/perf.jl codespeed
-#	@$(call spawn,$(JULIA_EXECUTABLE)) lapack/perf.jl codespeed
-#	@$(call spawn,$(JULIA_EXECUTABLE)) simd/perf.jl codespeed
-#	@$(call spawn,$(JULIA_EXECUTABLE)) sort/perf.jl codespeed
-	@$(call spawn,$(JULIA_EXECUTABLE)) spell/perf.jl codespeed
-	@$(call spawn,$(JULIA_EXECUTABLE)) sparse/perf.jl codespeed
-	@$(call spawn,$(JULIA_EXECUTABLE)) report.jl
+	@$(MAKE) $(QUIET_MAKE) -C $(SRCDIR)/shootout
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/micro/perf.jl codespeed
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/kernel/perf.jl codespeed
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/shootout/perf.jl codespeed
+#	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/cat/perf.jl codespeed
+#	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/blas/perf.jl codespeed
+#	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/lapack/perf.jl codespeed
+#	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/simd/perf.jl codespeed
+#	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/sort/perf.jl codespeed
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/spell/perf.jl codespeed
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/sparse/perf.jl codespeed
+	@$(call spawn,$(JULIA_EXECUTABLE)) $(SRCDIR)/report.jl
 
 
 clean:
-	rm -f *~
-	$(MAKE) -C micro $@
-	$(MAKE) -C shootout $@
+	$(MAKE) -C $(SRCDIR)/micro clean
+	$(MAKE) -C $(SRCDIR)/shootout clean
 
 .PHONY: micro kernel cat shootout blas lapack simd sort spell sparse clean
diff --git a/test/perf/arrayalloc/Makefile b/test/perf/arrayalloc/Makefile
deleted file mode 100644
index ace591be023d2..0000000000000
--- a/test/perf/arrayalloc/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-JULIAHOME = $(abspath ../../..)
-include $(JULIAHOME)/Make.inc
-
-ifndef PYTHONBIN
-	PYTHONBIN = python
-endif
-
-python:
-	$(PYTHONBIN) lucompletepiv.py
-
-julia:
-	@$(call spawn,$(JULIA_EXECUTABLE)) lucompletepiv.jl
-
-all: python julia
diff --git a/test/perf/arrayalloc/lucompletepiv.jl b/test/perf/arrayalloc/lucompletepiv.jl
deleted file mode 100644
index d2ad0e2d0e2dd..0000000000000
--- a/test/perf/arrayalloc/lucompletepiv.jl
+++ /dev/null
@@ -1,55 +0,0 @@
-# This file is a part of Julia. License is MIT: http://julialang.org/license
-
-function lucompletepivCopy!(A)
-    n = size(A, 1)
-    rowpiv=zeros(Int, n-1)
-    colpiv=zeros(Int, n-1)
-    for k = 1:n-1
-        As = abs(A[k:n, k:n])
-        μ, λ = ind2sub(size(As), indmax(As))
-        μ += k-1; λ += k-1
-        rowpiv[k] = μ
-        A[[k,μ], 1:n] = A[[μ,k], 1:n]
-        colpiv[k] = λ
-        A[1:n, [k,λ]] = A[1:n, [λ,k]]
-        if A[k,k] ≠ 0
-            ρ = k+1:n
-            A[ρ, k] = A[ρ, k]/A[k, k]
-            A[ρ, ρ] = A[ρ, ρ] - A[ρ, k] * A[k, ρ]
-        end
-    end
-    return (A, rowpiv, colpiv)
-end
-
-function lucompletepivSub!(A)
-    n = size(A, 1)
-    rowpiv=zeros(Int, n-1)
-    colpiv=zeros(Int, n-1)
-    for k = 1:n-1
-        As = abs(sub(A, k:n, k:n))
-        μ, λ = ind2sub(size(As), indmax(As))
-        μ += k-1; λ += k-1
-        rowpiv[k] = μ
-        A[[k,μ], 1:n] = sub(A, [μ,k], 1:n)
-        colpiv[k] = λ
-        A[1:n, [k,λ]] = sub(A, 1:n, [λ,k])
-        if A[k,k] ≠ 0
-            ρ = k+1:n
-            A[ρ, k] = sub(A, ρ, k)/A[k, k]
-            A[ρ, ρ] = sub(A, ρ, ρ) - sub(A, ρ, k) * sub(A, k, ρ)
-        end
-    end
-    return (A, rowpiv, colpiv)
-end
-
-println("Julia version with copy slices")
-for n = [100, 250, 500, 1000]
-    A = randn(n,n)
-    @printf("size %4d matrix factorized in %6.3f seconds\n", n, mean([@elapsed lucompletepivCopy!(copy(A)) for i = 1:3]))
-end
-
-println("\nJulia version with view slices")
-for n = [100, 250, 500, 1000]
-    A = randn(n,n)
-    @printf("size %4d matrix factorized in %6.3f seconds\n", n, mean([@elapsed lucompletepivSub!(copy(A)) for i = 1:3]))
-end
diff --git a/test/perf/arrayalloc/lucompletepiv.py b/test/perf/arrayalloc/lucompletepiv.py
deleted file mode 100644
index 81785ab307976..0000000000000
--- a/test/perf/arrayalloc/lucompletepiv.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import numpy as np
-import time
-
-def lucompletepiv(A):
-    assert np.size(A, 0) == np.size(A, 1)
-    n = np.size(A, 1)
-    rowpiv = np.zeros(n-1, dtype=int)
-    colpiv = np.zeros(n-1, dtype=int)
-    for k in range(n-1):
-        Asub = abs(A[k:n, k:n])
-        mu, lam = np.unravel_index(np.argmax(Asub), np.shape(Asub))
-        mu, lam = mu + k, lam + k
-        rowpiv[k] = mu
-        A[[k, mu], :n] = A[[mu, k], :n]
-        colpiv[k] = lam
-        A[:n, [k, lam]] = A[:n, [lam, k]]
-        if A[k, k] != 0:
-            rho = slice(k+1, n)
-            A[rho, k] = A[rho, k]/A[k, k]
-            A[rho, rho] -= np.dot(np.reshape(A[rho, k], (n - (k + 1), 1)),
-                                  np.reshape(A[k, rho], (1, n - (k + 1))))
-    return (A, rowpiv, colpiv)
-
-
-for n in [100, 250, 500, 1000]:
-    tt = []
-    for rep in range(3):
-        A = np.random.randn(n, n)
-        t0 = time.time()
-        lucompletepiv(A.copy())
-        tt.append(time.time() - t0)
-
-    print("size %4d matrix factorized in %6.3f seconds" % (n, sum(tt)/3))
-
-print("")
diff --git a/test/perf/kernel/perf.jl b/test/perf/kernel/perf.jl
index b29acd7498e1a..9977ac1383fcf 100644
--- a/test/perf/kernel/perf.jl
+++ b/test/perf/kernel/perf.jl
@@ -102,9 +102,7 @@ d = randn(len)
 
 @timeit (for n in 1:10; a = arith_vectorized(b,c,d); end) "vectorize" "Vectorized arithmetic"
 
-open("random.csv","w") do io
-    writecsv(io, rand(100000,4))
-end
+writecsv("random.csv", rand(100000,4))
 
 function parsecsv()
     for line in EachLine(open("random.csv"))
diff --git a/test/perf/kernel/stockcorr.m b/test/perf/kernel/stockcorr.m
index e5df602c570c2..687402b401f3e 100644
--- a/test/perf/kernel/stockcorr.m
+++ b/test/perf/kernel/stockcorr.m
@@ -1,4 +1,5 @@
 %ORIGINAL_CORR - The original, unoptimised code that simulates two correlated assets
+%Mike Croucher (http://www.walkingrandomly.com/?p=3604)
 
 %% Correlated asset information
 CurrentPrice = [78 102];       %Initial Prices of the two stocks
diff --git a/test/perf/micro/.gitignore b/test/perf/micro/.gitignore
index bae59a651e9bd..19727ca0afb5a 100644
--- a/test/perf/micro/.gitignore
+++ b/test/perf/micro/.gitignore
@@ -2,4 +2,5 @@
 /benchmarks.csv
 /benchmarks.txt
 /benchmarks.html
+gopath
 mods/*
diff --git a/test/perf/micro/Makefile b/test/perf/micro/Makefile
index ef7bbe80472d1..636f4885b87a8 100644
--- a/test/perf/micro/Makefile
+++ b/test/perf/micro/Makefile
@@ -1,9 +1,12 @@
-JULIAHOME = $(abspath ../../..)
+JULIAHOME := $(abspath ../../..)
 include $(JULIAHOME)/Make.inc
 include $(JULIAHOME)/deps/Versions.make
 
 NODEJSBIN = nodejs
 
+#Use python2 for Python 2.x
+PYTHON = python3
+
 ifeq ($(OS), WINNT)
 MATHEMATICABIN = MathKernel
 else ifeq ($(OS), Darwin)
@@ -14,30 +17,29 @@ endif
 
 #Which BLAS library am I using?
 ifeq ($(USE_SYSTEM_BLAS), 0)
-BLASDIR=$(JULIAHOME)/deps/openblas-$(OPENBLAS_VER)/
-LIBBLAS=$(BLASDIR)libopenblas.a
+BLASDIR=$(JULIAHOME)/deps/build/openblas/
+LIBBLAS=$(BLASDIR)$(LIBBLASNAME).a
 endif
 
 FFLAGS=-fexternal-blas
+#gfortran cannot multiply matrices using 64-bit external BLAS.
 ifeq ($(findstring gfortran, $(FC)), gfortran)
 ifeq ($(USE_BLAS64), 1)
-#gfortran cannot multiply matrices using 64-bit external BLAS.
-#External BLAS usage is turned OFF.
 FFLAGS=
 endif
 FFLAGS+= -static-libgfortran
 endif
 
 #Which libm library am I using?
-LIBMDIR = $(JULIAHOME)/deps/openlibm/
+LIBMDIR = $(JULIAHOME)/deps/build/openlibm/
 ifeq ($(USE_SYSTEM_LIBM), 0)
 ifeq ($(USE_SYSTEM_OPENLIBM), 0)
 LIBM = $(LIBMDIR)libopenlibm.a
 endif
 endif
 
-DSFMTDIR = $(JULIAHOME)/deps/dsfmt-$(DSFMT_VER)
-RMATHDIR = $(JULIAHOME)/deps/Rmath-julia-$(RMATH_JULIA_VER)
+DSFMTDIR = $(JULIAHOME)/deps/build/dsfmt-$(DSFMT_VER)
+RMATHDIR = $(JULIAHOME)/deps/build/Rmath-julia-$(RMATH_JULIA_VER)
 
 default: benchmarks.html
 
@@ -51,11 +53,11 @@ perf.h: $(JULIAHOME)/deps/Versions.make
 	echo '#include "$(RMATHDIR)/src/randmtzig.c"' >> $@
 
 bin/perf%: perf.c perf.h
-	$(CC) -std=c99 -O$* $< -o $@  -I$(DSFMTDIR) -L$(BLASDIR) $(LIBBLAS) -L$(LIBMDIR) $(LIBM) $(CFLAGS) -lpthread
+	$(CC) -std=c99 -O$* $< -o $@  -I$(DSFMTDIR) $(LIBBLAS) -L$(LIBMDIR) $(LIBM) $(CFLAGS) -lpthread
 
 bin/fperf%: perf.f90
 	mkdir -p mods/$@ #Modules for each binary go in separate directories
-	$(FC) $(FFLAGS) -Jmods/$@ -O$* $< -o $@ -L$(BLASDIR) $(LIBBLAS) -L$(LIBMDIR) $(LIBM) -lpthread
+	$(FC) $(FFLAGS) -Jmods/$@ -O$* $< -o $@ $(LIBBLAS) -L$(LIBMDIR) $(LIBM) -lpthread
 
 benchmarks/c.csv: \
 	benchmarks/c0.csv \
@@ -77,17 +79,21 @@ benchmarks/c%.csv: bin/perf%
 benchmarks/fortran%.csv: bin/fperf%
 	for t in 1 2 3 4 5; do $<; done >$@
 
+benchmarks/go.csv: export GOPATH=$(abspath gopath)
 benchmarks/go.csv: perf.go
+	CGO_LDFLAGS="$(LIBBLAS) $(LIBM)" go get github.com/gonum/blas/cgo
+	go get github.com/gonum/matrix/mat64
+	go get github.com/gonum/stat
 	for t in 1 2 3 4 5; do go run $<; done >$@
 
 benchmarks/julia.csv: perf.jl
 	for t in 1 2 3 4 5; do ../../../julia $<; done >$@
 
 benchmarks/python.csv: perf.py
-	for t in 1 2 3 4 5; do python $<; done >$@
+	for t in 1 2 3 4 5; do $(PYTHON) $<; done >$@
 
 benchmarks/matlab.csv: perf.m
-	for t in 1 2 3 4 5; do matlab -nosplash -nodesktop -nojvm -r 'perf;exit' 2>/dev/null | grep '^matlab,'; done >$@
+	for t in 1 2 3 4 5; do matlab -nojvm -singleCompThread -r 'perf; perf; exit' | grep ^matlab | tail -8; done >$@
 
 benchmarks/octave.csv: perf.m
 	for t in 1 2 3 4 5; do octave -q --eval perf 2>/dev/null; done >$@
@@ -110,6 +116,9 @@ benchmarks/lua.csv: perf.lua
 benchmarks/java.csv: java/src/main/java/PerfBLAS.java
 	cd java; sh setup.sh; for t in 1 2 3 4 5; do mvn -q exec:java; done >../$@
 
+benchmarks/scala.csv: scala/src/main/scala/perf.scala scala/build.sbt
+	cd scala; for t in 1 2 3 4 5; do sbt run; done >../$@
+
 BENCHMARKS = \
 	benchmarks/c.csv \
 	benchmarks/fortran.csv \
@@ -122,7 +131,8 @@ BENCHMARKS = \
 	benchmarks/lua.csv \
 	benchmarks/javascript.csv \
 	benchmarks/mathematica.csv \
-	benchmarks/java.csv
+	benchmarks/java.csv \
+	benchmarks/scala.csv
 
 benchmarks.csv: bin/collect.pl $(BENCHMARKS)
 	@$(call PRINT_PERL, $^ >$@)
@@ -131,6 +141,8 @@ benchmarks.html: bin/table.pl benchmarks.csv
 	@$(call PRINT_PERL, $^ >$@)
 
 clean:
-	@rm -rf perf.h bin/perf* bin/fperf* benchmarks/*.csv benchmarks.csv mods *~ octave-core perf.log
+	@rm -rf perf.h bin/perf* bin/fperf* benchmarks/*.csv benchmarks.csv mods *~ octave-core perf.log gopath/*
 
 .PHONY: all perf clean
+
+.PRECIOUS: bin/perf0 bin/perf1 bin/perf2 bin/perf3
diff --git a/test/perf/micro/bin/table.pl b/test/perf/micro/bin/table.pl
index 930e29f0c2cde..e3ba93b1799ff 100755
--- a/test/perf/micro/bin/table.pl
+++ b/test/perf/micro/bin/table.pl
@@ -19,9 +19,9 @@
   rand_mat_mul
 );
 
-our $julia_ver = `julia -v | cut -f3 -d" "`;
-our $fortran_ver = `gfortran-4.8 -v 2>&1 | grep "gcc version" | cut -f3 -d" "`;
-our $python_ver = `python -V 2>&1 | cut -f2 -d" "`;
+our $julia_ver = `../../../julia -v | cut -f3 -d" "`;
+our $fortran_ver = `gfortran -v 2>&1 | grep "gcc version" | cut -f3 -d" "`;
+our $python_ver = `python3 -V 2>&1 | cut -f2 -d" "`;
 our $matlab_ver = `matlab -nodisplay -nojvm -nosplash -r "version -release, quit" | tail -n 3 | head -n 1`;
 our $R_ver = `R --version | grep "R version" | cut -f3 -d" "`;
 our $octave_ver = `octave -v | grep version | cut -f4 -d" "`;
diff --git a/test/perf/micro/java/src/main/java/PerfBLAS.java b/test/perf/micro/java/src/main/java/PerfBLAS.java
index 92be8df7a7673..f446b9417430c 100644
--- a/test/perf/micro/java/src/main/java/PerfBLAS.java
+++ b/test/perf/micro/java/src/main/java/PerfBLAS.java
@@ -6,279 +6,70 @@
 
 import org.jblas.DoubleMatrix;
 
-public class PerfBLAS {
-	private static final int NITER = 5;
-	private static Random rand = new Random(0);
-
-	public static void main(String[] args) {
-
-		    long t, tmin;
-		    assert(fib(20) == 6765);
-		    int f = 0;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        f += fib(20);
-		        t = (System.nanoTime())-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("fib", tmin);
-
-		    // parse_bin
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        for (int k=0; k<1000; ++k) {
-		        	int n = rand.nextInt(Integer.MAX_VALUE);
-		        	String str = Integer.toHexString(n);
-		        	int m = Integer.valueOf(str, 16);
-		            assert(m == n);
-		        }
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("parse_int", tmin);
-
-		    // mandel
-		    int mandel_sum = 0;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        mandel_sum = mandelperf();
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    assert(mandel_sum == 14720) : "value was "+mandel_sum;
-		    print_perf("mandel", tmin);
-
-		    // sort
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        int j = 5000;
-		        double[] d = new double[j];
-		        while (--j>=0) {
-		        	d[j] = rand.nextDouble();
-		        }
-		        quicksort(d, 0, 5000-1);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("quicksort", tmin);
-
-		    // pi sum
-		    double pi = 0;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        pi = pisum();
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    assert(Math.abs(pi-1.644834071848065) < 1e-12);
-		    print_perf("pi_sum", tmin);
-
-		    // rand mat stat
-		    double[] r;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        r = randmatstat_JBLAS(1000);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("rand_mat_stat", tmin);
-
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        DoubleMatrix C = randmatmul_JBLAS(1000);
-		        assert(0 <= C.get(0));
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("rand_mat_mul", tmin);
-
-
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        sinc_sum(1000);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("sinc_sum", tmin);
-
-		    // printfd
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        printfd(100000);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("printfd", tmin);
-	}
-
-	static void printfd(int n) {
-		try {
-			FileOutputStream f = new FileOutputStream("/dev/null");
-		    PrintStream ps = new PrintStream(f);
-		    long i = 0;
-		    for (i = 0; i < n; i++) {
-		        ps.println(i+" "+i);
-		    }
-		    ps.close();
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		}
-	}
-
-
-	private static double sinc_sum(int n) {
-
-		double total = 0;
-		for (int i=0; i < n; i++) {
-			double f= Math.PI*i;
-			double sinc = Math.sin(f)/f;
-			total+=sinc;
-		}
-		return total;
-	}
-
-	private static DoubleMatrix randmatmul_JBLAS(int i) {
-		DoubleMatrix a = DoubleMatrix.randn(i,i);
-		DoubleMatrix b = DoubleMatrix.randn(i,i);
-		return a.mmul(b);
-	}
-
-	private static double[] randmatstat_JBLAS(int t) {
-	    int n=5;
-	    DoubleMatrix p;
-	    DoubleMatrix q;
-	    DoubleMatrix v = new DoubleMatrix(new double[t][1]); //zeros(t,1);
-	    DoubleMatrix w = new DoubleMatrix(new double[t][1]); //zeros(t,1);
-	    for (int i=0; i < t; i++) {
-	    	DoubleMatrix a = DoubleMatrix.randn(n,n);
-	    	DoubleMatrix b = DoubleMatrix.randn(n,n);
-	    	DoubleMatrix c = DoubleMatrix.randn(n,n);
-	    	DoubleMatrix d = DoubleMatrix.randn(n,n);
-
-	    	p = DoubleMatrix.concatHorizontally(DoubleMatrix.concatHorizontally(a, b),DoubleMatrix.concatHorizontally(c, d));
-	    	q = DoubleMatrix.concatVertically(DoubleMatrix.concatHorizontally(a, b),DoubleMatrix.concatHorizontally(c, d));
+/**
+ * Benchmark tests that call BLAS. 
+ */
+public class PerfBLAS extends PerfPure {
+
+    public static void main(String[] args) {
+        PerfBLAS p = new PerfBLAS();
+        p.runBenchmarks();
+    }
 
-	    	DoubleMatrix x = p.transpose().mmul(p);
-	    	x = x.mmul(x);
-	    	x = x.mmul(x);
-	    	v.data[i]=x.diag().sum();
+    private double randmatmul(int i) {
+        DoubleMatrix a = DoubleMatrix.randn(i,i);
+        DoubleMatrix b = DoubleMatrix.randn(i,i);
+        return a.mmul(b).get(0);
+    }
 
-	    	x = q.transpose().mmul(q);
-	    	x = x.mmul(x);
-	    	x = x.mmul(x);
-	    	w.data[i]=x.diag().sum();
+    private double[] randmatstat(int t) {
+        int n=5;
+        DoubleMatrix p;
+        DoubleMatrix q;
+        DoubleMatrix v = new DoubleMatrix(new double[t][1]); //zeros(t,1);
+        DoubleMatrix w = new DoubleMatrix(new double[t][1]); //zeros(t,1);
+        for (int i=0; i < t; i++) {
+            DoubleMatrix a = DoubleMatrix.randn(n,n);
+            DoubleMatrix b = DoubleMatrix.randn(n,n);
+            DoubleMatrix c = DoubleMatrix.randn(n,n);
+            DoubleMatrix d = DoubleMatrix.randn(n,n);
+
+            p = DoubleMatrix.concatHorizontally(DoubleMatrix.concatHorizontally(a, b),DoubleMatrix.concatHorizontally(c, d));
+            q = DoubleMatrix.concatVertically(DoubleMatrix.concatHorizontally(a, b),DoubleMatrix.concatHorizontally(c, d));
+
+            DoubleMatrix x = p.transpose().mmul(p);
+            x = x.mmul(x);
+            x = x.mmul(x);
+            v.data[i]=x.diag().sum();
+
+            x = q.transpose().mmul(q);
+            x = x.mmul(x);
+            x = x.mmul(x);
+            w.data[i]=x.diag().sum();
 
-	    }
+        }
 
-	    List<Double> vElements = v.elementsAsList();
-	    List<Double> wElements = w.elementsAsList();
+        List<Double> vElements = v.elementsAsList();
+        List<Double> wElements = w.elementsAsList();
 
-	    return new double[]{stdev(vElements)/mean(vElements),stdev(wElements)/mean(wElements)};
-	}
+        return new double[]{stdev(vElements)/mean(vElements),stdev(wElements)/mean(wElements)};
+    }
 
-    public static double stdev(List<Double> elements) {
-        double m = mean(elements);
-        double total = 0;
-        for(Double d:elements) {
-        	double dif = (d-m);
-        	total += dif*dif;
+    private static int mandel(double re, double im) {
+        int n = 0;
+        Complex z = new Complex(re, im);
+        Complex c = new Complex(re, im);
+        for (n=0; n<=79; ++n) {
+            if (Complex.abs(z) > 2.0) {
+                n -= 1;
+                break;
+            }
+
+            // z = z*z + c
+            z = Complex.add(Complex.mul(z, z), c);
         }
-        return Math.sqrt(total/(elements.size()-1));
+        return n+1;
     }
 
-	public static double mean(List<Double> elements) {
-		double total = 0;
-		for(Double d:elements) {
-			total += d;
-		}
-	    return total/elements.size();
-	}
-
-	private static void quicksort(double[] a, int lo, int hi) {
-	    int i = lo;
-	    int j = hi;
-	    while (i < hi) {
-	        double pivot = a[(lo+hi)/2];
-	        // Partition
-	        while (i <= j) {
-	            while (a[i] < pivot) {
-	                i = i + 1;
-	            }
-	            while (a[j] > pivot) {
-	                j = j - 1;
-	            }
-	            if (i <= j) {
-	                double t = a[i];
-	                a[i] = a[j];
-	                a[j] = t;
-	                i = i + 1;
-	                j = j - 1;
-	            }
-	        }
-
-	        // Recursion for quicksort
-	        if (lo < j) {
-	            quicksort(a, lo, j);
-	        }
-	        lo = i;
-	        j = hi;
-	    }
-	}
-
-	private static double pisum() {
-	    double sum = 0.0;
-	    for (int j=0; j<500; ++j) {
-	        sum = 0.0;
-	        for (int k=1; k<=10000; ++k) {
-	            sum += 1.0/(k*k);
-	        }
-	    }
-	    return sum;
-	}
-
-	private static int mandel(double re, double im) {
-	    int n = 0;
-	    Complex z = new Complex(re, im);
-	    Complex c = new Complex(re, im);
-	    for (n=0; n<=79; ++n) {
-	        if (Complex.abs(z) > 2.0) {
-	            n -= 1;
-	            break;
-	        }
-
-	        // z = z*z + c
-	        z = Complex.add(Complex.mul(z, z), c);
-	    }
-	    return n+1;
-	}
-
-	private static int mandelperf() {
-	    int mandel_sum = 0;
-	    for (double re=-2.0; re<=0.5; re+=0.1) {
-	        for (double im=-1.0; im<=1.0; im+=0.1) {
-	            int m = mandel(re,im);
-	            mandel_sum += m;
-	        }
-	    }
-	    return mandel_sum;
-	}
-
-	private static void print_perf(String name, long t) {
-		System.out.printf("java,%s,%.6f\n", name, t/(double)1E6);
-	}
-
-	private static int fib(int n) {
-		return n < 2 ? n : fib(n-1) + fib(n-2);
-	}
-
 }
 
diff --git a/test/perf/micro/java/src/main/java/PerfPure.java b/test/perf/micro/java/src/main/java/PerfPure.java
index ce65657d13920..d23453c910a1b 100644
--- a/test/perf/micro/java/src/main/java/PerfPure.java
+++ b/test/perf/micro/java/src/main/java/PerfPure.java
@@ -6,315 +6,336 @@
 
 import org.ejml.simple.SimpleMatrix;
 
+/**
+ * (Below excerpt is printed on the website and repeated here)
+ * 
+ * These benchmarks, while not comprehensive, do test compiler performance on a range of common code patterns, 
+ * such as function calls, string parsing, sorting, numerical loops, random number generation, and array operations. 
+ * It is important to note that these benchmark implementations are not written for absolute maximal performance 
+ * (the fastest code to compute fib(20) is the constant literal 6765). Rather, all of the benchmarks are written 
+ * to test the performance of specific algorithms, expressed in a reasonable idiom in each language. 
+ * In particular, all languages use the same algorithm: the Fibonacci benchmarks are all recursive while 
+ * the pi summation benchmarks are all iterative; the “algorithm” for random matrix multiplication is to 
+ * call LAPACK, except where that’s not possible, such as in JavaScript. The point of these benchmarks is to 
+ * compare the performance of specific algorithms across language implementations, not to compare the fastest 
+ * means of computing a result, which in most high-level languages relies on calling C code. 
+ *
+ */
 public class PerfPure {
-	private static final int NITER = 5;
-	private static Random rand = new Random(0);
-
-	public static void main(String[] args) {
-
-		    long t, tmin;
-
-		    assert(fib(20) == 6765);
-		    int f = 0;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        f += fib(20);
-		        t = (System.nanoTime())-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("fib", tmin);
-
-		    // parse_bin
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        for (int k=0; k<1000; ++k) {
-		        	int n = rand.nextInt(Integer.MAX_VALUE);
-		        	String str = Integer.toHexString(n);
-		        	int m = Integer.valueOf(str, 16);
-		            assert(m == n);
-		        }
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("parse_int", tmin);
-
-		    // mandel
-		    int mandel_sum = 0;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        mandel_sum = mandelperf();
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    assert(mandel_sum == 14720) : "value was "+mandel_sum;
-		    print_perf("mandel", tmin);
-
-		    // sort
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        int j = 5000;
-		        double[] d = new double[j];
-		        while (--j>=0) {
-		        	d[j] = rand.nextDouble();
-		        }
-		        quicksort(d, 0, 5000-1);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("quicksort", tmin);
-
-		    // pi sum
-		    double pi = 0;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        pi = pisum();
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    assert(Math.abs(pi-1.644834071848065) < 1e-12);
-		    print_perf("pi_sum", tmin);
-
-		    // rand mat stat
-		    double[] r;
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        r = randmatstat_EJML(1000);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("rand_mat_stat", tmin);
-
-		    // rand mat mul
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        SimpleMatrix C = randmatmul_EJML(1000);
-		        assert(0 <= C.get(0));
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("rand_mat_mul", tmin);
-
-
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        sinc_sum(1000);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("sinc_sum", tmin);
-
-		    // printfd
-		    tmin = Long.MAX_VALUE;
-		    for (int i=0; i<NITER; ++i) {
-		        t = System.nanoTime();
-		        printfd(100000);
-		        t = System.nanoTime()-t;
-		        if (t < tmin) tmin = t;
-		    }
-		    print_perf("printfd", tmin);
-	}
-
-	static void printfd(int n) {
-		try {
-			FileOutputStream f = new FileOutputStream("/dev/null");
-		    PrintStream ps = new PrintStream(f);
-		    long i = 0;
-		    for (i = 0; i < n; i++) {
-		        ps.println(i+" "+i);
-		    }
-		    ps.close();
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		}
-	}
-
-
-	private static double sinc_sum(int n) {
-
-		double total = 0;
-		for (int i=0; i < n; i++) {
-			double f= Math.PI*i;
-			double sinc = Math.sin(f)/f;
-			total+=sinc;
-		}
-		return total;
-	}
-
-	private static SimpleMatrix randmatmul_EJML(int i) {
-		SimpleMatrix a = SimpleMatrix.random(i, i,  -1d, +1d, rand);
-		SimpleMatrix b = SimpleMatrix.random(i, i,  -1d, +1d, rand);
-		return a.mult(b);
-	}
-
-	private static double[] randmatstat_EJML(int t) {
-	    int n=5;
-	    SimpleMatrix p = new SimpleMatrix(new double[n][4*n]);
-	    SimpleMatrix q = new SimpleMatrix(new double[2*n][2*n]);
-	    SimpleMatrix v = new SimpleMatrix(new double[t][1]); //zeros(t,1);
-	    SimpleMatrix w = new SimpleMatrix(new double[t][1]); //zeros(t,1);
-	    for (int i=0; i < t; i++) {
-	    	SimpleMatrix a = SimpleMatrix.random(n, n,  -1d, +1d, rand);
-	    	SimpleMatrix b = SimpleMatrix.random(n, n,  -1d, +1d, rand);
-	    	SimpleMatrix c = SimpleMatrix.random(n, n,  -1d, +1d, rand);
-	    	SimpleMatrix d = SimpleMatrix.random(n, n,  -1d, +1d, rand);
-
-	    	p.combine(0, 0*n, a);
-	    	p.combine(0, 1*n, b);
-	    	p.combine(0, 2*n, c);
-	    	p.combine(0, 3*n, d);
-
-	    	q.combine(0, 0*n, a);
-	    	q.combine(0, 1*n, b);
-	    	q.combine(n, 0*n, c);
-	    	q.combine(n, 1*n, d);
-
-	    	SimpleMatrix x = p.transpose().mult(p);
-	    	x = x.mult(x);
-	    	x = x.mult(x);
-	    	v.set(i, x.trace());
-
-	    	x = q.transpose().mult(q);
-	    	x = x.mult(x);
-	    	x = x.mult(x);
-	    	w.set(i, x.trace());
-
-	    }
-	    return new double[]{stdev(v)/mean(v),stdev(w)/mean(w)};
-	}
-
-    public static double stdev(List<Double> elements) {
+    
+    protected final int NITER = 5;
+    protected Random rand = new Random(0);
+
+    public static void main(String[] args) {
+        PerfPure p = new PerfPure();
+        p.runBenchmarks();
+    }
+    
+    void runBenchmarks() {
+
+        long t, tmin;
+
+        assert(fib(20) == 6765);
+        int f = 0;
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            f += fib(20);
+            t = (System.nanoTime())-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("fib", tmin);
+
+        // parse_bin
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            for (int k=0; k<1000; ++k) {
+                int n = rand.nextInt(Integer.MAX_VALUE);
+                String str = Integer.toHexString(n);
+                int m = Integer.valueOf(str, 16);
+                assert(m == n);
+            }
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("parse_int", tmin);
+
+        // mandel
+        int mandel_sum = 0;
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            mandel_sum = mandelperf();
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        assert(mandel_sum == 14720) : "value was "+mandel_sum;
+        print_perf("mandel", tmin);
+
+        // sort
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            int j = 5000;
+            double[] d = new double[j];
+            while (--j>=0) {
+                d[j] = rand.nextDouble();
+            }
+            quicksort(d, 0, 5000-1);
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("quicksort", tmin);
+
+        // pi sum
+        double pi = 0;
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            pi = pisum();
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        assert(Math.abs(pi-1.644834071848065) < 1e-12);
+        print_perf("pi_sum", tmin);
+
+        // rand mat stat
+        double[] r;
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            r = randmatstat(1000);
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("rand_mat_stat", tmin);
+
+        // rand mat mul
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            double d = randmatmul(1000);
+            assert(0 <= d);
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("rand_mat_mul", tmin);
+
+
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            sinc_sum(1000);
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("sinc_sum", tmin);
+
+        // printfd
+        tmin = Long.MAX_VALUE;
+        for (int i=0; i<NITER; ++i) {
+            t = System.nanoTime();
+            printfd(100000);
+            t = System.nanoTime()-t;
+            if (t < tmin) tmin = t;
+        }
+        print_perf("printfd", tmin);
+    }
+
+    void printfd(int n) {
+        try {
+            FileOutputStream f = new FileOutputStream("/dev/null");
+            PrintStream ps = new PrintStream(f);
+            long i = 0;
+            for (i = 0; i < n; i++) {
+                ps.println(i+" "+i);
+            }
+            ps.close();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    protected double sinc_sum(int n) {
+
+        double total = 0;
+        for (int i=0; i < n; i++) {
+            double f= Math.PI*i;
+            double sinc = Math.sin(f)/f;
+            total+=sinc;
+        }
+        return total;
+    }
+
+    private double randmatmul(int i) {
+        SimpleMatrix a = SimpleMatrix.random(i, i,  -1d, +1d, rand);
+        SimpleMatrix b = SimpleMatrix.random(i, i,  -1d, +1d, rand);
+        return a.mult(b).get(0);
+    }
+
+    private double[] randmatstat(int t) {
+        int n=5;
+        SimpleMatrix p = new SimpleMatrix(new double[n][4*n]);
+        SimpleMatrix q = new SimpleMatrix(new double[2*n][2*n]);
+        SimpleMatrix v = new SimpleMatrix(new double[t][1]); //zeros(t,1);
+        SimpleMatrix w = new SimpleMatrix(new double[t][1]); //zeros(t,1);
+        for (int i=0; i < t; i++) {
+            SimpleMatrix a = SimpleMatrix.random(n, n,  -1d, +1d, rand);
+            SimpleMatrix b = SimpleMatrix.random(n, n,  -1d, +1d, rand);
+            SimpleMatrix c = SimpleMatrix.random(n, n,  -1d, +1d, rand);
+            SimpleMatrix d = SimpleMatrix.random(n, n,  -1d, +1d, rand);
+
+            p.combine(0, 0*n, a);
+            p.combine(0, 1*n, b);
+            p.combine(0, 2*n, c);
+            p.combine(0, 3*n, d);
+
+            q.combine(0, 0*n, a);
+            q.combine(0, 1*n, b);
+            q.combine(n, 0*n, c);
+            q.combine(n, 1*n, d);
+
+            SimpleMatrix x = p.transpose().mult(p);
+            x = x.mult(x);
+            x = x.mult(x);
+            v.set(i, x.trace());
+
+            x = q.transpose().mult(q);
+            x = x.mult(x);
+            x = x.mult(x);
+            w.set(i, x.trace());
+
+        }
+        return new double[]{stdev(v)/mean(v),stdev(w)/mean(w)};
+    }
+
+    public double stdev(List<Double> elements) {
         double m = mean(elements);
         double total = 0;
         for(Double d:elements) {
-        	double dif = (d-m);
-        	total += dif*dif;
+            double dif = (d-m);
+            total += dif*dif;
         }
         return Math.sqrt(total/(elements.size()-1));
     }
 
-	public static double mean(List<Double> elements) {
-		double total = 0;
-		for(Double d:elements) {
-			total += d;
-		}
-	    return total/elements.size();
-	}
-
-    public static double stdev(SimpleMatrix sm) {
-	        double m = mean(sm);
-	        double total = 0;
-
-	        int i = sm.getNumElements();
-	        while (--i>=0) {
-	            double dif = (sm.get(i)-m);
-	            total += dif*dif;
-	        }
-	        return Math.sqrt(total/(sm.getNumElements()-1));
-	    }
-
-    public static double mean(SimpleMatrix sm) {
+    public double mean(List<Double> elements) {
+        double total = 0;
+        for(Double d:elements) {
+            total += d;
+        }
+        return total/elements.size();
+    }
+
+    public double stdev(SimpleMatrix sm) {
+            double m = mean(sm);
+            double total = 0;
+
+            int i = sm.getNumElements();
+            while (--i>=0) {
+                double dif = (sm.get(i)-m);
+                total += dif*dif;
+            }
+            return Math.sqrt(total/(sm.getNumElements()-1));
+        }
+
+    public double mean(SimpleMatrix sm) {
         double total = 0;
         int i = sm.getNumElements();
         while (--i>=0) {
-        	total += sm.get(i);
+            total += sm.get(i);
         }
         return total/sm.getNumElements();
     }
 
-	private static void quicksort(double[] a, int lo, int hi) {
-	    int i = lo;
-	    int j = hi;
-	    while (i < hi) {
-	        double pivot = a[(lo+hi)/2];
-	        // Partition
-	        while (i <= j) {
-	            while (a[i] < pivot) {
-	                i = i + 1;
-	            }
-	            while (a[j] > pivot) {
-	                j = j - 1;
-	            }
-	            if (i <= j) {
-	                double t = a[i];
-	                a[i] = a[j];
-	                a[j] = t;
-	                i = i + 1;
-	                j = j - 1;
-	            }
-	        }
-
-	        // Recursion for quicksort
-	        if (lo < j) {
-	            quicksort(a, lo, j);
-	        }
-	        lo = i;
-	        j = hi;
-	    }
-	}
-
-	private static double pisum() {
-	    double sum = 0.0;
-	    for (int j=0; j<500; ++j) {
-	        sum = 0.0;
-	        for (int k=1; k<=10000; ++k) {
-	            sum += 1.0/(k*k);
-	        }
-	    }
-	    return sum;
-	}
-
-	private static int mandel(double zReal, double zImag) {
-	    int n = 0;
-	    double cReal = zReal;
-	    double cImag = zImag;
-	    for (n=0; n<=79; ++n) {
-	        if (complexAbs(zReal,zImag) > 2.0) {
-	            n -= 1;
-	            break;
-	        }
-
-	        // z^2
-	        double zSquaredReal = zReal*zReal-zImag*zImag;
-	        double zSquaredImag = zReal*zImag+zImag*zReal;
-
-	        // +c
-	        zReal = zSquaredReal+cReal;
-	        zImag = zSquaredImag+cImag;
-
-	    }
-	    return n+1;
-	}
-
-	private static double complexAbs(double zReal, double zImag) {
-		return Math.sqrt(zReal*zReal + zImag*zImag);
-	}
-
-	private static int mandelperf() {
-	    int mandel_sum = 0;
-	    for (double re=-2.0; re<=0.5; re+=0.1) {
-	        for (double im=-1.0; im<=1.0; im+=0.1) {
-	            int m = mandel(re,im);
-	            mandel_sum += m;
-	        }
-	    }
-	    return mandel_sum;
-	}
-
-	private static void print_perf(String name, long t) {
-		System.out.printf("javaPure,%s,%.6f\n", name, t/(double)1E6);
-	}
-
-	private static int fib(int n) {
-		return n < 2 ? n : fib(n-1) + fib(n-2);
-	}
+    protected void quicksort(double[] a, int lo, int hi) {
+        int i = lo;
+        int j = hi;
+        while (i < hi) {
+            double pivot = a[(lo+hi)/2];
+            // Partition
+            while (i <= j) {
+                while (a[i] < pivot) {
+                    i = i + 1;
+                }
+                while (a[j] > pivot) {
+                    j = j - 1;
+                }
+                if (i <= j) {
+                    double t = a[i];
+                    a[i] = a[j];
+                    a[j] = t;
+                    i = i + 1;
+                    j = j - 1;
+                }
+            }
+
+            // Recursion for quicksort
+            if (lo < j) {
+                quicksort(a, lo, j);
+            }
+            lo = i;
+            j = hi;
+        }
+    }
+
+    protected double pisum() {
+        double sum = 0.0;
+        for (int j=0; j<500; ++j) {
+            sum = 0.0;
+            for (int k=1; k<=10000; ++k) {
+                sum += 1.0/(k*k);
+            }
+        }
+        return sum;
+    }
+
+    private int mandel(double zReal, double zImag) {
+        int n = 0;
+        double cReal = zReal;
+        double cImag = zImag;
+        for (n=0; n<=79; ++n) {
+            if (complexAbs(zReal,zImag) > 2.0) {
+                n -= 1;
+                break;
+            }
+
+            // z^2
+            double zSquaredReal = zReal*zReal-zImag*zImag;
+            double zSquaredImag = zReal*zImag+zImag*zReal;
+
+            // +c
+            zReal = zSquaredReal+cReal;
+            zImag = zSquaredImag+cImag;
+
+        }
+        return n+1;
+    }
+
+    private double complexAbs(double zReal, double zImag) {
+        return Math.sqrt(zReal*zReal + zImag*zImag);
+    }
+
+    protected int mandelperf() {
+        int mandel_sum = 0;
+        for (double re=-2.0; re<=0.5; re+=0.1) {
+            for (double im=-1.0; im<=1.0; im+=0.1) {
+                int m = mandel(re,im);
+                mandel_sum += m;
+            }
+        }
+        return mandel_sum;
+    }
+
+    protected void print_perf(String name, long t) {
+        System.out.printf("javaPure,%s,%.6f\n", name, t/(double)1E6);
+    }
+
+    protected int fib(int n) {
+        return n < 2 ? n : fib(n-1) + fib(n-2);
+    }
 
 }
 
diff --git a/test/perf/micro/perf.c b/test/perf/micro/perf.c
index e9ad4a14bd35c..7bfa4199e67a7 100644
--- a/test/perf/micro/perf.c
+++ b/test/perf/micro/perf.c
@@ -59,7 +59,7 @@ double *matmul_aat(int n, double *b) {
 int mandel(double complex z) {
     int maxiter = 80;
     double complex c = z;
-    for (int n=0; n<maxiter; ++n) {
+    for (int n = 0; n < maxiter; ++n) {
         if (cabs(z) > 2.0) {
             return n;
         }
@@ -68,15 +68,14 @@ int mandel(double complex z) {
     return maxiter;
 }
 
-int mandelperf() {
-    int mandel_sum = 0;
-    for (int re=-20; re<=5; re+=1) {
-        for (int im=-10; im<=10; im+=1) {
-            int m = mandel(re/10.0+I*im/10.0);
-            mandel_sum += m;
+int *mandelperf() {
+    int *M = (int*) malloc(21*26*sizeof(int));
+    for (int i = 0; i < 21; i++) {
+        for (int j = 0; j < 26; j++) {
+            M[26*i + j] = mandel((j-20)/10.0 + ((i-10)/10.0)*I);
         }
     }
-    return mandel_sum;
+    return M;
 }
 
 void quicksort(double *a, int lo, int hi) {
@@ -289,20 +288,38 @@ int main() {
     // print_perf("AtA", tmin);
 
     // mandel
-    int mandel_sum;
-    int mandel_sum2 = 0;
+    /* The initialization on the next line is deliberately volatile to
+     * prevent gcc from optimizing away the entire loop.
+     * (First observed in gcc 4.9.2)
+     */
+    static volatile int mandel_sum_init = 0;
+    int mandel_sum2 = mandel_sum_init;
     tmin = INFINITY;
     for (int i=0; i<NITER; ++i) {
+        int *M;
         t = clock_now();
         for (int j = 0; j < 100; j++) {
-                mandel_sum = mandelperf();
+            M = mandelperf();
+            if (j == 0) {
+                int mandel_sum = 0;
+                // for (int ii = 0; ii < 21; ii++) {
+                //     for (int jj = 0; jj < 26; jj++) {
+                //         printf("%4d", M[26*ii + jj]);
+                //     }
+                //     printf("\n");
+                // }
+                for (int k = 0; k < 21*26; k++) {
+                    mandel_sum += M[k];
+                }
+                assert(mandel_sum == 14791);
                 mandel_sum2 += mandel_sum;
+            }
+            free(M);
         }
         t = clock_now()-t;
         if (t < tmin) tmin = t;
     }
-    assert(mandel_sum == 14791);
-    assert(mandel_sum2 == mandel_sum * 100 * NITER);
+    assert(mandel_sum2 == 14791 * NITER);
     print_perf("mandel", tmin / 100);
 
     // sort
diff --git a/test/perf/micro/perf.go b/test/perf/micro/perf.go
index bde15e46d1a74..201fb8b12a5ee 100644
--- a/test/perf/micro/perf.go
+++ b/test/perf/micro/perf.go
@@ -1,24 +1,47 @@
-//The go.matrix and GoStats packages must be installed
-//To install the go.matrix package, run:
-//    go get github.com/skelterjohn/go.matrix
-//    go install github.com/skelterjohn/go.matrix
-//To install the GoStats package, run:
-//    go get github.com/GaryBoone/GoStats/stats
-//    go install github.com/GaryBoone/GoStats/stats
-
+// Implementation of the Julia benchmark suite in Go.
+//
+// Three gonum packages must be installed, and then an additional environmental
+// variable must be set to use the BLAS installation.
+// To install the gonum packages, run:
+// 		go get github.com/gonum/blas
+//		go get github.com/gonum/matrix/mat64
+//		go get github.com/gonum/stat
+// The cgo ldflags must then be set to use the BLAS implementation. As an example,
+// download OpenBLAS to ~/software
+//		git clone https://github.com/xianyi/OpenBLAS
+// 		cd OpenBLAS
+//		make
+// Then edit the enivorment variable to have
+// 		export CGO_LDFLAGS="-L/$HOME/software/OpenBLAS -lopenblas"
 package main
 
 import (
+	"errors"
 	"fmt"
-	matrix "github.com/skelterjohn/go.matrix"
-	stats "github.com/GaryBoone/GoStats/stats"
+	"log"
 	"math"
 	"math/cmplx"
 	"math/rand"
 	"strconv"
-	"time"
+	"testing"
+
+	"github.com/gonum/blas/blas64"
+	"github.com/gonum/blas/cgo"
+	"github.com/gonum/matrix/mat64"
+	"github.com/gonum/stat"
 )
 
+func init() {
+	// Use the BLAS implementation specified in CGO_LDFLAGS. This line can be
+	// commented out to use the native Go BLAS implementation found in
+	// github.com/gonum/blas/native.
+	blas64.Use(cgo.Implementation{})
+
+	// These are here so that toggling the BLAS implementation does not make imports unused
+	_ = cgo.Implementation{}
+	_ = blas64.General{}
+}
+
 // fibonacci
 
 func fib(n int) int {
@@ -57,67 +80,74 @@ func qsort_kernel(a []float64, lo, hi int) []float64 {
 	return a
 }
 
+var rnd = rand.New(rand.NewSource(1))
+
 // randmatstat
 
 func randmatstat(t int) (float64, float64) {
 	n := 5
-	var v stats.Stats
-	var w stats.Stats
-	for i :=0; i<t; i++ {
-		a := matrix.Zeros(n, n)
-		b := matrix.Zeros(n, n)
-		c := matrix.Zeros(n, n)
-		d := matrix.Zeros(n, n)
-		for j := 0; j < n; j++ {
-			for k := 0; k < n; k++ {
-				a.Set(j, k, rand.NormFloat64())
-				b.Set(j, k, rand.NormFloat64())
-				c.Set(j, k, rand.NormFloat64())
-				d.Set(j, k, rand.NormFloat64())
-			}
-		}
-		P := matrix.Zeros(n, 4*n)
-		for j := 0; j < n; j++ {
-			for k := 0; k < n; k++ {
-				P.Set(j,     k, a.Get(j, k))
-				P.Set(j,   n+k, b.Get(j, k))
-				P.Set(j, 2*n+k, c.Get(j, k))
-				P.Set(j, 3*n+k, d.Get(j, k))
-			}
+	v := make([]float64, t)
+	w := make([]float64, t)
+	ad := make([]float64, n*n)
+	bd := make([]float64, n*n)
+	cd := make([]float64, n*n)
+	dd := make([]float64, n*n)
+	P := mat64.NewDense(n, 4*n, nil)
+	Q := mat64.NewDense(2*n, 2*n, nil)
+	pTmp := mat64.NewDense(4*n, 4*n, nil)
+	qTmp := mat64.NewDense(2*n, 2*n, nil)
+	for i := 0; i < t; i++ {
+		for i := range ad {
+			ad[i] = rnd.NormFloat64()
+			bd[i] = rnd.NormFloat64()
+			cd[i] = rnd.NormFloat64()
+			dd[i] = rnd.NormFloat64()
 		}
-		Q := matrix.Zeros(2*n, 2*n)
-		for j := 0; j < n; j++ {
-			for k := 0; k < n; k++ {
-				Q.Set(j,     k, a.Get(j, k))
-				Q.Set(j,   n+k, b.Get(j, k))
-				Q.Set(n+j,   k, c.Get(j, k))
-				Q.Set(n+j, n+k, d.Get(j, k))
-			}
-		}
-        	P = matrix.Product(matrix.Transpose(P), P)
-        	P = matrix.Product(P, P)
-        	P = matrix.Product(P, P)
-        	Q = matrix.Product(matrix.Transpose(Q), Q)
-        	Q = matrix.Product(Q, Q)
-        	Q = matrix.Product(Q, Q)
-        	v.Update(P.Trace())
-        	w.Update(Q.Trace())
+		a := mat64.NewDense(n, n, ad)
+		b := mat64.NewDense(n, n, bd)
+		c := mat64.NewDense(n, n, cd)
+		d := mat64.NewDense(n, n, dd)
+		P.Copy(a)
+		P.View(0, n, n, n).(*mat64.Dense).Copy(b)
+		P.View(0, 2*n, n, n).(*mat64.Dense).Copy(c)
+		P.View(0, 3*n, n, n).(*mat64.Dense).Copy(d)
+
+		Q.Copy(a)
+		Q.View(0, n, n, n).(*mat64.Dense).Copy(b)
+		Q.View(n, 0, n, n).(*mat64.Dense).Copy(c)
+		Q.View(n, n, n, n).(*mat64.Dense).Copy(d)
+
+		pTmp.Mul(P.T(), P)
+		pTmp.Pow(pTmp, 4)
+
+		qTmp.Mul(Q.T(), Q)
+		qTmp.Pow(qTmp, 4)
+
+		v[i] = mat64.Trace(pTmp)
+		w[i] = mat64.Trace(qTmp)
 	}
-	return v.PopulationStandardDeviation()/float64(v.Count())/v.Mean(), w.PopulationStandardDeviation()/float64(w.Count())/w.Mean()
+	mv, stdv := stat.MeanStdDev(v, nil)
+	mw, stdw := stat.MeanStdDev(v, nil)
+	return stdv / mv, stdw / mw
 }
 
 // randmatmul
 
-func randmatmul(n int) matrix.MatrixRO {
-	a := matrix.Zeros(n, n)
-	b := matrix.Zeros(n, n)
-	for i := 0; i < n; i++ {
-		for k := 0; k < n; k++ {
-			a.Set(i, k, rand.Float64())
-			b.Set(i, k, rand.Float64())
-		}
+func randmatmul(n int) *mat64.Dense {
+	aData := make([]float64, n*n)
+	for i := range aData {
+		aData[i] = rnd.Float64()
+	}
+	a := mat64.NewDense(n, n, aData)
+
+	bData := make([]float64, n*n)
+	for i := range bData {
+		bData[i] = rnd.Float64()
 	}
-	return matrix.Product(a, b)
+	b := mat64.NewDense(n, n, bData)
+	var c mat64.Dense
+	c.Mul(a, b)
+	return &c
 }
 
 // mandelbrot
@@ -134,11 +164,15 @@ func mandel(z complex128) int {
 	return maxiter
 }
 
+// mandelperf
+
 func mandelperf() int {
 	mandel_sum := 0
-	for re := -20; re <= 5; re += 1 {
-		for im := -10; im <= 10; im += 1 {
-			m := mandel(complex(float64(re)/10, float64(im)/10))
+	// These loops are constructed as such because mandel is very sensitive to
+	// its input and this avoids very small floating point issues.
+	for re := -20.0; re <= 5; re += 1 {
+		for im := -10.0; im <= 10; im += 1 {
+			m := mandel(complex(re/10, im/10))
 			mandel_sum += m
 		}
 	}
@@ -151,8 +185,8 @@ func pisum() float64 {
 	var sum float64
 	for i := 0; i < 500; i++ {
 		sum = 0.0
-		for k := 1; k <= 10000; k++ {
-			sum += 1.0 / float64(k*k)
+		for k := 1.0; k <= 10000; k += 1 {
+			sum += 1.0 / (k * k)
 		}
 	}
 	return sum
@@ -164,104 +198,116 @@ func print_perf(name string, time float64) {
 
 // run tests
 
-func assert(b bool) {
-	if b != true {
-		panic("assert failed")
+func assert(b *testing.B, t bool) {
+	if t != true {
+		b.Fatal("assert failed")
 	}
 }
 
 func main() {
-	assert(fib(20) == 6765)
-	tmin := float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		t := time.Now()
-		_ = fib(20)
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
-		}
-	}
-	print_perf("fib", tmin)
-
-	tmin = float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		t := time.Now()
-		for k := 0; k < 1000; k++ {
-			n := rand.Uint32()
-			s := fmt.Sprintf("%x", n)
-			m, _ := strconv.ParseUint(s, 16, 32)
-			assert(uint32(m) == n)
-		}
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
-		}
-	}
-	print_perf("parse_int", tmin)
-
-	assert(mandelperf() == 14791)
-	tmin = float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		t := time.Now()
-		_ = mandelperf()
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
+	for _, bm := range benchmarks {
+		seconds, err := runBenchmarkFor(bm.fn)
+		if err != nil {
+			log.Fatalf("%s %s", bm.name, err)
 		}
+		print_perf(bm.name, seconds)
 	}
-	print_perf("mandel", tmin)
+}
 
-	tmin = float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		lst := make([]float64, 5000)
-		for k := 0; k < len(lst); k++ {
-			lst[k] = rand.Float64()
-		}
-		t := time.Now()
-		qsort_kernel(lst, 0, len(lst)-1)
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
-		}
-	}
-	print_perf("quicksort", tmin)
-
-	assert(math.Abs(pisum()-1.644834071848065) < 1e-6)
-	tmin = float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		t := time.Now()
-		pisum()
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
-		}
-	}
-	print_perf("pi_sum", tmin)
-
-	tmin = float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		t := time.Now()
-		c1, c2 := randmatstat(1000)
-		//assert(0.5 < c1) //XXX Why does this assertion fail?
-		assert(c1 < 1.0)
-		//assert(0.5 < c2) //XXX Why does this assertion fail?
-		assert(c2 < 1.0)
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
-		}
-	}
-	print_perf("rand_mat_stat", tmin)
-
-	tmin = float64(math.MaxFloat64)
-	for i := 0; i < 5; i++ {
-		t := time.Now()
-		c := randmatmul(1000)
-		assert(c.Get(0, 0) >= 0)
-		d := float64(time.Since(t).Seconds())
-		if d < tmin {
-			tmin = d
-		}
+func runBenchmarkFor(fn func(*testing.B)) (seconds float64, err error) {
+	bm := testing.Benchmark(fn)
+	if (bm == testing.BenchmarkResult{}) {
+		return 0, errors.New("failed")
 	}
-	print_perf("rand_mat_mul", tmin)
+	return bm.T.Seconds() / float64(bm.N), nil
+}
+
+var benchmarks = []struct {
+	name string
+	fn   func(*testing.B)
+}{
+	{
+		name: "fib",
+		fn: func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				if fib(20) != 6765 {
+					b.Fatal("unexpected value for fib(20)")
+				}
+			}
+		},
+	},
+
+	{
+		name: "parse_int",
+		fn: func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				for k := 0; k < 1000; k++ {
+					n := rnd.Uint32()
+					m, _ := strconv.ParseUint(strconv.FormatUint(uint64(n), 16), 16, 32)
+					if uint32(m) != n {
+						b.Fatal("incorrect value for m")
+					}
+				}
+			}
+		},
+	},
+
+	{
+		name: "mandel",
+		fn: func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				if mandelperf() != 14791 {
+					b.Fatal("unexpected value for mandelperf")
+				}
+			}
+		},
+	},
+
+	{
+		name: "quicksort",
+		fn: func(b *testing.B) {
+			lst := make([]float64, 5000)
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				for k := range lst {
+					lst[k] = rnd.Float64()
+				}
+				qsort_kernel(lst, 0, len(lst)-1)
+			}
+		},
+	},
+
+	{
+		name: "pi_sum",
+		fn: func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				if math.Abs(pisum()-1.644834071848065) >= 1e-6 {
+					b.Fatal("pi_sum out of range")
+				}
+			}
+		},
+	},
+
+	{
+		name: "rand_mat_stat",
+		fn: func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				c1, c2 := randmatstat(1000)
+				assert(b, 0.5 < c1)
+				assert(b, c1 < 1.0)
+				assert(b, 0.5 < c2)
+				assert(b, c2 < 1.0)
+			}
+		},
+	},
+
+	{
+		name: "rand_mat_mul",
+		fn: func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				c := randmatmul(1000)
+				assert(b, c.At(0, 0) >= 0)
+			}
+		},
+	},
 }
diff --git a/test/perf/micro/perf.lua b/test/perf/micro/perf.lua
index 5e54048002d65..31ba2644a115a 100644
--- a/test/perf/micro/perf.lua
+++ b/test/perf/micro/perf.lua
@@ -1,49 +1,50 @@
 
-local ffi = require 'ffi'
-local bit = require 'bit'
-local gsl = require 'gsl'
+if jit.arch ~= 'x64' then
+    print('WARNING: please use BIT=64 for optimal OpenBLAS performance')
+end
+
+local ffi     = require 'ffi'
+local bit     = require 'bit'
+local time    = require 'time'
+local alg     = require 'sci.alg'
+local prng    = require 'sci.prng'
+local stat    = require 'sci.stat'
+local dist    = require 'sci.dist'
+local complex = require 'sci.complex'
 
-local min, max, abs, sqrt, random, floor = math.min, math.max, math.abs, math.sqrt, math.random, math.floor
+local min, sqrt, random, abs = math.min, math.sqrt, math.random, math.abs
 local cabs = complex.abs
 local rshift = bit.rshift
 local format = string.format
+local nowutc = time.nowutc
+local rng = prng.std()
+local vec, mat, join = alg.vec, alg.mat, alg.join
+local sum, trace = alg.sum, alg.trace
+local var, mean = stat.var, stat.mean
 
-local gettime
-do
-    ffi.cdef[[
-         struct timeval {
-            long tv_sec;
-            long tv_usec;
-         };
-
-         int gettimeofday(struct timeval * tp, void *tzp);
-       ]]
-
-    local tv = ffi.new('struct timeval[1]')
-
-    gettime = function()
-      ffi.C.gettimeofday(tv, nil)
-      return tv[0].tv_sec, tv[0].tv_usec
-    end
-end
-
--- return the elapsed time in ms
+--------------------------------------------------------------------------------
 local function elapsed(f)
-    local s0, us0 = gettime()
-    f()
-    local s1, us1 = gettime()
-    return tonumber(s1 - s0) * 1000 + tonumber(us1 - us0) / 1000
-end
-
-local function timeit(f, name)
-    local t = nil
-    for k = 1, 5 do
-        local tx = elapsed(f)
-        t = t and min(t, tx) or tx
+    local t0 = nowutc()
+    local val1, val2 = f()
+    local t1 = nowutc()
+    return (t1 - t0):tomilliseconds(), val1, val2
+end
+
+local function timeit(f, name, check)
+    local t, k, s = 1/0, 0, nowutc()
+    while true do
+        k = k + 1
+        local tx, val1, val2 = elapsed(f)
+        t = min(t, tx)
+        if check then 
+            check(val1, val2)
+        end
+        if k > 5 and (nowutc() - s):toseconds() >= 2 then break end
     end
-    print(format("lua,%s,%g", name, t))
+    io.write(format('lua,%s,%g\n', name, t))
 end
 
+--------------------------------------------------------------------------------
 local function fib(n)
     if n < 2 then
         return n
@@ -52,23 +53,21 @@ local function fib(n)
     end
 end
 
-assert(fib(20) == 6765)
-timeit(|| fib(20), "fib")
+timeit(function() return fib(20) end, 'fib', function(x) assert(x == 6765) end)
 
 local function parseint()
-    local r = rng.new('rand')
     local lmt = 2^32 - 1
     local n, m
     for i = 1, 1000 do
-        n = r:getint(lmt)
+        n = random(lmt) -- Between 0 and 2^32 - 1, i.e. uint32_t.
         local s = format('0x%x', tonumber(n))
         m = tonumber(s)
     end
-    assert(m == n)
-    return n
+    assert(n == m) -- Done here to be even with Julia benchmark.
+    return n, m
 end
 
-timeit(parseint, "parse_int")
+timeit(parseint, 'parse_int')
 
 local function mandel(z)
     local c = z
@@ -81,28 +80,18 @@ local function mandel(z)
     end
     return maxiter
 end
-function mandelperf()
-    local a, re, im, z
-    a = ffi.new("double[?]", 546)
-    r = 0
-    for r = -20, 5 do
-        re = r*0.1
-        for i=-10, 10 do
-            im = i*0.1
-            a[r*21+i+430] = mandel(re + 1i * im)
+local function mandelperf()
+    local a = mat(26, 21)
+    for r=1,26 do -- Lua's for i=l,u,c doesn't match Julia's for i=l:c:u.
+        for c=1,21 do
+            local re, im = (r - 21)*0.1, (c - 11)*0.1
+            a[{r, c}] = mandel(re + im*1i)
         end
     end
     return a
 end
 
-do
-    local a = mandelperf()
-    local sum = 0
-    for i = 0, 545 do sum = sum + a[i] end
-    assert(sum == 14791)
-end
-
-timeit(mandelperf, "mandel")
+timeit(mandelperf, 'mandel', function(a) assert(sum(a) == 14791) end)
 
 local function qsort(a, lo, hi)
     local i, j = lo, hi
@@ -124,122 +113,84 @@ end
 
 local function sortperf()
     local n = 5000
-    local r = rng.new('rand')
-    local v = iter.ilist(|| r:get(), n)
-    qsort(v, 1, n)
+    local v = ffi.new('double[?]', n+1)
+    for i=1,n do
+        v[i] = rng:sample()
+    end
+    return qsort(v, 1, n)
 end
 
-
+timeit(sortperf, 'quicksort', function(x)
+    for i=2,5000 do
+        assert(x[i-1] <= x[i])
+    end
+end
+)
 
 local function pisum()
-    local sum
+    local s
     for j = 1, 500 do
-        sum = 0
+        s = 0
         for k = 1, 10000 do
-            sum = sum + 1 / (k*k)
+            s = s + 1 / (k*k)
         end
     end
-    return sum
+    return s
 end
 
-local function stat(v)
-    local p, q = 0, 0
-    local n = #v
-    for k = 1, n do
-        local x = v[k]
-        p = p + x
-        q = q + x*x
-    end
-    return sqrt((n*(n*q-p*p))/((n-1)*p*p))
-end
-
-local function randmatstat(t)
-    local n = 5
-    local A = iter.ilist(|| matrix.alloc(n, n), 4)
-
-    local P = matrix.alloc(n, 4*n)
-    local Q = matrix.alloc(2*n, 2*n)
-
-    local PtP1 = matrix.alloc(4*n, 4*n)
-    local PtP2 = matrix.alloc(4*n, 4*n)
-    local QtQ1 = matrix.alloc(2*n, 2*n)
-    local QtQ2 = matrix.alloc(2*n, 2*n)
-
-    local get, set = A[1].get, A[1].set
+timeit(pisum, 'pi_sum', function(x) 
+    assert(abs(x - 1.644834071848065) < 1e-12)
+end)
 
-    local r = rng.new('rand')
-    local randn = || rnd.gaussian(r, 1)
-
-    local function hstackf(i, j)
-        local k, r = math.divmod(j - 1, n)
-        return get(A[k + 1], i, r + 1)
+local function rand(r, c)
+    local x = mat(r, c)
+    for i=1,#x do 
+        x[i] = rng:sample()
     end
+    return x
+end
 
-    local function vstackf(i, j)
-        local ik, ir = math.divmod(i - 1, n)
-        local jk, jr = math.divmod(j - 1, n)
-        return get(A[2*ik + jk + 1], ir + 1, jr + 1)
+local function randn(r, c)
+    local x = mat(r, c)
+    for i=1,#x do 
+        x[i] = dist.normal(0, 1):sample(rng) 
     end
+    return x
+end
 
-    local Tr, NT = gsl.CblasTrans, gsl.CblasNoTrans
-
-    local v, w = {}, {}
-
-    for i = 1, t do
-        matrix.fset(A[1], randn)
-        matrix.fset(A[2], randn)
-        matrix.fset(A[3], randn)
-        matrix.fset(A[4], randn)
-
-        matrix.fset(P, hstackf)
-        matrix.fset(Q, vstackf)
-
-        gsl.gsl_blas_dgemm(Tr, NT, 1.0, P, P, 0.0, PtP1)
-        gsl.gsl_blas_dgemm(NT, NT, 1.0, PtP1, PtP1, 0.0, PtP2)
-        gsl.gsl_blas_dgemm(NT, NT, 1.0, PtP2, PtP2, 0.0, PtP1)
-
-        local vi = 0
-        for j = 1, n do vi = vi + get(PtP1, j, j) end
-        v[i] = vi
-
-        gsl.gsl_blas_dgemm(Tr, NT, 1.0, Q, Q, 0.0, QtQ1)
-        gsl.gsl_blas_dgemm(NT, NT, 1.0, QtQ1, QtQ1, 0.0, QtQ2)
-        gsl.gsl_blas_dgemm(NT, NT, 1.0, QtQ2, QtQ2, 0.0, QtQ1)
-
-        local wi = 0
-        for j = 1, 2*n do wi = wi + get(QtQ1, j, j) end
-        w[i] = wi
+local function randmatstat(t)
+    local n = 5
+    local v, w = vec(t), vec(t)
+    for i=1,t do
+        local a, b, c, d = randn(n, n), randn(n, n), randn(n, n), randn(n, n)
+        local P = join(a..b..c..d)
+        local Q = join(a..b, c..d)
+        v[i] = trace((P[]`**P[])^^4)
+        w[i] = trace((Q[]`**Q[])^^4)
     end
-
-    return stat(v), stat(w)
+    return sqrt(var(v))/mean(v), sqrt(var(w))/mean(w)
 end
 
-do
-    local s1, s2 = randmatstat(1000)
-    assert( 0.5 < s1 and s1 < 1.0
-        and 0.5 < s2 and s2 < 1.0 )
-end
+timeit(function() return randmatstat(1000) end, 'rand_mat_stat', 
+    function(s1, s2)
+        assert( 0.5 < s1 and s1 < 1.0 and 0.5 < s2 and s2 < 1.0 )
+    end)
 
 local function randmatmult(n)
-    local r = rng.new('rand')
-    --local rand = || r:get()
-    local rand = random
-    local a = matrix.new(n, n, rand)
-    local b = matrix.new(n, n, rand)
-    return a*b
-end
-
-local function printfd(n)
-    local f = io.open("/dev/null","w")
-    for i = 1, n do
-        f:write(format("%d %d\n", i, i+1))
-    end
-    f:close()
+    local a, b = rand(n, n), rand(n, n)
+    return a[]**b[]
 end
 
+timeit(function() return randmatmult(1000) end, 'rand_mat_mul')
 
-timeit(sortperf, "quicksort")
-timeit(pisum, "pi_sum")
-timeit(|| randmatstat(1000), "rand_mat_stat")
-timeit(|| randmatmult(1000), "rand_mat_mul")
--- timeit(|| printfd(100000), "printfd")
+if jit.os ~= 'Windows' then
+    local function printfd(n)
+        local f = io.open('/dev/null','w')
+        for i = 1, n do
+            f:write(format('%d %d\n', i, i+1))
+        end
+        f:close()
+    end
+
+    timeit(function() return printfd(100000) end, 'printfd')
+end
diff --git a/test/perf/micro/perf.m b/test/perf/micro/perf.m
index 6c6a846f7b931..398711f104ea9 100644
--- a/test/perf/micro/perf.m
+++ b/test/perf/micro/perf.m
@@ -6,9 +6,6 @@
 function perf()
 
 	warning off;
-	if exist('OCTAVE_VERSION') == 0
-    	maxNumCompThreads(1);
-	end
 	
 	f = fib(20);
 	assert(f == 6765)
@@ -95,8 +92,8 @@ function timeit(name, func, varargin)
 function n = parseintperf(t)
     for i = 1:t
         n = randi([0,2^32-1],1,'uint32');
-        s = dec2hex(n);
-        m = hex2dec(s);
+        s = sprintf('%08X',n);
+        m = sscanf(s,'%X');
         assert(m == n);
     end
 end
@@ -122,14 +119,14 @@ function timeit(name, func, varargin)
 end
 
 function M = mandelperf(ignore)
-  M = zeros(length(-2.0:.1:0.5), length(-1:.1:1));
-  count = 1;
-  for r = -2:0.1:0.5
-    for i = -1:.1:1
-      M(count) = mandel(complex(r,i));
-      count = count + 1;
+    x=-2.0:.1:0.5;
+    y=-1:.1:1;
+    M=zeros(length(y),length(x));
+    for r=1:size(M,1) 
+        for c=1:size(M,2)
+           M(r,c) = mandel(x(c)+y(r)*i);
+        end
     end
-  end
 end
 
 %% numeric vector quicksort %%
diff --git a/test/perf/micro/scala/.gitignore b/test/perf/micro/scala/.gitignore
new file mode 100644
index 0000000000000..c58d83b318909
--- /dev/null
+++ b/test/perf/micro/scala/.gitignore
@@ -0,0 +1,17 @@
+*.class
+*.log
+
+# sbt specific
+.cache
+.history
+.lib/
+dist/*
+target/
+lib_managed/
+src_managed/
+project/boot/
+project/plugins/project/
+
+# Scala-IDE specific
+.scala_dependencies
+.worksheet
diff --git a/test/perf/micro/scala/build.sbt b/test/perf/micro/scala/build.sbt
new file mode 100644
index 0000000000000..c98322a85653e
--- /dev/null
+++ b/test/perf/micro/scala/build.sbt
@@ -0,0 +1,18 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+libraryDependencies ++= Seq(
+    "org.scalanlp" %% "breeze" % "0.10",
+    "org.scalanlp" %% "breeze-natives" % "0.10"
+)
+
+resolvers ++= Seq(
+    "Sonatype Releases" at "https://oss.sonatype.org/content/repositories/releases/"
+)
+
+scalaVersion := "2.11.1"
+
+showSuccess := false
+
+onLoadMessage := ""
+
+logLevel := Level.Warn
diff --git a/test/perf/micro/scala/src/main/scala/perf.scala b/test/perf/micro/scala/src/main/scala/perf.scala
new file mode 100644
index 0000000000000..73fd84fee4296
--- /dev/null
+++ b/test/perf/micro/scala/src/main/scala/perf.scala
@@ -0,0 +1,274 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+
+import scala.util._
+import java.io._
+import breeze.linalg._
+import breeze.numerics._
+import breeze.stats._
+import breeze.math._
+//import com.github.fommil.netlib.{BLAS}
+
+object PerfBreeze {
+  final val NITER = 5
+
+  // print results appropriately. times are in milliseconds
+  def print_perf(name:String, t:Double) = {
+    printf("scala,%s,%.9f\n", name, t/1e6)
+  }
+
+  // time fib
+  def fib(n:Int):Int = {
+    if (n < 2) n else fib(n-1) + fib(n-2)
+  }
+
+  def time_fib() = {
+    assert(fib(20) == 6765)
+    var tmin = Long.MaxValue
+    var f = 0
+
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      for(j <- 1 to 1000) {
+        f += fib(20)
+      }
+      val t = System.nanoTime() - t1
+      if(t < tmin) tmin = t
+    }
+
+    tmin / 1000.0
+  }
+
+  // time parseint
+  def time_parseint() = {
+    val generator = scala.util.Random
+    var tmin = Long.MaxValue
+
+    for(i <- 1 to NITER) {
+      var rand:Int = 0
+      var rands:String = "0"
+      var parsed:Int = 0
+      val t1 = System.nanoTime()
+      for(j <- 1 to 1000) {
+        rand = generator.nextInt()
+        rands = if(rand < 0) "-" + abs(rand).toHexString else rand.toHexString
+        parsed = Integer.parseInt(rands, 16)
+      }
+      val t = System.nanoTime() - t1
+      assert(rand == parsed)
+      if(t < tmin) tmin = t
+    }
+    tmin / 1000.0
+  }
+
+  // time mandel
+  def mandel(zin:Complex):Int = {
+    val c = zin
+    var z = zin
+    val maxiter = 80
+    for(n <- 0 to maxiter) {
+      if(z.abs > 2) return n
+      z = c + (z * z)
+    }
+    maxiter
+  }
+
+  def mandelperf() = {
+    for(re <- -20 to 5; im <- -10 to 10) yield mandel(re/10.0 + i * im/10.0)
+  }
+
+  def time_mandel() = {
+    var mandel_sum = 0
+    var mandel_sum2 = 0
+    var tmin = Long.MaxValue
+
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      for(j <- 1 to 100) {
+        val mandel_arr = mandelperf()
+        if(j == 1) {
+          mandel_sum = sum(mandel_arr)
+          mandel_sum2 += mandel_sum
+        }
+      }
+      val t = System.nanoTime() - t1
+      if(t < tmin) tmin = t
+    }
+    assert(mandel_sum == 14791)
+    assert(mandel_sum2 == mandel_sum * NITER)
+    tmin / 100.0
+  }
+
+  // time quicksort
+  def quicksort(a:Array[Double], lo:Int, hi:Int):Array[Double] = {
+    var i, l = lo
+    var j = hi
+
+    def _swap(i:Int, j:Int) = {
+      val tmp = a(i)
+      a(i) = a(j)
+      a(j) = tmp
+    }
+
+    while(i < hi) {
+      val pivot = a((l+hi)>>>1)
+      while(i <= j) {
+        while(a(i) < pivot) i += 1
+        while(a(j) > pivot) j -= 1
+        if(i <= j) {
+          _swap(i, j)
+          i += 1
+          j -= 1
+        }
+      }
+      if(l < j) quicksort(a, l, j)
+      l = j
+      j = hi
+    }
+    a
+  }
+
+  /*
+  def checksorted(a:Array[Double]):Boolean = {
+    for(i <- 0 to a.length-2) {
+      assert(a(i) < a(i+1))
+    }
+    true
+  }
+  */
+
+  def time_quicksort() = {
+    var tmin = Long.MaxValue
+
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      for(j <- 1 to 1000) {
+        val A = DenseVector.rand[Double](5000)
+        quicksort(A.data, 0, 4999)
+      }
+      val t = System.nanoTime() - t1
+      if(t < tmin) tmin = t
+    }
+    tmin / 1000.0
+  }
+
+  // time pisum
+  def pisum() = {
+    var sum = 0.0
+    for(j <- 1 to 500) {
+      sum = 0.0
+      for(k <- 1 to 10000) {
+        sum += 1.0/(k*k)
+      }
+    }
+    sum
+  }
+
+  def time_pisum() = {
+    var tmin = Long.MaxValue
+    var pi = 0:Double
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      pi = pisum()
+      val t = System.nanoTime() - t1
+      if(t < tmin) tmin = t
+      assert(abs(pi-1.644834071848065) < 1e-12)
+    }
+    tmin
+  }
+
+  // time printfd
+  def printfd(n:Int) = {
+    var stream = None: Option[PrintStream]
+    try {
+      stream = Some(new PrintStream(new BufferedOutputStream(new FileOutputStream("/dev/null"))))
+      val valid_stream = stream.get
+      for (i <- 1 to n) {
+        valid_stream.printf(i + " " + i)
+      }
+    } catch {
+      case e: Exception => println("Exception caught: " + e)
+    } finally {
+      if(stream.isDefined) stream.get.close()
+    }
+  }
+
+  def time_printfd() = {
+    var tmin = Long.MaxValue
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      printfd(100000)
+      val t = System.nanoTime() - t1
+      if(t < tmin) tmin = t
+    }
+    tmin
+  }
+
+  // random matrix statistics
+  def randmatstat(t:Int):(Double,Double) = {
+    val n = 5
+    val v = DenseVector.zeros[Double](t)
+    val w = DenseVector.zeros[Double](t)
+
+    val g = breeze.stats.distributions.Gaussian(0, 1)
+    for(i <- 0 to t-1) {
+      val a = DenseMatrix.rand(n, n, g)
+      val b = DenseMatrix.rand(n, n, g)
+      val c = DenseMatrix.rand(n, n, g)
+      val d = DenseMatrix.rand(n, n, g)
+      val P = DenseMatrix.horzcat(a, b, c, d)
+      val Q = DenseMatrix.vertcat(DenseMatrix.horzcat(a, b), DenseMatrix.horzcat(c, d))
+      val V = P.t * P
+      val W = Q.t * Q
+
+      v(i) = trace(V * V * V * V)
+      w(i) = trace(W * W * W * W)
+    }
+    (stddev(v)/mean(v), stddev(w)/mean(w))
+  }
+
+  def time_randmatstat() = {
+    var tmin = Long.MaxValue
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      val (s1, s2) = randmatstat(1000)
+      val t = System.nanoTime() - t1
+      assert(0.5 < s1 && s1 < 1.0 && 0.5 < s2 && s2 < 1.0)
+
+      if(t < tmin) tmin = t
+    }
+    tmin
+  }
+
+  // random matrix multiplication
+  def randmatmul(t:Int):DenseMatrix[Double] = {
+    val m1 = randomDouble((t, t))
+    val m2 = randomDouble((t, t))
+    m1 * m2
+  }
+
+  def time_randmatmul() = {
+    var tmin = Long.MaxValue
+    for(i <- 1 to NITER) {
+      val t1 = System.nanoTime()
+      val m = randmatmul(1000)
+      val t = System.nanoTime() - t1
+      assert(0 <= m(0,0))
+
+      if(t < tmin) tmin = t
+    }
+    tmin
+  }
+
+
+  def main(args: Array[String]) = {
+    //println("BLAS: " + BLAS.getInstance().getClass().getName())
+    print_perf("fib", time_fib())
+    print_perf("parse_int", time_parseint())
+    print_perf("mandel", time_mandel())
+    print_perf("quicksort", time_quicksort())
+    print_perf("pi_sum", time_pisum())
+    print_perf("rand_mat_stat", time_randmatstat())
+    print_perf("rand_mat_mul", time_randmatmul())
+    print_perf("printfd", time_printfd())
+  }
+}
diff --git a/test/perf/perfutil.jl b/test/perf/perfutil.jl
index 1c9123cc10ab1..1974c337c96b2 100644
--- a/test/perf/perfutil.jl
+++ b/test/perf/perfutil.jl
@@ -21,7 +21,7 @@ if codespeed
     csdata["project"] = "Julia"
     csdata["branch"] = Base.GIT_VERSION_INFO.branch
     csdata["executable"] = ENV["JULIA_FLAVOR"]
-    csdata["environment"] = chomp(readall(`hostname`))
+    csdata["environment"] = chomp(readstring(`hostname`))
     csdata["result_date"] = join( split(Base.GIT_VERSION_INFO.date_string)[1:2], " " )    #Cut the timezone out
 end
 
diff --git a/test/perf/report.jl b/test/perf/report.jl
index 49750ea06dd94..34513c53d0a8a 100644
--- a/test/perf/report.jl
+++ b/test/perf/report.jl
@@ -2,7 +2,7 @@
 
 using HTTPClient.HTTPC
 
-env_name = chomp(readall(`hostname`))
+env_name = chomp(readstring(`hostname`))
 commit = Base.GIT_VERSION_INFO.commit
 flavor = ENV["JULIA_FLAVOR"]
 json = "{\"env\": \"$env_name\", \"blas\":\"$flavor\", \"commit\":\"$commit\"}"
diff --git a/test/perf/shootout/Makefile b/test/perf/shootout/Makefile
index 622e92708e0b9..cbdc6cd30374e 100644
--- a/test/perf/shootout/Makefile
+++ b/test/perf/shootout/Makefile
@@ -1,4 +1,4 @@
-JULIAHOME = $(abspath ../../..)
+JULIAHOME := $(abspath ../../..)
 include ../../../Make.inc
 
 SHOOTOUTFILES = knucleotide-input.txt regexdna-input.txt revcomp-input.txt fasta-output.txt mandelbrot-output.txt nbody-output.txt fannkuchredux-output.txt pidigits-output.txt knucleotide-output.txt revcomp-output.txt spectralnorm-output.txt regexdna-output.txt meteor-output.txt
diff --git a/test/perf/shootout/k_nucleotide.jl b/test/perf/shootout/k_nucleotide.jl
index 79535e4c07f1d..e81a3e44e2401 100644
--- a/test/perf/shootout/k_nucleotide.jl
+++ b/test/perf/shootout/k_nucleotide.jl
@@ -69,7 +69,7 @@ function k_nucleotide(infile="knucleotide-input.txt")
             break
         end
     end
-    data = collect(readall(input))
+    data = collect(readstring(input))
     # delete the newlines and convert to upper case
     i, j = 1, 1
     while i <= length(data)
diff --git a/test/perf/shootout/regex_dna.jl b/test/perf/shootout/regex_dna.jl
index 0c3c24bc6663c..348c14187ccd5 100644
--- a/test/perf/shootout/regex_dna.jl
+++ b/test/perf/shootout/regex_dna.jl
@@ -33,7 +33,7 @@ const subs = [
 ]
 
 function regex_dna(infile="regexdna-input.txt")
-    seq = readall(infile)
+    seq = readstring(infile)
     l1 = length(seq)
 
     seq = replace(seq, r">.*\n|\n", "")
diff --git a/test/perf/sparse/getindex_skinny.jl b/test/perf/sparse/getindex_skinny.jl
new file mode 100644
index 0000000000000..27059989f2263
--- /dev/null
+++ b/test/perf/sparse/getindex_skinny.jl
@@ -0,0 +1,41 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# Test getindex for skinny sparse matrix
+function sparse_getindex_skinny_perf()
+
+    seed = 1
+    srand(seed)
+
+    # matsize = (size(A,1), nnz(A))
+    matsize = [
+        (2^12,1  ),
+        (2^12,2^6),
+        (2^18,1  ),
+        (2^18,2^9)]
+    # indsize = (length(I), number of repetitions)
+    indsize = [
+        (1,   2^12),
+        (2^8, 2^8 ),
+        (2^16,2^4 )]
+
+    c = 0 # counter
+    for (m,nz) in matsize
+        A = sprand(m,1,nz/m)
+        for (n,p) in indsize
+            c += 1
+            I = rand(1:m,n)
+            @timeit indexing(A,I,p) "sparse_getindex_skinny$c" ""
+        end
+    end
+
+end
+
+function indexing(A,I,p)
+
+    J = [1]
+    for k = 1:p
+        A[I,J]
+    end
+    nothing
+
+end
diff --git a/test/perf/sparse/perf.jl b/test/perf/sparse/perf.jl
index 171059385749c..5de1774ad565a 100644
--- a/test/perf/sparse/perf.jl
+++ b/test/perf/sparse/perf.jl
@@ -6,5 +6,8 @@ include("../perfutil.jl")
 include("getindex.jl")
 sparse_getindex_perf()
 
+include("getindex_skinny.jl")
+sparse_getindex_skinny_perf()
+
 include("fem.jl")
 fem_perf()
diff --git a/test/perf/spell/perf.jl b/test/perf/spell/perf.jl
index b65fc9352e906..e6ee7bb4bf373 100644
--- a/test/perf/spell/perf.jl
+++ b/test/perf/spell/perf.jl
@@ -28,7 +28,7 @@ end
 if !isfile("big.txt")
     download("http://norvig.com/big.txt", "big.txt")
 end
-const NWORDS = train(words(readall("big.txt")))
+const NWORDS = train(words(readstring("big.txt")))
 
 const alphabet = "abcdefghijklmnopqrstuvwxyz"
 
diff --git a/test/perf/threads/laplace3d/README b/test/perf/threads/laplace3d/README
new file mode 100644
index 0000000000000..67553fc52ecae
--- /dev/null
+++ b/test/perf/threads/laplace3d/README
@@ -0,0 +1,14 @@
+Laplace 3D
+
+This is a simple 7 point stencil on a 3D grid. It is bandwidth-bound.
+The C version gets 60 GB/s on a 2 socket SNB-EP. The code doesn't
+handle corner cases at the grid edges, so each dimension must be 4n+2
+for SSE or 8n+2 for AVX.
+
+E.g.:
+
+$ ./laplace3d 258 258 258 1000 avx 0
+
+The Matlab/Octave versions are enough slower than the C and Julia
+versions that they use only 1/10 the iterations.
+
diff --git a/test/perf/threads/laplace3d/laplace3d.c b/test/perf/threads/laplace3d/laplace3d.c
new file mode 100644
index 0000000000000..963b9334505f1
--- /dev/null
+++ b/test/perf/threads/laplace3d/laplace3d.c
@@ -0,0 +1,370 @@
+// This file is a part of Julia. License is MIT: http://julialang.org/license
+// GCC command line: gcc -fopenmp -mavx2 laplace3d.c -o laplace3d
+
+/* Laplace 3D
+
+   orig:        simple serial version
+   naive:       simple parallelized version
+   auto:        some ninja knowledge, using icc directives
+   sse/avx:     ninja-optimized
+
+   Requires Sandy Bridge and up.
+
+   Note that the SSE/AVX versions do not handle boundary conditions
+   and thus each dimension must be 4n+2/8n+2. Try 258x258x258.
+
+   2014.08.06   anand.deshpande         Initial code.
+   2014.08.06   dhiraj.kalamkar         Padding and streaming stores.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <math.h>
+#include <unistd.h>
+#include <immintrin.h>
+#include <omp.h>
+
+#if defined(__i386__)
+static inline uint64_t rdtsc(void)
+{
+    uint64_t x;
+    __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
+    return x;
+}
+#elif defined(__x86_64__)
+static inline uint64_t rdtsc(void)
+{
+    unsigned hi, lo;
+    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+    return ((uint64_t)lo) | (((uint64_t)hi) << 32);
+}
+#elif defined(_COMPILER_MICROSOFT_)
+#include <intrin.h>
+static inline uint64_t rdtsc(void)
+{
+    return __rdtsc();
+}
+#endif
+
+void l3d_naive(int nx, int padded_nx, int ny, int nz, float *u1, float *u2);
+void l3d_auto(int nx, int padded_nx, int ny, int nz, float *u1, float *u2);
+void l3d_sse(int nx, int padded_nx, int ny, int nz, float *u1, float *u2);
+void l3d_avx(int nx, int padded_nx, int ny, int nz, float *u1, float *u2);
+void l3d_orig(int nx, int ny, int nz, float *u1, float *u2);
+
+double cpughz()
+{
+    uint64_t t0 = rdtsc();
+    sleep(1);
+    uint64_t onesec = rdtsc() - t0;
+    return onesec*1.0/1e9;
+}
+
+int main(int argc, char **argv)
+{
+    int nx, padded_nx, ny, nz, iters, i, j, k, ind, p_ind, verify,
+        nthreads, pad_size;
+    float *u1, *u1_p, *u1_orig, *u2, *u2_p, *u2_orig, *foo,
+        error_tol = 0.00001;
+    double ghz;
+    void (*l3d)(int nx, int padded_nx, int ny, int nz,
+        float *u1, float *u2);
+
+    if (argc != 7) {
+        fprintf(stderr, "Usage:\n"
+            "  laplace3d <nx> <ny> <nz> <#iters> <naive|auto|sse|avx> "
+            "<verify?>\n");
+        exit(-1);
+    }
+
+    nx = strtol(argv[1], NULL, 10);
+    ny = strtol(argv[2], NULL, 10);
+    nz = strtol(argv[3], NULL, 10);
+
+    padded_nx = ((nx + 0x7) & (~0x7));
+    iters = strtol(argv[4], NULL, 10);
+
+    if (strncasecmp(argv[5], "naive", 5) == 0)
+        l3d = l3d_naive;
+    else if (strncasecmp(argv[5], "auto", 4) == 0)
+        l3d = l3d_auto;
+    else if (strncasecmp(argv[5], "sse", 3) == 0)
+        l3d = l3d_sse;
+    else if (strncasecmp(argv[5], "avx", 3) == 0)
+        l3d = l3d_avx;
+    else {
+        fprintf(stderr, "don't recognize %s. naive, auto, sse, or avx?\n",
+                argv[5]);
+        exit(-1);
+    }
+
+    verify = strtol(argv[6], NULL, 10);
+
+    ghz = cpughz();
+    nthreads = omp_get_max_threads();
+    printf("machine speed is %g GHz, using %d threads\n", ghz, nthreads);
+
+    printf("laplace3d: %d iterations on %dx%dx%d grid, "
+           "verification is %s\n",
+           iters, nx, ny, nz, verify ? "on" : "off");
+
+    /* pad for aligned access; non-naive only */
+    if (strncasecmp(argv[5], "naive", 5) != 0) {
+        pad_size = (((1 + padded_nx + padded_nx * ny) + 0xF) & (~0xF)) -
+                (1 + padded_nx + padded_nx * ny);
+        printf("using padded_nx = %d, pad_size = %d\n",
+               padded_nx, pad_size);
+
+        u1_p = (float *)_mm_malloc(sizeof (float) *
+                (padded_nx * ny * nz + pad_size), 64);
+        u2_p = (float *)_mm_malloc(sizeof (float) *
+                (padded_nx * ny * nz + pad_size), 64);
+        u1 = u1_p + pad_size;
+        u2 = u2_p + pad_size;
+    }
+    else {
+        u1_p = (float *)_mm_malloc(sizeof (float) * (nx * ny * nz), 64);
+        u2_p = (float *)_mm_malloc(sizeof (float) * (nx * ny * nz), 64);
+        u1 = u1_p;
+        u2 = u2_p;
+        padded_nx = nx;
+    }
+    u1_orig = (float *)_mm_malloc(sizeof (float) * nx * ny * nz, 64);
+    u2_orig = (float *)_mm_malloc(sizeof (float) * nx * ny * nz, 64);
+
+    // initialize
+    #pragma omp parallel for private(k,j,i,ind,p_ind)
+    for (k = 0;  k < nz;  ++k) {
+        for (j = 0;  j < ny;  ++j) {
+            for (i = 0;  i < nx;  ++i) {
+                ind = i + j*nx + k*nx*ny;
+                p_ind = i + j*padded_nx + k*padded_nx*ny;
+
+                if (i == 0  ||  i == nx - 1
+                        ||  j == 0  ||  j == ny - 1
+                        ||  k == 0  ||  k == nz - 1) {
+                    // Dirichlet b.c.'s
+                    u1[p_ind] = u1_orig[ind] = u2[p_ind] = 1.0f;
+                }
+                else {
+                    u1[p_ind] = u1_orig[ind] = u2[p_ind] = 0.0f;
+                }
+            }
+        }
+    }
+
+    // run optimized version
+    uint64_t t0 = rdtsc();
+    for (i = 0;  i < iters;  ++i) {
+        l3d(nx, padded_nx, ny, nz, u1, u2);
+        foo = u1; u1 = u2; u2 = foo;
+    }
+    uint64_t gold = rdtsc() - t0;
+    double elapsed = gold / (ghz * 1e9);
+
+    double grid_size = nx * ny * nz;
+    double gflops = grid_size * iters * 6.0 / 1e9;
+    double gflops_sec = gflops / elapsed;
+
+    double traffic = grid_size * iters * 4 * 2.0 / 1e9;
+    double bw_realized = traffic / elapsed;
+
+    printf("laplace3d completed in %.4lf seconds\n", elapsed);
+    printf("GFLOPs/sec: %.1f\n", gflops_sec);
+    printf("BW realized: %.1f\n", bw_realized);
+
+    if (verify) {
+        // run serial version for verification
+        uint64_t st0 = rdtsc();
+        for (i = 0;  i < iters;  ++i) {
+            l3d_orig(nx, ny, nz, u1_orig, u2_orig);
+            foo = u1_orig; u1_orig = u2_orig; u2_orig = foo;
+        }
+        uint64_t ser = rdtsc() - st0;
+        elapsed = ser / (ghz * 1e9);
+        gflops_sec = gflops / elapsed;
+        bw_realized = traffic / elapsed;
+
+        printf("laplace3d_orig completed in %.2lf seconds\n", elapsed);
+        printf("GFLOPs/sec: %.1f\n", gflops_sec);
+        printf("BW realized: %.1f\n", bw_realized);
+
+        // verify
+        for (k = 0;  k < nz;  ++k) {
+            for (j = 0;  j < ny;  ++j) {
+                for (i = 0;  i < nx;  ++i) {
+                    ind = i + j*nx + k*nx*ny;
+                    p_ind = i + j*padded_nx + k*padded_nx*ny;
+
+                    if (fabs(u1[p_ind] - u1_orig[ind]) > error_tol) {
+                        printf("ERROR %f - %f [%d, %d, %d]\n",
+                               u1[p_ind], u1_orig[ind], i, j, k);
+                        goto done;
+                    }
+                }
+            }
+        }
+        printf("verified, no error\n");
+    }
+
+    done:
+    _mm_free(u1_p);
+    _mm_free(u2_p);
+    _mm_free(u1_orig);
+    _mm_free(u2_orig);
+
+    return 0;
+}
+
+void l3d_naive(int nx, int padded_nx, int ny, int nz, float *u1, float *u2)
+{
+    int i, j, k, ind;
+    const float sixth = 1.0f/6.0f;
+
+    /* compute on the grid */
+    #pragma omp parallel for private(i,j,k,ind)
+    for (k = 1;  k < nz-1;  ++k) {
+        for (j = 1;  j < ny-1;  ++j) {
+            #pragma ivdep
+            for (i = 1;  i < nx-1;  ++i) {
+                ind = i + j*padded_nx + k*padded_nx*ny;
+                u2[ind] =
+                   ( u1[ind-1    ]        + u1[ind+1    ]
+                   + u1[ind-padded_nx   ] + u1[ind+padded_nx   ]
+                   + u1[ind-padded_nx*ny] + u1[ind+padded_nx*ny] ) * sixth;
+            }
+        }
+    }
+}
+
+void l3d_auto(int nx, int padded_nx, int ny, int nz, float *u1, float *u2)
+{
+    int i, j, k, ind;
+
+    float sixth = 1.0f/6.0f;
+
+#if defined(__INTEL_COMPILER)
+    __assume(padded_nx%8==0);
+    __assume_aligned(&u1[1],32);
+    __assume_aligned(&u2[1],32);
+#elif defined(__GNUC__)
+    if (!(padded_nx%8==0))
+        __builtin_unreachable();
+    // third argument is the misalignment
+    u1 = __builtin_assume_aligned(u1, 32, sizeof(float));
+    u2 = __builtin_assume_aligned(u2, 32, sizeof(float));
+#endif
+
+    /* compute on the grid */
+    #pragma omp parallel for private(i,j,k,ind)
+    for (k = 1;  k < nz-1;  ++k) {
+        for (j = 1;  j < ny-1;  ++j) {
+            #pragma vector nontemporal(u2)
+            for (i = 1;  i < nx-1;  ++i) {
+                ind = i + j*padded_nx + k*padded_nx*ny;
+                u2[ind] =
+                    ( u1[ind-1    ]        + u1[ind+1    ]
+                    + u1[ind-padded_nx   ] + u1[ind+padded_nx   ]
+                    + u1[ind-padded_nx*ny] + u1[ind+padded_nx*ny] ) * sixth;
+            }
+        }
+    }
+}
+
+void l3d_sse(int nx, int padded_nx, int ny, int nz, float *u1, float *u2)
+{
+    int i, j, k, ind;
+
+    float fsixth = 1.0f/6.0f;
+    __m128 sixth = _mm_set_ps1(fsixth);
+
+    /* compute on the grid */
+    #pragma omp parallel for private(i,j,k,ind)
+    for (k = 1;  k < nz-1;  ++k) {
+        for (j = 1;  j < ny-1;  ++j) {
+            for (i = 1;  i < nx-1;  i += 4) {
+                ind = i + j*padded_nx + k*padded_nx*ny;
+
+                __m128 pSrc1 = _mm_loadu_ps(&u1[ind-1]);
+                __m128 pSrc2 = _mm_loadu_ps(&u1[ind+1]);
+                __m128 pSrc3 = _mm_load_ps(&u1[ind-padded_nx]);
+                __m128 pSrc4 = _mm_load_ps(&u1[ind+padded_nx]);
+                __m128 pSrc5 = _mm_load_ps(&u1[ind-padded_nx*ny]);
+                __m128 pSrc6 = _mm_load_ps(&u1[ind+padded_nx*ny]);
+
+                __m128 sum1 = _mm_add_ps(pSrc1, pSrc2);
+                __m128 sum2 = _mm_add_ps(pSrc3, pSrc4);
+                __m128 sum3 = _mm_add_ps(pSrc5, pSrc6);
+                __m128 sum4 = _mm_add_ps(sum1, sum2);
+                __m128 vsum = _mm_add_ps(sum3, sum4);
+
+                vsum = _mm_mul_ps(vsum, sixth);
+
+                _mm_stream_ps(&u2[ind], vsum);
+            }
+        }
+    }
+}
+
+void l3d_avx(int nx, int padded_nx, int ny, int nz, float *u1, float *u2)
+{
+    int i, j, k, ind;
+
+    float fsixth = 1.0f/6.0f;
+    __m256 sixth = _mm256_set1_ps(fsixth);
+
+    /* compute on the grid */
+    #pragma omp parallel for private(i,j,k,ind)
+    for (k = 1;  k < nz-1;  ++k) {
+        for (j = 1;  j < ny-1;  ++j) {
+            for (i = 1;  i < nx-1;  i += 8) {
+                ind = i + j*padded_nx + k*padded_nx*ny;
+
+                __m256 pSrc1 = _mm256_loadu_ps(&u1[ind-1]);
+                __m256 pSrc2 = _mm256_loadu_ps(&u1[ind+1]);
+                __m256 pSrc3 = _mm256_load_ps(&u1[ind-padded_nx]);
+                __m256 pSrc4 = _mm256_load_ps(&u1[ind+padded_nx]);
+                __m256 pSrc5 = _mm256_load_ps(&u1[ind-padded_nx*ny]);
+                __m256 pSrc6 = _mm256_load_ps(&u1[ind+padded_nx*ny]);
+
+                __m256 sum1 = _mm256_add_ps(pSrc1, pSrc2);
+                __m256 sum2 = _mm256_add_ps(pSrc3, pSrc4);
+                __m256 sum3 = _mm256_add_ps(pSrc5, pSrc6);
+                __m256 sum4 = _mm256_add_ps(sum1, sum2);
+                __m256 vsum = _mm256_add_ps(sum3, sum4);
+
+                vsum = _mm256_mul_ps(vsum, sixth);
+
+                _mm256_stream_ps(&u2[ind], vsum);
+            }
+        }
+    }
+}
+
+void l3d_orig(int nx, int ny, int nz, float *u1, float *u2)
+{
+    int i, j, k, ind;
+    const float sixth = 1.0f/6.0f;
+
+    for (k = 0;  k < nz;  ++k) {
+        for (j = 0;  j < ny;  ++j) {
+            for (i = 0;  i < nx;  ++i) {
+                ind = i + j*nx + k*nx*ny;
+
+                if (i == 0  ||  i == nx - 1
+                        ||  j == 0  ||  j == ny - 1
+                        ||  k == 0  ||  k == nz - 1) {
+                    u2[ind] = u1[ind];          // Dirichlet b.c.'s
+                }
+                else {
+                    u2[ind] = ( u1[ind-1    ] + u1[ind+1    ]
+                              + u1[ind-nx   ] + u1[ind+nx   ]
+                              + u1[ind-nx*ny] + u1[ind+nx*ny] ) * sixth;
+                }
+            }
+        }
+    }
+}
diff --git a/test/perf/threads/laplace3d/laplace3d.jl b/test/perf/threads/laplace3d/laplace3d.jl
new file mode 100644
index 0000000000000..f6dc15d838f84
--- /dev/null
+++ b/test/perf/threads/laplace3d/laplace3d.jl
@@ -0,0 +1,136 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+## 3D Laplace equation
+
+using Base.Cartesian
+using Base.Threads
+
+const sixth = 1.0f0/6.0f0
+const error_tol = 0.00001
+
+function stencil3d(u::Array{Float32,3}, k_1::Int64, k_2::Int64, k_3::Int64)
+    return (u[k_1-1, k_2,   k_3  ] + u[k_1+1, k_2,   k_3] +
+            u[k_1,   k_2-1, k_3  ] + u[k_1,   k_2+1, k_3] +
+            u[k_1,   k_2,   k_3-1] + u[k_1,   k_2,   k_3+1]) * sixth
+end
+
+function l3d_orig(u1::Array{Float32,3}, u3::Array{Float32,3},
+                        nx::Int64, ny::Int64, nz::Int64)
+    @nloops 3 k u1 begin
+        if @nany 3 d->(k_d == 1 || k_d == size(u1, d))
+            @inbounds (@nref 3 u3 k) = (@nref 3 u1 k)
+        else
+            @inbounds (@nref 3 u3 k) = stencil3d(u1, k_1, k_2, k_3)
+        end
+    end
+end
+
+## @threads 'call' form
+function l3d_threadfun(u1, u3, nx, ny, nz)
+    tid = threadid()
+    tnz, rem = divrem(nz-2, nthreads())
+    z_start = 2 + ((tid-1) * tnz)
+    z_end = z_start + tnz - 1
+    if tid <= rem
+        z_start = z_start + tid - 1
+        z_end = z_end + tid
+    else
+        z_start = z_start + rem
+        z_end = z_end + rem
+    end
+
+    for k_3 = z_start:z_end
+        for k_2 = 2:ny-1
+            @simd for k_1 = 2:nx-1
+                @inbounds u3[k_1, k_2, k_3] = stencil3d(u1, k_1, k_2, k_3)
+            end
+        end
+    end
+end
+
+#= @threads 'block' form no longer supported
+function l3d_threadblock(u1, u3, nx, ny, nz)
+    @threads all begin
+	tid = threadid()
+	tnz, rem = divrem(nz-2, nthreads())
+	z_start = 2 + ((tid-1) * tnz)
+	z_end = z_start + tnz - 1
+	if tid <= rem
+	    z_start = z_start + tid - 1
+	    z_end = z_end + tid
+	else
+	    z_start = z_start + rem
+	    z_end = z_end + rem
+	end
+
+	for k_3 = z_start:z_end
+	    for k_2 = 2:ny-1
+		@simd for k_1 = 2:nx-1
+		    @inbounds u3[k_1, k_2, k_3] = stencil3d(u1, k_1, k_2, k_3)
+		end
+	    end
+	end
+    end
+end
+=#
+
+## @threads 'for' form
+function l3d_threadfor(u1, u3, nx, ny, nz)
+    @threads for k_3=2:nz-1
+        for k_2 = 2:ny-1
+            @simd for k_1 = 2:nx-1
+                @inbounds u3[k_1, k_2, k_3] = stencil3d(u1, k_1, k_2, k_3)
+            end
+        end
+    end
+end
+
+## initialize and run
+function laplace3d(nx=290, ny=290, nz=290; iters=1000, verify=false)
+    u1 = Array(Float32, nx, ny, nz)
+    u3 = Array(Float32, nx, ny, nz)
+    @nloops 3 k u1 begin
+        if @nany 3 d->(k_d == 1 || k_d == size(u1, d))
+            (@nref 3 u3 k) = (@nref 3 u1 k) = 1.0
+        else
+            (@nref 3 u1 k) = 0.0
+        end
+    end
+    @time for n in 1:iters
+        l3d_threadfor(u1, u3, nx, ny, nz)
+        # @threads all l3d_threadfun(u1, u3, nx, ny, nz)
+	# l3d_threadblock(u1, u3, nx, ny, nz)
+        # ccall(:jl_threading_run, Void, (Any, Any), l3d_threadfun, (u1, u3, nx, ny, nz))
+        foo = u1
+        u1 = u3
+        u3 = foo
+    end
+    if verify
+        u1_orig = Array(Float32, nx, ny, nz)
+        u3_orig = Array(Float32, nx, ny, nz)
+        @nloops 3 k u1_orig begin
+            if @nany 3 d->(k_d == 1 || k_d == size(u1_orig, d))
+                (@nref 3 u3_orig k) = (@nref 3 u1_orig k) = 1.0
+            else
+                (@nref 3 u1_orig k) = 0.0
+            end
+        end
+        @time for n in 1:iters
+            l3d_orig(u1_orig, u3_orig, nx, ny, nz)
+            foo = u1_orig
+            u1_orig = u3_orig
+            u3_orig = foo
+        end
+        @nloops 3 k u1 begin
+            if abs((@nref 3 u1 k) - (@nref 3 u1_orig k)) > error_tol
+                error(@sprintf("Verify error: %f - %f [%d, %d, %d]\n",
+                      (@nref 3 u1 k), (@nref 3 u1_orig k), k_1, k_2, k_3))
+            end
+        end
+        println("verification succeeded")
+    end
+end
+
+@time laplace3d()
+#ccall(:jl_threading_profile, Void, ())
+
diff --git a/test/perf/threads/laplace3d/laplace3d_devec.m b/test/perf/threads/laplace3d/laplace3d_devec.m
new file mode 100644
index 0000000000000..38473d9f04025
--- /dev/null
+++ b/test/perf/threads/laplace3d/laplace3d_devec.m
@@ -0,0 +1,38 @@
+% 3D Laplace equation solver
+
+nx = 290;
+ny = 290;
+nz = 290;
+iters = 100;
+sixth = 1.0/6.0;
+
+u1 = zeros(nx, ny, nz);
+u2 = zeros(nx, ny, nz);
+
+for k3 = 1:nz
+    for k2 = 1:ny
+        for k1 = 1:nx
+            if k1==1 || k1==nx || k2==1 || k2==ny || k3==1 || k3==nz
+                u1(k1,k2,k3) = 1.0;
+                u2(k1,k2,k3) = 1.0;
+            end
+        end
+    end
+end
+
+tic
+for n = 1:iters
+    for k3 = 2:nz-1
+        for k2 = 2:ny-1
+            for k1 = 2:nx-1
+                s = (u1(k1-1,k2,k3) + u1(k1+1,k2,k3) + u1(k1,k2-1,k3) + u1(k1,k2+1,k3) + u1(k1,k2,k3-1) + u1(k1,k2,k3+1)) * sixth;
+                u2(k1,k2,k3) = s;
+            end
+        end
+    end
+    foo = u1;
+    u1 = u2;
+    u2 = foo;
+end
+toc
+
diff --git a/test/perf/threads/laplace3d/laplace3d_vec.m b/test/perf/threads/laplace3d/laplace3d_vec.m
new file mode 100644
index 0000000000000..43767dc352774
--- /dev/null
+++ b/test/perf/threads/laplace3d/laplace3d_vec.m
@@ -0,0 +1,34 @@
+% 3D Laplace equation solver
+
+nx = 290;
+ny = 290;
+nz = 290;
+iters = 100;
+sixth = 1.0/6.0;
+
+u1 = zeros(nx, ny, nz);
+u2 = zeros(nx, ny, nx);
+
+%Boundary conditions
+u1(1,:,:) = 1.0;
+u1(nx,:,:) = 1.0;
+u1(:,1,:) = 1.0;
+u1(:,ny,:) = 1.0;
+u1(:,:,1) = 1.0;
+u1(:,:,nz) = 1.0;
+u2 = u1;
+
+i = 2:nx-1;
+j = 2:ny-1;
+k = 2:nz-1;
+
+%Main
+tic
+for n = 1:iters
+    u2(i,j,k) = (u1(i-1,j,k) + u1(i+1,j,k) + u1(i,j-1,k) + u1(i,j+1,k) + u1(i,j,k-1) + u1(i,j,k+1))*sixth;
+    foo = u1;
+    u1 = u2;
+    u2 = foo; 
+end
+toc
+
diff --git a/test/perf/threads/lbm3d/README b/test/perf/threads/lbm3d/README
new file mode 100644
index 0000000000000..c7ce696941bad
--- /dev/null
+++ b/test/perf/threads/lbm3d/README
@@ -0,0 +1,9 @@
+3D Lattice Boltzmann (BGK) model of a fluid (http://exolete.com/lbm/)
+
+The Matlab/Octave version is from the website. The Julia version is
+rewritten in devectorized form with threading directives applied to
+the parallelizable code.
+
+The circshift! implementation needs work to support arbitrary
+dimensioned grids.
+
diff --git a/test/perf/threads/lbm3d/circshift.jl b/test/perf/threads/lbm3d/circshift.jl
new file mode 100644
index 0000000000000..ccd4ec7686b44
--- /dev/null
+++ b/test/perf/threads/lbm3d/circshift.jl
@@ -0,0 +1,110 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# An in-place version of circshift. Needs generalization -- currently
+# works only on a 3D hyperplane of a 4D array and supports only unit
+# shifts. Code needs refactoring to reduce duplication.
+
+using Match
+
+# a is the 4D array; index specifies which 3D hyperplane; vec
+# specifies the shifts (only 1 and -1)
+function circshift3d1!(a,index,vec)
+    nx = size(a,1)
+    ny = size(a,2)
+    nz = size(a,3)
+    for i = 1 : length(vec)
+        @match vec[i] begin
+            1  => shift1!(a,nx,ny,nz,index,i)
+           -1  => shiftm1!(a,nx,ny,nz,index,i)
+        end
+    end
+end
+
+function shift1!(a,nx,ny,nz,index,i)
+    @match i begin
+        1 => shifti!(a,nx,ny,nz,index)
+        2 => shiftj!(a,nx,ny,nz,index)
+        3 => shiftk!(a,nx,ny,nz,index)
+    end
+end
+
+function shiftm1!(a,nx,ny,nz,index,i)
+    @match i begin
+        1 => shiftmi!(a,nx,ny,nz,index)
+        2 => shiftmj!(a,nx,ny,nz,index)
+        3 => shiftmk!(a,nx,ny,nz,index)
+    end
+end
+
+function shifti!(a,nx,ny,nz,index)
+    for k = 1:nz
+        for j = 1:ny
+            t = a[end,j,k,index]
+            for i = nx-1:-1:1
+               a[i+1,j,k,index] = a[i,j,k,index]
+            end
+            a[1,j,k,index] = t
+        end
+    end
+end
+
+function shiftj!(a,nx,ny,nz,index)
+    for i = 1:nx
+        for k = 1:nz
+            t = a[i,end,k,index]
+            for j = ny-1:-1:1
+                a[i,j+1,k,index] = a[i,j,k,index]
+            end
+            a[i,1,k,index] = t
+       end
+    end
+end
+
+function shiftk!(a,nx,ny,nz,index)
+    for i = 1:nx
+        for j = 1:ny
+        t = a[i,j,end,index]
+            for k = nz-1:-1:1
+                a[i,j,k+1,index] = a[i,j,k,index]
+            end
+        a[i,j,1,index] = t
+        end
+    end
+end
+
+function shiftmi!(a,nx,ny,nz,index)
+    for k = 1:nz
+        for j = 1:ny
+            t = a[1,j,k,index]
+            for i = 1:nx-1
+                a[i,j,k,index] = a[i+1,j,k,index]
+            end
+            a[end,j,k,index] = t
+        end
+    end
+end
+
+function shiftmj!(a,nx,ny,nz,index)
+    for k = 1:nz
+        for i = 1:nx
+            t = a[i,1,k,index]
+            for j = 1:ny-1
+                a[i,j,k,index] = a[i,j+1,k,index]
+            end
+            a[i,end,k,index] = t
+       end
+    end
+end
+
+function shiftmk!(a,nx,ny,nz,index)
+    for i = 1:nx
+        for j = 1:ny
+            t = a[i,j,1,index]
+            for k = 1:nz-1
+                a[i,j,k,index] = a[i,j,k+1,index]
+            end
+            a[i,j,end,index] = t
+       end
+    end
+end
+
diff --git a/test/perf/threads/lbm3d/lbm3d.jl b/test/perf/threads/lbm3d/lbm3d.jl
new file mode 100644
index 0000000000000..f1464a13f3b40
--- /dev/null
+++ b/test/perf/threads/lbm3d/lbm3d.jl
@@ -0,0 +1,223 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# 3D Lattice Boltzmann (BGK) model of a fluid.
+# (http://exolete.com/lbm/)
+# D3Q19 model. At each timestep, particle densities propagate
+# outwards in the directions indicated in the figure. An
+# equivalent 'equilibrium' density is found, and the densities
+# relax towards that state, in a proportion governed by omega.
+#               Iain Haslam, March 2006.
+#
+# Julia version: devectorized and threaded. The in-place
+# circshift implementation is needed because of issue #10317.
+# Despite that, GC time is ~22% of runtime. relax! and
+# calc_equi! are broken out because of issue #10718. The
+# threaded call form is used and the for loop form is is
+# commented out in both because of issue #10527.
+
+#using PyPlot
+using Base.Threads
+
+include("circshift.jl")
+
+const t1 = 1/3
+const t2 = 1/18
+const t3 = 1/36
+
+const prop_shifts = tuple([ 0  0  1], [ 0  0 -1], [ 0  1  0],
+                    	  [ 0 -1  0], [ 1  0  0], [-1  0  0],
+                     	  [ 1  1  0], [ 1 -1  0], [-1  1  0],
+                     	  [-1 -1  0], [ 1  0  1], [ 1  0 -1],
+                     	  [-1  0  1], [-1  0 -1], [ 0  1  1],
+                     	  [ 0  1 -1], [ 0 -1  1], [ 0 -1 -1]);
+
+const fourths = tuple([ 6, 8, 9,12,13], [ 7,10,11,14,15],
+                      [ 4, 8,10,16,17], [ 5, 9,11,18,19],
+                      [ 2,12,14,16,18], [ 3,13,15,17,19])
+
+
+function relax!(F, UX, UY, UZ, nx, ny, nz, deltaU, t1D, t2D, t3D, sSQU, chunkid, nchunk)
+    outerrange = Base.splitrange(nx, nchunk)
+    for i = outerrange[chunkid]
+    #@threads all for i = 1:nx
+        for j = 1:ny
+            for k = 1:nz
+                density = 0.0
+                for l = 1:size(F,4)
+                    density = density + F[i,j,k,l]
+                end
+                fs = Array(Float64, 6)
+                for l = 1:6
+                    fs[l] = 0.0
+                    for m = 1:5
+                        fs[l] = fs[l] + F[i,j,k,fourths[l][m]]
+                    end
+                end
+                UX[i,j,k] = (fs[1] - fs[2]) / density
+                UY[i,j,k] = (fs[3] - fs[4]) / density
+                UZ[i,j,k] = (fs[5] - fs[6]) / density
+
+                if i == 1
+                    UX[i,j,k] = UX[i,j,k] + deltaU # Increase inlet pressure
+                end
+
+                t1D[i,j,k] = t1 * density
+                t2D[i,j,k] = t2 * density
+                t3D[i,j,k] = t3 * density
+                sSQU[i,j,k] = 3/2 * (UX[i,j,k]^2 + UY[i,j,k]^2 + UZ[i,j,k]^2)
+            end
+        end
+    end
+end
+
+
+function calc_equi!(F, FEQ, t1D, t2D, t3D, U, UX, UY, UZ, sSQU, nx, ny, nz, omega, chunkid, nchunk)
+    outerrange = Base.splitrange(nx, nchunk)
+    for i = outerrange[chunkid]
+    #@threads all for i = 1:nx
+        #tid = threadid()
+        for j = 1:ny
+            for k = 1:nz
+
+                FEQ[i,j,k,1] = t1D[i,j,k,1] * (1 - sSQU[i,j,k,1])
+
+                # nearest neighbors
+                FEQ[i,j,k,2] = t2D[i,j,k,1] * (1 + 3*UZ[i,j,k,1] + 9/2*UZ[i,j,k,1]^2 - sSQU[i,j,k,1])
+                FEQ[i,j,k,3] = t2D[i,j,k,1] * (1 - 3*UZ[i,j,k,1] + 9/2*UZ[i,j,k,1]^2 - sSQU[i,j,k,1])
+                FEQ[i,j,k,4] = t2D[i,j,k,1] * (1 + 3*UY[i,j,k,1] + 9/2*UY[i,j,k,1]^2 - sSQU[i,j,k,1])
+                FEQ[i,j,k,5] = t2D[i,j,k,1] * (1 - 3*UY[i,j,k,1] + 9/2*UY[i,j,k,1]^2 - sSQU[i,j,k,1])
+                FEQ[i,j,k,6] = t2D[i,j,k,1] * (1 + 3*UX[i,j,k,1] + 9/2*UX[i,j,k,1]^2 - sSQU[i,j,k,1])
+                FEQ[i,j,k,7] = t2D[i,j,k,1] * (1 - 3*UX[i,j,k,1] + 9/2*UX[i,j,k,1]^2 - sSQU[i,j,k,1])
+
+                U[1,chunkid]  = UX[i,j,k,1] + UY[i,j,k,1]
+                U[2,chunkid]  = UX[i,j,k,1] - UY[i,j,k,1]
+                U[3,chunkid]  = -UX[i,j,k,1] + UY[i,j,k,1]
+                U[4,chunkid]  = -U[1,chunkid]
+                U[5,chunkid]  = UX[i,j,k,1] + UZ[i,j,k,1]
+                U[6,chunkid]  = UX[i,j,k,1] - UZ[i,j,k,1]
+                U[7,chunkid]  = -U[6,chunkid]
+                U[8,chunkid]  = -U[5,chunkid]
+                U[9,chunkid]  = UY[i,j,k,1] + UZ[i,j,k,1]
+                U[10,chunkid] = UY[i,j,k,1] - UZ[i,j,k,1]
+                U[11,chunkid] = -U[10,chunkid]
+                U[12,chunkid] = -U[9,chunkid]
+
+                # next-nearest neighbors
+                for l = 1:12
+                    FEQ[i,j,k,l+7] = t3D[i,j,k,1] * (1 + 3*U[l,chunkid] + 9/2*(U[l,chunkid]^2) - sSQU[i,j,k,1])
+                end
+
+                for l = 1:19
+                    F[i,j,k,l] = omega * FEQ[i,j,k,l] + (1 - omega) * F[i,j,k,l]
+                end
+
+            end
+        end
+    end
+end
+
+precompile(calc_equi!, (Array{Float64,4}, Array{Float64,4}, Array{Float64,3}, Array{Float64,3}, Array{Float64,3}, Array{Float64,2}, Array{Float64,3}, Array{Float64,3}, Array{Float64,3}, Array{Float64,3}, Int64, Int64, Int64, Float64))
+
+function lbm3d(n)
+    const nx = n
+    const ny = nx
+    const nz = nx
+    const omega = 1.0
+    const density = 1.0
+
+    # Implementation note: setting nchunk to nthreads() is a hack
+    # to simulate the previous implementation's use of parallel regions.
+    nchunk = nthreads()
+
+    tprop = 0
+    trelax = 0
+    tequi = 0
+
+    F = repeat([density/19], outer=[nx, ny, nz, 19])
+    FEQ = F
+    matsize = nx*ny*nz
+
+    CI = [0:matsize:matsize*19;]'
+
+    BOUND = Array(Float64,nx,ny,nz)
+
+    for i=1:nx, j=1:ny, k=1:nz
+        BOUND[i,j,k] = ((i-5)^2 + (j-6)^2 + (k-7)^2) < 6
+    end
+
+    BOUND[:,:,1] = 1
+    BOUND[:,1,:] = 1
+
+    ON = find(BOUND); # matrix offset of each Occupied Node
+
+    TO_REFLECT = [ON+CI[2] ON+CI[3] ON+CI[4] ON+CI[5] ON+CI[6] ON+CI[7] ON+CI[8] ON+CI[9] ON+CI[10] ON+CI[11] ON+CI[12] ON+CI[13] ON+CI[14] ON+CI[15] ON+CI[16] ON+CI[17] ON+CI[18] ON+CI[19]]
+    REFLECTED = [ON+CI[3] ON+CI[2] ON+CI[5] ON+CI[4] ON+CI[7] ON+CI[6] ON+CI[11] ON+CI[10] ON+CI[9] ON+CI[8] ON+CI[15] ON+CI[14] ON+CI[13] ON+CI[12] ON+CI[19] ON+CI[18] ON+CI[17] ON+CI[16]]
+
+    UX = Array(Float64,nx,ny,nz)
+    UY = Array(Float64,nx,ny,nz)
+    UZ = Array(Float64,nx,ny,nz)
+    U  = Array(Float64,12,nchunk)
+    t1D = Array(Float64,nx,ny,nz)
+    t2D = Array(Float64,nx,ny,nz)
+    t3D = Array(Float64,nx,ny,nz)
+    sSQU = Array(Float64,nx,ny,nz)
+
+    avu = 1
+    prevavu = 1
+    ts = 0
+    deltaU = 1e-7
+    numactivenodes = sum(1-BOUND)
+
+    @time while (ts < 4000  &&  (1e-10 < abs((prevavu-avu)/avu)))  ||  ts < 100
+        tic()
+        # Propagate -- nearest and next-nearest neighbors
+        for i = 2:19
+            circshift3d1!(F, i, prop_shifts[i-1])
+        end
+        tprop = tprop + toq()
+
+        # Densities bouncing back at next timestep
+        BOUNCEDBACK = F[TO_REFLECT]
+
+        tic()
+
+        # Relax; calculate equilibrium state (FEQ) with equivalent speed and density to F
+        @threads for chunk=1:nchunk
+            relax!(F, UX, UY, UZ, nx, ny, nz, deltaU, t1D, t2D, t3D, sSQU, chunkid, nchunk)
+        end
+        for o in ON
+            UX[o] = UY[o] = UZ[o] = t1D[o] = t2D[o] = t3D[o] = sSQU[o] = 0.0
+        end
+
+        trelax = trelax + toq()
+        tic()
+
+        # Calculate equilibrium distribution: stationary
+        @threads for chunk=1:nchunk
+            calc_equi!(F, FEQ, t1D, t2D, t3D, U, UX, UY, UZ, sSQU, nx, ny, nz, omega)
+        end
+
+        tequi = tequi + toq()
+
+        F[REFLECTED] = BOUNCEDBACK
+
+        prevavu = avu
+        avu = sum(UX) / numactivenodes
+        ts = ts + 1
+        #println(avu)
+    end
+
+    println("ts: $(ts)")
+    println("propagation time: $tprop")
+    println("relaxation time: $trelax")
+    println("equilibrium time: $tequi")
+
+    #zcut=5
+    #quiver(UY[:,:,zcut], UX[:,:,zcut])
+    #xlabel("y"); ylabel("x")
+    #title("Flow field at z = $(zcut)), after $(ts)")
+end
+
+@time lbm3d(36)
+#ccall(:jl_threading_profile, Void, ())
+
diff --git a/test/perf/threads/lbm3d/lbm3d.m b/test/perf/threads/lbm3d/lbm3d.m
new file mode 100644
index 0000000000000..c7c7d9f228a9b
--- /dev/null
+++ b/test/perf/threads/lbm3d/lbm3d.m
@@ -0,0 +1,93 @@
+% 3D Lattice Boltzmann (BGK) model of a fluid.
+%
+% From http://exolete.com/lbm/, reproduced here with the author's
+% permission.
+%
+% D3Q19 model. At each timestep, particle densities propagate
+% outwards in the directions indicated in the figure. An
+% equivalent 'equilibrium' density is found, and the densities
+% relax towards that state, in a proportion governed by omega.
+%               Iain Haslam, March 2006.
+nx=36;ny=nx;nz=nx; omega=1.0; density=1.0;t1=1/3; t2=1/18; t3=1/36;
+F=repmat(density/19,[nx ny nz 19]); FEQ=F; matsize=nx*ny*nz;
+CI=[0:matsize:matsize*19];
+BOUND=zeros(nx,ny,nz);
+for i=1:nx, for j=1:ny, for k=1:nz
+	BOUND(i,j,k)=((i-5)^2+(j-6)^2+(k-7)^2)<6;
+end, end, end
+BOUND(:,:,1)=1;BOUND(:,1,:)=1;
+ON=find(BOUND); %matrix offset of each Occupied Node
+TO_REFLECT=[ON+CI(2) ON+CI(3) ON+CI(4) ON+CI(5)	ON+CI(6) ON+CI(7) ON+CI(8) ...
+  ON+CI(9) ON+CI(10) ON+CI(11) ON+CI(12) ON+CI(13) ON+CI(14) ON+CI(15) ... 
+  ON+CI(16) ON+CI(17) ON+CI(18) ON+CI(19)];
+REFLECTED=[ON+CI(3) ON+CI(2) ON+CI(5) ON+CI(4) ON+CI(7) ON+CI(6) ON+CI(11) ...
+  ON+CI(10) ON+CI(9) ON+CI(8) ON+CI(15) ON+CI(14) ON+CI(13) ON+CI(12) ...
+  ON+CI(19) ON+CI(18) ON+CI(17) ON+CI(16)];
+avu=1; prevavu=1; ts=0; deltaU=1e-7; numactivenodes=sum(sum(sum(1-BOUND)));
+tic;
+while (ts<4000 & 1e-10<abs((prevavu-avu)/avu)) | ts<100
+	% Propagate
+	%nearest-neighbours
+	F(:,:,:,2)=F(:,:,[nz 1:nz-1],2);
+	F(:,:,:,3)=F(:,:,[2:nz 1],3);
+	F(:,:,:,4)=F(:,[ny 1:ny-1],:,4);
+	F(:,:,:,5)=F(:,[2:ny 1],:,5);	
+	F(:,:,:,6)=F([nx 1:nx-1],:,:,6);
+	F(:,:,:,7)=F([2:nx 1],:,:,7);	
+	%next-nearest neighbours
+	F(:,:,:,8)= F([nx 1:nx-1],[ny 1:ny-1],:,8);
+	F(:,:,:,9)= F([nx 1:nx-1],[2:ny 1],:,9);
+	F(:,:,:,10)=F([2:nx 1],[ny 1:ny-1],:,10);
+	F(:,:,:,11)=F([2:nx 1],[2:ny 1],:,11);	
+	F(:,:,:,12)=F([nx 1:nx-1],:,[nz 1:nz-1],12);
+	F(:,:,:,13)=F([nx 1:nx-1],:,[2:nz 1],13);
+	F(:,:,:,14)=F([2:nx 1],:,[nz 1:nz-1],14);
+	F(:,:,:,15)=F([2:nx 1],:,[2:nz 1],15);
+	F(:,:,:,16)=F(:,[ny 1:ny-1],[nz 1:nz-1],16);
+	F(:,:,:,17)=F(:,[ny 1:ny-1],[2:nz 1],17);
+	F(:,:,:,18)=F(:,[2:ny 1],[nz 1:nz-1],18);
+	F(:,:,:,19)=F(:,[2:ny 1],[2:nz 1],19);
+	BOUNCEDBACK=F(TO_REFLECT); %Densities bouncing back at next timestep
+	% Relax; calculate equilibrium state (FEQ) with equivalent speed and density to F 
+	DENSITY = sum(F,4);
+	UX=(sum(F(:,:,:,[6 8 9 12 13]),4)-sum(F(:,:,:,[7 10 11 14 15]),4))./DENSITY;
+	UY=(sum(F(:,:,:,[4 8 10 16 17]),4)-sum(F(:,:,:,[5 9 11 18 19]),4))./DENSITY;
+	UZ=(sum(F(:,:,:,[2 12 14 16 18]),4)-sum(F(:,:,:,[3 13 15 17 19]),4))./DENSITY;
+	UX(1,:,:)=UX(1,:,:)+deltaU; %Increase inlet pressure
+	UX(ON)=0; UY(ON)=0; UZ(ON)=0; DENSITY(ON)=0; U_SQU=UX.^2+UY.^2+UZ.^2;
+	U8=UX+UY;U9=UX-UY;U10=-UX+UY;U11=-U8;U12=UX+UZ;U13=UX-UZ;
+	U14=-U13;U15=-U12;U16=UY+UZ;U17=UY-UZ;U18=-U17;U19=-U16;
+	% Calculate equilibrium distribution: stationary
+	FEQ(:,:,:,1)=t1*DENSITY.*(1-3*U_SQU/2);
+	% nearest-neighbours
+	FEQ(:,:,:,2)=t2*DENSITY.*(1 + 3*UZ + 9/2*UZ.^2 - 3/2*U_SQU);
+	FEQ(:,:,:,3)=t2*DENSITY.*(1 - 3*UZ + 9/2*UZ.^2 - 3/2*U_SQU);
+	FEQ(:,:,:,4)=t2*DENSITY.*(1 + 3*UY + 9/2*UY.^2 - 3/2*U_SQU);
+	FEQ(:,:,:,5)=t2*DENSITY.*(1 - 3*UY + 9/2*UY.^2 - 3/2*U_SQU);
+	FEQ(:,:,:,6)=t2*DENSITY.*(1 + 3*UX + 9/2*UX.^2 - 3/2*U_SQU);
+	FEQ(:,:,:,7)=t2*DENSITY.*(1 - 3*UX + 9/2*UX.^2 - 3/2*U_SQU);
+	% next-nearest neighbours
+	FEQ(:,:,:,8) =t3*DENSITY.*(1 + 3*U8  + 9/2*(U8).^2  - 3*U_SQU/2);
+	FEQ(:,:,:,9) =t3*DENSITY.*(1 + 3*U9  + 9/2*(U9).^2  - 3*U_SQU/2);
+	FEQ(:,:,:,10)=t3*DENSITY.*(1 + 3*U10 + 9/2*(U10).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,11)=t3*DENSITY.*(1 + 3*U11 + 9/2*(U11).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,12)=t3*DENSITY.*(1 + 3*U12 + 9/2*(U12).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,13)=t3*DENSITY.*(1 + 3*U13 + 9/2*(U13).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,14)=t3*DENSITY.*(1 + 3*U14 + 9/2*(U14).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,15)=t3*DENSITY.*(1 + 3*U15 + 9/2*(U15).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,16)=t3*DENSITY.*(1 + 3*U16 + 9/2*(U16).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,17)=t3*DENSITY.*(1 + 3*U17 + 9/2*(U17).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,18)=t3*DENSITY.*(1 + 3*U18 + 9/2*(U18).^2 - 3*U_SQU/2);
+	FEQ(:,:,:,19)=t3*DENSITY.*(1 + 3*U19 + 9/2*(U19).^2 - 3*U_SQU/2);
+	F=omega*FEQ+(1-omega)*F;
+	F(REFLECTED)=BOUNCEDBACK;
+	prevavu=avu;avu=sum(sum(sum(UX)))/numactivenodes; ts=ts+1;
+end
+toc;
+%figure;zcut=5;colormap(gray(2));image(2-BOUND(:,:,5));hold on;
+%Thanks to Thomas Wagner for correcting the transposed results plots
+%quiver(UY(:,:,zcut),UX(:,:,zcut));xlabel('y');ylabel('x');
+%title(['Flow field at z=',num2str(zcut),', after ',num2str(ts),'\deltat']);
+%figure;ycut=5;colormap(gray(2));image(2-squeeze(BOUND(:,ycut,:)));hold on;
+%quiver(squeeze(UZ(:,ycut,:)),squeeze(UX(:,ycut,:)));xlabel('z');ylabel('x');
+%title(['Flow field at y=',num2str(ycut),', after ',num2str(ts),'\deltat']);
diff --git a/test/perf/threads/stockcorr/pstockcorr.jl b/test/perf/threads/stockcorr/pstockcorr.jl
new file mode 100644
index 0000000000000..96e4e762cd893
--- /dev/null
+++ b/test/perf/threads/stockcorr/pstockcorr.jl
@@ -0,0 +1,113 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+## Test case from Issue #445
+##
+## Added threaded implementation (2015-04-06)
+
+using Base.Threads
+
+#STOCKCORR - The original, unoptimised code that simulates two correlated assets
+function stockcorr()
+
+    ## Correlated asset information
+    CurrentPrice = [78. 102.]     # Initial Prices of the two stocks
+    Corr = [1. 0.4; 0.4 1.]       # Correlation Matrix
+    T = 500                       # Number of days to simulate = 2years = 500days
+    n = 1000000                   # Number of simulations
+    dt = 1/250                    # Time step (1year = 250days)
+    Div=[0.01 0.01]               # Dividend
+    Vol=[0.2 0.3]                 # Volatility
+
+    ## Market Information
+    r = 0.03                      # Risk-free rate
+
+    ## Define storages
+    SimulPriceA = zeros(T,n)      # Simulated Price of Asset A
+    SimulPriceA[1,:] = CurrentPrice[1]
+    SimulPriceB = zeros(T,n)      # Simulated Price of Asset B
+    SimulPriceB[1,:] = CurrentPrice[2]
+
+    ## Generating the paths of stock prices by Geometric Brownian Motion
+    UpperTriangle=chol(Corr)      # UpperTriangle Matrix by Cholesky decomposition
+
+    for i = 1:n
+       Wiener = randn(T-1,2)
+       CorrWiener = Wiener*UpperTriangle
+       for j = 2:T
+          SimulPriceA[j,i] = SimulPriceA[j-1,i]*exp((r-Div[1]-Vol[1]^2/2)*dt+Vol[1]*sqrt(dt)*CorrWiener[j-1,1])
+          SimulPriceB[j,i] = SimulPriceB[j-1,i]*exp((r-Div[2]-Vol[2]^2/2)*dt+Vol[2]*sqrt(dt)*CorrWiener[j-1,2])
+       end
+    end
+
+    return (SimulPriceA, SimulPriceB)
+end
+
+# Run paths in parallel
+# NOTE: this has to be in its own function due to #10718
+function runpath!(n, Wiener, CorrWiener, SA, SB, T, UpperTriangle, k11, k12, k21, k22, rngs)
+    @threads for i = 1:n
+    #for i = 1:n
+        randn!(rngs[threadid()], Wiener)
+        #randn!(rngs[1], Wiener)
+        A_mul_B!(CorrWiener, Wiener, UpperTriangle)
+        @simd for j = 2:T
+            @inbounds SA[j, i] = SA[j-1, i] * exp(k11 + k12*CorrWiener[j-1, 1])
+            @inbounds SB[j, i] = SB[j-1, i] * exp(k21 + k22*CorrWiener[j-1, 2])
+        end
+    end
+end
+
+#precompile(runpath!, (Int64, Array{Float64,2}, Array{Float64,2}, Array{Float64,2}, Int64, Array{Float64, 2}, Float64, Float64, Float64, Float64))
+
+# Threaded version
+function pstockcorr(n)
+
+    ## Correlated asset information
+    const CurrentPrice = [78. 102.]     # Initial Prices of the two stocks
+    const Corr = [1. 0.4; 0.4 1.]       # Correlation Matrix
+    const T = 500                       # Number of days to simulate = 2years = 500days
+    const dt = 1/250                    # Time step (1year = 250days)
+    const Div=[0.01 0.01]               # Dividend
+    const Vol=[0.2 0.3]                 # Volatility
+
+    ## Market Information
+    const r = 0.03                      # Risk-free rate
+
+    ## Define storages
+    SimulPriceA = zeros(T,n)            # Simulated Price of Asset A
+    SimulPriceA[1,:] = CurrentPrice[1]
+    SimulPriceB = zeros(T,n)            # Simulated Price of Asset B
+    SimulPriceB[1,:] = CurrentPrice[2]
+
+    ## Generating the paths of stock prices by Geometric Brownian Motion
+    const UpperTriangle = full(chol(Corr))    # UpperTriangle Matrix by Cholesky decomposition
+
+    # Optimization: pre-allocate these for performance
+    # NOTE: the new GC will hopefully fix this, but currently GC time
+    # kills performance if we don't do in-place computations
+    Wiener = Array(Float64, T-1, 2)
+    CorrWiener = Array(Float64, T-1, 2)
+
+    # Runtime requirement: need per-thread RNG since it stores state
+    rngs = [MersenneTwister(777+x) for x in 1:nthreads()]
+
+    # Optimization: pre-computable factors
+    # NOTE: this should be automatically hoisted out of the loop
+    # NOTE: applied this to the MATLAB version as well
+    k11 = (r-Div[1]-Vol[1]^2/2)*dt
+    k12 = Vol[1]*sqrt(dt)
+    k21 = (r-Div[2]-Vol[2]^2/2)*dt
+    k22 = Vol[2]*sqrt(dt)
+
+    # NOTE: this reduces reported GC allocation to 576 bytes (due to?)
+    #runpath!(1, Wiener, CorrWiener, SimulPriceA, SimulPriceB, T, UpperTriangle, k11, k12, k21, k22, rngs)
+
+    # run
+    @time runpath!(n, Wiener, CorrWiener, SimulPriceA, SimulPriceB, T, UpperTriangle, k11, k12, k21, k22, rngs)
+
+    return (SimulPriceA, SimulPriceB)
+end
+
+@time pstockcorr(1000000)
+#ccall(:jl_threading_profile, Void, ())
+
diff --git a/test/perf/threads/stockcorr/stockcorr_devec.m b/test/perf/threads/stockcorr/stockcorr_devec.m
new file mode 100644
index 0000000000000..fd8aa550f0654
--- /dev/null
+++ b/test/perf/threads/stockcorr/stockcorr_devec.m
@@ -0,0 +1,47 @@
+%% Simulate two correlated assets
+%% Original code from Mike Croucher (http://www.walkingrandomly.com/?p=3604)
+%% Manually hoisted some computations outside the loop; see ../../kernel/
+%% for the original version
+
+%% Correlated asset information
+CurrentPrice = [78 102];       %Initial Prices of the two stocks
+Corr = [1 0.4; 0.4 1];         %Correlation Matrix
+T = 500;                       %Number of days to simulate = 2years = 500days
+n = 1000000;                   %Number of simulations
+dt = 1/250;                    %Time step (1year = 250days)
+Div=[0.01 0.01];               %Dividend
+Vol=[0.2 0.3];                 %Volatility
+
+%%Market Information
+r = 0.03;                      %Risk-free rate
+
+%% Define storages
+SimulPriceA=zeros(T,n);    %Simulated Price of Asset A
+SimulPriceA(1,:)=CurrentPrice(1);
+SimulPriceB=zeros(T,n);    %Simulated Price of Asset B
+SimulPriceB(1,:)=CurrentPrice(2);
+
+%% Generating the paths of stock prices by Geometric Brownian Motion
+UpperTriangle=chol(Corr);    %UpperTriangle Matrix by Cholesky decomposition
+
+%% Pre-calculating factors
+k11 = (r - Div(1) - Vol(1)^2/2)*dt;
+k12 = Vol(1) * sqrt(dt);
+k21 = (r - Div(2) - Vol(2)^2/2)*dt;
+k22 = Vol(2) * sqrt(dt);
+
+tic
+for i=1:n
+   Wiener=randn(T-1,2);
+   CorrWiener=Wiener*UpperTriangle;
+   for j=2:T
+      SimulPriceA(j,i)=SimulPriceA(j-1,i)*exp(k11+k12*CorrWiener(j-1,1));
+      SimulPriceB(j,i)=SimulPriceB(j-1,i)*exp(k21+k22*CorrWiener(j-1,2));
+   end
+end
+toc
+
+%% Plot the distribution of final prices
+% Comment this section out if doing timings
+%subplot(1,2,1);hist(SimulPriceA(end,:),100);
+%subplot(1,2,2);hist(SimulPriceB(end,:),100);
diff --git a/test/perf/threads/stockcorr/stockcorr_vec.m b/test/perf/threads/stockcorr/stockcorr_vec.m
new file mode 100644
index 0000000000000..7264221880d74
--- /dev/null
+++ b/test/perf/threads/stockcorr/stockcorr_vec.m
@@ -0,0 +1,42 @@
+%% Simulate two correlated assets
+%% Original code from Mike Croucher (http://www.walkingrandomly.com/?p=3604)
+
+%% Correlated asset information
+CurrentPrice = [78 102];       %Initial Prices of the two stocks
+Corr = [1 0.4; 0.4 1];         %Correlation Matrix
+T = 500;                       %Number of days to simulate = 2years = 500days 
+Div=[0.01 0.01];               %Dividend
+Vol=[0.2 0.3];                 %Volatility
+
+%% Market Information
+r = 0.03;                      %Risk-free rate
+
+%% Simulation parameters 
+n=1000000;                      %Number of simulation
+dt=1/250;                       %Time step (1year = 250days)
+
+%% Define storages
+SimulPrices=repmat(CurrentPrice,n,1);
+CorrWiener = zeros(T-1,2,n);
+
+%% Generating the paths of stock prices by Geometric Brownian Motion
+UpperTriangle=chol(Corr);    %UpperTriangle Matrix by Cholesky decomposition
+
+tic;
+for i=1:n
+     CorrWiener(:,:,i)=randn(T-1,2)*UpperTriangle;
+end
+Volr = repmat(Vol,[T-1,1,n]);
+Divr = repmat(Div,[T-1,1,n]);
+
+%% do simulation
+sim = cumprod(exp((r-Divr-Volr.^2./2).*dt+Volr.*sqrt(dt).*CorrWiener));
+%get just the final prices
+SimulPrices = SimulPrices.*reshape(sim(end,:,:),2,n)';
+toc;
+
+%% Plot the distribution of final prices
+% Comment this section out if doing timings
+%subplot(1,2,1);hist(SimulPrices(:,1),100);
+%subplot(1,2,2);hist(SimulPrices(:,2),100);
+
diff --git a/test/pkg.jl b/test/pkg.jl
index 506ad8787e827..0fa9988b426d5 100644
--- a/test/pkg.jl
+++ b/test/pkg.jl
@@ -1,165 +1,248 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-function temp_pkg_dir(fn::Function)
-  # Used in tests below to setup and teardown a sandboxed package directory
-  const tmpdir = ENV["JULIA_PKGDIR"] = joinpath(tempdir(),randstring())
-  @test !isdir(Pkg.dir())
-  try
-    Pkg.init()
-    @test isdir(Pkg.dir())
-    Pkg.resolve()
-
-    fn()
-  finally
-    rm(tmpdir, recursive=true)
-  end
+import Base.Pkg.PkgError
+
+function temp_pkg_dir(fn::Function, remove_tmp_dir::Bool=true)
+    # Used in tests below to setup and teardown a sandboxed package directory
+    const tmpdir = ENV["JULIA_PKGDIR"] = joinpath(tempdir(),randstring())
+    @test !isdir(Pkg.dir())
+    try
+        Pkg.init()
+        @test isdir(Pkg.dir())
+        Pkg.resolve()
+        fn()
+    finally
+        remove_tmp_dir && rm(tmpdir, recursive=true)
+    end
 end
 
+
 # Test basic operations: adding or removing a package, status, free
 #Also test for the existence of REQUIRE and META_Branch
 temp_pkg_dir() do
-  @test isfile(joinpath(Pkg.dir(),"REQUIRE"))
-  @test isfile(joinpath(Pkg.dir(),"META_BRANCH"))
-  @test isempty(Pkg.installed())
-  Pkg.add("Example")
-  @test [keys(Pkg.installed())...] == ["Example"]
-  iob = IOBuffer()
-  Pkg.checkout("Example")
-  Pkg.status("Example", iob)
-  str = chomp(takebuf_string(iob))
-  @test startswith(str, " - Example")
-  @test endswith(str, "master")
-  Pkg.free("Example")
-  Pkg.status("Example", iob)
-  str = chomp(takebuf_string(iob))
-  @test endswith(str, string(Pkg.installed("Example")))
-  Pkg.checkout("Example")
-  Pkg.free(("Example",))
-  Pkg.status("Example", iob)
-  str = chomp(takebuf_string(iob))
-  @test endswith(str, string(Pkg.installed("Example")))
-  Pkg.rm("Example")
-  @test isempty(Pkg.installed())
-  @test !isempty(Pkg.available("Example"))
-  @test_throws ErrorException Pkg.available("FakePackageDoesn'tExist")
-  Pkg.clone("https://github.com/JuliaLang/Example.jl.git")
-  @test [keys(Pkg.installed())...] == ["Example"]
-  Pkg.status("Example", iob)
-  str = chomp(takebuf_string(iob))
-  @test startswith(str, " - Example")
-  @test endswith(str, "master")
-  Pkg.free("Example")
-  Pkg.status("Example", iob)
-  str = chomp(takebuf_string(iob))
-  @test endswith(str, string(Pkg.installed("Example")))
-  Pkg.checkout("Example")
-  Pkg.free(("Example",))
-  Pkg.status("Example", iob)
-  str = chomp(takebuf_string(iob))
-  @test endswith(str, string(Pkg.installed("Example")))
-  Pkg.rm("Example")
-  @test isempty(Pkg.installed())
-end
-
-# testing a package with test dependencies causes them to be installed for the duration of the test
-temp_pkg_dir() do
-  Pkg.generate("PackageWithTestDependencies", "MIT", config=Dict("user.name"=>"Julia Test", "user.email"=>"test@julialang.org"))
-  @test [keys(Pkg.installed())...] == ["PackageWithTestDependencies"]
-  @test readall(Pkg.dir("PackageWithTestDependencies","REQUIRE")) == "julia $(Pkg.Generate.versionfloor(VERSION))\n"
-
-  isdir(Pkg.dir("PackageWithTestDependencies","test")) || mkdir(Pkg.dir("PackageWithTestDependencies","test"))
-  open(Pkg.dir("PackageWithTestDependencies","test","REQUIRE"),"w") do f
-    println(f,"Example")
-  end
-
-  open(Pkg.dir("PackageWithTestDependencies","test","runtests.jl"),"w") do f
-    println(f,"using Base.Test")
-    println(f,"@test haskey(Pkg.installed(), \"Example\")")
-  end
-
-  Pkg.resolve()
-  @test [keys(Pkg.installed())...] == ["PackageWithTestDependencies"]
-
-  Pkg.test("PackageWithTestDependencies")
-
-  @test [keys(Pkg.installed())...] == ["PackageWithTestDependencies"]
-end
-
-# testing a package with no runtests.jl errors
-temp_pkg_dir() do
-  Pkg.generate("PackageWithNoTests", "MIT", config=Dict("user.name"=>"Julia Test", "user.email"=>"test@julialang.org"))
-
-  if isfile(Pkg.dir("PackageWithNoTests", "test", "runtests.jl"))
-    rm(Pkg.dir("PackageWithNoTests", "test", "runtests.jl"))
-  end
-
-  try
-    Pkg.test("PackageWithNoTests")
-  catch err
-    @test err.msg == "PackageWithNoTests did not provide a test/runtests.jl file"
-  end
-end
-
-# testing a package with failing tests errors
-temp_pkg_dir() do
-  Pkg.generate("PackageWithFailingTests", "MIT", config=Dict("user.name"=>"Julia Test", "user.email"=>"test@julialang.org"))
-
-  isdir(Pkg.dir("PackageWithFailingTests","test")) || mkdir(Pkg.dir("PackageWithFailingTests","test"))
-  open(Pkg.dir("PackageWithFailingTests", "test", "runtests.jl"),"w") do f
-    println(f,"using Base.Test")
-    println(f,"@test false")
-  end
-
-  try
-    Pkg.test("PackageWithFailingTests")
-  catch err
-    @test err.msg == "PackageWithFailingTests had test errors"
-  end
-end
-
-# Testing with code-coverage
-temp_pkg_dir() do
-  Pkg.generate("PackageWithCodeCoverage", "MIT", config=Dict("user.name"=>"Julia Test", "user.email"=>"test@julialang.org"))
-
-  src = """
-module PackageWithCodeCoverage
-
-export f1, f2, f3, untested
-
-f1(x) = 2x
-f2(x) = f1(x)
-function f3(x)
-    3x
-end
-untested(x) = 7
-
-end"""
-  linetested = [false, false, false, false, true, true, false, true, false, false]
-  open(Pkg.dir("PackageWithCodeCoverage", "src", "PackageWithCodeCoverage.jl"), "w") do f
-      println(f, src)
-  end
-  isdir(Pkg.dir("PackageWithCodeCoverage","test")) || mkdir(Pkg.dir("PackageWithCodeCoverage","test"))
-  open(Pkg.dir("PackageWithCodeCoverage", "test", "runtests.jl"),"w") do f
-    println(f,"using PackageWithCodeCoverage, Base.Test")
-    println(f,"@test f2(2) == 4")
-    println(f,"@test f3(5) == 15")
-  end
-
-  Pkg.test("PackageWithCodeCoverage")
-  covdir = Pkg.dir("PackageWithCodeCoverage","src")
-  covfiles = filter!(x -> contains(x, "PackageWithCodeCoverage.jl") && contains(x,".cov"), readdir(covdir))
-  @test isempty(covfiles)
-  Pkg.test("PackageWithCodeCoverage", coverage=true)
-  covfiles = filter!(x -> contains(x, "PackageWithCodeCoverage.jl") && contains(x,".cov"), readdir(covdir))
-  @test !isempty(covfiles)
-  for file in covfiles
-      @test isfile(joinpath(covdir,file))
-      covstr = readall(joinpath(covdir,file))
-      srclines = split(src, '\n')
-      covlines = split(covstr, '\n')
-      for i = 1:length(linetested)
-          covline = (linetested[i] ? "        1 " : "        - ")*srclines[i]
-          @test covlines[i] == covline
-      end
-  end
+    @test isfile(joinpath(Pkg.dir(),"REQUIRE"))
+    @test isfile(joinpath(Pkg.dir(),"META_BRANCH"))
+    @test isempty(Pkg.installed())
+    @test sprint(io -> Pkg.status(io)) == "No packages installed\n"
+    @test !isempty(Pkg.available())
+
+    # check that versioninfo(io, true) doesn't error and produces some output
+    # (done here since it calls Pkg.status which might error or clone metadata)
+    buf = PipeBuffer()
+    versioninfo(buf, true)
+    ver = readstring(buf)
+    @test startswith(ver, "Julia Version $VERSION")
+    @test contains(ver, "Environment:")
+
+    # Check that setprotocol! works.
+    begin
+        try
+            Pkg.setprotocol!("notarealprotocol")
+            Pkg.add("Example")
+            error("unexpected")
+        catch ex
+            if isa(ex, CompositeException)
+                ex = ex.exceptions[1]
+
+                if isa(ex, CapturedException)
+                    ex = ex.ex
+                end
+            end
+            @test isa(ex,Pkg.PkgError)
+            @test ex.msg == "Cannot clone Example from notarealprotocol://github.com/JuliaLang/Example.jl.git. Unsupported URL protocol"
+        end
+    end
+
+    Pkg.setprotocol!("https")
+    Pkg.add("Example")
+    @test [keys(Pkg.installed())...] == ["Example"]
+    iob = IOBuffer()
+    Pkg.checkout("Example")
+    Pkg.status("Example", iob)
+    str = chomp(takebuf_string(iob))
+    @test startswith(str, " - Example")
+    @test endswith(str, "master")
+    Pkg.free("Example")
+    Pkg.status("Example", iob)
+    str = chomp(takebuf_string(iob))
+    @test endswith(str, string(Pkg.installed("Example")))
+    Pkg.checkout("Example")
+    Pkg.free(("Example",))
+    Pkg.status("Example", iob)
+    str = chomp(takebuf_string(iob))
+    @test endswith(str, string(Pkg.installed("Example")))
+    Pkg.rm("Example")
+    @test isempty(Pkg.installed())
+    @test !isempty(Pkg.available("Example"))
+    @test !in("Example", keys(Pkg.installed()))
+    Pkg.clone("https://github.com/JuliaLang/Example.jl.git")
+    @test [keys(Pkg.installed())...] == ["Example"]
+    Pkg.status("Example", iob)
+    str = chomp(takebuf_string(iob))
+    @test startswith(str, " - Example")
+    @test endswith(str, "master")
+    Pkg.free("Example")
+    Pkg.status("Example", iob)
+    str = chomp(takebuf_string(iob))
+    @test endswith(str, string(Pkg.installed("Example")))
+    Pkg.checkout("Example")
+    Pkg.free(("Example",))
+    Pkg.status("Example", iob)
+    str = chomp(takebuf_string(iob))
+    @test endswith(str, string(Pkg.installed("Example")))
+    @test isempty(Pkg.dependents("Example"))
+
+    # adding a package with unsatisfiable julia version requirements (REPL.jl) errors
+    try
+        Pkg.add("REPL")
+        error("unexpected")
+    catch err
+        @test isa(err.exceptions[1].ex, PkgError)
+        @test err.exceptions[1].ex.msg == "REPL can't be installed because " *
+            "it has no versions that support $VERSION of julia. You may " *
+            "need to update METADATA by running `Pkg.update()`"
+    end
+
+    # trying to add, check availability, or pin a nonexistent package errors
+    try
+        Pkg.add("NonexistentPackage")
+        error("unexpected")
+    catch err
+        @test isa(err.exceptions[1].ex, PkgError)
+        @test err.exceptions[1].ex.msg == "unknown package NonexistentPackage"
+    end
+    try
+        Pkg.available("NonexistentPackage")
+        error("unexpected")
+    catch err
+        @test isa(err, PkgError)
+        @test err.msg == "NonexistentPackage is not a package (not registered or installed)"
+    end
+    try
+        Pkg.pin("NonexistentPackage", v"1.0.0")
+        error("unexpected")
+    catch err
+        @test isa(err, PkgError)
+        @test err.msg == "NonexistentPackage is not a git repo"
+    end
+
+    # trying to pin a git repo under Pkg.dir that is not an installed package errors
+    try
+        Pkg.pin("METADATA", v"1.0.0")
+        error("unexpected")
+    catch err
+        @test isa(err, PkgError)
+        @test err.msg == "METADATA cannot be pinned – not an installed package"
+    end
+
+    # trying to pin an installed, registered package to an unregistered version errors
+    try
+        Pkg.pin("Example", v"2147483647.0.0")
+        error("unexpected")
+    catch err
+        @test isa(err, PkgError)
+        @test err.msg == "Example – 2147483647.0.0 is not a registered version"
+    end
+
+    # PR #13572, handling of versions with untagged detached heads
+    LibGit2.with(LibGit2.GitRepo, Pkg.dir("Example")) do repo
+        LibGit2.checkout!(repo, "72f09c7d0099793378c645929a9961155faae6d2")
+    end
+    @test Pkg.installed()["Example"] > v"0.0.0"
+
+    # issue #13583
+    begin
+        try
+            Pkg.test("IDoNotExist")
+            error("unexpected")
+        catch ex
+            @test isa(ex,Pkg.PkgError)
+            @test ex.msg == "IDoNotExist is not an installed package"
+        end
+
+        try
+            Pkg.test("IDoNotExist1", "IDoNotExist2")
+            error("unexpected")
+        catch ex
+            @test isa(ex,Pkg.PkgError)
+            @test ex.msg == "IDoNotExist1 and IDoNotExist2 are not installed packages"
+        end
+    end
+
+    begin
+        Pkg.pin("Example")
+        Pkg.free("Example")
+
+        Pkg.pin("Example", v"0.4.0")
+        Pkg.update()
+        Pkg.installed()["Example"] == v"0.4.0"
+    end
+
+    # add a directory that is not a git repository
+    begin
+        mkdir(joinpath(Pkg.dir(), "NOTGIT"))
+        Pkg.installed("NOTGIT") == typemin(VersionNumber)
+        Pkg.installed()["NOTGIT"] == typemin(VersionNumber)
+    end
+
+    begin
+        # don't bork when a Pkg repo is bare, issue #13804
+        pth = joinpath(Pkg.dir(), "BAREGIT")
+        mkdir(pth)
+        # create a bare repo (isbare = true)
+        repo = LibGit2.init(pth, true)
+        @test repo.ptr != C_NULL
+        finalize(repo)
+        Pkg.update()
+    end
+
+    #test PkgDev redirects
+    begin
+        try
+            Pkg.register("IDoNotExist")
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.register(pkg,[url]) has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+
+        try
+            Pkg.tag("IDoNotExist")
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.tag(pkg, [ver, [commit]]) has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+
+        try
+            Pkg.generate("IDoNotExist","MIT")
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.generate(pkg, license) has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+
+        try
+            Pkg.publish()
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.publish() has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+
+        try
+            Pkg.license()
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.license([lic]) has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+        try
+            Pkg.submit("IDoNotExist")
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.submit(pkg[, commit]) has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+        try
+            Pkg.submit("IDoNotExist", "nonexistentcommit")
+            error("unexpected")
+        catch ex
+            @test ex.msg == "Pkg.submit(pkg[, commit]) has been moved to the package PkgDev.jl.\nRun Pkg.add(\"PkgDev\") to install PkgDev on Julia v0.5-"
+        end
+    end
 end
diff --git a/test/pollfd.jl b/test/pollfd.jl
index 2044663f7df2b..1c0a178fd737c 100644
--- a/test/pollfd.jl
+++ b/test/pollfd.jl
@@ -9,7 +9,7 @@
 # Writable ends are always tested for writability before a write
 
 n = 20
-intvls = [2, .2, .1, .002]
+intvls = [2, .2, .1, .005]
 
 pipe_fds = cell(n)
 for i in 1:n
@@ -33,8 +33,8 @@ function pfd_tst_reads(idx, intvl)
     @test @windows ? evt.writable : !evt.writable
 
     # println("Expected ", intvl, ", actual ", t_elapsed, ", diff ", t_elapsed - intvl)
-    # Assuming that a 2 second buffer is good enough on a modern system
-    @test t_elapsed <= (intvl + 1)
+    # Disabled since this assertion fails randomly, notably on build VMs (issue #12824)
+    # @test t_elapsed <= (intvl + 1)
 
     dout = Array(UInt8, 1)
     @windows ? (
@@ -56,8 +56,9 @@ function pfd_tst_timeout(idx, intvl)
     @test !evt.writable
     t_elapsed = toq()
 
-    @unix_only @test (intvl <= t_elapsed) # TODO: enable this test on windows when the libuv version is bumped
-    @test (t_elapsed <= (intvl + 1))
+    # Disabled since these assertions fail randomly, notably on build VMs (issue #12824)
+    # @unix_only @test (intvl <= t_elapsed) # TODO: enable this test on windows when the libuv version is bumped
+    # @test (t_elapsed <= (intvl + 1))
 end
 
 
diff --git a/test/printf.jl b/test/printf.jl
index 102a4e171bc51..061f87dfe2720 100644
--- a/test/printf.jl
+++ b/test/printf.jl
@@ -3,6 +3,9 @@
 # printf
 # int
 @test (@sprintf "%d" typemax(Int64)) == "9223372036854775807"
+@test (@sprintf "%a" typemax(Int64)) == "0x7.fffffffffffffffp+60"
+@test (@sprintf "%A" typemax(Int64)) == "0X7.FFFFFFFFFFFFFFFP+60"
+
 for (fmt, val) in (("%i", "42"),
                    ("%u", "42"),
                    ("Test: %i", "Test: 42"),
@@ -13,7 +16,10 @@ for (fmt, val) in (("%i", "42"),
                    ("% i", " 42"),
                    ("%+i", "+42"),
                    ("%4i", "  42"),
-                   ("%-4i", "42  "))
+                   ("%-4i", "42  "),
+                   ("%a","0x2.ap+4"),
+                   ("%20a","            0x2.ap+4"),
+                   ("%-20a","0x2.ap+4            "))
     @test( @eval(@sprintf($fmt, 42) == $val))
 end
 
@@ -73,8 +79,15 @@ end
 @test( @sprintf( "%.6g", big"12340000.0" ) == "1.234e+07")
 @test( @sprintf( "%#.6g", big"12340000.0") == "1.23400e+07")
 
+# %g regression gh #14331
+@test( @sprintf( "%.5g", 42) == "42")
+@test( @sprintf( "%#.2g", 42) == "42.")
+@test( @sprintf( "%#.5g", 42) == "42.000")
+
 # hex float
 @test (@sprintf "%a" 1.5) == "0x1.8p+0"
+@test (@sprintf "%a" 1.5f0) == "0x1.8p+0"
+@test (@sprintf "%a" big"1.5") == "0x1.8p+0"
 @test (@sprintf "%#.0a" 1.5) == "0x2.p+0"
 @test (@sprintf "%+30a" 1/3) == "         +0x1.5555555555555p-2"
 
diff --git a/test/random.jl b/test/random.jl
index dc78c9368239d..bbff7ccea5f87 100644
--- a/test/random.jl
+++ b/test/random.jl
@@ -275,8 +275,15 @@ let mt = MersenneTwister()
     a = Array(Float64, 0)
     resize!(a, 1000) # could be 8-byte aligned
     b = Array(Float64, 1000) # should be 16-byte aligned
-    c8 = Array(UInt8, 8001)
-    c = pointer_to_array(Ptr{Float64}(pointer(c8, 2)), 1000) # Int(pointer(c)) % 16 == 1
+    c8 = Array(UInt64, 1001)
+    pc8 = pointer(c8)
+    if Int(pc8) % 16 == 0
+        # Make sure pc8 is not 16-byte aligned since that's what we want to test.
+        # It still has to be 8-byte aligned since it is otherwise invalid on
+        # certain architectures (e.g. ARM)
+        pc8 += 8
+    end
+    c = pointer_to_array(Ptr{Float64}(pc8), 1000) # Int(pointer(c)) % 16 == 8
 
     for A in (a, b, c)
         srand(mt, 0)
@@ -286,6 +293,11 @@ let mt = MersenneTwister()
     end
 end
 
+# make sure reading 128-bit ints from RandomDevice works
+let a = [rand(RandomDevice(), UInt128) for i=1:10]
+    @test reduce(|, a)>>>64 != 0
+end
+
 # test all rand APIs
 for rng in ([], [MersenneTwister()], [RandomDevice()])
     for f in [rand, randn, randexp]
@@ -303,7 +315,7 @@ for rng in ([], [MersenneTwister()], [RandomDevice()])
     rand!(rng..., BitArray(5))     ::BitArray{1}
     rand!(rng..., BitArray(2, 3))  ::BitArray{2}
 
-    for T in [Base.IntTypes..., Bool, Char, Float16, Float32, Float64]
+    for T in [Base.BitInteger_types..., Bool, Char, Float16, Float32, Float64]
         a0 = rand(rng..., T)       ::T
         a1 = rand(rng..., T, 5)    ::Vector{T}
         a2 = rand(rng..., T, 2, 3) ::Array{T, 2}
diff --git a/test/ranges.jl b/test/ranges.jl
index a4a53ed49cc02..3882c02ca302e 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -45,6 +45,8 @@ r = 5:-1:1
 @test isempty((1:4)[5:4])
 @test_throws BoundsError (1:10)[8:-1:-2]
 
+@test findin([5.2, 3.3], 3:20) == findin([5.2, 3.3], collect(3:20))
+
 let
     span = 5:20
     r = -7:3:42
@@ -108,6 +110,12 @@ end
 @test intersect(reverse(typemin(Int):2:typemax(Int)),typemin(Int):2:typemax(Int)) == reverse(typemin(Int):2:typemax(Int))
 @test intersect(typemin(Int):2:typemax(Int),reverse(typemin(Int):2:typemax(Int))) == typemin(Int):2:typemax(Int)
 
+@test intersect(UnitRange(1,2),3) == UnitRange(3,2)
+@test intersect(UnitRange(1,2), UnitRange(1,5), UnitRange(3,7), UnitRange(4,6)) == UnitRange(4,3)
+
+@test sort(UnitRange(1,2)) == UnitRange(1,2)
+@test sort!(UnitRange(1,2)) == UnitRange(1,2)
+
 @test 0 in UInt(0):100:typemax(UInt)
 @test last(UInt(0):100:typemax(UInt)) in UInt(0):100:typemax(UInt)
 @test -9223372036854775790 in -9223372036854775790:100:9223372036854775710
@@ -183,6 +191,12 @@ let s = 0
     end
     @test s == 256
 
+    s = 0
+    for i = typemin(UInt8):one(UInt8):typemax(UInt8)
+        s += 1
+    end
+    @test s == 256
+
     # loops past typemax(Int)
     n = 0
     s = Int128(0)
@@ -237,6 +251,7 @@ end
 @test (1:2:6) + 0.3 == 1+0.3:2:5+0.3
 @test (1:2:6) - 1 == 0:2:4
 @test (1:2:6) - 0.3 == 1-0.3:2:5-0.3
+@test 2 .- (1:3) == 1:-1:-1
 
 # operations between ranges and arrays
 @test all(([1:5;] + (5:-1:1)) .== 6)
@@ -441,7 +456,7 @@ r = linspace(1/3,5/7,6)
 @test abs(r[end] - 5/7) <= eps(5/7)
 r = linspace(0.25,0.25,1)
 @test length(r) == 1
-@test_throws Exception linspace(0.25,0.5,1)
+@test_throws ErrorException linspace(0.25,0.5,1)
 
 # issue #7426
 @test [typemax(Int):1:typemax(Int);] == [typemax(Int)]
@@ -517,6 +532,8 @@ end
 @test convert(StepRange, 0:5) === 0:1:5
 @test convert(StepRange{Int128,Int128}, 0.:5) === Int128(0):Int128(1):Int128(5)
 
+@test_throws ArgumentError StepRange(1.1,1,5.1)
+
 @test promote(0f0:inv(3f0):1f0, 0.:2.:5.) === (0:1/3:1, 0.:2.:5.)
 @test convert(FloatRange{Float64}, 0:1/3:1) === 0:1/3:1
 @test convert(FloatRange{Float64}, 0f0:inv(3f0):1f0) === 0:1/3:1
@@ -544,6 +561,21 @@ for x in r
 end
 @test i == 7
 
+# stringmime/writemime should display the range or linspace nicely
+# to test print_range in range.jl
+replstrmime(x) = stringmime("text/plain", x)
+@test replstrmime(1:4) == "4-element UnitRange{$Int}:\n 1,2,3,4"
+@test replstrmime(linspace(1,5,7)) == "7-element LinSpace{Float64}:\n 1.0,1.66667,2.33333,3.0,3.66667,4.33333,5.0"
+@test replstrmime(0:100.) == "101-element FloatRange{Float64}:\n 0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,…,94.0,95.0,96.0,97.0,98.0,99.0,100.0"
+# next is to test a very large range, which should be fast because print_range
+# only examines spacing of the left and right edges of the range, sufficient
+# to cover the designated screen size.
+@test replstrmime(0:10^9) == "1000000001-element UnitRange{$Int}:\n 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,…,999999998,999999999,1000000000"
+
+@test sprint(io -> show(io,UnitRange(1,2))) == "1:2"
+@test sprint(io -> show(io,StepRange(1,2,5))) == "1:2:5"
+
+
 # Issue 11049 and related
 @test promote(linspace(0f0, 1f0, 3), linspace(0., 5., 2)) ===
     (linspace(0., 1., 3), linspace(0., 5., 2))
@@ -664,3 +696,12 @@ test_range_sum_diff(1.:5., linspace(0, 8, 5),
 let r = 0x02:0x05
     @test r[2:3] == 0x03:0x04
 end
+
+# Issue #13738
+for r in (big(1):big(2), UInt128(1):UInt128(2), 0x1:0x2)
+    rr = r[r]
+    @test typeof(rr) == typeof(r)
+    @test r[r] == r
+    # these calls to similar must not throw:
+    @test size(similar(r, size(r))) == size(similar(r, length(r)))
+end
diff --git a/test/read.jl b/test/read.jl
new file mode 100644
index 0000000000000..40b6f90bc9243
--- /dev/null
+++ b/test/read.jl
@@ -0,0 +1,487 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+mktempdir() do dir
+
+tasks = []
+
+# Create test file...
+filename = joinpath(dir, "file.txt")
+text = "C1,C2\n1,2\na,b\n"
+
+# List of IO producers...
+l = Vector{Tuple{AbstractString,Function}}()
+
+
+# File
+io = (text) -> begin
+    write(filename, text)
+    Base.Filesystem.open(filename, Base.Filesystem.JL_O_RDONLY)
+end
+s = io(text)
+@test isa(s, IO)
+@test isa(s, Base.Filesystem.File)
+close(s)
+push!(l, ("File", io))
+
+
+# IOStream
+io = (text) -> begin
+    write(filename, text)
+    open(filename)
+end
+s = io(text)
+@test isa(s, IO)
+@test isa(s, IOStream)
+close(s)
+push!(l, ("IOStream", io))
+
+
+# IOBuffer
+io = (text)->IOBuffer(text)
+s = io(text)
+@test isa(s, IO)
+@test isa(s, IOBuffer)
+close(s)
+push!(l, ("IOBuffer", io))
+
+
+function run_test_server(srv, text)
+    push!(tasks, @async begin
+        try
+            sock = accept(srv)
+            try
+                write(sock,text)
+            catch e
+                if typeof(e) != Base.UVError
+                    rethrow(e)
+                end
+            finally
+                close(sock)
+            end
+        finally
+            close(srv)
+        end
+    end)
+    yield()
+end
+
+
+# TCPSocket
+io = (text) -> begin
+    port, srv = listenany(rand(2000:4000))
+    run_test_server(srv, text)
+    connect(port)
+end
+s = io(text)
+@test isa(s, IO)
+@test isa(s, TCPSocket)
+close(s)
+push!(l, ("TCPSocket", io))
+
+
+# PipeEndpoint
+io = (text) -> begin
+    a = "\\\\.\\pipe\\uv-test-$(randstring(6))"
+    b = joinpath(dir, "socket-$(randstring(6))")
+    socketname = @windows ? a : b
+    srv = listen(socketname)
+    run_test_server(srv, text)
+    connect(socketname)
+end
+s = io(text)
+@test isa(s, IO)
+@test isa(s, Base.PipeEndpoint)
+close(s)
+push!(l, ("PipeEndpoint", io))
+
+
+#FIXME See https://github.com/JuliaLang/julia/issues/14747
+#      Reading from open(::Command) seems to deadlock on Linux/Travis
+#=
+@windows ? nothing : begin
+
+# Windows type command not working?
+# See "could not spawn `type 'C:\Users\appveyor\AppData\Local\Temp\1\jul3516.tmp\file.txt'`"
+#https://ci.appveyor.com/project/StefanKarpinski/julia/build/1.0.12733/job/hpwjs4hmf03vs5ag#L1244
+
+# Pipe
+io = (text) -> begin
+    write(filename, text)
+    open(`$(@windows ? "type" : "cat") $filename`)[1]
+#    Was open(`echo -n $text`)[1]
+#    See https://github.com/JuliaLang/julia/issues/14747
+end
+s = io(text)
+@test isa(s, IO)
+@test isa(s, Pipe)
+close(s)
+push!(l, ("Pipe", io))
+
+end
+=#
+
+
+open_streams = []
+function cleanup()
+    for s in open_streams
+        try close(s) end
+    end
+    empty!(open_streams)
+    for tsk in tasks
+        wait(tsk)
+    end
+    empty!(tasks)
+end
+
+
+verbose = false
+
+
+for (name, f) in l
+
+    io = ()->(s=f(text); push!(open_streams, s); s)
+
+    write(filename, text)
+
+    verbose && println("$name read...")
+    @test read(io(), UInt8) == read(IOBuffer(text), UInt8)
+    @test read(io(), UInt8) == read(filename, UInt8)
+    @test read(io(), Int) == read(IOBuffer(text), Int)
+    @test read(io(), Int) == read(filename,Int)
+    s1 = io()
+    s2 = IOBuffer(text)
+    @test read(s1, UInt32, 2) == read(s2, UInt32, 2)
+    @test !eof(s1)
+    @test read(s1, UInt8, 5) == read(s2, UInt8, 5)
+    @test !eof(s1)
+    @test read(s1, UInt8, 1) == read(s2, UInt8, 1)
+    @test eof(s1)
+    @test_throws EOFError read(s1, UInt8)
+    @test eof(s1)
+    close(s1)
+    close(s2)
+
+    verbose && println("$name eof...")
+    n = length(text) - 1
+    @test read!(io(), Vector{UInt8}(n)) ==
+          read!(IOBuffer(text), Vector{UInt8}(n))
+    @test (s = io(); read!(s, Vector{UInt8}(n)); !eof(s))
+    n = length(text)
+    @test read!(io(), Vector{UInt8}(n)) ==
+          read!(IOBuffer(text), Vector{UInt8}(n))
+    @test (s = io(); read!(s, Vector{UInt8}(n)); eof(s))
+    n = length(text) + 1
+    @test_throws EOFError read!(io(), Vector{UInt8}(n))
+    @test_throws EOFError read!(io(), Vector{UInt8}(n))
+
+    old_text = text
+    cleanup()
+
+    for text in [
+        old_text,
+        UTF8String(Char['A' + i % 52 for i in 1:(div(Base.SZ_UNBUFFERED_IO,2))]),
+        UTF8String(Char['A' + i % 52 for i in 1:(    Base.SZ_UNBUFFERED_IO -1)]),
+        UTF8String(Char['A' + i % 52 for i in 1:(    Base.SZ_UNBUFFERED_IO   )]),
+        UTF8String(Char['A' + i % 52 for i in 1:(    Base.SZ_UNBUFFERED_IO +1)])
+    ]
+
+        write(filename, text)
+
+        verbose && println("$name readstring...")
+        @test readstring(io()) == text
+
+        @test readstring(io()) == readstring(filename)
+
+
+        verbose && println("$name read...")
+        @test read(io()) == Vector{UInt8}(text)
+
+        @test read(io()) == read(filename)
+
+        cleanup()
+
+
+        verbose && println("$name readbytes!...")
+        l = length(text)
+        for n = [1, 2, l-2, l-1, l, l+1, l+2]
+            a1 = Vector{UInt8}(n);
+            a2 = Vector{UInt8}(n)
+            s1 = io()
+            s2 = IOBuffer(text)
+            n1 = readbytes!(s1, a1)
+            n2 = readbytes!(s2, a2)
+            @test n1 == n2
+            @test length(a1) == length(a2)
+            @test a1[1:n1] == a2[1:n2]
+            @test n <= length(text) || eof(s1)
+            @test n <= length(text) || eof(s2)
+
+            cleanup()
+        end
+
+        verbose && println("$name read!...")
+        l = length(text)
+        for n = [1, 2, l-2, l-1, l]
+            @test read!(io(), Vector{UInt8}(n)) ==
+                  read!(IOBuffer(text), Vector{UInt8}(n))
+            @test read!(io(), Vector{UInt8}(n)) ==
+                  read!(filename, Vector{UInt8}(n))
+
+            cleanup()
+        end
+        @test_throws EOFError read!(io(), Vector{UInt8}(length(text)+1))
+
+
+        verbose && println("$name readuntil...")
+        @test readuntil(io(), '\n') == readuntil(IOBuffer(text),'\n')
+        @test readuntil(io(), '\n') == readuntil(filename,'\n')
+        @test readuntil(io(), "\n") == readuntil(IOBuffer(text),"\n")
+        @test readuntil(io(), "\n") == readuntil(filename,"\n")
+        @test readuntil(io(), ',')  == readuntil(IOBuffer(text),',')
+        @test readuntil(io(), ',')  == readuntil(filename,',')
+
+        cleanup()
+
+        verbose && println("$name readline...")
+        @test readline(io()) == readline(IOBuffer(text))
+        @test readline(io()) == readline(filename)
+
+        verbose && println("$name readlines...")
+        @test readlines(io()) == readlines(IOBuffer(text))
+        @test readlines(io()) == readlines(filename)
+        @test collect(eachline(io())) == collect(eachline(IOBuffer(text)))
+        @test collect(eachline(io())) == collect(eachline(filename))
+
+        cleanup()
+
+        verbose && println("$name countlines...")
+        @test countlines(io()) == countlines(IOBuffer(text))
+
+        verbose && println("$name readcsv...")
+        @test readcsv(io()) == readcsv(IOBuffer(text))
+        @test readcsv(io()) == readcsv(filename)
+
+        cleanup()
+    end
+
+    text = old_text
+    write(filename, text)
+
+    if !(typeof(io()) in [Base.PipeEndpoint, Pipe, TCPSocket])
+
+        verbose && println("$name position...")
+        @test (s = io(); read!(s, Vector{UInt8}(4)); position(s))  == 4
+
+        verbose && println("$name seek...")
+        for n = 0:length(text)-1
+            @test readlines(seek(io(), n)) == readlines(seek(IOBuffer(text), n))
+            cleanup()
+        end
+        verbose && println("$name skip...")
+        for n = 0:length(text)-1
+            @test readlines(seek(io(), n)) == readlines(seek(IOBuffer(text), n))
+            @test readlines(skip(io(), n)) == readlines(skip(IOBuffer(text), n))
+            cleanup()
+        end
+        verbose && println("$name seekend...")
+        @test readstring(seekend(io())) == ""
+    end
+
+
+    verbose && println("$name write(::IOStream, ...)")
+    to = open("$filename.to", "w")
+    write(to, io())
+    close(to)
+    @test readstring("$filename.to") == text
+
+    verbose && println("$name write(filename, ...)")
+    write("$filename.to", io())
+    @test readstring("$filename.to") == text
+
+    verbose && println("$name write(::IOBuffer, ...)")
+    to = IOBuffer(Vector{UInt8}(copy(text)), false, true)
+    write(to, io())
+    @test takebuf_string(to) == text
+
+    cleanup()
+end
+
+function test_read_nbyte()
+    fn = tempname()
+    # Write one byte. One byte read should work once
+    # but 2-byte read should throw EOFError.
+    f = open(fn, "w+") do f
+        write(f, 0x55)
+        flush(f)
+        seek(f, 0)
+        @test read(f, UInt8) == 0x55
+        @test_throws EOFError read(f, UInt8)
+        seek(f, 0)
+        @test_throws EOFError read(f, UInt16)
+    end
+    # Write 2 more bytes. Now 2-byte read should work once
+    # but 4-byte read should fail with EOFError.
+    open(fn, "a+") do f
+        write(f, 0x4444)
+        flush(f)
+        seek(f, 0)
+        @test read(f, UInt16) == 0x4455
+        @test_throws EOFError read(f, UInt16)
+        seek(f, 0)
+        @test_throws EOFError read(f, UInt32)
+    end
+    # Write 4 more bytes. Now 4-byte read should work once
+    # but 8-byte read should fail with EOFError.
+    open(fn, "a+") do f
+        write(f, 0x33333333)
+        flush(f)
+        seek(f, 0)
+        @test read(f, UInt32) == 0x33444455
+        @test_throws EOFError read(f, UInt32)
+        seek(f, 0)
+        @test_throws EOFError read(f, UInt64)
+    end
+    # Writing one more byte should allow an 8-byte
+    # read to proceed.
+    open(fn, "a+") do f
+        write(f, 0x22)
+        flush(f)
+        seek(f, 0)
+        @test read(f, UInt64) == 0x2233333333444455
+    end
+    rm(fn)
+end
+test_read_nbyte()
+
+
+# DevNull
+@test !isreadable(DevNull)
+@test iswritable(DevNull)
+@test isopen(DevNull)
+@test write(DevNull, 0xff) === 1
+@test write(DevNull, Int32(1234)) === 4
+@test_throws EOFError read(DevNull, UInt8)
+@test close(DevNull) === nothing
+@test flush(DevNull) === nothing
+@test copy(DevNull) === DevNull
+@test eof(DevNull)
+@test print(DevNull, "go to /dev/null") === nothing
+
+
+let s = "qwerty"
+    @test read(IOBuffer(s)) == s.data
+    @test read(IOBuffer(s), 10) == s.data
+    @test read(IOBuffer(s), 1) == s.data[1:1]
+
+    # Test growing output array
+    x = UInt8[]
+    n = readbytes!(IOBuffer(s), x, 10)
+    @test x == s.data
+    @test n == length(x)
+end
+
+
+# Filesystem.File
+f = joinpath(dir, "test.txt")
+open(io->write(io, "123"), f, "w")
+f1 = open(f)
+f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+@test read(f1, UInt8) == read(f2, UInt8) == '1'
+@test read(f1, UInt8) == read(f2, UInt8) == '2'
+@test read(f1, UInt8) == read(f2, UInt8) == '3'
+@test_throws EOFError read(f1, UInt8)
+@test_throws EOFError read(f2, UInt8)
+close(f1)
+close(f2)
+
+a = UInt8[0,0,0]
+f1 = open(f)
+f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+@test read!(f1, a) == read!(f2, a) == UInt8['1','2','3']
+@test_throws EOFError read!(f1, a)
+@test_throws EOFError read!(f2, a)
+close(f1)
+close(f2)
+
+a = UInt8[0,0,0,0]
+f1 = open(f)
+f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+@test_throws EOFError read!(f1, a)
+@test_throws EOFError read!(f2, a)
+close(f1)
+close(f2)
+rm(f)
+
+io = Base.Filesystem.open(f, Base.Filesystem.JL_O_WRONLY | Base.Filesystem.JL_O_CREAT | Base.Filesystem.JL_O_EXCL, 0o000)
+@test write(io, "abc") == 3
+close(io)
+@unix_only begin
+    # msvcrt _wchmod documentation states that all files are readable,
+    # so we don't test that it correctly set the umask on windows
+    @test_throws SystemError open(f)
+    @test_throws Base.UVError Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+end
+chmod(f, 0o400)
+f1 = open(f)
+f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+for i = 1:2
+    @test !eof(f1)
+    @test !eof(f2)
+    @test position(f1) == 0
+    @test position(f2) == 0
+    @test readstring(f1) == readstring(f2) == "abc"
+    @test readstring(f1) == readstring(f2) == ""
+    @test position(f1) == 3
+    @test position(f2) == 3
+    @test eof(f1)
+    @test eof(f2)
+    @test seekstart(f1) == f1
+    @test seekstart(f2) == f2
+end
+@test seekend(f1) == f1
+@test seekend(f2) == f2
+@test eof(f1)
+@test eof(f2)
+@test skip(f1, -2) == f1
+@test skip(f2, -2) == f2
+@test position(f1) == 1
+@test position(f2) == 1
+@test_throws SystemError skip(f1, -2)
+@test_throws SystemError skip(f2, -2)
+@test position(f1) == 1
+@test position(f2) == 1
+@test skip(f1, 300) == f1
+@test skip(f2, 300) == f2
+@test position(f1) == 301
+@test position(f2) == 301
+@test eof(f1)
+@test eof(f2)
+@test_throws ArgumentError write(f1, '*')
+@test_throws Base.UVError write(f2, '*')
+close(f1)
+close(f2)
+@test eof(f1)
+@test_throws Base.UVError eof(f2)
+
+@test_throws SystemError open(f, "r+")
+@test_throws Base.UVError Base.Filesystem.open(f, Base.Filesystem.JL_O_RDWR)
+chmod(f, 0o600)
+f1 = open(f, "r+")
+f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDWR)
+@test skip(f1, 10) == f1
+@test skip(f2, 10) == f2
+@test eof(f1)
+@test eof(f2)
+@test write(f1, '*') == 1; @test flush(f1) == f1
+@test !eof(f2)
+@test skip(f2, 1) == f2
+@test write(f2, '*') == 1
+@test !eof(f1)
+@test seekstart(f1) == f1
+@test seekstart(f2) == f2
+@test readstring(f1) == readstring(f2) == "abc\0\0\0\0\0\0\0**"
+close(f1)
+close(f2)
+rm(f)
+
+end
diff --git a/test/reduce.jl b/test/reduce.jl
index c5accb3db1542..177f76859d32e 100644
--- a/test/reduce.jl
+++ b/test/reduce.jl
@@ -33,7 +33,7 @@
 
 # sum
 
-@test sum(Int8[]) === 0
+@test sum(Int8[]) === Int32(0)
 @test sum(Int[]) === Int(0)
 @test sum(Float64[]) === 0.0
 
@@ -41,7 +41,7 @@
 @test sum(3) === 3
 @test sum(3.0) === 3.0
 
-@test sum([Int8(3)]) === 3
+@test sum([Int8(3)]) === Int32(3)
 @test sum([3]) === 3
 @test sum([3.0]) === 3.0
 
@@ -62,14 +62,14 @@ fz = float(z)
 a = randn(32) # need >16 elements to trigger BLAS code path
 b = complex(randn(32), randn(32))
 @test sumabs(Float64[]) === 0.0
-@test sumabs([Int8(-2)]) === 2
+@test sumabs([Int8(-2)]) === Int32(2)
 @test sumabs(z) === 14
 @test sumabs(fz) === 14.0
 @test_approx_eq sumabs(a) sum(abs(a))
 @test_approx_eq sumabs(b) sum(abs(b))
 
 @test sumabs2(Float64[]) === 0.0
-@test sumabs2([Int8(-2)]) === 4
+@test sumabs2([Int8(-2)]) === Int32(4)
 @test sumabs2(z) === 54
 @test sumabs2(fz) === 54.0
 @test_approx_eq sumabs2(a) sum(abs2(a))
@@ -105,11 +105,11 @@ end
 # prod
 
 @test prod(Int[]) === 1
-@test prod(Int8[]) === 1
+@test prod(Int8[]) === Int32(1)
 @test prod(Float64[]) === 1.0
 
 @test prod([3]) === 3
-@test prod([Int8(3)]) === 3
+@test prod([Int8(3)]) === Int32(3)
 @test prod([3.0]) === 3.0
 
 @test prod(z) === 120
@@ -118,14 +118,14 @@ end
 @test prod(1:big(16)) == big(20922789888000)
 @test prod(big(typemax(Int64)):big(typemax(Int64))+16) == parse(BigInt,"25300281663413827620486300433089141956148633919452440329174083959168114253708467653081909888307573358090001734956158476311046124934597861626299416732205795533726326734482449215730132757595422510465791525610410023802664753402501982524443370512346073948799084936298007821432734720004795146875180123558814648586972474376192000")
 
-@test_throws ErrorException prod(bitunpack(trues(10)))
+@test typeof(prod(bitunpack(trues(10)))) == Bool
 
 # check type-stability
 prod2(itr) = invoke(prod, Tuple{Any}, itr)
 @test prod(Int[]) === prod2(Int[]) === 1
 @test prod(Int[7]) === prod2(Int[7]) === 7
-@test typeof(prod(Int8[])) == typeof(prod(Int8[1])) == typeof(prod(Int8[1, 7])) == Int
-@test typeof(prod2(Int8[])) == typeof(prod2(Int8[1])) == typeof(prod2(Int8[1 7])) == Int
+@test typeof(prod(Int8[])) == typeof(prod(Int8[1])) == typeof(prod(Int8[1, 7])) == Int32
+@test typeof(prod2(Int8[])) == typeof(prod2(Int8[1])) == typeof(prod2(Int8[1 7])) == Int32
 
 # maximum & minimum & extrema
 
@@ -219,7 +219,7 @@ end
 # any and all with functors
 
 immutable SomeFunctor end
-Base.call(::SomeFunctor, x) = true
+(::SomeFunctor)(x) = true
 
 @test any(SomeFunctor(), 1:10)
 @test all(SomeFunctor(), 1:10)
@@ -271,6 +271,14 @@ end
 @test sum(collect(map(UInt8,0:255))) == 32640
 @test sum(collect(map(UInt8,254:255))) == 509
 
+A = reshape(map(UInt8, 101:109), (3,3))
+@test @inferred(sum(A)) == 945
+@test @inferred(sum(sub(A, 1:3, 1:3))) == 945
+
+A = reshape(map(UInt8, 1:100), (10,10))
+@test @inferred(sum(A)) == 5050
+@test @inferred(sum(sub(A, 1:10, 1:10))) == 5050
+
 # issue #11618
 @test sum([-0.0]) === -0.0
 @test sum([-0.0, -0.0]) === -0.0
diff --git a/test/reducedim.jl b/test/reducedim.jl
index da2d5192dccd4..1c74fa5b3959c 100644
--- a/test/reducedim.jl
+++ b/test/reducedim.jl
@@ -113,15 +113,23 @@ R = reducedim((a,b) -> a+b, [1 2; 3 4], 2, 0.0)
 rt = Base.return_types(reducedim, Tuple{Function, Array{Float64, 3}, Int, Float64})
 @test length(rt) == 1 && rt[1] == Array{Float64, 3}
 
+
 ## findmin/findmax
 A = [1.0 3.0 6.0;
      5.0 2.0 4.0]
-@test findmin(A, (1,)) == ([1.0 2.0 4.0], [1 4 6])
-@test findmin(A, (2,)) == (reshape([1.0,2.0], 2, 1), reshape([1,4], 2, 1))
-@test findmin(A, (1,2)) == (fill(1.0,1,1),fill(1,1,1))
-@test findmax(A, (1,)) == ([5.0 3.0 6.0], [2 3 5])
-@test findmax(A, (2,)) == (reshape([6.0,5.0], 2, 1), reshape([5,2], 2, 1))
-@test findmax(A, (1,2)) == (fill(6.0,1,1),fill(5,1,1))
+for (tup, rval, rind) in [((1,), [1.0 2.0 4.0], [1 4 6]),
+                          ((2,), reshape([1.0,2.0], 2, 1), reshape([1,4], 2, 1)),
+                          ((1,2), fill(1.0,1,1),fill(1,1,1))]
+    @test findmin(A, tup) == (rval, rind)
+    @test findmin!(similar(rval), similar(rind), A) == (rval, rind)
+end
+
+for (tup, rval, rind) in [((1,), [5.0 3.0 6.0], [2 3 5]),
+                          ((2,), reshape([6.0,5.0], 2, 1), reshape([5,2], 2, 1)),
+                          ((1,2), fill(6.0,1,1),fill(5,1,1))]
+    @test findmax(A, tup) == (rval, rind)
+    @test findmax!(similar(rval), similar(rind), A) == (rval, rind)
+end
 
 # issue #6672
 @test sum(Real[1 2 3; 4 5.3 7.1], 2) == reshape([6, 16.4], 2, 1)
diff --git a/test/reflection.jl b/test/reflection.jl
index 71772e0922199..969050dfedfd8 100644
--- a/test/reflection.jl
+++ b/test/reflection.jl
@@ -4,6 +4,9 @@
 # It's hard to really test these, but just running them should be
 # sufficient to catch segfault bugs.
 
+module ReflectionTest
+using Base.Test
+
 function test_ast_reflection(freflect, f, types)
     @test !isempty(freflect(f, types))
 end
@@ -22,12 +25,12 @@ end
 
 function test_code_reflections(tester, freflect)
     test_code_reflection(freflect, ismatch,
-                         Tuple{Regex, AbstractString}, tester)
-    test_code_reflection(freflect, +, Tuple{Int, Int}, tester)
+                         Tuple{Regex, AbstractString}, tester) # abstract type
+    test_code_reflection(freflect, +, Tuple{Int, Int}, tester) # leaftype signature
     test_code_reflection(freflect, +,
-                         Tuple{Array{Float32}, Array{Float32}}, tester)
-    test_code_reflection(freflect, Module, Tuple{}, tester)
-    test_code_reflection(freflect, Array{Int64}, Tuple{Array{Int32}}, tester)
+                         Tuple{Array{Float32}, Array{Float32}}, tester) # incomplete types
+    test_code_reflection(freflect, Module, Tuple{}, tester) # Module() constructor (transforms to call)
+    test_code_reflection(freflect, Array{Int64}, Tuple{Array{Int32}}, tester) # with incomplete types
 end
 
 println(STDERR, "The following 'Returned code...' warnings indicate normal behavior:")
@@ -35,29 +38,25 @@ test_code_reflections(test_ast_reflection, code_lowered)
 test_code_reflections(test_ast_reflection, code_typed)
 test_code_reflections(test_bin_reflection, code_llvm)
 test_code_reflections(test_bin_reflection, code_native)
-
-@test_throws Exception code_native(+, Int, Int)
-@test_throws Exception code_native(+, Array{Float32}, Array{Float32})
-
-@test_throws Exception code_llvm(+, Int, Int)
-@test_throws Exception code_llvm(+, Array{Float32}, Array{Float32})
+end
 
 # code_warntype
 module WarnType
 using Base.Test
 
-iob = IOBuffer()
+function warntype_hastag(f, types, tag)
+    iob = IOBuffer()
+    code_warntype(iob, f, types)
+    str = takebuf_string(iob)
+    !isempty(search(str, tag))
+end
 
 pos_stable(x) = x > 0 ? x : zero(x)
 pos_unstable(x) = x > 0 ? x : 0
 
 tag = Base.have_color ? Base.text_colors[:red] : "UNION"
-code_warntype(iob, pos_unstable, Tuple{Float64,})
-str = takebuf_string(iob)
-@test !isempty(search(str, tag))
-code_warntype(iob, pos_stable, Tuple{Float64,})
-str = takebuf_string(iob)
-@test isempty(search(str, tag))
+@test warntype_hastag(pos_unstable, Tuple{Float64}, tag)
+@test !warntype_hastag(pos_stable, Tuple{Float64}, tag)
 
 type Stable{T,N}
     A::Array{T,N}
@@ -69,35 +68,23 @@ Base.getindex(A::Stable, i) = A.A[i]
 Base.getindex(A::Unstable, i) = A.A[i]
 
 tag = Base.have_color ? Base.text_colors[:red] : "ARRAY{FLOAT64,N}"
-code_warntype(iob, getindex, Tuple{Unstable{Float64},Int})
-str = takebuf_string(iob)
-@test !isempty(search(str, tag))
-code_warntype(iob, getindex, Tuple{Stable{Float64,2},Int})
-str = takebuf_string(iob)
-@test isempty(search(str, tag))
-code_warntype(iob, getindex, Tuple{Stable{Float64},Int})
-str = takebuf_string(iob)
-@test !isempty(search(str, tag))
-
-function funfun(x)
-    function internal(y)
-        return 2y
-    end
-    z = internal(3)
-    x
-end
-
-tag = Base.have_color ? string("2y",Base.text_colors[:red],"::Any") : "2y::ANY"
-code_warntype(iob, funfun, Tuple{Float64})
-str = takebuf_string(iob)
-@test !isempty(search(str, tag))
+@test warntype_hastag(getindex, Tuple{Unstable{Float64},Int}, tag)
+@test !warntype_hastag(getindex, Tuple{Stable{Float64,2},Int}, tag)
+@test warntype_hastag(getindex, Tuple{Stable{Float64},Int}, tag)
 
 # Make sure emphasis is not used for other functions
 tag = Base.have_color ? Base.text_colors[:red] : "ANY"
+iob = IOBuffer()
 show(iob, expand(:(x->x^2)))
 str = takebuf_string(iob)
 @test isempty(search(str, tag))
 
+# issue #13568
+@test !warntype_hastag(+, Tuple{Int,Int}, tag)
+@test !warntype_hastag(-, Tuple{Int,Int}, tag)
+@test !warntype_hastag(*, Tuple{Int,Int}, tag)
+@test !warntype_hastag(/, Tuple{Int,Int}, tag)
+
 end
 
 # isbits
@@ -111,7 +98,7 @@ end
 i10165(::DataType) = 0
 i10165{T,n}(::Type{AbstractArray{T,n}}) = 1
 @test i10165(AbstractArray{Int}) == 0
-@test which(i10165, Tuple{Type{AbstractArray{Int}},}).sig == Tuple{DataType,}
+@test which(i10165, Tuple{Type{AbstractArray{Int}},}).sig == Tuple{typeof(i10165),DataType}
 
 # fullname
 @test fullname(Base) == (:Base,)
@@ -173,20 +160,80 @@ let
     @test Set(names(TestMod7648))==Set([:TestMod7648, :a9475, :c7648, :foo7648])
     @test isconst(TestMod7648, :c7648)
     @test !isconst(TestMod7648, :d7648)
-    @test !isgeneric(isa)
 end
 
 let
     using TestMod7648
     @test Base.binding_module(:a9475)==TestMod7648.TestModSub9475
     @test Base.binding_module(:c7648)==TestMod7648
-    @test isgeneric(foo7648)
     @test Base.function_name(foo7648)==:foo7648
     @test Base.function_module(foo7648, (Any,))==TestMod7648
     @test basename(functionloc(foo7648, (Any,))[1]) == "reflection.jl"
-    @test TestMod7648.TestModSub9475.foo7648.env.defs==@which foo7648(5)
+    @test methods(TestMod7648.TestModSub9475.foo7648).defs==@which foo7648(5)
     @test TestMod7648==@which foo7648
     @test TestMod7648.TestModSub9475==@which a9475
 end
 
 @test_throws ArgumentError which(is, Tuple{Int, Int})
+
+module TestingExported
+using Base.Test
+import Base.isexported
+global this_is_not_defined
+export this_is_not_defined
+@test_throws ErrorException which(:this_is_not_defined)
+@test_throws ErrorException @which this_is_not_defined
+@test_throws ErrorException which(:this_is_not_exported)
+@test isexported(current_module(), :this_is_not_defined)
+@test !isexported(current_module(), :this_is_not_exported)
+const a_value = 1
+@test which(:a_value) == current_module()
+@test !isexported(current_module(), :a_value)
+end
+
+# issue #13264
+@test isa((@which vcat(1...)), Method)
+
+# issue #13464
+let t13464 = "hey there sailor"
+    try
+        @which t13464[1,1] = (1.0,true)
+        error("unexpected")
+    catch err13464
+        @test startswith(err13464.msg, "expression is not a function call, or is too complex")
+    end
+end
+
+let ex = :(a + b)
+    @test string(ex) == "a + b"
+    ex.typ = Integer
+    @test string(ex) == "(a + b)::Integer"
+end
+
+type TLayout
+    x::Int8
+    y::Int16
+    z::Int32
+end
+tlayout = TLayout(5,7,11)
+@test fieldnames(tlayout) == fieldnames(TLayout) == [:x, :y, :z]
+@test [(fieldoffset(TLayout,i), fieldname(TLayout,i), fieldtype(TLayout,i)) for i = 1:nfields(TLayout)] ==
+    [(0, :x, Int8), (2, :y, Int16), (4, :z, Int32)]
+@test_throws BoundsError fieldtype(TLayout, 0)
+@test_throws BoundsError fieldname(TLayout, 0)
+@test_throws BoundsError fieldoffset(TLayout, 0)
+@test_throws BoundsError fieldtype(TLayout, 4)
+@test_throws BoundsError fieldname(TLayout, 4)
+@test_throws BoundsError fieldoffset(TLayout, 4)
+
+import Base: isstructtype, type_alignment, return_types
+@test !isstructtype(Union{})
+@test !isstructtype(Union{Int,Float64})
+@test !isstructtype(Int)
+@test isstructtype(TLayout)
+@test type_alignment(UInt16) == 2
+@test type_alignment(TLayout) == 4
+let rts = return_types(TLayout)
+    @test length(rts) >= 3 # general constructor, specific constructor, and call-to-convert adapter(s)
+    @test all(rts .== TLayout)
+end
diff --git a/test/regex.jl b/test/regex.jl
index 601f0b4189ec1..e3a90abb1c591 100644
--- a/test/regex.jl
+++ b/test/regex.jl
@@ -29,7 +29,7 @@ match(pat, target)
 # Issue 9545 (32 bit)
 buf = PipeBuffer()
 show(buf, r"")
-@test readall(buf) == "r\"\""
+@test readstring(buf) == "r\"\""
 
 # see #10994, #11447: PCRE2 allows NUL chars in the pattern
 @test ismatch(Regex("^a\0b\$"), "a\0b")
diff --git a/test/repl.jl b/test/repl.jl
index 51968f0e07d27..99927d954a010 100644
--- a/test/repl.jl
+++ b/test/repl.jl
@@ -29,109 +29,129 @@ ccall(:jl_exit_on_sigint, Void, (Cint,), 0)
 # this should make sure nothing crashes without depending on how exactly the control
 # characters are being used.
 if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
-stdin_write, stdout_read, stderr_read, repl = fake_repl()
+    stdin_write, stdout_read, stderr_read, repl = fake_repl()
 
-repl.specialdisplay = Base.REPL.REPLDisplay(repl)
-repl.history_file = false
-
-repltask = @async begin
-    Base.REPL.run_repl(repl)
-end
-
-sendrepl(cmd) = write(stdin_write,"inc || wait(b); r = $cmd; notify(c); r\r")
-
-inc = false
-b = Condition()
-c = Condition()
-sendrepl("\"Hello REPL\"")
-inc=true
-begin
-    notify(b)
-    wait(c)
-end
-# Latex completions
-write(stdin_write, "\x32\\alpha\t")
-readuntil(stdout_read, "α")
-# Bracketed paste in search mode
-write(stdin_write, "\e[200~paste here ;)\e[201~")
-# Abort search (^C)
-write(stdin_write, '\x03')
-# Test basic completion in main mode
-write(stdin_write, "Base.REP\t")
-readuntil(stdout_read, "Base.REPL")
-write(stdin_write, '\x03')
-write(stdin_write, "\\alpha\t")
-readuntil(stdout_read,"α")
-write(stdin_write, '\x03')
-# Test cd feature in shell mode.  We limit to 40 characters when
-# calling readuntil() to suppress the warning it (currently) gives for
-# long strings.
-origpwd = pwd()
-tmpdir = mktempdir()
-write(stdin_write, ";")
-readuntil(stdout_read, "shell> ")
-write(stdin_write, "cd $(escape_string(tmpdir))\n")
-readuntil(stdout_read, "cd $(escape_string(tmpdir))"[max(1,end-39):end])
-readuntil(stdout_read, realpath(tmpdir)[max(1,end-39):end])
-readuntil(stdout_read, "\n")
-readuntil(stdout_read, "\n")
-@test pwd() == realpath(tmpdir)
-write(stdin_write, ";")
-readuntil(stdout_read, "shell> ")
-write(stdin_write, "cd -\n")
-readuntil(stdout_read, origpwd[max(1,end-39):end])
-readuntil(stdout_read, "\n")
-readuntil(stdout_read, "\n")
-@test pwd() == origpwd
-write(stdin_write, ";")
-readuntil(stdout_read, "shell> ")
-write(stdin_write, "cd\n")
-readuntil(stdout_read, homedir()[max(1,end-39):end])
-readuntil(stdout_read, "\n")
-readuntil(stdout_read, "\n")
-@test pwd() == homedir()
-rm(tmpdir)
-cd(origpwd)
-
-# Test that accepting a REPL result immediately shows up, not
-# just on the next keystroke
-write(stdin_write, "1+1\n") # populate history with a trivial input
-readline(stdout_read)
-write(stdin_write, "\e[A\n")
-t = Timer(10) do t
-    isopen(t) || return
-    error("Stuck waiting for the repl to write `1+1`")
-end
-# yield make sure this got processed
-readuntil(stdout_read, "1+1")
-close(t)
-
-# Issue #10222
-# Test ignoring insert key in standard and prefix search modes
-write(stdin_write, "\e[2h\e[2h\n") # insert (VT100-style)
-@test search(readline(stdout_read), "[2h") == 0:-1
-readline(stdout_read)
-write(stdin_write, "\e[2~\e[2~\n") # insert (VT220-style)
-@test search(readline(stdout_read), "[2~") == 0:-1
-readline(stdout_read)
-write(stdin_write, "1+1\n") # populate history with a trivial input
-readline(stdout_read)
-write(stdin_write, "\e[A\e[2h\n") # up arrow, insert (VT100-style)
-readline(stdout_read)
-readline(stdout_read)
-write(stdin_write, "\e[A\e[2~\n") # up arrow, insert (VT220-style)
-readline(stdout_read)
-readline(stdout_read)
-
-# Close REPL ^D
-write(stdin_write, '\x04')
-wait(repltask)
+    repl.specialdisplay = Base.REPL.REPLDisplay(repl)
+    repl.history_file = false
+
+    repltask = @async begin
+        Base.REPL.run_repl(repl)
+    end
+
+    sendrepl(cmd) = write(stdin_write,"inc || wait(b); r = $cmd; notify(c); r\r")
+
+    inc = false
+    b = Condition()
+    c = Condition()
+    sendrepl("\"Hello REPL\"")
+    inc=true
+    begin
+        notify(b)
+        wait(c)
+    end
+    # Latex completions
+    write(stdin_write, "\x32\\alpha\t")
+    readuntil(stdout_read, "α")
+    # Bracketed paste in search mode
+    write(stdin_write, "\e[200~paste here ;)\e[201~")
+    # Abort search (^C)
+    write(stdin_write, '\x03')
+    # Test basic completion in main mode
+    write(stdin_write, "Base.REP\t")
+    readuntil(stdout_read, "Base.REPL")
+    write(stdin_write, '\x03')
+    write(stdin_write, "\\alpha\t")
+    readuntil(stdout_read,"α")
+    write(stdin_write, '\x03')
+    # Test cd feature in shell mode.  We limit to 40 characters when
+    # calling readuntil() to suppress the warning it (currently) gives for
+    # long strings.
+    origpwd = pwd()
+    tmpdir = mktempdir()
+    write(stdin_write, ";")
+    readuntil(stdout_read, "shell> ")
+    write(stdin_write, "cd $(escape_string(tmpdir))\n")
+    readuntil(stdout_read, "cd $(escape_string(tmpdir))"[max(1,end-39):end])
+    readuntil(stdout_read, realpath(tmpdir)[max(1,end-39):end])
+    readuntil(stdout_read, "\n")
+    readuntil(stdout_read, "\n")
+    @test pwd() == realpath(tmpdir)
+    write(stdin_write, ";")
+    readuntil(stdout_read, "shell> ")
+    write(stdin_write, "cd -\n")
+    readuntil(stdout_read, origpwd[max(1,end-39):end])
+    readuntil(stdout_read, "\n")
+    readuntil(stdout_read, "\n")
+    @test pwd() == origpwd
+    write(stdin_write, ";")
+    readuntil(stdout_read, "shell> ")
+    write(stdin_write, "cd\n")
+    readuntil(stdout_read, homedir()[max(1,end-39):end])
+    readuntil(stdout_read, "\n")
+    readuntil(stdout_read, "\n")
+    @test pwd() == homedir()
+    rm(tmpdir)
+    cd(origpwd)
+
+    # Test that accepting a REPL result immediately shows up, not
+    # just on the next keystroke
+    write(stdin_write, "1+1\n") # populate history with a trivial input
+    readline(stdout_read)
+    write(stdin_write, "\e[A\n")
+    t = Timer(10) do t
+        isopen(t) || return
+        error("Stuck waiting for the repl to write `1+1`")
+    end
+    # yield make sure this got processed
+    readuntil(stdout_read, "1+1")
+    close(t)
+
+    # Issue #10222
+    # Test ignoring insert key in standard and prefix search modes
+    write(stdin_write, "\e[2h\e[2h\n") # insert (VT100-style)
+    @test search(readline(stdout_read), "[2h") == 0:-1
+    readline(stdout_read)
+    write(stdin_write, "\e[2~\e[2~\n") # insert (VT220-style)
+    @test search(readline(stdout_read), "[2~") == 0:-1
+    readline(stdout_read)
+    write(stdin_write, "1+1\n") # populate history with a trivial input
+    readline(stdout_read)
+    write(stdin_write, "\e[A\e[2h\n") # up arrow, insert (VT100-style)
+    readline(stdout_read)
+    readline(stdout_read)
+    write(stdin_write, "\e[A\e[2~\n") # up arrow, insert (VT220-style)
+    readline(stdout_read)
+    readline(stdout_read)
+
+    # Test down arrow to go back to history
+    # populate history with a trivial input
+
+    t = Timer(10) do t
+        isopen(t) || return
+        error("Stuck waiting for history test")
+    end
+    s1 = "12345678"; s2 = "23456789";
+    write(stdin_write, s1, '\n')
+    readuntil(stdout_read, s1)
+    write(stdin_write, s2, '\n')
+    readuntil(stdout_read, s2)
+    # Two up arrow, enter, should get back to 1
+    write(stdin_write, "\e[A\e[A\n")
+    readuntil(stdout_read, s1)
+    # Now, down arrow, enter, should get us back to 2
+    write(stdin_write, "\e[B\n")
+    readuntil(stdout_read, s2)
+    close(t)
+
+    # Close REPL ^D
+    write(stdin_write, '\x04')
+    wait(repltask)
 end
 
 function buffercontents(buf::IOBuffer)
     p = position(buf)
     seek(buf,0)
-    c = readall(buf)
+    c = readstring(buf)
     seek(buf,p)
     c
 end
@@ -178,6 +198,12 @@ end
 # it is important not to have the """ code reindent this line,
 # possibly converting \t to spaces.
 fakehistory = """
+# time: 2014-06-29 20:44:29 EDT
+# mode: julia
+\té
+# time: 2014-06-29 21:44:29 EDT
+# mode: julia
+\téé
 # time: 2014-06-30 17:32:49 EDT
 # mode: julia
 \tshell
@@ -198,7 +224,8 @@ fakehistory = """
 \tls
 # time: 2014-06-30 20:44:29 EDT
 # mode: julia
-\t2 + 2"""
+\t2 + 2
+"""
 
 # Test various history related issues
 begin
@@ -280,6 +307,27 @@ begin
     @test LineEdit.mode(s) == shell_mode
     @test buffercontents(LineEdit.buffer(s)) == "ll"
 
+    # Test that searching backwards with a one-letter query doesn't
+    # return indefinitely the same match (#9352)
+    LineEdit.enter_search(s, histp, true)
+    write(ss.query_buffer, "l")
+    LineEdit.update_display_buffer(ss, ss)
+    LineEdit.history_next_result(s, ss)
+    LineEdit.update_display_buffer(ss, ss)
+    LineEdit.accept_result(s, histp)
+    @test LineEdit.mode(s) == repl_mode
+    @test buffercontents(LineEdit.buffer(s)) == "shell"
+
+    # Test that searching backwards doesn't skip matches (#9352)
+    # (for a search with multiple one-byte characters, or UTF-8 characters)
+    LineEdit.enter_search(s, histp, true)
+    write(ss.query_buffer, "é") # matches right-most "é" in "éé"
+    LineEdit.update_display_buffer(ss, ss)
+    LineEdit.history_next_result(s, ss) # matches left-most "é" in "éé"
+    LineEdit.update_display_buffer(ss, ss)
+    LineEdit.accept_result(s, histp)
+    @test buffercontents(LineEdit.buffer(s)) == "éé"
+
     # Issue #7551
     # Enter search mode and try accepting an empty result
     REPL.history_reset_state(hp)
@@ -312,54 +360,93 @@ begin
     # Try entering search mode while in custom repl mode
     LineEdit.enter_search(s, custom_histp, true)
 end
+# Simple non-standard REPL tests
+if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
+    stdin_write, stdout_read, stdout_read, repl = fake_repl()
+    panel = LineEdit.Prompt("test";
+        prompt_prefix="\e[38;5;166m",
+        prompt_suffix=Base.text_colors[:white],
+        on_enter = s->true)
 
-ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
-
-let exename = joinpath(JULIA_HOME, Base.julia_exename())
+    hp = REPL.REPLHistoryProvider(Dict{Symbol,Any}(:parse => panel))
+    search_prompt, skeymap = LineEdit.setup_prefix_keymap(hp, panel)
+    REPL.history_reset_state(hp)
 
-# Test REPL in dumb mode
-@unix_only begin
+    panel.hist = hp
+    panel.keymap_dict = LineEdit.keymap(Dict{Any,Any}[skeymap,
+        LineEdit.default_keymap, LineEdit.escape_defaults])
 
-const O_RDWR = Base.FS.JL_O_RDWR
-const O_NOCTTY = Base.FS.JL_O_NOCTTY
-
-fdm = ccall(:posix_openpt,Cint,(Cint,),O_RDWR|O_NOCTTY)
-fdm == -1 && error("Failed to open PTY master")
-rc = ccall(:grantpt,Cint,(Cint,),fdm)
-rc != 0 && error("grantpt failed")
-rc = ccall(:unlockpt,Cint,(Cint,),fdm)
-rc != 0 && error("unlockpt")
-
-fds = ccall(:open,Cint,(Ptr{UInt8},Cint),ccall(:ptsname,Ptr{UInt8},(Cint,),fdm), O_RDWR|O_NOCTTY)
-
-# slave
-slave   = RawFD(fds)
-master = Base.TTY(RawFD(fdm); readable = true)
-
-nENV = copy(ENV)
-nENV["TERM"] = "dumb"
-p = spawn(setenv(`$exename --startup-file=no --quiet`,nENV),slave,slave,slave)
-output = readuntil(master,"julia> ")
-if ccall(:jl_running_on_valgrind,Cint,()) == 0
-    # If --trace-children=yes is passed to valgrind, we will get a
-    # valgrind banner here, not just the prompt.
-    @test output == "julia> "
+    c = Condition()
+    panel.on_done = (s,buf,ok)->begin
+        if !ok
+            LineEdit.transition(s,:abort)
+        end
+        line = strip(takebuf_string(buf))
+        LineEdit.reset_state(s)
+        return notify(c,line)
+    end
+
+    repltask = @async Base.REPL.run_interface(repl.t, LineEdit.ModalInterface([panel,search_prompt]))
+
+    write(stdin_write,"a\n")
+    @test wait(c) == "a"
+    # Up arrow enter should recall history even at the start
+    write(stdin_write,"\e[A\n")
+    @test wait(c) == "a"
+    # And again
+    write(stdin_write,"\e[A\n")
+    @test wait(c) == "a"
+    # Close REPL ^D
+    write(stdin_write, '\x04')
+    wait(repltask)
 end
-write(master,"1\nquit()\n")
 
-wait(p)
-output = readuntil(master,' ')
-@test output == "1\r\nquit()\r\n1\r\n\r\njulia> "
-@test nb_available(master) == 0
-ccall(:close,Cint,(Cint,),fds) # XXX: this causes the kernel to throw away all unread data on the pty
-close(master)
+ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
+
+let exename = Base.julia_cmd()
 
+# Test REPL in dumb mode
+@unix_only begin
+    const O_RDWR = Base.Filesystem.JL_O_RDWR
+    const O_NOCTTY = Base.Filesystem.JL_O_NOCTTY
+
+    fdm = ccall(:posix_openpt, Cint, (Cint,), O_RDWR|O_NOCTTY)
+    fdm == -1 && error("Failed to open PTY master")
+    rc = ccall(:grantpt, Cint, (Cint,), fdm)
+    rc != 0 && error("grantpt failed")
+    rc = ccall(:unlockpt, Cint, (Cint,), fdm)
+    rc != 0 && error("unlockpt")
+
+    fds = ccall(:open, Cint, (Ptr{UInt8}, Cint),
+        ccall(:ptsname, Ptr{UInt8}, (Cint,), fdm), O_RDWR|O_NOCTTY)
+
+    # slave
+    slave   = RawFD(fds)
+    master = Base.TTY(RawFD(fdm); readable = true)
+
+    nENV = copy(ENV)
+    nENV["TERM"] = "dumb"
+    p = spawn(setenv(`$exename --startup-file=no --quiet`,nENV),slave,slave,slave)
+    output = readuntil(master,"julia> ")
+    if ccall(:jl_running_on_valgrind,Cint,()) == 0
+        # If --trace-children=yes is passed to valgrind, we will get a
+        # valgrind banner here, not just the prompt.
+        @test output == "julia> "
+    end
+    write(master,"1\nquit()\n")
+
+    wait(p)
+    output = readuntil(master,' ')
+    @test output == "1\r\nquit()\r\n1\r\n\r\njulia> "
+    @test nb_available(master) == 0
+    ccall(:close,Cint,(Cint,),fds) # XXX: this causes the kernel to throw away all unread data on the pty
+    close(master)
 end
 
 # Test stream mode
 if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
     outs, ins, p = readandwrite(`$exename --startup-file=no --quiet`)
     write(ins,"1\nquit()\n")
-    @test readall(outs) == "1\n"
+    @test readstring(outs) == "1\n"
 end
 end
diff --git a/test/replcompletions.jl b/test/replcompletions.jl
index 4a0e2bb060526..75a2e6dff2eae 100644
--- a/test/replcompletions.jl
+++ b/test/replcompletions.jl
@@ -33,20 +33,28 @@ module CompletionFoo
     test3(x::AbstractArray{Int}, y::Int) = pass
     test3(x::AbstractArray{Float64}, y::Float64) = pass
 
+    test4(x::AbstractString, y::AbstractString) = pass
+    test4(x::AbstractString, y::Regex) = pass
+
+    test5(x::Array{Bool,1}) = pass
+    test5(x::BitArray{1}) = pass
+    test5(x::Float64) = pass
+
     array = [1, 1]
+    varfloat = 0.1
 end
 
 function temp_pkg_dir(fn::Function)
-  # Used in tests below to setup and teardown a sandboxed package directory
-  const tmpdir = ENV["JULIA_PKGDIR"] = joinpath(tempdir(),randstring())
-  @test !isdir(Pkg.dir())
-  try
-    mkpath(Pkg.dir())
-    @test isdir(Pkg.dir())
-    fn()
-  finally
-    rm(tmpdir, recursive=true)
-  end
+    # Used in tests below to setup and teardown a sandboxed package directory
+    const tmpdir = ENV["JULIA_PKGDIR"] = joinpath(tempdir(),randstring())
+    @test !isdir(Pkg.dir())
+    try
+        mkpath(Pkg.dir())
+        @test isdir(Pkg.dir())
+        fn()
+    finally
+        rm(tmpdir, recursive=true)
+    end
 end
 
 test_complete(s) = completions(s,endof(s))
@@ -186,7 +194,7 @@ c, r, res = test_complete(s)
 @test r == 1:3
 @test s[r] == "max"
 
-# Test completion of methods with input args
+# Test completion of methods with input concrete args and args where typeinference determine their type
 s = "CompletionFoo.test(1,1, "
 c, r, res = test_complete(s)
 @test !res
@@ -239,24 +247,54 @@ for (T, arg) in [(ASCIIString,"\")\""),(Char, "')'")]
     @test s[r] == "CompletionFoo.test2"
 end
 
-# This cannot find the correct method due to the backticks expands to a macro in the parser.
-# Then the function argument is an expression which is not handled by current method completion logic.
 s = "(1, CompletionFoo.test2(`)`,"
 c, r, res = test_complete(s)
-@test length(c) == 3
+@test c[1] == string(methods(CompletionFoo.test2, Tuple{Cmd})[1])
+@test length(c) == 1
 
-s = "CompletionFoo.test3([1.,2.],"
+s = "CompletionFoo.test3([1, 2] + CompletionFoo.varfloat,"
 c, r, res = test_complete(s)
 @test !res
-@test length(c) == 2
+@test c[1] == string(methods(CompletionFoo.test3, Tuple{Array{Float64, 1}, Float64})[1])
+@test length(c) == 1
 
 s = "CompletionFoo.test3([1.,2.], 1.,"
 c, r, res = test_complete(s)
 @test !res
 @test c[1] == string(methods(CompletionFoo.test3, Tuple{Array{Float64, 1}, Float64})[1])
 @test r == 1:19
+@test length(c) == 1
 @test s[r] == "CompletionFoo.test3"
 
+s = "CompletionFoo.test4(\"e\",r\" \","
+c, r, res = test_complete(s)
+@test !res
+@test c[1] == string(methods(CompletionFoo.test4, Tuple{ASCIIString, Regex})[1])
+@test r == 1:19
+@test length(c) == 1
+@test s[r] == "CompletionFoo.test4"
+
+s = "CompletionFoo.test5(push!(Base.split(\"\",' '),\"\",\"\").==\"\","
+c, r, res = test_complete(s)
+@test !res
+@test length(c) == 1
+@test c[1] == string(methods(CompletionFoo.test5, Tuple{BitArray{1}})[1])
+
+########## Test where the current inference logic fails ########
+# Fails due to inferrence fails to determine a concrete type for arg 1
+# But it returns AbstractArray{T,N} and hence is able to remove test5(x::Float64) from the suggestions
+s = "CompletionFoo.test5(AbstractArray[[]][1],"
+c, r, res = test_complete(s)
+@test !res
+@test length(c) == 2
+
+# equivalent to above but due to the time macro the completion fails to find the concrete type
+s = "CompletionFoo.test3(@time([1, 2] + CompletionFoo.varfloat),"
+c, r, res = test_complete(s)
+@test !res
+@test length(c) == 2
+#################################################################
+
 # Test completion in multi-line comments
 s = "#=\n\\alpha"
 c, r, res = test_complete(s)
@@ -393,6 +431,27 @@ c, r, res = test_scomplete(s)
     @test r == 6:7
     @test s[r] == "Pk"
 
+    # Pressing tab after having entered "/tmp " should not
+    # attempt to complete "/tmp" but rather work on the current
+    # working directory again.
+    let
+        file = joinpath(path, "repl completions")
+        s = "/tmp "
+        c,r = test_scomplete(s)
+        @test r == 6:5
+    end
+
+    # Test completing paths with an escaped trailing space
+    let
+        file = joinpath(tempdir(), "repl completions")
+        touch(file)
+        s = string(tempdir(), "/repl\\ ")
+        c,r = test_scomplete(s)
+        @test ["repl\\ completions"] == c
+        @test s[r] == "repl\\ "
+        rm(file)
+    end
+
     # Tests homedir expansion
     let
         path = homedir()
@@ -408,6 +467,57 @@ c, r, res = test_scomplete(s)
         c,r = test_complete(s)
         rm(dir)
     end
+
+    # Tests detecting of files in the env path (in shell mode)
+    let
+        oldpath = ENV["PATH"]
+        path = tempdir()
+        # PATH can also contain folders which we aren't actually allowed to read.
+        unreadable = joinpath(tempdir(), "replcompletion-unreadable")
+        ENV["PATH"] = string(path, ":", unreadable)
+
+        file = joinpath(path, "tmp-executable")
+        touch(file)
+        chmod(file, 0o755)
+        mkdir(unreadable)
+        chmod(unreadable, 0o000)
+
+        s = "tmp-execu"
+        c,r = test_scomplete(s)
+        @test "tmp-executable" in c
+        @test r == 1:9
+        @test s[r] == "tmp-execu"
+
+        rm(file)
+        rm(unreadable)
+        ENV["PATH"] = oldpath
+    end
+
+    # Make sure completion results are unique in case things are in the env path twice.
+    let
+        file0 = joinpath(tempdir(), "repl-completion")
+        dir = joinpath(tempdir(), "repl-completion-subdir")
+        file1 = joinpath(dir, "repl-completion")
+
+        try
+            # Create /tmp/repl-completion and /tmp/repl-completion-subdir/repl-completion
+            mkdir(dir)
+            touch(file0)
+            touch(file1)
+
+            withenv("PATH" => string(tempdir(), ":", dir)) do
+                s = string("repl-completio")
+                c,r = test_scomplete(s)
+                @test [utf8("repl-completion")] == c
+                @test s[r] == "repl-completio"
+            end
+
+        finally
+            rm(file0)
+            rm(file1)
+            rm(dir)
+        end
+    end
 end
 
 let #test that it can auto complete with spaces in file/path
@@ -469,3 +579,11 @@ c,r = test_complete("cd(\"folder_do_not_exist_77/file")
     end
     rm(tmp)
 end
+
+# auto completions of true and false... issue #14101
+s = "tru"
+c, r, res = test_complete(s)
+@test "true" in c
+s = "fals"
+c, r, res = test_complete(s)
+@test "false" in c
diff --git a/test/replutil.jl b/test/replutil.jl
index c0c8760d10d17..124fc935296fc 100644
--- a/test/replutil.jl
+++ b/test/replutil.jl
@@ -52,7 +52,7 @@ test_have_color(buf, color, no_color)
 
 # Test for the method error in issue #8651
 Base.show_method_candidates(buf, MethodError(readline,("",)))
-test_have_color(buf, "", "")
+test_have_color(buf, "\e[0m\nClosest candidates are:\n  readline(::AbstractString)\e[0m", "\nClosest candidates are:\n  readline(::AbstractString)")
 
 method_c4(::Type{Float64}) = true
 Base.show_method_candidates(buf, MethodError(method_c4,(Float64,)))
@@ -69,16 +69,15 @@ for f in [getindex, setindex!]
     test_have_color(buf, "", "")
 end
 
-
-function _except_str(expr, err_type=Exception)
-    quote
+macro except_str(expr, err_type)
+    return quote
         let
-            local err::$(esc(err_type))
+            local err
             try
                 $(esc(expr))
             catch err
             end
-            err
+            @test typeof(err) === $(esc(err_type))
             buff = IOBuffer()
             showerror(buff, err)
             takebuf_string(buff)
@@ -86,8 +85,35 @@ function _except_str(expr, err_type=Exception)
     end
 end
 
-macro except_str(args...)
-    _except_str(args...)
+macro except_strbt(expr, err_type)
+    return quote
+        let
+            local err
+            try
+                $(esc(expr))
+            catch err
+            end
+            @test typeof(err) === $(esc(err_type))
+            buff = IOBuffer()
+            showerror(buff, err, catch_backtrace())
+            takebuf_string(buff)
+        end
+    end
+end
+
+macro except_stackframe(expr, err_type)
+    return quote
+       let
+           local st
+           try
+               $(esc(expr))
+           catch err
+               st = catch_stacktrace()
+               @test typeof(err) === $(esc(err_type))
+           end
+           sprint(show, st[1])
+       end
+    end
 end
 
 # Pull Request 11007
@@ -103,27 +129,85 @@ let
     @test contains(err_str, "::InvokeType11007")
 end
 
-let
-    +() = nothing
-    err_str = @except_str 1 + 2 MethodError
-    @test contains(err_str, "Base.+")
+module __tmp_replutil
+
+using Base.Test
+import Main.@except_str
+global +
++() = nothing
+err_str = @except_str 1 + 2 MethodError
+@test contains(err_str, "import Base.+")
+
+err_str = @except_str Float64[](1) MethodError
+@test !contains(err_str, "import Base.Array")
+
+Array() = 1
+err_str = @except_str Array(1) MethodError
+@test contains(err_str, "import Base.Array")
+
 end
 
 let
     g11007(::AbstractVector) = nothing
-    err_str = @except_str g11007([[1] [1]])
+    err_str = @except_str g11007([[1] [1]]) MethodError
     @test contains(err_str, "row vector")
     @test contains(err_str, "column vector")
 end
 
 abstract T11007
 let
-    err_str = @except_str T11007()
-    @test contains(err_str, "convert")
-    @test contains(err_str, "constructor")
-    @test contains(err_str, "T11007(...)")
+    err_str = @except_str T11007() MethodError
+    @test contains(err_str, "no method matching T11007()")
 end
 
+immutable TypeWithIntParam{T <: Integer} end
+let undefvar
+    err_str = @except_strbt sqrt(-1) DomainError
+    @test contains(err_str, "Try sqrt(complex(x)).")
+    err_str = @except_strbt 1^(-1) DomainError
+    @test contains(err_str, "Cannot raise an integer x to a negative power -n")
+    err_str = @except_strbt (-1)^0.25 DomainError
+    @test contains(err_str, "Exponentiation yielding a complex result requires a complex argument")
+
+    err_str = @except_str [5,4,3][-2,1] BoundsError
+    @test err_str == "BoundsError: attempt to access 3-element Array{$Int,1}:\n 5\n 4\n 3\n  at index [-2,1]"
+    err_str = @except_str [5,4,3][1:5] BoundsError
+    @test err_str == "BoundsError: attempt to access 3-element Array{$Int,1}:\n 5\n 4\n 3\n  at index [1:5]"
+
+    err_str = @except_str 0::Bool TypeError
+    @test err_str == "TypeError: non-boolean ($Int) used in boolean context"
+    err_str = @except_str 0::AbstractFloat TypeError
+    @test err_str == "TypeError: typeassert: expected AbstractFloat, got $Int"
+    err_str = @except_str 0::7 TypeError
+    @test err_str == "TypeError: typeassert: expected Type{T}, got $Int"
+    err_str = @except_str "" <: AbstractString TypeError
+    @test err_str == "TypeError: subtype: expected Type{T}, got ASCIIString"
+    err_str = @except_str AbstractString <: "" TypeError
+    @test err_str == "TypeError: subtype: expected Type{T}, got ASCIIString"
+    err_str = @except_str Type{""} TypeError
+    @test err_str == "TypeError: Type: in parameter, expected Type{T}, got ASCIIString"
+    err_str = @except_str TypeWithIntParam{Any} TypeError
+    @test err_str == "TypeError: TypeWithIntParam: in T, expected T<:Integer, got Type{Any}"
+
+    err_str = @except_str mod(1,0) DivideError
+    @test err_str == "DivideError: integer division error"
+    err_str = @except_str Array(Any,1)[1] UndefRefError
+    @test err_str == "UndefRefError: access to undefined reference"
+    err_str = @except_str undefvar UndefVarError
+    @test err_str == "UndefVarError: undefvar not defined"
+    err_str = @except_str read(IOBuffer(), UInt8) EOFError
+    @test err_str == "EOFError: read end of file"
+    err_str = @except_str Dict()[:doesnotexist] KeyError
+    @test err_str == "KeyError: doesnotexist not found"
+    err_str = @except_str throw(InterruptException()) InterruptException
+    @test err_str == "InterruptException:"
+    err_str = @except_str throw(ArgumentError("not an error")) ArgumentError
+    @test err_str == "ArgumentError: not an error"
+    err_str = @except_str @assert(false) AssertionError
+    @test err_str == "AssertionError: false"
+end
+
+
 # issue 11845
 let
     buff = IOBuffer()
@@ -132,3 +216,126 @@ let
     showerror(buff, MethodError(convert, Tuple{Type, Float64}))
     showerror(buff, MethodError(convert, Tuple{DataType, Float64}))
 end
+
+# Issue #14884
+bitstype 8 EightBitType
+bitstype 8 EightBitTypeT{T}
+immutable FunctionLike <: Function; end
+let err_str,
+    i = reinterpret(EightBitType, 0x54),
+    j = reinterpret(EightBitTypeT{Int32}, 0x54)
+
+    err_str = @except_str Symbol() MethodError
+    @test contains(err_str, "MethodError: no method matching Symbol()")
+    err_str = @except_str :a() MethodError
+    @test contains(err_str, "MethodError: objects of type Symbol are not callable")
+    err_str = @except_str EightBitType() MethodError
+    @test contains(err_str, "MethodError: no method matching EightBitType()")
+    err_str = @except_str i() MethodError
+    @test contains(err_str, "MethodError: objects of type EightBitType are not callable")
+    err_str = @except_str EightBitTypeT() MethodError
+    @test contains(err_str, "MethodError: no method matching EightBitTypeT{T}()")
+    err_str = @except_str EightBitTypeT{Int32}() MethodError
+    @test contains(err_str, "MethodError: no method matching EightBitTypeT{Int32}()")
+    err_str = @except_str j() MethodError
+    @test contains(err_str, "MethodError: objects of type EightBitTypeT{Int32} are not callable")
+    err_str = @except_str FunctionLike()() MethodError
+    @test contains(err_str, "MethodError: no method matching (::FunctionLike)()")
+    err_str = @except_str [1,2](1) MethodError
+    @test contains(err_str, "MethodError: objects of type Array{$Int,1} are not callable\nUse square brackets [] for indexing an Array.")
+    # Issue 14940
+    err_str = @except_str randn(1)() MethodError
+    @test contains(err_str, "MethodError: objects of type Array{Float64,1} are not callable")
+end
+@test stringmime("text/plain", FunctionLike()) == "(::FunctionLike) (generic function with 0 methods)"
+@test ismatch(r"^@doc \(macro with \d+ method[s]?\)$", stringmime("text/plain", Base.(symbol("@doc"))))
+
+method_defs_lineno = @__LINE__
+Base.Symbol() = error(1)
+(::Symbol)() = error(2)
+EightBitType() = error(3)
+(::EightBitType)() = error(4)
+EightBitTypeT() = error(5)
+(::Type{EightBitTypeT{T}}){T}() = error(6)
+(::EightBitTypeT)() = error(7)
+(::FunctionLike)() = error(8)
+
+
+let err_str,
+    i = reinterpret(EightBitType, 0x54),
+    j = reinterpret(EightBitTypeT{Int32}, 0x54),
+    sp = Base.source_path()
+    sn = basename(sp)
+
+    @test sprint(show, which(Symbol, Tuple{})) == "Symbol() at $sp:$(method_defs_lineno + 0)"
+    @test sprint(show, which(:a, Tuple{})) == "(::Symbol)() at $sp:$(method_defs_lineno + 1)"
+    @test sprint(show, which(EightBitType, Tuple{})) == "EightBitType() at $sp:$(method_defs_lineno + 2)"
+    @test sprint(show, which(reinterpret(EightBitType, 0x54), Tuple{})) == "(::EightBitType)() at $sp:$(method_defs_lineno + 3)"
+    @test sprint(show, which(EightBitTypeT, Tuple{})) == "(::Type{EightBitTypeT{T<:Any}})() at $sp:$(method_defs_lineno + 4)"
+    @test sprint(show, which(EightBitTypeT{Int32}, Tuple{})) == "(::Type{EightBitTypeT{T}}){T}() at $sp:$(method_defs_lineno + 5)"
+    @test sprint(show, which(reinterpret(EightBitTypeT{Int32}, 0x54), Tuple{})) == "(::EightBitTypeT{T<:Any})() at $sp:$(method_defs_lineno + 6)"
+    @test startswith(sprint(show, which(Base.(symbol("@doc")), Tuple{Vararg{Any}})), "@doc(args...) at docs/bootstrap.jl:")
+    @test startswith(sprint(show, which(FunctionLike(), Tuple{})), "(::FunctionLike)() at $sp:$(method_defs_lineno + 7)")
+    @test stringmime("text/plain", FunctionLike()) == "(::FunctionLike) (generic function with 1 method)"
+    @test stringmime("text/plain", Core.arraysize) == "arraysize (built-in function)"
+
+    err_str = @except_stackframe Symbol() ErrorException
+    @test err_str == " in Symbol() at $sn:$(method_defs_lineno + 0)"
+    err_str = @except_stackframe :a() ErrorException
+    @test err_str == " in (::Symbol)() at $sn:$(method_defs_lineno + 1)"
+    err_str = @except_stackframe EightBitType() ErrorException
+    @test err_str == " in EightBitType() at $sn:$(method_defs_lineno + 2)"
+    err_str = @except_stackframe i() ErrorException
+    @test err_str == " in (::EightBitType)() at $sn:$(method_defs_lineno + 3)"
+    err_str = @except_stackframe EightBitTypeT() ErrorException
+    @test err_str == " in EightBitTypeT{T}() at $sn:$(method_defs_lineno + 4)"
+    err_str = @except_stackframe EightBitTypeT{Int32}() ErrorException
+    @test err_str == " in EightBitTypeT{Int32}() at $sn:$(method_defs_lineno + 5)"
+    err_str = @except_stackframe j() ErrorException
+    @test err_str == " in (::EightBitTypeT{Int32})() at $sn:$(method_defs_lineno + 6)"
+    err_str = @except_stackframe FunctionLike()() ErrorException
+    @test err_str == " in (::FunctionLike)() at $sn:$(method_defs_lineno + 7)"
+end
+
+
+# Issue #13032
+withenv("JULIA_EDITOR" => nothing, "VISUAL" => nothing, "EDITOR" => nothing) do
+
+    # Make sure editor doesn't error when no ENV editor is set.
+    @test isa(Base.editor(), Array)
+
+    # Invalid editor
+    ENV["JULIA_EDITOR"] = ""
+    @test_throws ErrorException Base.editor()
+
+    # Note: The following testcases should work regardless of whether these editors are
+    # installed or not.
+
+    # Editor on the path.
+    ENV["JULIA_EDITOR"] = "vim"
+    @test Base.editor() == ["vim"]
+
+    # Absolute path to editor.
+    ENV["JULIA_EDITOR"] = "/usr/bin/vim"
+    @test Base.editor() == ["/usr/bin/vim"]
+
+    # Editor on the path using arguments.
+    ENV["JULIA_EDITOR"] = "subl -w"
+    @test Base.editor() == ["subl", "-w"]
+
+    # Absolute path to editor with spaces.
+    ENV["JULIA_EDITOR"] = "/Applications/Sublime\\ Text.app/Contents/SharedSupport/bin/subl"
+    @test Base.editor() == ["/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl"]
+
+    # Paths with spaces and arguments (#13032).
+    ENV["JULIA_EDITOR"] = "/Applications/Sublime\\ Text.app/Contents/SharedSupport/bin/subl -w"
+    @test Base.editor() == ["/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl", "-w"]
+
+    ENV["JULIA_EDITOR"] = "'/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl' -w"
+    @test Base.editor() == ["/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl", "-w"]
+
+    ENV["JULIA_EDITOR"] = "\"/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl\" -w"
+    @test Base.editor() == ["/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl", "-w"]
+end
+
+
diff --git a/test/resolve.jl b/test/resolve.jl
index e17209d8836a4..ffc9aad485fe8 100644
--- a/test/resolve.jl
+++ b/test/resolve.jl
@@ -4,6 +4,7 @@ using Base.Pkg.Types
 using Base.Pkg.Query
 using Base.Pkg.Resolve
 using Base.Pkg.Resolve.VersionWeights
+import Base.Pkg.PkgError
 
 # Check that VersionWeight keeps the same ordering as VersionNumber
 
@@ -209,7 +210,7 @@ reqs_data = Any[
     ["A", v"1", v"2"],
     ["C", v"2"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 
 ## DEPENDENCY SCHEME 4: TWO PACKAGES, DAG, WITH TRIVIAL INCONSISTENCY
@@ -256,7 +257,7 @@ want = resolve_tst(deps_data, reqs_data)
 reqs_data = Any[
     ["A", v"2"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 
 ## DEPENDENCY SCHEME 6: TWO PACKAGES, CYCLIC, TOTALLY INCONSISTENT
@@ -274,13 +275,13 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 # require B (impossible)
 reqs_data = Any[
     ["B"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 
 ## DEPENDENCY SCHEME 7: THREE PACKAGES, CYCLIC, WITH INCONSISTENCY
@@ -314,7 +315,7 @@ want = resolve_tst(deps_data, reqs_data)
 reqs_data = Any[
     ["C", v"1", v"2"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 
 ## DEPENDENCY SCHEME 8: THREE PACKAGES, CYCLIC, TOTALLY INCONSISTENT
@@ -335,19 +336,19 @@ deps_data = Any[
 reqs_data = Any[
     ["A"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 # require B (impossible)
 reqs_data = Any[
     ["B"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 # require C (impossible)
 reqs_data = Any[
     ["C"]
 ]
-@test_throws ErrorException resolve_tst(deps_data, reqs_data)
+@test_throws PkgError resolve_tst(deps_data, reqs_data)
 
 ## DEPENDENCY SCHEME 9: SIX PACKAGES, DAG
 deps_data = Any[
diff --git a/test/rounding.jl b/test/rounding.jl
index 022058b3cbf20..e6791bdefd7aa 100644
--- a/test/rounding.jl
+++ b/test/rounding.jl
@@ -18,7 +18,7 @@ d = prevfloat(1.)
 @test b - a === c
 
 # RoundToZero
-with_rounding(Float64,RoundToZero) do
+setrounding(Float64,RoundToZero) do
     @test a + b === d
     @test - a - b === -d
     @test a - b === -c
@@ -32,7 +32,7 @@ end
 @test b - a == c
 
 # RoundUp
-with_rounding(Float64,RoundUp) do
+setrounding(Float64,RoundUp) do
     @test a + b === 1.
     @test - a - b === -d
     @test a - b === -c
@@ -40,7 +40,7 @@ with_rounding(Float64,RoundUp) do
 end
 
 # RoundDown
-with_rounding(Float64,RoundDown) do
+setrounding(Float64,RoundDown) do
     @test a + b === d
     @test - a - b === -1.
     @test a - b === -c
@@ -61,7 +61,7 @@ d32 = prevfloat(1.0f0)
 @test b32 - a32 === c32
 
 # RoundToZero
-with_rounding(Float32,RoundToZero) do
+setrounding(Float32,RoundToZero) do
     @test a32 + b32 === d32
     @test - a32 - b32 === -d32
     @test a32 - b32 === -c32
@@ -75,7 +75,7 @@ end
 @test b32 - a32 == c32
 
 # RoundUp
-with_rounding(Float32,RoundUp) do
+setrounding(Float32,RoundUp) do
     @test a32 + b32 === 1.0f0
     @test - a32 - b32 === -d32
     @test a32 - b32 === -c32
@@ -83,7 +83,7 @@ with_rounding(Float32,RoundUp) do
 end
 
 # RoundDown
-with_rounding(Float32,RoundDown) do
+setrounding(Float32,RoundDown) do
     @test a32 + b32 === d32
     @test - a32 - b32 === -1.0f0
     @test a32 - b32 === -c32
@@ -96,11 +96,11 @@ for v = [sqrt(2),-1/3,nextfloat(1.0),prevfloat(1.0),nextfloat(-1.0),
     pn = Float32(v,RoundNearest)
     @test pn == convert(Float32,v)
     pz = Float32(v,RoundToZero)
-    @test pz == with_rounding(()->convert(Float32,v), Float64, RoundToZero)
+    @test pz == setrounding(()->convert(Float32,v), Float64, RoundToZero)
     pd = Float32(v,RoundDown)
-    @test pd == with_rounding(()->convert(Float32,v), Float64, RoundDown)
+    @test pd == setrounding(()->convert(Float32,v), Float64, RoundDown)
     pu = Float32(v,RoundUp)
-    @test pu == with_rounding(()->convert(Float32,v), Float64, RoundUp)
+    @test pu == setrounding(()->convert(Float32,v), Float64, RoundUp)
 
     @test pn == pd || pn == pu
     @test v > 0 ? pz == pd : pz == pu
@@ -115,11 +115,11 @@ for T in [Float32,Float64]
         pn = T(v,RoundNearest)
         @test pn == convert(T,BigFloat(v))
         pz = T(v,RoundToZero)
-        @test pz == with_rounding(()->convert(T,BigFloat(v)), BigFloat, RoundToZero)
+        @test pz == setrounding(()->convert(T,BigFloat(v)), BigFloat, RoundToZero)
         pd = T(v,RoundDown)
-        @test pd == with_rounding(()->convert(T,BigFloat(v)), BigFloat, RoundDown)
+        @test pd == setrounding(()->convert(T,BigFloat(v)), BigFloat, RoundDown)
         pu = T(v,RoundUp)
-        @test pu == with_rounding(()->convert(T,BigFloat(v)), BigFloat, RoundUp)
+        @test pu == setrounding(()->convert(T,BigFloat(v)), BigFloat, RoundUp)
 
         @test pn == pd || pn == pu
         @test v > 0 ? pz == pd : pz == pu
diff --git a/test/runtests.jl b/test/runtests.jl
index 349faf18c64f9..969c72ee53182 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -20,7 +20,49 @@ cd(dirname(@__FILE__)) do
 
     @everywhere include("testdefs.jl")
 
-    reduce(propagate_errors, nothing, pmap(runtests, tests; err_retry=false, err_stop=true))
+    results=[]
+    if haskey(ENV, "JULIA_TEST_MAXRSS_MB")
+        max_worker_rss = parse(Int, ENV["JULIA_TEST_MAXRSS_MB"]) * 2^20
+    else
+        max_worker_rss = typemax(Csize_t)
+    end
+    @sync begin
+        for p in workers()
+            @async begin
+                while length(tests) > 0
+                    test = shift!(tests)
+                    local resp
+                    try
+                        resp = remotecall_fetch(t -> runtests(t), p, test)
+                    catch e
+                        resp = e
+                    end
+                    push!(results, (test, resp))
+
+                    if (isa(resp, Integer) && (resp > max_worker_rss)) || isa(resp, Exception)
+                        if n > 1
+                            rmprocs(p, waitfor=0.5)
+                            p = addprocs(1; exeflags=`--check-bounds=yes --depwarn=error`)[1]
+                            remotecall_fetch(()->include("testdefs.jl"), p)
+                        else
+                            # single process testing, bail if mem limit reached, or, on an exception.
+                            isa(resp, Exception) ? rethrow(resp) : error("Halting tests. Memory limit reached : $resp > $max_worker_rss")
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    errors = filter(x->isa(x[2], Exception), results)
+    if length(errors) > 0
+        for err in errors
+            println("Exception running test $(err[1]) :")
+            showerror(STDERR, err[2])
+            println()
+        end
+        error("Some tests exited with errors.")
+    end
 
     if compile_test
         n > 1 && print("\tFrom worker 1:\t")
diff --git a/test/serialize.jl b/test/serialize.jl
index 0d5a6554c04fc..5c2c549d47fad 100644
--- a/test/serialize.jl
+++ b/test/serialize.jl
@@ -39,7 +39,9 @@ end
 
 # Ptr
 create_serialization_stream() do s
-    @test_throws ErrorException serialize(s, C_NULL)
+    serialize(s, C_NULL)
+    seekstart(s)
+    @test deserialize(s) === C_NULL
 end
 
 # Integer
@@ -230,6 +232,30 @@ create_serialization_stream() do s # slices
     @test deserialize(s) == slc2
 end
 
+# Objects that have a SubArray as a type in a type-parameter list
+module ArrayWrappers
+
+immutable ArrayWrapper{T,N,A<:AbstractArray} <: AbstractArray{T,N}
+    data::A
+end
+Base.size(A::ArrayWrapper) = size(A.data)
+Base.size(A::ArrayWrapper, d) = size(A.data, d)
+Base.getindex(A::ArrayWrapper, i::Real...) = getindex(A.data, i...)
+
+end
+
+let A = rand(3,4)
+    for B in (sub(A, :, 2:4), slice(A, 2, 1:3))
+        C = ArrayWrappers.ArrayWrapper{Float64,2,typeof(B)}(B)
+        io = IOBuffer()
+        serialize(io, C)
+        seek(io, 0)
+        Cd = deserialize(io)
+        @test size(Cd) == size(C)
+        @test Cd == B
+    end
+end
+
 # Function
 serialize_test_function() = 1
 serialize_test_function2 = ()->1
@@ -242,32 +268,32 @@ create_serialization_stream() do s # Base generic function
     seek(s, 0)
     @test deserialize(s) === sin
     @test deserialize(s) === typeof
-    @test deserialize(s) == serialize_test_function
-    @test deserialize(s).code.ast == Base.uncompressed_ast(serialize_test_function2.code)
+    @test deserialize(s)() === 1
+    @test deserialize(s)() === 1
 end
 
 # Task
 create_serialization_stream() do s # user-defined type array
     f = () -> begin task_local_storage(:v, 2); return 1+1 end
     t = Task(f)
-    yieldto(t)
+    wait(schedule(t))
     serialize(s, t)
     seek(s, 0)
     r = deserialize(s)
-    @test r.code.code.ast == Base.uncompressed_ast(f.code)
     @test r.storage[:v] == 2
     @test r.state == :done
     @test r.exception == nothing
 end
 
+immutable MyErrorTypeTest <: Exception end
 create_serialization_stream() do s # user-defined type array
-    t = Task(()->error("Test"))
-    @test_throws ErrorException yieldto(t)
+    t = Task(()->throw(MyErrorTypeTest()))
+    @test_throws MyErrorTypeTest wait(schedule(t))
     serialize(s, t)
     seek(s, 0)
     r = deserialize(s)
     @test r.state == :failed
-    @test isa(t.exception, ErrorException)
+    @test isa(t.exception, MyErrorTypeTest)
 end
 
 # corner case: undefined inside immutable type
@@ -280,16 +306,34 @@ create_serialization_stream() do s
 end
 
 # cycles
+module CycleFoo
+    echo(x)=x
+end
 create_serialization_stream() do s
-    A = Any[1,2,3,4,5]
+    echo(x) = x
+    afunc = (x)->x
+    A = Any[1,2,3,abs,abs,afunc,afunc,echo,echo,CycleFoo.echo,CycleFoo.echo,4,5]
     A[3] = A
     serialize(s, A)
     seekstart(s)
     b = deserialize(s)
     @test b[3] === b
     @test b[1] == 1
-    @test b[5] == 5
-    @test length(b) == 5
+    @test b[4] === abs
+    @test b[5] === b[4]
+    @test b[5](-1) == 1
+
+    @test b[6] === b[7]
+    @test b[6]("Hello") == "Hello"
+
+    @test b[8] === b[9]
+    @test b[8]("World") == "World"
+
+    @test b[10] === b[11]
+    @test b[10]("foobar") == "foobar"
+
+    @test b[end] == 5
+    @test length(b) == length(A)
     @test isa(b,Vector{Any})
 end
 
@@ -301,3 +345,37 @@ create_serialization_stream() do s
     r2 = deserialize(s)
     @test r1 == r2
 end
+
+# issue #13452
+module Test13452
+using Base.Test
+
+module Shell
+export foo
+foo(x) = error("Instances must implement foo")
+end
+
+module Instance1
+using ..Shell
+Shell.foo(x::Int) = "This is an Int"
+end
+
+using .Shell, .Instance1
+io = IOBuffer()
+serialize(io, foo)
+str = takebuf_string(io)
+@test isempty(search(str, "Instance1"))
+@test !isempty(search(str, "Shell"))
+
+end  # module Test13452
+
+# issue #15163
+type B15163{T}
+    x::Array{T}
+end
+let b = IOBuffer()
+    serialize(b,B15163([1]))
+    seekstart(b)
+    c = deserialize(b)
+    @test isa(c,B15163) && c.x == [1]
+end
diff --git a/test/sets.jl b/test/sets.jl
index 8570042f7f98a..0ce992f1f6f72 100644
--- a/test/sets.jl
+++ b/test/sets.jl
@@ -194,13 +194,15 @@ end
 @test ⊊(Set([1]), Set([1,2]))
 @test !⊊(Set([1]), Set([1]))
 @test ⊈(Set([1]), Set([2]))
-@test symdiff(Set([1,2,3,4]), Set([2,4,5,6])) == Set([1,3,5, 6])
+@test symdiff(Set([1,2,3,4]), Set([2,4,5,6])) == Set([1,3,5,6])
 
 # unique
 u = unique([1,1,2])
 @test in(1,u)
 @test in(2,u)
 @test length(u) == 2
+@test unique(iseven, [5,1,8,9,3,4,10,7,2,6]) == [5,8]
+@test unique(n->n % 3, [5,1,8,9,3,4,10,7,2,6]) == [5,1,9]
 
 # filter
 s = Set([1,2,3,4])
@@ -212,4 +214,16 @@ filter!(isodd, s)
 @test_throws ArgumentError first(Set())
 @test first(Set(2)) == 2
 
-# ########## end of set tests ##########
+# pop!
+let s = Set(1:5)
+    @test 2 in s
+    @test pop!(s, 2) == 2
+    @test !(2 in s)
+    @test_throws KeyError pop!(s, 2)
+    @test pop!(s, 2, ()) == ()
+    @test 3 in s
+    @test pop!(s, 3, ()) == 3
+    @test !(3 in s)
+end
+
+@test pop!(Set(1:2), 2, nothing) == 2
diff --git a/test/show.jl b/test/show.jl
index 18731bd42577f..4130943a57d64 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -78,6 +78,8 @@ end
 #@test_repr "w = (x = y) = z" # Doesn't pass, but it's an invalid assignment loc
 @test_repr "a & b && c"
 @test_repr "a & (b && c)"
+@test_repr "(a => b) in c"
+@test_repr "a => b in c"
 
 # precedence tie resolution
 @test_repr "(a * b) * (c * d)"
@@ -293,3 +295,64 @@ let
     @test sprint(show, B)  == "\n\t[1, 1]  =  #undef\n\t[1, 2]  =  T12960()\n\t[2, 2]  =  #undef\n\t[3, 3]  =  #undef"
     @test sprint(print, B) == "\n\t[1, 1]  =  #undef\n\t[1, 2]  =  T12960()\n\t[2, 2]  =  #undef\n\t[3, 3]  =  #undef"
 end
+
+# issue #13127
+function f13127()
+    buf = IOBuffer()
+    f() = 1
+    show(buf, f)
+    takebuf_string(buf)
+end
+@test f13127() == "f"
+
+let a = Pair(1.0,2.0)
+    @test sprint(show,a) == "1.0=>2.0"
+end
+let a = Pair(Pair(1,2),Pair(3,4))
+    @test sprint(show,a) == "(1=>2)=>(3=>4)"
+end
+
+#test methodshow.jl functions
+@test Base.inbase(Base)
+@test Base.inbase(LinAlg)
+
+@test contains(sprint(io -> writemime(io,"text/plain",methods(Base.inbase))),"inbase(m::Module)")
+@test contains(sprint(io -> writemime(io,"text/html",methods(Base.inbase))),"inbase(m::<b>Module</b>)")
+
+if isempty(Base.GIT_VERSION_INFO.commit)
+    @test contains(Base.url(methods(eigs).defs),"https://github.com/JuliaLang/julia/tree/v$VERSION/base/linalg/arnoldi.jl#L")
+else
+    @test contains(Base.url(methods(eigs).defs),"https://github.com/JuliaLang/julia/tree/$(Base.GIT_VERSION_INFO.commit)/base/linalg/arnoldi.jl#L")
+end
+
+# print_matrix should be able to handle small and large objects easily, test by
+# calling writemime. This also indirectly tests print_matrix_row, which
+# is used repeatedly by print_matrix.
+# This fits on screen:
+@test replstr(eye(10)) == "10x10 Array{Float64,2}:\n 1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0\n 0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0\n 0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0\n 0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0\n 0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0\n 0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0\n 0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0\n 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0\n 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0\n 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0"
+# an array too long vertically to fit on screen, and too long horizontally:
+@test replstr(collect(1.:100.)) == "100-element Array{Float64,1}:\n   1.0\n   2.0\n   3.0\n   4.0\n   5.0\n   6.0\n   7.0\n   8.0\n   9.0\n  10.0\n   ⋮  \n  92.0\n  93.0\n  94.0\n  95.0\n  96.0\n  97.0\n  98.0\n  99.0\n 100.0"
+@test replstr(collect(1.:100.)') == "1x100 Array{Float64,2}:\n 1.0  2.0  3.0  4.0  5.0  6.0  7.0  …  95.0  96.0  97.0  98.0  99.0  100.0"
+# too big in both directions to fit on screen:
+@test replstr((1.:100.)*(1:100)') == "100x100 Array{Float64,2}:\n   1.0    2.0    3.0    4.0    5.0    6.0  …    97.0    98.0    99.0    100.0\n   2.0    4.0    6.0    8.0   10.0   12.0      194.0   196.0   198.0    200.0\n   3.0    6.0    9.0   12.0   15.0   18.0      291.0   294.0   297.0    300.0\n   4.0    8.0   12.0   16.0   20.0   24.0      388.0   392.0   396.0    400.0\n   5.0   10.0   15.0   20.0   25.0   30.0      485.0   490.0   495.0    500.0\n   6.0   12.0   18.0   24.0   30.0   36.0  …   582.0   588.0   594.0    600.0\n   7.0   14.0   21.0   28.0   35.0   42.0      679.0   686.0   693.0    700.0\n   8.0   16.0   24.0   32.0   40.0   48.0      776.0   784.0   792.0    800.0\n   9.0   18.0   27.0   36.0   45.0   54.0      873.0   882.0   891.0    900.0\n  10.0   20.0   30.0   40.0   50.0   60.0      970.0   980.0   990.0   1000.0\n   ⋮                                  ⋮    ⋱                                 \n  92.0  184.0  276.0  368.0  460.0  552.0     8924.0  9016.0  9108.0   9200.0\n  93.0  186.0  279.0  372.0  465.0  558.0     9021.0  9114.0  9207.0   9300.0\n  94.0  188.0  282.0  376.0  470.0  564.0     9118.0  9212.0  9306.0   9400.0\n  95.0  190.0  285.0  380.0  475.0  570.0     9215.0  9310.0  9405.0   9500.0\n  96.0  192.0  288.0  384.0  480.0  576.0  …  9312.0  9408.0  9504.0   9600.0\n  97.0  194.0  291.0  388.0  485.0  582.0     9409.0  9506.0  9603.0   9700.0\n  98.0  196.0  294.0  392.0  490.0  588.0     9506.0  9604.0  9702.0   9800.0\n  99.0  198.0  297.0  396.0  495.0  594.0     9603.0  9702.0  9801.0   9900.0\n 100.0  200.0  300.0  400.0  500.0  600.0     9700.0  9800.0  9900.0  10000.0"
+
+# Issue 14121
+@test_repr "(A'x)'"
+
+
+# issue #14481
+@test_repr "in(1,2,3)"
+@test_repr "<(1,2,3)"
+@test_repr "+(1,2,3)"
+@test_repr "-(1,2,3)"
+@test_repr "*(1,2,3)"
+
+# test structured zero matrix printing for select structured types
+A = reshape(1:16,4,4)
+@test replstr(Diagonal(A)) == "4x4 Diagonal{$Int}:\n 1  ⋅   ⋅   ⋅\n ⋅  6   ⋅   ⋅\n ⋅  ⋅  11   ⋅\n ⋅  ⋅   ⋅  16"
+@test replstr(Bidiagonal(A,true)) == "4x4 Bidiagonal{$Int}:\n 1  5   ⋅   ⋅\n ⋅  6  10   ⋅\n ⋅  ⋅  11  15\n ⋅  ⋅   ⋅  16"
+@test replstr(Bidiagonal(A,false)) == "4x4 Bidiagonal{$Int}:\n 1  ⋅   ⋅   ⋅\n 2  6   ⋅   ⋅\n ⋅  7  11   ⋅\n ⋅  ⋅  12  16"
+@test replstr(SymTridiagonal(A+A')) == "4x4 SymTridiagonal{$Int}:\n 2   7   ⋅   ⋅\n 7  12  17   ⋅\n ⋅  17  22  27\n ⋅   ⋅  27  32"
+@test replstr(Tridiagonal(diag(A,-1),diag(A),diag(A,+1))) == "4x4 Tridiagonal{$Int}:\n 1  5   ⋅   ⋅\n 2  6  10   ⋅\n ⋅  7  11  15\n ⋅  ⋅  12  16"
+@test replstr(UpperTriangular(A)) == "4x4 UpperTriangular{$Int,Array{$Int,2}}:\n 1  5   9  13\n ⋅  6  10  14\n ⋅  ⋅  11  15\n ⋅  ⋅   ⋅  16"
+@test replstr(LowerTriangular(A)) == "4x4 LowerTriangular{$Int,Array{$Int,2}}:\n 1  ⋅   ⋅   ⋅\n 2  6   ⋅   ⋅\n 3  7  11   ⋅\n 4  8  12  16"
diff --git a/test/simdloop.jl b/test/simdloop.jl
index c7d99fd15e73f..782c4e91f9cd6 100644
--- a/test/simdloop.jl
+++ b/test/simdloop.jl
@@ -125,3 +125,15 @@ crng = CartesianRange(CartesianIndex{0}(),
                       CartesianIndex{0}())
 indexes = simd_cartesian_range!(Array(eltype(crng), 0), crng)
 @test indexes == collect(crng)
+
+# @simd with array as "range"
+# issue #13869
+function simd_sum_over_array(a)
+    s = zero(eltype(a))
+    @inbounds @simd for x in a
+        s += x
+    end
+    s
+end
+@test 2001000 == simd_sum_over_array(collect(1:2000))
+@test 2001000 == simd_sum_over_array(Float32[i+j*500 for i=1:500, j=0:3])
diff --git a/test/socket.jl b/test/socket.jl
index 1810dfac1f1d7..550fc65b73d5f 100644
--- a/test/socket.jl
+++ b/test/socket.jl
@@ -14,17 +14,17 @@
 @test_throws InexactError Int16(IPv4("1.2.3.4"))
 @test_throws InexactError Int64(IPv6("2001:1::2"))
 
-let ipv = parseip("127.0.0.1")
+let ipv = parse(IPAddr, "127.0.0.1")
     @test isa(ipv, IPv4)
     @test ipv == ip"127.0.0.1"
 end
 
-@test_throws ArgumentError Base.parseipv4("192.0xFFFFFFF")
+@test_throws ArgumentError parse(IPv4, "192.0xFFFFFFF")
 @test_throws ArgumentError IPv4(192,255,255,-1)
 @test_throws ArgumentError IPv4(192,255,255,256)
 
-@test_throws ArgumentError Base.parseipv4("192.0xFFFFFFFFF")
-@test_throws ArgumentError Base.parseipv4("192.")
+@test_throws ArgumentError parse(IPv4, "192.0xFFFFFFFFF")
+@test_throws ArgumentError parse(IPv4, "192.")
 
 @test ip"::1" == IPv6(1)
 @test ip"2605:2700:0:3::4713:93e3" == IPv6(parse(UInt128,"260527000000000300000000471393e3",16))
@@ -33,7 +33,7 @@ end
 
 @test ip"0:0:0:0:0:ffff:127.0.0.1" == IPv6(0xffff7f000001)
 
-let ipv = parseip("0:0:0:0:0:ffff:127.0.0.1")
+let ipv = parse(IPAddr, "0:0:0:0:0:ffff:127.0.0.1")
     @test isa(ipv, IPv6)
     @test ipv == ip"0:0:0:0:0:ffff:127.0.0.1"
 end
@@ -47,8 +47,8 @@ let inet = Base.InetAddr(IPv4(127,0,0,1), 1024)
     @test inet.port == 1024
 end
 # test InetAddr invalid port
-@test_throws ArgumentError Base.InetAddr(IPv4(127,0,0,1), -1)
-@test_throws ArgumentError Base.InetAddr(IPv4(127,0,0,1), typemax(UInt16)+1)
+@test_throws InexactError Base.InetAddr(IPv4(127,0,0,1), -1)
+@test_throws InexactError Base.InetAddr(IPv4(127,0,0,1), typemax(UInt16)+1)
 
 # isless and comparisons
 @test ip"1.2.3.4" < ip"1.2.3.7" < ip"2.3.4.5"
@@ -64,6 +64,9 @@ end
 @test repr(ip"2001:db8:0:0:1:0:0:1") == "ip\"2001:db8::1:0:0:1\""
 @test repr(ip"2001:0:0:1:0:0:0:1") == "ip\"2001:0:0:1::1\""
 
+# test show() function for UDPSocket()
+@test repr(UDPSocket()) == "UDPSocket(init)"
+
 port = Channel(1)
 defaultport = rand(2000:4000)
 tsk = @async begin
@@ -83,25 +86,25 @@ tsk = @async begin
     close(sock)
 end
 wait(port)
-@test readall(connect(fetch(port))) == "Hello World\n" * ("a1\n"^100)
+@test readstring(connect(fetch(port))) == "Hello World\n" * ("a1\n"^100)
 wait(tsk)
 
-socketname = (@windows ? "\\\\.\\pipe\\uv-test" : "testsocket") * "-" * randstring(6)
-@unix_only isfile(socketname) && Base.FS.unlink(socketname)
-
-c=Base.Condition()
-for T in (ASCIIString, UTF8String, UTF16String) # test for issue #9435
-    tsk = @async begin
-        s = listen(T(socketname))
-        Base.notify(c)
-        sock = accept(s)
-        write(sock,"Hello World\n")
-        close(s)
-        close(sock)
+mktempdir() do tmpdir
+    socketname = @windows ? ("\\\\.\\pipe\\uv-test-" * randstring(6)) : joinpath(tmpdir, "socket")
+    c = Base.Condition()
+    for T in (ASCIIString, UTF8String, UTF16String) # test for issue #9435
+        tsk = @async begin
+            s = listen(T(socketname))
+            Base.notify(c)
+            sock = accept(s)
+            write(sock,"Hello World\n")
+            close(s)
+            close(sock)
+        end
+        wait(c)
+        @test readstring(connect(socketname)) == "Hello World\n"
+        wait(tsk)
     end
-    wait(c)
-    @test readall(connect(socketname)) == "Hello World\n"
-    wait(tsk)
 end
 
 @test_throws Base.UVError getaddrinfo(".invalid")
@@ -185,3 +188,134 @@ if @unix? true : (Base.windows_version() >= Base.WINDOWS_VISTA_VER)
     send(b, ip"::1", port, "Hello World")
     wait(tsk)
 end
+
+begin
+    default_port = UInt16(11011)
+    default_addr = IPv4("127.0.0.1")
+
+    sock = Base.TCPServer()
+    bind(sock,Base.InetAddr(default_addr,default_port))
+    listen(sock)
+
+    new_addr, new_port = getsockname(sock)
+
+    @test default_addr == new_addr
+    @test default_port == new_port
+    close(sock)
+end
+
+begin
+    default_port = UInt16(21011)
+    default_addr = IPv6("::1")
+
+    sock = Base.TCPServer()
+    addr = Base.InetAddr(default_addr,default_port)
+    bind(sock,addr)
+    listen(sock)
+
+    new_addr, new_port = getsockname(sock)
+
+    @test default_addr == new_addr
+    @test default_port == new_port
+    close(sock)
+end
+
+begin
+    default_port = UInt16(11011)
+    default_addr = getipaddr()
+
+    sock = Base.TCPServer()
+    bind(sock,Base.InetAddr(default_addr,default_port))
+    listen(sock)
+
+    @async begin
+        sleep(1)
+        ssock = connect(default_addr, default_port)
+    end
+
+    csock = accept(sock)
+    new_addr, new_port = getsockname(csock)
+
+    @test default_addr == new_addr
+    @test new_port > 0
+    close(csock)
+    close(sock)
+end
+
+# Local-machine broadcast
+let
+    # (Mac OS X's loopback interface doesn't support broadcasts)
+    bcastdst = @osx ? ip"255.255.255.255" : ip"127.255.255.255"
+
+    function create_socket()
+        s = UDPSocket()
+        bind(s, ip"0.0.0.0", 2000, reuseaddr = true, enable_broadcast = true)
+        s
+    end
+    a, b, c = [create_socket() for i = 1:3]
+    try
+        @sync begin
+            send(c, bcastdst, 2000, "hello")
+            recvs = [@async @test bytestring(recv(s)) == "hello" for s in (a, b)]
+            map(wait, recvs)
+        end
+    catch e
+        if isa(e, Base.UVError) && Base.uverrorname(e) == "EPERM"
+            warn("UDP broadcast test skipped (permission denied upon send, restrictive firewall?)")
+        else
+            rethrow()
+        end
+    end
+    [close(s) for s in [a, b, c]]
+end
+
+let P = Pipe()
+    Base.link_pipe(P)
+    write(P, "hello")
+    @test nb_available(P) == 0
+    @test !eof(P)
+    @test read(P, Char) === 'h'
+    @test !eof(P)
+    @test read(P, Char) === 'e'
+    @test isopen(P)
+    close(P.in)
+    @test isopen(P)
+    @test !eof(P)
+    @test readuntil(P, 'o') == "llo"
+    @test isopen(P)
+    @test eof(P)
+    @test !isopen(P)
+    close(P)
+    @test !isopen(P)
+    @test eof(P)
+end
+
+# test the method matching connect!(::TCPSocket, ::Base.InetAddr{T<:Base.IPAddr})
+let
+    addr = Base.InetAddr(ip"127.0.0.1", 4444)
+
+    function test_connect(addr::Base.InetAddr)
+        srv = listen(addr)
+
+        @async try c = accept(srv); close(c) catch end
+        yield()
+
+        t0 = TCPSocket()
+        t = t0
+        @assert is(t,t0)
+
+        try
+            t = connect(addr)
+        finally
+            close(srv)
+        end
+
+        test = !is(t,t0)
+        close(t)
+
+        return test
+    end
+
+    @test test_connect(addr)
+end
+
diff --git a/test/sorting.jl b/test/sorting.jl
index 03d6c4f201245..e8eca5a60d8e0 100644
--- a/test/sorting.jl
+++ b/test/sorting.jl
@@ -30,7 +30,6 @@ let a=[1:10;]
     end
 end
 @test sum(randperm(6)) == 21
-@test nthperm([0,1,2],3) == [1,0,2]
 
 numTypes = [ Int8,  Int16,  Int32,  Int64,  Int128,
             UInt8, UInt16, UInt32, UInt64, UInt128,
diff --git a/test/sparse.jl b/test/sparse.jl
index 79dcd9c27f413..c57b889fa11f8 100644
--- a/test/sparse.jl
+++ b/test/sparse.jl
@@ -1,6 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 include("sparsedir/sparse.jl")
+include("sparsedir/sparsevector.jl")
 if Base.USE_GPL_LIBS
     include("sparsedir/umfpack.jl")
     include("sparsedir/cholmod.jl")
diff --git a/test/sparsedir/cholmod.jl b/test/sparsedir/cholmod.jl
index 8026c0039bf9e..bc21d912b7591 100644
--- a/test/sparsedir/cholmod.jl
+++ b/test/sparsedir/cholmod.jl
@@ -3,7 +3,7 @@
 srand(123)
 using Base.Test
 
-using Base.SparseMatrix.CHOLMOD
+using Base.SparseArrays.CHOLMOD
 
 # based on deps/SuiteSparse-4.0.2/CHOLMOD/Demo/
 
@@ -174,7 +174,6 @@ let # Issue 9160
     end
 end
 
-
 # Issue #9915
 @test speye(2)\speye(2) == eye(2)
 
@@ -183,10 +182,10 @@ end
 @test eltype(A) == Float64
 @test eltype(chma) == Float64
 
-# test Sparse constructor Symmetric and Hermitian input (and issym and ishermitian)
+# test Sparse constructor Symmetric and Hermitian input (and issymmetric and ishermitian)
 ACSC = sprandn(10, 10, 0.3) + I
-@test issym(Sparse(Symmetric(ACSC, :L)))
-@test issym(Sparse(Symmetric(ACSC, :U)))
+@test issymmetric(Sparse(Symmetric(ACSC, :L)))
+@test issymmetric(Sparse(Symmetric(ACSC, :U)))
 @test ishermitian(Sparse(Hermitian(complex(ACSC), :L)))
 @test ishermitian(Sparse(Hermitian(complex(ACSC), :U)))
 
@@ -318,8 +317,8 @@ for elty in (Float64, Complex{Float64})
     A1pdSparse = CHOLMOD.Sparse(
         A1pd.m,
         A1pd.n,
-        Base.SparseMatrix.decrement(A1pd.colptr),
-        Base.SparseMatrix.decrement(A1pd.rowval),
+        Base.SparseArrays.decrement(A1pd.colptr),
+        Base.SparseArrays.decrement(A1pd.rowval),
         A1pd.nzval)
 
     ## High level interface
@@ -388,7 +387,7 @@ for elty in (Float64, Complex{Float64})
     @test !isposdef(A1 + A1' |> t -> t - 2eigmax(full(t))*I)
 
     if elty <: Real
-        @test CHOLMOD.issym(Sparse(A1pd, 0))
+        @test CHOLMOD.issymmetric(Sparse(A1pd, 0))
         @test CHOLMOD.Sparse(cholfact(Symmetric(A1pd, :L))) == CHOLMOD.Sparse(cholfact(A1pd))
         F1 = CHOLMOD.Sparse(cholfact(Symmetric(A1pd, :L), shift=2))
         F2 = CHOLMOD.Sparse(cholfact(A1pd, shift=2))
@@ -398,7 +397,7 @@ for elty in (Float64, Complex{Float64})
         F2 = CHOLMOD.Sparse(ldltfact(A1pd, shift=2))
         @test F1 == F2
     else
-        @test !CHOLMOD.issym(Sparse(A1pd, 0))
+        @test !CHOLMOD.issymmetric(Sparse(A1pd, 0))
         @test CHOLMOD.ishermitian(Sparse(A1pd, 0))
         @test CHOLMOD.Sparse(cholfact(Hermitian(A1pd, :L))) == CHOLMOD.Sparse(cholfact(A1pd))
         F1 = CHOLMOD.Sparse(cholfact(Hermitian(A1pd, :L), shift=2))
@@ -410,27 +409,27 @@ for elty in (Float64, Complex{Float64})
         @test F1 == F2
     end
 
-    ### update!
+    ### cholfact!/ldltfact!
     F = cholfact(A1pd)
     CHOLMOD.change_factor!(elty, false, false, true, true, F)
     @test unsafe_load(F.p).is_ll == 0
     CHOLMOD.change_factor!(elty, true, false, true, true, F)
-    @test_approx_eq CHOLMOD.Sparse(CHOLMOD.update!(copy(F), A1pd)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
+    @test_approx_eq CHOLMOD.Sparse(cholfact!(copy(F), A1pd)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
     @test size(F, 2) == 5
     @test size(F, 3) == 1
     @test_throws ArgumentError size(F, 0)
 
     F = cholfact(A1pdSparse, shift=2)
     @test isa(CHOLMOD.Sparse(F), CHOLMOD.Sparse{elty})
-    @test_approx_eq CHOLMOD.Sparse(CHOLMOD.update!(copy(F), A1pd, shift=2.0)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
+    @test_approx_eq CHOLMOD.Sparse(cholfact!(copy(F), A1pd, shift=2.0)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
 
     F = ldltfact(A1pd)
     @test isa(CHOLMOD.Sparse(F), CHOLMOD.Sparse{elty})
-    @test_approx_eq CHOLMOD.Sparse(CHOLMOD.update!(copy(F), A1pd)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
+    @test_approx_eq CHOLMOD.Sparse(ldltfact!(copy(F), A1pd)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
 
     F = ldltfact(A1pdSparse, shift=2)
     @test isa(CHOLMOD.Sparse(F), CHOLMOD.Sparse{elty})
-    @test_approx_eq CHOLMOD.Sparse(CHOLMOD.update!(copy(F), A1pd, shift=2.0)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
+    @test_approx_eq CHOLMOD.Sparse(ldltfact!(copy(F), A1pd, shift=2.0)) CHOLMOD.Sparse(F) # surprisingly, this can cause small ulp size changes so we cannot test exact equality
 
     @test isa(CHOLMOD.factor_to_sparse!(F), CHOLMOD.Sparse)
     @test_throws CHOLMOD.CHOLMODException CHOLMOD.factor_to_sparse!(F)
@@ -564,7 +563,7 @@ b = rand(3)
 Asp = As[p,p]
 LDp = sparse(ldltfact(Asp, perm=[1,2,3])[:LD])
 # LDp = sparse(Fs[:LD])
-Lp, dp = Base.SparseMatrix.CHOLMOD.getLd!(copy(LDp))
+Lp, dp = Base.SparseArrays.CHOLMOD.getLd!(copy(LDp))
 Dp = spdiagm(dp)
 @test_approx_eq Fs\b Af\b
 @test_approx_eq Fs[:UP]\(Fs[:PtLD]\b) Af\b
@@ -597,3 +596,39 @@ Base.writemime(IOBuffer(), MIME"text/plain"(), cholfact(sparse(Float64[ 10 1 1 1
 # Element promotion and type inference
 @inferred cholfact(As)\ones(Int, size(As, 1))
 @inferred ldltfact(As)\ones(Int, size(As, 1))
+
+# Issue 14076
+@test cholfact(sparse([1,2,3,4], [1,2,3,4], Float32[1,4,16,64]))\[1,4,16,64] == ones(4)
+
+# Issue 14134
+A = SparseArrays.CHOLMOD.Sparse(sprandn(10,5,0.1) + I |> t -> t't)
+b = IOBuffer()
+serialize(b, A)
+seekstart(b)
+Anew = deserialize(b)
+@test_throws ArgumentError show(Anew)
+@test_throws ArgumentError size(Anew)
+@test_throws ArgumentError Anew[1]
+@test_throws ArgumentError Anew[2,1]
+F = cholfact(A)
+serialize(b, F)
+seekstart(b)
+Fnew = deserialize(b)
+@test_throws ArgumentError Fnew\ones(5)
+@test_throws ArgumentError show(Fnew)
+@test_throws ArgumentError size(Fnew)
+@test_throws ArgumentError diag(Fnew)
+@test_throws ArgumentError logdet(Fnew)
+
+# Issue with promotion during conversion to CHOLMOD.Dense
+@test SparseArrays.CHOLMOD.Dense(ones(Float32, 5)) == ones(5, 1)
+@test SparseArrays.CHOLMOD.Dense(ones(Int, 5)) == ones(5, 1)
+@test SparseArrays.CHOLMOD.Dense(ones(Complex{Float32}, 5, 2)) == ones(5, 2)
+
+# Further issue with promotion #14894
+@test cholfact(speye(Float16, 5))\ones(5) == ones(5)
+@test cholfact(Symmetric(speye(Float16, 5)))\ones(5) == ones(5)
+@test cholfact(Hermitian(speye(Complex{Float16}, 5)))\ones(5) == ones(Complex{Float64}, 5)
+@test_throws MethodError cholfact(speye(BigFloat, 5))
+@test_throws MethodError cholfact(Symmetric(speye(BigFloat, 5)))
+@test_throws MethodError cholfact(Hermitian(speye(Complex{BigFloat}, 5)))
diff --git a/test/sparsedir/sparse.jl b/test/sparsedir/sparse.jl
index 5b00876343974..56f498d6484da 100644
--- a/test/sparsedir/sparse.jl
+++ b/test/sparsedir/sparse.jl
@@ -2,8 +2,19 @@
 
 using Base.Test
 
+@test issparse(sparse(ones(5,5)))
+@test !issparse(ones(5,5))
+@test Base.SparseArrays.indtype(sparse(ones(Int8,2),ones(Int8,2),rand(2))) == Int8
+
 # check sparse matrix construction
 @test isequal(full(sparse(complex(ones(5,5),ones(5,5)))), complex(ones(5,5),ones(5,5)))
+@test_throws ArgumentError sparse([1,2,3], [1,2], [1,2,3], 3, 3)
+@test_throws ArgumentError sparse([1,2,3], [1,2,3], [1,2], 3, 3)
+@test_throws ArgumentError sparse([1,2,3], [1,2,3], [1,2,3], 0, 1)
+@test_throws ArgumentError sparse([1,2,3], [1,2,3], [1,2,3], 1, 0)
+@test_throws ArgumentError sparse([1,2,4], [1,2,3], [1,2,3], 3, 3)
+@test_throws ArgumentError sparse([1,2,3], [1,2,4], [1,2,3], 3, 3)
+@test isequal(sparse(Int[], Int[], Int[], 0, 0), SparseMatrixCSC(0, 0, Int[1], Int[], Int[]))
 
 # check matrix operations
 se33 = speye(3)
@@ -48,7 +59,7 @@ de33 = eye(3)
 # also side-checks sparse ref
 for i = 1 : 10
     a = sprand(5, 4, 0.5)
-    @test all([a[1:2,1:2] a[1:2,3:4]; a[3:5,1] [a[3:4,2:4]; a[5,2:4]]] == a)
+    @test all([a[1:2,1:2] a[1:2,3:4]; a[3:5,1] [a[3:4,2:4]; a[5:5,2:4]]] == a)
 end
 
 # sparse ref
@@ -70,6 +81,18 @@ a116[p, p] = reshape(1:9, 3, 3)
 s116[p, p] = reshape(1:9, 3, 3)
 @test a116 == s116
 
+# squeeze
+for i = 1:5
+    am = sprand(20, 1, 0.2)
+    av = squeeze(am, 2)
+    @test ndims(av) == 1
+    @test all(av.==am)
+    am = sprand(1, 20, 0.2)
+    av = squeeze(am, 1)
+    @test ndims(av) == 1
+    @test all(av.'.==am)
+end
+
 # matrix-vector multiplication (non-square)
 for i = 1:5
     a = sprand(10, 5, 0.5)
@@ -126,7 +149,6 @@ for i = 1:5
     @test (maximum(abs(a\b - full(a)\b)) < 1000*eps())
     @test (maximum(abs(a'\b - full(a')\b)) < 1000*eps())
     @test (maximum(abs(a.'\b - full(a.')\b)) < 1000*eps())
-    @test (maximum(abs(A_ldiv_B!(a,copy(b)) - full(a)\b)) < 1000*eps())
 
     a = speye(5) + tril(0.1*sprandn(5, 5, 0.2) + 0.1*im*sprandn(5, 5, 0.2))
     b = randn(5,3)
@@ -145,7 +167,6 @@ for i = 1:5
     @test (maximum(abs(a\b - full(a)\b)) < 1000*eps())
     @test (maximum(abs(a'\b - full(a')\b)) < 1000*eps())
     @test (maximum(abs(a.'\b - full(a.')\b)) < 1000*eps())
-    @test (maximum(abs(A_ldiv_B!(a,copy(b)) - full(a)\b)) < 1000*eps())
 
     a = speye(5) + triu(0.1*sprandn(5, 5, 0.2) + 0.1*im*sprandn(5, 5, 0.2))
     b = randn(5,3)
@@ -164,7 +185,6 @@ for i = 1:5
     @test (maximum(abs(a\b - full(a)\b)) < 1000*eps())
     @test (maximum(abs(a'\b - full(a')\b)) < 1000*eps())
     @test (maximum(abs(a.'\b - full(a.')\b)) < 1000*eps())
-    @test (maximum(abs(A_ldiv_B!(a,copy(b)) - full(a)\b)) < 1000*eps())
 
     a = spdiagm(randn(5)) + im*spdiagm(randn(5))
     b = randn(5,3)
@@ -190,14 +210,17 @@ for i = 1:5
     a = sprand(10, 5, 0.7)
     b = sprand(5, 15, 0.3)
     @test maximum(abs(a*b - full(a)*full(b))) < 100*eps()
-    @test maximum(abs(Base.SparseMatrix.spmatmul(a,b,sortindices=:sortcols) - full(a)*full(b))) < 100*eps()
-    @test maximum(abs(Base.SparseMatrix.spmatmul(a,b,sortindices=:doubletranspose) - full(a)*full(b))) < 100*eps()
+    @test maximum(abs(Base.SparseArrays.spmatmul(a,b,sortindices=:sortcols) - full(a)*full(b))) < 100*eps()
+    @test maximum(abs(Base.SparseArrays.spmatmul(a,b,sortindices=:doubletranspose) - full(a)*full(b))) < 100*eps()
     @test full(kron(a,b)) == kron(full(a), full(b))
     @test full(kron(full(a),b)) == kron(full(a), full(b))
     @test full(kron(a,full(b))) == kron(full(a), full(b))
     c = sparse(rand(Float32,5,5))
     d = sparse(rand(Float64,5,5))
     @test full(kron(c,d)) == kron(full(c),full(d))
+    f = Diagonal(rand(5))
+    @test full(a*f) == full(a)*f
+    @test full(f*b) == f*full(b)
 end
 
 # scale and scale!
@@ -205,22 +228,54 @@ sA = sprandn(3, 7, 0.5)
 sC = similar(sA)
 dA = full(sA)
 b = randn(7)
-@test scale(dA, b) == scale(sA, b)
-@test scale(dA, b) == scale!(sC, sA, b)
-@test scale(dA, b) == scale!(copy(sA), b)
+@test dA * Diagonal(b) == sA * Diagonal(b)
+@test dA * Diagonal(b) == scale!(sC, sA, b)
+@test dA * Diagonal(b) == scale!(copy(sA), b)
 b = randn(3)
-@test scale(b, dA) == scale(b, sA)
-@test scale(b, dA) == scale!(sC, b, sA)
-@test scale(b, dA) == scale!(b, copy(sA))
-
-@test scale(dA, 0.5) == scale(sA, 0.5)
-@test scale(dA, 0.5) == scale!(sC, sA, 0.5)
-@test scale(dA, 0.5) == scale!(copy(sA), 0.5)
-@test scale(0.5, dA) == scale(0.5, sA)
-@test scale(0.5, dA) == scale!(sC, sA, 0.5)
-@test scale(0.5, dA) == scale!(0.5, copy(sA))
+@test Diagonal(b) * dA == Diagonal(b) * sA
+@test Diagonal(b) * dA == scale!(sC, b, sA)
+@test Diagonal(b) * dA == scale!(b, copy(sA))
+
+@test dA * 0.5            == sA * 0.5
+@test dA * 0.5            == scale!(sC, sA, 0.5)
+@test dA * 0.5            == scale!(copy(sA), 0.5)
+@test 0.5 * dA            == 0.5 * sA
+@test 0.5 * dA            == scale!(sC, sA, 0.5)
+@test 0.5 * dA            == scale!(0.5, copy(sA))
 @test scale!(sC, 0.5, sA) == scale!(sC, sA, 0.5)
 
+# copy!
+let
+    A = sprand(5, 5, 0.2)
+    B = sprand(5, 5, 0.2)
+    copy!(A, B)
+    @test A == B
+    @test pointer(A.nzval) != pointer(B.nzval)
+    @test pointer(A.rowval) != pointer(B.rowval)
+    @test pointer(A.colptr) != pointer(B.colptr)
+    # Test size(A) != size(B)
+    B = sprand(3, 3, 0.2)
+    copy!(A, B)
+    @test A[1:9] == B[:]
+    # Test eltype(A) != eltype(B), size(A) != size(B)
+    B = sparse(rand(Float32, 3, 3))
+    copy!(A, B)
+    @test A[1:9] == B[:]
+    # Test eltype(A) != eltype(B), size(A) == size(B)
+    A = sparse(rand(Float64, 3, 3))
+    B = sparse(rand(Float32, 3, 3))
+    copy!(A, B)
+    @test A == B
+end
+
+# conj
+cA = sprandn(5,5,0.2) + im*sprandn(5,5,0.2)
+@test full(conj(cA)) == conj(full(cA))
+
+# exp
+A = sprandn(5,5,0.2)
+@test e.^A ≈ e.^full(A)
+
 # reductions
 pA = sparse(rand(3, 7))
 
@@ -290,7 +345,10 @@ mfe22 = eye(Float64, 2)
 @test_throws ArgumentError sparsevec([3,5,7],[0.1,0.0,3.2],4)
 
 # issue #5169
-@test nnz(sparse([1,1],[1,2],[0.0,-0.0])) == 0
+@test nnz(sparse([1,1],[1,2],[0.0,-0.0])) == 2
+@test nnz(Base.SparseArrays.dropzeros!(sparse([1,1],[1,2],[0.0,-0.0]))) == 0
+# changed from `== 0` to `== 2` and added dropzeros! form in #14798,
+# matching sparse()'s behavioral revision discussed in #12605, #9928, #9906, #6769
 
 # issue #5386
 K,J,V = findnz(SparseMatrixCSC(2,1,[1,3],[1,2],[1.0,0.0]))
@@ -301,7 +359,10 @@ A = speye(Bool, 5)
 @test find(A) == find(x -> x == true, A) == find(full(A))
 
 # issue #5437
-@test nnz(sparse([1,2,3],[1,2,3],[0.0,1.0,2.0])) == 2
+@test nnz(sparse([1,2,3],[1,2,3],[0.0,1.0,2.0])) == 3
+@test nnz(Base.SparseArrays.dropzeros!(sparse([1,2,3],[1,2,3],[0.0,1.0,2.0]))) == 2
+# changed from `== 2` to `== 3` and added dropzeros! form in #14798,
+# matching sparse()'s behavioral revision discussed in #12605, #9928, #9906, #6769
 
 # issue #5824
 @test sprand(4,5,0.5).^0 == sparse(ones(4,5))
@@ -379,20 +440,22 @@ for (aa116, ss116) in [(a116, s116), (ad116, sd116)]
     @test ss116[i,j] == 0
     ss116 = sparse(aa116)
 
+    @test ss116[:,:] == copy(ss116)
+
     # range indexing
     @test full(ss116[i,:]) == aa116[i,:]
-    @test full(ss116[:,j]) == aa116[:,j]'' # sparse matrices/vectors always have ndims==2:
+    @test full(ss116[:,j]) == aa116[:,j]
     @test full(ss116[i,1:2:end]) == aa116[i,1:2:end]
-    @test full(ss116[1:2:end,j]) == aa116[1:2:end,j]''
+    @test full(ss116[1:2:end,j]) == aa116[1:2:end,j]
     @test full(ss116[i,end:-2:1]) == aa116[i,end:-2:1]
-    @test full(ss116[end:-2:1,j]) == aa116[end:-2:1,j]''
+    @test full(ss116[end:-2:1,j]) == aa116[end:-2:1,j]
     # float-range indexing is not supported
 
     # sorted vector indexing
     @test full(ss116[i,[3:2:end-3;]]) == aa116[i,[3:2:end-3;]]
-    @test full(ss116[[3:2:end-3;],j]) == aa116[[3:2:end-3;],j]''
+    @test full(ss116[[3:2:end-3;],j]) == aa116[[3:2:end-3;],j]
     @test full(ss116[i,[end-3:-2:1;]]) == aa116[i,[end-3:-2:1;]]
-    @test full(ss116[[end-3:-2:1;],j]) == aa116[[end-3:-2:1;],j]''
+    @test full(ss116[[end-3:-2:1;],j]) == aa116[[end-3:-2:1;],j]
 
     # unsorted vector indexing with repetition
     p = [4, 1, 2, 3, 2, 6]
@@ -403,7 +466,7 @@ for (aa116, ss116) in [(a116, s116), (ad116, sd116)]
     # bool indexing
     li = bitrand(size(aa116,1))
     lj = bitrand(size(aa116,2))
-    @test full(ss116[li,j]) == aa116[li,j]''
+    @test full(ss116[li,j]) == aa116[li,j]
     @test full(ss116[li,:]) == aa116[li,:]
     @test full(ss116[i,lj]) == aa116[i,lj]
     @test full(ss116[:,lj]) == aa116[:,lj]
@@ -412,7 +475,7 @@ for (aa116, ss116) in [(a116, s116), (ad116, sd116)]
     # empty indices
     for empty in (1:0, Int[])
         @test full(ss116[empty,:]) == aa116[empty,:]
-        @test full(ss116[:,empty]) == aa116[:,empty]''
+        @test full(ss116[:,empty]) == aa116[:,empty]
         @test full(ss116[empty,lj]) == aa116[empty,lj]
         @test full(ss116[li,empty]) == aa116[li,empty]
         @test full(ss116[empty,empty]) == aa116[empty,empty]
@@ -445,7 +508,7 @@ S1290 = SparseMatrixCSC(3, 3, UInt8[1,1,1,1], UInt8[], Int64[])
     S1290[end] = 3
     @test S1290[end] == (S1290[1] + S1290[2,2])
     @test 6 == sum(diag(S1290))
-    @test (full(S1290)[[3,1],1])'' == full(S1290[[3,1],1])
+    @test full(S1290)[[3,1],1] == full(S1290[[3,1],1])
 # end
 
 
@@ -454,13 +517,13 @@ let a = spzeros(Int, 10, 10)
     @test countnz(a) == 0
     a[1,:] = 1
     @test countnz(a) == 10
-    @test a[1,:] == sparse(ones(Int,1,10))
+    @test a[1,:] == sparse(ones(Int,10))
     a[:,2] = 2
     @test countnz(a) == 19
-    @test a[:,2] == 2*sparse(ones(Int,10,1))
+    @test a[:,2] == 2*sparse(ones(Int,10))
 
     a[1,:] = 1:10
-    @test a[1,:] == sparse([1:10;]')
+    @test a[1,:] == sparse([1:10;])
     a[:,2] = 1:10
     @test a[:,2] == sparse([1:10;])
 end
@@ -500,9 +563,9 @@ let ASZ = 1000, TSZ = 800
 end
 
 let A = speye(Int, 5), I=1:10, X=reshape([trues(10); falses(15)],5,5)
-    @test A[I] == A[X] == reshape([1,0,0,0,0,0,1,0,0,0], 10, 1)
+    @test A[I] == A[X] == [1,0,0,0,0,0,1,0,0,0]
     A[I] = [1:10;]
-    @test A[I] == A[X] == reshape(1:10, 10, 1)
+    @test A[I] == A[X] == collect(1:10)
 end
 
 let S = sprand(50, 30, 0.5, x->round(Int,rand(x)*100)), I = sprandbool(50, 30, 0.2)
@@ -540,7 +603,7 @@ let S = sprand(50, 30, 0.5, x->round(Int,rand(x)*100))
 end
 
 #Issue 7507
-@test (i7507=sparsevec(Dict{Int64, Float64}(), 10))==spzeros(10,1)
+@test (i7507=sparsevec(Dict{Int64, Float64}(), 10))==spzeros(10)
 
 #Issue 7650
 let S = spzeros(3, 3)
@@ -552,9 +615,10 @@ let X = eye(5), M = rand(5,4), C = spzeros(3,3)
     VX = vec(X); VSX = vec(SX)
     VM = vec(M); VSM1 = vec(SM); VSM2 = sparsevec(M)
     VC = vec(C)
-    @test reshape(VX, (25,1)) == VSX
-    @test reshape(VM, (20,1)) == VSM1 == VSM2
-    @test size(VC) == (9,1)
+    @test VX == VSX
+    @test VM == VSM1
+    @test VM == VSM2
+    @test size(VC) == (9,)
     @test nnz(VC) == 0
     @test nnz(VSX) == 5
 end
@@ -641,9 +705,9 @@ function test_getindex_algs{Tv,Ti}(A::SparseMatrixCSC{Tv,Ti}, I::AbstractVector,
         ((minj < 1) || (maxj > n)) && BoundsError()
     end
 
-    (alg == 0) ? Base.SparseMatrix.getindex_I_sorted_bsearch_A(A, I, J) :
-    (alg == 1) ? Base.SparseMatrix.getindex_I_sorted_bsearch_I(A, I, J) :
-    Base.SparseMatrix.getindex_I_sorted_linear(A, I, J)
+    (alg == 0) ? Base.SparseArrays.getindex_I_sorted_bsearch_A(A, I, J) :
+    (alg == 1) ? Base.SparseArrays.getindex_I_sorted_bsearch_I(A, I, J) :
+    Base.SparseArrays.getindex_I_sorted_linear(A, I, J)
 end
 
 let M=2^14, N=2^4
@@ -761,7 +825,7 @@ end
 
 # issue #9917
 @test sparse([]') == reshape(sparse([]), 1, 0)
-@test full(sparse([])) == zeros(0, 1)
+@test full(sparse([])) == zeros(0)
 @test_throws BoundsError sparse([])[1]
 @test_throws BoundsError sparse([])[1] = 1
 x = speye(100)
@@ -879,8 +943,17 @@ let  A = sprand(10,10,0.3), B = sprand(10,10,0.3), CF = rand(10,10), AF = full(A
     @test BF[:,1] .^ A == BF[:,1] .^ AF
 end
 
+# test broadcasting for empty matrices
+@test spzeros(0,0)  + spzeros(0,0)  == zeros(0,0)
+@test spzeros(0,0)  * spzeros(0,0)  == zeros(0,0)
+@test spzeros(1,0) .+ spzeros(2,1)  == zeros(2,0)
+@test spzeros(1,0) .* spzeros(2,1)  == zeros(2,0)
+@test spzeros(1,2) .+ spzeros(0,1)  == zeros(0,2)
+@test spzeros(1,2) .* spzeros(0,1)  == zeros(0,2)
+
 # test throws
 A = sprandbool(5,5,0.2)
+@test_throws ArgumentError reinterpret(Complex128,A)
 @test_throws ArgumentError reinterpret(Complex128,A,(5,5))
 @test_throws DimensionMismatch reinterpret(Int8,A,(20,))
 @test_throws DimensionMismatch reshape(A,(20,2))
@@ -904,6 +977,8 @@ A = sprandbool(5,5,0.2)
 # test sparsevec
 A = sparse(ones(5,5))
 @test all(full(sparsevec(A)) .== ones(25))
+@test all(full(sparsevec([1:5;],1)) .== ones(5))
+@test_throws ArgumentError sparsevec([1:5;], [1:4;])
 
 #test sparse
 @test sparse(A) == A
@@ -927,10 +1002,16 @@ A = sparse(tril(rand(5,5)))
 srand(1234321)
 A = triu(sprand(10,10,0.2))       # symperm operates on upper triangle
 perm = randperm(10)
-@test symperm(A,perm).colptr == [1,2,3,3,3,4,5,5,7,9,10]
+@test symperm(A,perm).colptr == [1,1,2,4,5,5,6,8,8,9,10]
 
 # droptol
 @test Base.droptol!(A,0.01).colptr == [1,1,1,2,2,3,4,6,6,7,9]
+@test isequal(Base.droptol!(sparse([1], [1], [1]), 1), SparseMatrixCSC(1,1,Int[1,1],Int[],Int[]))
+
+# dropzeros
+A = sparse([1 2 3; 4 5 6; 7 8 9])
+A.nzval[2] = A.nzval[6] = A.nzval[7] = 0
+@test Base.dropzeros!(A).colptr == [1, 3, 5, 7]
 
 #trace
 @test_throws DimensionMismatch trace(sparse(ones(5,6)))
@@ -940,6 +1021,7 @@ perm = randperm(10)
 @test_throws DimensionMismatch diagm(sparse(ones(5,2)))
 @test_throws DimensionMismatch diagm(sparse(ones(2,5)))
 @test diagm(sparse(ones(1,5))) == speye(5)
+@test diagm(sparse(ones(5,1))) == speye(5)
 
 # triu/tril
 A = sprand(5,5,0.2)
@@ -952,6 +1034,13 @@ AF = full(A)
 @test_throws BoundsError tril(A,-6)
 @test_throws BoundsError triu(A,6)
 @test_throws BoundsError triu(A,-6)
+@test_throws ArgumentError tril!(sparse([1,2,3], [1,2,3], [1,2,3], 3, 4), 4)
+@test_throws ArgumentError tril!(sparse([1,2,3], [1,2,3], [1,2,3], 3, 4), -3)
+@test_throws ArgumentError triu!(sparse([1,2,3], [1,2,3], [1,2,3], 3, 4), 4)
+@test_throws ArgumentError triu!(sparse([1,2,3], [1,2,3], [1,2,3], 3, 4), -3)
+
+# fkeep trim option
+@test isequal(length(tril!(sparse([1,2,3], [1,2,3], [1,2,3], 3, 4), -1).rowval), 0)
 
 # test norm
 
@@ -962,43 +1051,43 @@ A = sparse([1.0])
 @test_throws ArgumentError norm(sprand(5,5,0.2),3)
 @test_throws ArgumentError norm(sprand(5,5,0.2),2)
 
-# test ishermitian and issym real matrices
+# test ishermitian and issymmetric real matrices
 A = speye(5,5)
 @test ishermitian(A) == true
-@test issym(A) == true
+@test issymmetric(A) == true
 A[1,3] = 1.0
 @test ishermitian(A) == false
-@test issym(A) == false
+@test issymmetric(A) == false
 A[3,1] = 1.0
 @test ishermitian(A) == true
-@test issym(A) == true
+@test issymmetric(A) == true
 
-# test ishermitian and issym complex matrices
+# test ishermitian and issymmetric complex matrices
 A = speye(5,5) + im*speye(5,5)
 @test ishermitian(A) == false
-@test issym(A) == true
+@test issymmetric(A) == true
 A[1,4] = 1.0 + im
 @test ishermitian(A) == false
-@test issym(A) == false
+@test issymmetric(A) == false
 
 A = speye(Complex128, 5,5)
 A[3,2] = 1.0 + im
 @test ishermitian(A) == false
-@test issym(A) == false
+@test issymmetric(A) == false
 A[2,3] = 1.0 - im
 @test ishermitian(A) == true
-@test issym(A) == false
+@test issymmetric(A) == false
 
 A = sparse(zeros(5,5))
 @test ishermitian(A) == true
-@test issym(A) == true
+@test issymmetric(A) == true
 
 # Test with explicit zeros
 A = speye(Complex128, 5,5)
 A[3,1] = 2
 A.nzval[2] = 0.0
 @test ishermitian(A) == true
-@test issym(A) == true
+@test issymmetric(A) == true
 
 # equality ==
 A1 = speye(10)
@@ -1069,14 +1158,15 @@ Ai = ceil(Int,Ar*100)
 @test_approx_eq vecnorm(Ai)    vecnorm(full(Ai))
 
 # test sparse matrix cond
-A = sparse([1.0])
+A = sparse(reshape([1.0],1,1))
 Ac = sprandn(20,20,.5) + im* sprandn(20,20,.5)
 Ar = sprandn(20,20,.5)
 @test cond(A,1) == 1.0
-@test_approx_eq_eps cond(Ar,1) cond(full(Ar),1) 1e-4
-@test_approx_eq_eps cond(Ac,1) cond(full(Ac),1) 1e-4
-@test_approx_eq_eps cond(Ar,Inf) cond(full(Ar),Inf) 1e-4
-@test_approx_eq_eps cond(Ac,Inf) cond(full(Ac),Inf) 1e-4
+# For a discussion of the tolerance, see #14778
+@test 0.99 <= cond(Ar, 1) \ norm(Ar, 1) * norm(inv(full(Ar)), 1) < 3
+@test 0.99 <= cond(Ac, 1) \ norm(Ac, 1) * norm(inv(full(Ac)), 1) < 3
+@test 0.99 <= cond(Ar, Inf) \ norm(Ar, Inf) * norm(inv(full(Ar)), Inf) < 3
+@test 0.99 <= cond(Ac, Inf) \ norm(Ac, Inf) * norm(inv(full(Ac)), Inf) < 3
 @test_throws ArgumentError cond(A,2)
 @test_throws ArgumentError cond(A,3)
 let Arect = spzeros(10, 6)
@@ -1090,12 +1180,12 @@ Ac = sprandn(20,20,.5) + im* sprandn(20,20,.5)
 Aci = ceil(Int64,100*sprand(20,20,.5))+ im*ceil(Int64,sprand(20,20,.5))
 Ar = sprandn(20,20,.5)
 Ari = ceil(Int64,100*Ar)
-@test_approx_eq_eps Base.SparseMatrix.normestinv(Ac,3) norm(inv(full(Ac)),1) 1e-4
-@test_approx_eq_eps Base.SparseMatrix.normestinv(Aci,3) norm(inv(full(Aci)),1) 1e-4
-@test_approx_eq_eps Base.SparseMatrix.normestinv(Ar) norm(inv(full(Ar)),1) 1e-4
-@test_throws ArgumentError Base.SparseMatrix.normestinv(Ac,0)
-@test_throws ArgumentError Base.SparseMatrix.normestinv(Ac,21)
-@test_throws DimensionMismatch Base.SparseMatrix.normestinv(sprand(3,5,.9))
+@test_approx_eq_eps Base.SparseArrays.normestinv(Ac,3) norm(inv(full(Ac)),1) 1e-4
+@test_approx_eq_eps Base.SparseArrays.normestinv(Aci,3) norm(inv(full(Aci)),1) 1e-4
+@test_approx_eq_eps Base.SparseArrays.normestinv(Ar) norm(inv(full(Ar)),1) 1e-4
+@test_throws ArgumentError Base.SparseArrays.normestinv(Ac,0)
+@test_throws ArgumentError Base.SparseArrays.normestinv(Ac,21)
+@test_throws DimensionMismatch Base.SparseArrays.normestinv(sprand(3,5,.9))
 
 @test_throws ErrorException transpose(sub(sprandn(10, 10, 0.3), 1:4, 1:4))
 @test_throws ErrorException ctranspose(sub(sprandn(10, 10, 0.3), 1:4, 1:4))
@@ -1104,7 +1194,7 @@ Ari = ceil(Int64,100*Ar)
 A = sprand(10,10,0.2)
 p = randperm(10)
 q = randperm(10)
-@test Base.SparseMatrix.csc_permute(A, invperm(p), q) == full(A)[p, q]
+@test Base.SparseArrays.csc_permute(A, invperm(p), q) == full(A)[p, q]
 
 # issue #13008
 @test_throws ArgumentError sparse(collect(1:100), collect(1:100), fill(5,100), 5, 5)
@@ -1134,3 +1224,64 @@ let
         @test op(A13024, B13024) == op(full(A13024), full(B13024))
     end
 end
+
+let A = 2. * speye(5,5)
+    @test full(spones(A)) == eye(full(A))
+end
+
+let
+    A = spdiagm(rand(5)) + sprandn(5,5,0.2) + im*sprandn(5,5,0.2)
+    A = A + A'
+    @test abs(det(factorize(Hermitian(A)))) ≈ abs(det(factorize(full(A))))
+    A = spdiagm(rand(5)) + sprandn(5,5,0.2) + im*sprandn(5,5,0.2)
+    A = A*A'
+    @test abs(det(factorize(Hermitian(A)))) ≈ abs(det(factorize(full(A))))
+    A = spdiagm(rand(5)) + sprandn(5,5,0.2)
+    A = A + A.'
+    @test abs(det(factorize(Symmetric(A)))) ≈ abs(det(factorize(full(A))))
+    A = spdiagm(rand(5)) + sprandn(5,5,0.2)
+    A = A*A.'
+    @test abs(det(factorize(Symmetric(A)))) ≈ abs(det(factorize(full(A))))
+    @test factorize(triu(A)) == triu(A)
+    @test isa(factorize(triu(A)), UpperTriangular{Float64, SparseMatrixCSC{Float64, Int}})
+    @test factorize(tril(A)) == tril(A)
+    @test isa(factorize(tril(A)), LowerTriangular{Float64, SparseMatrixCSC{Float64, Int}})
+    @test factorize(A[:,1:4])\ones(size(A,1)) ≈ full(A[:,1:4])\ones(size(A,1))
+    @test_throws ErrorException chol(A)
+    @test_throws ErrorException lu(A)
+    @test_throws ErrorException eig(A)
+    @test_throws ErrorException inv(A)
+end
+
+let
+    n = 100
+    A = sprandn(n, n, 0.5) + sqrt(n)*I
+    x = LowerTriangular(A)*ones(n)
+    @test LowerTriangular(A)\x ≈ ones(n)
+    x = UpperTriangular(A)*ones(n)
+    @test UpperTriangular(A)\x ≈ ones(n)
+    A[2,2] = 0
+    @test_throws LinAlg.SingularException LowerTriangular(A)\ones(n)
+    @test_throws LinAlg.SingularException UpperTriangular(A)\ones(n)
+end
+
+# https://groups.google.com/forum/#!topic/julia-dev/QT7qpIpgOaA
+@test sparse([1,1], [1,1], [true, true]) == sparse([1,1], [1,1], [true, true], 1, 1) == fill(true, 1, 1)
+@test sparsevec([1,1], [true, true]) == sparsevec([1,1], [true, true], 1) == fill(true, 1)
+
+# issparse for specialized matrix types
+let
+    m = sprand(10, 10, 0.1)
+    @test issparse(Symmetric(m))
+    @test issparse(Hermitian(m))
+    @test issparse(LowerTriangular(m))
+    @test issparse(LinAlg.UnitLowerTriangular(m))
+    @test issparse(UpperTriangular(m))
+    @test issparse(LinAlg.UnitUpperTriangular(m))
+    @test issparse(Symmetric(full(m))) == false
+    @test issparse(Hermitian(full(m))) == false
+    @test issparse(LowerTriangular(full(m))) == false
+    @test issparse(LinAlg.UnitLowerTriangular(full(m))) == false
+    @test issparse(UpperTriangular(full(m))) == false
+    @test issparse(LinAlg.UnitUpperTriangular(full(m))) == false
+end
diff --git a/test/sparsedir/sparsevector.jl b/test/sparsedir/sparsevector.jl
new file mode 100644
index 0000000000000..f43aaab188aa8
--- /dev/null
+++ b/test/sparsedir/sparsevector.jl
@@ -0,0 +1,840 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+### Data
+
+spv_x1 = SparseVector(8, [2, 5, 6], [1.25, -0.75, 3.5])
+
+@test isa(spv_x1, SparseVector{Float64,Int})
+
+x1_full = zeros(length(spv_x1))
+x1_full[SparseArrays.nonzeroinds(spv_x1)] = nonzeros(spv_x1)
+
+### Basic Properties
+
+let x = spv_x1
+    @test eltype(x) == Float64
+    @test ndims(x) == 1
+    @test length(x) == 8
+    @test size(x) == (8,)
+    @test size(x,1) == 8
+    @test size(x,2) == 1
+    @test !isempty(x)
+
+    @test countnz(x) == 3
+    @test nnz(x) == 3
+    @test SparseArrays.nonzeroinds(x) == [2, 5, 6]
+    @test nonzeros(x) == [1.25, -0.75, 3.5]
+end
+
+# full
+
+for (x, xf) in [(spv_x1, x1_full)]
+    @test isa(full(x), Vector{Float64})
+    @test full(x) == xf
+end
+
+### Show
+
+@test contains(string(spv_x1), "1.25")
+@test contains(string(spv_x1), "-0.75")
+@test contains(string(spv_x1), "3.5")
+
+### Other Constructors
+
+### Comparison helper to ensure exact equality with internal structure
+function exact_equal(x::AbstractSparseVector, y::AbstractSparseVector)
+    eltype(x) == eltype(y) &&
+    eltype(SparseArrays.nonzeroinds(x)) == eltype(SparseArrays.nonzeroinds(y)) &&
+    length(x) == length(y) &&
+    SparseArrays.nonzeroinds(x) == SparseArrays.nonzeroinds(y) &&
+    nonzeros(x) == nonzeros(y)
+end
+
+# construct empty sparse vector
+
+@test exact_equal(spzeros(Float64, 8), SparseVector(8, Int[], Float64[]))
+
+# from list of indices and values
+
+@test exact_equal(
+    sparsevec(Int[], Float64[], 8),
+    SparseVector(8, Int[], Float64[]))
+
+@test exact_equal(
+    sparsevec(Int[], Float64[]),
+    SparseVector(0, Int[], Float64[]))
+
+@test exact_equal(
+    sparsevec([3, 3], [5.0, -5.0], 8),
+    spzeros(Float64, 8))
+
+@test exact_equal(
+    sparsevec([2, 3, 6], [12.0, 18.0, 25.0]),
+    SparseVector(6, [2, 3, 6], [12.0, 18.0, 25.0]))
+
+let x0 = SparseVector(8, [2, 3, 6], [12.0, 18.0, 25.0])
+    @test exact_equal(
+        sparsevec([2, 3, 6], [12.0, 18.0, 25.0], 8), x0)
+
+    @test exact_equal(
+        sparsevec([3, 6, 2], [18.0, 25.0, 12.0], 8), x0)
+
+    @test exact_equal(
+        sparsevec([2, 3, 4, 4, 6], [12.0, 18.0, 5.0, -5.0, 25.0], 8),
+        x0)
+
+    @test exact_equal(
+        sparsevec([1, 1, 1, 2, 3, 3, 6], [2.0, 3.0, -5.0, 12.0, 10.0, 8.0, 25.0], 8),
+        x0)
+
+    @test exact_equal(
+        sparsevec([2, 3, 6, 7, 7], [12.0, 18.0, 25.0, 5.0, -5.0], 8), x0)
+end
+
+# from dictionary
+
+function my_intmap(x)
+    a = Dict{Int,eltype(x)}()
+    for i in SparseArrays.nonzeroinds(x)
+        a[i] = x[i]
+    end
+    return a
+end
+
+let x = spv_x1
+    a = my_intmap(x)
+    xc = sparsevec(a, 8)
+    @test exact_equal(x, xc)
+
+    xc = sparsevec(a)
+    @test exact_equal(xc, SparseVector(6, [2, 5, 6], [1.25, -0.75, 3.5]))
+end
+
+# spones - copies structure, but replaces nzvals with ones
+let x = SparseVector(8, [2, 3, 6], [12.0, 18.0, 25.0])
+    y = spones(x)
+    @test (x .!= 0) == (y .!= 0)
+    @test y == SparseVector(8, [2, 3, 6], [1.0, 1.0, 1.0])
+end
+
+# sprand & sprandn
+
+let xr = sprand(1000, 0.9)
+    @test isa(xr, SparseVector{Float64,Int})
+    @test length(xr) == 1000
+    @test all(nonzeros(xr) .>= 0.0)
+end
+
+let xr = sprand(1000, 0.9, Float32)
+    @test isa(xr, SparseVector{Float32,Int})
+    @test length(xr) == 1000
+    @test all(nonzeros(xr) .>= 0.0)
+end
+
+let xr = sprandn(1000, 0.9)
+    @test isa(xr, SparseVector{Float64,Int})
+    @test length(xr) == 1000
+    if !isempty(nonzeros(xr))
+        @test any(nonzeros(xr) .> 0.0) && any(nonzeros(xr) .< 0.0)
+    end
+end
+
+let xr = sprandbool(1000, 0.9)
+    @test isa(xr, SparseVector{Bool,Int})
+    @test length(xr) == 1000
+    @test all(nonzeros(xr))
+end
+
+let r1 = MersenneTwister(), r2 = MersenneTwister()
+    @test sprand(r1, 100, .9) == sprand(r2, 100, .9)
+    @test sprandn(r1, 100, .9) == sprandn(r2, 100, .9)
+    @test sprandbool(r1, 100, .9) == sprandbool(r2, 100, .9)
+end
+
+### Element access
+
+# getindex
+
+# single integer index
+for (x, xf) in [(spv_x1, x1_full)]
+    for i = 1:length(x)
+        @test x[i] == xf[i]
+    end
+end
+
+# generic array index
+let x = sprand(100, 0.5)
+    I = rand(1:length(x), 20)
+    @which x[I]
+    r = x[I]
+    @test isa(r, SparseVector{Float64,Int})
+    @test all(nonzeros(r) .!= 0.0)
+    @test full(r) == full(x)[I]
+end
+
+# setindex
+
+let xc = spzeros(Float64, 8)
+    xc[3] = 2.0
+    @test exact_equal(xc, SparseVector(8, [3], [2.0]))
+end
+
+let xc = copy(spv_x1)
+    xc[5] = 2.0
+    @test exact_equal(xc, SparseVector(8, [2, 5, 6], [1.25, 2.0, 3.5]))
+end
+
+let xc = copy(spv_x1)
+    xc[3] = 4.0
+    @test exact_equal(xc, SparseVector(8, [2, 3, 5, 6], [1.25, 4.0, -0.75, 3.5]))
+
+    xc[1] = 6.0
+    @test exact_equal(xc, SparseVector(8, [1, 2, 3, 5, 6], [6.0, 1.25, 4.0, -0.75, 3.5]))
+
+    xc[8] = -1.5
+    @test exact_equal(xc, SparseVector(8, [1, 2, 3, 5, 6, 8], [6.0, 1.25, 4.0, -0.75, 3.5, -1.5]))
+end
+
+let xc = copy(spv_x1)
+    xc[5] = 0.0
+    @test exact_equal(xc, SparseVector(8, [2, 6], [1.25, 3.5]))
+
+    xc[6] = 0.0
+    @test exact_equal(xc, SparseVector(8, [2], [1.25]))
+
+    xc[2] = 0.0
+    @test exact_equal(xc, SparseVector(8, Int[], Float64[]))
+end
+
+
+### Array manipulation
+
+# copy
+
+let x = spv_x1
+    xc = copy(x)
+    @test isa(xc, SparseVector{Float64,Int})
+    @test !is(x.nzind, xc.nzval)
+    @test !is(x.nzval, xc.nzval)
+    @test exact_equal(x, xc)
+end
+
+let a = SparseVector(8, [2, 5, 6], Int32[12, 35, 72])
+    # vec
+    @test vec(a) == a
+
+    # reinterpret
+    au = reinterpret(UInt32, a)
+    @test isa(au, SparseVector{UInt32,Int})
+    @test exact_equal(au, SparseVector(8, [2, 5, 6], UInt32[12, 35, 72]))
+
+    # float
+    af = float(a)
+    @test float(af) == af
+    @test isa(af, SparseVector{Float64,Int})
+    @test exact_equal(af, SparseVector(8, [2, 5, 6], [12., 35., 72.]))
+    @test sparsevec(transpose(transpose(af))) == af
+
+    # complex
+    acp = complex(af)
+    @test complex(acp) == acp
+    @test isa(acp, SparseVector{Complex128,Int})
+    @test exact_equal(acp, SparseVector(8, [2, 5, 6], complex([12., 35., 72.])))
+    @test sparsevec(ctranspose(ctranspose(acp))) == acp
+end
+
+### Type conversion
+
+let x = convert(SparseVector, sparse([2, 5, 6], [1, 1, 1], [1.25, -0.75, 3.5], 8, 1))
+    @test isa(x, SparseVector{Float64,Int})
+    @test exact_equal(x, spv_x1)
+end
+
+let x = spv_x1, xf = x1_full
+    xc = convert(SparseVector, xf)
+    @test isa(xc, SparseVector{Float64,Int})
+    @test exact_equal(xc, x)
+
+    xc = convert(SparseVector{Float32,Int}, x)
+    xf32 = SparseVector(8, [2, 5, 6], [1.25f0, -0.75f0, 3.5f0])
+    @test isa(xc, SparseVector{Float32,Int})
+    @test exact_equal(xc, xf32)
+
+    xc = convert(SparseVector{Float32}, x)
+    @test isa(xc, SparseVector{Float32,Int})
+    @test exact_equal(xc, xf32)
+
+    xm = convert(SparseMatrixCSC, x)
+    @test isa(xm, SparseMatrixCSC{Float64,Int})
+    @test full(xm) == reshape(xf, 8, 1)
+
+    xm = convert(SparseMatrixCSC{Float32}, x)
+    @test isa(xm, SparseMatrixCSC{Float32,Int})
+    @test full(xm) == reshape(convert(Vector{Float32}, xf), 8, 1)
+end
+
+
+### Concatenation
+
+let m = 80, n = 100
+    A = Array(SparseVector{Float64,Int}, n)
+    tnnz = 0
+    for i = 1:length(A)
+        A[i] = sprand(m, 0.3)
+        tnnz += nnz(A[i])
+    end
+
+    H = hcat(A...)
+    @test isa(H, SparseMatrixCSC{Float64,Int})
+    @test size(H) == (m, n)
+    @test nnz(H) == tnnz
+    Hr = zeros(m, n)
+    for j = 1:n
+        Hr[:,j] = full(A[j])
+    end
+    @test full(H) == Hr
+
+    V = vcat(A...)
+    @test isa(V, SparseVector{Float64,Int})
+    @test length(V) == m * n
+    Vr = vec(Hr)
+    @test full(V) == Vr
+end
+
+
+## sparsemat: combinations with sparse matrix
+
+let S = sprand(4, 8, 0.5)
+    Sf = full(S)
+    @assert isa(Sf, Matrix{Float64})
+
+    # get a single column
+    for j = 1:size(S,2)
+        col = S[:, j]
+        @test isa(col, SparseVector{Float64,Int})
+        @test length(col) == size(S,1)
+        @test full(col) == Sf[:,j]
+    end
+
+    # Get a reshaped vector
+    v = S[:]
+    @test isa(v, SparseVector{Float64,Int})
+    @test length(v) == length(S)
+    @test full(v) == Sf[:]
+
+    # Get a linear subset
+    for i=0:length(S)
+        v = S[1:i]
+        @test isa(v, SparseVector{Float64,Int})
+        @test length(v) == i
+        @test full(v) == Sf[1:i]
+    end
+    for i=1:length(S)+1
+        v = S[i:end]
+        @test isa(v, SparseVector{Float64,Int})
+        @test length(v) == length(S) - i + 1
+        @test full(v) == Sf[i:end]
+    end
+    for i=0:div(length(S),2)
+        v = S[1+i:end-i]
+        @test isa(v, SparseVector{Float64,Int})
+        @test length(v) == length(S) - 2i
+        @test full(v) == Sf[1+i:end-i]
+    end
+end
+
+let r = [1,10], S = sparse(r, r, r)
+    Sf = full(S)
+    @assert isa(Sf, Matrix{Int})
+
+    inds = [1,1,1,1,1,1]
+    v = S[inds]
+    @test isa(v, SparseVector{Int,Int})
+    @test length(v) == length(inds)
+    @test full(v) == Sf[inds]
+
+    inds = [2,2,2,2,2,2]
+    v = S[inds]
+    @test isa(v, SparseVector{Int,Int})
+    @test length(v) == length(inds)
+    @test full(v) == Sf[inds]
+
+    # get a single column
+    for j = 1:size(S,2)
+        col = S[:, j]
+        @test isa(col, SparseVector{Int,Int})
+        @test length(col) == size(S,1)
+        @test full(col) == Sf[:,j]
+    end
+
+    # Get a reshaped vector
+    v = S[:]
+    @test isa(v, SparseVector{Int,Int})
+    @test length(v) == length(S)
+    @test full(v) == Sf[:]
+
+    # Get a linear subset
+    for i=0:length(S)
+        v = S[1:i]
+        @test isa(v, SparseVector{Int,Int})
+        @test length(v) == i
+        @test full(v) == Sf[1:i]
+    end
+    for i=1:length(S)+1
+        v = S[i:end]
+        @test isa(v, SparseVector{Int,Int})
+        @test length(v) == length(S) - i + 1
+        @test full(v) == Sf[i:end]
+    end
+    for i=0:div(length(S),2)
+        v = S[1+i:end-i]
+        @test isa(v, SparseVector{Int,Int})
+        @test length(v) == length(S) - 2i
+        @test full(v) == Sf[1+i:end-i]
+    end
+end
+
+## math
+
+### Data
+
+rnd_x0 = sprand(50, 0.6)
+rnd_x0f = full(rnd_x0)
+
+rnd_x1 = sprand(50, 0.7) * 4.0
+rnd_x1f = full(rnd_x1)
+
+spv_x1 = SparseVector(8, [2, 5, 6], [1.25, -0.75, 3.5])
+spv_x2 = SparseVector(8, [1, 2, 6, 7], [3.25, 4.0, -5.5, -6.0])
+
+### Arithmetic operations
+
+let x = spv_x1, x2 = x2 = spv_x2
+    # negate
+    @test exact_equal(-x, SparseVector(8, [2, 5, 6], [-1.25, 0.75, -3.5]))
+
+    # abs and abs2
+    @test exact_equal(abs(x), SparseVector(8, [2, 5, 6], abs([1.25, -0.75, 3.5])))
+    @test exact_equal(abs2(x), SparseVector(8, [2, 5, 6], abs2([1.25, -0.75, 3.5])))
+
+    # plus and minus
+    xa = SparseVector(8, [1,2,5,6,7], [3.25,5.25,-0.75,-2.0,-6.0])
+
+    @test exact_equal(x + x, x * 2)
+    @test exact_equal(x + x2, xa)
+    @test exact_equal(x2 + x, xa)
+
+    xb = SparseVector(8, [1,2,5,6,7], [-3.25,-2.75,-0.75,9.0,6.0])
+    @test exact_equal(x - x, SparseVector(8, Int[], Float64[]))
+    @test exact_equal(x - x2, xb)
+    @test exact_equal(x2 - x, -xb)
+
+    @test full(x) + x2 == full(xa)
+    @test full(x) - x2 == full(xb)
+    @test x + full(x2) == full(xa)
+    @test x - full(x2) == full(xb)
+
+    # multiplies
+    xm = SparseVector(8, [2, 6], [5.0, -19.25])
+    @test exact_equal(x .* x, abs2(x))
+    @test exact_equal(x .* x2, xm)
+    @test exact_equal(x2 .* x, xm)
+
+    @test full(x) .* x2 == full(xm)
+    @test x .* full(x2) == full(xm)
+
+    # max & min
+    @test exact_equal(max(x, x), x)
+    @test exact_equal(min(x, x), x)
+    @test exact_equal(max(x, x2),
+        SparseVector(8, Int[1, 2, 6], Float64[3.25, 4.0, 3.5]))
+    @test exact_equal(min(x, x2),
+        SparseVector(8, Int[2, 5, 6, 7], Float64[1.25, -0.75, -5.5, -6.0]))
+end
+
+### Complex
+
+let x = spv_x1, x2 = spv_x2
+    # complex
+    @test exact_equal(complex(x, x),
+        SparseVector(8, [2,5,6], [1.25+1.25im, -0.75-0.75im, 3.5+3.5im]))
+    @test exact_equal(complex(x, x2),
+        SparseVector(8, [1,2,5,6,7], [3.25im, 1.25+4.0im, -0.75+0.im, 3.5-5.5im, -6.0im]))
+    @test exact_equal(complex(x2, x),
+        SparseVector(8, [1,2,5,6,7], [3.25+0.im, 4.0+1.25im, -0.75im, -5.5+3.5im, -6.0+0.im]))
+
+    # real & imag
+
+    @test is(real(x), x)
+    @test exact_equal(imag(x), spzeros(Float64, length(x)))
+
+    xcp = complex(x, x2)
+    @test exact_equal(real(xcp), x)
+    @test exact_equal(imag(xcp), x2)
+end
+
+### Zero-preserving math functions: sparse -> sparse
+
+function check_nz2z_z2z{T}(f::Function, x::SparseVector{T}, xf::Vector{T})
+    R = typeof(f(zero(T)))
+    r = f(x)
+    isa(r, AbstractSparseVector) || error("$f(x) is not a sparse vector.")
+    eltype(r) == R || error("$f(x) results in eltype = $(eltype(r)), expect $R")
+    all(r.nzval .!= 0) || error("$f(x) contains zeros in nzval.")
+    full(r) == f(xf) || error("Incorrect results found in $f(x).")
+end
+
+for f in [floor, ceil, trunc, round]
+    check_nz2z_z2z(f, rnd_x1, rnd_x1f)
+end
+
+for f in [log1p, expm1,
+          sin, tan, sinpi, sind, tand,
+          asin, atan, asind, atand,
+          sinh, tanh, asinh, atanh]
+    check_nz2z_z2z(f, rnd_x0, rnd_x0f)
+end
+
+### Non-zero-preserving math functions: sparse -> dense
+
+function check_z2nz{T}(f::Function, x::SparseVector{T}, xf::Vector{T})
+    R = typeof(f(zero(T)))
+    r = f(x)
+    isa(r, Vector) || error("$f(x) is not a dense vector.")
+    eltype(r) == R || error("$f(x) results in eltype = $(eltype(r)), expect $R")
+    r == f(xf) || error("Incorrect results found in $f(x).")
+end
+
+for f in [exp, exp2, exp10, log, log2, log10,
+          cos, csc, cot, sec, cospi,
+          cosd, cscd, cotd, secd,
+          acos, acot, acosd, acotd,
+          cosh, csch, coth, sech, acsch, asech]
+    check_z2nz(f, rnd_x0, rnd_x0f)
+end
+
+
+### Reduction
+
+# sum, sumabs, sumabs2, vecnorm
+
+let x = spv_x1
+    @test sum(x) == 4.0
+    @test sumabs(x) == 5.5
+    @test sumabs2(x) == 14.375
+
+    @test vecnorm(x) == sqrt(14.375)
+    @test vecnorm(x, 1) == 5.5
+    @test vecnorm(x, 2) == sqrt(14.375)
+    @test vecnorm(x, Inf) == 3.5
+end
+
+# maximum, minimum, maxabs, minabs
+
+let x = spv_x1
+    @test maximum(x) == 3.5
+    @test minimum(x) == -0.75
+    @test maxabs(x) == 3.5
+    @test minabs(x) == 0.0
+end
+
+let x = abs(spv_x1)
+    @test maximum(x) == 3.5
+    @test minimum(x) == 0.0
+end
+
+let x = -abs(spv_x1)
+    @test maximum(x) == 0.0
+    @test minimum(x) == -3.5
+end
+
+let x = SparseVector(3, [1, 2, 3], [-4.5, 2.5, 3.5])
+    @test maximum(x) == 3.5
+    @test minimum(x) == -4.5
+    @test maxabs(x) == 4.5
+    @test minabs(x) == 2.5
+end
+
+let x = spzeros(Float64, 8)
+    @test maximum(x) == 0.0
+    @test minimum(x) == 0.0
+    @test maxabs(x) == 0.0
+    @test minabs(x) == 0.0
+end
+
+
+### linalg
+
+### BLAS Level-1
+
+let x = sprand(16, 0.5), x2 = sprand(16, 0.4)
+    xf = full(x)
+    xf2 = full(x2)
+
+    # axpy!
+    for c in [1.0, -1.0, 2.0, -2.0]
+        y = full(x)
+        @test is(Base.axpy!(c, x2, y), y)
+        @test y == full(x2 * c + x)
+    end
+
+    # scale
+    let sx = SparseVector(x.n, x.nzind, x.nzval * 2.5)
+        @test exact_equal(x * 2.5, sx)
+        @test exact_equal(x * (2.5 + 0.0*im), complex(sx))
+        @test exact_equal(2.5 * x, sx)
+        @test exact_equal((2.5 + 0.0*im) * x, complex(sx))
+        @test exact_equal(x * 2.5, sx)
+        @test exact_equal(2.5 * x, sx)
+        @test exact_equal(x .* 2.5, sx)
+        @test exact_equal(2.5 .* x, sx)
+
+        xc = copy(x)
+        @test is(scale!(xc, 2.5), xc)
+        @test exact_equal(xc, sx)
+    end
+
+    # dot
+    let dv = dot(xf, xf2)
+        @test dot(x, x) == sumabs2(x)
+        @test dot(x2, x2) == sumabs2(x2)
+        @test_approx_eq dot(x, x2) dv
+        @test_approx_eq dot(x2, x) dv
+        @test_approx_eq dot(full(x), x2) dv
+        @test_approx_eq dot(x, full(x2)) dv
+    end
+end
+
+let x = complex(sprand(32, 0.6), sprand(32, 0.6)),
+    y = complex(sprand(32, 0.6), sprand(32, 0.6))
+    xf = full(x)::Vector{Complex128}
+    yf = full(y)::Vector{Complex128}
+    @test_approx_eq dot(x, x) dot(xf, xf)
+    @test_approx_eq dot(x, y) dot(xf, yf)
+end
+
+
+
+### BLAS Level-2:
+
+## dense A * sparse x -> dense y
+
+let A = randn(9, 16), x = sprand(16, 0.7)
+    xf = full(x)
+    for α in [0.0, 1.0, 2.0], β in [0.0, 0.5, 1.0]
+        y = rand(9)
+        rr = α * A * xf + β * y
+        @test is(A_mul_B!(α, A, x, β, y), y)
+        @test_approx_eq y rr
+    end
+    y = A * x
+    @test isa(y, Vector{Float64})
+    @test_approx_eq A * x A * xf
+end
+
+let A = randn(16, 9), x = sprand(16, 0.7)
+    xf = full(x)
+    for α in [0.0, 1.0, 2.0], β in [0.0, 0.5, 1.0]
+        y = rand(9)
+        rr = α * A'xf + β * y
+        @test is(At_mul_B!(α, A, x, β, y), y)
+        @test_approx_eq y rr
+    end
+    y = At_mul_B(A, x)
+    @test isa(y, Vector{Float64})
+    @test_approx_eq y At_mul_B(A, xf)
+end
+
+## sparse A * sparse x -> dense y
+
+let A = sprandn(9, 16, 0.5), x = sprand(16, 0.7)
+    Af = full(A)
+    xf = full(x)
+    for α in [0.0, 1.0, 2.0], β in [0.0, 0.5, 1.0]
+        y = rand(9)
+        rr = α * Af * xf + β * y
+        @test is(A_mul_B!(α, A, x, β, y), y)
+        @test_approx_eq y rr
+    end
+    y = SparseArrays.densemv(A, x)
+    @test isa(y, Vector{Float64})
+    @test_approx_eq y Af * xf
+end
+
+let A = sprandn(16, 9, 0.5), x = sprand(16, 0.7)
+    Af = full(A)
+    xf = full(x)
+    for α in [0.0, 1.0, 2.0], β in [0.0, 0.5, 1.0]
+        y = rand(9)
+        rr = α * Af'xf + β * y
+        @test is(At_mul_B!(α, A, x, β, y), y)
+        @test_approx_eq y rr
+    end
+    y = SparseArrays.densemv(A, x; trans='T')
+    @test isa(y, Vector{Float64})
+    @test_approx_eq y At_mul_B(Af, xf)
+end
+
+let A = complex(sprandn(7, 8, 0.5), sprandn(7, 8, 0.5)),
+    x = complex(sprandn(8, 0.6), sprandn(8, 0.6)),
+    x2 = complex(sprandn(7, 0.75), sprandn(7, 0.75))
+    Af = full(A)
+    xf = full(x)
+    x2f = full(x2)
+    @test_approx_eq SparseArrays.densemv(A, x; trans='N') Af * xf
+    @test_approx_eq SparseArrays.densemv(A, x2; trans='T') Af.' * x2f
+    @test_approx_eq SparseArrays.densemv(A, x2; trans='C') Af'x2f
+end
+
+## sparse A * sparse x -> sparse y
+
+let A = sprandn(9, 16, 0.5), x = sprand(16, 0.7), x2 = sprand(9, 0.7)
+    Af = full(A)
+    xf = full(x)
+    x2f = full(x2)
+
+    y = A * x
+    @test isa(y, SparseVector{Float64,Int})
+    @test all(nonzeros(y) .!= 0.0)
+    @test_approx_eq full(y) Af * xf
+
+    y = At_mul_B(A, x2)
+    @test isa(y, SparseVector{Float64,Int})
+    @test all(nonzeros(y) .!= 0.0)
+    @test_approx_eq full(y) Af'x2f
+end
+
+let A = complex(sprandn(7, 8, 0.5), sprandn(7, 8, 0.5)),
+    x = complex(sprandn(8, 0.6), sprandn(8, 0.6)),
+    x2 = complex(sprandn(7, 0.75), sprandn(7, 0.75))
+    Af = full(A)
+    xf = full(x)
+    x2f = full(x2)
+
+    y = A * x
+    @test isa(y, SparseVector{Complex128,Int})
+    @test_approx_eq full(y) Af * xf
+
+    y = At_mul_B(A, x2)
+    @test isa(y, SparseVector{Complex128,Int})
+    @test_approx_eq full(y) Af.' * x2f
+
+    y = Ac_mul_B(A, x2)
+    @test isa(y, SparseVector{Complex128,Int})
+    @test_approx_eq full(y) Af'x2f
+end
+
+# left-division operations involving triangular matrices and sparse vectors (#14005)
+let m = 10
+    sparsefloatvecs = SparseVector[sprand(m, 0.4) for k in 1:3]
+    sparseintvecs = SparseVector[SparseVector(m, sprvec.nzind, round(Int, sprvec.nzval*10)) for sprvec in sparsefloatvecs]
+    sparsecomplexvecs = SparseVector[SparseVector(m, sprvec.nzind, complex(sprvec.nzval, sprvec.nzval)) for sprvec in sparsefloatvecs]
+
+    sprmat = sprand(m, m, 0.2)
+    sparsefloatmat = speye(m) + sprmat/(2m)
+    sparsecomplexmat = speye(m) + SparseMatrixCSC(m, m, sprmat.colptr, sprmat.rowval, complex(sprmat.nzval, sprmat.nzval)/(4m))
+    sparseintmat = speye(Int, m)*10m + SparseMatrixCSC(m, m, sprmat.colptr, sprmat.rowval, round(Int, sprmat.nzval*10))
+
+    denseintmat = eye(Int, m)*10m + rand(1:m, m, m)
+    densefloatmat = eye(m) + randn(m, m)/(2m)
+    densecomplexmat = eye(m) + complex(randn(m, m), randn(m, m))/(4m)
+
+    inttypes = (Int32, Int64, BigInt)
+    floattypes = (Float32, Float64, BigFloat)
+    complextypes = (Complex{Float32}, Complex{Float64})
+    eltypes = (inttypes..., floattypes..., complextypes...)
+
+    for eltypemat in eltypes
+        (densemat, sparsemat) = eltypemat in inttypes ? (denseintmat, sparseintmat) :
+                                eltypemat in floattypes ? (densefloatmat, sparsefloatmat) :
+                                eltypemat in complextypes && (densecomplexmat, sparsecomplexmat)
+        densemat = convert(Matrix{eltypemat}, densemat)
+        sparsemat = convert(SparseMatrixCSC{eltypemat}, sparsemat)
+        trimats = (LowerTriangular(densemat), UpperTriangular(densemat),
+                   LowerTriangular(sparsemat), UpperTriangular(sparsemat) )
+        unittrimats = (Base.LinAlg.UnitLowerTriangular(densemat), Base.LinAlg.UnitUpperTriangular(densemat),
+                       Base.LinAlg.UnitLowerTriangular(sparsemat), Base.LinAlg.UnitUpperTriangular(sparsemat) )
+
+        for eltypevec in eltypes
+            spvecs = eltypevec in inttypes ? sparseintvecs :
+                     eltypevec in floattypes ? sparsefloatvecs :
+                     eltypevec in complextypes && sparsecomplexvecs
+            spvecs = SparseVector[SparseVector(m, spvec.nzind, convert(Vector{eltypevec}, spvec.nzval)) for spvec in spvecs]
+
+            for spvec in spvecs
+                fspvec = convert(Array, spvec)
+                # test out-of-place left-division methods
+                for mat in (trimats..., unittrimats...), func in (\, At_ldiv_B, Ac_ldiv_B)
+                    @test isapprox((func)(mat, spvec), (func)(mat, fspvec))
+                end
+                # test in-place left-division methods not involving quotients
+                if eltypevec == typeof(zero(eltypemat)*zero(eltypevec) + zero(eltypemat)*zero(eltypevec))
+                    for mat in unittrimats, func in (A_ldiv_B!, Base.LinAlg.At_ldiv_B!, Base.LinAlg.Ac_ldiv_B!)
+                        @test isapprox((func)(mat, copy(spvec)), (func)(mat, copy(fspvec)))
+                    end
+                end
+                # test in-place left-division methods involving quotients
+                if eltypevec == typeof((zero(eltypemat)*zero(eltypevec) + zero(eltypemat)*zero(eltypevec))/one(eltypemat))
+                    for mat in trimats, func in (A_ldiv_B!, Base.LinAlg.At_ldiv_B!, Base.LinAlg.Ac_ldiv_B!)
+                        @test isapprox((func)(mat, copy(spvec)), (func)(mat, copy(fspvec)))
+                    end
+                end
+            end
+        end
+    end
+end
+
+# It's tempting to share data between a SparseVector and a SparseArrays,
+# but if that's done, then modifications to one or the other will cause
+# an inconsistent state:
+sv = sparse(1:10)
+sm = convert(SparseMatrixCSC, sv)
+sv[1] = 0
+@test full(sm)[2:end] == collect(2:10)
+
+# Ensure that sparsevec with all-zero values returns an array of zeros
+@test sparsevec([1,2,3],[0,0,0]) == [0,0,0]
+
+# Compare stored zero semantics between SparseVector and SparseMatrixCSC
+let S = SparseMatrixCSC(10,1,[1,6],[1,3,5,6,7],[0,1,2,0,3]), x = SparseVector(10,[1,3,5,6,7],[0,1,2,0,3])
+    @test nnz(S) == nnz(x) == 5
+    for I = (:, 1:10, collect(1:10))
+        @test S[I,1] == S[I] == x[I] == x
+        @test nnz(S[I,1]) == nnz(S[I]) == nnz(x[I]) == nnz(x)
+    end
+    for I = (2:9, 1:2, 9:10, [3,6,1], [10,9,8], [])
+        @test S[I,1] == S[I] == x[I]
+        @test nnz(S[I,1]) == nnz(S[I]) == nnz(x[I])
+    end
+    @test S[[1 3 5; 2 4 6]] == x[[1 3 5; 2 4 6]]
+    @test nnz(S[[1 3 5; 2 4 6]]) == nnz(x[[1 3 5; 2 4 6]])
+end
+
+
+# Issue 14013
+s14013 = sparse([10.0 0.0 30.0; 0.0 1.0 0.0])
+a14013 = [10.0 0.0 30.0; 0.0 1.0 0.0]
+@test s14013 == a14013
+@test vec(s14013) == s14013[:] == a14013[:]
+@test full(s14013)[1,:] == s14013[1,:] == a14013[1,:] == [10.0, 0.0, 30.0]
+@test full(s14013)[2,:] == s14013[2,:] == a14013[2,:] == [0.0, 1.0, 0.0]
+
+# Issue 14046
+s14046 = sprand(5, 1.0)
+@test spzeros(5) + s14046 == s14046
+@test 2*s14046 == s14046 + s14046
+
+# Issue 14589
+#test vectors with no zero elements
+x = sparsevec(1:7, [3., 2., -1., 1., -2., -3., 3.], 7)
+@test collect(sort(x)) == sort(collect(x))
+#test vectors with all zero elements
+x = sparsevec(Int64[], Float64[], 7)
+@test collect(sort(x)) == sort(collect(x))
+#test vector with sparsity approx 1/2
+x = sparsevec(1:7, [3., 2., -1., 1., -2., -3., 3.], 15)
+@test collect(sort(x)) == sort(collect(x))
+# apply three distinct tranformations where zeros sort into start/middle/end
+@test collect(sort(x, by=abs)) == sort(collect(x), by=abs)
+@test collect(sort(x, by=sign)) == sort(collect(x), by=sign)
+@test collect(sort(x, by=inv)) == sort(collect(x), by=inv)
diff --git a/test/sparsedir/spqr.jl b/test/sparsedir/spqr.jl
index 3b9c0f9d1782a..e42d74ea75972 100644
--- a/test/sparsedir/spqr.jl
+++ b/test/sparsedir/spqr.jl
@@ -2,9 +2,10 @@
 
 using Base.Test
 
-using Base.SparseMatrix.SPQR
-using Base.SparseMatrix.CHOLMOD
+using Base.SparseArrays.SPQR
+using Base.SparseArrays.CHOLMOD
 
+let
 m, n = 100, 10
 nn = 100
 
@@ -50,3 +51,12 @@ for eltyA in (Float64, Complex{Float64})
         end
     end
 end
+
+# Issue 14134
+F = qrfact(sprandn(10,5,0.5))
+b = IOBuffer()
+serialize(b, F)
+seekstart(b)
+@test_throws ArgumentError deserialize(b)\ones(10)
+
+end
diff --git a/test/sparsedir/umfpack.jl b/test/sparsedir/umfpack.jl
index 2a7e708eca2e5..deb69dc75d157 100644
--- a/test/sparsedir/umfpack.jl
+++ b/test/sparsedir/umfpack.jl
@@ -1,4 +1,5 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
+using Base.Test
 
 se33 = speye(3)
 do33 = ones(3)
@@ -6,19 +7,19 @@ do33 = ones(3)
 
 # based on deps/Suitesparse-4.0.2/UMFPACK/Demo/umfpack_di_demo.c
 
-using Base.SparseMatrix.UMFPACK.increment!
+using Base.SparseArrays.UMFPACK.increment!
 
 A0 = sparse(increment!([0,4,1,1,2,2,0,1,2,3,4,4]),
            increment!([0,4,0,2,1,2,1,4,3,2,1,2]),
            [2.,1.,3.,4.,-1.,-3.,3.,6.,2.,1.,4.,2.], 5, 5)
 
 for Tv in (Float64, Complex128)
-    for Ti in Base.SparseMatrix.UMFPACK.UMFITypes.types
+    for Ti in Base.SparseArrays.UMFPACK.UMFITypes.types
         A = convert(SparseMatrixCSC{Tv,Ti}, A0)
         lua = lufact(A)
         @test nnz(lua) == 18
         L,U,p,q,Rs = lua[:(:)]
-        @test_approx_eq scale(Rs,A)[p,q] L*U
+        @test_approx_eq (Diagonal(Rs) * A)[p,q] L * U
 
         @test_approx_eq det(lua) det(full(A))
 
@@ -40,11 +41,11 @@ for Tv in (Float64, Complex128)
 end
 
 Ac0 = complex(A0,A0)
-for Ti in Base.SparseMatrix.UMFPACK.UMFITypes.types
+for Ti in Base.SparseArrays.UMFPACK.UMFITypes.types
     Ac = convert(SparseMatrixCSC{Complex128,Ti}, Ac0)
     lua = lufact(Ac)
     L,U,p,q,Rs = lua[:(:)]
-    @test_approx_eq scale(Rs,Ac)[p,q] L*U
+    @test_approx_eq (Diagonal(Rs) * Ac)[p,q] L * U
 end
 
 for elty in (Float64, Complex128)
@@ -52,10 +53,48 @@ for elty in (Float64, Complex128)
         A = sparse([1:min(m,n); rand(1:m, 10)], [1:min(m,n); rand(1:n, 10)], elty == Float64 ? randn(min(m, n) + 10) : complex(randn(min(m, n) + 10), randn(min(m, n) + 10)))
         F = lufact(A)
         L, U, p, q, Rs = F[:(:)]
-        @test_approx_eq scale(Rs,A)[p,q] L*U
+        @test_approx_eq (Diagonal(Rs) * A)[p,q] L * U
     end
 end
 
 #4523 - complex sparse \
 x = speye(2) + im * speye(2)
 @test_approx_eq (x*(lufact(x) \ ones(2))) ones(2)
+
+@test det(sparse([1,3,3,1], [1,1,3,3], [1,1,1,1])) == 0
+
+# UMFPACK_ERROR_n_nonpositive
+@test_throws ArgumentError lufact(sparse(Int[], Int[], Float64[], 5, 0))
+
+#15099
+for (Tin, Tout) in (
+	(Complex32, Complex128),
+	(Complex64, Complex128),
+	(Complex128, Complex128),
+	(Float16, Float64),
+	(Float32, Float64),
+	(Float64, Float64),
+	(Int, Float64),
+    )
+
+    F = lufact(sparse(ones(Tin, 1, 1)))
+    L = sparse(ones(Tout, 1, 1))
+    @test F[:p] == F[:q] == [1]
+    @test F[:Rs] == [1.0]
+    @test F[:L] == F[:U] == L
+    @test F[:(:)] == (L, L, [1], [1], [1.0])
+end
+
+for T in (BigFloat, Complex{BigFloat})
+    @test_throws ArgumentError lufact(sparse(ones(T, 1, 1)))
+end
+
+#size(::UmfpackLU)
+let
+    m = n = 1
+    F = lufact(sparse(ones(m, n)))
+    @test size(F) == (m, n)
+    @test size(F, 1) == m
+    @test size(F, 2) == n
+    @test size(F, 3) == 1
+end
diff --git a/test/spawn.jl b/test/spawn.jl
index 1856df40147d1..86d7ba719709c 100644
--- a/test/spawn.jl
+++ b/test/spawn.jl
@@ -11,6 +11,8 @@
 #TODO:
 # - Windows:
 #   - Add a test whether coreutils are available and skip tests if not
+@windows_only oldpath = ENV["PATH"]
+@windows_only ENV["PATH"] = joinpath(JULIA_HOME,"..","Git","usr","bin")*";"*oldpath
 
 valgrind_off = ccall(:jl_running_on_valgrind,Cint,()) == 0
 
@@ -18,14 +20,14 @@ yes = `perl -le 'while (1) {print STDOUT "y"}'`
 
 #### Examples used in the manual ####
 
-@test readall(`echo hello | sort`) == "hello | sort\n"
-@test readall(pipeline(`echo hello`, `sort`)) == "hello\n"
+@test readstring(`echo hello | sort`) == "hello | sort\n"
+@test readstring(pipeline(`echo hello`, `sort`)) == "hello\n"
 @test length(spawn(pipeline(`echo hello`, `sort`)).processes) == 2
 
-out = readall(`echo hello` & `echo world`)
-@test search(out,"world") != (0,0)
-@test search(out,"hello") != (0,0)
-@test readall(pipeline(`echo hello` & `echo world`, `sort`)) == "hello\nworld\n"
+out = readstring(`echo hello` & `echo world`)
+@test search(out,"world") != 0:-1
+@test search(out,"hello") != 0:-1
+@test readstring(pipeline(`echo hello` & `echo world`, `sort`)) == "hello\nworld\n"
 
 @test (run(`printf "       \033[34m[stdio passthrough ok]\033[0m\n"`); true)
 
@@ -73,8 +75,8 @@ end
 # STDIN Redirection
 file = tempname()
 run(pipeline(`echo hello world`, file))
-@test readall(pipeline(file, `cat`)) == "hello world\n"
-@test open(readall, pipeline(file, `cat`), "r") == "hello world\n"
+@test readstring(pipeline(file, `cat`)) == "hello world\n"
+@test open(readstring, pipeline(file, `cat`), "r") == "hello world\n"
 rm(file)
 
 # Stream Redirection
@@ -84,7 +86,7 @@ rm(file)
         port, server = listenany(2326)
         put!(r,port)
         client = accept(server)
-        @test readall(pipeline(client, `cat`)) == "hello world\n"
+        @test readstring(pipeline(client, `cat`)) == "hello world\n"
         close(server)
     end
     @async begin
@@ -94,11 +96,11 @@ rm(file)
     end
 end
 
-@test readall(setenv(`sh -c "echo \$TEST"`,["TEST=Hello World"])) == "Hello World\n"
-@test readall(setenv(`sh -c "echo \$TEST"`,Dict("TEST"=>"Hello World"))) == "Hello World\n"
-@test readall(setenv(`sh -c "echo \$TEST"`,"TEST"=>"Hello World")) == "Hello World\n"
+@test readstring(setenv(`sh -c "echo \$TEST"`,["TEST=Hello World"])) == "Hello World\n"
+@test readstring(setenv(`sh -c "echo \$TEST"`,Dict("TEST"=>"Hello World"))) == "Hello World\n"
+@test readstring(setenv(`sh -c "echo \$TEST"`,"TEST"=>"Hello World")) == "Hello World\n"
 @test (withenv("TEST"=>"Hello World") do
-       readall(`sh -c "echo \$TEST"`); end) == "Hello World\n"
+       readstring(`sh -c "echo \$TEST"`); end) == "Hello World\n"
 pathA = readchomp(setenv(`sh -c "pwd -P"`;dir=".."))
 pathB = readchomp(setenv(`sh -c "cd .. && pwd -P"`))
 @unix_only @test Base.samefile(pathA, pathB)
@@ -113,7 +115,7 @@ end
 stdout, stdin, proc = readandwrite(`cat -`)
 write(stdin, str)
 close(stdin)
-str2 = readall(stdout)
+str2 = readstring(stdout)
 @test str2 == str
 
 # This test hangs if the end of run walk across uv streams calls shutdown on a stream that is shutting down.
@@ -173,16 +175,16 @@ exename = Base.julia_cmd()
 if valgrind_off
     # If --trace-children=yes is passed to valgrind, we will get a
     # valgrind banner here, not "Hello World\n".
-    @test readall(pipeline(`$exename -f -e 'println(STDERR,"Hello World")'`, stderr=`cat`)) == "Hello World\n"
+    @test readstring(pipeline(`$exename -f -e 'println(STDERR,"Hello World")'`, stderr=`cat`)) == "Hello World\n"
     out = Pipe()
     proc = spawn(pipeline(`$exename -f -e 'println(STDERR,"Hello World")'`, stderr = out))
     close(out.in)
-    @test readall(out) == "Hello World\n"
+    @test readstring(out) == "Hello World\n"
     @test success(proc)
 end
 
 # issue #6310
-@test readall(pipeline(`echo "2+2"`, `$exename -f`)) == "4\n"
+@test readstring(pipeline(`echo "2+2"`, `$exename -f`)) == "4\n"
 
 # issue #5904
 @test run(pipeline(ignorestatus(`false`), `true`)) === nothing
@@ -203,7 +205,7 @@ redirect_stdout(f)
 println("Hello World")
 redirect_stdout(OLD_STDOUT)
 close(f)
-@test "Hello World\n" == readall(fname)
+@test "Hello World\n" == readstring(fname)
 @test is(OLD_STDOUT,STDOUT)
 rm(fname)
 
@@ -231,12 +233,12 @@ sleep(1)
 import Base.zzzInvalidIdentifier
 """
 try
-    (in,p) = open(`$exename -f`, "w")
+    (in,p) = open(pipeline(`$exename -f`, stderr=STDERR), "w")
     write(in,cmd)
     close(in)
     wait(p)
 catch
-    error("IOStream redirect failed. Child stderr was \n$(readall(fname))\n")
+    error("IOStream redirect failed. Child stderr was \n$(readstring(fname))\n")
 end
 rm(fname)
 
@@ -249,20 +251,54 @@ let bad = "bad\0name"
 end
 
 # issue #12829
-let out = Pipe()
+let out = Pipe(), echo = `$exename -f -e 'print(STDOUT, " 1\t", readstring(STDIN))'`, ready = Condition()
     @test_throws ArgumentError write(out, "not open error")
-    open(`cat`, "w", out) do io
-        println(io, 1)
+    @async begin # spawn writer task
+        open(echo, "w", out) do in1
+            open(echo, "w", out) do in2
+                notify(ready)
+                write(in1, 'h')
+                write(in2, UInt8['w'])
+                println(in1, "ello")
+                write(in2, "orld\n")
+            end
+        end
+        show(out, out)
+        notify(ready)
+        @test isreadable(out)
+        @test iswritable(out)
+        close(out.in)
+        @test_throws ArgumentError write(out, "now closed error")
+        @test isreadable(out)
+        @test !iswritable(out)
+        @test isopen(out)
     end
-    close(out.in)
-    @test readline(out) == "1\n"
+    wait(ready) # wait for writer task to be ready before using `out`
+    @test nb_available(out) == 0
+    @test endswith(readuntil(out, '1'), '1')
+    @test read(out, UInt8) == '\t'
+    c = UInt8[0]
+    @test c == read!(out, c)
+    Base.wait_readnb(out, 1)
+    @test nb_available(out) > 0
+    ln1 = readline(out)
+    ln2 = readline(out)
+    desc = readstring(out)
+    @test !isreadable(out)
+    @test !iswritable(out)
+    @test !isopen(out)
+    @test nb_available(out) == 0
+    @test c == ['w']
+    @test lstrip(ln2) == "1\thello\n"
+    @test ln1 == "orld\n"
+    @test isempty(read(out))
+    @test eof(out)
+    @test desc == "Pipe(open => active, 0 bytes waiting)"
 end
 
 # issue #8529
 let fname = tempname()
-    open(fname, "w") do f
-        println(f, "test")
-    end
+    write(fname, "test\n")
     code = """
     for line in eachline(STDIN)
         run(pipeline(`echo asdf`,`cat`))
@@ -271,3 +307,50 @@ let fname = tempname()
     @test success(pipeline(`cat $fname`, `$exename -e $code`))
     rm(fname)
 end
+
+# Ensure that quoting works
+@test Base.shell_split("foo bar baz") == ["foo", "bar", "baz"]
+@test Base.shell_split("foo\\ bar baz") == ["foo bar", "baz"]
+@test Base.shell_split("'foo bar' baz") == ["foo bar", "baz"]
+@test Base.shell_split("\"foo bar\" baz") == ["foo bar", "baz"]
+
+# "Over quoted"
+@test Base.shell_split("'foo\\ bar' baz") == ["foo\\ bar", "baz"]
+@test Base.shell_split("\"foo\\ bar\" baz") == ["foo\\ bar", "baz"]
+
+# Ensure that shell_split handles quoted spaces
+let cmd = ["/Volumes/External HD/program", "-a"]
+    @test Base.shell_split("/Volumes/External\\ HD/program -a") == cmd
+    @test Base.shell_split("'/Volumes/External HD/program' -a") == cmd
+    @test Base.shell_split("\"/Volumes/External HD/program\" -a") == cmd
+end
+
+# Backticks should automatically quote where necessary
+let cmd = ["foo bar", "baz"]
+    @test string(`$cmd`) == "`'foo bar' baz`"
+end
+
+@test Base.shell_split("\"\\\\\"") == ["\\"]
+
+# issue #13616
+@test_throws ErrorException collect(eachline(pipeline(`cat _doesnt_exist__111_`, stderr=DevNull)))
+
+# make sure windows_verbatim strips quotes
+@windows_only readstring(`cmd.exe /c dir /b spawn.jl`) == readstring(Cmd(`cmd.exe /c dir /b "\"spawn.jl\""`, windows_verbatim=true))
+
+# make sure Cmd is nestable
+@test string(Cmd(Cmd(`ls`, detach=true))) == "`ls`"
+
+@windows_only ENV["PATH"] = oldpath
+
+# equality tests for Cmd
+
+@test Base.Cmd(``) == Base.Cmd(``)
+@test Base.Cmd(`lsof -i :9090`) == Base.Cmd(`lsof -i :9090`)
+@test Base.Cmd(`echo test`) == Base.Cmd(`echo test`)
+@test Base.Cmd(``) != Base.Cmd(`echo test`)
+@test Base.Cmd(``, ignorestatus=true) != Base.Cmd(``, ignorestatus=false)
+@test Base.Cmd(``, dir="TESTS") != Base.Cmd(``, dir="TEST")
+@test Base.Set([``, ``]) == Base.Set([``])
+@test Set([``, `echo`]) != Set([``, ``])
+@test Set([`echo`, ``, ``, `echo`]) == Set([`echo`, ``])
diff --git a/test/stacktraces.jl b/test/stacktraces.jl
new file mode 100644
index 0000000000000..c0ba1faaa3c18
--- /dev/null
+++ b/test/stacktraces.jl
@@ -0,0 +1,83 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+# Tests for /base/stacktraces.jl
+
+let
+    @noinline child() = stacktrace()
+    @noinline parent() = child()
+    @noinline grandparent() = parent()
+    line_numbers = @__LINE__ - [3, 2, 1]
+    stack = grandparent()
+
+    # Basic tests.
+    @assert length(stack) >= 3 "Compiler has unexpectedly inlined functions"
+    @test [:child, :parent, :grandparent] == [f.func for f in stack[1:3]]
+    for (line, frame) in zip(line_numbers, stack[1:3])
+        @test [Symbol(@__FILE__), line] in
+            ([frame.file, frame.line], [frame.inlined_file, frame.inlined_line])
+    end
+    @test [false, false, false] == [f.from_c for f in stack[1:3]]
+
+    # Test remove_frames!
+    stack = StackTraces.remove_frames!(grandparent(), :parent)
+    @test stack[1] == StackFrame(:grandparent, @__FILE__, line_numbers[3])
+
+    stack = StackTraces.remove_frames!(grandparent(), [:child, :something_nonexistent])
+    @test stack[1:2] == [
+        StackFrame(:parent, @__FILE__, line_numbers[2]),
+        StackFrame(:grandparent, @__FILE__, line_numbers[3])
+    ]
+
+    b = PipeBuffer()
+    frame = stack[1]
+    serialize(b, frame)
+    frame2 = deserialize(b)
+    @test frame !== frame2
+    @test frame == frame2
+    @test !isnull(frame.outer_linfo)
+    @test isnull(frame2.outer_linfo)
+end
+
+let
+    # Test from_c
+    default, with_c, without_c = stacktrace(), stacktrace(true), stacktrace(false)
+    @test default == without_c
+    @test length(with_c) > length(without_c)
+    @test !isempty(filter(frame -> frame.from_c, with_c))
+    @test isempty(filter(frame -> frame.from_c, without_c))
+end
+
+@test StackTraces.lookup(C_NULL) == StackTraces.UNKNOWN
+
+let ct = current_task()
+    # After a task switch, there should be nothing in catch_backtrace
+    yieldto(@task yieldto(ct))
+    @test catch_backtrace() == StackFrame[]
+
+    @noinline bad_function() = throw(UndefVarError(:nonexistent))
+    @noinline function try_stacktrace()
+        try
+            bad_function()
+        catch
+            i_need_a_line_number_julia_bug = true # julia lowering doesn't emit a proper line number for catch
+            return stacktrace()
+        end
+    end
+    @noinline function try_catch()
+        try
+            bad_function()
+        catch
+            return catch_stacktrace()
+        end
+    end
+    line_numbers = @__LINE__ .- [16, 10, 5]
+
+    # Test try...catch with stacktrace
+    @test try_stacktrace()[1] == StackFrame(:try_stacktrace, @__FILE__, line_numbers[2])
+
+    # Test try...catch with catch_stacktrace
+    @test try_catch()[1:2] == [
+        StackFrame(:bad_function, @__FILE__, line_numbers[1]),
+        StackFrame(:try_catch, @__FILE__, line_numbers[3])
+    ]
+end
diff --git a/test/staged.jl b/test/staged.jl
index 6e4269af0763f..7e099d3ef7474 100644
--- a/test/staged.jl
+++ b/test/staged.jl
@@ -151,3 +151,9 @@ module TestGeneratedThrow
         cfunction(foo,Void,())
     end
 end
+
+# @generated functions including inner functions
+@generated function _g_f_with_inner(x)
+    :(y->y)
+end
+@test (_g_f_with_inner(1))(8) == 8
diff --git a/test/statistics.jl b/test/statistics.jl
index 7f313cf8051ec..ab392062d7958 100644
--- a/test/statistics.jl
+++ b/test/statistics.jl
@@ -178,35 +178,50 @@ for vd in [1, 2], zm in [true, false], cr in [true, false]
         y1 = vec(Y[1,:])
     end
 
-    c = zm ? cov(x1; mean=0, corrected=cr) :
-             cov(x1; corrected=cr)
+    c = zm ? Base.covm(x1, 0, cr) :
+             cov(x1, cr)
     @test isa(c, Float64)
     @test_approx_eq c Cxx[1,1]
+    @inferred cov(x1, cr)
 
-    C = zm ? cov(X; vardim=vd, mean=0, corrected=cr) :
-             cov(X; vardim=vd, corrected=cr)
+    @test cov(X) == Base.covm(X, mean(X, 1))
+    C = zm ? Base.covm(X, 0, vd, cr) :
+             cov(X, vd, cr)
     @test size(C) == (k, k)
     @test_approx_eq C Cxx
+    @inferred cov(X, vd, cr)
 
-    c = zm ? cov(x1, y1; mean=0, corrected=cr) :
-             cov(x1, y1; corrected=cr)
+    @test cov(x1, y1) == Base.covm(x1, mean(x1), y1, mean(y1))
+    c = zm ? Base.covm(x1, 0, y1, 0, cr) :
+             cov(x1, y1, cr)
     @test isa(c, Float64)
     @test_approx_eq c Cxy[1,1]
+    @inferred cov(x1, y1, cr)
 
-    C = zm ? cov(x1, Y; vardim=vd, mean=0, corrected=cr) :
-             cov(x1, Y; vardim=vd, corrected=cr)
+    if vd == 1
+        @test cov(x1, Y) == Base.covm(x1, mean(x1), Y, mean(Y, 1))
+    end
+    C = zm ? Base.covm(x1, 0, Y, 0, vd, cr) :
+             cov(x1, Y, vd, cr)
     @test size(C) == (1, k)
     @test_approx_eq C Cxy[1,:]
+    @inferred cov(x1, Y, vd, cr)
 
-    C = zm ? cov(X, y1; vardim=vd, mean=0, corrected=cr) :
-             cov(X, y1; vardim=vd, corrected=cr)
+    if vd == 1
+        @test cov(X, y1) == Base.covm(X, mean(X, 1), y1, mean(y1))
+    end
+    C = zm ? Base.covm(X, 0, y1, 0, vd, cr) :
+             cov(X, y1, vd, cr)
     @test size(C) == (k, 1)
     @test_approx_eq C Cxy[:,1]
+    @inferred cov(X, y1, vd, cr)
 
-    C = zm ? cov(X, Y; vardim=vd, mean=0, corrected=cr) :
-             cov(X, Y; vardim=vd, corrected=cr)
+    @test cov(X, Y) == Base.covm(X, mean(X, 1), Y, mean(Y, 1))
+    C = zm ? Base.covm(X, 0, Y, 0, vd, cr) :
+             cov(X, Y, vd, cr)
     @test size(C) == (k, k)
     @test_approx_eq C Cxy
+    @inferred cov(X, Y, vd, cr)
 end
 
 # test correlation
@@ -245,29 +260,44 @@ for vd in [1, 2], zm in [true, false]
         y1 = vec(Y[1,:])
     end
 
-    c = zm ? cor(x1; mean=0) : cor(x1)
+    c = zm ? Base.corm(x1, 0) : cor(x1)
     @test isa(c, Float64)
     @test_approx_eq c Cxx[1,1]
+    @inferred cor(x1)
 
-    C = zm ? cor(X; vardim=vd, mean=0) : cor(X; vardim=vd)
+    @test cor(X) == Base.corm(X, mean(X, 1))
+    C = zm ? Base.corm(X, 0, vd) : cor(X, vd)
     @test size(C) == (k, k)
     @test_approx_eq C Cxx
+    @inferred cor(X, vd)
 
-    c = zm ? cor(x1, y1; mean=0) : cor(x1, y1)
+    @test cor(x1, y1) == Base.corm(x1, mean(x1), y1, mean(y1))
+    c = zm ? Base.corm(x1, 0, y1, 0) : cor(x1, y1)
     @test isa(c, Float64)
     @test_approx_eq c Cxy[1,1]
+    @inferred cor(x1, y1)
 
-    C = zm ? cor(x1, Y; vardim=vd, mean=0) : cor(x1, Y; vardim=vd)
+    if vd == 1
+        @test cor(x1, Y) == Base.corm(x1, mean(x1), Y, mean(Y, 1))
+    end
+    C = zm ? Base.corm(x1, 0, Y, 0, vd) : cor(x1, Y, vd)
     @test size(C) == (1, k)
     @test_approx_eq C Cxy[1,:]
+    @inferred cor(x1, Y, vd)
 
-    C = zm ? cor(X, y1; vardim=vd, mean=0) : cor(X, y1; vardim=vd)
+    if vd == 1
+        @test cor(X, y1) == Base.corm(X, mean(X, 1), y1, mean(y1))
+    end
+    C = zm ? Base.corm(X, 0, y1, 0, vd) : cor(X, y1, vd)
     @test size(C) == (k, 1)
     @test_approx_eq C Cxy[:,1]
+    @inferred cor(X, y1, vd)
 
-    C = zm ? cor(X, Y; vardim=vd, mean=0) : cor(X, Y; vardim=vd)
+    @test cor(X, Y) == Base.corm(X, mean(X, 1), Y, mean(Y, 1))
+    C = zm ? Base.corm(X, 0, Y, 0, vd) : cor(X, Y, vd)
     @test size(C) == (k, k)
     @test_approx_eq C Cxy
+    @inferred cor(X, Y, vd)
 end
 
 
@@ -289,8 +319,12 @@ end
 @test midpoints(Float64[1.0:1.0:10.0;]) == Float64[1.5:1.0:9.5;]
 
 @test quantile([1,2,3,4],0.5) == 2.5
+@test quantile([1,2,3,4],[0.5]) == [2.5]
 @test quantile([1., 3],[.25,.5,.75])[2] == median([1., 3])
-@test quantile([0.:100.;],[.1,.2,.3,.4,.5,.6,.7,.8,.9])[1] == 10.0
+@test quantile(100.0:-1.0:0.0, 0.0:0.1:1.0) == collect(0.0:10.0:100.0)
+@test quantile(0.0:100.0, 0.0:0.1:1.0, sorted=true) == collect(0.0:10.0:100.0)
+@test quantile(100f0:-1f0:0.0, 0.0:0.1:1.0) == collect(0f0:10f0:100f0)
+
 
 # test invalid hist nbins argument (#9999)
 @test_throws ArgumentError hist(Int[], -1)
@@ -307,6 +341,28 @@ end
 @test histrange([1, 600], 4) == 0.0:200.0:600.0
 @test histrange([1, -1000], 4) == -1500.0:500.0:500.0
 
+# issue #13326
+l,h = extrema(histrange([typemin(Int),typemax(Int)], 10))
+@test l <= typemin(Int)
+@test h >= typemax(Int)
+
 @test_throws ArgumentError histrange([1, 10], 0)
 @test_throws ArgumentError histrange([1, 10], -1)
 @test_throws ArgumentError histrange(Float64[],-1)
+
+# variance of complex arrays (#13309)
+let z = rand(Complex128, 10)
+    @test var(z) ≈ invoke(var, (Any,), z) ≈ cov(z) ≈ var(z,1)[1] ≈ sumabs2(z - mean(z))/9
+    @test isa(var(z), Float64)
+    @test isa(invoke(var, (Any,), z), Float64)
+    @test isa(cov(z), Float64)
+    @test isa(var(z,1), Vector{Float64})
+    @test varm(z, 0.0) ≈ invoke(varm, (Any,Float64), z, 0.0) ≈ sumabs2(z)/9
+    @test isa(varm(z, 0.0), Float64)
+    @test isa(invoke(varm, (Any,Float64), z, 0.0), Float64)
+    @test cor(z) === 1.0
+end
+let v = varm([1.0+2.0im], 0; corrected = false)
+    @test v ≈ 5
+    @test isa(v, Float64)
+end
diff --git a/test/string.jl b/test/string.jl
index df9581e7655f8..1bff360c9c6ac 100644
--- a/test/string.jl
+++ b/test/string.jl
@@ -1,5 +1,14 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+## generic string uses only endof and next; used for testing ##
+
+immutable GenericString <: AbstractString
+    string::AbstractString
+end
+
+Base.endof(s::GenericString) = endof(s.string)
+Base.next(s::GenericString, i::Int) = next(s.string, i)
+
 include("strings/basic.jl")
 include("strings/types.jl")
 include("strings/search.jl")
diff --git a/test/strings/basic.jl b/test/strings/basic.jl
index 2b19745579275..6cf6edbf8ee4b 100644
--- a/test/strings/basic.jl
+++ b/test/strings/basic.jl
@@ -11,6 +11,8 @@
 @test endswith("abcd", "cd")
 @test !endswith("abcd", "dc")
 @test !endswith("cd", "abcd")
+@test startswith("ab\0cd", "ab\0c")
+@test !startswith("ab\0cd", "ab\0d")
 
 @test filter(x -> x ∈ ['f', 'o'], "foobar") == "foo"
 
@@ -155,15 +157,6 @@ tstr = tstStringType("12");
 @test_throws ErrorException endof(tstr)
 @test_throws ErrorException next(tstr, Bool(1))
 
-## generic string uses only endof and next ##
-
-immutable GenericString <: AbstractString
-    string::AbstractString
-end
-
-Base.endof(s::GenericString) = endof(s.string)
-Base.next(s::GenericString, i::Int) = next(s.string, i)
-
 gstr = GenericString("12");
 @test typeof(string(gstr))==GenericString
 @test bytestring()==""
@@ -261,14 +254,14 @@ end
 # issue # 11389: Vector{UInt32} was copied with UTF32String, unlike Vector{Char}
 a = UInt32[48,0]
 b = UTF32String(a)
-@test b=="0"
+@test b == "0"
 a[1] = 65
-@test b=="A"
+@test b == "A"
 c = Char['0','\0']
 d = UTF32String(c)
-@test d=="0"
+@test d == "0"
 c[1] = 'A'
-@test d=="A"
+@test d == "A"
 
 # iteration
 @test [c for c in "ḟøøƀäṙ"] == ['ḟ', 'ø', 'ø', 'ƀ', 'ä', 'ṙ']
@@ -480,7 +473,13 @@ str = "abcdef\uff\uffff\u10ffffABCDEF"
 
 foomap(ch) = (ch > 65)
 foobar(ch) = Char(0xd800)
-foobaz(ch) = Char(0x200000)
+foobaz(ch) = reinterpret(Char, typemax(UInt32))
 @test_throws UnicodeError map(foomap, utf16(str))
 @test_throws UnicodeError map(foobar, utf16(str))
 @test_throws UnicodeError map(foobaz, utf16(str))
+
+@test "a".*["b","c"] == ["ab","ac"]
+@test ["b","c"].*"a" == ["ba","ca"]
+@test utf8("a").*["b","c"] == ["ab","ac"]
+@test "a".*map(utf8,["b","c"]) == ["ab","ac"]
+@test ["a","b"].*["c","d"]' == ["ac" "ad"; "bc" "bd"]
diff --git a/test/strings/io.jl b/test/strings/io.jl
index dc315fb3bb62e..4b73b926bc267 100644
--- a/test/strings/io.jl
+++ b/test/strings/io.jl
@@ -54,15 +54,17 @@ cx = Any[
 ]
 
 for i = 1:size(cx,1)
-    @test cx[i,1] == convert(UInt32, cx[i,2])
-    @test string(cx[i,2]) == unescape_string(cx[i,3])
-    if isascii(cx[i,2]) || !isprint(cx[i,2])
-        @test cx[i,3] == escape_string(string(cx[i,2]))
+    cp, ch, st = cx[i,:]
+    @test cp == convert(UInt32, ch)
+    @test string(ch) == unescape_string(st)
+    if isascii(ch) || !isprint(ch)
+        @test st == escape_string(string(ch))
     end
     for j = 1:size(cx,1)
-        str = string(cx[i,2], cx[j,2])
+        str = string(ch, cx[j,2])
         @test str == unescape_string(escape_string(str))
     end
+    @test repr(ch) == "'$(isprint(ch) ? ch : st)'"
 end
 
 for i = 0:0x7f, p = ["","\0","x","xxx","\x7f","\uFF","\uFFF",
@@ -134,6 +136,8 @@ end
 @test "\x0f" == unescape_string("\\x0f")
 @test "\x0F" == unescape_string("\\x0F")
 
+extrapath = @windows? joinpath(JULIA_HOME,"..","Git","usr","bin")*";" : ""
+withenv("PATH" => extrapath * ENV["PATH"]) do
 if !success(`iconv --version`)
     warn("iconv not found, skipping unicode tests!")
     @windows_only warn("Use WinRPM.install(\"win_iconv\") to run these tests")
@@ -154,9 +158,9 @@ else
     # Use iconv to generate the other data
     for encoding in ["UTF-32LE", "UTF-16BE", "UTF-16LE", "UTF-8"]
         output_path = joinpath(unicodedir, encoding*".unicode")
-        f = Base.FS.open(output_path,Base.JL_O_WRONLY|Base.JL_O_CREAT,Base.S_IRUSR | Base.S_IWUSR | Base.S_IRGRP | Base.S_IROTH)
+        f = Base.Filesystem.open(output_path,Base.JL_O_WRONLY|Base.JL_O_CREAT,Base.S_IRUSR | Base.S_IWUSR | Base.S_IRGRP | Base.S_IROTH)
         run(pipeline(`iconv -f $primary_encoding -t $encoding $primary_path`, f))
-        Base.FS.close(f)
+        Base.Filesystem.close(f)
     end
 
     f=open(joinpath(unicodedir,"UTF-32LE.unicode"))
@@ -168,23 +172,22 @@ else
     close(f)
     @test str1 == str2
 
-    @test str1 == open(joinpath(unicodedir,"UTF-16LE.unicode")) do f
-        utf16(read(f, UInt16, 2160641)[2:end])
-    end
+    @test str1 == utf16(read(joinpath(unicodedir,"UTF-16LE.unicode"),
+                             UInt16, 2160641)[2:end])
 
-    @test str1 == open(joinpath(unicodedir,"UTF-16LE.unicode")) do f
-        utf16(read(f, UInt8, 2160641*2))
-    end
-    @test str1 == open(joinpath(unicodedir,"UTF-16BE.unicode")) do f
-        utf16(read(f, UInt8, 2160641*2))
-    end
+    @test str1 == utf16(read(joinpath(unicodedir,"UTF-16LE.unicode"),
+                             UInt8, 2160641*2))
+
+    @test str1 == utf16(read(joinpath(unicodedir,"UTF-16BE.unicode"),
+                             UInt8, 2160641*2))
+
+
+    @test str1 == utf32(read(joinpath(unicodedir,"UTF-32LE.unicode"),
+                             UInt8, 1112065*4))
+
+    @test str1 == utf32(read(joinpath(unicodedir,"UTF-32BE.unicode"),
+                             UInt8, 1112065*4))
 
-    @test str1 == open(joinpath(unicodedir,"UTF-32LE.unicode")) do f
-        utf32(read(f, UInt8, 1112065*4))
-    end
-    @test str1 == open(joinpath(unicodedir,"UTF-32BE.unicode")) do f
-        utf32(read(f, UInt8, 1112065*4))
-    end
 
     str1 = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
     str2 = UTF32String(UInt32[
@@ -201,6 +204,7 @@ else
     end
     rm(unicodedir)
 end
+end
 
 # Tests of join()
 @test join([]) == ""
diff --git a/test/strings/search.jl b/test/strings/search.jl
index 365f750c94230..6cc7b7233619a 100644
--- a/test/strings/search.jl
+++ b/test/strings/search.jl
@@ -4,15 +4,6 @@
 astr = "Hello, world.\n"
 u8str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
 
-## generic string uses only endof and next ##
-
-immutable GenericString <: AbstractString
-    string::AbstractString
-end
-
-Base.endof(s::GenericString) = endof(s.string)
-Base.next(s::GenericString, i::Int) = next(s.string, i)
-
 # I think these should give error on 4 also, and "" is not treated
 # consistently with SubString("",1,1), nor with Char[]
 for ind in (0, 5)
diff --git a/test/strings/types.jl b/test/strings/types.jl
index 2922c68bdf605..a904c87e321bc 100644
--- a/test/strings/types.jl
+++ b/test/strings/types.jl
@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
-## SubString, RevString, and RepString tests ##
+## SubString, RevString, RepString and Cstring tests ##
 
 ## SubString tests ##
 u8str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
@@ -213,3 +213,27 @@ let
     @test srep[7] == 'β'
     @test_throws BoundsError srep[8]
 end
+
+
+## Cstring tests ##
+
+# issue #13974: comparison against pointers
+
+str = bytestring("foobar")
+ptr = pointer(str)
+cstring = Cstring(ptr)
+@test ptr == cstring
+@test cstring == ptr
+
+# convenient NULL string creation from Ptr{Void}
+nullstr = Cstring(C_NULL)
+
+# Comparisons against NULL strings
+@test ptr != nullstr
+@test nullstr != ptr
+
+# Short-hand comparison against C_NULL
+@test nullstr == C_NULL
+@test C_NULL == nullstr
+@test cstring != C_NULL
+@test C_NULL != cstring
diff --git a/test/strings/util.jl b/test/strings/util.jl
index a1858b0c062e3..d3a4e92034bf6 100644
--- a/test/strings/util.jl
+++ b/test/strings/util.jl
@@ -205,6 +205,9 @@ end
 
 @test replace("foo", "oo", uppercase) == "fOO"
 
+# Issue 13332
+@test replace("abc", 'b', 2.1) == "a2.1c"
+
 # chomp/chop
 @test chomp("foo\n") == "foo"
 @test chop("foob") == "foo"
diff --git a/test/subarray.jl b/test/subarray.jl
index 6b0e91c51c3f0..8aed951ccc382 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
 using Base.Test
-# import Base: ViewIndex, nextLD, dimsizeexpr, rangetype, merge_indexes, first_index, stride1expr, tailsize, subarray_linearindexing_dim
+# import Base: ViewIndex, dimsizeexpr, rangetype, merge_indexes, first_index, stride1expr, tailsize
 using Base.Cartesian
 
 print_underestimates = false
@@ -89,59 +89,12 @@ function single_stride_dim(A::Array)
 end
 single_stride_dim(A::AbstractArray) = single_stride_dim(copy_to_array(A))
 
-# Extract the "linear indexing dimension" from a SubArray
-getLD{T,N,P,I,LD}(::SubArray{T,N,P,I,LD}) = LD
-
-# Compare the linear indexing dimension of a SubArray
-# to a direct computation of strides
-function cmpLD(Atest::SubArray, Acomp)
-    # Compute ld, skipping over dropped dimensions
-    LD = getLD(Atest)
-    ld = LD
-    for i = 1:LD
-        if isa(Atest.indexes[i], Real)
-            ld -= 1
-        end
-    end
-    ld, single_stride_dim(Acomp)
-end
-
-# Testing linear dimension inference for views-of-views
-for N = 1:4
-    @eval begin
-        function test_viewview{T}(SB, A::Array{T,$N}, f, vindex)
-            local SSB
-            @nloops $N j d->(1:length(vindex)) d->(i_d = vindex[j_d]) begin
-                I = @ntuple $N d->i_d
-                try
-                    SSB = f(SB, I...)
-                catch err
-                    println(summary(SB))
-                    println(I)
-                    rethrow(err)
-                end
-                SA = f(A, I...)
-                ld, ldc = cmpLD(SSB, SA)
-                if ld == ldc
-                elseif ld <= ldc
-                    if print_underestimates
-                        println("Underestimate f = ", f, " on ", summary(SB), " with I = ", I, ", producing ", summary(SSB))
-                    end
-                else
-                    println(summary(SB))
-                    println(summary(SSB))
-                    error("failed on ", I)
-                end
-            end
-        end
-    end
-end
-
 # Testing equality of AbstractArrays, using several different methods to access values
 function test_cartesian(A, B)
     isgood = true
     for (IA, IB) in zip(eachindex(A), eachindex(B))
         if A[IA] != B[IB]
+            @show IA IB A[IA] B[IB]
             isgood = false
             break
         end
@@ -164,6 +117,7 @@ function test_linear(A, B)
     end
     if !isgood
         @show A
+        @show A.indexes
         @show B
         error("Mismatch")
     end
@@ -189,50 +143,69 @@ function _test_mixed(A, B)
         @show B
         error("Mismatch")
     end
+    nothing
 end
 
-function err_li(I::Tuple, ld::Int, ldc::Int)
-    @show I
-    @show ld, ldc
-    error("Linear indexing inference mismatch")
+function test_bounds(A)
+    @test_throws BoundsError A[0]
+    @test_throws BoundsError A[end+1]
+    @test_throws BoundsError A[1, 0]
+    @test_throws BoundsError A[1, end+1]
+    @test_throws BoundsError A[1, 1, 0]
+    @test_throws BoundsError A[1, 1, end+1]
+    @test_throws BoundsError A[0, 1]
+    @test_throws BoundsError A[end+1, 1]
+    @test_throws BoundsError A[0, 1, 1]
+    @test_throws BoundsError A[end+1, 1, 1]
+    @test_throws BoundsError A[1, 0, 1]
+    @test_throws BoundsError A[1, end+1, 1]
 end
 
-function err_li(S::SubArray, ld::Int, szC)
-    println(summary(S))
-    @show S.indexes
-    @show ld
-    @show szC
-    error("Linear indexing inference mismatch")
+function dim_break_linindex(I)
+    i = 1
+    while i <= length(I) && !isa(I[i], Vector{Int})
+        i += 1
+    end
+    i - 1
 end
 
 function runtests(A::Array, I...)
     # Direct test of linear indexing inference
     C = Agen_nodrop(A, I...)
-    ld = single_stride_dim(C)
-    ldc = Base.subarray_linearindexing_dim(typeof(A), typeof(I))
-    ld == ldc || err_li(I, ld, ldc)
+    ld = min(single_stride_dim(C), dim_break_linindex(I))
     # sub
     S = sub(A, I...)
-    getLD(S) == ldc || err_li(S, ldc)
     if Base.iscontiguous(S)
         @test S.stride1 == 1
     end
     test_linear(S, C)
     test_cartesian(S, C)
     test_mixed(S, C)
+    test_bounds(S)
     # slice
     S = slice(A, I...)
-    getLD(S) == ldc || err_li(S, ldc)
     test_linear(S, C)
     test_cartesian(S, C)
     test_mixed(S, C)
+    test_bounds(S)
 end
 
 function runtests(A::SubArray, I...)
+    # When A was created with sub, we have to check bounds, since some
+    # of the "residual" dimensions have size 1. It's possible that we
+    # need dedicated tests for sub.
+    for d = 1:length(I)-1
+        if !isa(I[d], Colon) && any(I[d] .> size(A,d))
+            return nothing
+        end
+    end
+    if !isa(I[end], Colon) && any(I[end] .> prod(size(A)[length(I):end]))
+        return nothing
+    end
     AA = copy_to_array(A)
     # Direct test of linear indexing inference
     C = Agen_nodrop(AA, I...)
-    Cld = ld = single_stride_dim(C)
+    Cld = ld = min(single_stride_dim(C), dim_break_linindex(I))
     Cdim = AIindex = 0
     while Cdim <= Cld && AIindex < length(A.indexes)
         AIindex += 1
@@ -252,11 +225,10 @@ function runtests(A::SubArray, I...)
         @show I
         rethrow(err)
     end
-    ldc = getLD(S)
-    ldc <= ld || err_li(S, ld, size(C))
     test_linear(S, C)
     test_cartesian(S, C)
     test_mixed(S, C)
+    test_bounds(S)
     # slice
     try
         S = slice(A, I...)
@@ -266,11 +238,10 @@ function runtests(A::SubArray, I...)
         @show I
         rethrow(err)
     end
-    ldc = getLD(S)
-    ldc <= ld || err_li(S, ld, size(C))
     test_linear(S, C)
     test_cartesian(S, C)
     test_mixed(S, C)
+    test_bounds(S)
 end
 
 # indexN is a cartesian index, indexNN is a linear index for 2 dimensions, and indexNNN is a linear index for 3 dimensions
@@ -308,8 +279,8 @@ runviews{T}(SB::AbstractArray{T,0}, indexN, indexNN, indexNNN) = nothing
 testfull = Bool(parse(Int,(get(ENV, "JULIA_TESTFULL", "0"))))
 
 ### Views from Arrays ###
-index5 = (2, :, 2:5, 1:2:5, [4,1,5], sub(1:5,[2,1,5]))  # all work with at least size 5
-index25 = (8, :, 2:11, 12:3:22, [4,1,5,9], sub(1:25,[13,22,24]))
+index5 = (1, 2, :, 2:5, 1:2:5, [1], [4,1,5], sub(1:5,[2,1,5]))  # all work with at least size 5
+index25 = (3, 8, :, 2:11, 12:3:22, [4,1,5,9], sub(1:25,[13,22,24]))
 index125 = (113, :, 85:121, 2:15:92, [99,14,103], sub(1:125,[66,18,59]))
 
 if testfull
@@ -329,6 +300,8 @@ if testfull
         for o3 in oindex, o2 in oindex, o1 in oindex
             sliceB = slice(B, o1, o2, o3)
             runviews(sliceB, index5, index25, index125)
+            subB = sub(B, o1, o2, o3)
+            runviews(subB, index5, index25, index125)
         end
     end
 end
@@ -342,16 +315,18 @@ if !testfull
                      (:,3:7,:),
                      (3:7,:,:),
                      (3:7,6,:),
-                     (3:7,6,6),
-                     (6,3:7,3:7),
+                     (3:7,6,0x6),
+                     (6,UInt(3):UInt(7),3:7),
                      (13:-2:1,:,:),
                      ([8,4,6,12,5,7],:,3:7),
                      (6,6,[8,4,6,12,5,7]),
                      (1,:,sub(1:13,[9,12,4,13,1])),
                      (sub(1:13,[9,12,4,13,1]),2:6,4))
             runtests(B, oind...)
-            sliceB = slice(B, oind)
+            sliceB = slice(B, oind...)
             runviews(sliceB, index5, index25, index125)
+            subB = sub(B, oind...)
+            runviews(subB, index5, index25, index125)
         end
     end
 end
@@ -367,8 +342,9 @@ x11289 = randn(5,5)
 # sub
 A = reshape(1:120, 3, 5, 8)
 sA = sub(A, 2, 1:5, :)
+@test strides(sA) == (1, 3, 15)
 @test parent(sA) == A
-@test parentindexes(sA) == (2:2, 1:5, :)
+@test parentindexes(sA) == (Base.NoSlice(2), 1:5, :)
 @test Base.parentdims(sA) == [1:3;]
 @test size(sA) == (1, 5, 8)
 @test sA[1, 2, 1:8][:] == [5:15:120;]
@@ -388,7 +364,7 @@ sA[:] = -3
 sA = sub(A, 1:3, 3, 2:5)
 @test Base.parentdims(sA) == [1:3;]
 @test size(sA) == (3,1,4)
-@test sA == A[1:3,3,2:5]
+@test sA == A[1:3,3:3,2:5]
 @test sA[:] == A[1:3,3,2:5][:]
 sA = sub(A, 1:2:3, 1:3:5, 1:2:8)
 @test Base.parentdims(sA) == [1:3;]
@@ -470,3 +446,22 @@ let a = ones(Float64, (2,2)),
     b[2] = 2
     @test b[2] === 2.0
 end
+
+# issue #15138
+let a = [1,2,3],
+    b = sub(a, UInt(1):UInt(2))
+    @test b == slice(a, UInt(1):UInt(2)) == slice(slice(a, :), UInt(1):UInt(2)) == [1,2]
+end
+
+let A = reshape(1:4, 2, 2)
+    B = sub(A, :, :)
+    @test parent(B) === A
+    @test parent(sub(B, 0x1, :)) === parent(slice(B, 0x1, :)) === A
+end
+
+# issue #15168
+let A = rand(10), sA = sub(copy(A), :)
+    @test sA[Int16(1)] === sA[Int32(1)] === sA[Int64(1)] === A[1]
+    permute!(sA, collect(Int16, 1:10))
+    @test A == sA
+end
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 3136227606b93..c6d687fa2c556 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -12,6 +12,10 @@ Base.Sys.loadavg()
 @test_throws ArgumentError ENV["okname"] = "bad\0val"
 @test_throws ArgumentError Sys.set_process_title("bad\0title")
 
+withenv("bad"=>"dog") do
+    @test_throws ArgumentError ENV["bad\0cat"]
+end
+
 # issue #11170
 withenv("TEST"=>"nonempty") do
     @test ENV["TEST"] == "nonempty"
@@ -25,3 +29,9 @@ let c = collect(ENV)
     @test length(ENV) == length(c)
     @test isempty(ENV) || first(ENV) in c
 end
+
+# test for non-existent keys
+key = randstring(25)
+@test !haskey(ENV,key)
+@test_throws KeyError ENV[key]
+@test get(ENV,key,"default") == "default"
diff --git a/test/test.jl b/test/test.jl
index bbd8adde09ed0..7736cb5898d29 100644
--- a/test/test.jl
+++ b/test/test.jl
@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: http://julialang.org/license
 
+using Base.Test
+
 # test file to test testing
 
 # Test @test
@@ -9,9 +11,6 @@
 @test strip("\t  hi   \n") == "hi"
 @test strip("\t  this should fail   \n") != "hi"
 
-scary = Base.Test.Error("hi",DimensionMismatch,[])
-@test sprint(showerror,scary) == "test error in expression: hi\nDimensionMismatch"
-
 a = Array(Float64, 2, 2, 2, 2, 2)
 a[1,1,1,1,1] = 10
 @test a[1,1,1,1,1] == 10
@@ -19,74 +18,135 @@ a[1,1,1,1,1] = 10
 
 @test rand() != rand()
 
+# Test printing of Pass results
+# Pass - constant
+@test contains(sprint(show, @test true), "Expression: true")
+# Pass - expression
+@test contains(sprint(show, @test 10 == 2*5), "Evaluated: 10 == 10")
+@test contains(sprint(show, @test !false), "Expression: !false")
+# Pass - exception
+@test contains(sprint(show, @test_throws ErrorException error()),
+                "Thrown: ErrorException")
 
-# Test with_handler
-successflag = false
-failureflag = false
-errorflag = false
-test_handler(r::Test.Success) = !successflag
-test_handler(r::Test.Failure) = !failureflag
-test_handler(r::Test.Error) = !errorflag
-
-Test.with_handler(test_handler) do
-    @test true
-    @test successflag
-    @test !failureflag
-    @test !errorflag
-    successflag = false
+# Test printing of Fail results
+type NoThrowTestSet <: Base.Test.AbstractTestSet
+    results::Vector
+    NoThrowTestSet(desc) = new([])
+end
+Base.Test.record(ts::NoThrowTestSet, t::Base.Test.Result) = (push!(ts.results, t); t)
+Base.Test.finish(ts::NoThrowTestSet) = ts.results
+fails = @testset NoThrowTestSet begin
+    # Fail - wrong exception
+    @test_throws OverflowError error()
+    # Fail - no exception
+    @test_throws OverflowError 1 + 1
+    # Fail - const
     @test false
-    @test !successflag
-    @test failureflag
-    @test !errorflag
-    failureflag = false
-    @test error("throw error")
-    @test !successflag
-    @test !failureflag
-    @test errorflag
+    # Fail - comparison
+    @test 1+1 == 2+2
 end
-
-# Test evaluation of comparison tests
-i7586_1() = 1
-i7586_2() = 7
-i7586_3() = 9
-
-comparison_flags_s = [false,false,false]
-comparison_flags_f = [false,false,false]
-function test_handler2(r::Test.Success)
-    comparison_flags_s[1] = (r.resultexpr.args[1] == 1)
-    comparison_flags_s[2] = (r.resultexpr.args[3] == 7)
-    comparison_flags_s[3] = (r.resultexpr.args[5] == 9)
+for i in 1:4
+    @test isa(fails[i], Base.Test.Fail)
 end
+@test contains(sprint(show, fails[1]), "Thrown: ErrorException")
+@test contains(sprint(show, fails[2]), "No exception thrown")
+@test contains(sprint(show, fails[3]), "Evaluated: false")
+@test contains(sprint(show, fails[4]), "Evaluated: 2 == 4")
+
+# Test printing of a TestSetException
+tse_str = sprint(show, Test.TestSetException(1,2,3))
+@test contains(tse_str, "1 passed")
+@test contains(tse_str, "2 failed")
+@test contains(tse_str, "3 errored")
+
+@test Test.finish(Test.FallbackTestSet()) != nothing
+
+OLD_STDOUT = STDOUT
+catch_out = IOStream("")
+rd, wr = redirect_stdout()
 
-function test_handler2(r::Test.Failure)
-    comparison_flags_f[1] = (r.resultexpr.args[1] == 1)
-    comparison_flags_f[2] = (r.resultexpr.args[3] == 7)
-    comparison_flags_f[3] = (r.resultexpr.args[5] == 10)
+# Check that the fallback test set throws immediately
+@test_throws ErrorException (@test 1 == 2)
+
+@testset "no errors" begin
+    @test true
+    @test 1 == 1
 end
 
-Test.with_handler(test_handler2) do
-    @test i7586_1() <= i7586_2() <= i7586_3()
-    @test i7586_1() >= i7586_2() >= 10
+# Test entirely empty test set
+@testset "outer" begin
+    @testset "inner" begin
+    end
 end
-@test all(comparison_flags_s)
-@test all(comparison_flags_f)
-
-# Test @test_throws
-domainerror_thrower() = throw(DomainError())
-boundserror_thrower() = throw(BoundsError())
-error_thrower() = error("An error happened")
-@test_throws DomainError domainerror_thrower()
-@test_throws BoundsError boundserror_thrower()
-
-failureflag = false
-successflag = false
-Test.with_handler(test_handler) do
-    @test_throws DomainError boundserror_thrower()
-    @test failureflag
-    @test_throws DomainError domainerror_thrower()
-    @test successflag
+
+try
+
+@testset "outer" begin
+    @testset "inner1" begin
+        @test true
+        @test false
+        @test 1 == 1
+        @test 2 == :foo
+        @test 3 == 3
+        @testset "d" begin
+            @test 4 == 4
+        end
+        @testset begin
+            @test :blank != :notblank
+        end
+    end
+    @testset "inner1" begin
+        @test 1 == 1
+        @test 2 == 2
+        @test 3 == :bar
+        @test 4 == 4
+        @test_throws ErrorException 1+1
+        @test_throws ErrorException error()
+        @test_throws RemoteException error()
+        @testset "errrrr" begin
+            @test "not bool"
+            @test error()
+        end
+
+        error("exceptions in testsets should be caught")
+        @test 1 == 1 # this test will not be run
+    end
+
+    @testset "loop with desc" begin
+        @testset "loop1 $T" for T in (Float32, Float64)
+            @test 1 == T(1)
+        end
+    end
+    @testset "loops without desc" begin
+        @testset for T in (Float32, Float64)
+            @test 1 == T(1)
+        end
+        @testset for T in (Float32, Float64), S in (Int32,Int64)
+            @test S(1) == T(1)
+        end
+    end
+    srand(123)
+    @testset "some loops fail" begin
+        @testset for i in 1:5
+            @test i <= rand(1:10)
+        end
+        # should add 3 errors and 3 passing tests
+        @testset for i in 1:6
+            iseven(i) || error("error outside of test")
+            @test true # only gets run if the above passed
+        end
+    end
 end
+    # These lines shouldn't be called
+    redirect_stdout(OLD_STDOUT)
+    error("No exception was thrown!")
+catch ex
 
+    @test isa(ex, Test.TestSetException)
+    @test ex.pass  == 24
+    @test ex.fail  == 6
+    @test ex.error == 6
+end
 
 # Test @test_approx_eq
 # TODO
@@ -98,3 +158,111 @@ end
 
 # Test @test_approx_eq_eps
 # TODO
+
+ts = @testset "@testset should return the testset" begin
+    @test true
+end
+@test typeof(ts) == Base.Test.DefaultTestSet
+@test typeof(ts.results[1]) == Base.Test.Pass
+
+tss = @testset "@testset/for should return an array of testsets: $i" for i in 1:3
+    @test true
+end
+@test length(tss) == 3
+@test typeof(tss[1]) == Base.Test.DefaultTestSet
+@test typeof(tss[1].results[1]) == Base.Test.Pass
+
+# now we're done running tests with DefaultTestSet so we can go back to STDOUT
+redirect_stdout(OLD_STDOUT)
+
+# import the methods needed for defining our own testset type
+import Base.Test: record, finish
+using Base.Test: get_testset_depth, get_testset
+using Base.Test: AbstractTestSet, Result, Pass, Fail, Error
+immutable CustomTestSet <: Base.Test.AbstractTestSet
+    description::AbstractString
+    foo::Int
+    results::Vector
+    # constructor takes a description string and options keyword arguments
+    CustomTestSet(desc; foo=1) = new(desc, foo, [])
+end
+
+record(ts::CustomTestSet, child::AbstractTestSet) = push!(ts.results, child)
+record(ts::CustomTestSet, res::Result) = push!(ts.results, res)
+function finish(ts::CustomTestSet)
+    # just record if we're not the top-level parent
+    if get_testset_depth() > 0
+        record(get_testset(), ts)
+    end
+    ts
+end
+
+ts = @testset CustomTestSet "Testing custom testsets" begin
+    # this testset should inherit the parent testset type
+    @testset "custom testset inner 1" begin
+        @test true
+        @test false
+        @test error("this error will be reported as an error")
+        @test_throws ErrorException nothing
+        @test_throws ErrorException error("this error is a success")
+    end
+    # this testset has its own testset type
+    @testset CustomTestSet foo=4 "custom testset inner 2" begin
+        # this testset should inherit the type, but not the argument. If a particular
+        # testset type wants inheritance behavior they should implement it themselves
+        # using get_testset() in the constructor
+        @testset "custom testset inner 2 inner 1" begin
+            @test true
+        end
+        # make sure the RHS can use computed values, also tests options without
+        # specifying the testset type
+        @testset foo=(1+2) "custom testset inner 2 inner 2" begin
+            @test true
+        end
+    end
+end
+
+@test typeof(ts) == CustomTestSet
+@test ts.foo == 1
+@test ts.description == "Testing custom testsets"
+@test typeof(ts.results[1]) == CustomTestSet
+@test ts.results[1].description == "custom testset inner 1"
+@test ts.results[1].foo == 1
+@test typeof(ts.results[1].results[1]) == Pass
+@test typeof(ts.results[1].results[2]) == Fail
+@test typeof(ts.results[1].results[3]) == Error
+@test typeof(ts.results[1].results[4]) == Fail
+@test typeof(ts.results[1].results[5]) == Pass
+
+@test typeof(ts.results[2]) == CustomTestSet
+@test ts.results[2].description == "custom testset inner 2"
+@test ts.results[2].foo == 4
+@test typeof(ts.results[2].results[1]) == CustomTestSet
+@test ts.results[2].results[1].foo == 1
+@test typeof(ts.results[2].results[1].results[1]) == Pass
+@test typeof(ts.results[2].results[2]) == CustomTestSet
+@test ts.results[2].results[2].foo == 3
+
+# test custom testset types on testset/for
+tss = @testset CustomTestSet foo=3 "custom testset $i" for i in 1:6
+    @testset "inner testset $i-$j" for j in 1:3
+        @test iseven(i + j)
+    end
+    # make sure a testset within a testset/for works
+    @testset "inner testset $i" begin
+        @test iseven(i)
+    end
+end
+
+
+for i in 1:6
+    @test typeof(tss[i]) == CustomTestSet
+    @test tss[i].foo == 3
+    for j in 1:3
+        @test typeof(tss[i].results[j]) == CustomTestSet
+        @test tss[i].results[j].foo == 1
+        @test typeof(tss[i].results[j].results[1]) == (iseven(i+j) ? Pass : Fail)
+    end
+    @test typeof(tss[i].results[4]) == CustomTestSet
+    @test typeof(tss[i].results[4].results[1]) == (iseven(i) ? Pass : Fail)
+end
diff --git a/test/test_sourcepath.jl b/test/test_sourcepath.jl
index 837e89e126adf..ac19d8b70bd37 100644
--- a/test/test_sourcepath.jl
+++ b/test/test_sourcepath.jl
@@ -3,5 +3,15 @@
 # source path in tasks
 path = Base.source_path()::ByteString # this variable is leaked to the source script
 @test endswith(path, joinpath("test","test_sourcepath.jl"))
-@test yieldto(@task Base.source_path()) == path
+@test let ct = current_task()
+    yieldto(@task yieldto(ct, Base.source_path()))
+end == path
+@test let ct = current_task()
+    yieldto(@task schedule(ct, Base.source_path()))
+end == path
+@test let ct = current_task(), t = @task Base.source_path()
+    schedule(ct)
+    yieldto(t)
+    wait(t)
+end == path
 @test isabspath(@__FILE__)
diff --git a/test/testdefs.jl b/test/testdefs.jl
index 944b86d16c781..0c9a7cb4f002b 100644
--- a/test/testdefs.jl
+++ b/test/testdefs.jl
@@ -5,18 +5,9 @@ using Base.Test
 function runtests(name)
     @printf("     \033[1m*\033[0m \033[31m%-21s\033[0m", name)
     tt = @elapsed include("$name.jl")
-    @printf(" in %6.2f seconds\n", tt)
-    nothing
-end
-
-function propagate_errors(a,b)
-    if isa(a,Exception)
-        rethrow(a)
-    end
-    if isa(b,Exception)
-        rethrow(b)
-    end
-    nothing
+    rss = Sys.maxrss()
+    @printf(" in %6.2f seconds, maxrss %7.2f MB\n", tt, rss / 2^20)
+    rss
 end
 
 # looking in . messes things up badly
diff --git a/test/threads.jl b/test/threads.jl
new file mode 100644
index 0000000000000..dfc9d9247c2f0
--- /dev/null
+++ b/test/threads.jl
@@ -0,0 +1,231 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+using Base.Test
+using Base.Threads
+
+# threading constructs
+
+# parallel loop with parallel atomic addition
+function threaded_loop(a, r, x)
+    @threads for i in r
+        a[i] = 1 + atomic_add!(x, 1)
+    end
+end
+
+function test_threaded_loop_and_atomic_add()
+    x = Atomic()
+    a = zeros(Int,10000)
+    threaded_loop(a,1:10000,x)
+    found = zeros(Bool,10000)
+    was_inorder = true
+    for i=1:length(a)
+        was_inorder &= a[i]==i
+        found[a[i]] = true
+    end
+    @test x[] == 10000
+    # Next test checks that al loop iterations ran,
+    # and were unique (via pigeon-hole principle).
+    @test findfirst(found,false) == 0
+    if was_inorder
+        println(STDERR, "Warning: threaded loop executed in order")
+    end
+end
+
+test_threaded_loop_and_atomic_add()
+
+# Helper for test_threaded_atomic_minmax that verifies sequential consistency.
+function check_minmax_consistency{T}(old::Array{T,1}, m::T, start::T, o::Base.Ordering)
+    for v in old
+        if v != start
+            # Check that atomic op that installed v reported consistent old value.
+            @test Base.lt(o, old[v-m+1], v)
+        end
+    end
+end
+
+function test_threaded_atomic_minmax{T}(m::T,n::T)
+    mid = m + (n-m)>>1
+    x = Atomic{T}(mid)
+    y = Atomic{T}(mid)
+    oldx = Array(T,n-m+1)
+    oldy = Array(T,n-m+1)
+    @threads for i = m:n
+        oldx[i-m+1] = atomic_min!(x, T(i))
+        oldy[i-m+1] = atomic_max!(y, T(i))
+    end
+    @test x[] == m
+    @test y[] == n
+    check_minmax_consistency(oldy,m,mid,Base.Forward)
+    check_minmax_consistency(oldx,m,mid,Base.Reverse)
+end
+
+# The ranges below verify that the correct signed/unsigned comparison is used.
+test_threaded_atomic_minmax(Int16(-5000),Int16(5000))
+test_threaded_atomic_minmax(UInt16(27000),UInt16(37000))
+
+function threaded_add_locked{LockT}(::Type{LockT}, x, n)
+    lock = LockT()
+    @threads for i = 1:n
+        lock!(lock)
+        x = x + 1
+        unlock!(lock)
+    end
+    return x
+end
+
+@test threaded_add_locked(SpinLock, 0, 10000) == 10000
+@test threaded_add_locked(Threads.RecursiveSpinLock, 0, 10000) == 10000
+@test threaded_add_locked(Mutex, 0, 10000) == 10000
+
+# Check if the recursive lock can be locked and unlocked correctly.
+let lock = Threads.RecursiveSpinLock()
+    @test lock!(lock) == 0
+    @test lock!(lock) == 0
+    @test unlock!(lock) == 0
+    @test unlock!(lock) == 0
+    @test unlock!(lock) == 1
+end
+
+# Make sure doing a GC while holding a lock doesn't cause dead lock
+# PR 14190. (This is only meaningful for threading)
+function threaded_gc_locked{LockT}(::Type{LockT})
+    lock = LockT()
+    @threads for i = 1:20
+        lock!(lock)
+        gc(false)
+        unlock!(lock)
+    end
+end
+
+threaded_gc_locked(SpinLock)
+threaded_gc_locked(Threads.RecursiveSpinLock)
+threaded_gc_locked(Mutex)
+
+# Issue 14726
+# Make sure that eval'ing in a different module doesn't mess up other threads
+orig_curmodule14726 = current_module()
+main_var14726 = 1
+module M14726
+module_var14726 = 1
+end
+
+@threads for i in 1:100
+    for j in 1:100
+        eval(M14726, :(module_var14726 = $j))
+    end
+end
+@test isdefined(:orig_curmodule14726)
+@test isdefined(:main_var14726)
+@test current_module() == orig_curmodule14726
+
+@threads for i in 1:100
+    # Make sure current module is not null.
+    # The @test might not be particularly meaningful currently since the
+    # thread infrastructures swallows the error. (Same below)
+    @test current_module() == orig_curmodule14726
+end
+
+module M14726_2
+using Base.Test
+using Base.Threads
+@threads for i in 1:100
+    # Make sure current module is the same with the one on the thread that
+    # pushes the work onto the threads.
+    # The @test might not be particularly meaningful currently since the
+    # thread infrastructures swallows the error. (See also above)
+    @test current_module() == M14726_2
+end
+end
+
+# Ensure only LLVM-supported types can be atomic
+@test_throws TypeError Atomic{Bool}
+@test_throws TypeError Atomic{BigInt}
+@test_throws TypeError Atomic{Float64}
+
+# Test atomic memory ordering with load/store
+type CommBuf
+    var1::Atomic{Int}
+    var2::Atomic{Int}
+    correct_write::Bool
+    correct_read::Bool
+    CommBuf() = new(Atomic{Int}(0), Atomic{Int}(0), false, false)
+end
+function test_atomic_write(commbuf::CommBuf, n::Int)
+    for i in 1:n
+        # The atomic stores guarantee that var1 >= var2
+        commbuf.var1[] = i
+        commbuf.var2[] = i
+    end
+    commbuf.correct_write = true
+end
+function test_atomic_read(commbuf::CommBuf, n::Int)
+    correct = true
+    while true
+        # load var2 before var1
+        var2 = commbuf.var2[]
+        var1 = commbuf.var1[]
+        correct &= var1 >= var2
+        var1 == n && break
+    end
+    commbuf.correct_read = correct
+end
+function test_atomic()
+    commbuf = CommBuf()
+    count = 1_000_000
+    @threads for i in 1:2
+        if i==1
+            test_atomic_write(commbuf, count)
+        else
+            test_atomic_read(commbuf, count)
+        end
+    end
+    @test commbuf.correct_write == true
+    @test commbuf.correct_read == true
+end
+test_atomic()
+
+# Test ordering with fences using Peterson's algorithm
+# Example adapted from <https://en.wikipedia.org/wiki/Peterson%27s_algorithm>
+type Peterson
+    # State for Peterson's algorithm
+    flag::Vector{Atomic{Int}}
+    turn::Atomic{Int}
+    # Collision detection
+    critical::Vector{Atomic{Int}}
+    correct::Vector{Bool}
+    Peterson() =
+        new([Atomic{Int}(0), Atomic{Int}(0)],
+            Atomic{Int}(0),
+            [Atomic{Int}(0), Atomic{Int}(0)],
+            [false, false])
+end
+function test_fence(p::Peterson, id::Int, n::Int)
+    @assert id == mod1(id,2)
+    correct = true
+    otherid = mod1(id+1,2)
+    for i in 1:n
+        p.flag[id][] = 1
+        p.turn[] = otherid
+        atomic_fence()
+        while p.flag[otherid][] != 0 && p.turn[] == otherid
+            # busy wait
+        end
+        # critical section
+        p.critical[id][] = 1
+        correct &= p.critical[otherid][] == 0
+        p.critical[id][] = 0
+        # end of critical section
+        p.flag[id][] = 0
+    end
+    p.correct[id] = correct
+end
+function test_fence()
+    commbuf = Peterson()
+    count = 1_000_000
+    @threads for i in 1:2
+        test_fence(commbuf, i, count)
+    end
+    @test commbuf.correct[1] == true
+    @test commbuf.correct[2] == true
+end
+test_fence()
diff --git a/test/topology.jl b/test/topology.jl
index 70a5e9792060c..a72ab26771d47 100644
--- a/test/topology.jl
+++ b/test/topology.jl
@@ -2,7 +2,7 @@
 
 include("testdefs.jl")
 addprocs(4; topology="master_slave")
-@test_throws RemoteException remotecall_fetch(2, ()->remotecall_fetch(3,myid))
+@test_throws RemoteException remotecall_fetch(()->remotecall_fetch(myid, 3), 2)
 
 function test_worker_counts()
     # check if the nprocs/nworkers/workers are the same on the remaining workers
@@ -11,7 +11,9 @@ function test_worker_counts()
     ws=sort(workers())
 
     for p in workers()
-        @test (true, true, true) == remotecall_fetch(p, (x,y,z)->(x==nprocs(), y==nworkers(), z==sort(workers())), np, nw, ws)
+        @test (true, true, true) == remotecall_fetch(p, np, nw, ws) do x,y,z
+            (x==nprocs(), y==nworkers(), z==sort(workers()))
+        end
     end
 end
 
@@ -38,8 +40,8 @@ function Base.launch(manager::TopoTestManager, params::Dict, launched::Array, c:
     exeflags = params[:exeflags]
 
     for i in 1:manager.np
-        io, pobj = open(detach(
-            setenv(`$(Base.julia_cmd(exename)) $exeflags --bind-to $(Base.LPROC.bind_addr) --worker`, dir=dir)), "r")
+        io, pobj = open(pipeline(detach(
+            setenv(`$(Base.julia_cmd(exename)) $exeflags --bind-to $(Base.LPROC.bind_addr) --worker`, dir=dir)); stderr=STDERR), "r")
         wconfig = WorkerConfig()
         wconfig.process = pobj
         wconfig.io = io
@@ -75,9 +77,9 @@ for p1 in workers()
         i1 = map_pid_ident[p1]
         i2 = map_pid_ident[p2]
         if (iseven(i1) && iseven(i2)) || (isodd(i1) && isodd(i2))
-            @test p2 == remotecall_fetch(p1, p->remotecall_fetch(p,myid), p2)
+            @test p2 == remotecall_fetch(p->remotecall_fetch(myid, p), p1, p2)
         else
-            @test_throws RemoteException remotecall_fetch(p1, p->remotecall_fetch(p,myid), p2)
+            @test_throws RemoteException remotecall_fetch(p->remotecall_fetch(myid, p), p1, p2)
         end
     end
 end
diff --git a/test/tuple.jl b/test/tuple.jl
index 7412850ba4abe..a704676a14b48 100644
--- a/test/tuple.jl
+++ b/test/tuple.jl
@@ -49,6 +49,8 @@
 @test_throws BoundsError next((5,6,7), 0)
 @test_throws BoundsError next((), 1)
 
+@test collect(eachindex((2,5,"foo"))) == collect(1:3)
+@test collect(eachindex((2,5,"foo"), (1,2,5,7))) == collect(1:4)
 
 
 ## eltype ##
diff --git a/test/unicode/UnicodeError.jl b/test/unicode/UnicodeError.jl
index 0f78ab85bb94d..6ec6d0a936ec6 100644
--- a/test/unicode/UnicodeError.jl
+++ b/test/unicode/UnicodeError.jl
@@ -2,6 +2,6 @@
 
 let io = IOBuffer()
     show(io, UnicodeError(Base.UTF_ERR_SHORT, 1, 10))
-    check = "UnicodeError: invalid UTF-8 sequence starting at index 1 (0xa) missing one or more continuation bytes)"
+    check = "UnicodeError: invalid UTF-8 sequence starting at index 1 (0xa missing one or more continuation bytes)"
     @test takebuf_string(io) == check
 end
diff --git a/test/unicode/utf32.jl b/test/unicode/utf32.jl
index 2b9488a024e07..53e7de500ed3e 100644
--- a/test/unicode/utf32.jl
+++ b/test/unicode/utf32.jl
@@ -163,7 +163,7 @@ for T in (UTF8String, UTF16String, UTF32String)
         # Lead followed by non-continuation character > 0xbf
         @test_throws UnicodeError convert(T, strval(T, UInt8[byt,0x80,0x80,0xc0]))
     end
-    catch exp ;
+    catch exp
         println("Error checking $T: $byt")
         throw(exp)
     end
diff --git a/test/unicode/utf8proc.jl b/test/unicode/utf8proc.jl
index 8f97a160b271a..4f979c347b721 100644
--- a/test/unicode/utf8proc.jl
+++ b/test/unicode/utf8proc.jl
@@ -239,7 +239,12 @@ let grphtest = (("b\u0300lahβlahb\u0302láh", ["b\u0300","l","a","h",
             for (s, g) in grphtest
                 s_ = T(normalize_string(s, nf))
                 g_ = map(s -> normalize_string(s, nf), g)
+                # #9261
+                if length(s_) > 0
+                    @test typeof(first(graphemes(s_))) == SubString{typeof(s_)}
+                end
                 grph = collect(graphemes(s_))
+                @test eltype(grph) == SubString{typeof(s_)}
                 @test grph == g_
                 @test length(graphemes(s_)) == length(grph)
             end
diff --git a/test/workspace.jl b/test/workspace.jl
index 5288c123236f5..3cf0ae60ff4e0 100644
--- a/test/workspace.jl
+++ b/test/workspace.jl
@@ -13,5 +13,5 @@ show(io, Pair)
 @assert takebuf_string(io) == "Pair{A,B}"
 @assert !Base.inbase(LastMain)
 """
-exename = joinpath(JULIA_HOME, Base.julia_exename())
+exename = Base.julia_cmd()
 run(`$exename -f -e $script`)
diff --git a/ui/Makefile b/ui/Makefile
index c9b5d0ea982f8..c4a12467c84e7 100644
--- a/ui/Makefile
+++ b/ui/Makefile
@@ -1,4 +1,6 @@
-JULIAHOME = $(abspath ..)
+SRCDIR := $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
+JULIAHOME := $(abspath $(SRCDIR)/..)
+BUILDDIR ?= .
 include $(JULIAHOME)/deps/Versions.make
 include $(JULIAHOME)/Make.inc
 
@@ -6,28 +8,28 @@ override CFLAGS += $(JCFLAGS)
 override CXXFLAGS += $(JCXXFLAGS)
 override CPPFLAGS += $(JCPPFLAGS)
 
-SRCS = repl
+SRCS := repl
 ifeq ($(USEMSVC), 1)
 SRCS += getopt
 endif
 
-FLAGS = -I$(JULIAHOME)/src -I$(JULIAHOME)/src/support -I$(build_includedir)
+FLAGS := -I$(BUILDROOT)/src -I$(JULIAHOME)/src -I$(JULIAHOME)/src/support -I$(build_includedir)
 ifneq ($(USEMSVC), 1)
-FLAGS += -Wall -Wno-strict-aliasing -fno-omit-frame-pointer
+FLAGS += -Wall -Wno-strict-aliasing -fno-omit-frame-pointer -Wc++-compat
 endif
 
-OBJS = $(SRCS:%=%.o)
-DOBJS = $(SRCS:%=%.dbg.obj)
+OBJS := $(SRCS:%=$(BUILDDIR)/%.o)
+DOBJS := $(SRCS:%=$(BUILDDIR)/%.dbg.obj)
 DEBUGFLAGS += $(FLAGS)
 SHIPFLAGS += $(FLAGS)
 ifeq ($(USE_LLVM_SHLIB),1)
 ifeq ($(LLVM_USE_CMAKE),1)
-LLVMLINK = $(call exec,$(LLVM_CONFIG) --ldflags) -lLLVM
+LLVMLINK := $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM
 else
-LLVMLINK = $(call exec,$(LLVM_CONFIG) --ldflags) -lLLVM-$(call exec,$(LLVM_CONFIG) --version)
+LLVMLINK := $(shell $(LLVM_CONFIG_HOST) --ldflags) -lLLVM-$(shell $(LLVM_CONFIG_HOST) --version)
 endif
 else
-LLVMLINK =
+LLVMLINK :=
 endif
 JLDFLAGS += $(LDFLAGS) $(NO_WHOLE_ARCHIVE) $(OSLIBS) $(LLVMLINK) $(RPATH)
 
@@ -45,14 +47,14 @@ default: release
 all: release debug
 release debug :  % : julia-%
 
-%.o: %.c
+$(BUILDDIR)/%.o: $(SRCDIR)/%.c
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(SHIPFLAGS) -c $< -o $@)
-%.dbg.obj: %.c
+$(BUILDDIR)/%.dbg.obj: $(SRCDIR)/%.c
 	@$(call PRINT_CC, $(CC) $(CPPFLAGS) $(CFLAGS) $(DEBUGFLAGS) -c $< -o $@)
 
 ifeq ($(OS),WINNT)
 ifneq ($(USEMSVC), 1)
-julia_res.o: $(JULIAHOME)/contrib/windows/julia.rc
+$(BUILDDIR)/julia_res.o: $(JULIAHOME)/contrib/windows/julia.rc
 	JLVER=`cat $(JULIAHOME)/VERSION` && \
 	JLVERi=`echo $$JLVER | perl -nle \
 		'/^(\d+)\.?(\d*)\.?(\d*)/ && \
@@ -67,9 +69,9 @@ julia-release: $(build_bindir)/julia$(EXE)
 julia-debug: $(build_bindir)/julia-debug$(EXE)
 
 ifneq ($(USEMSVC), 1)
-CXXLD = $(CXX)
+CXXLD := $(CXX)
 else
-CXXLD = $(LD)
+CXXLD := $(LD)
 endif
 
 $(build_bindir)/julia$(EXE): $(OBJS)
diff --git a/ui/repl.c b/ui/repl.c
index a4c11ea2dc41b..179bb609b106f 100644
--- a/ui/repl.c
+++ b/ui/repl.c
@@ -34,6 +34,18 @@
 extern "C" {
 #endif
 
+#ifdef JULIA_ENABLE_THREADING
+static JL_CONST_FUNC jl_tls_states_t *jl_get_ptls_states_static(void)
+{
+#  if !defined(_COMPILER_MICROSOFT_)
+    static __thread jl_tls_states_t tls_states;
+#  else
+    static __declspec(thread) jl_tls_states_t tls_states;
+#  endif
+    return &tls_states;
+}
+#endif
+
 static int lisp_prompt = 0;
 static int codecov  = JL_LOG_NONE;
 static int malloclog= JL_LOG_NONE;
@@ -47,6 +59,7 @@ static const char opts[]  =
     // startup options
     " -J, --sysimage <file>     Start up with the given system image file\n"
     " --precompiled={yes|no}    Use precompiled code from system image if available\n"
+    " --compilecache={yes|no}   Enable/disable incremental precompilation of modules\n"
     " -H, --home <dir>          Set location of julia executable\n"
     " --startup-file={yes|no}   Load ~/.juliarc.jl\n"
     " -f, --no-startup          Don't load ~/.juliarc (deprecated, use --startup-file=no)\n"
@@ -72,9 +85,9 @@ static const char opts[]  =
     " --no-history-file         Don't load history file (deprecated, use --history-file=no)\n\n"
 
     // code generation options
-    " --compile={yes|no|all}    Enable or disable compiler, or request exhaustive compilation\n"
+    " --compile={yes|no|all|min}Enable or disable JIT compiler, or request exhaustive compilation\n"
     " -C, --cpu-target <target> Limit usage of cpu features up to <target>\n"
-    " -O, --optimize            Run time-intensive code optimizations\n"
+    " -O, --optimize={0,1,2,3}  Set the optimization level (default 2 if unspecified or 3 if specified as -O)\n"
     " --inline={yes|no}         Control whether inlining is permitted (overrides functions declared as @inline)\n"
     " --check-bounds={yes|no}   Emit bounds checks always or never (ignoring declarations)\n"
     " --math-mode={ieee,fast}   Disallow or enable unsafe floating point optimizations (overrides @fastmath declaration)\n\n"
@@ -115,9 +128,10 @@ void parse_opts(int *argcp, char ***argvp)
            opt_output_o,
            opt_output_ji,
            opt_use_precompiled,
+           opt_use_compilecache,
            opt_incremental
     };
-    static char* shortopts = "+vhqFfH:e:E:P:L:J:C:ip:Ob:";
+    static char* shortopts = "+vhqFfH:e:E:P:L:J:C:ip:O:";
     static struct option longopts[] = {
         // exposed command line options
         // NOTE: This set of required arguments need to be kept in sync
@@ -132,6 +146,7 @@ void parse_opts(int *argcp, char ***argvp)
         { "load",            required_argument, 0, 'L' },
         { "sysimage",        required_argument, 0, 'J' },
         { "precompiled",     required_argument, 0, opt_use_precompiled },
+        { "compilecache",    required_argument, 0, opt_use_compilecache },
         { "cpu-target",      required_argument, 0, 'C' },
         { "procs",           required_argument, 0, 'p' },
         { "machinefile",     required_argument, 0, opt_machinefile },
@@ -143,7 +158,7 @@ void parse_opts(int *argcp, char ***argvp)
         { "compile",         required_argument, 0, opt_compile },
         { "code-coverage",   optional_argument, 0, opt_code_coverage },
         { "track-allocation",optional_argument, 0, opt_track_allocation },
-        { "optimize",        no_argument,       0, 'O' },
+        { "optimize",        optional_argument, 0, 'O' },
         { "check-bounds",    required_argument, 0, opt_check_bounds },
         { "output-bc",       required_argument, 0, opt_output_bc },
         { "output-o",        required_argument, 0, opt_output_o },
@@ -160,27 +175,47 @@ void parse_opts(int *argcp, char ***argvp)
         { 0, 0, 0, 0 }
     };
     // getopt handles argument parsing up to -- delineator
-    int lastind = optind;
     int argc = *argcp;
+    char **argv = *argvp;
     if (argc > 0) {
         for (int i=0; i < argc; i++) {
-            if (!strcmp((*argvp)[i], "--")) {
+            if (!strcmp(argv[i], "--")) {
                 argc = i;
                 break;
             }
         }
     }
-    int c;
     char *endptr;
-    opterr = 0;
-    int skip = 0;
-    while ((c = getopt_long(argc,*argvp,shortopts,longopts,0)) != -1) {
+    opterr = 0; // suppress getopt warning messages
+    while (1) {
+        int lastind = optind;
+        int c = getopt_long(argc, argv, shortopts, longopts, 0);
+        if (c == -1) break;
+restart_switch:
         switch (c) {
         case 0:
             break;
         case '?':
-        if (optind != lastind) skip++;
-            lastind = optind;
+        case ':':
+            if (optopt) {
+                for (struct option *o = longopts; o->val; o++) {
+                    if (optopt == o->val) {
+                        if (o->has_arg == optional_argument) {
+                            c = o->val;
+                            goto restart_switch;
+                        }
+                        else if (strchr(shortopts, o->val)) {
+                            jl_errorf("option `-%c/--%s` is missing an argument", o->val, o->name);
+                        }
+                        else {
+                            jl_errorf("option `--%s` is missing an argument", o->name);
+                        }
+                    }
+                }
+                jl_errorf("unknown option `-%c`", optopt);
+            } else {
+                jl_errorf("unknown option `%s`", argv[lastind]);
+            }
             break;
         case 'v': // version
             jl_printf(JL_STDOUT, "julia version %s\n", JULIA_VERSION_STRING);
@@ -218,6 +253,14 @@ void parse_opts(int *argcp, char ***argvp)
             else
                 jl_errorf("julia: invalid argument to --precompiled={yes|no} (%s)", optarg);
             break;
+        case opt_use_compilecache:
+            if (!strcmp(optarg,"yes"))
+                jl_options.use_compilecache = JL_OPTIONS_USE_COMPILECACHE_YES;
+            else if (!strcmp(optarg,"no"))
+                jl_options.use_compilecache = JL_OPTIONS_USE_COMPILECACHE_NO;
+            else
+                jl_errorf("julia: invalid argument to --compilecache={yes|no} (%s)", optarg);
+            break;
         case 'C': // cpu-target
             jl_options.cpu_target = strdup(optarg);
             break;
@@ -276,6 +319,8 @@ void parse_opts(int *argcp, char ***argvp)
                 jl_options.compile_enabled = JL_OPTIONS_COMPILE_OFF;
             else if (!strcmp(optarg,"all"))
                 jl_options.compile_enabled = JL_OPTIONS_COMPILE_ALL;
+            else if (!strcmp(optarg,"min"))
+                jl_options.compile_enabled = JL_OPTIONS_COMPILE_MIN;
             else
                 jl_errorf("julia: invalid argument to --compile (%s)", optarg);
             break;
@@ -287,6 +332,8 @@ void parse_opts(int *argcp, char ***argvp)
                     codecov = JL_LOG_ALL;
                 else if (!strcmp(optarg,"none"))
                     codecov = JL_LOG_NONE;
+                else
+                    jl_errorf("julia: invalid argument to --code-coverage (%s)", optarg);
                 break;
             }
             else {
@@ -301,6 +348,8 @@ void parse_opts(int *argcp, char ***argvp)
                     malloclog = JL_LOG_ALL;
                 else if (!strcmp(optarg,"none"))
                     malloclog = JL_LOG_NONE;
+                else
+                    jl_errorf("julia: invalid argument to --track-allocation (%s)", optarg);
                 break;
             }
             else {
@@ -308,7 +357,22 @@ void parse_opts(int *argcp, char ***argvp)
             }
             break;
         case 'O': // optimize
-            jl_options.opt_level = 1;
+            if (optarg != NULL) {
+                if (!strcmp(optarg,"0"))
+                    jl_options.opt_level = 0;
+                else if (!strcmp(optarg,"1"))
+                    jl_options.opt_level = 1;
+                else if (!strcmp(optarg,"2"))
+                    jl_options.opt_level = 2;
+                else if (!strcmp(optarg,"3"))
+                    jl_options.opt_level = 3;
+                else
+                    jl_errorf("julia: invalid argument to -O (%s)", optarg);
+                break;
+            }
+            else {
+                jl_options.opt_level = 3;
+            }
             break;
         case 'i': // isinteractive
             jl_options.isinteractive = 1;
@@ -391,7 +455,6 @@ void parse_opts(int *argcp, char ***argvp)
     }
     jl_options.code_coverage = codecov;
     jl_options.malloc_log = malloclog;
-    optind -= skip;
     *argvp += optind;
     *argcp -= optind;
 }
@@ -454,13 +517,15 @@ static void print_profile(void)
 }
 #endif
 
-static int true_main(int argc, char *argv[])
+static NOINLINE int true_main(int argc, char *argv[])
 {
-    if (jl_base_module != NULL) {
-        jl_array_t *args = (jl_array_t*)jl_get_global(jl_base_module, jl_symbol("ARGS"));
+    if (jl_core_module != NULL) {
+        jl_array_t *args = (jl_array_t*)jl_get_global(jl_core_module, jl_symbol("ARGS"));
         if (args == NULL) {
             args = jl_alloc_cell_1d(0);
-            jl_set_const(jl_base_module, jl_symbol("ARGS"), (jl_value_t*)args);
+            JL_GC_PUSH1(&args);
+            jl_set_const(jl_core_module, jl_symbol("ARGS"), (jl_value_t*)args);
+            JL_GC_POP();
         }
         assert(jl_array_len(args) == 0);
         jl_array_grow_end(args, argc);
@@ -476,7 +541,7 @@ static int true_main(int argc, char *argv[])
         (jl_function_t*)jl_get_global(jl_base_module, jl_symbol("_start")) : NULL;
 
     if (start_client) {
-        jl_apply(start_client, NULL, 0);
+        jl_apply(&start_client, 1);
         return 0;
     }
 
@@ -572,6 +637,14 @@ int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
         if (!WideCharToMultiByte(CP_UTF8, 0, warg, -1, arg, len, NULL, NULL)) return 1;
         argv[i] = (wchar_t*)arg;
     }
+#endif
+#ifdef JULIA_ENABLE_THREADING
+    // We need to make sure this function is called before any reference to
+    // TLS variables. Since the compiler is free to move calls to
+    // `jl_get_ptls_states()` around, we should avoid referencing TLS
+    // variables in this function. (Mark `true_main` as noinline for this
+    // reason).
+    jl_set_ptls_states_getter(jl_get_ptls_states_static);
 #endif
     libsupport_init();
     parse_opts(&argc, (char***)&argv);